int main(int argc, char *argv[])
{
lcb_error_t err;
lcb_t instance;
{
struct lcb_create_st create_options = {};
create_options.version = 3;
if (argc < 2) {
fprintf(stderr, "Usage: %s couchbase://host/bucket [ password [ username ] ]\n", argv[0]);
exit(EXIT_FAILURE);
}
create_options.v.v3.connstr = argv[1];
if (argc > 2) {
create_options.v.v3.passwd = argv[2];
}
if (argc > 3) {
create_options.v.v3.username = argv[3];
}
err = lcb_create(&instance, &create_options);
if (err != LCB_SUCCESS) {
die(NULL, "Couldn't create couchbase handle", err);
}
err = lcb_connect(instance);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't schedule connection", err);
}
lcb_wait(instance);
err = lcb_get_bootstrap_status(instance);
if (err != LCB_SUCCESS) {
die(instance, "Couldn't bootstrap from cluster", err);
}
lcb_install_callback3(instance, LCB_CALLBACK_GET, op_callback);
}
lcbcrypto_register(instance, "AES-256-HMAC-SHA256", osp_create());
get_encrypted(instance, "secret-1");
printf("\n");
get_encrypted(instance, "secret-2");
printf("\n");
get_encrypted(instance, "secret-3");
printf("\n");
get_encrypted(instance, "secret-4");
printf("\n");
get_encrypted(instance, "secret-5");
lcb_destroy(instance);
return 0;
}
PHP_METHOD(Bucket, __construct)
{
bucket_object *data = PCBC_PHP_THISOBJ();
zval *zdsn = NULL;
zval *zname = NULL;
zval *zpassword = NULL;
char *dsn = NULL;
char *name = NULL;
char *password = NULL;
lcb_error_t err;
lcb_t instance;
struct lcb_create_st create_options;
char *connkey = NULL;
pcbc_lcb *conn_iter, *conn;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzz",
&zdsn, &zname, &zpassword) == FAILURE) {
RETURN_NULL();
}
if (zap_zval_is_undef(zdsn)) {
zdsn = NULL;
}
if (zap_zval_is_undef(zname)) {
zname = NULL;
}
if (zap_zval_is_undef(zpassword)) {
zpassword = NULL;
}
if (zdsn) {
if (Z_TYPE_P(zdsn) == IS_STRING) {
dsn = estrndup(Z_STRVAL_P(zdsn), Z_STRLEN_P(zdsn));
} else {
throw_pcbc_exception("Expected dsn as string", LCB_EINVAL);
RETURN_NULL();
}
}
if (zname) {
if (Z_TYPE_P(zname) == IS_STRING) {
name = estrndup(Z_STRVAL_P(zname), Z_STRLEN_P(zname));
} else {
throw_pcbc_exception("Expected bucket name as string", LCB_EINVAL);
if (dsn) efree(dsn);
RETURN_NULL();
}
}
if (zpassword) {
if (Z_TYPE_P(zpassword) == IS_STRING) {
password = estrndup(Z_STRVAL_P(zpassword), Z_STRLEN_P(zpassword));
} else {
throw_pcbc_exception("Expected bucket password as string", LCB_EINVAL);
if (dsn) efree(dsn);
if (name) efree(name);
RETURN_NULL();
}
}
spprintf(&connkey, 512, "%s|%s|%s",
dsn ? dsn : "",
name ? name : "",
password ? password : "");
conn_iter = PCBCG(first_bconn);
while (conn_iter) {
if (strcmp(conn_iter->key, connkey) == 0) {
break;
}
conn_iter = conn_iter->next;
}
if (!conn_iter)
{
memset(&create_options, 0, sizeof(create_options));
create_options.version = 3;
create_options.v.v3.connstr = dsn;
create_options.v.v3.username = name;
create_options.v.v3.passwd = password;
create_options.v.v3.type = LCB_TYPE_BUCKET;
err = lcb_create(&instance, &create_options);
if (dsn) efree(dsn);
if (password) efree(password);
if (err != LCB_SUCCESS) {
efree(connkey);
efree(name);
throw_lcb_exception(err);
RETURN_NULL();
}
lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_CLIENT_STRING, pcbc_client_string);
lcb_install_callback3(instance, LCB_CALLBACK_GET, get_callback);
lcb_install_callback3(instance, LCB_CALLBACK_UNLOCK, unlock_callback);
lcb_install_callback3(instance, LCB_CALLBACK_STORE, store_callback);
lcb_install_callback3(instance, LCB_CALLBACK_STOREDUR, store_callback);
lcb_install_callback3(instance, LCB_CALLBACK_REMOVE, remove_callback);
lcb_install_callback3(instance, LCB_CALLBACK_TOUCH, touch_callback);
lcb_install_callback3(instance, LCB_CALLBACK_COUNTER, counter_callback);
lcb_install_callback3(instance, LCB_CALLBACK_SDLOOKUP, subdoc_callback);
lcb_install_callback3(instance, LCB_CALLBACK_SDMUTATE, subdoc_callback);
lcb_install_callback3(instance, LCB_CALLBACK_HTTP, http_callback);
lcb_set_durability_callback(instance, durability_callback);
err = lcb_connect(instance);
if (err != LCB_SUCCESS) {
efree(connkey);
efree(name);
lcb_destroy(instance);
throw_lcb_exception(err);
RETURN_NULL();
}
// We use lcb_wait here as no callbacks are invoked by connect.
lcb_wait(instance);
err = lcb_get_bootstrap_status(instance);
if (err != LCB_SUCCESS) {
efree(connkey);
efree(name);
lcb_destroy(instance);
throw_lcb_exception(err);
RETURN_NULL();
}
conn = pemalloc(sizeof(pcbc_lcb), 1);
conn->bucket = pestrdup(name, 1);
efree(name);
conn->key = pestrdup(connkey, 1);
conn->lcb = instance;
conn->next = NULL;
data->conn = conn;
if (PCBCG(last_bconn)) {
PCBCG(last_bconn)->next = conn;
PCBCG(last_bconn) = conn;
} else {
PCBCG(first_bconn) = conn;
PCBCG(last_bconn) = conn;
}
} else {
if (dsn) efree(dsn);
if (name) efree(name);
if (password) efree(password);
data->conn = conn_iter;
}
efree(connkey);
}
void
pycbc_callbacks_init(lcb_t instance)
{
lcb_install_callback3(instance, LCB_CALLBACK_STORE, durability_chain_common);
lcb_install_callback3(instance, LCB_CALLBACK_REMOVE, durability_chain_common);
lcb_install_callback3(instance, LCB_CALLBACK_UNLOCK, keyop_simple_callback);
lcb_install_callback3(instance, LCB_CALLBACK_TOUCH, keyop_simple_callback);
lcb_install_callback3(instance, LCB_CALLBACK_ENDURE, keyop_simple_callback);
lcb_install_callback3(instance, LCB_CALLBACK_GET, value_callback);
lcb_install_callback3(instance, LCB_CALLBACK_GETREPLICA, value_callback);
lcb_install_callback3(instance, LCB_CALLBACK_COUNTER, value_callback);
lcb_install_callback3(instance, LCB_CALLBACK_OBSERVE, observe_callback);
lcb_install_callback3(instance, LCB_CALLBACK_STATS, stats_callback);
/* Subdoc */
lcb_install_callback3(instance, LCB_CALLBACK_SDLOOKUP, subdoc_callback);
lcb_install_callback3(instance, LCB_CALLBACK_SDMUTATE, subdoc_callback);
lcb_set_bootstrap_callback(instance, bootstrap_callback);
pycbc_http_callbacks_init(instance);
}
void
plcb_callbacks_setup(PLCB_t *object)
{
lcb_t o = object->instance;
lcb_install_callback3(o, LCB_CALLBACK_GET, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_GETREPLICA, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_STORE, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_TOUCH, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_REMOVE, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_COUNTER, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_UNLOCK, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_ENDURE, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_STATS, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_OBSERVE, callback_common);
lcb_install_callback3(o, LCB_CALLBACK_HTTP, callback_common);
lcb_set_bootstrap_callback(o, bootstrap_callback);
}
