Commit bf438b4c authored by Manuel Wudka-Robles's avatar Manuel Wudka-Robles
Browse files

Created example program that deletes a file from a drive using the nonblocking API

parent d6b97a64

.gitignore

+1 −0
Original line number Diff line number Diff line
@@ -17,3 +17,4 @@ CMakeScripts/ 
kinetic_cpp_client_examples.build/

kinetic_cpp_client_examples.xcodeproj/

.idea

delete_file_nonblocking

CMakeLists.txt

+10 −2
Original line number Diff line number Diff line
@@ -11,8 +11,8 @@ include(ExternalProject) 
ExternalProject_add(

    kinetic_cpp_client

    PREFIX "vendor"

    GIT_REPOSITORY "git@github.com:Seagate/Kinetic-C-Client.git"

    GIT_TAG "origin/master"

    GIT_REPOSITORY "git@gitlab.pl-ops.net:seagate/kinetic_cpp_client.git"

    GIT_TAG "origin/features/asynchronous-get"

    BUILD_IN_SOURCE 1

    INSTALL_COMMAND ""

)
@@ -42,6 +42,13 @@ macro(add_example_target NAME) 
    add_executable(${NAME} src/${NAME}.cc)

    target_link_libraries(${NAME} ${LIBRARY_DEPENDENCIES})

    add_dependencies(${NAME} kinetic_cpp_client)



    set_target_properties( ${NAME} PROPERTIES

        RUNTIME_OUTPUT_DIRECTORY_DEBUG   ${CMAKE_SOURCE_DIR}

        RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_SOURCE_DIR}

        ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_SOURCE_DIR}

        ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_SOURCE_DIR}

    )

endmacro(add_example_target)



add_example_target(hello_kinetic)
@@ -54,4 +61,5 @@ add_example_target(set_acls) 
add_example_target(write_file_blocking)

add_example_target(read_file_blocking)

add_example_target(read_file_nonblocking)

add_example_target(delete_file_nonblocking)

src/async.cc

+11 −6
Original line number Diff line number Diff line
@@ -12,18 +12,22 @@ 


using com::seagate::kinetic::HmacProvider;

using com::seagate::kinetic::ValueFactory;

using kinetic::CallbackInterface;

using kinetic::ConnectionOptions;

using kinetic::GetCallbackInterface;

using kinetic::Message;

using kinetic::NonblockingKineticConnection;

using kinetic::NonblockingMessageService;

using kinetic::NonblockingError;

using palominolabs::protobufutil::MessageStreamFactory;



class TestCallback : public GetCallbackInterface {

    public:

    void Call(const std::string &value, const std::string &version, const std::string &tag) {

        printf("The callback got called!");

    void Success(const std::string &value, const std::string &version,

            const std::string &tag) {

        printf("The callback got called!\n");

    }

    virtual void Failure(NonblockingError error) {

        printf("Error!\n");

        exit(1);

    }

};
@@ -52,8 +56,9 @@ int main(int argc, char* argv[]) { 
    connection->Get("key", callback);



    fd_set read_fds, write_fds;

    connection->Run(&read_fds, &write_fds);

    connection->Run(&read_fds, &write_fds);

    int num_fds = 0;

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

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



    delete callback;

    delete connection;

src/delete_file_nonblocking.cc

0 → 100644
+122 −0
Original line number Diff line number Diff line 
// This deletes a file written using write_file_(non)blocking



#include <stdio.h>

#include <glog/logging.h>

#include <sys/fcntl.h>

#include <sys/mman.h>



#include "protobufutil/message_stream.h"



#include "connection_options.h"

#include "hmac_provider.h"

#include "kinetic_connection_factory.h"

#include "value_factory.h"

#include "socket_wrapper.h"



using com::seagate::kinetic::HmacProvider;

using com::seagate::kinetic::proto::Message;

using com::seagate::kinetic::proto::Message_MessageType_GET;

using com::seagate::kinetic::proto::Message_Algorithm_SHA1;

using com::seagate::kinetic::ValueFactory;

using kinetic::KineticConnection;

using kinetic::KineticConnectionFactory;

using kinetic::Status;

using kinetic::KineticRecord;

using kinetic::DeleteCallbackInterface;

using kinetic::NonblockingError;

using palominolabs::protobufutil::MessageStreamFactory;



class DeleteCallback : public DeleteCallbackInterface {

public:

    DeleteCallback(int* remaining) : remaining_(remaining) {};

    void Success() {

        printf(".");

        fflush(stdout);

        (*remaining_)--;

    }



    void Failure(NonblockingError error) {

        printf("Error!\n");

        exit(1);

    }

private:

    int* remaining_;



};



int main(int argc, char* argv[]) {



    if (argc != 3) {

        printf("%s: <host> <kinetic key>\n", argv[0]);

        return 1;

    }



    const char* host = argv[1];

    const char* kinetic_key = argv[2];



    kinetic::ConnectionOptions options;

    options.host = host;

    options.port = 8123;

    options.user_id = 1;

    options.hmac_key = "asdfasdf";



    HmacProvider hmac_provider;

    ValueFactory value_factory;

    MessageStreamFactory message_stream_factory(NULL, value_factory);

    kinetic::KineticConnectionFactory kinetic_connection_factory(hmac_provider,

            message_stream_factory);



    kinetic::KineticConnection* kinetic_connection;

    if(!kinetic_connection_factory.NewConnection(options, &kinetic_connection).ok()) {

        printf("Unable to connect\n");

        return 1;

    }





    std::string value;

    if(!kinetic_connection->Get(kinetic_key, &value, NULL, NULL).ok()) {

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

        return 1;

    }



    unsigned int file_size = std::stoi(value);

    printf("Deleting file of size %d\n", file_size);





    delete kinetic_connection;



    kinetic::NonblockingKineticConnection* connection;

    kinetic_connection_factory.NewNonblockingConnection(options, &connection);



    char key_buffer[100];

    int remaining = 0;

    for (unsigned int i = 0; i < file_size; i += 1024*1024) {

        unsigned int block_length = 1024*1024;

        if (i + block_length > file_size) {

            block_length = file_size - i + 1;

        }



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

        remaining++;

        DeleteCallback* callback = new DeleteCallback(&remaining);

        std::string key(key_buffer);

        connection->Delete(key, "", true, callback);

    }



    remaining++;

    connection->Delete(kinetic_key, "", true, new DeleteCallback(&remaining));





    fd_set read_fds, write_fds;

    int num_fds = 0;

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

    while (remaining > 0) {

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

    }



    printf("\nDone!\n");



    delete connection;



    return 0;

}

src/read_file_nonblocking.cc

+10 −5
Original line number Diff line number Diff line
@@ -24,18 +24,18 @@ using kinetic::Status; 
using kinetic::KineticRecord;

using palominolabs::protobufutil::MessageStreamFactory;

using com::seagate::kinetic::HmacProvider;

using kinetic::CallbackInterface;

using kinetic::NonblockingError ;

using kinetic::ConnectionOptions;

using kinetic::GetCallbackInterface;

using kinetic::Message;

using kinetic::NonblockingKineticConnection;

using kinetic::NonblockingMessageService;

using kinetic::SocketWrapper;



class TestCallback : public GetCallbackInterface {

public:

    TestCallback(char* buffer, unsigned int expected_length, int* remaining) : buffer_(buffer), expected_length_(expected_length), remaining_(remaining) {};

    void Call(const std::string &value, const std::string &version, const std::string &tag) {

    void Success(const std::string &value, const std::string &version,

            const std::string &tag) {

        if(expected_length_ != value.size()) {

            printf("Received value chunk of wrong size\n");

            exit(1);
@@ -45,6 +45,10 @@ public: 
        fflush(stdout);

        (*remaining_)--;

    }

    void Failure(NonblockingError error) {

        printf("Error!\n");

        exit(1);

    }

private:

    char* buffer_;

    unsigned int expected_length_;
@@ -127,9 +131,10 @@ int main(int argc, char* argv[]) { 




    fd_set read_fds, write_fds;

    connection->Run(&read_fds, &write_fds);

    int num_fds = 0;

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

    while (remaining > 0) {

        connection->Run(&read_fds, &write_fds);

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

    }



    CHECK(!close(file));