andreiz / php-zookeeper / 10

pending completion

Build # 10

Build Type

Pull #68

travis-ci

Committed by

jbboehr

Commit Message

<a href="https://github.com/andreiz/php-zookeeper/commit/<a class=hub.com/andreiz/php-zookeeper/commit/42ca280219ee080135d72eb6efeadd80c76bd8b9">42ca28021<a href="https://github.com/andreiz/php-zookeeper/commit/42ca280219ee080135d72eb6efeadd80c76bd8b9">&quot;&gt;Fixes for PHP7

- Fix leak in </a><a class="double-link" href="https://github.com/andreiz/php-zookeeper/commit/<a class="double-link" href="https://github.com/andreiz/php-zookeeper/commit/18ea003219582b4a2a7a9e0b05c0d1bd663f8de8">18ea00321</a>">18ea00321</a><a href="https://github.com/andreiz/php-zookeeper/commit/42ca280219ee080135d72eb6efeadd80c76bd8b9">
- Add missing session test case

Pull Request Pull Request #68: PHP7 support

Run Details

131 of 131 new or added lines in 2 files covered. (100.0%)

804 of 1032 relevant lines covered (77.91%)

295.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.14

/php_zookeeper_session.c

/*
  +----------------------------------------------------------------------+
  | Copyright (c) 2010 The PHP Group                                     |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt.                                 |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Authors: Andrei Zmievski <andrei@php.net>                            |
  |          Mikko Koppanen <mkoppanen@php.net>                          |
  +----------------------------------------------------------------------+
*/

#include "php_zookeeper.h"
#include "php_zookeeper_private.h"
#include "php_zookeeper_session.h"
#include "SAPI.h"

#ifdef HAVE_ZOOKEEPER_SESSION

#define ZK_SESS_DATA php_zookeeper_session *session = PS_GET_MOD_DATA();

#define PHP_ZK_PARENT_NODE "/php-sessid"

#define PHP_ZK_SESS_DEFAULT_LOCK_WAIT 150000

#define PHP_ZK_SESS_LOCK_EXPIRATION 30

#ifndef ZEND_ENGINE_3
typedef zend_rsrc_list_entry zend_resource;
static inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, size_t len, void *pData, size_t size)
{
        void *pDest;
        if (zend_hash_update(ht, str, len, pData, size, &pDest) == FAILURE) {
                return NULL;
        }
        return pDest;
}
static inline void *zend_hash_str_find_ptr(const HashTable *ht, const char *str, size_t len)
{
        void *pData;
        if (zend_hash_find(ht, str, len, &pData) == FAILURE) {
                return NULL;
        }
        return pData;
}
#endif

ps_module ps_mod_zookeeper = {
        PS_MOD(zookeeper)
};

/* {{{ static php_zookeeper_session *php_zookeeper_session_init(char *save_path TSRMLS_DC)
        Initialize the session
*/
static php_zookeeper_session *php_zookeeper_session_init(char *save_path TSRMLS_DC)
{
        struct Stat stat;

        int status, recv_timeout = ZK_G(recv_timeout);
        php_zookeeper_session *session;

        session     = pecalloc(1, sizeof(php_zookeeper_session), 1);
        session->zk = zookeeper_init(save_path, NULL, recv_timeout, 0, NULL, 0);

        if (!session->zk) {
                efree(session);
                return NULL;
        }

        /* Create parent node if it does not exist */
        if (zoo_exists(session->zk, PHP_ZK_PARENT_NODE, 1, &stat) == ZNONODE) {
                int retry_count = 3;
                do {
                        status = zoo_create(session->zk, PHP_ZK_PARENT_NODE, 0, 0, &ZOO_OPEN_ACL_UNSAFE, 0, 0, 0);
                        retry_count++;
                } while (status == ZCONNECTIONLOSS && retry_count--);

                if (status != ZOK) {
                        zookeeper_close(session->zk);
                        efree(session);
                        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to create parent node for sessions");
                }
        }
        return session;
}
/* }}} */

/* {{{ static php_zookeeper_session *php_zookeeper_session_get(char *save_path TSRMLS_DC)
        Get a connection. If connection does not exist in persistent list allocates a new one
*/
static php_zookeeper_session *php_zookeeper_session_get(char *save_path TSRMLS_DC)
{
        php_zookeeper_session *session = NULL;

        char *plist_key;
        int plist_key_len;
        zend_resource le, *le_p = NULL;

        plist_key_len  = spprintf(&plist_key, 0, "zk-conn:[%s]", save_path);
#ifndef ZEND_ENGINE_3
        plist_key_len += 1;
#endif

        le_p = zend_hash_str_find_ptr(&EG(persistent_list), plist_key, plist_key_len);
        if (le_p) {
                if (le_p->type == php_zookeeper_get_connection_le()) {
                        efree(plist_key);
                        return (php_zookeeper_session *) le_p->ptr;
                }
        }

        session = php_zookeeper_session_init(save_path TSRMLS_CC);
        le.type = php_zookeeper_get_connection_le();
        le.ptr  = session;

        if (!zend_hash_str_update_mem(&EG(persistent_list), (char *)plist_key, plist_key_len, (void *)&le, sizeof(le))) {
                php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not register persistent entry for the zk handle");
        }

        efree(plist_key);
        session->is_locked = 0;

        return session;
}
/* }}} */

/* {{{ PS_OPEN_FUNC(zookeeper)
*/
PS_OPEN_FUNC(zookeeper)
{
        php_zookeeper_session *session = php_zookeeper_session_get(PS(save_path) TSRMLS_CC);

        if (!session) {
                PS_SET_MOD_DATA(NULL);
                return FAILURE;
        }
        PS_SET_MOD_DATA(session);
        return SUCCESS;
}
/* }}} */

/* {{{ static int php_zookeeper_sess_lock(php_zookeeper_session *session, const char *key TSRMLS_DC)
        Locking functionality. Adapted algo from memcached extension
*/
static zend_bool php_zookeeper_sess_lock(php_zookeeper_session *session, const char *key TSRMLS_DC)
{
        char *lock_path;
        int lock_path_len;
        long attempts, lock_maxwait;
        long lock_wait = ZK_G(sess_lock_wait);
        time_t expiration;

        /* lock_path if freed when the lock is freed */
        lock_path_len = spprintf(&lock_path, 512 + 5, "%s/%s-lock", PHP_ZK_PARENT_NODE, key);

        if (zkr_lock_init(&(session->lock), session->zk, lock_path, &ZOO_OPEN_ACL_UNSAFE) != 0) {
                efree(lock_path);
                return 0;
        }

        /* set max timeout for session_start = max_execution_time.  (c) Andrei Darashenka, Richter & Poweleit GmbH */
        lock_maxwait = zend_ini_long(ZEND_STRS("max_execution_time"), 0);
        if (lock_maxwait <= 0) {
                lock_maxwait = PHP_ZK_SESS_LOCK_EXPIRATION;
        }
        if (lock_wait == 0) {
                lock_wait = PHP_ZK_SESS_DEFAULT_LOCK_WAIT;
        }
        expiration = SG(global_request_time) + lock_maxwait + 1;
        attempts   = lock_maxwait * 1000000 / lock_wait;

        do {
                if (zkr_lock_lock(&(session->lock))) {
                        session->is_locked = 1;
                        return 1;
                }
                if (lock_wait > 0) {
                        usleep(lock_wait);
                }
        } while(--attempts > 0);

        return 0;
}

/* {{{ PS_READ_FUNC(zookeeper)
*/
PS_READ_FUNC(zookeeper)
{
#ifdef ZEND_ENGINE_3
#define SESSKEY ZSTR_VAL(key)
#else
#define SESSKEY key
#endif
        ZK_SESS_DATA;
        int status, path_len;
        struct Stat stat;
        int retry_count;
        int64_t expiration_time;
        char * rbuf;
        int rbuf_len;

        if (ZK_G(session_lock)) {
                if (!php_zookeeper_sess_lock(session, SESSKEY TSRMLS_CC)) {
                        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to create session mutex");
                        return FAILURE;
                }
        }

        path_len = snprintf(session->path, 512, "%s/%s", PHP_ZK_PARENT_NODE, SESSKEY);

        retry_count = 3;
        do {
                status = zoo_exists(session->zk, session->path, 1, &stat);
                retry_count++;
        } while (status == ZCONNECTIONLOSS && retry_count--);

        if (status != ZOK) {
                goto error;
        }

        expiration_time = (int64_t) (SG(global_request_time) - PS(gc_maxlifetime)) * 1000;

        /* The session has expired */
        if (stat.mtime < expiration_time) {
                retry_count = 3;
                do {
                        status = zoo_delete(session->zk, session->path, -1);
                        retry_count++;
                } while (status == ZCONNECTIONLOSS && retry_count--);
                goto error;
        }

        rbuf    = emalloc(stat.dataLength);
        rbuf_len = stat.dataLength;

        retry_count = 3;
        do {
                status = zoo_get(session->zk, session->path, 0, rbuf, &rbuf_len, &stat);
                retry_count++;
        } while (status == ZCONNECTIONLOSS && retry_count--);

        if (status != ZOK) {
                efree(rbuf);
                goto error;
        }

#ifdef ZEND_ENGINE_3
        *val = zend_string_init(rbuf, rbuf_len, 0);
        efree(rbuf);
#else
        *val = rbuf;
        *vallen = rbuf_len;
#endif

        return SUCCESS;
error:
#ifdef ZEND_ENGINE_3
        *val = ZSTR_EMPTY_ALLOC();
#else
        *val    = NULL;
        *vallen = 0;
#endif
        return FAILURE;
#undef SESSKEY
}
/* }}} */

/* {{{ PS_WRITE_FUNC(zookeeper)
*/
PS_WRITE_FUNC(zookeeper)
{
#ifdef ZEND_ENGINE_3
#define WBUF ZSTR_VAL(val)
#define WBUFLEN ZSTR_LEN(val)
#else
#define WBUF val
#define WBUFLEN vallen
#endif

        ZK_SESS_DATA;
        int status, retry_count;
        struct Stat stat;

        retry_count = 3;
        do {
                status = zoo_exists(session->zk, session->path, 1, &stat);
                retry_count++;
        } while (status == ZCONNECTIONLOSS && retry_count--);

        retry_count = 3;
        do {
                if (status != ZOK) {
                        status = zoo_create(session->zk, session->path, WBUF, WBUFLEN, &ZOO_OPEN_ACL_UNSAFE, 0, 0, 0);
                } else {
                        status = zoo_set(session->zk, session->path, WBUF, WBUFLEN, -1);
                }
                retry_count++;
        } while (status == ZCONNECTIONLOSS && retry_count--);


        return (status == ZOK) ? SUCCESS : FAILURE;

#undef WBUF
#undef WBUFLEN
}
/* }}} */

PS_DESTROY_FUNC(zookeeper)
{
        ZK_SESS_DATA;
        int status, retry_count;

        retry_count = 3;
        do {
                status = zoo_delete(session->zk, session->path, -1);
                retry_count++;
        } while (status == ZCONNECTIONLOSS && retry_count--);

        return (status == ZOK) ? SUCCESS : FAILURE;
}

PS_GC_FUNC(zookeeper)
{
        struct Stat stat;
        struct String_vector nodes;
        int i, status;
        int64_t expiration_time;
        ZK_SESS_DATA;

        expiration_time = (int64_t) (SG(global_request_time) - PS(gc_maxlifetime)) * 1000;
        status          = zoo_get_children(session->zk, PHP_ZK_PARENT_NODE, 0, &nodes);

        if (status == ZOK) {
                for (i = 0; i < nodes.count; i++) {
                        char path[512];
                        int path_len;

                        path_len = snprintf(path, 512, "%s/%s", PHP_ZK_PARENT_NODE, nodes.data[i]);

                        if (zoo_exists(session->zk, path, 1, &stat) == ZOK) {
                                /* TODO: should lock here? */
                                if (stat.mtime < expiration_time) {
                                        (void) zoo_delete(session->zk, path, -1);
                                }
                        }
                }
        }
        return SUCCESS;
}

static void php_zk_sync_completion(int rc, const char *value, const void *data) {}

PS_CLOSE_FUNC(zookeeper)
{
        ZK_SESS_DATA;

        if (session->is_locked) {
                (void) zkr_lock_unlock(&(session->lock));
                efree(session->lock.path);

                zkr_lock_destroy(&(session->lock));
                session->is_locked = 0;
        }

        /* TODO: is this needed? */
        // zoo_async(session->zk, session->path, php_zk_sync_completion, (const void *) session);
        PS_SET_MOD_DATA(NULL);
        return SUCCESS;
}

#endif /* HAVE_ZOOKEEPER_SESSION */

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim: noet sw=4 ts=4 fdm=marker:
 */

1	/*
2	+----------------------------------------------------------------------+
3	\| Copyright (c) 2010 The PHP Group \|
4	+----------------------------------------------------------------------+
5	\| This source file is subject to version 3.01 of the PHP license, \|
6	\| that is bundled with this package in the file LICENSE, and is \|
7	\| available through the world-wide-web at the following url: \|
8	\| http://www.php.net/license/3_01.txt. \|
9	\| If you did not receive a copy of the PHP license and are unable to \|
10	\| obtain it through the world-wide-web, please send a note to \|
11	\| license@php.net so we can mail you a copy immediately. \|
12	+----------------------------------------------------------------------+
13	\| Authors: Andrei Zmievski <andrei@php.net> \|
14	\| Mikko Koppanen <mkoppanen@php.net> \|
15	+----------------------------------------------------------------------+
16	*/
17
18	#include "php_zookeeper.h"
19	#include "php_zookeeper_private.h"
20	#include "php_zookeeper_session.h"
21	#include "SAPI.h"
22
23	#ifdef HAVE_ZOOKEEPER_SESSION
24
25	#define ZK_SESS_DATA php_zookeeper_session *session = PS_GET_MOD_DATA();
26
27	#define PHP_ZK_PARENT_NODE "/php-sessid"
28
29	#define PHP_ZK_SESS_DEFAULT_LOCK_WAIT 150000
30
31	#define PHP_ZK_SESS_LOCK_EXPIRATION 30
32
33	#ifndef ZEND_ENGINE_3
34	typedef zend_rsrc_list_entry zend_resource;
35	static inline void zend_hash_str_update_mem(HashTable ht, const char str, size_t len, void pData, size_t size)	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
36	{
37	void *pDest;
38	if (zend_hash_update(ht, str, len, pData, size, &pDest) == FAILURE) {	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
39	return NULL;	×
40	}
41	return pDest;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
42	}
43	static inline void zend_hash_str_find_ptr(const HashTable ht, const char *str, size_t len)	16 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
44	{
45	void *pData;
46	if (zend_hash_find(ht, str, len, &pData) == FAILURE) {	16 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
47	return NULL;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
48	}
49	return pData;	16 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
50	}
51	#endif
52
53	ps_module ps_mod_zookeeper = {
54	PS_MOD(zookeeper)
55	};
56
57	/* {{{ static php_zookeeper_session php_zookeeper_session_init(char save_path TSRMLS_DC)
58	Initialize the session
59	*/
60	static php_zookeeper_session php_zookeeper_session_init(char save_path TSRMLS_DC)	10✔
61	{
62	struct Stat stat;
63
64	int status, recv_timeout = ZK_G(recv_timeout);	10✔
65	php_zookeeper_session *session;
66
67	session = pecalloc(1, sizeof(php_zookeeper_session), 1);	10✔
68	session->zk = zookeeper_init(save_path, NULL, recv_timeout, 0, NULL, 0);	10✔
69
70	if (!session->zk) {	10✔
71	efree(session);	×
72	return NULL;	×
73	}
74
75	/* Create parent node if it does not exist */
76	if (zoo_exists(session->zk, PHP_ZK_PARENT_NODE, 1, &stat) == ZNONODE) {	10✔
77	int retry_count = 3;	10✔
78	do {
79	status = zoo_create(session->zk, PHP_ZK_PARENT_NODE, 0, 0, &ZOO_OPEN_ACL_UNSAFE, 0, 0, 0);	10✔
80	retry_count++;	10✔
81	} while (status == ZCONNECTIONLOSS && retry_count--);	10✔
82
83	if (status != ZOK) {	10✔
84	zookeeper_close(session->zk);	×
85	efree(session);	×
86	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to create parent node for sessions");	×
87	}
88	}
89	return session;	10✔
90	}
91	/* }}} */
92
93	/* {{{ static php_zookeeper_session php_zookeeper_session_get(char save_path TSRMLS_DC)
94	Get a connection. If connection does not exist in persistent list allocates a new one
95	*/
96	static php_zookeeper_session php_zookeeper_session_get(char save_path TSRMLS_DC)	20✔
97	{
98	php_zookeeper_session *session = NULL;	20✔
99
100	char *plist_key;
101	int plist_key_len;
102	zend_resource le, *le_p = NULL;	20✔
103
104	plist_key_len = spprintf(&plist_key, 0, "zk-conn:[%s]", save_path);	20✔
105	#ifndef ZEND_ENGINE_3
106	plist_key_len += 1;	16 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
107	#endif
108
109	le_p = zend_hash_str_find_ptr(&EG(persistent_list), plist_key, plist_key_len);	20✔
110	if (le_p) {	20✔
111	if (le_p->type == php_zookeeper_get_connection_le()) {	10✔
112	efree(plist_key);	10✔
113	return (php_zookeeper_session *) le_p->ptr;	10✔
114	}
115	}
116
117	session = php_zookeeper_session_init(save_path TSRMLS_CC);	10✔
118	le.type = php_zookeeper_get_connection_le();	10✔
119	le.ptr = session;	10✔
120
121	if (!zend_hash_str_update_mem(&EG(persistent_list), (char )plist_key, plist_key_len, (void )&le, sizeof(le))) {	12✔
122	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not register persistent entry for the zk handle");	×
123	}
124
125	efree(plist_key);	10✔
126	session->is_locked = 0;	10✔
127
128	return session;	20✔
129	}
130	/* }}} */
131
132	/* {{{ PS_OPEN_FUNC(zookeeper)
133	*/
134	PS_OPEN_FUNC(zookeeper)	20✔
135	{
136	php_zookeeper_session *session = php_zookeeper_session_get(PS(save_path) TSRMLS_CC);	20✔
137
138	if (!session) {	20✔
139	PS_SET_MOD_DATA(NULL);	×
140	return FAILURE;	×
141	}
142	PS_SET_MOD_DATA(session);	20✔
143	return SUCCESS;	20✔
144	}
145	/* }}} */
146
147	/* {{{ static int php_zookeeper_sess_lock(php_zookeeper_session session, const char key TSRMLS_DC)
148	Locking functionality. Adapted algo from memcached extension
149	*/
150	static zend_bool php_zookeeper_sess_lock(php_zookeeper_session session, const char key TSRMLS_DC)	20✔
151	{
152	char *lock_path;
153	int lock_path_len;
154	long attempts, lock_maxwait;
155	long lock_wait = ZK_G(sess_lock_wait);	20✔
156	time_t expiration;
157
158	/* lock_path if freed when the lock is freed */
159	lock_path_len = spprintf(&lock_path, 512 + 5, "%s/%s-lock", PHP_ZK_PARENT_NODE, key);	20✔
160
161	if (zkr_lock_init(&(session->lock), session->zk, lock_path, &ZOO_OPEN_ACL_UNSAFE) != 0) {	20✔
162	efree(lock_path);	×
163	return 0;	×
164	}
165
166	/* set max timeout for session_start = max_execution_time. (c) Andrei Darashenka, Richter & Poweleit GmbH */
167	lock_maxwait = zend_ini_long(ZEND_STRS("max_execution_time"), 0);	20✔
168	if (lock_maxwait <= 0) {	20✔
169	lock_maxwait = PHP_ZK_SESS_LOCK_EXPIRATION;	20✔
170	}
171	if (lock_wait == 0) {	20✔
172	lock_wait = PHP_ZK_SESS_DEFAULT_LOCK_WAIT;	×
173	}
174	expiration = SG(global_request_time) + lock_maxwait + 1;	20✔
175	attempts = lock_maxwait * 1000000 / lock_wait;	20✔
176
177	do {
178	if (zkr_lock_lock(&(session->lock))) {	20✔
179	session->is_locked = 1;	20✔
180	return 1;	20✔
181	}
182	if (lock_wait > 0) {	×
183	usleep(lock_wait);	×
184	}
185	} while(--attempts > 0);	×
186
187	return 0;	20✔
188	}
189
190	/* {{{ PS_READ_FUNC(zookeeper)
191	*/
192	PS_READ_FUNC(zookeeper)	20✔
193	{
194	#ifdef ZEND_ENGINE_3
195	#define SESSKEY ZSTR_VAL(key)
196	#else
197	#define SESSKEY key
198	#endif
199	ZK_SESS_DATA;	20✔
200	int status, path_len;
201	struct Stat stat;
202	int retry_count;
203	int64_t expiration_time;
204	char * rbuf;
205	int rbuf_len;
206
207	if (ZK_G(session_lock)) {	20✔
208	if (!php_zookeeper_sess_lock(session, SESSKEY TSRMLS_CC)) {	20✔
209	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to create session mutex");	×
210	return FAILURE;	×
211	}
212	}
213
214	path_len = snprintf(session->path, 512, "%s/%s", PHP_ZK_PARENT_NODE, SESSKEY);	20✔
215
216	retry_count = 3;	20✔
217	do {
218	status = zoo_exists(session->zk, session->path, 1, &stat);	20✔
219	retry_count++;	20✔
220	} while (status == ZCONNECTIONLOSS && retry_count--);	20✔
221
222	if (status != ZOK) {	20✔
223	goto error;	10✔
224	}
225
226	expiration_time = (int64_t) (SG(global_request_time) - PS(gc_maxlifetime)) * 1000;	10✔
227
228	/* The session has expired */
229	if (stat.mtime < expiration_time) {	10✔
230	retry_count = 3;	×
231	do {
232	status = zoo_delete(session->zk, session->path, -1);	×
233	retry_count++;	×
234	} while (status == ZCONNECTIONLOSS && retry_count--);	×
235	goto error;	×
236	}
237
238	rbuf = emalloc(stat.dataLength);	10✔
239	rbuf_len = stat.dataLength;	10✔
240
241	retry_count = 3;	10✔
242	do {
243	status = zoo_get(session->zk, session->path, 0, rbuf, &rbuf_len, &stat);	10✔
244	retry_count++;	10✔
245	} while (status == ZCONNECTIONLOSS && retry_count--);	10✔
246
247	if (status != ZOK) {	10✔
248	efree(rbuf);	×
249	goto error;	×
250	}
251
252	#ifdef ZEND_ENGINE_3
253	*val = zend_string_init(rbuf, rbuf_len, 0);	4 only LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
254	efree(rbuf);	2 only LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
255	#else
256	*val = rbuf;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
257	*vallen = rbuf_len;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
258	#endif
259
260	return SUCCESS;	10✔
261	error:
262	#ifdef ZEND_ENGINE_3
263	*val = ZSTR_EMPTY_ALLOC();	2 only LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
264	#else
265	*val = NULL;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
266	*vallen = 0;	8 all except LIBZOOKEEPER_VERSION=3.5.0-alpha and LIBZOOKEEPER_VERSION=3.4.6 ✔
267	#endif
268	return FAILURE;	20✔
269	#undef SESSKEY
270	}
271	/* }}} */
272
273	/* {{{ PS_WRITE_FUNC(zookeeper)
274	*/
275	PS_WRITE_FUNC(zookeeper)	20✔
276	{
277	#ifdef ZEND_ENGINE_3
278	#define WBUF ZSTR_VAL(val)
279	#define WBUFLEN ZSTR_LEN(val)
280	#else
281	#define WBUF val
282	#define WBUFLEN vallen
283	#endif
284
285	ZK_SESS_DATA;	20✔
286	int status, retry_count;
287	struct Stat stat;
288
289	retry_count = 3;	20✔
290	do {
291	status = zoo_exists(session->zk, session->path, 1, &stat);	20✔
292	retry_count++;	20✔
293	} while (status == ZCONNECTIONLOSS && retry_count--);	20✔
294
295	retry_count = 3;	20✔
296	do {
297	if (status != ZOK) {	20✔
298	status = zoo_create(session->zk, session->path, WBUF, WBUFLEN, &ZOO_OPEN_ACL_UNSAFE, 0, 0, 0);	10✔
299	} else {
300	status = zoo_set(session->zk, session->path, WBUF, WBUFLEN, -1);	10✔
301	}
302	retry_count++;	20✔
303	} while (status == ZCONNECTIONLOSS && retry_count--);	20✔
304
305
306	return (status == ZOK) ? SUCCESS : FAILURE;	20✔
307
308	#undef WBUF
309	#undef WBUFLEN
310	}
311	/* }}} */
312
313	PS_DESTROY_FUNC(zookeeper)	×
314	{
315	ZK_SESS_DATA;	×
316	int status, retry_count;
317
318	retry_count = 3;	×
319	do {
320	status = zoo_delete(session->zk, session->path, -1);	×
321	retry_count++;	×
322	} while (status == ZCONNECTIONLOSS && retry_count--);	×
323
324	return (status == ZOK) ? SUCCESS : FAILURE;	×
325	}
326
327	PS_GC_FUNC(zookeeper)	×
328	{
329	struct Stat stat;
330	struct String_vector nodes;
331	int i, status;
332	int64_t expiration_time;
333	ZK_SESS_DATA;	×
334
335	expiration_time = (int64_t) (SG(global_request_time) - PS(gc_maxlifetime)) * 1000;	×
336	status = zoo_get_children(session->zk, PHP_ZK_PARENT_NODE, 0, &nodes);	×
337
338	if (status == ZOK) {	×
339	for (i = 0; i < nodes.count; i++) {	×
340	char path[512];
341	int path_len;
342
343	path_len = snprintf(path, 512, "%s/%s", PHP_ZK_PARENT_NODE, nodes.data[i]);	×
344
345	if (zoo_exists(session->zk, path, 1, &stat) == ZOK) {	×
346	/* TODO: should lock here? */
347	if (stat.mtime < expiration_time) {	×
348	(void) zoo_delete(session->zk, path, -1);	×
349	}
350	}
351	}
352	}
353	return SUCCESS;	×
354	}
355
356	static void php_zk_sync_completion(int rc, const char value, const void data) {}	×
357
358	PS_CLOSE_FUNC(zookeeper)	20✔
359	{
360	ZK_SESS_DATA;	20✔
361
362	if (session->is_locked) {	20✔
363	(void) zkr_lock_unlock(&(session->lock));	20✔
364	efree(session->lock.path);	20✔
365
366	zkr_lock_destroy(&(session->lock));	20✔
367	session->is_locked = 0;	20✔
368	}
369
370	/* TODO: is this needed? */
371	// zoo_async(session->zk, session->path, php_zk_sync_completion, (const void *) session);
372	PS_SET_MOD_DATA(NULL);	20✔
373	return SUCCESS;	20✔
374	}
375
376	#endif /* HAVE_ZOOKEEPER_SESSION */
377
378	/*
379	* Local variables:
380	* tab-width: 4
381	* c-basic-offset: 4
382	* End:
383	* vim: noet sw=4 ts=4 fdm=marker:
384	*/

andreiz / php-zookeeper / 10

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous