cmap.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2017 Red Hat, Inc.
 *
 * All rights reserved.
 *
 * Author: Jan Friesse (jfriesse@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.
 */
 
#ifndef COROSYNC_CMAP_H_DEFINED
#define COROSYNC_CMAP_H_DEFINED
 
#include <corosync/corotypes.h>
#include <corosync/hdb.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * Handle for cmap service connection
 */
typedef uint64_t cmap_handle_t;
 
/*
 * Handle for cmap iterator
 */
typedef uint64_t cmap_iter_handle_t;
 
/*
 * Handle for cmap tracking function
 */
typedef uint64_t cmap_track_handle_t;
 
/*
 * Maximum length of key in cmap
 */
#define CMAP_KEYNAME_MAXLEN            255
/*
 * Minumum length of key in cmap
 */
#define CMAP_KEYNAME_MINLEN            3
 
/*
 * Tracking values.
 */
#define CMAP_TRACK_ADD          4
#define CMAP_TRACK_DELETE       1
#define CMAP_TRACK_MODIFY       2
 
#define CMAP_TRACK_PREFIX       8
 
typedef enum {
    CMAP_VALUETYPE_INT8         =  1,
    CMAP_VALUETYPE_UINT8        =  2,
    CMAP_VALUETYPE_INT16        =  3,
    CMAP_VALUETYPE_UINT16       =  4,
    CMAP_VALUETYPE_INT32        =  5,
    CMAP_VALUETYPE_UINT32       =  6,
    CMAP_VALUETYPE_INT64        =  7,
    CMAP_VALUETYPE_UINT64       =  8,
    CMAP_VALUETYPE_FLOAT        =  9,
    CMAP_VALUETYPE_DOUBLE       = 10,
    CMAP_VALUETYPE_STRING       = 11,
    CMAP_VALUETYPE_BINARY       = 12,
} cmap_value_types_t;
 
typedef enum {
        CMAP_MAP_DEFAULT        = 0,
        CMAP_MAP_ICMAP          = 0,
        CMAP_MAP_STATS          = 1,
} cmap_map_t;
 
struct cmap_notify_value {
        cmap_value_types_t type;
        size_t len;
        const void *data;
};
 
typedef void (*cmap_notify_fn_t) (
        cmap_handle_t cmap_handle,
        cmap_track_handle_t cmap_track_handle,
        int32_t event,
        const char *key_name,
        struct cmap_notify_value new_value,
        struct cmap_notify_value old_value,
        void *user_data);
 
extern cs_error_t cmap_initialize (
        cmap_handle_t *handle);
 
extern cs_error_t cmap_initialize_map (
        cmap_handle_t *handle,
        cmap_map_t map);
 
extern cs_error_t cmap_finalize (
        cmap_handle_t handle);
 
extern cs_error_t cmap_fd_get (
        cmap_handle_t handle,
        int *fd);
 
extern cs_error_t cmap_dispatch (
        cmap_handle_t handle,
        cs_dispatch_flags_t dispatch_types);
extern cs_error_t cmap_context_get (
        cmap_handle_t handle,
        const void **context);
 
extern cs_error_t cmap_context_set (
        cmap_handle_t handle,
        const void *context);
 
extern cs_error_t cmap_set(
        cmap_handle_t handle,
        const char *key_name,
        const void *value,
        size_t value_len,
        cmap_value_types_t type);
 
/*
 * Shortcuts for cmap_set with given type
 */
extern cs_error_t cmap_set_int8(cmap_handle_t handle, const char *key_name, int8_t value);
extern cs_error_t cmap_set_uint8(cmap_handle_t handle, const char *key_name, uint8_t value);
extern cs_error_t cmap_set_int16(cmap_handle_t handle, const char *key_name, int16_t value);
extern cs_error_t cmap_set_uint16(cmap_handle_t handle, const char *key_name, uint16_t value);
extern cs_error_t cmap_set_int32(cmap_handle_t handle, const char *key_name, int32_t value);
extern cs_error_t cmap_set_uint32(cmap_handle_t handle, const char *key_name, uint32_t value);
extern cs_error_t cmap_set_int64(cmap_handle_t handle, const char *key_name, int64_t value);
extern cs_error_t cmap_set_uint64(cmap_handle_t handle, const char *key_name, uint64_t value);
extern cs_error_t cmap_set_float(cmap_handle_t handle, const char *key_name, float value);
extern cs_error_t cmap_set_double(cmap_handle_t handle, const char *key_name, double value);
extern cs_error_t cmap_set_string(cmap_handle_t handle, const char *key_name, const char *value);
 
extern cs_error_t cmap_delete(cmap_handle_t handle, const char *key_name);
 
extern cs_error_t cmap_get(
        cmap_handle_t handle,
        const char *key_name,
        void *value,
        size_t *value_len,
        cmap_value_types_t *type);
 
/*
 * Shortcuts for cmap_get.
 */
extern cs_error_t cmap_get_int8(cmap_handle_t handle, const char *key_name, int8_t *i8);
extern cs_error_t cmap_get_uint8(cmap_handle_t handle, const char *key_name, uint8_t *u8);
extern cs_error_t cmap_get_int16(cmap_handle_t handle, const char *key_name, int16_t *i16);
extern cs_error_t cmap_get_uint16(cmap_handle_t handle, const char *key_name, uint16_t *u16);
extern cs_error_t cmap_get_int32(cmap_handle_t handle, const char *key_name, int32_t *i32);
extern cs_error_t cmap_get_uint32(cmap_handle_t handle, const char *key_name, uint32_t *u32);
extern cs_error_t cmap_get_int64(cmap_handle_t handle, const char *key_name, int64_t *i64);
extern cs_error_t cmap_get_uint64(cmap_handle_t handle, const char *key_name, uint64_t *u64);
extern cs_error_t cmap_get_float(cmap_handle_t handle, const char *key_name, float *flt);
extern cs_error_t cmap_get_double(cmap_handle_t handle, const char *key_name, double *dbl);
 
extern cs_error_t cmap_get_string(cmap_handle_t handle, const char *key_name, char **str);
 
extern cs_error_t cmap_inc(cmap_handle_t handle, const char *key_name);
 
extern cs_error_t cmap_dec(cmap_handle_t handle, const char *key_name);
 
extern cs_error_t cmap_iter_init(cmap_handle_t handle, const char *prefix, cmap_iter_handle_t *cmap_iter_handle);
 
extern cs_error_t cmap_iter_next(
                cmap_handle_t handle,
                cmap_iter_handle_t iter_handle,
                char key_name[],
                size_t *value_len,
                cmap_value_types_t *type);
 
extern cs_error_t cmap_iter_finalize(cmap_handle_t handle, cmap_iter_handle_t iter_handle);
 
extern cs_error_t cmap_track_add(
        cmap_handle_t handle,
        const char *key_name,
        int32_t track_type,
        cmap_notify_fn_t notify_fn,
        void *user_data,
        cmap_track_handle_t *cmap_track_handle);
 
extern cs_error_t cmap_track_delete(cmap_handle_t handle, cmap_track_handle_t track_handle);
 
#ifdef __cplusplus
}
#endif
 
#endif /* COROSYNC_CMAP_H_DEFINED */