Commit 1b6c0181 authored by Marshall Pierce's avatar Marshall Pierce
Browse files

Merge pull request #23 from Seagate/features/update-client-version 

Features/update client version
parents 170c8458 3c265944

CMakeLists.txt

+1 −1
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ else(USE_LOCAL_KINETIC_CLIENT) 
        kinetic_cpp_client

        PREFIX "vendor"

        GIT_REPOSITORY "https://github.com/Seagate/kinetic-cpp-client.git"

        GIT_TAG "0.0.1"

        GIT_TAG "0.0.2"

        BUILD_IN_SOURCE 1

        INSTALL_COMMAND ""

    )

src/command_line_flags.h

+6 −2
Original line number Diff line number Diff line
@@ -31,7 +31,10 @@ DEFINE_uint64(timeout, 30, "Timeout"); 
DEFINE_uint64(user_id, 1, "Kinetic User ID");

DEFINE_string(hmac_key, "asdfasdf", "Kinetic User HMAC key");



bool parse_flags(int *argc, char*** argv, std::unique_ptr<kinetic::ConnectionHandle>& connection) {

bool parse_flags(int *argc,

        char*** argv,

        std::shared_ptr<kinetic::NonblockingKineticConnection>& nonblocking_connection,

        std::shared_ptr<kinetic::BlockingKineticConnection>& blocking_connection) {

    google::ParseCommandLineFlags(argc, argv, true);



    kinetic::ConnectionOptions options;
@@ -42,10 +45,11 @@ bool parse_flags(int *argc, char*** argv, std::unique_ptr<kinetic::ConnectionHan 


    kinetic::KineticConnectionFactory kinetic_connection_factory = kinetic::NewKineticConnectionFactory();



    if (!kinetic_connection_factory.NewConnection(options, FLAGS_timeout, connection).ok()) {

    if (!kinetic_connection_factory.NewNonblockingConnection(options, nonblocking_connection).ok()) {

        printf("Unable to connect\n");

        return false;

    }

    blocking_connection = std::make_shared<kinetic::BlockingKineticConnection>(nonblocking_connection, FLAGS_timeout);



    return true;

}

src/copydrive.cc

+10 −7
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ using kinetic::Status; 
using kinetic::KineticRecord;



using std::shared_ptr;

using std::make_shared;

using std::string;

using std::unique_ptr;

using std::vector;
@@ -48,11 +49,13 @@ kinetic::P2PPushRequest prepare_request(const vector<kinetic::P2PPushOperation>& 
    return request;

}



void dispatch_request(kinetic::BlockingKineticConnection &connection, const vector<kinetic::P2PPushOperation>& operations, const vector<pair<string, int>>& destinations) {

void dispatch_request(shared_ptr<kinetic::BlockingKineticConnection> connection,

        const vector<kinetic::P2PPushOperation>& operations,

        const vector<pair<string, int>>& destinations) {

    kinetic::P2PPushRequest request = prepare_request(operations, destinations, 0);



    unique_ptr<vector<kinetic::KineticStatus>> statuses(new vector<kinetic::KineticStatus>());

    if (!connection.P2PPush(request, statuses).ok()) {

    if (!connection->P2PPush(request, statuses).ok()) {

        printf("Error pushing\n");

        exit(1);

    }
@@ -96,8 +99,8 @@ int main(int argc, char* argv[]) { 


    kinetic::KineticConnectionFactory kinetic_connection_factory = kinetic::NewKineticConnectionFactory();



    unique_ptr<kinetic::ConnectionHandle> connection;

    if (!kinetic_connection_factory.NewConnection(options, 5, connection).ok()) {

    shared_ptr<kinetic::BlockingKineticConnection> blocking_connection;

    if(!kinetic_connection_factory.NewBlockingConnection(options, blocking_connection, 5).ok()){

        printf("Unable to connect\n");

        return 1;

    }
@@ -112,7 +115,7 @@ int main(int argc, char* argv[]) { 
    }



    // Iterate over all the keys and print them out

    for (kinetic::KeyRangeIterator it = connection->blocking().IterateKeyRange("", true, last_key, true, 100); it != kinetic::KeyRangeEnd(); ++it) {

    for (kinetic::KeyRangeIterator it = blocking_connection->IterateKeyRange("", true, last_key, true, 100); it != kinetic::KeyRangeEnd(); ++it) {

        kinetic::P2PPushOperation op;

        op.key = *it;

        op.force = true;
@@ -120,12 +123,12 @@ int main(int argc, char* argv[]) { 
        operations.push_back(op);



        if (operations.size() > kP2PBatchSize) {

            dispatch_request(connection->blocking(), operations, destinations);

            dispatch_request(blocking_connection, operations, destinations);

            operations.clear();

        }

    }



    dispatch_request(connection->blocking(), operations, destinations);

    dispatch_request(blocking_connection, operations, destinations);



    printf("\n");

src/delete_file_blocking.cc

+5 −5
Original line number Diff line number Diff line
@@ -51,14 +51,14 @@ int main(int argc, char* argv[]) { 


    KineticConnectionFactory kinetic_connection_factory = kinetic::NewKineticConnectionFactory();



    unique_ptr<kinetic::ConnectionHandle> connection;

    if(!kinetic_connection_factory.NewConnection(options, 5, connection).ok()) {

    unique_ptr<kinetic::BlockingKineticConnection> blocking_connection;

    if (!kinetic_connection_factory.NewBlockingConnection(options, blocking_connection, 5).ok()) {

        printf("Unable to connect\n");

        return 1;

    }



    std::unique_ptr<KineticRecord> record;

    if(!connection->blocking().Get(kinetic_key, record).ok()) {

    if(!blocking_connection->Get(kinetic_key, record).ok()) {

        printf("Unable to get metadata\n");

        return 1;

    }
@@ -75,7 +75,7 @@ int main(int argc, char* argv[]) { 


        sprintf(key_buffer, "%s-%10" PRId64, kinetic_key, i);

        std::string key(key_buffer);

        if (connection->blocking().Delete(key, "", kinetic::IGNORE_VERSION).ok()) {

        if (blocking_connection->Delete(key, "", kinetic::IGNORE_VERSION).ok()) {

            printf(".");

        } else {

            printf("X");
@@ -83,7 +83,7 @@ int main(int argc, char* argv[]) { 
        fflush(stdout);

    }



    if (!connection->blocking().Delete(kinetic_key, "", kinetic::IGNORE_VERSION).ok()) {

    if (!blocking_connection->Delete(kinetic_key, "", kinetic::IGNORE_VERSION).ok()) {

        printf("Unable to delete metadata\n");

    }

src/delete_file_nonblocking.cc

+10 −7
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ using kinetic::Status; 
using std::make_shared;

using std::string;

using std::unique_ptr;

using std::shared_ptr;



class DeleteCallback : public SimpleCallbackInterface {

public:
@@ -73,14 +74,16 @@ int main(int argc, char* argv[]) { 


    KineticConnectionFactory kinetic_connection_factory = kinetic::NewKineticConnectionFactory();



    unique_ptr<kinetic::ConnectionHandle> connection;

    if(!kinetic_connection_factory.NewConnection(options, 5, connection).ok()) {

    shared_ptr<kinetic::NonblockingKineticConnection> nonblocking_connection;

    if (!kinetic_connection_factory.NewNonblockingConnection(options, nonblocking_connection).ok()) {

        printf("Unable to connect\n");

        return 1;

    }

    shared_ptr<kinetic::BlockingKineticConnection> blocking_connection =

            make_shared<kinetic::BlockingKineticConnection>(nonblocking_connection, 5);



    std::unique_ptr<KineticRecord> record;

    if(!connection->blocking().Get(string(kinetic_key), record).ok()) {

    if(!blocking_connection->Get(string(kinetic_key), record).ok()) {

        printf("Unable to get metadata\n");

        return 1;

    }
@@ -100,18 +103,18 @@ int main(int argc, char* argv[]) { 
        sprintf(key_buffer, "%s-%10" PRId64, kinetic_key, i);

        remaining++;

        std::string key(key_buffer);

        connection->nonblocking().Delete(key, "", kinetic::IGNORE_VERSION, callback);

        nonblocking_connection->Delete(key, "", kinetic::IGNORE_VERSION, callback);

    }



    remaining++;

    connection->nonblocking().Delete(kinetic_key, "", kinetic::IGNORE_VERSION, callback);

    nonblocking_connection->Delete(kinetic_key, "", kinetic::IGNORE_VERSION, callback);





    fd_set read_fds, write_fds;

    int num_fds = 0;

    connection->nonblocking().Run(&read_fds, &write_fds, &num_fds);

    nonblocking_connection->Run(&read_fds, &write_fds, &num_fds);

    while (remaining > 0) {

        connection->nonblocking().Run(&read_fds, &write_fds, &num_fds);

        nonblocking_connection->Run(&read_fds, &write_fds, &num_fds);

    }



    printf("\nDone!\n");