连接zookeeper获取所需信息

zookeeper c API介绍

本文内容大部分参考Zookeeper C API 指南所得

API可分为以下几类：
1. 初始化、销毁 Zookeeper句柄 可参考
2. 辅助函数 参考
3. 与 zoo_multi() 和 zoo_amulti() 批量操作相关的 zoo_op_t 初始化 可参考
4. Zookeeper C API 同步接口 可参考
5. Zookeeper C API 异步接口 可参考

1.初始化、销毁 Zookeeper 句柄

ZOOAPI zhandle_t *zookeeper_init(const char* host,watcher_fn fn,
                                 int recv_timeout,const clientid_t*
                                 clientid,void *context,int flags);
ZOOAPI int zookeeper_close(zhandle_t * zh);

各参数说明如下：
- host———-zookeeper集群地址，格式为 ip:port;ip:port….,每一个ip:port代表一个zk server
- fn————全局的监视器回调函数，当发生事件通知时，该函数被调用
- clientid——客户端尝试重连的先前会话的ID，如果不需要重连先前的会话，则设置为 0
- context——-与 zhandle_t 实例相关联的“上下文对象”（可以通过该参数为 zhandle_t 传入自定义类型的数据），应用程序可以通过zoo_get_context 访问它（例如在监视器回调函数中），当然zookeeper 内部没有用到该参数，所以 context 可以设置为 NULL。
-flags———-目前为保留参数，设置为 0。

2.创建，删除，查询节点等API

此部分简单介绍节点的创建，删除和查询.

2.1创建

同步：

ZOOAPI int zoo_create(zhandle_t * zh, const char*path,const char *value, 
                      int valuelen,const struct ACL_vector *acl, int 
                      flags,char *path_buffer, int path_buffer_len); 

• path————节点路径
• value———–该节点保存的数据,为NULL表不含数据
• valuelen——–保存的数据的大小。如value为NULL，长度应设为-1
• acl————-该节点初始acl,不能为NULL
• flags———–0,ZOO_EPHEMERAL,ZOO_SEQUENCE,可组合
• path_buffer—–用于保存返回节点新路径（因为设置了 ZOO_SEQUENCE 后 zoo_create 所创建的节点名称与参数 path 提供的名称不同，新的节点名称后面填充了序号），path 字符串以 NULL 结束。path_buffer 可以设置为 NULL，此时 path_buffer_len 等于0

异步：

ZOOAPI int zoo_acreate(zhandle_t * zh, const char *path,
                       const char *value, int valuelen,
                       const struct ACL_vector *acl, int flags,
                       string_completion_t completion, const void *data);

• completion———当创建节点请求完成时会调用该函数同时传递给completion的 rc参数为: ZOK 操作完成；ZNONODE 父节点不存在；ZNODEEXISTS 节点已存在；ZNOAUTH 客户端没有权限创建节点。ZNOCHILDRENFOREPHEMERALS 临时节点不能创建子节点。
• data—————completino函数被调用时，传递给 completion 的数据。

2.2删除

同步：

ZOOAPI int zoo_delete(zhandle_t * zh, const char *path, int version);

• version————节点的版本号，如果该 znode 节点的实际版本号与该参数提供的版本号不一致，则删除节点失败，如果 version 为 -1，则不作版本检查。
  异步：

ZOOAPI int zoo_adelete(zhandle_t * zh, const char *path, int version,
                       void_completion_t completion, const void *data);

2.3查询

同步：

ZOOAPI int zoo_get(zhandle_t * zh, const char *path, int watch,
                   char *buffer, int *buffer_len, struct Stat *stat);

• watch————–非0，则会在服务端设置监视，当节点发生变化客户端会得到通知
• buffer————-保存获得的数据
• stat—————保存该节点的状态信息

设置watcher

ZOOAPI int zoo_wget(zhandle_t * zh, const char *path,
                    watcher_fn watcher, void *watcherCtx,
                    char *buffer, int *buffer_len, struct Stat *stat);

• watcher————监视器回调函数
• watcherCtx———用户指定的数据，将被传入到监视器回调函数中，与由 zookeeper_init() 设置的全局监视器上下文不同，该函数设置的监视器上下文只与当前的监视器相关联。

异步：

ZOOAPI int zoo_aget(zhandle_t * zh, const char *path, int watch,
                    data_completion_t completion, const void *data);
ZOOAPI int zoo_aget(zhandle_t * zh, const char *path, int watch,
                    data_completion_t completion, const void *data);

3.辅助函数

ZOOAPI void zoo_set_debug_level(ZooLogLevel logLevel);\\设置日志等级
ZOOAPI void zoo_set_log_stream(FILE * logStream);   \\设置日志流

4.应用举例

1. include <zookeeper.h>
2. 多线程链接zookeeper_mt,单线程链接zookeeper_st

example1:

    const char * host="127.0.0.1:25001,127.0.0.1:25002,127.0.0.1:25003";
    int timeout = 30000;
    //zoo_set_log_stream(FILE * logStream); //设置日志输出位置，默认标志输出

    //connect zookeeper
    zoo_set_debug_level(ZOO_LOG_LEVEL_ERROR);//设置日志等级为只在出错时输出日志。
    zhandle_t* zkhandle = zookeeper_init(host.c_str(),zktest_watcher_g, timeout, 0, (void*)"hello zookeeper.", 0);
    if (zkhandle == NULL) {
        fprintf(stderr, "Error when connecting to zookeeper servers...\n");
        //exit(EXIT_FAILURE);
        return false;
    }

    //get
    char szBuff[10*1000];
    int32 iBuffLen = sizeof(szBuff);
    memset(szBuff, 0, iBuffLen);
    Stat stat;
    zoo_get(zkhandle, path.c_str(), 0,szBuff, &iBuffLen,&stat);    
    cout<<"data:"<<szBuffer<<endl;

example2:

/*
 * =============================================================================
 *
 *       Filename:  zktest.c
 *
 *    Description:  zookeeper api testcase.
 *
 *        Created:  02/15/2013 08:48:49 PM
 *
 *         Author:  Fu Haiping (forhappy), haipingf@gmail.com
 *        Company:  ICT ( Institute Of Computing Technology, CAS )
 *
 * =============================================================================
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zookeeper/zookeeper.h>
#include <zookeeper/zookeeper_log.h>

///监视回调
void zktest_watcher_g(zhandle_t* zh, int type, int state,
        const char* path, void* watcherCtx)
{
    printf("Something happened.\n");
    printf("type: %d\n", type);
    printf("state: %d\n", state);
    printf("path: %s\n", path);
    printf("watcherCtx: %s\n", (char *)watcherCtx);
}
///在异步 API 调用结束或 Zookeeper 客户端失去连接时被调用
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 Stat:\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 = "127.0.0.1:2181,127.0.0.1:2182,"
        "127.0.0.1:2183,127.0.0.1:2184,127.0.0.1:2185";
    int timeout = 30000;

    zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
    zhandle_t* zkhandle = zookeeper_init(host,
            zktest_watcher_g, timeout, 0, "hello zookeeper.", 0);//设置全局监视回调
    if (zkhandle == NULL) {
        fprintf(stderr, "Error when connecting to zookeeper servers...\n");
        exit(EXIT_FAILURE);
    }

    // struct ACL ALL_ACL[] = {{ZOO_PERM_ALL, ZOO_ANYONE_ID_UNSAFE}};
    // struct ACL_vector ALL_PERMS = {1, ALL_ACL};
    int ret = zoo_acreate(zkhandle, "/xyz", "hello", 5,
           &ZOO_OPEN_ACL_UNSAFE, 0 /* ZOO_SEQUENCE */,
           zktest_string_completion, "acreate");
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "acreate");
        exit(EXIT_FAILURE);
    }
    ret = 0;

    ret = zoo_aexists(zkhandle, "/xyz", 1, zktest_stat_completion, "aexists"); //设置监视回调
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "aexists");
        exit(EXIT_FAILURE);
    }
    ret = 0;
    // Wait for asynchronous zookeeper call done.
    getchar();

    ret = zoo_adelete(zkhandle, "/xyz", -1, zktest_void_completion, "adelete");
    if (ret) {
        fprintf(stderr, "Error %d for %s\n", ret, "adelete");
        exit(EXIT_FAILURE);
    }
    // Wait for asynchronous zookeeper call done.
    getchar();

    zookeeper_close(zkhandle);
}