Merge pull request #19 from Seagate/features/set-client-cluster-version (ef23d0dd) · Commits · kinetic-archive / kinetic-cpp-examples

CMakeLists.txt

+26 −18

Original line number	Diff line number	Diff line
		@@ -18,7 +18,7 @@ else(USE_LOCAL_KINETIC_CLIENT)
		kinetic_cpp_client
		PREFIX "vendor"
		GIT_REPOSITORY "git@github.com:Seagate/Kinetic-C-Client.git"
		GIT_TAG "ff3a91392e387670675913780cabaa3435e7d597"
		GIT_TAG "896c99790ddd81ad9ca1dd73670818ccd575793e"
		BUILD_IN_SOURCE 1
		INSTALL_COMMAND ""
		)
		@@ -44,8 +44,16 @@ set(LIBRARY_DEPENDENCIES
		dl
		)

		macro(add_example_target NAME)
		add_executable(${NAME} src/${NAME}.cc)
		macro(add_example_target NAME USE_EXAMPLE_MAIN)
		if(${USE_EXAMPLE_MAIN})
		add_executable(${NAME}
		src/example_main.cc
		src/${NAME}.cc)
		else(${USE_EXAMPLE_MAIN})
		add_executable(${NAME}
		src/${NAME}.cc)
		endif()

		target_link_libraries(${NAME} ${LIBRARY_DEPENDENCIES})
		add_dependencies(${NAME} kinetic_cpp_client)

		@@ -57,18 +65,18 @@ macro(add_example_target NAME)
		)
		endmacro(add_example_target)

		add_example_target(kineticstat)
		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)
		add_example_target(delete_file_nonblocking)
		add_example_target(delete_file_blocking)
		add_example_target(write_file_nonblocking)
		add_example_target(firmware_update)
		add_example_target(write_file_blocking_threads)
		add_example_target(dump_keyspace)
		add_example_target(copydrive)
		add_example_target(kineticstat true)
		add_example_target(ise true)
		add_example_target(setclusterversion true)
		add_example_target(setpin true)
		add_example_target(set_acls true)
		add_example_target(write_file_blocking true)
		add_example_target(read_file_blocking false)
		add_example_target(read_file_nonblocking false)
		add_example_target(delete_file_nonblocking false)
		add_example_target(delete_file_blocking false)
		add_example_target(write_file_nonblocking true)
		add_example_target(firmware_update false)
		add_example_target(write_file_blocking_threads false)
		add_example_target(dump_keyspace false)
		add_example_target(copydrive false)

src/command_line_flags.h

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		#ifndef COMMAND_LINE_FLAGS_H_
		#define COMMAND_LINE_FLAGS_H_

		#include "kinetic/kinetic.h"

		#include "gflags/gflags.h"

		DEFINE_string(host, "localhost", "Kinetic Host");
		DEFINE_uint64(port, 8123, "Kinetic Port");
		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) {
		google::ParseCommandLineFlags(argc, argv, true);

		kinetic::ConnectionOptions options;
		options.host = FLAGS_host;
		options.port = FLAGS_port;
		options.user_id = FLAGS_user_id;
		options.hmac_key = FLAGS_hmac_key;

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

		if (!kinetic_connection_factory.NewConnection(options, FLAGS_timeout, connection).ok()) {
		printf("Unable to connect\n");
		return false;
		}

		return true;
		}

		#endif // COMMAND_LINE_FLAGS_H_

src/example_main.cc

0 → 100644

+23 −0

Original line number	Diff line number	Diff line
		#include "kinetic/kinetic.h"
		#include "glog/logging.h"

		#include "command_line_flags.h"

		int example_main(std::unique_ptr<kinetic::ConnectionHandle> connection, int argc, char** argv);

		int main(int argc, char** argv) {
		google::InitGoogleLogging(argv[0]);

		std::unique_ptr<kinetic::ConnectionHandle> connection;
		if (!parse_flags(&argc, &argv, connection)) {
		return 1;
		}

		int ret = example_main(move(connection), argc, argv);

		google::protobuf::ShutdownProtobufLibrary();
		google::ShutdownGoogleLogging();
		google::ShutDownCommandLineFlags();

		return ret;
		}

src/ise.cc

+4 −31

Original line number	Diff line number	Diff line
		@@ -3,6 +3,7 @@
		#include <stdio.h>

		#include "kinetic/kinetic.h"
		#include "gflags/gflags.h"

		using kinetic::KineticConnectionFactory;
		using kinetic::Status;
		@@ -13,38 +14,10 @@ using std::shared_ptr;
		using std::string;
		using std::unique_ptr;

		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";

		kinetic::KineticConnectionFactory kinetic_connection_factory = kinetic::NewKineticConnectionFactory();
		DEFINE_string(pin, "", "PIN");

		unique_ptr<kinetic::ConnectionHandle> connection;
		if (!kinetic_connection_factory.NewConnection(options, 60, connection).ok()) {
		printf("Unable to connect\n");
		return 1;
		}

		shared_ptr<string> pin;

		if (argc == 3) {
		printf("Performing ISE on %s:%d\n", host, port);
		} else {
		pin.reset(new std::string(argv[3]));
		printf("Performing ISE on %s:%d with pin %s\n", host, port, argv[3]);
		}
		int example_main(unique_ptr<kinetic::ConnectionHandle> connection, int argc, char* argv[]) {
		shared_ptr<string> pin(new string(FLAGS_pin));

		KineticStatus status = connection->blocking().InstantSecureErase(pin);
		bool success = status.ok();

src/kineticstat.cc

+10 −35

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@
		#include <stdio.h>

		#include "kinetic/kinetic.h"
		#include "gflags/gflags.h"

		using kinetic::DriveLog;
		using kinetic::Capacity;
		@@ -18,32 +19,11 @@ 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;
		DEFINE_string(type, "all", "Stat type (all\|log\|temp\|utilization\|stat)");
		DEFINE_uint64(interval, 5, "Refresh interval");

		if (argc < 2 \|\| argc > 4) {
		printf("Usage: %s <host>\n", argv[0]);
		printf(" %s <host> log", 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";

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

		unique_ptr<kinetic::ConnectionHandle> connection;
		if(!kinetic_connection_factory.NewConnection(options, 5, connection).ok()) {
		printf("Unable to connect\n");
		return 1;
		}

		if (argc == 2) {
		// User just specified host so dump everything
		int example_main(std::unique_ptr<kinetic::ConnectionHandle> connection, int argc, char** argv) {
		if (FLAGS_type == "all") {
		unique_ptr<DriveLog> drive_log;
		if(!connection->blocking().GetLog(drive_log).ok()) {
		printf("Unable to get log\n");
		@@ -51,8 +31,7 @@ int main(int argc, char* argv[]) {
		}

		dump_all_information(*drive_log);
		} else if(argc == 3) {
		// User wants the logs
		} else if (FLAGS_type == "log") {
		unique_ptr<DriveLog> drive_log;
		if(!connection->blocking().GetLog(drive_log).ok()) {
		printf("Unable to get log\n");
		@@ -61,10 +40,6 @@ int main(int argc, char* argv[]) {

		printf("%s\n", drive_log->messages.c_str());
		} 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) {
		unique_ptr<DriveLog> drive_log;
		@@ -75,17 +50,17 @@ int main(int argc, char* argv[]) {

		bool print_headers = report_number % 5 == 0;

		if (report_type == "temp") {
		if (FLAGS_type == "temp") {
		print_temp_report(*drive_log, print_headers);
		} else if (report_type == "utilization") {
		} else if (FLAGS_type == "utilization") {
		print_utilization_report(*drive_log, print_headers);
		} else if (report_type == "stat") {
		} else if (FLAGS_type == "stat") {
		print_operation_stats_report(*drive_log, print_headers);
		}

		printf("\n");

		sleep(report_interval);
		sleep(FLAGS_interval);
		report_number++;
		}
		}