zookeeper-ng 1.5.2.1-java

data/ext/patches/zkc-3.4.5-fetch-and-add.patch

@@ -0,0 +1,16 @@
+diff -ur zkc-3.4.5-orig/c/src/mt_adaptor.c zkc-3.4.5/c/src/mt_adaptor.c
+--- zkc-3.4.5-orig/c/src/mt_adaptor.c	2012-09-30 10:53:32.000000000 -0700
++++ zkc-3.4.5/c/src/mt_adaptor.c	2016-09-07 16:55:13.787553837 -0700
+@@ -484,11 +484,7 @@
+ {
+ #ifndef WIN32
+     int32_t result;
+-    asm __volatile__(
+-         "lock xaddl %0,%1\n"
+-         : "=r"(result), "=m"(*(int *)operand)
+-         : "0"(incr)
+-         : "memory");
++    result = __sync_fetch_and_add(operand, incr);
+    return result;
+ #else
+     volatile int32_t result;

data/ext/patches/zkc-3.4.5-logging.patch

@@ -0,0 +1,41 @@
+diff -ur zkc-3.4.5-orig/c/src/zookeeper.c zkc-3.4.5/c/src/zookeeper.c
+--- zkc-3.4.5-orig/c/src/zookeeper.c	2012-09-30 10:53:32.000000000 -0700
++++ zkc-3.4.5/c/src/zookeeper.c	2013-09-07 21:25:24.000000000 -0700
+@@ -1650,14 +1650,16 @@
+         // a PING
+         if (zh->state==ZOO_CONNECTED_STATE) {
+             send_to = zh->recv_timeout/3 - idle_send;
+-            if (send_to <= 0 && zh->sent_requests.head==0) {
+-//                LOG_DEBUG(("Sending PING to %s (exceeded idle by %dms)",
+-//                                format_current_endpoint_info(zh),-send_to));
+-                int rc=send_ping(zh);
+-                if (rc < 0){
+-                    LOG_ERROR(("failed to send PING request (zk retcode=%d)",rc));
+-                    return api_epilog(zh,rc);
+-                }
++            if (send_to <= 0) {
++                if (zh->sent_requests.head==0) {
++                    LOG_DEBUG(("Sending PING to %s (exceeded idle by %dms)",
++                                   format_current_endpoint_info(zh),-send_to));
++                    int rc=send_ping(zh);
++                    if (rc < 0){
++                        LOG_ERROR(("failed to send PING request (zk retcode=%d)",rc));
++                        return api_epilog(zh,rc);
++                    }
++                }
+                 send_to = zh->recv_timeout/3;
+             }
+         }
+@@ -1669,6 +1671,12 @@
+             zh->next_deadline.tv_sec += zh->next_deadline.tv_usec / 1000000;
+             zh->next_deadline.tv_usec = zh->next_deadline.tv_usec % 1000000;
+         }
++        
++        if (tv->tv_sec == 0 && tv->tv_usec == 0) {
++          LOG_DEBUG(("Returning a 0.0 timeval: state=%d idle_recv=%d idle_send=%d recv_to=%d send_to=%d  send_requests=%s",
++            zh->state, idle_recv, idle_send, recv_to, send_to, zh->sent_requests.head==0 ? "false" : "true"));
++        }
++        
+         *interest = ZOOKEEPER_READ;
+         /* we are interested in a write if we are connected and have something
+          * to send, or we are waiting for a connect to finish. */

data/ext/patches/zkc-3.4.5-out-of-order-ping.patch

@@ -0,0 +1,163 @@
+diff --git zkc-3.4.5-orig/c/src/zookeeper.c zkc-3.4.5/c/src/zookeeper.c
+index de58c62..2347ff4 100644
+--- zkc-3.4.5-orig/c/src/zookeeper.c
++++ zkc-3.4.5/c/src/zookeeper.c
+@@ -1167,25 +1167,20 @@ void free_completions(zhandle_t *zh,int callCompletion,int reason)
+             zh->outstanding_sync--;
+             destroy_completion_entry(cptr);
+         } else if (callCompletion) {
+-            if(cptr->xid == PING_XID){
+-                // Nothing to do with a ping response
+-                destroy_completion_entry(cptr);
+-            } else {
+-                // Fake the response
+-                buffer_list_t *bptr;
+-                h.xid = cptr->xid;
+-                h.zxid = -1;
+-                h.err = reason;
+-                oa = create_buffer_oarchive();
+-                serialize_ReplyHeader(oa, "header", &h);
+-                bptr = calloc(sizeof(*bptr), 1);
+-                assert(bptr);
+-                bptr->len = get_buffer_len(oa);
+-                bptr->buffer = get_buffer(oa);
+-                close_buffer_oarchive(&oa, 0);
+-                cptr->buffer = bptr;
+-                queue_completion(&zh->completions_to_process, cptr, 0);
+-            }
++            // Fake the response
++            buffer_list_t *bptr;
++            h.xid = cptr->xid;
++            h.zxid = -1;
++            h.err = reason;
++            oa = create_buffer_oarchive();
++            serialize_ReplyHeader(oa, "header", &h);
++            bptr = calloc(sizeof(*bptr), 1);
++            assert(bptr);
++            bptr->len = get_buffer_len(oa);
++            bptr->buffer = get_buffer(oa);
++            close_buffer_oarchive(&oa, 0);
++            cptr->buffer = bptr;
++            queue_completion(&zh->completions_to_process, cptr, 0);
+         }
+     }
+     a_list.completion = NULL;
+@@ -1526,7 +1521,6 @@ static struct timeval get_timeval(int interval)
+     rc = serialize_RequestHeader(oa, "header", &h);
+     enter_critical(zh);
+     gettimeofday(&zh->last_ping, 0);
+-    rc = rc < 0 ? rc : add_void_completion(zh, h.xid, 0, 0);
+     rc = rc < 0 ? rc : queue_buffer_bytes(&zh->to_send, get_buffer(oa),
+             get_buffer_len(oa));
+     leave_critical(zh);
+@@ -2063,12 +2057,8 @@ static void deserialize_response(int type, int xid, int failed, int rc, completi
+     case COMPLETION_VOID:
+         LOG_DEBUG(("Calling COMPLETION_VOID for xid=%#x failed=%d rc=%d",
+                     cptr->xid, failed, rc));
+-        if (xid == PING_XID) {
+-            // We want to skip the ping
+-        } else {
+-            assert(cptr->c.void_result);
+-            cptr->c.void_result(rc, cptr->data);
+-        }
++        assert(cptr->c.void_result);
++        cptr->c.void_result(rc, cptr->data);
+         break;
+     case COMPLETION_MULTI:
+         LOG_DEBUG(("Calling COMPLETION_MULTI for xid=%#x failed=%d rc=%d",
+@@ -2184,7 +2174,15 @@ int zookeeper_process(zhandle_t *zh, int events)
+             // fprintf(stderr, "Got %#x for %#x\n", hdr.zxid, hdr.xid);
+         }
+ 
+-        if (hdr.xid == WATCHER_EVENT_XID) {
++        if (hdr.xid == PING_XID) {
++            // Ping replies can arrive out-of-order
++            int elapsed = 0;
++            struct timeval now;
++            gettimeofday(&now, 0);
++            elapsed = calculate_interval(&zh->last_ping, &now);
++            LOG_DEBUG(("Got ping response in %d ms", elapsed));
++            free_buffer(bptr);
++        } else if (hdr.xid == WATCHER_EVENT_XID) {
+             struct WatcherEvent evt;
+             int type = 0;
+             char *path = NULL;
+@@ -2250,22 +2248,9 @@ int zookeeper_process(zhandle_t *zh, int events)
+             activateWatcher(zh, cptr->watcher, rc);
+ 
+             if (cptr->c.void_result != SYNCHRONOUS_MARKER) {
+-                if(hdr.xid == PING_XID){
+-                    int elapsed = 0;
+-                    struct timeval now;
+-                    gettimeofday(&now, 0);
+-                    elapsed = calculate_interval(&zh->last_ping, &now);
+-                    LOG_DEBUG(("Got ping response in %d ms", elapsed));
+-
+-                    // Nothing to do with a ping response
+-                    free_buffer(bptr);
+-                    destroy_completion_entry(cptr);
+-                } else {
+-                    LOG_DEBUG(("Queueing asynchronous response"));
+-
+-                    cptr->buffer = bptr;
+-                    queue_completion(&zh->completions_to_process, cptr, 0);
+-                }
++                LOG_DEBUG(("Queueing asynchronous response"));
++                cptr->buffer = bptr;
++                queue_completion(&zh->completions_to_process, cptr, 0);
+             } else {
+                 struct sync_completion
+                         *sc = (struct sync_completion*)cptr->data;
+diff --git zkc-3.4.5-orig/c/tests/TestOperations.cc zkc-3.4.5/c/tests/TestOperations.cc
+index b0370e9..27d9270 100644
+--- zkc-3.4.5-orig/c/tests/TestOperations.cc
++++ zkc-3.4.5/c/tests/TestOperations.cc
+@@ -29,6 +29,7 @@ class Zookeeper_operations : public CPPUNIT_NS::TestFixture
+     CPPUNIT_TEST_SUITE(Zookeeper_operations);
+ #ifndef THREADED
+     CPPUNIT_TEST(testPing);
++    CPPUNIT_TEST(testUnsolicitedPing);
+     CPPUNIT_TEST(testTimeoutCausedByWatches1);
+     CPPUNIT_TEST(testTimeoutCausedByWatches2);
+ #else    
+@@ -305,6 +306,40 @@ public:
+         CPPUNIT_ASSERT_EQUAL(1,zkServer.pingCount_);
+     }
+ 
++    // ZOOKEEPER-2253: Permit unsolicited pings
++    void testUnsolicitedPing()
++    {
++        const int TIMEOUT=9; // timeout in secs
++        Mock_gettimeofday timeMock;
++        PingCountingServer zkServer;
++        // must call zookeeper_close() while all the mocks are in scope
++        CloseFinally guard(&zh);
++
++        // receive timeout is in milliseconds
++        zh=zookeeper_init("localhost:1234",watcher,TIMEOUT*1000,TEST_CLIENT_ID,0,0);
++        CPPUNIT_ASSERT(zh!=0);
++        // simulate connected state
++        forceConnected(zh);
++
++        int fd=0;
++        int interest=0;
++        timeval tv;
++
++        int rc=zookeeper_interest(zh,&fd,&interest,&tv);
++        CPPUNIT_ASSERT_EQUAL((int)ZOK,rc);
++
++        // verify no ping sent
++        CPPUNIT_ASSERT(zkServer.pingCount_==0);
++
++        // we're going to receive a unsolicited PING response; ensure
++        // that the client has updated its last_recv timestamp
++        timeMock.tick(tv);
++        zkServer.addRecvResponse(new PingResponse);
++        rc=zookeeper_process(zh,interest);
++        CPPUNIT_ASSERT_EQUAL((int)ZOK,rc);
++        CPPUNIT_ASSERT(timeMock==zh->last_recv);
++    }
++
+     // simulate a watch arriving right before a ping is due
+     // assert the ping is sent nevertheless
+     void testTimeoutCausedByWatches1()

data/ext/patches/zkc-3.4.5-yosemite-htonl-fix.patch

@@ -0,0 +1,102 @@
+diff -ur zkc-3.4.5-orig/c/include/recordio.h zkc-3.4.5/c/include/recordio.h
+--- zkc-3.4.5-orig/c/include/recordio.h	2012-09-30 13:53:32.000000000 -0400
++++ zkc-3.4.5/c/include/recordio.h	2014-07-29 03:13:27.000000000 -0400
+@@ -73,7 +73,7 @@
+ char *get_buffer(struct oarchive *);
+ int get_buffer_len(struct oarchive *);
+ 
+-int64_t htonll(int64_t v);
++int64_t zk_htonll(int64_t v);
+ 
+ #ifdef __cplusplus
+ }
+diff -ur zkc-3.4.5-orig/c/src/recordio.c zkc-3.4.5/c/src/recordio.c
+--- zkc-3.4.5-orig/c/src/recordio.c	2012-09-30 13:53:32.000000000 -0400
++++ zkc-3.4.5/c/src/recordio.c	2014-07-29 03:13:35.000000000 -0400
+@@ -80,7 +80,7 @@
+     priv->off+=sizeof(i);
+     return 0;
+ }
+-int64_t htonll(int64_t v)
++int64_t zk_htonll(int64_t v)
+ {
+     int i = 0;
+     char *s = (char *)&v;
+@@ -98,7 +98,7 @@
+ 
+ int oa_serialize_long(struct oarchive *oa, const char *tag, const int64_t *d)
+ {
+-    const int64_t i = htonll(*d);
++    const int64_t i = zk_htonll(*d);
+     struct buff_struct *priv = oa->priv;
+     if ((priv->len - priv->off) < sizeof(i)) {
+         int rc = resize_buffer(priv, priv->len + sizeof(i));
+@@ -207,7 +207,7 @@
+     }
+     memcpy(count, priv->buffer+priv->off, sizeof(*count));
+     priv->off+=sizeof(*count);
+-    v = htonll(*count); // htonll and  ntohll do the same
++    v = zk_htonll(*count); // zk_htonll and  ntohll do the same
+     *count = v;
+     return 0;
+ }
+diff -ur zkc-3.4.5-orig/c/src/zookeeper.c zkc-3.4.5/c/src/zookeeper.c
+--- zkc-3.4.5-orig/c/src/zookeeper.c	2012-09-30 13:53:32.000000000 -0400
++++ zkc-3.4.5/c/src/zookeeper.c	2014-07-29 03:13:45.000000000 -0400
+@@ -1408,7 +1408,7 @@
+     memcpy(buffer + offset, &req->protocolVersion, sizeof(req->protocolVersion));
+     offset = offset +  sizeof(req->protocolVersion);
+ 
+-    req->lastZxidSeen = htonll(req->lastZxidSeen);
++    req->lastZxidSeen = zk_htonll(req->lastZxidSeen);
+     memcpy(buffer + offset, &req->lastZxidSeen, sizeof(req->lastZxidSeen));
+     offset = offset +  sizeof(req->lastZxidSeen);
+ 
+@@ -1416,7 +1416,7 @@
+     memcpy(buffer + offset, &req->timeOut, sizeof(req->timeOut));
+     offset = offset +  sizeof(req->timeOut);
+ 
+-    req->sessionId = htonll(req->sessionId);
++    req->sessionId = zk_htonll(req->sessionId);
+     memcpy(buffer + offset, &req->sessionId, sizeof(req->sessionId));
+     offset = offset +  sizeof(req->sessionId);
+ 
+@@ -1447,7 +1447,7 @@
+      memcpy(&req->sessionId, buffer + offset, sizeof(req->sessionId));
+      offset = offset +  sizeof(req->sessionId);
+ 
+-     req->sessionId = htonll(req->sessionId);
++     req->sessionId = zk_htonll(req->sessionId);
+      memcpy(&req->passwd_len, buffer + offset, sizeof(req->passwd_len));
+      offset = offset +  sizeof(req->passwd_len);
+ 
+diff -ur zkc-3.4.5-orig/c/tests/ZKMocks.cc zkc-3.4.5/c/tests/ZKMocks.cc
+--- zkc-3.4.5-orig/c/tests/ZKMocks.cc	2012-09-30 13:53:32.000000000 -0400
++++ zkc-3.4.5/c/tests/ZKMocks.cc	2014-07-29 03:13:59.000000000 -0400
+@@ -41,7 +41,7 @@
+     int offset=sizeof(req->protocolVersion);
+     
+     memcpy(&req->lastZxidSeen,buf.data()+offset,sizeof(req->lastZxidSeen));
+-    req->lastZxidSeen = htonll(req->lastZxidSeen);
++    req->lastZxidSeen = zk_htonll(req->lastZxidSeen);
+     offset+=sizeof(req->lastZxidSeen);
+     
+     memcpy(&req->timeOut,buf.data()+offset,sizeof(req->timeOut));
+@@ -49,7 +49,7 @@
+     offset+=sizeof(req->timeOut);
+     
+     memcpy(&req->sessionId,buf.data()+offset,sizeof(req->sessionId));
+-    req->sessionId = htonll(req->sessionId);
++    req->sessionId = zk_htonll(req->sessionId);
+     offset+=sizeof(req->sessionId);
+     
+     memcpy(&req->passwd_len,buf.data()+offset,sizeof(req->passwd_len));
+@@ -322,7 +322,7 @@
+     buf.append((char*)&tmp,sizeof(tmp));
+     tmp=htonl(timeOut);
+     buf.append((char*)&tmp,sizeof(tmp));
+-    int64_t tmp64=htonll(sessionId);
++    int64_t tmp64=zk_htonll(sessionId);
+     buf.append((char*)&tmp64,sizeof(sessionId));
+     tmp=htonl(passwd_len);
+     buf.append((char*)&tmp,sizeof(tmp));