named_cache.h

/*
 Copyright (c) 2013 by ScaleOut Software, Inc.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
*/ 

#pragma once

#include <string>
#include <stdint.h>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <boost/shared_ptr.hpp>

#include "soss_client/exceptions.h"
#include "soss_client/internal/soss_handle.h"
#include "soss_client/internal/client_cache.h"
#include "soss_client/soss_key.h"
#include "soss_client/remove_result.h"
#include "soss_client/object_policy.h"
#include "soss_client/get_options.h"
#include "soss_client/get_result.h"
#include "soss_client/put_result.h"
#include "soss_client/object_policy.h"
#include "soss_client/object_metadata.h"
#include "soss_client/lock_ticket.h"
#include "soss_client/lock_options.h"
#include "soss_client/lock_result.h"
#include "soss_client/query_result.h"
#include "soss_client/pmicli_invoke_options.h"
#include "soss_client/pmicli_invoke_result.h"
#include "soss_client/filter.h"

#include "soss_svccli.h"

namespace sosscli {

class NamedCache
{
public:

 /* Constants */

 static const size_t MAX_CACHE_NAME_LENGTH = SOSSLIB_DEF_MAX_APPNM_LEN;

 virtual ~NamedCache() {}

 /* Cache Operations */

 RemoveResult remove(SossKey key, bool object_may_not_exist = true, bool throw_on_error = true);
 
 RemoveResult remove_locked(SossKey key, LockTicket lock_ticket, bool object_may_not_exist = true, bool throw_on_error = true);
 
 LockResult lock(SossKey key, const LockOptions & options = LockOptions::CACHE_DEFAULTS);
 
 LockResult lock_refresh(SossKey key, LockTicket lock_ticket, bool throw_on_error = true);
 
 LockResult unlock(SossKey key, LockTicket lock_ticket, bool throw_on_error = true);
 
 int32_t clear(bool throw_on_error = true);
 
 GetMetadataResult get_metadata(SossKey key, const GetMetadataOptions &options = GetMetadataOptions::CACHE_DEFAULTS);

 const std::wstring& get_key_string(SossKey &key, bool force_refresh=false) const;
 
 int64_t query_obj_count(bool throw_on_error = true);

 boost::shared_ptr<QueryResult> query(const Filter &filter, bool throw_on_error = true);

 boost::shared_ptr<PmicliInvokeResult> pmicli_invoke(const Filter &filter, int eval_id, int merge_id, const std::vector<uint8_t> &param, const PmicliInvokeOptions &options = PmicliInvokeOptions::CACHE_DEFAULTS);
 
 /* Accessors */

 uint32_t app_id() const {return app_id_;}

 std::string name() const {return name_;}

 /* Nested Classes */

 class DefaultCachePolicy
 {
 public:
 template<typename T> friend class TypedNamedCache;

 DefaultCachePolicy();

 virtual ~DefaultCachePolicy() {}

 /* Accessors */

 boost::posix_time::time_duration timeout() const { return timeout_; }
 void set_timeout(boost::posix_time::time_duration timeout) { timeout_ = timeout; }

 ObjectPolicy::TimeoutType timeout_type() const { return timeout_type_; }
 void set_timeout_type(ObjectPolicy::TimeoutType timeout_type) { timeout_type_ = timeout_type; }

 ObjectPolicy::PreemptionPriority preemption_priority() const { return preemption_priority_; }
 void set_preemption_priority(ObjectPolicy::PreemptionPriority preemption_priority) { preemption_priority_ = preemption_priority; }

 bool allow_push_repl() const { return allow_push_repl_; }
 void set_allow_push_repl(bool allow_push_repl) { allow_push_repl_ = allow_push_repl; }

 bool use_client_cache() { return use_client_cache_; }
 void set_use_client_cache(bool use_client_cache) { use_client_cache_ = use_client_cache; }

 bool throw_on_error() const { return throw_on_error_; }
 void set_throw_on_error(bool throw_on_error) { throw_on_error_ = throw_on_error; }
 
 int32_t max_lock_retry_count() const { return max_lock_retry_count_; }
 void set_max_lock_retry_count(int32_t max_lock_retry_count) { max_lock_retry_count_ = max_lock_retry_count; }

 int32_t lock_retry_interval_ms() const { return lock_retry_interval_ms_; }
 void set_lock_retry_interval_ms(int32_t lock_retry_interval_ms) { lock_retry_interval_ms_ = lock_retry_interval_ms; }

 int32_t max_read_pending_attempts() const { return max_read_pending_attempts_; }
 void set_max_read_pending_attempts(int32_t max_read_pending_attempts) { max_read_pending_attempts_ = max_read_pending_attempts; }

 int32_t read_pending_retry_interval_ms() const { return read_pending_retry_interval_ms_; }
 void set_read_pending_retry_interval_ms(int32_t read_pending_retry_interval_ms) { read_pending_retry_interval_ms_ = read_pending_retry_interval_ms; }

 private:

 SOSSLIB_OBJ_PARAMS_EXT &copy_to(SOSSLIB_OBJ_PARAMS_EXT &params) const;

 boost::posix_time::time_duration timeout_;
 ObjectPolicy::TimeoutType timeout_type_;
 ObjectPolicy::PreemptionPriority preemption_priority_;
 bool allow_push_repl_;
 bool use_client_cache_;
 bool throw_on_error_;
 int32_t max_lock_retry_count_;
 int32_t lock_retry_interval_ms_;
 int32_t max_read_pending_attempts_;
 int32_t read_pending_retry_interval_ms_;
 };

 DefaultCachePolicy& default_cache_policy() { return default_cache_policy_; }

 void set_default_cache_policy(DefaultCachePolicy default_cache_policy) { default_cache_policy_ = default_cache_policy; }

 static internal::ClientCache& client_cache();

protected:

 NamedCache() { }

 /* Initialization routines, intended to be called by constructors in subclasses */

 void init(const uint32_t app_id);

 void init(const std::string &name);

 virtual void serialize_filter(const Filter &filter, std::vector<uint8_t> &bytes_out, size_t bytes_to_reserve_for_header) {}

 static internal::ClientCache client_cache_;

 static boost::mutex init_mutex_;
 
 static bool is_init_;
 
private:
 
 uint32_t app_id_;
 std::string name_;
 DefaultCachePolicy default_cache_policy_;
};

}