[sheepdog] [PATCH] multi-sheep cluster in one zookeeper cluster.

Yifeng Xu skypexu at gmail.com
Fri Feb 27 04:51:22 CET 2015


Is this patch really necessary ? I think zookeeper C client support
chroot, if you read zookeeper.c source code, you will find it,
here is some code quoted:

/**
 * Create a zookeeper handle associated with the given host and port.
 */
zhandle_t *zookeeper_init(const char *host, watcher_fn watcher,
  int recv_timeout, const clientid_t *clientid, void *context, int flags)
...
//parse the host to get the chroot if
    //available
    index_chroot = strchr(host, '/');
    if (index_chroot) {
        zh->chroot = strdup(index_chroot);
        if (zh->chroot == NULL) {
            goto abort;
        }



2015-02-27 11:41 GMT+08:00 Ruoyu <liangry at ucweb.com>:
>
> On 2015年02月26日 14:50, Yu Yang wrote:
>>
>> In order to distinguish different sheep cluster in one zookeeper, one more
>> level
>> directory is added in znode as domain. The same domain means the same
>> sheep cluster.
>
> The idea is not bad. But I have some questions. Please think about as below.
>>
>>
>> Signed-off-by: Yu Yang <yuyang at cmss.chinamobile.com>
>>
>>         modified:   sheep/cluster/zookeeper.c
>>         modified:   sheep/sheep.c
>> ---
>>   sheep/cluster/zookeeper.c |  192
>> ++++++++++++++++++++++++++++++++-------------
>>   sheep/sheep.c             |   10 ++-
>>   2 files changed, 143 insertions(+), 59 deletions(-)
>>
>> diff --git a/sheep/cluster/zookeeper.c b/sheep/cluster/zookeeper.c
>> index 3248af2..e492fde 100644
>> --- a/sheep/cluster/zookeeper.c
>> +++ b/sheep/cluster/zookeeper.c
>> @@ -26,15 +26,22 @@
>>   #include "rbtree.h"
>>     #define SESSION_TIMEOUT 30000               /* millisecond */
>> +#define SD_DEFAULT_DOMAIN "sd_domain_default"
>
> Is it the default domain name? Maybe it is too long. I think just 'default'
> is enough.
>
>> +
>> +static const char base_znode[] = "/sheepdog";
>> +static char queue_znode[MAX_NODE_STR_LEN] = "";
>> +static const char queue_znode_post[] = "/queue";
>> +static char member_znode[MAX_NODE_STR_LEN] = "";
>> +static const char member_znode_post[] = "/member";
>> +static char master_znode[MAX_NODE_STR_LEN] = "";
>> +static const char master_znode_post[] = "/master";
>> +static char lock_znode[MAX_NODE_STR_LEN] = "";
>> +static const char lock_znode_post[] = "/lock";
>>   -#define BASE_ZNODE "/sheepdog"
>> -#define QUEUE_ZNODE BASE_ZNODE "/queue"
>> -#define MEMBER_ZNODE BASE_ZNODE "/member"
>> -#define MASTER_ZNODE BASE_ZNODE "/master"
>> -#define LOCK_ZNODE BASE_ZNODE "/lock"
>>     static int zk_timeout = SESSION_TIMEOUT;
>>   static int my_master_seq;
>> +static char sd_domain[MAX_NODE_STR_LEN] = SD_DEFAULT_DOMAIN;
>>     /* structure for distributed lock */
>>   struct cluster_lock {
>> @@ -347,7 +354,7 @@ static struct cluster_lock
>> *lock_table_lookup_acquire(uint64_t lock_id)
>>                 ret_lock = xzalloc(sizeof(*ret_lock));
>>                 ret_lock->id = lock_id;
>>                 ret_lock->ref = 1;
>> -               snprintf(path, MAX_NODE_STR_LEN, LOCK_ZNODE "/%"PRIu64,
>> +               snprintf(path, MAX_NODE_STR_LEN, "%s/%"PRIu64, lock_znode,
>>                          ret_lock->id);
>>                 rc = zk_init_node(path);
>>                 if (rc)
>> @@ -399,8 +406,8 @@ static void lock_table_lookup_release(uint64_t
>> lock_id)
>>                         /* free all resource used by this lock */
>>                         sd_destroy_mutex(&lock->id_lock);
>>                         sem_destroy(&lock->wait_wakeup);
>> -                       snprintf(path, MAX_NODE_STR_LEN, LOCK_ZNODE
>> "/%"PRIu64,
>> -                                lock->id);
>> +                       snprintf(path, MAX_NODE_STR_LEN, "%s/%"PRIu64,
>> +                                lock_znode, lock->id);
>>                         /*
>>                          * If deletion of directory 'lock_id' fail, we
>> only get
>>                          * a * empty directory in zookeeper. That's
>> unharmful
>> @@ -458,7 +465,7 @@ static int zk_queue_peek(bool *peek)
>>         int rc;
>>         char path[MAX_NODE_STR_LEN];
>>   -     snprintf(path, sizeof(path), QUEUE_ZNODE "/%010"PRId32,
>> queue_pos);
>> +       snprintf(path, sizeof(path), "%s/%010"PRId32, queue_znode,
>> queue_pos);
>>         rc = zk_node_exists(path);
>>         switch (rc) {
>> @@ -483,7 +490,8 @@ static int zk_find_seq_node(uint64_t id, char
>> *seq_path, int seq_path_len,
>>         for (int seq = queue_pos; ; seq++) {
>>                 struct zk_event ev;
>>   -             snprintf(seq_path, seq_path_len, QUEUE_ZNODE"/%010"PRId32,
>> seq);
>> +               snprintf(seq_path, seq_path_len, "%s/%010"PRId32,
>> +                               queue_znode, seq);
>>                 len = offsetof(typeof(ev), id) + sizeof(ev.id);
>>                 rc = zk_get_data(seq_path, &ev, &len);
>>                 switch (rc) {
>> @@ -513,7 +521,7 @@ static int zk_queue_push(struct zk_event *ev)
>>         bool found;
>>         len = offsetof(typeof(*ev), buf) + ev->buf_len;
>> -       snprintf(path, sizeof(path), "%s/", QUEUE_ZNODE);
>> +       snprintf(path, sizeof(path), "%s/", queue_znode);
>>   again:
>>         rc = zk_create_seq_node(path, (char *)ev, len, buf, sizeof(buf),
>> false);
>>         switch (rc) {
>> @@ -537,7 +545,10 @@ again:
>>         if (first_push) {
>>                 int32_t seq;
>>   -             sscanf(buf, QUEUE_ZNODE "/%"PRId32, &seq);
>> +               char temp_char_form[MAX_NODE_STR_LEN] = "";
>> +               strcpy(temp_char_form, queue_znode);
>> +               strcat(temp_char_form, "/%"PRId32);
>
> If temp_char_form is not a pointer, could you please use snprintf instead of
> strcpy and strcat? So do others.
>
>> +               sscanf(buf, temp_char_form, &seq);
>>                 queue_pos = seq;
>>                 eventfd_xwrite(efd, 1);
>>                 first_push = false;
>> @@ -568,7 +579,7 @@ static int push_join_response(struct zk_event *ev)
>>         queue_pos--;
>>         len = offsetof(typeof(*ev), buf) + ev->buf_len;
>> -       snprintf(path, sizeof(path), QUEUE_ZNODE "/%010"PRId32,
>> queue_pos);
>> +       snprintf(path, sizeof(path), "%s/%010"PRId32, queue_znode,
>> queue_pos);
>>         RETURN_IF_ERROR(zk_set_data(path, (char *)ev, len, -1), "");
>>         sd_debug("update path:%s, queue_pos:%010" PRId32 ", len:%d", path,
>> @@ -582,7 +593,7 @@ static int zk_queue_pop_advance(struct zk_event *ev)
>>         char path[MAX_NODE_STR_LEN];
>>         len = sizeof(*ev);
>> -       snprintf(path, sizeof(path), QUEUE_ZNODE "/%010"PRId32,
>> queue_pos);
>> +       snprintf(path, sizeof(path), "%s/%010"PRId32, queue_znode,
>> queue_pos);
>>         RETURN_IF_ERROR(zk_get_data(path, ev, &len), "path %s", path);
>>         sd_debug("%s, type:%d, len:%d, pos:%" PRId32, path, ev->type, len,
>> @@ -641,10 +652,16 @@ static inline void build_node_list(void)
>>     static int zk_queue_init(void)
>>   {
>> -       RETURN_IF_ERROR(zk_init_node(BASE_ZNODE), "path %s", BASE_ZNODE);
>> -       RETURN_IF_ERROR(zk_init_node(MASTER_ZNODE), "path %s",
>> MASTER_ZNODE);
>> -       RETURN_IF_ERROR(zk_init_node(QUEUE_ZNODE), "path %s",
>> QUEUE_ZNODE);
>> -       RETURN_IF_ERROR(zk_init_node(MEMBER_ZNODE), "path %s",
>> MEMBER_ZNODE);
>> +       char sd_domain_znode[128] = "";
>> +       strcpy(sd_domain_znode, base_znode);
>> +       strcat(sd_domain_znode, "/");
>> +       strcat(sd_domain_znode, sd_domain);
>> +       RETURN_IF_ERROR(zk_init_node(base_znode), "path %s", base_znode);
>> +       RETURN_IF_ERROR(zk_init_node(sd_domain_znode),
>> +                                       "path %s", sd_domain_znode);
>> +       RETURN_IF_ERROR(zk_init_node(master_znode), "path %s",
>> master_znode);
>> +       RETURN_IF_ERROR(zk_init_node(queue_znode), "path %s",
>> queue_znode);
>> +       RETURN_IF_ERROR(zk_init_node(member_znode), "path %s",
>> member_znode);
>>         return ZOK;
>>   }
>>   @@ -692,6 +709,7 @@ static void zk_watcher(zhandle_t *zh, int type, int
>> state, const char *path,
>>         char str[MAX_NODE_STR_LEN], *p;
>>         uint64_t lock_id;
>>         int ret;
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         if (type == ZOO_SESSION_EVENT && state ==
>> ZOO_EXPIRED_SESSION_STATE) {
>>                 /*
>> @@ -705,7 +723,9 @@ static void zk_watcher(zhandle_t *zh, int type, int
>> state, const char *path,
>>   /* CREATED_EVENT 1, DELETED_EVENT 2, CHANGED_EVENT 3, CHILD_EVENT 4 */
>>         sd_debug("path:%s, type:%d, state:%d", path, type, state);
>>         if (type == ZOO_CREATED_EVENT || type == ZOO_CHANGED_EVENT) {
>> -               ret = sscanf(path, MEMBER_ZNODE "/%s", str);
>> +               strcpy(temp_char_form, member_znode);
>> +               strcat(temp_char_form, "/%s");
>> +               ret = sscanf(path, temp_char_form, str);
>>                 if (ret == 1)
>>                         zk_node_exists(path);
>>                 /* kick off the event handler */
>> @@ -714,7 +734,9 @@ static void zk_watcher(zhandle_t *zh, int type, int
>> state, const char *path,
>>                 struct zk_node *n;
>>                 /* process distributed lock */
>> -               ret = sscanf(path, LOCK_ZNODE "/%"PRIu64"/%s", &lock_id,
>> str);
>> +               strcpy(temp_char_form, lock_znode);
>> +               strcat(temp_char_form, "/%"PRIu64"/%s");
>> +               ret = sscanf(path, temp_char_form, &lock_id, str);
>>                 if (ret == 2) {
>>                         ret = lock_table_lookup_wakeup(lock_id);
>>                         if (ret)
>> @@ -723,13 +745,17 @@ static void zk_watcher(zhandle_t *zh, int type, int
>> state, const char *path,
>>                         return;
>>                 }
>>   -             ret = sscanf(path, MASTER_ZNODE "/%s", str);
>> +               strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/%s");
>> +               ret = sscanf(path, temp_char_form, str);
>>                 if (ret == 1) {
>>                         zk_compete_master();
>>                         return;
>>                 }
>>   -             ret = sscanf(path, MEMBER_ZNODE "/%s", str);
>> +               strcpy(temp_char_form, member_znode);
>> +               strcat(temp_char_form, "/%s");
>> +               ret = sscanf(path, temp_char_form, str);
>>                 if (ret != 1)
>>                         return;
>>                 p = strrchr(path, '/');
>> @@ -815,19 +841,23 @@ static int zk_find_master(int *master_seq, char
>> *master_name)
>>   {
>>         int rc, len = MAX_NODE_STR_LEN;
>>         char master_compete_path[MAX_NODE_STR_LEN];
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         if (*master_seq < 0) {
>> -               RETURN_IF_ERROR(zk_get_least_seq(MASTER_ZNODE,
>> +               RETURN_IF_ERROR(zk_get_least_seq(master_znode,
>>                                                  master_compete_path,
>>                                                  MAX_NODE_STR_LEN,
>> master_name,
>>                                                  &len), "");
>> -               sscanf(master_compete_path, MASTER_ZNODE "/%"PRId32,
>> -                      master_seq);
>> +               strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/%"PRId32);
>> +               sscanf(master_compete_path, temp_char_form, master_seq);
>>                 return ZOK;
>>         } else {
>>                 while (true) {
>> +                       strcpy(temp_char_form, master_znode);
>> +                       strcat(temp_char_form, "/%010"PRId32);
>>                         snprintf(master_compete_path, len,
>> -                                MASTER_ZNODE "/%010"PRId32, *master_seq);
>> +                                temp_char_form, *master_seq);
>>                         rc = zk_get_data(master_compete_path, master_name,
>>                                          &len);
>>                         switch (rc) {
>> @@ -854,10 +884,12 @@ static int zk_verify_last_sheep_join(int seq, int
>> *last_sheep)
>>   {
>>         int rc, len = MAX_NODE_STR_LEN;
>>         char path[MAX_NODE_STR_LEN], name[MAX_NODE_STR_LEN];
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         for (*last_sheep = seq - 1; *last_sheep >= 0; (*last_sheep)--) {
>> -               snprintf(path, MAX_NODE_STR_LEN, MASTER_ZNODE
>> "/%010"PRId32,
>> -                        *last_sheep);
>> +               strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/%010"PRId32);
>> +               snprintf(path, MAX_NODE_STR_LEN, temp_char_form,
>> *last_sheep);
>>                 rc = zk_get_data(path, name, &len);
>>                 switch (rc) {
>>                 case ZNONODE:
>> @@ -871,8 +903,9 @@ static int zk_verify_last_sheep_join(int seq, int
>> *last_sheep)
>>                 if (!strcmp(name, node_to_str(&this_node.node)))
>>                         continue;
>> -
>> -               snprintf(path, MAX_NODE_STR_LEN, MEMBER_ZNODE "/%s",
>> name);
>> +               strcpy(temp_char_form, member_znode);
>> +               strcat(temp_char_form, "/%s");
>> +               snprintf(path, MAX_NODE_STR_LEN, temp_char_form, name);
>>                 rc = zk_node_exists(path);
>>                 switch (rc) {
>>                 case ZOK:
>> @@ -909,23 +942,28 @@ static void zk_compete_master(void)
>>                 goto out_unlock;
>>         if (!joined) {
>> +               char temp_char_form[MAX_NODE_STR_LEN] = "";
>> +               strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/");
>>                 sd_debug("start to compete master for the first time");
>>                 do {
>>                         if (uatomic_is_true(&stop))
>>                                 goto out_unlock;
>>                         /* duplicate sequential node has no side-effect */
>> -                       rc = zk_create_seq_node(MASTER_ZNODE "/",
>> +                       rc = zk_create_seq_node(temp_char_form,
>>
>> node_to_str(&this_node.node),
>>                                                 MAX_NODE_STR_LEN,
>>                                                 my_compete_path,
>>                                                 MAX_NODE_STR_LEN, true);
>>                 } while (rc == ZOPERATIONTIMEOUT || rc ==
>> ZCONNECTIONLOSS);
>> -               CHECK_ZK_RC(rc, MASTER_ZNODE "/");
>> +               CHECK_ZK_RC(rc, temp_char_form);
>>                 if (rc != ZOK)
>>                         goto out_unlock;
>>   +             strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/%"PRId32);
>>                 sd_debug("my compete path: %s", my_compete_path);
>> -               sscanf(my_compete_path, MASTER_ZNODE "/%"PRId32,
>> +               sscanf(my_compete_path, temp_char_form,
>>                        &my_seq);
>>         }
>>   @@ -964,10 +1002,12 @@ static int zk_join(const struct sd_node *myself,
>>   {
>>         int rc;
>>         char path[MAX_NODE_STR_LEN];
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         this_node.node = *myself;
>> -
>> -       snprintf(path, sizeof(path), MEMBER_ZNODE "/%s",
>> node_to_str(myself));
>> +       strcpy(temp_char_form, member_znode);
>> +       strcat(temp_char_form, "/%s");
>> +       snprintf(path, sizeof(path), temp_char_form, node_to_str(myself));
>>         rc = zk_node_exists(path);
>>         if (rc == ZOK) {
>>                 sd_err("Previous zookeeper session exist, shoot myself.
>> Please "
>> @@ -985,17 +1025,21 @@ static int zk_join(const struct sd_node *myself,
>>   static int zk_leave(void)
>>   {
>>         char path[PATH_MAX];
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         sd_info("leaving from cluster");
>>         uatomic_set_true(&stop);
>>         if (uatomic_is_true(&is_master)) {
>> -               snprintf(path, sizeof(path), MASTER_ZNODE "/%010"PRId32,
>> -                               my_master_seq);
>> +               strcpy(temp_char_form, master_znode);
>> +               strcat(temp_char_form, "/%010"PRId32);
>> +               snprintf(path, sizeof(path), temp_char_form,
>> my_master_seq);
>>                 zk_delete_node(path, -1);
>>         }
>>   -     snprintf(path, sizeof(path), MEMBER_ZNODE"/%s",
>> +       strcpy(temp_char_form, member_znode);
>> +       strcat(temp_char_form, "/%s");
>> +       snprintf(path, sizeof(path), temp_char_form,
>>                  node_to_str(&this_node.node));
>>         add_event(EVENT_LEAVE, &this_node, NULL, 0);
>>         lock_table_remove_znodes();
>> @@ -1038,9 +1082,9 @@ static void watch_all_nodes(void)
>>         struct String_vector strs;
>>         char path[MAX_NODE_STR_LEN];
>>   -     RETURN_VOID_IF_ERROR(zk_get_children(MEMBER_ZNODE, &strs), "");
>> +       RETURN_VOID_IF_ERROR(zk_get_children(member_znode, &strs), "");
>>   -     FOR_EACH_ZNODE(MEMBER_ZNODE, path, &strs) {
>> +       FOR_EACH_ZNODE(member_znode, path, &strs) {
>>                 RETURN_VOID_IF_ERROR(zk_node_exists(path), "");
>>         }
>>   }
>> @@ -1066,6 +1110,7 @@ static void zk_handle_accept(struct zk_event *ev)
>>   {
>>         char path[MAX_NODE_STR_LEN];
>>         int rc;
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         sd_debug("ACCEPT");
>>         if (node_eq(&ev->sender.node, &this_node.node))
>> @@ -1074,7 +1119,9 @@ static void zk_handle_accept(struct zk_event *ev)
>>         sd_debug("%s", node_to_str(&ev->sender.node));
>>   -     snprintf(path, sizeof(path), MEMBER_ZNODE"/%s",
>> +       strcpy(temp_char_form, member_znode);
>> +       strcat(temp_char_form, "/%s");
>> +       snprintf(path, sizeof(path), temp_char_form,
>>                  node_to_str(&ev->sender.node));
>>         if (node_eq(&ev->sender.node, &this_node.node)) {
>>                 joined = true;
>> @@ -1286,18 +1333,22 @@ static void zk_lock(uint64_t lock_id)
>>         char lowest_seq_path[MAX_NODE_STR_LEN];
>>         char owner_name[MAX_NODE_STR_LEN];
>>         struct cluster_lock *cluster_lock;
>> +       char temp_char_form[MAX_NODE_STR_LEN] = "";
>>         cluster_lock = lock_table_lookup_acquire(lock_id);
>>         my_path = cluster_lock->lock_path;
>>   -     snprintf(parent, MAX_NODE_STR_LEN, LOCK_ZNODE "/%"PRIu64"/",
>> +       strcpy(temp_char_form, lock_znode);
>> +       strcat(temp_char_form, "/%"PRIu64"/");
>> +       snprintf(parent, MAX_NODE_STR_LEN, temp_char_form,
>>                  cluster_lock->id);
>>         /*
>>          * It need using path without end of '/' to create node of lock_id
>> in
>>          * zookeeper's API, so we use 'parent_node'.
>>          */
>> -       snprintf(parent_node, MAX_NODE_STR_LEN, LOCK_ZNODE "/%"PRIu64,
>> +       temp_char_form[strlen(temp_char_form)-1] = '\0';
>> +       snprintf(parent_node, MAX_NODE_STR_LEN, temp_char_form,
>>                  cluster_lock->id);
>>   create_seq_node:
>>         /* compete owner of lock is just like zk_compete_master() */
>> @@ -1359,7 +1410,8 @@ static void zk_unlock(uint64_t lock_id)
>>     static int zk_init(const char *option)
>>   {
>> -       char *hosts, *to, *p;
>> +       char hosts[MAX_NODE_STR_LEN];
>> +       const char *pt, *pd;
>>         int ret, interval, retry = 0, max_retry;
>>         if (!option) {
>> @@ -1367,17 +1419,29 @@ static int zk_init(const char *option)
>>                 return -1;
>>         }
>>   -     hosts = strtok((char *)option, "=");
>> -       if ((to = strtok(NULL, "="))) {
>> -               if (sscanf(to, "%u", &zk_timeout) != 1) {
>> -                       sd_err("Invalid parameter for timeout");
>> -                       return -1;
>> -               }
>> -               p = strstr(hosts, "timeout");
>> -               *--p = '\0';
>> +       pt = strstr(option, "timeout=");
>> +       pd = strstr(option, "domain=");
>> +       if (pt == NULL && pd == NULL) {
>> +               strcpy(hosts, option);
>> +       } else if (pt) {
>> +               int i = 0;
>> +               while (option != pt)
>> +                       hosts[i++] = *option++;
>> +               hosts[i-1] = '\0';
>> +               sscanf(pt, "timeout=%d", &zk_timeout);
>> +               if (pd)
>> +                       sscanf(pd, "domain=%s", sd_domain);
>> +       } else {
>> +               int i = 0;
>> +               while (option != pd)
>> +                       hosts[i++] = *option++;
>> +               hosts[i-1] = '\0';
>> +               sscanf(pd, "domain=%s", sd_domain);
>>         }
>> -       sd_debug("version %d.%d.%d, address %s, timeout %d",
>> ZOO_MAJOR_VERSION,
>> -                ZOO_MINOR_VERSION, ZOO_PATCH_VERSION, hosts, zk_timeout);
>> +
>> +       sd_debug("version %d.%d.%d, address %s, timeout %d, sheepdog
>> domain %s",
>> +                       ZOO_MAJOR_VERSION, ZOO_MINOR_VERSION,
>> ZOO_PATCH_VERSION,
>> +                       hosts, zk_timeout, sd_domain);
>>         zhandle = zookeeper_init(hosts, zk_watcher, zk_timeout, NULL,
>> NULL, 0);
>>         if (!zhandle) {
>>                 sd_err("failed to initialize zk server %s", option);
>> @@ -1398,6 +1462,18 @@ static int zk_init(const char *option)
>>         uatomic_set_false(&stop);
>>         uatomic_set_false(&is_master);
>> +       strcpy(master_znode, base_znode);
>> +       strcat(master_znode, "/");
>> +       strcat(master_znode, sd_domain);
>> +       strcat(master_znode, master_znode_post);
>> +       strcpy(queue_znode, base_znode);
>> +       strcat(queue_znode, "/");
>> +       strcat(queue_znode, sd_domain);
>> +       strcat(queue_znode, queue_znode_post);
>> +       strcpy(member_znode, base_znode);
>> +       strcat(member_znode, "/");
>> +       strcat(member_znode, sd_domain);
>> +       strcat(member_znode, member_znode_post);
>>         if (zk_queue_init() != ZOK)
>>                 return -1;
>>   @@ -1421,9 +1497,13 @@ static int zk_init(const char *option)
>>                 sd_init_mutex(table_locks + i);
>>         }
>>   -     ret = zk_init_node(LOCK_ZNODE);
>> +       strcpy(lock_znode, base_znode);
>> +       strcat(lock_znode, "/");
>> +       strcat(lock_znode, sd_domain);
>> +       strcat(lock_znode, lock_znode_post);
>> +       ret = zk_init_node(lock_znode);
>>         if (ret != ZOK) {
>> -               sd_err("Failed to create %s %s", LOCK_ZNODE, zerror(ret));
>> +               sd_err("Failed to create %s %s", lock_znode, zerror(ret));
>>                 free(cluster_locks_table);
>>                 return -1;
>>         }
>> diff --git a/sheep/sheep.c b/sheep/sheep.c
>> index 7d5fa0f..0cbe69b 100644
>> --- a/sheep/sheep.c
>> +++ b/sheep/sheep.c
>> @@ -68,12 +68,16 @@ static const char cluster_help[] =
>>   "\tlocal: use local driver\n"
>>   "\tcorosync: use corosync driver\n"
>>   "\tzookeeper: use zookeeper driver, need extra arguments\n"
>> -"\n\tzookeeper arguments: address-list,timeout=value (default as 3000)\n"
>> +"\n\tzookeeper arguments: address-list,timeout=value(default as 3000)"
>> +",domain=value(default as sd_domain_default)\n"
>>   "\nExample:\n\t"
>> -"$ sheep -c zookeeper:IP1:PORT1,IP2:PORT2,IP3:PORT3,timeout=1000 ...\n"
>> +"$ sheep -c
>> zookeeper:IP1:PORT1,IP2:PORT2,IP3:PORT3,timeout=1000,domain=sheep_01 ...\n"
>>   "This tries to use 3 node zookeeper cluster, which can be reached by\n"
>>   "IP1:PORT1, IP2:PORT2, IP3:PORT3 to manage membership and broadcast
>> message\n"
>> -"and set the timeout of node heartbeat as 1000 milliseconds\n";
>> +"and set the timeout of node heartbeat as 1000 milliseconds\n"
>> +"and join the domain sheep_01.\n"
>> +"Notice that timeout should be followed by domain "
>> +"if both are given explicitly.\n";
>
> Why the constraint is needed? Is it possible to parse domain field and
> timeout field in random order?
>>
>>     static const char cache_help[] =
>>   "Available arguments:\n"
>
>
>
> --
> sheepdog mailing list
> sheepdog at lists.wpkg.org
> https://lists.wpkg.org/mailman/listinfo/sheepdog



More information about the sheepdog mailing list