PCBC-360, PCBC-376: Major refactor for PHP 7 and reentrant transcoders.

This includes major changes to most components to support
PHP 7.  This also includes a major change to the operation
handling flow to correct issues when callbacks (ex:
transcoders) call back into the library.

Change-Id: I90c68f250863bf723b8d6327d8a77c2e2e7fa3ae

Author: brett19

bucket.c

@@ -3,15 +3,17 @@
 
 #include <php.h>
 #include "couchbase.h"
+#include "zap.h"
 
 typedef struct bucket_object {
-	zend_object std;
-	zval *error;
-	zval *encoder;
-	zval *decoder;
-	zval *prefix;
+    zap_ZEND_OBJECT_START
 
-	pcbc_lcb *conn;
+    zapval encoder;
+    zapval decoder;
+    zapval prefix;
+    pcbc_lcb *conn;
+
+    zap_ZEND_OBJECT_END
 } bucket_object;
 
 #endif // BUCKET_H_

bucket.h

@@ -1,9 +1,10 @@
 #include <libcouchbase/couchbase.h>
 #include <php.h>
+#include "cas.h"
 
 int le_cas;
 
-static void cas_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static zap_DTORRES_FUNC(cas_dtor)
 {
     lcb_cas_t *cas_data = (lcb_cas_t*)rsrc->ptr;
     if (cas_data) {
@@ -12,24 +13,20 @@ static void cas_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 }
 
 void couchbase_init_cas(INIT_FUNC_ARGS) {
-	le_cas = zend_register_list_destructors_ex(cas_dtor, NULL, "CouchbaseCAS", module_number);
+    le_cas = zend_register_list_destructors_ex(cas_dtor, NULL, "CouchbaseCAS", module_number);
 }
 
 lcb_cas_t cas_retrieve(zval * zcas TSRMLS_DC) {
-	lcb_cas_t *cas = 0;
-	ZEND_FETCH_RESOURCE_NO_RETURN(cas, lcb_cas_t*, &zcas, -1, "CouchbaseCAS", le_cas);
-	if (cas) {
-		return *cas;
-	} else {
-		return 0;
-	}
+    lcb_cas_t *cas = (lcb_cas_t*)zap_fetch_resource(zcas, "CouchbaseCAS", le_cas);
+    if (cas) {
+        return *cas;
+    } else {
+        return 0;
+    }
 }
 
-zval * cas_create(lcb_cas_t value TSRMLS_DC) {
-	zval *cas;
-	void *cas_data = emalloc(sizeof(lcb_cas_t));
-	*((lcb_cas_t*)cas_data) = value;
-	MAKE_STD_ZVAL(cas);
-	ZEND_REGISTER_RESOURCE(cas, cas_data, le_cas);
-	return cas;
+void cas_create(zapval *casout, lcb_cas_t value TSRMLS_DC) {
+    void *cas_data = emalloc(sizeof(lcb_cas_t));
+    *((lcb_cas_t*)cas_data) = value;
+    zapval_alloc_res(*casout, cas_data, le_cas);
 }

cas.c

@@ -3,9 +3,13 @@
 
 #include <php.h>
 #include <libcouchbase/couchbase.h>
+#include "zap.h"
 
 void couchbase_init_cas(INIT_FUNC_ARGS);
 lcb_cas_t cas_retrieve(zval * zcas TSRMLS_DC);
-zval * cas_create(lcb_cas_t value TSRMLS_DC);
+void cas_create(zapval *casout, lcb_cas_t value TSRMLS_DC);
+
+#define alloc_cas(z, v) \
+    cas_create(&z, v)
 
 #endif // CAS_H_

cas.h

@@ -1,96 +1,83 @@
-#include <libcouchbase/couchbase.h>
 #include "couchbase.h"
-#include "phphelpers.h"
+#include "ext/standard/php_var.h"
 #include "exception.h"
+#include "zap.h"
 #include "cluster.h"
-#include "metadoc.h"
+#include "opcookie.h"
 
-zend_object_handlers cluster_handlers;
+zap_class_entry cluster_class;
+zend_class_entry *cluster_ce;
+
+#define PHP_THISOBJ() zap_fetch_this(cluster_object)
 
-void cluster_free_storage(void *object TSRMLS_DC)
+zap_FREEOBJ_FUNC(cluster_free_storage)
 {
-	cluster_object *obj = (cluster_object *)object;
+    cluster_object *obj = zap_get_object(cluster_object, object);
 
-	zend_hash_destroy(obj->std.properties);
-	FREE_HASHTABLE(obj->std.properties);
+    if (obj->lcb != NULL) {
+        lcb_destroy(obj->lcb);
+        obj->lcb = NULL;
+    }
 
-	efree(obj);
+    zend_object_std_dtor(&obj->std TSRMLS_CC);
+    zap_free_object_storage(obj);
 }
 
-zend_object_value cluster_create_handler(zend_class_entry *type TSRMLS_DC)
+zap_CREATEOBJ_FUNC(cluster_create_handler)
 {
-	zend_object_value retval;
-
-	cluster_object *obj = (cluster_object *)emalloc(sizeof(cluster_object));
-	memset(obj, 0, sizeof(cluster_object));
-	obj->std.ce = type;
+    cluster_object *obj = zap_alloc_object_storage(cluster_object, type);
 
-	ALLOC_HASHTABLE(obj->std.properties);
-	zend_hash_init(obj->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
-	phlp_object_properties_init(&obj->std, type);
+    zend_object_std_init(&obj->std, type TSRMLS_CC);
+    zap_object_properties_init(&obj->std, type);
 
-	retval.handle = zend_objects_store_put(obj, NULL,
-		cluster_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &cluster_handlers;
+    obj->lcb = NULL;
 
-	return retval;
+    return zap_finalize_object(obj, &cluster_class);
 }
 
 typedef struct {
-	zval *retval;
-	cluster_object *owner;
-} copcookie;
-
-copcookie * copcookie_init(cluster_object *clusterobj, zval *return_value) {
-	copcookie *cookie = emalloc(sizeof(copcookie));
-	cookie->owner = clusterobj;
-	cookie->retval = return_value;
-	ZVAL_NULL(cookie->retval);
-	return cookie;
-}
-
-void ccookie_error(const copcookie *cookie, cluster_object *data, zval *doc,
-				  lcb_error_t error TSRMLS_DC) {
-	zval *zerror = create_lcb_exception(error TSRMLS_CC); 
-	if (Z_TYPE_P(cookie->retval) == IS_ARRAY) {
-		metadoc_from_error(doc, zerror TSRMLS_CC);
-	} else {
-		data->error = zerror;
-	}
-}
+    opcookie_res header;
+    zapval bytes;
+} opcookie_http_res;
 
 static void http_complete_callback(lcb_http_request_t request, lcb_t instance,
 			const void *cookie, lcb_error_t error,
 			const lcb_http_resp_t *resp) {
-	cluster_object *data = (cluster_object*)lcb_get_cookie(instance);
-	zval *doc = ((copcookie*)cookie)->retval;
-	TSRMLS_FETCH();
+    opcookie_http_res *result = ecalloc(1, sizeof(opcookie_http_res));
+    TSRMLS_FETCH();
 
-	if (error == LCB_SUCCESS) {
-		ZVAL_STRINGL(doc, resp->v.v0.bytes, resp->v.v0.nbytes, 1);
-	} else {
-		ccookie_error(cookie, data, NULL, error TSRMLS_CC);
-	}
+    result->header.err = error;
+    zapval_alloc_stringl(
+            result->bytes, resp->v.v0.bytes, resp->v.v0.nbytes);
+
+    opcookie_push((opcookie*)cookie, &result->header);
 }
 
-static int pcbc_wait(cluster_object *obj TSRMLS_DC)
+static lcb_error_t proc_http_results(cluster_object *cluster, zval *return_value,
+        opcookie *cookie TSRMLS_DC)
 {
-	lcb_t instance = obj->lcb;
-	obj->error = NULL;
-
-	lcb_wait(instance);
-
-	if (obj->error) {
-		zend_throw_exception_object(obj->error TSRMLS_CC);
-		obj->error = NULL;
-		return 0;
-	}
-
-	return 1;
+    opcookie_http_res *res;
+    lcb_error_t err = LCB_SUCCESS;
+
+    // Any error should cause everything to fail... for now?
+    err = opcookie_get_first_error(cookie);
+
+    if (err == LCB_SUCCESS) {
+        // TODO: This could leak with multiple results...  It also copies
+        //   which might not be needed...
+        FOREACH_OPCOOKIE_RES(opcookie_http_res, res, cookie) {
+            zap_zval_stringl_p(return_value,
+                zapval_strval_p(&res->bytes), zapval_strlen_p(&res->bytes))
+        }
+    }
+
+    FOREACH_OPCOOKIE_RES(opcookie_http_res, res, cookie) {
+        zapval_destroy(res->bytes);
+    }
+
+    return err;
 }
 
-zend_class_entry *cluster_ce;
-
 PHP_METHOD(Cluster, __construct)
 {
 	cluster_object *data = PHP_THISOBJ();
@@ -187,11 +174,12 @@ PHP_METHOD(Cluster, http_request)
 {
 	cluster_object *data = PHP_THISOBJ();
 	lcb_http_cmd_t cmd = { 0 };
-	copcookie *cookie;
+	opcookie *cookie;
 	lcb_http_type_t type;
 	lcb_http_method_t method;
 	const char *contenttype;
 	zval *ztype, *zmethod, *zpath, *zbody, *zcontenttype;
+	lcb_error_t err;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzzz",
 				&ztype, &zmethod, &zpath, &zbody, &zcontenttype) == FAILURE) {
@@ -240,12 +228,21 @@ PHP_METHOD(Cluster, http_request)
 	cmd.v.v0.chunked = 0;
 	cmd.v.v0.content_type = contenttype;
 
-	cookie = copcookie_init(data, return_value);
+	cookie = opcookie_init();
+
+	err = lcb_make_http_request(data->lcb, cookie, type, &cmd, NULL);
+
+    if (err == LCB_SUCCESS) {
+        lcb_wait(data->lcb);
+
+        err = proc_http_results(data, return_value, cookie TSRMLS_CC);
+    }
 
-	lcb_make_http_request(data->lcb, cookie, type, &cmd, NULL);
-	pcbc_wait(data TSRMLS_CC);
+    opcookie_destroy(cookie);
 
-	efree(cookie);
+    if (err != LCB_SUCCESS) {
+        throw_lcb_exception(err);
+    }
 }
 
 zend_function_entry cluster_methods[] = {
@@ -256,12 +253,9 @@ zend_function_entry cluster_methods[] = {
 };
 
 void couchbase_init_cluster(INIT_FUNC_ARGS) {
-	zend_class_entry ce;
-	INIT_CLASS_ENTRY(ce, "_CouchbaseCluster", cluster_methods);
-	ce.create_object = cluster_create_handler;
-	cluster_ce = zend_register_internal_class(&ce TSRMLS_CC);
-
-	memcpy(&cluster_handlers,
-			zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	cluster_handlers.clone_obj = NULL;
+    zap_init_class_entry(&cluster_class, "_CouchbaseCluster",
+            cluster_methods);
+    cluster_class.create_obj = cluster_create_handler;
+    cluster_class.free_obj = cluster_free_storage;
+    cluster_ce = zap_register_internal_class(&cluster_class, cluster_object);
 }

cluster.c

@@ -1,13 +1,16 @@
 #ifndef CLUSTER_H_
 #define CLUSTER_H_
 
-#include <libcouchbase/couchbase.h>
 #include <php.h>
+#include "couchbase.h"
+#include "zap.h"
 
 typedef struct cluster_object {
-	zend_object std;
-	lcb_t lcb;
-	zval *error;
+    zap_ZEND_OBJECT_START
+
+    lcb_t lcb;
+
+    zap_ZEND_OBJECT_END
 } cluster_object;
 
 #endif // CLUSTER_H_

cluster.h

@@ -40,6 +40,7 @@ if test "$PHP_COUCHBASE" != "no"; then
 	couchbase.c \
 	exception.c \
 	metadoc.c \
+	opcookie.c \
 	transcoding.c \
 	fastlz/fastlz.c \
   , $ext_shared)

config.m4

@@ -8,6 +8,7 @@ if (PHP_COUCHBASE != "no") {
 		"couchbase.c " + 
 		"exception.c " +
 		"metadoc.c " +
+		"opcookie.c " +
 		"transcoding.c ";
 
 	if (CHECK_LIB("libcouchbase.lib", "couchbase", PHP_COUCHBASE) &&

config.w32

@@ -3,6 +3,7 @@
 #include "metadoc.h"
 #include "phpstubstr.h"
 #include "fastlz/fastlz.h"
+#include "zap.h"
 
 #if HAVE_ZLIB
 #include <zlib.h>
@@ -150,10 +151,10 @@ PHP_FUNCTION(couchbase_zlib_compress)
     compress((uint8_t*)dataOut + 4, &dataOutSize, dataIn, dataSize);
     *(uint32_t*)dataOut = dataSize;
 
-    RETURN_STRINGL(dataOut, 4 + dataOutSize, 0);
+    zap_zval_stringl_p(return_value, dataOut, 4 + dataOutSize);
+    efree(dataOut);
 #else
     zend_throw_exception(NULL, "The zlib library was not available when the couchbase extension was built.", 0 TSRMLS_CC);
-    RETURN_NULL();
 #endif
 }
 
@@ -175,10 +176,10 @@ PHP_FUNCTION(couchbase_zlib_decompress)
     dataOut = emalloc(dataOutSize);
     uncompress(dataOut, &dataOutSize, (uint8_t*)dataIn + 4, dataSize - 4);
 
-    RETURN_STRINGL(dataOut, dataOutSize, 0);
+    zap_zval_stringl_p(return_value, dataOut, dataOutSize);
+    efree(dataOut);
 #else
     zend_throw_exception(NULL, "The zlib library was not available when the couchbase extension was built.", 0 TSRMLS_CC);
-    RETURN_NULL();
 #endif
 }
 
@@ -200,7 +201,9 @@ PHP_FUNCTION(couchbase_fastlz_compress)
     dataOutSize = fastlz_compress(dataIn, dataSize, (uint8_t*)dataOut + 4);
     *(uint32_t*)dataOut = dataSize;
 
-    RETURN_STRINGL(dataOut, 4 + dataOutSize, 0);
+    zap_zval_stringl_p(return_value, dataOut, 4 + dataOutSize);
+
+    efree(dataOut);
 }
 
 PHP_FUNCTION(couchbase_fastlz_decompress)
@@ -221,7 +224,9 @@ PHP_FUNCTION(couchbase_fastlz_decompress)
     dataOutSize = fastlz_decompress(
             (uint8_t*)dataIn + 4, dataSize - 4, dataOut, dataOutSize);
 
-    RETURN_STRINGL(dataOut, dataOutSize, 0);
+    zap_zval_stringl_p(return_value, dataOut, dataOutSize);
+
+    efree(dataOut);
 }
 
 static zend_function_entry couchbase_functions[] = {

couchbase.c

@@ -41,8 +41,6 @@ ZEND_EXTERN_MODULE_GLOBALS(couchbase)
 #define PCBCG(v) (couchbase_globals.v)
 #endif
 
-#define PHP_THISOBJ() zend_object_store_get_object(getThis() TSRMLS_CC)
-
 void couchbase_init_exceptions(INIT_FUNC_ARGS);
 void couchbase_init_cluster(INIT_FUNC_ARGS);
 void couchbase_init_bucket(INIT_FUNC_ARGS);