Commit 9ffdd6f2 authored by Paul Lensing's avatar Paul Lensing
Browse files

Implemented nonblocking and blocking connections more cleanly. Both

threadsafe and non-threadsafe classes now inherit from an abstract
interface class. While threadsafe classes are still implemented on top
of non-threadsafe classes, relationship has been changed to 'has-a'
instead of 'is-a'. 
parent 0e551543
Loading
Loading
Loading
Loading
+38 −56
Original line number Diff line number Diff line
@@ -21,78 +21,60 @@
#ifndef KINETIC_CPP_CLIENT_BLOCKING_KINETIC_CONNECTION_H_
#define KINETIC_CPP_CLIENT_BLOCKING_KINETIC_CONNECTION_H_

#include <memory>

#include "kinetic/blocking_kinetic_connection_interface.h"
#include "kinetic/nonblocking_kinetic_connection.h"
#include "kinetic/status.h"
#include "kinetic/kinetic_connection.h"
#include "kinetic/key_range_iterator.h"
#include "kinetic/common.h"


namespace kinetic {

using std::shared_ptr;
using std::unique_ptr;
using std::string;
using std::vector;

class KeyRangeIterator;
class BlockingCallbackState;

class BlockingKineticConnection : public BlockingKineticConnectionInterface {

class BlockingKineticConnection {
    public:
    /// Takes ownership of the given NonblockingKineticConnection
    /// @param[in] nonblocking_connection   The underlying connection that will be used
    /// @param[in] network_timeout_seconds  If an operation goes more than network_timeout_seconds
    ///                                     seconds without receiving data the operation will fail
    explicit BlockingKineticConnection(
            shared_ptr<NonblockingKineticConnection> nonblocking_connection,
        unsigned int network_timeout_seconds);

     explicit BlockingKineticConnection(
            unique_ptr<NonblockingKineticConnection> nonblocking_connection,
            unsigned int network_timeout_seconds);

    virtual ~BlockingKineticConnection();
    ~BlockingKineticConnection();

    /// If the drive has a non-zero cluster version, requests will fail unless the developer
    /// tells the client the correct cluster version using this method.
    virtual void SetClientClusterVersion(int64_t cluster_version);
    void SetClientClusterVersion(int64_t cluster_version);

    virtual KineticStatus NoOp();
    KineticStatus NoOp();

    virtual KineticStatus Get(
    KineticStatus Get(
            const shared_ptr<const string> key,
            unique_ptr<KineticRecord>& record);

    virtual KineticStatus Get(const string& key, unique_ptr<KineticRecord>& record);
    KineticStatus Get(const string& key, unique_ptr<KineticRecord>& record);

    virtual KineticStatus GetNext(
    KineticStatus GetNext(
            const shared_ptr<const string> key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record);

    virtual KineticStatus GetNext(
    KineticStatus GetNext(
            const string& key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record);

    virtual KineticStatus GetPrevious(const shared_ptr<const string> key,
    KineticStatus GetPrevious(const shared_ptr<const string> key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record);

    virtual KineticStatus GetPrevious(const string& key,
    KineticStatus GetPrevious(const string& key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record);

    virtual KineticStatus GetVersion(const shared_ptr<const string> key,
    KineticStatus GetVersion(const shared_ptr<const string> key,
            unique_ptr<string>& version);

    virtual KineticStatus GetVersion(const string& key, unique_ptr<string>& version);
    KineticStatus GetVersion(const string& key, unique_ptr<string>& version);

    virtual KineticStatus GetKeyRange(const shared_ptr<const string> start_key,
    KineticStatus GetKeyRange(const shared_ptr<const string> start_key,
            bool start_key_inclusive,
            const shared_ptr<const string> end_key,
            bool end_key_inclusive,
@@ -100,7 +82,7 @@ class BlockingKineticConnection {
            int32_t max_results,
            unique_ptr<vector<string>>& keys);

    virtual KineticStatus GetKeyRange(const string& start_key,
    KineticStatus GetKeyRange(const string& start_key,
            bool start_key_inclusive,
            const string& end_key,
            bool end_key_inclusive,
@@ -109,70 +91,70 @@ class BlockingKineticConnection {
            unique_ptr<vector<string>>& keys);


    virtual KeyRangeIterator IterateKeyRange(const shared_ptr<const string> start_key,
    KeyRangeIterator IterateKeyRange(const shared_ptr<const string> start_key,
            bool start_key_inclusive,
            const shared_ptr<const string> end_key,
            bool end_key_inclusive,
            unsigned int frame_size);

    virtual KeyRangeIterator IterateKeyRange(const string& start_key,
    KeyRangeIterator IterateKeyRange(const string& start_key,
            bool start_key_inclusive,
            const string& end_key,
            bool end_key_inclusive,
            unsigned int frame_size);

    virtual KineticStatus Put(const shared_ptr<const string> key,
    KineticStatus Put(const shared_ptr<const string> key,
            const shared_ptr<const string> current_version, WriteMode mode,
            const shared_ptr<const KineticRecord> record,
            PersistMode persistMode);

    virtual KineticStatus Put(const string& key,
    KineticStatus Put(const string& key,
            const string& current_version, WriteMode mode,
            const KineticRecord& record,
            PersistMode persistMode);

    virtual KineticStatus Put(const shared_ptr<const string> key,
    KineticStatus Put(const shared_ptr<const string> key,
            const shared_ptr<const string> current_version, WriteMode mode,
            const shared_ptr<const KineticRecord> record);

    virtual KineticStatus Put(const string& key,
    KineticStatus Put(const string& key,
            const string& current_version, WriteMode mode,
            const KineticRecord& record);

    virtual KineticStatus Delete(const shared_ptr<const string> key,
    KineticStatus Delete(const shared_ptr<const string> key,
            const shared_ptr<const string> version, WriteMode mode, PersistMode persistMode);

    virtual KineticStatus Delete(const string& key, const string& version,
    KineticStatus Delete(const string& key, const string& version,
            WriteMode mode, PersistMode persistMode);

    virtual KineticStatus Delete(const shared_ptr<const string> key,
    KineticStatus Delete(const shared_ptr<const string> key,
            const shared_ptr<const string> version, WriteMode mode);

    virtual KineticStatus Delete(const string& key, const string& version, WriteMode mode);
    KineticStatus Delete(const string& key, const string& version, WriteMode mode);

    virtual KineticStatus InstantSecureErase(const shared_ptr<string> pin);
    KineticStatus InstantSecureErase(const shared_ptr<string> pin);

    virtual KineticStatus InstantSecureErase(const string& pin);
    KineticStatus InstantSecureErase(const string& pin);

    virtual KineticStatus SetClusterVersion(int64_t cluster_version);
    KineticStatus SetClusterVersion(int64_t cluster_version);

    virtual KineticStatus GetLog(unique_ptr<DriveLog>& drive_log);
    KineticStatus GetLog(unique_ptr<DriveLog>& drive_log);

    virtual KineticStatus GetLog(const vector<Command_GetLog_Type>& types, unique_ptr<DriveLog>& drive_log);
    KineticStatus GetLog(const vector<Command_GetLog_Type>& types, unique_ptr<DriveLog>& drive_log);

    virtual KineticStatus UpdateFirmware(const shared_ptr<const string> new_firmware);
    KineticStatus UpdateFirmware(const shared_ptr<const string> new_firmware);

    virtual KineticStatus SetACLs(const shared_ptr<const list<ACL>> acls);
    KineticStatus SetACLs(const shared_ptr<const list<ACL>> acls);

    virtual KineticStatus SetPin(const shared_ptr<const string> new_pin,
    KineticStatus SetPin(const shared_ptr<const string> new_pin,
            const shared_ptr<const string> current_pin = make_shared<string>());

    virtual KineticStatus SetPin(const string& new_pin, const string& current_pin);
    KineticStatus SetPin(const string& new_pin, const string& current_pin);

    virtual KineticStatus P2PPush(const P2PPushRequest& push_request,
    KineticStatus P2PPush(const P2PPushRequest& push_request,
            unique_ptr<vector<KineticStatus>>& operation_statuses);

    virtual KineticStatus P2PPush(const shared_ptr<const P2PPushRequest> push_request,
    KineticStatus P2PPush(const shared_ptr<const P2PPushRequest> push_request,
            unique_ptr<vector<KineticStatus>>& operation_statuses);

    private:
@@ -181,7 +163,7 @@ class BlockingKineticConnection {
    /// Helper method for translating a StatusCode from the drive into an API client KineticStatus
    /// object
    KineticStatus GetKineticStatus(StatusCode code);
    shared_ptr<NonblockingKineticConnection> nonblocking_connection_;
    unique_ptr<NonblockingKineticConnection> nonblocking_connection_;
    const unsigned int network_timeout_seconds_;
    DISALLOW_COPY_AND_ASSIGN(BlockingKineticConnection);
    };
+167 −0
Original line number Diff line number Diff line
/*
 * kinetic-cpp-client
 * Copyright (C) 2014 Seagate Technology.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */

#ifndef BLOCKING_KINETIC_CONNECTION_INTERFACE_H_
#define BLOCKING_KINETIC_CONNECTION_INTERFACE_H_

#include "kinetic/status.h"
#include "kinetic/kinetic_connection.h"
#include "kinetic/key_range_iterator.h"
#include "kinetic/common.h"
#include "kinetic/nonblocking_kinetic_connection.h"


namespace kinetic {

using std::shared_ptr;
using std::unique_ptr;
using std::string;
using std::vector;

class KeyRangeIterator;
class BlockingCallbackState;


class BlockingKineticConnectionInterface {
    public:
    virtual ~BlockingKineticConnectionInterface(){};

    virtual void SetClientClusterVersion(int64_t cluster_version) = 0;

    virtual KineticStatus NoOp() = 0;

    virtual KineticStatus Get(
            const shared_ptr<const string> key,
            unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus Get(const string& key, unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus GetNext(
            const shared_ptr<const string> key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus GetNext(
            const string& key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus GetPrevious(const shared_ptr<const string> key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus GetPrevious(const string& key,
            unique_ptr<string>& actual_key,
            unique_ptr<KineticRecord>& record) = 0;

    virtual KineticStatus GetVersion(const shared_ptr<const string> key,
            unique_ptr<string>& version) = 0;

    virtual KineticStatus GetVersion(const string& key, unique_ptr<string>& version) = 0;

    virtual KineticStatus GetKeyRange(const shared_ptr<const string> start_key,
            bool start_key_inclusive,
            const shared_ptr<const string> end_key,
            bool end_key_inclusive,
            bool reverse_results,
            int32_t max_results,
            unique_ptr<vector<string>>& keys) = 0;

    virtual KineticStatus GetKeyRange(const string& start_key,
            bool start_key_inclusive,
            const string& end_key,
            bool end_key_inclusive,
            bool reverse_results,
            int32_t max_results,
            unique_ptr<vector<string>>& keys) = 0;


    virtual KeyRangeIterator IterateKeyRange(const shared_ptr<const string> start_key,
            bool start_key_inclusive,
            const shared_ptr<const string> end_key,
            bool end_key_inclusive,
            unsigned int frame_size) = 0;

    virtual KeyRangeIterator IterateKeyRange(const string& start_key,
            bool start_key_inclusive,
            const string& end_key,
            bool end_key_inclusive,
            unsigned int frame_size) = 0;

    virtual KineticStatus Put(const shared_ptr<const string> key,
            const shared_ptr<const string> current_version, WriteMode mode,
            const shared_ptr<const KineticRecord> record,
            PersistMode persistMode) = 0;

    virtual KineticStatus Put(const string& key,
            const string& current_version, WriteMode mode,
            const KineticRecord& record,
            PersistMode persistMode) = 0;

    virtual KineticStatus Put(const shared_ptr<const string> key,
            const shared_ptr<const string> current_version, WriteMode mode,
            const shared_ptr<const KineticRecord> record) = 0;

    virtual KineticStatus Put(const string& key,
            const string& current_version, WriteMode mode,
            const KineticRecord& record) = 0;

    virtual KineticStatus Delete(const shared_ptr<const string> key,
            const shared_ptr<const string> version, WriteMode mode, PersistMode persistMode) = 0;

    virtual KineticStatus Delete(const string& key, const string& version,
            WriteMode mode, PersistMode persistMode) = 0;

    virtual KineticStatus Delete(const shared_ptr<const string> key,
            const shared_ptr<const string> version, WriteMode mode) = 0;

    virtual KineticStatus Delete(const string& key, const string& version, WriteMode mode) = 0;

    virtual KineticStatus InstantSecureErase(const shared_ptr<string> pin) = 0;

    virtual KineticStatus InstantSecureErase(const string& pin) = 0;

    virtual KineticStatus SetClusterVersion(int64_t cluster_version) = 0;

    virtual KineticStatus GetLog(unique_ptr<DriveLog>& drive_log) = 0;

    virtual KineticStatus GetLog(const vector<Command_GetLog_Type>& types, unique_ptr<DriveLog>& drive_log) = 0;

    virtual KineticStatus UpdateFirmware(const shared_ptr<const string> new_firmware) = 0;

    virtual KineticStatus SetACLs(const shared_ptr<const list<ACL>> acls) = 0;

    virtual KineticStatus SetPin(const shared_ptr<const string> new_pin,
            const shared_ptr<const string> current_pin = make_shared<string>()) = 0;

    virtual KineticStatus SetPin(const string& new_pin, const string& current_pin) = 0;

    virtual KineticStatus P2PPush(const P2PPushRequest& push_request,
            unique_ptr<vector<KineticStatus>>& operation_statuses) = 0;

    virtual KineticStatus P2PPush(const shared_ptr<const P2PPushRequest> push_request,
            unique_ptr<vector<KineticStatus>>& operation_statuses) = 0;
};

} // namespace kinetic



#endif /* BLOCKING_KINETIC_CONNECTION_INTERFACE_H_ */
+5 −6
Original line number Diff line number Diff line
@@ -62,11 +62,11 @@ class KineticConnectionFactory {
    /// Like NewNonblockingConnection, except the connection is safe for use by multiple threads.
    virtual Status NewThreadsafeNonblockingConnection(
            const ConnectionOptions& options,
            unique_ptr <NonblockingKineticConnection>& connection);
            unique_ptr <ThreadsafeNonblockingKineticConnection>& connection);

    virtual Status NewThreadsafeNonblockingConnection(
            const ConnectionOptions& options,
            shared_ptr <NonblockingKineticConnection>& connection);
            shared_ptr <ThreadsafeNonblockingKineticConnection>& connection);

    /// Creates and opens a new blocking connection using the given options. If the returned
    /// Status indicates success then the connection is ready to perform
@@ -92,20 +92,19 @@ class KineticConnectionFactory {
    /// Like NewBlockingConnection, except the connection is safe for use by multiple threads
    virtual Status NewThreadsafeBlockingConnection(
            const ConnectionOptions& options,
            unique_ptr <BlockingKineticConnection>& connection,
            unique_ptr <ThreadsafeBlockingKineticConnection>& connection,
            unsigned int network_timeout_seconds);

    virtual Status NewThreadsafeBlockingConnection(
            const ConnectionOptions& options,
            shared_ptr <BlockingKineticConnection>& connection,
            shared_ptr <ThreadsafeBlockingKineticConnection>& connection,
            unsigned int network_timeout_seconds);

    private:
    HmacProvider hmac_provider_;
    Status doNewConnection(
            ConnectionOptions const& options,
            unique_ptr <NonblockingKineticConnection>& connection,
            bool threadsafe);
            unique_ptr <NonblockingKineticConnection>& connection);
};

/// Helper method that creates a new KineticConnectionFactory with
+49 −275

File changed.

Preview size limit exceeded, changes collapsed.

+313 −0

File added.

Preview size limit exceeded, changes collapsed.

Loading