[corosync] [PATCH 08/14] Add cmapctl tool

Steven Dake sdake at redhat.com
Wed Dec 14 16:49:54 GMT 2011



Couldn't corosync-objctl just be changed to use the new APIs?  Not super
hot on a new bnary but if that is the only way...

Reviewed-by: Steven Dake <sdake at redhat.com>


On 12/14/2011 08:41 AM, Jan Friesse wrote:
> corosync-cmapctl is direct replacement for corosync-objctl
> 
> Signed-off-by: Jan Friesse <jfriesse at redhat.com>
> ---
>  tools/.gitignore         |    1 +
>  tools/Makefile.am        |    4 +-
>  tools/corosync-cmapctl.c |  636 ++++++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 640 insertions(+), 1 deletions(-)
>  create mode 100644 tools/corosync-cmapctl.c
> 
> diff --git a/tools/.gitignore b/tools/.gitignore
> index 0dc0f7e..9651044 100644
> --- a/tools/.gitignore
> +++ b/tools/.gitignore
> @@ -6,3 +6,4 @@ corosync-objctl
>  corosync-pload
>  corosync-quorumtool
>  corosync-notifyd
> +corosync-cmapctl
> diff --git a/tools/Makefile.am b/tools/Makefile.am
> index 2699519..4847f3a 100644
> --- a/tools/Makefile.am
> +++ b/tools/Makefile.am
> @@ -36,7 +36,7 @@ INCLUDES       		= -I$(top_builddir)/include  -I$(top_srcdir)/include \
>  sbin_PROGRAMS		= corosync-fplay corosync-cfgtool \
>  			  corosync-keygen corosync-objctl \
>  			  corosync-pload corosync-cpgtool corosync-quorumtool \
> -			  corosync-notifyd
> +			  corosync-notifyd corosync-cmapctl
>  
>  bin_SCRIPTS		= corosync-blackbox
>  
> @@ -47,6 +47,8 @@ corosync_pload_LDADD	= -lpload $(LIBQB_LIBS)
>  corosync_pload_LDFLAGS	= -L../lib
>  corosync_objctl_LDADD	= -lconfdb ../lcr/liblcr.a $(LIBQB_LIBS)
>  corosync_objctl_LDFLAGS	= -L../lib
> +corosync_cmapctl_LDADD = -lcmap $(LIBQB_LIBS)
> +corosync_cmapctl_LDFLAGS= -L../lib
>  corosync_cfgtool_LDADD	= -lcfg $(LIBQB_LIBS)
>  corosync_cfgtool_LDFLAGS= -L../lib
>  corosync_cpgtool_LDADD	= -lcfg -lcpg $(LIBQB_LIBS)
> diff --git a/tools/corosync-cmapctl.c b/tools/corosync-cmapctl.c
> new file mode 100644
> index 0000000..0c707a2
> --- /dev/null
> +++ b/tools/corosync-cmapctl.c
> @@ -0,0 +1,636 @@
> +/*
> + * Copyright (c) 2011 Red Hat, Inc.
> + *
> + * All rights reserved.
> + *
> + * Author: Jan Friesse (jfriesse at redhat.com)
> + *
> + * This software licensed under BSD license, the text of which follows:
> + *
> + * Redistribution and use in source and binary forms, with or without
> + * modification, are permitted provided that the following conditions are met:
> + *
> + * - Redistributions of source code must retain the above copyright notice,
> + *   this list of conditions and the following disclaimer.
> + * - Redistributions in binary form must reproduce the above copyright notice,
> + *   this list of conditions and the following disclaimer in the documentation
> + *   and/or other materials provided with the distribution.
> + * - Neither the name of the Red Hat, Inc. nor the names of its
> + *   contributors may be used to endorse or promote products derived from this
> + *   software without specific prior written permission.
> + *
> + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
> + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
> + * THE POSSIBILITY OF SUCH DAMAGE.
> + */
> +
> +#include <config.h>
> +
> +#include <stdio.h>
> +#include <poll.h>
> +
> +#include <corosync/corotypes.h>
> +#include <corosync/cmap.h>
> +#include "../lib/util.h"
> +
> +#ifndef INFTIM
> +#define INFTIM -1
> +#endif
> +
> +#define MAX_TRY_AGAIN 10
> +
> +enum user_action {
> +	ACTION_GET,
> +	ACTION_SET,
> +	ACTION_DELETE,
> +	ACTION_PRINT_ALL,
> +	ACTION_PRINT_DEFAULT,
> +	ACTION_PRINT_PREFIX,
> +	ACTION_TRACK
> +};
> +
> +struct name_to_type_item {
> +	const char *name;
> +	cmap_value_types_t type;
> +};
> +
> +struct name_to_type_item name_to_type[] = {
> +	{"i8", CMAP_VALUETYPE_INT8},
> +	{"u8", CMAP_VALUETYPE_UINT8},
> +	{"i16", CMAP_VALUETYPE_INT16},
> +	{"u16", CMAP_VALUETYPE_UINT16},
> +	{"i32", CMAP_VALUETYPE_INT32},
> +	{"u32", CMAP_VALUETYPE_UINT32},
> +	{"i64", CMAP_VALUETYPE_INT64},
> +	{"u64", CMAP_VALUETYPE_UINT64},
> +	{"flt", CMAP_VALUETYPE_FLOAT},
> +	{"dbl", CMAP_VALUETYPE_DOUBLE},
> +	{"str", CMAP_VALUETYPE_STRING},
> +	{"bin", CMAP_VALUETYPE_BINARY}};
> +
> +static int convert_name_to_type(const char *name)
> +{
> +	int i;
> +
> +	for (i = 0; i < sizeof(name_to_type) / sizeof(*name_to_type); i++) {
> +		if (strcmp(name, name_to_type[i].name) == 0) {
> +			return (name_to_type[i].type);
> +		}
> +	}
> +
> +	return (-1);
> +}
> +
> +static int print_help(void)
> +{
> +	printf("\n");
> +	printf("usage:  corosync-cmapctl ");
> +	printf("\n");
> +
> +	return (0);
> +}
> +
> +static void print_key(cmap_handle_t handle,
> +		const char *key_name,
> +		size_t value_len,
> +		const void *value,
> +		cmap_value_types_t type)
> +{
> +	char *str;
> +	cs_error_t err;
> +	int8_t i8;
> +	uint8_t u8;
> +	int16_t i16;
> +	uint16_t u16;
> +	int32_t i32;
> +	uint32_t u32;
> +	int64_t i64;
> +	uint64_t u64;
> +	float flt;
> +	double dbl;
> +	int end_loop;
> +	int no_retries;
> +
> +	end_loop = 0;
> +	no_retries = 0;
> +
> +	err = CS_OK;
> +
> +	while (!end_loop) {
> +		switch (type) {
> +		case CMAP_VALUETYPE_INT8:
> +			if (value == NULL) {
> +				err = cmap_get_int8(handle, key_name, &i8);
> +			} else {
> +				i8 = *((int8_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_INT16:
> +			if (value == NULL) {
> +				err = cmap_get_int16(handle, key_name, &i16);
> +			} else {
> +				i16 = *((int16_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_INT32:
> +			if (value == NULL) {
> +				err = cmap_get_int32(handle, key_name, &i32);
> +			} else {
> +				i32 = *((int32_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_INT64:
> +			if (value == NULL) {
> +				err = cmap_get_int64(handle, key_name, &i64);
> +			} else {
> +				i64 = *((int64_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_UINT8:
> +			if (value == NULL) {
> +				err = cmap_get_uint8(handle, key_name, &u8);
> +			} else {
> +				u8 = *((uint8_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_UINT16:
> +			if (value == NULL) {
> +				err = cmap_get_uint16(handle, key_name, &u16);
> +			} else {
> +				u16 = *((uint16_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_UINT32:
> +			if (value == NULL) {
> +				err = cmap_get_uint32(handle, key_name, &u32);
> +			} else {
> +				u32 = *((uint32_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_UINT64:
> +			if (value == NULL) {
> +				err = cmap_get_uint64(handle, key_name, &u64);
> +			} else {
> +				u64 = *((uint64_t *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_FLOAT:
> +			if (value == NULL) {
> +				err = cmap_get_float(handle, key_name, &flt);
> +			} else {
> +				flt = *((float *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_DOUBLE:
> +			if (value == NULL) {
> +				err = cmap_get_double(handle, key_name, &dbl);
> +			} else {
> +				dbl = *((double *)value);
> +			}
> +			break;
> +		case CMAP_VALUETYPE_STRING:
> +			if (value == NULL) {
> +				err = cmap_get_string(handle, key_name, &str);
> +			} else {
> +				str = (char *)value;
> +			}
> +			break;
> +		case CMAP_VALUETYPE_BINARY: break;
> +		}
> +
> +		if (err == CS_OK)
> +			end_loop = 1;
> +
> +		if (err == CS_ERR_TRY_AGAIN) {
> +			sleep(1);
> +			no_retries++;
> +		}
> +
> +		if (no_retries > MAX_TRY_AGAIN) {
> +			end_loop = 1;
> +		}
> +	};
> +
> +	if (err != CS_OK) {
> +		fprintf(stderr, "Can't get value of %s. Error %s\n", key_name, cs_strerror(err));
> +
> +		return ;
> +	}
> +
> +	printf("%s (", key_name);
> +
> +	switch (type) {
> +	case CMAP_VALUETYPE_INT8:
> +		printf("%s) = %"PRId8, "i8", i8);
> +		break;
> +	case CMAP_VALUETYPE_UINT8:
> +		printf("%s) = %"PRIu8, "u8", u8);
> +		break;
> +	case CMAP_VALUETYPE_INT16:
> +		printf("%s) = %"PRId16, "i16", i16);
> +		break;
> +	case CMAP_VALUETYPE_UINT16:
> +		printf("%s) = %"PRIu16, "u16", u16);
> +		break;
> +	case CMAP_VALUETYPE_INT32:
> +		printf("%s) = %"PRId32, "i32", i32);
> +		break;
> +	case CMAP_VALUETYPE_UINT32:
> +		printf("%s) = %"PRIu32, "u32", u32);
> +		break;
> +	case CMAP_VALUETYPE_INT64:
> +		printf("%s) = %"PRId64, "i64", i64);
> +		break;
> +	case CMAP_VALUETYPE_UINT64:
> +		printf("%s) = %"PRIu64, "u64", u64);
> +		break;
> +	case CMAP_VALUETYPE_FLOAT:
> +		printf("%s) = %f", "flt", flt);
> +		break;
> +	case CMAP_VALUETYPE_DOUBLE:
> +		printf("%s) = %lf", "dbl", dbl);
> +		break;
> +	case CMAP_VALUETYPE_STRING:
> +		printf("%s) = %s", "str", str);
> +		if (value == NULL) {
> +			free(str);
> +		}
> +		break;
> +	case CMAP_VALUETYPE_BINARY:
> +		printf("%s)", "bin");
> +		break;
> +	}
> +
> +	printf("\n");
> +}
> +
> +static void print_iter(enum user_action action, cmap_handle_t handle, const char *prefix)
> +{
> +	cmap_iter_handle_t iter_handle;
> +	char key_name[CMAP_KEYNAME_MAXLEN + 1];
> +	size_t value_len;
> +	cmap_value_types_t type;
> +	cs_error_t err;
> +
> +	err = cmap_iter_init(handle, prefix, &iter_handle);
> +	if (err != CS_OK) {
> +		fprintf (stderr, "Failed to initialize iteration. Error %s\n", cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +
> +	while ((err = cmap_iter_next(handle, iter_handle, key_name, &value_len, &type)) == CS_OK) {
> +		if (action == ACTION_PRINT_DEFAULT &&
> +			strncmp(key_name, "internal_configuration", strlen("internal_configuration") == 0))
> +			continue;
> +		print_key(handle, key_name, value_len, NULL, type);
> +	}
> +}
> +
> +static void cmap_notify_fn(
> +	cmap_handle_t cmap_handle,
> +	cmap_track_handle_t cmap_track_handle,
> +	int32_t event,
> +	const char *key_name,
> +	struct cmap_notify_value new_val,
> +	struct cmap_notify_value old_val,
> +	void *user_data)
> +{
> +	switch (event) {
> +	case CMAP_TRACK_ADD:
> +		printf("create> ");
> +		print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
> +		break;
> +	case CMAP_TRACK_DELETE:
> +		printf("delete> ");
> +		print_key(cmap_handle, key_name, old_val.len, old_val.data, old_val.type);
> +		break;
> +	case CMAP_TRACK_MODIFY:
> +		printf("modify> ");
> +		print_key(cmap_handle, key_name, new_val.len, new_val.data, new_val.type);
> +		break;
> +	default:
> +		printf("unknown change> ");
> +		break;
> +	}
> +
> +}
> +
> +static void add_track(cmap_handle_t handle, const char *key_name, int prefix)
> +{
> +	cmap_track_handle_t track_handle;
> +	int32_t track_type;
> +	cs_error_t err;
> +
> +	track_type = CMAP_TRACK_ADD | CMAP_TRACK_DELETE | CMAP_TRACK_MODIFY;
> +	if (prefix) {
> +		track_type |= CMAP_TRACK_PREFIX;
> +	}
> +
> +	err = cmap_track_add(handle, key_name, track_type, cmap_notify_fn, NULL, &track_handle);
> +	if (err != CS_OK) {
> +		fprintf(stderr, "Failed to add tracking function. Error %s\n", cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +}
> +
> +static void track_changes(cmap_handle_t handle)
> +{
> +	struct pollfd pfd[2];
> +	int cmap_fd;
> +	cs_error_t err;
> +	int poll_res;
> +	char inbuf[3];
> +	int quit = CS_FALSE;
> +
> +	err = cmap_fd_get(handle, &cmap_fd);
> +	if (err != CS_OK) {
> +		fprintf(stderr, "Failed to get file handle. Error %s\n", cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +
> +	pfd[0].fd = cmap_fd;
> +	pfd[1].fd = STDIN_FILENO;
> +	pfd[0].events = pfd[1].events = POLLIN;
> +
> +	printf("Type \"q\" to finish\n");
> +	do {
> +		pfd[0].revents = pfd[1].revents = 0;
> +		poll_res = poll(pfd, 2, INFTIM);
> +		if (poll_res == -1) {
> +			perror("poll");
> +		}
> +
> +		if (pfd[1].revents & POLLIN) {
> +			if (fgets(inbuf, sizeof(inbuf), stdin) == NULL) {
> +				quit = CS_TRUE;
> +			} else if (strncmp(inbuf, "q", 1) == 0) {
> +				quit = CS_TRUE;
> +			}
> +		}
> +
> +		if (pfd[0].revents & POLLIN) {
> +			err = cmap_dispatch(handle, CS_DISPATCH_ALL);
> +			if (err != CS_OK) {
> +				fprintf(stderr, "Dispatch error %s\n", cs_strerror(err));
> +				quit = CS_TRUE;
> +			}
> +		}
> +	} while (poll_res > 0 && !quit);
> +}
> +
> +
> +static void set_key(cmap_handle_t handle, const char *key_name, const char *key_type_s, const char *key_value_s)
> +{
> +	int64_t i64;
> +	uint64_t u64;
> +	double dbl;
> +	float flt;
> +	cs_error_t err;
> +	int scanf_res;
> +
> +	cmap_value_types_t type;
> +
> +	if (convert_name_to_type(key_type_s) == -1) {
> +		fprintf(stderr, "Unknown type %s\n", key_type_s);
> +		exit (EXIT_FAILURE);
> +	}
> +
> +	type = convert_name_to_type(key_type_s);
> +
> +	switch (type) {
> +	case CMAP_VALUETYPE_INT8:
> +	case CMAP_VALUETYPE_INT16:
> +	case CMAP_VALUETYPE_INT32:
> +	case CMAP_VALUETYPE_INT64:
> +		scanf_res = sscanf(key_value_s, "%"PRId64, &i64);
> +		break;
> +	case CMAP_VALUETYPE_UINT8:
> +	case CMAP_VALUETYPE_UINT16:
> +	case CMAP_VALUETYPE_UINT32:
> +	case CMAP_VALUETYPE_UINT64:
> +		scanf_res = sscanf(key_value_s, "%"PRIu64, &u64);
> +		break;
> +	case CMAP_VALUETYPE_FLOAT:
> +		scanf_res = sscanf(key_value_s, "%f", &flt);
> +		break;
> +	case CMAP_VALUETYPE_DOUBLE:
> +		scanf_res = sscanf(key_value_s, "%lf", &dbl);
> +		break;
> +	case CMAP_VALUETYPE_STRING:
> +	case CMAP_VALUETYPE_BINARY:
> +		/*
> +		 * Do nothing
> +		 */
> +		scanf_res = 1;
> +		break;
> +	}
> +
> +	if (scanf_res != 1) {
> +		fprintf(stderr, "%s is not valid %s type value\n", key_value_s, key_type_s);
> +		exit(EXIT_FAILURE);
> +	}
> +	/*
> +	 * We have parsed value, so insert value
> +	 */
> +
> +	switch (type) {
> +	case CMAP_VALUETYPE_INT8:
> +		if (i64 > INT8_MAX || i64 < INT8_MIN) {
> +			fprintf(stderr, "%s is not valid i8 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_int8(handle, key_name, i64);
> +		break;
> +	case CMAP_VALUETYPE_INT16:
> +		if (i64 > INT16_MAX || i64 < INT16_MIN) {
> +			fprintf(stderr, "%s is not valid i16 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_int16(handle, key_name, i64);
> +		break;
> +	case CMAP_VALUETYPE_INT32:
> +		if (i64 > INT32_MAX || i64 < INT32_MIN) {
> +			fprintf(stderr, "%s is not valid i32 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_int32(handle, key_name, i64);
> +		break;
> +	case CMAP_VALUETYPE_INT64:
> +		err = cmap_set_int64(handle, key_name, i64);
> +		break;
> +
> +	case CMAP_VALUETYPE_UINT8:
> +		if (u64 > UINT8_MAX) {
> +			fprintf(stderr, "%s is not valid u8 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_uint8(handle, key_name, u64);
> +		break;
> +	case CMAP_VALUETYPE_UINT16:
> +		if (u64 > UINT16_MAX) {
> +			fprintf(stderr, "%s is not valid u16 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_uint16(handle, key_name, u64);
> +		break;
> +	case CMAP_VALUETYPE_UINT32:
> +		if (u64 > UINT32_MAX) {
> +			fprintf(stderr, "%s is not valid u32 integer\n", key_value_s);
> +			exit(EXIT_FAILURE);
> +		}
> +		err = cmap_set_uint32(handle, key_name, u64);
> +		break;
> +	case CMAP_VALUETYPE_UINT64:
> +		err = cmap_set_uint64(handle, key_name, u64);
> +		break;
> +	case CMAP_VALUETYPE_FLOAT:
> +		err = cmap_set_float(handle, key_name, flt);
> +		break;
> +	case CMAP_VALUETYPE_DOUBLE:
> +		err = cmap_set_double(handle, key_name, dbl);
> +		break;
> +	case CMAP_VALUETYPE_STRING:
> +		err = cmap_set_string(handle, key_name, key_value_s);
> +		break;
> +	case CMAP_VALUETYPE_BINARY:
> +		exit(1);
> +		break;
> +	}
> +
> +	if (err != CS_OK) {
> +		fprintf (stderr, "Failed to set key %s. Error %s\n", key_name, cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +}
> +
> +int main(int argc, char *argv[])
> +{
> +	enum user_action action;
> +	int c;
> +	cs_error_t err;
> +	cmap_handle_t handle;
> +	int i;
> +	size_t value_len;
> +	cmap_value_types_t type;
> +	int track_prefix;
> +	int no_retries;
> +
> +	action = ACTION_PRINT_PREFIX;
> +	track_prefix = 1;
> +
> +	while ((c = getopt(argc, argv, "hagsdtT")) != -1) {
> +		switch (c) {
> +		case 'h':
> +			return print_help();
> +			break;
> +		case 'a':
> +			action = ACTION_PRINT_ALL;
> +			break;
> +		case 'g':
> +			action = ACTION_GET;
> +			break;
> +		case 's':
> +			action = ACTION_SET;
> +			break;
> +		case 'd':
> +			action = ACTION_DELETE;
> +			break;
> +		case 't':
> +			action = ACTION_TRACK;
> +			break;
> +		case 'T':
> +			action = ACTION_TRACK;
> +			track_prefix = 0;
> +			break;
> +		case '?':
> +			return (EXIT_FAILURE);
> +			break;
> +		default:
> +			action = ACTION_PRINT_PREFIX;
> +			break;
> +		}
> +	}
> +
> +	if (argc == 1) {
> +		action = ACTION_PRINT_DEFAULT;
> +	}
> +
> +	argc -= optind;
> +	argv += optind;
> +
> +	if (argc == 0 && action != ACTION_PRINT_DEFAULT && action != ACTION_PRINT_ALL) {
> +		fprintf(stderr, "Expected key after options\n");
> +		return (EXIT_FAILURE);
> +	}
> +
> +	no_retries = 0;
> +	while ((err = cmap_initialize(&handle)) == CS_ERR_TRY_AGAIN && no_retries++ < MAX_TRY_AGAIN) {
> +		sleep(1);
> +	}
> +
> +	if (err != CS_OK) {
> +		fprintf (stderr, "Failed to initialize the cmap API. Error %s\n", cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +
> +	switch (action) {
> +	case ACTION_PRINT_DEFAULT:
> +	case ACTION_PRINT_ALL:
> +		print_iter(action, handle, NULL);
> +		break;
> +	case ACTION_PRINT_PREFIX:
> +		for (i = 0; i < argc; i++) {
> +			print_iter(action, handle, argv[i]);
> +		}
> +		break;
> +	case ACTION_GET:
> +		for (i = 0; i < argc; i++) {
> +			err = cmap_get(handle, argv[i], NULL, &value_len, &type);
> +			if (err == CS_OK) {
> +				print_key(handle, argv[i], value_len, NULL, type);
> +			} else {
> +				fprintf(stderr, "Can't get key %s. Error %s\n", argv[i], cs_strerror(err));
> +			}
> +		}
> +		break;
> +	case ACTION_DELETE:
> +		for (i = 0; i < argc; i++) {
> +			err = cmap_delete(handle, argv[i]);
> +			if (err != CS_OK) {
> +				fprintf(stderr, "Can't delete key %s. Error %s\n", argv[i], cs_strerror(err));
> +			}
> +		}
> +		break;
> +	case ACTION_TRACK:
> +		for (i = 0; i < argc; i++) {
> +			add_track(handle, argv[i], track_prefix);
> +		}
> +		track_changes(handle);
> +		break;
> +	case ACTION_SET:
> +		if (argc < 3) {
> +			fprintf(stderr, "At least 3 parameters are expected for set\n");
> +			return (EXIT_FAILURE);
> +		}
> +
> +		set_key(handle, argv[0], argv[1], argv[2]);
> +		break;
> +
> +	}
> +
> +	err = cmap_finalize(handle);
> +	if (err != CS_OK) {
> +		fprintf (stderr, "Failed to finalize the cmap API. Error %s\n", cs_strerror(err));
> +		exit (EXIT_FAILURE);
> +	}
> +
> +	return (0);
> +}



More information about the discuss mailing list