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@xxxxxxxxxx>
On 12/14/2011 08:41 AM, Jan Friesse wrote:
> corosync-cmapctl is direct replacement for corosync-objctl
>
> Signed-off-by: Jan Friesse <jfriesse@xxxxxxxxxx>
> ---
> 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@xxxxxxxxxx)
> + *
> + * 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);
> +}
_______________________________________________
discuss mailing list
discuss@xxxxxxxxxxxx
http://lists.corosync.org/mailman/listinfo/discuss
