object_metadata.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 <vector>
#include <stdint.h>
#include "boost/date_time/posix_time/posix_time_duration.hpp"
#include "soss_client/object_policy.h"

namespace sosscli {

class ObjectMetadata;

class GetMetadataOptions
{
public:

 /* Constants */

 const static GetMetadataOptions CACHE_DEFAULTS;

 /* Constructors */

 GetMetadataOptions()
 : throw_on_error_(true) {}

 GetMetadataOptions(bool throw_on_error)
 : throw_on_error_(throw_on_error) {}

 virtual ~GetMetadataOptions() {};

 /* Accessors */

 bool throw_on_error() const { return throw_on_error_; }
 GetMetadataOptions& set_throw_on_error(bool throw_on_error) { throw_on_error_ = throw_on_error; return *this; }

protected:

private:

 bool throw_on_error_;
};


class GetMetadataResult
{
public:

 /* Constructors */

 GetMetadataResult(int32_t return_code, boost::shared_ptr<ObjectMetadata> object_ptr)
 : return_code_(return_code), object_ptr_(object_ptr) {}

 virtual ~GetMetadataResult() {};

 /* Accessors */

 boost::shared_ptr<ObjectMetadata> object_ptr()
 {
 if (return_code_ < 1)
 throw std::runtime_error("The object was not retrieved successfully. Check GetMetadataResult.return_code() for error info.");
 return object_ptr_;
 }

 int32_t return_code() { return return_code_; }

protected:

private:
 GetMetadataResult() {}

 int32_t return_code_;
 boost::shared_ptr<ObjectMetadata> object_ptr_;
};

class ObjectMetadata
{
public:
 ObjectMetadata(PSOSS_OBJ_METADATA pobj_metadata)
 {
 boost::posix_time::time_duration timeout;
 if(pobj_metadata->timeout_granularity == SOSSLIB_TIMEOUT_GRAN_SECONDS)
 timeout = boost::posix_time::seconds(pobj_metadata->timeout);
 else
 timeout = boost::posix_time::minutes(pobj_metadata->timeout);

 std::vector<SossKey> parents(pobj_metadata->parent_list, pobj_metadata->parent_list + SOSSLIB_MAX_PARENTS);

 // Construct the ObjectPolicy from various SOSS_OBJ_METADATA parameters
 object_policy_
 .set_timeout(timeout)
 .set_timeout_type(static_cast<ObjectPolicy::TimeoutType>(pobj_metadata->absolute_timeout))
 .set_preemption_priority(static_cast<ObjectPolicy::PreemptionPriority>(pobj_metadata->allow_lru))
 .set_allow_push_repl(pobj_metadata->allow_repl != 0)
 .set_parents(std::vector<SossKey>(pobj_metadata->parent_list, pobj_metadata->parent_list + SOSSLIB_MAX_PARENTS));

 // The remainder of the SOSS_OBJ_DATA parameters are not expressed in the ObjectPolicy, and are stored local to this class.
 size_ = pobj_metadata->size;
 backstore_mode_ = static_cast<BackingStoreMode>(pobj_metadata->backstore_mode);
 immutable_ = (pobj_metadata->immutable == TRUE);
 backstore_timeout_ = boost::posix_time::seconds(pobj_metadata->backstore_timeout);
 coherency_timeout_ = boost::posix_time::seconds(pobj_metadata->coherency_timeout);
 coherency_policy_ = static_cast<CoherencyPolicy>(pobj_metadata->coherency_policy);
 last_replication_succeeded_ = static_cast<ReplicationStatus>(pobj_metadata->replication_status);
 is_proxy_ = (pobj_metadata->is_proxy == TRUE);
 allow_remote_ = (pobj_metadata->allow_remote == TRUE);
 }

 virtual ~ObjectMetadata(void) {}

 enum BackingStoreMode
 {
 ASYNC_WRITE_BEHIND,
 ASYNC_REFRESH_AHEAD,
 ASYNC_WRITE_AND_REFRESH
 };

 enum CoherencyPolicy
 {
 NONE,
 POLL,
 NOTIFY
 };

 enum ReplicationStatus
 {
 SUCCESS,
 UPDATE_FAILED,
 REFRESH_FAILED
 };

public:
 ObjectPolicy object_policy() const { return object_policy_; }

 unsigned long size() const { return size_; }

 BackingStoreMode backstore_mode() const { return backstore_mode_; }

 bool immutable() const { return immutable_; }

 boost::posix_time::time_duration backstore_timeout() const { return backstore_timeout_; }

 boost::posix_time::time_duration coherency_timeout() const { return coherency_timeout_; }

 CoherencyPolicy coherency_policy() const { return coherency_policy_; }

 ReplicationStatus last_replication_succeeded() const { return last_replication_succeeded_; }

 bool is_proxy() const { return is_proxy_; }

 bool allow_remote() const { return allow_remote_; }

private:
 ObjectPolicy object_policy_;

 unsigned long size_;

 BackingStoreMode backstore_mode_;

 bool immutable_;

 boost::posix_time::time_duration
 backstore_timeout_;

 boost::posix_time::time_duration
 coherency_timeout_;

 CoherencyPolicy coherency_policy_;

 ReplicationStatus last_replication_succeeded_;

 bool is_proxy_;

 bool allow_remote_;
};

}