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

include/kinetic/blocking_kinetic_connection.h

+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);

    };

include/kinetic/blocking_kinetic_connection_interface.h

0 → 100644
+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_ */

include/kinetic/kinetic_connection_factory.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

include/kinetic/nonblocking_kinetic_connection.h

+49 −275

File changed.

Preview size limit exceeded, changes collapsed.

include/kinetic/nonblocking_kinetic_connection_interface.h

0 → 100644
+313 −0

File added.

Preview size limit exceeded, changes collapsed.