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

Initial commit

parents

CMakeLists.txt

0 → 100644
+54 −0
Original line number Diff line number Diff line 
cmake_minimum_required(VERSION 2.8.6)

project(kinetic_cpp_client_examples CXX C)



set(CMAKE_CXX_FLAGS "-g --std=c++11 -Wall -Wextra -Werror -Wno-unused-parameter ${PTHREAD_FLAG} -DGTEST_USE_OWN_TR1_TUPLE=1")



set(GENERATED_SOURCES_PATH ${kinetic_cpp_client_SOURCE_DIR}/src/main/generated)



include(ExternalProject)

ExternalProject_add(

    kinetic_cpp_client

    PREFIX "vendor"

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

    GIT_TAG "origin/master"

    BUILD_IN_SOURCE 1

    INSTALL_COMMAND ""

)



include_directories(

    vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/include

    vendor/src/kinetic_cpp_client/vendor/src/protobufutil/include

    vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/src/gmock/fused-src

    vendor/src/kinetic_cpp_client/src/main

    vendor/src/kinetic_cpp_client/src/main/generated

    vendor/src/kinetic_cpp_client/src/public_include

)



set(LIBRARY_DEPENDENCIES

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/libkinetic_client_library.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/libprotobufutil.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/lib/libglog.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/lib/libgflags.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/lib/libssl.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/lib/libcrypto.a

    ${kinetic_cpp_client_examples_SOURCE_DIR}/vendor/src/kinetic_cpp_client/vendor/src/protobufutil/vendor/lib/libprotobuf.a

    dl

)



macro(add_example_target NAME)

    add_executable(${NAME} src/${NAME}.cc)

    target_link_libraries(${NAME} ${LIBRARY_DEPENDENCIES})

    add_dependencies(${NAME} kinetic_cpp_client)

endmacro(add_example_target)



add_example_target(hello_kinetic)

add_example_target(kineticstat)

add_example_target(async)

add_example_target(ise)

add_example_target(setclusterversion)

add_example_target(setpin)

add_example_target(set_acls)

add_example_target(write_file_blocking)

add_example_target(read_file_blocking)

add_example_target(read_file_nonblocking)

src/async.cc

0 → 100644
+63 −0
Original line number Diff line number Diff line 
#include <fcntl.h>

#include <sys/select.h>



#include "glog/logging.h"

#include "protobufutil/message_stream.h"



#include "hmac_provider.h"

#include "kinetic.pb.h"

#include "kinetic_connection_factory.h"

#include "nonblocking_kinetic_connection.h"

#include "nonblocking_message_service.h"

#include "socket_wrapper.h"

#include "value_factory.h"



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 palominolabs::protobufutil::MessageStreamFactory;



class TestCallback : public GetCallbackInterface {

    public:

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

        LOG(INFO) << "The callback got called!";

    }

};



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

    google::InitGoogleLogging(argv[0]);

    FLAGS_logtostderr = 1;



    ConnectionOptions options = {

        .host = "localhost",

        .port = 8123,

        .use_ssl = false,

        .user_id = 1,

        .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::NonblockingKineticConnection *connection;

    CHECK(kinetic_connection_factory.NewNonblockingConnection(options, &connection).ok());



    TestCallback *callback = new TestCallback;

    connection->Get("key", callback);



    fd_set read_fds, write_fds;

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

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



    delete callback;

    delete connection;

    return 0;

}

src/hello_kinetic.cc

0 → 100644
+57 −0
Original line number Diff line number Diff line 
#include <stdio.h>



#include "glog/logging.h"

#include "protobufutil/message_stream.h"



#include "connection_options.h"

#include "hmac_provider.h"

#include "kinetic_connection_factory.h"

#include "kinetic_connection.h"

#include "kinetic_record.h"

#include "value_factory.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 palominolabs::protobufutil::MessageStreamFactory;



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

    (void) argc;



    google::InitGoogleLogging(argv[0]);

    FLAGS_logtostderr = 1;



    LOG(INFO)<< "Hello Kinetic Client!";



    kinetic::ConnectionOptions options;

    options.host = std::string("localhost");

    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;

    CHECK(

            kinetic_connection_factory.NewConnection(options, &kinetic_connection).ok());



    std::string key = "key";

    std::string value, version, tag;

    CHECK(

            kinetic_connection->Put(key, "",

                    KineticRecord("the value", "", "", Message_Algorithm_SHA1)).ok());

    CHECK(kinetic_connection->Get(key, &value, &version, &tag).ok());

    LOG(INFO)<< "Value for " << key << " is <" << value << ">";



    return 0;

}

src/ise.cc

0 → 100644
+74 −0
Original line number Diff line number Diff line 
#include <stdio.h>



#include "protobufutil/message_stream.h"



#include "connection_options.h"

#include "hmac_provider.h"

#include "kinetic_connection_factory.h"

#include "kinetic_connection.h"

#include "kinetic_record.h"

#include "value_factory.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 palominolabs::protobufutil::MessageStreamFactory;



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

    if (argc != 3 && argc != 4) {

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

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

        return 1;

    }



    const char* host = argv[1];

    int port = atoi(argv[2]);



    kinetic::ConnectionOptions options;

    options.host = host;

    options.port = port;

    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* pin = NULL;



    if (argc == 3) {

        printf("Performing ISE on %s:%d\n", host, port);

    } else {

        pin = new std::string(argv[3]);

        printf("Performing ISE on %s:%d with pin %s\n", host, port, argv[3]);

    }



    bool success = kinetic_connection->InstantSecureErase(pin).ok();



    if (pin) {

        delete pin;

    }



    if (!success) {

        printf("Unable to execute ISE\n");

        return 1;

    }



    printf("Finished ISE\n");



    return 0;

}

src/kineticstat.cc

0 → 100644
+176 −0
Original line number Diff line number Diff line 
#define __STDC_FORMAT_MACROS

#include <inttypes.h>

#include <stdio.h>



#include "glog/logging.h"



#include "connection_options.h"

#include "hmac_provider.h"

#include "kinetic_connection_factory.h"

#include "kinetic_connection.h"

#include "kinetic_record.h"

#include "value_factory.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::DriveLog;

using kinetic::Capacity;

using kinetic::OperationStatistic;

using kinetic::Utilization;

using kinetic::Temperature;

using palominolabs::protobufutil::MessageStreamFactory;



void dump_all_information(const DriveLog& drive_log);

void print_temp_report(const DriveLog& drive_log, bool print_headers);

void print_utilization_report(const DriveLog& drive_log, bool print_headers);

void print_operation_stats_report(const DriveLog& drive_log, bool print_headers);



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

    (void) argc;



    if (argc != 2 && argc != 4) {

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

        printf("       %s <host> <temp|utilization|stat> <interval>\n", argv[0]);

        return 1;

    }



    kinetic::ConnectionOptions options;

    options.host = std::string(argv[1]);

    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;

    CHECK(

            kinetic_connection_factory.NewConnection(options, &kinetic_connection).ok());



    if (argc == 2) {

        // User just specified host so dump everything

        DriveLog drive_log;

        CHECK(kinetic_connection->GetLog(&drive_log).ok());



        dump_all_information(drive_log);

    } else {

        // User wants to poll host so figure out the information so start

        // the polling

        std::string report_type(argv[2]);

        int report_interval = atoi(argv[3]);

        int report_number = 0;

        while (true) {

            DriveLog drive_log;

            CHECK(kinetic_connection->GetLog(&drive_log).ok());



            bool print_headers = report_number % 5 == 0;



            if (report_type == "temp") {

                print_temp_report(drive_log, print_headers);

            } else if (report_type == "utilization") {

                print_utilization_report(drive_log, print_headers);

            } else if (report_type == "stat") {

                print_operation_stats_report(drive_log, print_headers);

            }



            printf("\n");



            sleep(report_interval);

            report_number++;

        }

    }



    return 0;

}



void dump_all_information(const DriveLog& drive_log) {

    printf("Configuration:\n");

    printf("  Vendor: %s\n", drive_log.configuration.vendor.c_str());

    printf("  Model: %s\n", drive_log.configuration.model.c_str());

    printf("  SN: %s\n", drive_log.configuration.serial_number.c_str());

    printf("  Version: %s\n", drive_log.configuration.version.c_str());

    printf("  Compilation Date: %s\n", drive_log.configuration.compilation_date.c_str());

    printf("  Source Hash: %s\n", drive_log.configuration.source_hash.c_str());

    printf("  Port: %d\n", drive_log.configuration.port);

    printf("  TLS Port: %d\n", drive_log.configuration.tls_port);





    printf("\n");



    printf("Capacity: %.0f bytes remaining / %.0f bytes\n\n",

        drive_log.capacity.remaining_bytes, drive_log.capacity.total_bytes);



    printf("Statistics:\n");

    for (auto it = drive_log.operation_statistics.begin();

        it != drive_log.operation_statistics.end();

        ++it) {

        printf("  %s: %" PRId64 " times %" PRId64 " bytes\n", it->name.c_str(), it->count,

            it->bytes);

    }



    printf("\n");



    printf("Utilizations:\n");

    for (auto it = drive_log.utilizations.begin();

        it != drive_log.utilizations.end();

        ++it) {

        printf("  %s: %.02f%%\n", it->name.c_str(), it->percent);

    }



    printf("\n");



    printf("Temperatures:\n");

    for (auto it = drive_log.temperatures.begin();

        it != drive_log.temperatures.end();

        ++it) {

        printf("  %s: %.0f\u00B0C\n", it->name.c_str(), it->current_degc);

    }

}



void print_temp_report(const DriveLog& drive_log, bool print_headers) {

    if (print_headers) {

        for (auto it = drive_log.temperatures.begin();

            it != drive_log.temperatures.end();

            ++it) {

            printf("%7s \u00B0C ", it->name.c_str());

        }

        printf("\n");

    }



    for (auto it = drive_log.temperatures.begin();

        it != drive_log.temperatures.end();

        ++it) {

        printf("%10.0f ", it->current_degc);

    }

}



void print_utilization_report(const DriveLog& drive_log, bool print_headers) {

    if (print_headers) {

        for (auto it = drive_log.utilizations.begin();

            it != drive_log.utilizations.end();

            ++it) {

            printf("%8s %% ", it->name.c_str());

        }

        printf("\n");

    }



    for (auto it = drive_log.utilizations.begin();

        it != drive_log.utilizations.end();

        ++it) {

        printf("%10.0f ", 100 * it->percent);

    }

}



void print_operation_stats_report(const DriveLog& drive_log, bool print_headers) {

    for (auto it = drive_log.operation_statistics.begin();

        it != drive_log.operation_statistics.end();

        ++it) {

        printf("%25s: %" PRId64 "\n", it->name.c_str(), it->count);

    }

}