void watchchildren(zhandle_t *zzh, int type, int state, const char *path,
void* context)
{
struct String_vector str;
int rc;
printf("The event path %s, event type %d\n", path, type);
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
return;
} else if (state == ZOO_AUTH_FAILED_STATE) {
zookeeper_close(zzh);
exit(1);
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
zookeeper_close(zzh);
exit(1);
}
}
// Put the watch again
rc = zoo_wget_children(zh, "/testpath1",
watchchildren , mycontext, &str);
if (ZOK != rc){
printf("Problems %d\n", rc);
} else {
int i = 0;
while (i < str.count) {
printf("Children %s\n", str.data[i++]);
}
if (str.count) {
deallocate_String_vector(&str);
}
}
}
enum zoo_res zu_create_ephemeral(struct zoodis *z)
{
int res;
int bufsize = 512;
char buffer[bufsize]; // no reason, added due to some of example, need to be done.
int buffer_len = bufsize;
memset(buffer, 0x00, bufsize);
res = zoo_get(z->zh, z->zoo_nodepath->data, 0, buffer, &buffer_len, 0);
if(res == ZOK)
{
if(buffer_len == z->zoo_nodedata->len && strncmp(z->zoo_nodedata->data, buffer, z->zoo_nodedata->len) == 0)
{
return ZOO_RES_OK;
}else
{
zu_remove_ephemeral(z);
}
}else if(res != ZOK && res != ZNONODE)
{
ZU_RETURN_PRINT(res);
if(res == ZINVALIDSTATE)
{
zookeeper_close(z->zh);
zoodis.zoo_stat = ZOO_STAT_NOT_CONNECTED;
z->zid = NULL;
log_warn("Zookeeper: error, trying to re-connect.");
zu_connect(z);
}
// exit_proc(-1);
}
res = zoo_create(z->zh, z->zoo_nodepath->data, z->zoo_nodedata->data, strlen(z->zoo_nodedata->data), &ZOO_READ_ACL_UNSAFE, ZOO_EPHEMERAL, buffer, sizeof(buffer)-1);
if(res != ZOK)
{
ZU_RETURN_PRINT(res);
if(res == ZINVALIDSTATE)
{
zookeeper_close(z->zh);
zoodis.zoo_stat = ZOO_STAT_NOT_CONNECTED;
z->zid = NULL;
log_warn("Zookeeper: error, trying to re-connect.");
zu_connect(z);
}
}
return ZOO_RES_OK;
}
void watcher(zhandle_t *zzh, int type, int state, const char *path,
void* context)
{
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
connected = 1;
} else if (state == ZOO_AUTH_FAILED_STATE) {
zookeeper_close(zzh);
exit(1);
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
zookeeper_close(zzh);
exit(1);
}
}
}
zkServer::~zkServer()
{
if(zkhandle != NULL)
{
zookeeper_close(zkhandle);
}
};
ZKWrapper::~ZKWrapper()
{
if (m_zkHandler)
{
zookeeper_close(m_zkHandler);
}
}
/**
* Watcher we use to process session events. In particular,
* when it receives a ZOO_CONNECTED_STATE event, we set the
* connected variable so that we know that the session has
* been established.
*/
void main_watcher (zhandle_t *zkh,
int type,
int state,
const char *path,
void* context)
{
/*
* zookeeper_init might not have returned, so we
* use zkh instead.
*/
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
connected = 1;
LOG_DEBUG(("Received a connected event."));
} else if (state == ZOO_CONNECTING_STATE) {
if(connected == 1) {
LOG_WARN(("Disconnected."));
}
connected = 0;
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
expired = 1;
connected = 0;
zookeeper_close(zkh);
}
}
LOG_DEBUG(("Event: %s, %d", type2string(type), state));
}
int main(int argc, const char *argv[])
{
const char* host = "127.0.0.1:2181";
char *data = "alive";
//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,
watcher_g, timeout, 0, "hello zookeeper.", 0);
if (zkhandle == NULL) {
fprintf(stderr, "Error when connecting to zookeeper servers...\n");
exit(EXIT_FAILURE);
}
int ret = zoo_acreate(zkhandle, "/server", data, strlen(data),
&ZOO_OPEN_ACL_UNSAFE, ZOO_EPHEMERAL,
completion, "zoo_acreate");
if (ret) {
fprintf(stderr, "Error %d for %s\n", ret, "acreate");
exit(EXIT_FAILURE);
}
do {
//sleep 5, then down
accept_query();
sleep(5);
} while(false);
zookeeper_close(zkhandle);
}
//ZooKeeper Watcher
void watcher(zhandle_t *zzh, int type, int state, const char *path, void* context) {
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
const clientid_t *id = zoo_client_id(zzh);
if (zkClientId.client_id == 0 || zkClientId.client_id != id->client_id) {
zkClientId = *id;
completeZkInit = 1;
}
}
} else if (state == ZOO_AUTH_FAILED_STATE || state == ZOO_EXPIRED_SESSION_STATE) {
zookeeper_close(zzh);
zh = 0;
exit(-1);
} else if (type == ZOO_CREATED_EVENT) {
printf("\nZOO_CREATED_EVENT(%s)\n", path);
} else if (type ==ZOO_DELETED_EVENT) {
printf("\nZOO_DELETE_EVENT(%s)\n", path);
} else if ( type == ZOO_CHANGED_EVENT) {
printf("\nZOO_CHANGED_EVENT(%s)\n", path);
} else if (type == ZOO_CHILD_EVENT) {
printf("\nZOO_CHILD_CHANGED_EVENT(%s)\n", path);
printChildren();
} else {
printf("ETC_EVENT(%d,%s)\n", type, path);
}
}
ZookeeperClient::~ZookeeperClient()
{
if (NULL != m_zk)
{
zookeeper_close(m_zk);
}
}
ZooKeeperWatcher::~ZooKeeperWatcher()
{
if (zk != NULL) {
zookeeper_close(zk);
zk = NULL;
}
events.clear();
}
int fini_zkhandle()
{
int ret = 0;
zookeeper_close(g_zhdl);
return ret;
}
void watcher(zhandle_t *zzh, int type, int state, const char *path,
void* context)
{
/* Be careful using zh here rather than zzh - as this may be mt code
* the client lib may call the watcher before zookeeper_init returns */
fprintf(stderr, "Watcher %s state = %s", type2String(type), state2String(state));
if (path && strlen(path) > 0) {
fprintf(stderr, " for path %s", path);
}
fprintf(stderr, "\n");
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
const clientid_t *id = zoo_client_id(zzh);
if (myid.client_id == 0 || myid.client_id != id->client_id) {
myid = *id;
fprintf(stderr, "Got a new session id: 0x%llx\n",
_LL_CAST_ myid.client_id);
if (clientIdFile) {
FILE *fh = fopen(clientIdFile, "w");
if (!fh) {
perror(clientIdFile);
} else {
int rc = fwrite(&myid, sizeof(myid), 1, fh);
if (rc != sizeof(myid)) {
perror("writing client id");
}
fclose(fh);
}
}
}
} else if (state == ZOO_AUTH_FAILED_STATE) {
fprintf(stderr, "Authentication failure. Shutting down...\n");
zookeeper_close(zzh);
shutdownThisThing=1;
zh=0;
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
fprintf(stderr, "Session expired. Shutting down...\n");
zookeeper_close(zzh);
shutdownThisThing=1;
zh=0;
}
}
}
void
ZHandleDeleter::operator() (zhandle_t* zhandle) const {
CHECK(nullptr != zhandle) << "NULL zhandle";
LOG(INFO) << "Destroying zhandle: " << zhandle;
int result = zookeeper_close(zhandle);
CHECK(ZOK == result)
<< "zookeeper_close() failed with error: "
<< zooErrorCodeToString(result);
}
// Destructor.
ZKClient::~ZKClient() {
if (eventLoop_) {
CHECK_EQ(eventLoop_->unRegisterForRead(pipers_[0]), 0);
}
close(pipers_[0]);
close(pipers_[1]);
delete zkaction_responses_;
zookeeper_close(zk_handle_);
}
void
zenv_close(struct zenv_s *zenv)
{
g_assert(zenv != NULL);
zreactor_destroy(zenv->zr);
zmq_ctx_destroy(zenv->zctx);
zookeeper_close(zenv->zh);
}
int main(int argc, const char *argv[])
{
int timeout = 30000;
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); //设置日志级别,避免出现一些其他信息
get_option(argc,argv);
zhandle_t* zkhandle = zookeeper_init(g_host,NULL, timeout, 0, (char *)"Load Balancing Test", 0);
if (zkhandle ==NULL){
fprintf(stderr, "Error when connecting to zookeeper servers...\n");
exit(EXIT_FAILURE);
}
char consumer_path[512] = "/Consumer";
char topic_path[512] = {0};
char group_path[512] = {0};
char client_path[512] = {0};
sprintf(topic_path,"%s/%s",consumer_path,g_topic);
sprintf(group_path,"%s/group-%d",topic_path,g_groupid);
sprintf(client_path,"%s/client-",group_path);
create(zkhandle,consumer_path,0,"");
create(zkhandle,topic_path,0,"");
create(zkhandle,group_path,0,"00000000");
int bufferlen = sizeof(g_my_path);
int ret = zoo_create(zkhandle,client_path,NULL,0,
&ZOO_OPEN_ACL_UNSAFE,ZOO_SEQUENCE|ZOO_EPHEMERAL,
g_my_path,bufferlen);
if (ret != ZOK){
printf("节点创建失败:%s \n",client_path);
exit(EXIT_FAILURE);
}else {
printf("创建的节点名称为：%s\n",g_my_path);
}
char self_name[512] = {0};
strcpy(self_name,rindex(g_my_path,'/')+1);
choose_mater(zkhandle,group_path,self_name);
do_work(zkhandle);
getchar();
zookeeper_close(zkhandle);
return 0;
}
Error_Info HBAgent::readZookeeper(){
Error_Info err;
string zk_snap;
const string ZK_SNAP="/wde/gbase/data/snapshot";
zhandle_t * zh;
bool pingpong=false;
zh=zookeeper_init(zookeeperAddress.c_str(),watcher, 10000, 0, &pingpong, 0);
char buffer[8192];
int buflen=sizeof(buffer);
struct Stat stat;
if(zh){
int rc;
int sleeptimes=0;
while(!pingpong){
sleep(1);
sleeptimes++;
if(sleeptimes==10){
err.code=-2;
err.description="Can't Connected to Zookeeper: "+zookeeperAddress;
return err;
}
}
if(zoo_state(zh)!=ZOO_CONNECTED_STATE){
err.code=HB_READZOOKEEPER_FAIL; err.description="Can't Connected to Zookeeper: "+zookeeperAddress;
return err;
}
rc=zoo_get(zh,ZK_SNAP.c_str(),0,buffer,&buflen,&stat);
if(rc==ZOK){
zk_snap=string(buffer,buflen);
}else{
err.code=HB_BADZOOKEEPER_CONFIG;
err.description="get snapshot from zookeeper fail";
return err;
}
}else{
err.code=HB_READZOOKEEPER_FAIL;
err.description="zookeeper init fail";
return err;
}
zookeeper_close(zh);
boost::replace_all(zk_snap,"\'","\"");
Json::Value root;
Json::Reader reader;
bool parseSuccess=reader.parse(zk_snap,root);
if(!parseSuccess){
err.code=HB_READZOOKEEPER_FAIL;
err.description="Bad Zookpeer Value for snapshot in Zookeeper";
}
collection=root["name"].asString();
columnfamily="contents";
err.code=HB_OK;
err.description="zookeeper init success";
return err;
}
/**
* ZKOP destructor
* if not NULL
* 1,delete handler
* 2,delete context
*/
ZKOP::~ZKOP()
{/*{{{*/
if (zkhandle != NULL) {
zookeeper_close(zkhandle);
zkhandle = NULL;
}
if (context_ != NULL) {
delete context_;
context_ = NULL;
}
}/*}}}*/
void zookeeper_init_watcher(zhandle_t *izh, int type, int state, const char *path, void *context)
{
if (type == ZOO_SESSION_EVENT)
{
if (state == ZOO_CONNECTED_STATE)
{
is_connected = 1;
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
is_connected = 0;
zookeeper_close(izh);
}
}
}
int main(int argc, const char *argv[])
{
int timeout = 30000;
char path_buffer[512];
int bufferlen=sizeof(path_buffer);
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN); //设置日志级别,避免出现一些其他信息
get_option(argc,argv);
zhandle_t* zkhandle = zookeeper_init(g_host,NULL, timeout, 0, (char *)"Load Balancing Test", 0);
if (zkhandle ==NULL){
fprintf(stderr, "Error when connecting to zookeeper servers...\n");
exit(EXIT_FAILURE);
}
char breaker_path[512] = "/Breaker";
char topic_path[512] = {0};
char partition_path[512] = {0};
sprintf(topic_path,"%s/%s",breaker_path,g_topic);
//init environment
create(zkhandle,breaker_path,0,"");
create(zkhandle,topic_path,0,"");
int i = 0;
for(i = 0; i < g_partition_num ; ++i){
sprintf(partition_path,"%s/Partition-%d",topic_path,i);
create(zkhandle,partition_path,0,"");
}
//send message by rand time
srand(time(NULL));
char msg_path[512] = {0};
for(i = 0; i < g_repeated_num; ++i){
sprintf(msg_path,"%s/Partition-%d/msg-",topic_path,i % g_partition_num);
// create seq msg node
create(zkhandle,msg_path,ZOO_SEQUENCE,g_msg);
int time = rand()%10;
printf("sleep time:%d\n",time);
sleep(time);
}
zookeeper_close(zkhandle);
return 0;
}
int main(int argc, char **argv) {
int nodeCount;
int cleaning=0;
if (argc < 4) {
usage(argv);
}
if(strcmp("clean",argv[3])==0){
cleaning=1;
}
zoo_set_debug_level(ZOO_LOG_LEVEL_INFO);
zoo_deterministic_conn_order(1); // enable deterministic order
zh = zookeeper_init(argv[1], listener, 10000, 0, 0, 0);
if (!zh)
return errno;
LOG_INFO(LOGSTREAM, "Checking server connection...");
ensureConnected();
if(cleaning==1){
int rc = 0;
deletedCounter=0;
rc=recursiveDelete(argv[2]);
if(rc==ZOK){
LOG_INFO(LOGSTREAM, "Successfully deleted a subtree starting at %s (%d nodes)",
argv[2],deletedCounter);
exit(0);
}
exit(1);
}
nodeCount=atoi(argv[3]);
createRoot(argv[2]);
while(1) {
ensureConnected();
LOG_INFO(LOGSTREAM, "Creating children for path %s",argv[2]);
doCreateNodes(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the write cycle for path %s",argv[2]);
doWrites(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the read cycle for path %s",argv[2]);
doReads(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the delete cycle for path %s",argv[2]);
doDeletes(argv[2],nodeCount);
waitCounter();
}
zookeeper_close(zh);
return 0;
}
void ZookeeperClient::Close()
{
if (NULL != m_zk)
{
if (-1 != m_zk_fd)
{
aeDeleteFileEvent(m_serv.GetRawEventLoop(), m_zk_fd,
AE_READABLE | AE_WRITABLE);
m_zk_fd = -1;
}
zookeeper_close(m_zk);
m_zk = NULL;
}
}
int main(int argc, char **argv) {
char buffer[512];
char p[2048];
char *cert=0;
char appId[64];
strcpy(appId, "example.foo_test");
cert = foo_get_cert_once(appId);
if(cert!=0) {
fprintf(stderr, "Certificate for appid [%s] is [%s]\n",appId,cert);
strncpy(p,cert, sizeof(p)-1);
free(cert);
} else {
fprintf(stderr, "Certificate for appid [%s] not found\n",appId);
strcpy(p, "dummy");
}
zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);
zh = zookeeper_init("localhost:2181", watcher, 10000, 0, 0, 0);
if (!zh) {
fprintf(stderr, "Error1: %s\n", strerror(errno));
return errno;
}
if (zoo_add_auth(zh, "foo", p, strlen(p), 0, 0) != ZOK) {
fprintf(stderr, "Error2: %s\n", strerror(errno));
return 2;
}
struct ACL CREATE_ONLY_ACL[] = {{ZOO_PERM_CREATE, ZOO_AUTH_IDS}};
struct ACL_vector CREATE_ONLY = {1, CREATE_ONLY_ACL};
int rc = zoo_create(zh, "/xyz", "value", 5, &CREATE_ONLY, ZOO_EPHEMERAL, (char*)&buffer, sizeof(buffer) - 1);
if (!rc) {
fprintf(stderr, "Error3: %s\n", strerror(errno));
return errno;
}
/** this operation will fail with a ZNOAUTH error */
int buflen= sizeof(buffer);
struct Stat stat;
rc = zoo_get(zh, "/xyz", 0, buffer, &buflen, &stat);
if (rc) {
fprintf(stderr, "Error4: %d for %s\n", rc, __LINE__);
} else {
fprintf(stdout, "Got %s\n", (char*)&buffer);
}
zookeeper_close(zh);
return 0;
}
void Cluster::OnInitWatcher(zhandle_t *zzh, int type, int state, const char *path)
{
INFO_LOG("Watcher %s state = %s for path %s", type2String(type), state2String(state), (path && strlen(path) > 0) ? path : "");
if (type == ZOO_SESSION_EVENT)
{
if (state == ZOO_CONNECTED_STATE)
{
const clientid_t *id = zoo_client_id(zzh);
if (m_zk_clientid.client_id == 0 || m_zk_clientid.client_id != id->client_id)
{
m_zk_clientid = *id;
INFO_LOG("Got a new session id: 0x%llx", (long long )m_zk_clientid.client_id);
if (!g_db->GetConf().zk_clientid_file.empty())
{
std::string content;
content.assign((const char*) (&m_zk_clientid), sizeof(m_zk_clientid));
file_write_content(g_db->GetConf().zk_clientid_file, content);
}
}
m_state = ZK_STATE_CONNECTED;
}
else if (state == ZOO_AUTH_FAILED_STATE)
{
WARN_LOG("Zookeeper server authentication failure. Shutting down...");
zookeeper_close(zzh);
m_zk = NULL;
m_state = ZK_STATE_DISCONNECT;
}
else if (state == ZOO_EXPIRED_SESSION_STATE)
{
WARN_LOG("Session expired. Shutting down...");
zookeeper_close(zzh);
m_zk = NULL;
m_state = ZK_STATE_DISCONNECT;
}
}
}
void watcher(zhandle_t *zzh, int type, int state, const char *path,
void *context)
{
/* quando um nó é deletado, verifica se é o nó cliente-1 (segundo cliente),
* se for, sai também */
if (type == ZOO_DELETED_EVENT && !strcmp(path, "/fase1/cliente-1")) {
fprintf(stdout, "cliente-1 desconectou, saindo...\n");
zookeeper_close(zh);
exit(EXIT_SUCCESS);
} else {
/* caso o nó deletado não seja o esperado, reativa o watcher */
zoo_exists(zh, "/fase1/cliente-1", 1, &stat);
}
return;
}
static void zookeeper_shutdown(grpc_exec_ctx *exec_ctx,
grpc_resolver *resolver) {
zookeeper_resolver *r = (zookeeper_resolver *)resolver;
grpc_closure *call = NULL;
gpr_mu_lock(&r->mu);
if (r->next_completion != NULL) {
*r->target_config = NULL;
call = r->next_completion;
r->next_completion = NULL;
}
zookeeper_close(r->zookeeper_handle);
gpr_mu_unlock(&r->mu);
if (call != NULL) {
call->cb(exec_ctx, call->cb_arg, 1);
}
}
static int destroy_zkrb_instance(struct zkrb_instance_data* ptr) {
int rv = ZOK;
if (ptr->zh) {
const void *ctx = zoo_get_context(ptr->zh);
/* Note that after zookeeper_close() returns, ZK handle is invalid */
rv = zookeeper_close(ptr->zh);
free((void *) ctx);
}
#warning [wickman] TODO: fire off warning if queue is not empty
if (ptr->queue) zkrb_queue_free(ptr->queue);
ptr->zh = NULL;
ptr->queue = NULL;
return rv;
}
int ZookeeperClient::Connect(const std::string& servers,
const ZKOptions& options)
{
if (NULL != m_zk)
{
zookeeper_close(m_zk);
m_zk = NULL;
}
m_zk = zookeeper_init(servers.c_str(), ZookeeperClient::WatchCallback,
options.recv_timeout, &options.clientid, this, 0);
if (NULL == m_zk)
{
ERROR_LOG("Failed to init zokkeeper.");
return -1;
}
m_callback = options.cb;
CheckConn();
return 0;
}
// TODO: factorize with the similar function in sqliterepo/synchro.h
static void
zk_main_watch(zhandle_t *zh, int type, int state, const char *path,
void *watcherCtx)
{
metautils_ignore_signals();
GRID_DEBUG("%s(%p,%d,%d,%s,%p)", __FUNCTION__,
zh, type, state, path, watcherCtx);
struct zk_manager_s *manager = watcherCtx;
const char *zkurl = manager->zk_url;
if (type != ZOO_SESSION_EVENT)
return;
if (state == ZOO_EXPIRED_SESSION_STATE) {
GRID_WARN("Zookeeper: (re)connecting to [%s]", zkurl);
if (manager->zh)
zookeeper_close(manager->zh);
/* XXX(jfs): forget the previous ID and reconnect */
manager->zh = zookeeper_init(manager->zk_url, zk_main_watch,
SQLX_SYNC_DEFAULT_ZK_TIMEOUT, NULL, manager, 0);
if (!manager->zh) {
GRID_ERROR("ZooKeeper init failure: (%d) %s",
errno, strerror(errno));
abort();
}
}
else if (state == ZOO_AUTH_FAILED_STATE) {
GRID_WARN("Zookeeper: auth problem to [%s]", zkurl);
}
else if (state == ZOO_ASSOCIATING_STATE) {
GRID_DEBUG("Zookeeper: associating to [%s]", zkurl);
}
else if (state == ZOO_CONNECTED_STATE) {
GRID_INFO("Zookeeper: connected to [%s]", zkurl);
}
else {
GRID_INFO("Zookeeper: unmanaged event [%s]", zkurl);
}
}
int main(int argc, char *argv[])
{
char server_address[256];
char ephemeral_path[256];
int rc;
/* verificação básica dos argumentos */
if (argc != 2) {
fprintf(stderr, "Uso: ./program <endereço do servidor>\n");
exit(EXIT_FAILURE);
}
/* Primeiro argumento é o endereço do servidor */
strcpy(server_address, argv[1]);
/* Inicializa a conexão com o servidor */
if ((zh = zookeeper_init(server_address, watcher, 10000, &myid, NULL, 0)) == NULL) {
fprintf(stderr, "Não foi possível conectar-se ao servidor %s\n", server_address);
exit(EXIT_FAILURE);
} else {
fprintf(stdout, "Conectado à %s\n", server_address);
}
fprintf(stdout, "Myid: %d\n", myid.client_id);
sprintf(ephemeral_path, "/fase1/cliente-%d", myid.client_id);
/* Cria um nó comum */
zoo_create(zh, "/fase1", NULL, 0, &ZOO_OPEN_ACL_UNSAFE, 0,
NULL, 0);
/* Cria um nó efêmero */
rc = zoo_create(zh, ephemeral_path, NULL, 0, &ZOO_OPEN_ACL_UNSAFE, ZOO_EPHEMERAL,
NULL, 0);
/* seta um watch em um arquivo criado por um processo diferente */
zoo_exists(zh, "/fase1/cliente-1", 1, &stat);
while(1) {
/* espera até que o watcher dispare */
}
/* não deve chegar aqui nunca */
zookeeper_close(zh);
return EXIT_SUCCESS;
}
