Workable C client code for zookeeper ensemble.

zk_client.c

/**
 * Workable C client code for zookeeper ensemble under zoopiter management.
 * Include async and sync mode, for async mode, should use some synchronization method like 'lock'.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <zookeeper/zookeeper.h>

 #define PATH_LEN     256
 #define MAX_DATA_LEN (1024*1024)


static const char* state2String(int state){
  if (state == 0)
    return "CLOSED_STATE";
  if (state == ZOO_CONNECTING_STATE)
    return "CONNECTING_STATE";
  if (state == ZOO_ASSOCIATING_STATE)
    return "ASSOCIATING_STATE";
  if (state == ZOO_CONNECTED_STATE)
    return "CONNECTED_STATE";
  if (state == ZOO_EXPIRED_SESSION_STATE)
    return "EXPIRED_SESSION_STATE";
  if (state == ZOO_AUTH_FAILED_STATE)
    return "AUTH_FAILED_STATE";

  return "INVALID_STATE";
}

static const char* type2String(int state){
  if (state == ZOO_CREATED_EVENT)
    return "CREATED_EVENT";
  if (state == ZOO_DELETED_EVENT)
    return "DELETED_EVENT";
  if (state == ZOO_CHANGED_EVENT)
    return "CHANGED_EVENT";
  if (state == ZOO_CHILD_EVENT)
    return "CHILD_EVENT";
  if (state == ZOO_SESSION_EVENT)
    return "SESSION_EVENT";
  if (state == ZOO_NOTWATCHING_EVENT)
    return "NOTWATCHING_EVENT";

  return "UNKNOWN_EVENT_TYPE";
}

void zktest_watcher_g(zhandle_t* zh, int type, int state, const char* path, void* watcherCtx) {
    printf("Something happened.\n");
    printf("type: %s\n", type2String(type));
    printf("state: %s\n", state2String(state));
    printf("path: %s\n", path);
    printf("watcherCtx: %s\n", (char *)watcherCtx);
}

void zktest_dump_stat(const struct Stat *stat) {
    char tctimes[40];
    char tmtimes[40];
    time_t tctime;
    time_t tmtime;

    if (!stat) {
        fprintf(stderr,"null\n");
        return;
    }
    tctime = stat->ctime/1000;
    tmtime = stat->mtime/1000;
       
    ctime_r(&tmtime, tmtimes);
    ctime_r(&tctime, tctimes);
       
    fprintf(stderr, "\tctime = %s\tczxid=%llx\n"
        "\tmtime=%s\tmzxid=%llx\n"
        "\tversion=%x\taversion=%x\n"
        "\tephemeralOwner = %llx\n",
        tctimes, stat->czxid,
        tmtimes, stat->mzxid,
        (unsigned int)stat->version, (unsigned int)stat->aversion,
        stat->ephemeralOwner);
}

void zktest_stat_completion(int rc, const struct Stat *stat, const void *data)
{
    fprintf(stderr, "%s: rc = %d \nStat:\n", (char*)data, rc);
    zktest_dump_stat(stat);
}

void zktest_void_completion(int rc, const void *data)
{
    fprintf(stderr, "[%s]: rc = %d\n", (char*)(data==0?"null":data), rc);
}

void zktest_string_completion(int rc, const char *name, const void *data)
{
    fprintf(stderr, "[%s]: rc = %d\n", (char*)(data==0?"null":data), rc);
    if (!rc) {
        fprintf(stderr, "\tname = %s\n", name);
    }
}

int main(int argc, const char *argv[])
{
    const char* host = "10.10.10.10:2181/mv_serv/new_app";
    int rcv_timeout = 30000;  // it is session reseive timeout
    const char* zo_scheme = "auth";
    const char* user_digest = "sysadmin:LjNJ/3oQADeSh0z+aIw/+rEPnis=";
    
    zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
    zhandle_t* zkhandle = zookeeper_init(host, zktest_watcher_g, rcv_timeout, 0, NULL, 0);
    if (zkhandle == NULL) {
        fprintf(stderr, "Error when connecting to zookeeper servers...\n");
        exit(EXIT_FAILURE);
    }

    // zookeeper operation is asynchonized, need to wait for the connection
    while (zoo_state(zkhandle) != ZOO_CONNECTED_STATE)
    {
        sleep(1);
    }

    int certLen = strlen(user_digest);
    int ret = zoo_add_auth(zkhandle, zo_scheme, user_digest, certLen, zktest_void_completion, "add_auth");
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "add_auth");
        exit(EXIT_FAILURE);
    }
    ret = 0;

    const char* nodeData = "Node data";
    // create node with async mode, get call back with complete function.
    //ret = zoo_acreate(zkhandle, "/new_node", nodeData, strlen(nodeData), &ZOO_READ_ACL_UNSAFE, 0 /* ZOO_SEQUENCE */,
    //       zktest_string_completion, "acreate");

    // create node in sync mode.
    int path_len = PATH_LEN + 1;
    char path_buff[PATH_LEN] = {'\0'};
    ret = zoo_create(zkhandle, "/new_node", nodeData, strlen(nodeData), &ZOO_READ_ACL_UNSAFE, 0, path_buff, path_len);
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "create");
        exit(EXIT_FAILURE);
    }
    fprintf(stderr, "Path: %s created\n", path_buff);
    ret = 0;

    // async mode
    // ret = zoo_aexists(zkhandle, "/new_node", 1, zktest_stat_completion, "aexists");

    // sync mode
    struct Stat *stat = NULL;
    ret = zoo_exists(zkhandle, "/new_node", 0, stat);
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "exists");
        exit(EXIT_FAILURE);
    }
    ret = 0;


    int data_len = MAX_DATA_LEN + 1;
    char data_buff[MAX_DATA_LEN] = {'\0'};
    stat = NULL;
    ret = zoo_get(zkhandle, "/new_node", 1, data_buff, &data_len, stat);
    if(ret)
        fprintf(stderr, "Error %d for %s\n", ret, "get");
    fprintf(stderr, "Got size:%d data: [%s] of path:%s\n", data_len, data_buff, "/new_node");

    // delete in async.
    // ret = zoo_adelete(zkhandle, "/new_node", -1, zktest_void_completion, "adelete");

    // sync
    ret = zoo_delete(zkhandle, "/new_node", -1);
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "delete");
        exit(EXIT_FAILURE);
    }

    zookeeper_close(zkhandle);
}