PyObject *
pycbc_Connection__vbmap(pycbc_Connection *conn, PyObject *args)
{
pycbc_strlen_t slen = 0;
const char *s = NULL;
PyObject *rtuple;
struct vbinfo_st info;
lcb_error_t err;
if (!PyArg_ParseTuple(args, "s#", &s, &slen)) {
PYCBC_EXCTHROW_ARGS();
}
memset(&info, 0, sizeof(info));
info.v.v0.key = s;
info.v.v0.nkey = slen;
err = lcb_cntl(conn->instance, CNTL_GET, CNTL_VBMAP, &info);
if (err != LCB_SUCCESS) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "lcb_cntl failed");
return NULL;
}
rtuple = PyTuple_New(2);
PyTuple_SET_ITEM(rtuple, 0, pycbc_IntFromL(info.v.v0.vbucket));
PyTuple_SET_ITEM(rtuple, 1, pycbc_IntFromL(info.v.v0.server_index));
return rtuple;
}
static PyObject *
handle_float_tmo(lcb_t instance,
int cmd, int mode, PyObject *val, lcb_error_t *err)
{
lcb_uint32_t cval;
if (val != NULL) {
if (PyFloat_Check(val)) {
double dv = PyFloat_AsDouble(val);
if (dv < 0) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0,
"Timeout cannot be < 0");
return NULL;
}
cval = dv * 1000000;
} else {
cval = pycbc_IntAsL(val);
if (cval == (lcb_uint32_t)-1 && PyErr_Occurred()) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
}
}
if ( (*err = lcb_cntl(instance, mode, cmd, &cval)) != LCB_SUCCESS) {
return NULL;
}
return pycbc_IntFromUL(cval);
}
PyObject *
pycbc_Bucket__fts_query(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
PyObject *ret = NULL;
pycbc_MultiResult *mres;
pycbc_ViewResult *vres;
lcb_error_t rc;
lcb_CMDFTS cmd = { 0 };
const char *params;
pycbc_strlen_t nparams;
static char *kwlist[] = { "params", NULL };
rv = PyArg_ParseTupleAndKeywords(args, kwargs,
"s#", kwlist, ¶ms, &nparams);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (-1 == pycbc_oputil_conn_lock(self)) {
return NULL;
}
if (self->pipeline_queue) {
PYCBC_EXC_WRAP(PYCBC_EXC_PIPELINE, 0,
"FTS queries cannot be executed in pipeline context");
}
mres = (pycbc_MultiResult *)pycbc_multiresult_new(self);
vres = (pycbc_ViewResult *)PYCBC_TYPE_CTOR(&pycbc_ViewResultType);
pycbc_httpresult_init(&vres->base, mres);
vres->rows = PyList_New(0);
vres->base.format = PYCBC_FMT_JSON;
vres->base.htype = PYCBC_HTTP_HN1QL;
cmd.callback = fts_row_callback;
cmd.query = params;
cmd.nquery = nparams;
cmd.handle = &vres->base.u.fts;
rc = lcb_fts_query(self->instance, mres, &cmd);
if (rc != LCB_SUCCESS) {
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, rc, "Couldn't schedule fts query");
goto GT_DONE;
}
ret = (PyObject *)mres;
mres = NULL;
GT_DONE:
Py_XDECREF(mres);
pycbc_oputil_conn_unlock(self);
return ret;
}
static PyObject *
handle_intval(lcb_t instance,
int cmd, int mode, PyObject *val, lcb_error_t *err)
{
int cval;
if (val != NULL) {
cval = pycbc_IntAsL(val);
if (cval == -1 && PyErr_Occurred()) {
PYCBC_EXCTHROW_ARGS();
}
}
if ((*err = lcb_cntl(instance, mode, cmd, &cval)) != LCB_SUCCESS) {
return NULL;
}
return pycbc_IntFromL(cval);
}
static PyObject *
ViewResult_fetch(pycbc_ViewResult *self, PyObject *args)
{
PyObject *ret = NULL;
pycbc_MultiResult *mres = NULL;
pycbc_Bucket *bucket;
int rv;
rv = PyArg_ParseTuple(args, "O", &mres);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
bucket = mres->parent;
if (bucket->flags & PYCBC_CONN_F_ASYNC) {
PYCBC_EXC_WRAP(PYCBC_EXC_INTERNAL, 0, "Cannot use fetch with async");
return NULL;
}
if (-1 == pycbc_oputil_conn_lock(bucket)) {
return NULL;
}
if (!self->base.done) {
pycbc_oputil_wait_common(bucket);
}
if (pycbc_multiresult_maybe_raise(mres)) {
goto GT_DONE;
}
ret = self->rows ? self->rows : PyList_New(0);
self->rows = PyList_New(0);
GT_DONE:
pycbc_oputil_conn_unlock(bucket);
return ret;
}
static PyObject*
get_common(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs,
int optype,
int argopts)
{
int rv;
Py_ssize_t ncmds = 0;
size_t cmdsize;
pycbc_seqtype_t seqtype;
PyObject *kobj = NULL;
PyObject *is_quiet = NULL;
lcb_error_t err;
PyObject *ttl_O = NULL;
PyObject *replica_O = NULL;
PyObject *nofmt_O = NULL;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
struct getcmd_vars_st gv = { 0 };
static char *kwlist[] = {
"keys", "ttl", "quiet", "replica", "no_format", NULL
};
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
"O|OOOO",
kwlist,
&kobj,
&ttl_O,
&is_quiet,
&replica_O,
&nofmt_O);
if (!rv) {
PYCBC_EXCTHROW_ARGS()
return NULL;
}
static PyObject*
get_common(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs,
int optype,
int argopts)
{
int rv;
int ii;
Py_ssize_t ncmds = 0;
size_t cmdsize;
pycbc_seqtype_t seqtype;
PyObject *ret = NULL;
PyObject *kobj = NULL;
PyObject *is_quiet = NULL;
pycbc_MultiResult *mres = NULL;
lcb_error_t err;
PyObject *ttl_O = NULL;
unsigned long ttl = 0;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", "ttl", "quiet", NULL };
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
"O|OO",
kwlist,
&kobj,
&ttl_O,
&is_quiet);
if (!rv) {
PYCBC_EXCTHROW_ARGS()
return NULL;
}
static PyObject *
observe_common(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs,
int argopts)
{
int rv;
int ii;
Py_ssize_t ncmds;
PyObject *kobj = NULL;
pycbc_seqtype_t seqtype;
lcb_error_t err;
int master_only = 0;
PyObject *master_only_O = NULL;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", "master_only", NULL };
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
"O|O",
kwlist,
&kobj,
&master_only_O);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_check_sequence(kobj, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
} else {
ncmds = 1;
}
master_only = master_only_O && PyObject_IsTrue(master_only_O);
rv = pycbc_common_vars_init(&cv,
self,
argopts,
ncmds, sizeof(lcb_observe_cmd_t),
0);
if (rv < 0) {
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
Py_ssize_t dictpos;
PyObject *curseq, *iter = NULL;
curseq = pycbc_oputil_iter_prepare(seqtype, kobj, &iter, &dictpos);
if (!curseq) {
goto GT_DONE;
}
for (ii = 0; ii < ncmds; ii++) {
PyObject *curkey = NULL, *curvalue = NULL;
rv = pycbc_oputil_sequence_next(seqtype,
curseq,
&dictpos,
ii,
&curkey,
&curvalue);
if (rv < 0) {
goto GT_ITER_DONE;
}
rv = handle_single_observe(self, curkey, ii, master_only, &cv);
GT_ITER_DONE:
Py_XDECREF(curkey);
Py_XDECREF(curvalue);
if (rv < 0) {
goto GT_DONE;
}
}
} else {
rv = handle_single_observe(self, kobj, 0, master_only, &cv);
if (rv < 0) {
goto GT_DONE;
}
}
err = lcb_observe(self->instance, cv.mres, ncmds, cv.cmdlist.obs);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
cv.is_seqcmd = 1;
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
static int
Connection__init__(pycbc_Connection *self,
PyObject *args, PyObject *kwargs)
{
int rv;
int conntype = LCB_TYPE_BUCKET;
lcb_error_t err;
char *conncache = NULL;
PyObject *unlock_gil_O = NULL;
PyObject *iops_O = NULL;
PyObject *timeout = NULL;
PyObject *dfl_fmt = NULL;
PyObject *tc = NULL;
struct lcb_create_st create_opts = { 0 };
struct lcb_cached_config_st cached_config = { { 0 } };
/**
* This xmacro enumerates the constructor keywords, targets, and types.
* This was converted into an xmacro to ease the process of adding or
* removing various parameters.
*/
#define XCTOR_ARGS(X) \
X("_errors", &self->errors, "O") \
X("_flags", &self->flags, "I") \
X("bucket", &create_opts.v.v1.bucket, "z") \
X("username", &create_opts.v.v1.user, "z") \
X("password", &create_opts.v.v1.passwd, "z") \
X("host", &create_opts.v.v1.host, "z") \
X("conncache", &conncache, "z") \
X("quiet", &self->quiet, "I") \
X("unlock_gil", &unlock_gil_O, "O") \
X("transcoder", &tc, "O") \
X("timeout", &timeout, "O") \
X("default_format", &dfl_fmt, "O") \
X("lockmode", &self->lockmode, "i") \
X("_conntype", &conntype, "i") \
X("_iops", &iops_O, "O")
static char *kwlist[] = {
#define X(s, target, type) s,
XCTOR_ARGS(X)
#undef X
NULL
};
#define X(s, target, type) type
static char *argspec = "|" XCTOR_ARGS(X);
#undef X
if (self->init_called) {
PyErr_SetString(PyExc_RuntimeError, "__init__ was already called");
return -1;
}
self->init_called = 1;
self->flags = 0;
self->unlock_gil = 1;
self->lockmode = PYCBC_LOCKMODE_EXC;
#define X(s, target, type) target,
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
argspec,
kwlist,
XCTOR_ARGS(X) NULL);
#undef X
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return -1;
}
if (unlock_gil_O && PyObject_IsTrue(unlock_gil_O) == 0) {
self->unlock_gil = 0;
}
if (create_opts.v.v1.bucket) {
self->bucket = pycbc_SimpleStringZ(create_opts.v.v1.bucket);
}
create_opts.version = 1;
create_opts.v.v1.type = conntype;
if (iops_O && iops_O != Py_None) {
self->iops = pycbc_iops_new(self, iops_O);
create_opts.v.v1.io = self->iops;
self->unlock_gil = 0;
}
Py_INCREF(self->errors);
if (dfl_fmt == Py_None || dfl_fmt == NULL) {
/** Set to 0 if None or NULL */
dfl_fmt = pycbc_IntFromL(0);
} else {
Py_INCREF(dfl_fmt); /* later decref */
}
rv = Connection_set_format(self, dfl_fmt, NULL);
Py_XDECREF(dfl_fmt);
if (rv == -1) {
return rv;
}
/** Set the transcoder */
if (tc && Connection_set_transcoder(self, tc, NULL) == -1) {
return -1;
}
#ifdef WITH_THREAD
if (!self->unlock_gil) {
self->lockmode = PYCBC_LOCKMODE_NONE;
}
if (self->lockmode != PYCBC_LOCKMODE_NONE) {
self->lock = PyThread_allocate_lock();
}
#endif
if (conncache) {
if (conntype != LCB_TYPE_BUCKET) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0,
"Cannot use connection cache with "
"management connection");
return -1;
}
cached_config.cachefile = conncache;
memcpy(&cached_config.createopt, &create_opts, sizeof(create_opts));
err = lcb_create_compat(LCB_CACHED_CONFIG,
&cached_config,
&self->instance,
NULL);
} else {
err = lcb_create(&self->instance, &create_opts);
}
if (err != LCB_SUCCESS) {
self->instance = NULL;
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, err,
"Couldn't create instance. Either bad "
"credentials/hosts/bucket names were "
"passed, or there was an internal error in creating the "
"object");
return -1;
}
pycbc_callbacks_init(self->instance);
lcb_set_cookie(self->instance, self);
if (timeout && timeout != Py_None) {
if (Connection_set_timeout(self, timeout, NULL) == -1) {
return -1;
}
}
PYCBC_CONN_THR_BEGIN(self);
err = lcb_connect(self->instance);
PYCBC_CONN_THR_END(self);
if (err != LCB_SUCCESS) {
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, err,
"Couldn't schedule connection. This might be a result of "
"an invalid hostname.");
return -1;
}
err = pycbc_oputil_wait_common(self);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
return -1;
}
return 0;
}
PyObject *
pycbc_Bucket__n1ql_query(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
PyObject *ret = NULL;
pycbc_MultiResult *mres;
pycbc_ViewResult *vres;
lcb_error_t rc;
lcb_CMDN1QL cmd = { 0 };
const char *params;
pycbc_strlen_t nparams;
int prepared = 0, cross_bucket = 0;
static char *kwlist[] = { "params", "prepare", "cross_bucket", NULL };
rv = PyArg_ParseTupleAndKeywords(
args, kwargs, "s#|ii", kwlist, ¶ms, &nparams, &prepared, &cross_bucket);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (-1 == pycbc_oputil_conn_lock(self)) {
return NULL;
}
if (self->pipeline_queue) {
PYCBC_EXC_WRAP(PYCBC_EXC_PIPELINE, 0,
"N1QL queries cannot be executed in "
"pipeline context");
}
mres = (pycbc_MultiResult *)pycbc_multiresult_new(self);
vres = (pycbc_ViewResult *)PYCBC_TYPE_CTOR(&pycbc_ViewResultType);
pycbc_httpresult_init(&vres->base, mres);
vres->rows = PyList_New(0);
vres->base.format = PYCBC_FMT_JSON;
vres->base.htype = PYCBC_HTTP_HN1QL;
cmd.content_type = "application/json";
cmd.callback = n1ql_row_callback;
cmd.query = params;
cmd.nquery = nparams;
cmd.handle = &vres->base.u.nq;
if (prepared) {
cmd.cmdflags |= LCB_CMDN1QL_F_PREPCACHE;
}
if (cross_bucket) {
cmd.cmdflags |= LCB_CMD_F_MULTIAUTH;
}
rc = lcb_n1ql_query(self->instance, mres, &cmd);
if (rc != LCB_SUCCESS) {
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, rc, "Couldn't schedule n1ql query");
goto GT_DONE;
}
ret = (PyObject *)mres;
mres = NULL;
GT_DONE:
Py_XDECREF(mres);
pycbc_oputil_conn_unlock(self);
return ret;
}
PyObject *
pycbc_Bucket__stats(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
int ii;
Py_ssize_t ncmds;
lcb_error_t err = LCB_ERROR;
PyObject *keys = NULL, *is_keystats = NULL;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", "keystats", NULL };
lcb_CMDSTATS cmd = { 0 };
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", kwlist,
&keys, &is_keystats);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (keys == NULL || PyObject_IsTrue(keys) == 0) {
keys = NULL;
ncmds = 1;
} else {
if (!PySequence_Check(keys)) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "keys argument must be sequence");
return NULL;
}
ncmds = PySequence_Size(keys);
}
rv = pycbc_common_vars_init(&cv, self, PYCBC_ARGOPT_MULTI, ncmds, 0);
if (rv < 0) {
return NULL;
}
if (keys) {
for (ii =0; ii < ncmds; ii++) {
char *key;
Py_ssize_t nkey;
PyObject *newkey = NULL;
PyObject *curkey = PySequence_GetItem(keys, ii);
rv = pycbc_BufFromString(curkey, &key, &nkey, &newkey);
if (rv < 0) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS, 0, "bad key type in stats", curkey);
goto GT_DONE;
}
LCB_CMD_SET_KEY(&cmd, key, nkey);
if (is_keystats && PyObject_IsTrue(is_keystats)) {
cmd.cmdflags |= LCB_CMDSTATS_F_KV;
}
err = lcb_stats3(self->instance, cv.mres, &cmd);
Py_XDECREF(newkey);
}
} else {
err = lcb_stats3(self->instance, cv.mres, &cmd);
}
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
PyObject *
pycbc_Bucket_endure_multi(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
Py_ssize_t ncmds;
pycbc_seqtype_t seqtype;
char persist_to = 0, replicate_to = 0;
lcb_durability_opts_t dopts = { 0 };
PyObject *keys;
PyObject *is_delete_O = Py_False;
lcb_error_t err;
float timeout = 0.0;
float interval = 0.0;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = {
"keys",
"persist_to",
"replicate_to",
"check_removed",
"timeout",
"interval",
NULL
};
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "OBB|Off", kwlist,
&keys,
&persist_to, &replicate_to,
&is_delete_O, &timeout, &interval);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
rv = pycbc_oputil_check_sequence(keys, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
rv = pycbc_common_vars_init(&cv, self, PYCBC_ARGOPT_MULTI, ncmds, 0);
if (rv < 0) {
return NULL;
}
dopts.v.v0.cap_max = persist_to < 0 || replicate_to < 0;
dopts.v.v0.check_delete = is_delete_O && PyObject_IsTrue(is_delete_O);
dopts.v.v0.timeout = (lcb_uint32_t)(timeout * 1000000.0);
dopts.v.v0.interval = (lcb_uint32_t)(interval * 1000000.0);
dopts.v.v0.persist_to = persist_to;
dopts.v.v0.replicate_to = replicate_to;
cv.mctx = lcb_endure3_ctxnew(self->instance, &dopts, &err);
if (cv.mctx == NULL) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
rv = pycbc_oputil_iter_multi(self, seqtype, keys, &cv, PYCBC_CMD_ENDURE,
handle_single_keyop, NULL);
if (rv < 0) {
goto GT_DONE;
}
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
static PyObject *
keyop_common(pycbc_Bucket *self, PyObject *args, PyObject *kwargs, int optype,
int argopts)
{
int rv;
Py_ssize_t ncmds = 0;
pycbc_seqtype_t seqtype;
PyObject *casobj = NULL;
PyObject *is_quiet = NULL;
PyObject *kobj = NULL;
char persist_to = 0, replicate_to = 0;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = {
"keys", "cas", "quiet", "persist_to", "replicate_to", NULL
};
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
"O|OOBB",
kwlist,
&kobj,
&casobj,
&is_quiet,
&persist_to, &replicate_to);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_check_sequence(kobj, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
if (casobj && PyObject_IsTrue(casobj)) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Can't pass CAS for multiple keys");
}
} else {
ncmds = 1;
}
rv = pycbc_common_vars_init(&cv, self, argopts, ncmds, 0);
if (rv < 0) {
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_iter_multi(self, seqtype, kobj, &cv, optype,
handle_single_keyop, NULL);
} else {
rv = handle_single_keyop(self, &cv, optype, kobj, casobj, NULL, NULL, NULL);
}
if (rv < 0) {
goto GT_DONE;
}
if (optype == PYCBC_CMD_DELETE) {
rv = pycbc_handle_durability_args(self, &cv.mres->dur,
persist_to, replicate_to);
if (rv == 1) {
cv.mres->mropts |= PYCBC_MRES_F_DURABILITY;
} else if (rv == -1) {
goto GT_DONE;
}
if (pycbc_maybe_set_quiet(cv.mres, is_quiet) == -1) {
goto GT_DONE;
}
}
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
PyObject *
pycbc_Connection__stats(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs)
{
int rv;
int ii;
Py_ssize_t ncmds;
lcb_error_t err;
PyObject *keys = NULL;
PyObject *ret = NULL;
pycbc_MultiResult *mres = NULL;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", NULL };
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &keys);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (keys == NULL || PyObject_IsTrue(keys) == 0) {
keys = NULL;
ncmds = 1;
} else {
if (!PySequence_Check(keys)) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "keys argument must be sequence");
return NULL;
}
ncmds = PySequence_Size(keys);
}
rv = pycbc_common_vars_init(&cv, ncmds, sizeof(lcb_server_stats_cmd_t), 0);
if (rv < 0) {
return NULL;
}
if (keys) {
for (ii =0; ii < ncmds; ii++) {
char *key;
Py_ssize_t nkey;
PyObject *newkey = NULL;
PyObject *curkey = PySequence_GetItem(keys, ii);
lcb_server_stats_cmd_t *cmd = cv.cmds.stats + ii;
rv = pycbc_BufFromString(curkey, &key, &nkey, &newkey);
if (rv < 0) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS,
0,
"bad key type in stats",
curkey);
goto GT_DONE;
}
cmd->v.v0.name = key;
cmd->v.v0.nname = nkey;
cv.cmdlist.stats[ii] = cmd;
cv.enckeys[ii] = newkey;
}
} else {
cv.cmdlist.stats[0] = cv.cmds.stats;
}
mres = (pycbc_MultiResult*)pycbc_multiresult_new(self);
err = lcb_server_stats(self->instance, mres, ncmds, cv.cmdlist.stats);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
err = pycbc_oputil_wait_common(self);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
goto GT_DONE;
}
ret = (PyObject*)mres;
GT_DONE:
pycbc_common_vars_free(&cv);
/* Force multi, it's always a MultiResult */
pycbc_make_retval(PYCBC_ARGOPT_MULTI, &ret, &mres);
Py_XDECREF(mres);
return ret;
}
PyObject *
pycbc_Connection__cntl(pycbc_Connection *self, PyObject *args)
{
int cmd = 0, mode = 0;
PyObject *val = NULL;
PyObject *ret = NULL;
lcb_error_t err = LCB_SUCCESS;
if (!PyArg_ParseTuple(args, "i|O", &cmd, &val)) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
mode = (val == NULL) ? CNTL_GET : CNTL_SET;
switch (cmd) {
/** Timeout parameters */
case CNTL_OP_TIMEOUT:
case CNTL_VIEW_TIMEOUT:
case CNTL_HTTP_TIMEOUT:
case CNTL_DURABILITY_INTERVAL:
case CNTL_DURABILITY_TIMEOUT:
case CNTL_CONFIGURATION_TIMEOUT: {
ret = handle_float_tmo(self->instance, cmd, mode, val, &err);
if (ret) {
return ret;
}
break;
}
/** Boolean values */
case CNTL_SKIP_CONFIGURATION_ERRORS_ON_CONNECT:
case CNTL_RANDOMIZE_BOOTSTRAP_HOSTS:
case CNTL_CONFIG_CACHE_LOADED: {
ret = handle_boolean(self->instance, cmd, mode, val, &err);
break;
}
/** int values */
case CNTL_MAX_REDIRECTS: {
ret = handle_intval(self->instance, cmd, mode, val, &err);
break;
}
default: {
if (val == NULL) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Unknown cntl");
return NULL;
} else {
if (PyBool_Check(val)) {
ret = handle_boolean(self->instance, cmd, mode, val, &err);
} else if (PyFloat_Check(val)) {
ret = handle_float_tmo(self->instance, cmd, mode, val, &err);
} else if (PyNumber_Check(val)) {
ret = handle_float_tmo(self->instance, cmd, mode, val, &err);
} else {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0,
"Couldn't determine type for cntl");
return NULL;
}
}
/** not reached */
abort();
break;
}
}
if (ret) {
return ret;
}
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, err, "lcb_cntl failed");
return NULL;
}
PyObject *
pycbc_Bucket__view_request(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
PyObject *ret = NULL;
pycbc_MultiResult *mres = NULL;
pycbc_ViewResult *vres = NULL;
lcb_CMDVIEWQUERY vcmd = { 0 };
viewpath_st vp = { NULL };
lcb_error_t rc;
const char *view = NULL, *design = NULL;
PyObject *options = NULL;
int flags;
static char *kwlist[] = { "design", "view", "options", "_flags", NULL };
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "ss|Oi", kwlist,
&design, &view, &options, &flags);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (-1 == pycbc_oputil_conn_lock(self)) {
return NULL;
}
if (self->pipeline_queue) {
PYCBC_EXC_WRAP(PYCBC_EXC_PIPELINE, 0,
"HTTP/View Requests cannot be executed in "
"pipeline context");
goto GT_DONE;
}
mres = (pycbc_MultiResult *)pycbc_multiresult_new(self);
vres = (pycbc_ViewResult *)PYCBC_TYPE_CTOR(&pycbc_ViewResultType);
vres->base.htype = PYCBC_HTTP_HVIEW;
pycbc_httpresult_init(&vres->base, mres);
rv = get_viewpath_str(self, &vp, options);
if (rv != 0) {
goto GT_DONE;
}
vcmd.ddoc = design;
vcmd.nddoc = strlen(design);
vcmd.view = view;
vcmd.nview = strlen(view);
vcmd.optstr = vp.optstr;
vcmd.noptstr = vp.noptstr;
vcmd.postdata = vp.body;
vcmd.npostdata = vp.nbody;
vcmd.handle = &vres->base.u.vh;
vcmd.callback = row_callback;
vcmd.cmdflags = flags;
vres->rows = PyList_New(0);
vres->base.format = PYCBC_FMT_JSON;
rc = lcb_view_query(self->instance, mres, &vcmd);
if (rc != LCB_SUCCESS) {
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, rc, "Couldn't schedule view");
goto GT_DONE;
}
ret = (PyObject*)mres;
mres = NULL; /* Avoid GT_DONE decref */
GT_DONE:
Py_XDECREF(mres);
Py_XDECREF(vp.bk);
pycbc_oputil_conn_unlock(self);
return ret;
}
static int
Bucket__init__(pycbc_Bucket *self,
PyObject *args, PyObject *kwargs)
{
int rv;
int conntype = LCB_TYPE_BUCKET;
lcb_error_t err;
PyObject *unlock_gil_O = NULL;
PyObject *iops_O = NULL;
PyObject *dfl_fmt = NULL;
PyObject *tc = NULL;
struct lcb_create_st create_opts = { 0 };
/**
* This xmacro enumerates the constructor keywords, targets, and types.
* This was converted into an xmacro to ease the process of adding or
* removing various parameters.
*/
#define XCTOR_ARGS(X) \
X("connection_string", &create_opts.v.v3.connstr, "z") \
X("connstr", &create_opts.v.v3.connstr, "z") \
X("username", &create_opts.v.v3.username, "z") \
X("password", &create_opts.v.v3.passwd, "z") \
X("quiet", &self->quiet, "I") \
X("unlock_gil", &unlock_gil_O, "O") \
X("transcoder", &tc, "O") \
X("default_format", &dfl_fmt, "O") \
X("lockmode", &self->lockmode, "i") \
X("_flags", &self->flags, "I") \
X("_conntype", &conntype, "i") \
X("_iops", &iops_O, "O")
static char *kwlist[] = {
#define X(s, target, type) s,
XCTOR_ARGS(X)
#undef X
NULL
};
#define X(s, target, type) type
static char *argspec = "|" XCTOR_ARGS(X);
#undef X
if (self->init_called) {
PyErr_SetString(PyExc_RuntimeError, "__init__ was already called");
return -1;
}
self->init_called = 1;
self->flags = 0;
self->unlock_gil = 1;
self->lockmode = PYCBC_LOCKMODE_EXC;
#define X(s, target, type) target,
rv = PyArg_ParseTupleAndKeywords(args, kwargs, argspec, kwlist,
XCTOR_ARGS(X) NULL);
#undef X
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return -1;
}
if (unlock_gil_O && PyObject_IsTrue(unlock_gil_O) == 0) {
self->unlock_gil = 0;
}
create_opts.version = 3;
create_opts.v.v3.type = conntype;
if (iops_O && iops_O != Py_None) {
self->iopswrap = pycbc_iowrap_new(self, iops_O);
create_opts.v.v3.io = pycbc_iowrap_getiops(self->iopswrap);
self->unlock_gil = 0;
}
if (dfl_fmt == Py_None || dfl_fmt == NULL) {
/** Set to 0 if None or NULL */
dfl_fmt = pycbc_IntFromL(PYCBC_FMT_JSON);
} else {
Py_INCREF(dfl_fmt); /* later decref */
}
rv = Bucket_set_format(self, dfl_fmt, NULL);
Py_XDECREF(dfl_fmt);
if (rv == -1) {
return rv;
}
/** Set the transcoder */
if (tc && Bucket_set_transcoder(self, tc, NULL) == -1) {
return -1;
}
#if defined(WITH_THREAD)
if (!self->unlock_gil) {
self->lockmode = PYCBC_LOCKMODE_NONE;
}
if (self->lockmode != PYCBC_LOCKMODE_NONE) {
self->lock = PyThread_allocate_lock();
}
#else
self->unlock_gil = 0;
self->lockmode = PYCBC_LOCKMODE_NONE;
#endif
err = lcb_create(&self->instance, &create_opts);
if (err != LCB_SUCCESS) {
self->instance = NULL;
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, err,
"Couldn't create instance. Either bad "
"credentials/hosts/bucket names were "
"passed, or there was an internal error in creating the "
"object");
return -1;
}
if (pycbc_log_handler) {
err = lcb_cntl(self->instance, LCB_CNTL_SET, LCB_CNTL_LOGGER,
&pycbc_lcb_logprocs);
if (err != LCB_SUCCESS) {
self->instance = NULL;
PYCBC_EXC_WRAP(PYCBC_EXC_LCBERR, err, "Couldn't create log handler");
return -1;
}
}
pycbc_callbacks_init(self->instance);
lcb_set_cookie(self->instance, self);
{
const char *bucketstr;
err = lcb_cntl(self->instance, LCB_CNTL_GET, LCB_CNTL_BUCKETNAME, &bucketstr);
if (err == LCB_SUCCESS && bucketstr != NULL) {
self->bucket = pycbc_SimpleStringZ(bucketstr);
}
}
return 0;
}
PyObject *
pycbc_Connection__http_request(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs)
{
int rv;
int method;
int reqtype;
int quiet = 0;
unsigned short value_format = 0;
lcb_error_t err;
const char *body = NULL;
PyObject *ret = NULL;
PyObject *quiet_O = NULL;
PyObject *fetch_headers_O = Py_False;
pycbc_strlen_t nbody = 0;
const char *path = NULL;
const char *content_type = NULL;
pycbc_HttpResult *htres;
lcb_http_request_t htreq = NULL;
lcb_http_cmd_t htcmd = { 0 };
static char *kwlist[] = {
"type", "method", "path", "content_type", "post_data",
"response_format", "quiet", "fetch_headers", NULL
};
rv = PyArg_ParseTupleAndKeywords(args, kwargs,
"iis|zz#HOO", kwlist,
&reqtype,
&method,
&path,
&content_type,
&body,
&nbody,
&value_format,
&quiet_O,
&fetch_headers_O);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (quiet_O != NULL) {
if (quiet_O == Py_None) {
quiet = 0;
} else {
quiet = PyObject_IsTrue(quiet_O);
}
}
htres = pycbc_httpresult_new(self);
htres->key = pycbc_SimpleStringZ(path);
htres->format = value_format;
if (fetch_headers_O && PyObject_IsTrue(fetch_headers_O)) {
htres->headers = PyDict_New();
}
htcmd.v.v1.body = body;
htcmd.v.v1.nbody = nbody;
htcmd.v.v1.content_type = content_type;
htcmd.v.v1.path = path;
htcmd.v.v1.npath = strlen(path);
htcmd.v.v1.method = method;
err = lcb_make_http_request(self->instance,
htres,
reqtype,
&htcmd,
&htreq);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
err = pycbc_oputil_wait_common(self);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
goto GT_DONE;
}
if (quiet == 0 && pycbc_httpresult_ok(htres) == 0) {
PYCBC_EXC_WRAP_EX(htres->rc ? PYCBC_EXC_LCBERR : PYCBC_EXC_HTTP,
htres->rc,
"HTTP Request failed. Examine 'objextra' for "
"full result",
htres->key,
(PyObject*)htres);
goto GT_DONE;
}
ret = (PyObject*)htres;
htres = NULL;
GT_DONE:
Py_XDECREF(htres);
return ret;
}
PyObject *
arithmetic_common(pycbc_Bucket *self,
PyObject *args,
PyObject *kwargs,
int optype,
int argopts)
{
int rv;
Py_ssize_t ncmds;
struct arithmetic_common_vars global_params = { 0 };
pycbc_seqtype_t seqtype;
PyObject *all_initial_O = NULL;
PyObject *all_ttl_O = NULL;
PyObject *collection;
lcb_error_t err;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", "delta", "initial", "ttl", NULL };
global_params.delta = 1;
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "O|LOO", kwlist,
&collection,
&global_params.delta,
&all_initial_O,
&all_ttl_O);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
rv = pycbc_get_ttl(all_ttl_O, &global_params.ttl, 1);
if (rv < 0) {
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_check_sequence(collection, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
} else {
ncmds = 1;
}
if (all_initial_O && PyNumber_Check(all_initial_O)) {
global_params.create = 1;
global_params.initial = pycbc_IntAsULL(all_initial_O);
}
rv = pycbc_common_vars_init(&cv,
self,
argopts,
ncmds,
sizeof(lcb_arithmetic_cmd_t),
0);
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_iter_multi(self,
seqtype,
collection,
&cv,
optype,
handle_single_arith,
&global_params);
} else {
rv = handle_single_arith(self,
&cv, optype, collection, NULL, NULL, NULL, 0,
&global_params);
}
if (rv < 0) {
goto GT_DONE;
}
err = lcb_arithmetic(self->instance, cv.mres, ncmds, cv.cmdlist.arith);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
static PyObject *
keyop_common(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs,
int optype,
int argopts)
{
int rv;
int ii;
Py_ssize_t ncmds = 0;
pycbc_seqtype_t seqtype;
PyObject *casobj = NULL;
PyObject *ret = NULL;
PyObject *is_quiet = NULL;
PyObject *kobj = NULL;
pycbc_MultiResult *mres = NULL;
lcb_error_t err;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = { "keys", "cas", "quiet", NULL };
rv = PyArg_ParseTupleAndKeywords(args,
kwargs,
"O|OO",
kwlist,
&kobj,
&casobj,
&is_quiet);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
rv = pycbc_oputil_check_sequence(kobj, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
if (casobj && PyObject_IsTrue(casobj)) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Can't pass CAS for multiple keys");
}
} else {
ncmds = 1;
}
rv = pycbc_common_vars_init(&cv, ncmds, sizeof(lcb_remove_cmd_t), 0);
if (rv < 0) {
return NULL;
}
if (argopts & PYCBC_ARGOPT_MULTI) {
Py_ssize_t dictpos = 0;
PyObject *curseq, *iter = NULL;
curseq = pycbc_oputil_iter_prepare(seqtype, kobj, &iter, &dictpos);
if (!curseq) {
goto GT_DONE;
}
for (ii = 0; ii < ncmds; ii++) {
PyObject *curkey = NULL, *curvalue = NULL;
rv = pycbc_oputil_sequence_next(seqtype,
curseq,
&dictpos,
ii,
&curkey,
&curvalue);
if (rv < 0) {
goto GT_ITER_DONE;
}
rv = handle_single_keyop(self, curkey, curvalue, ii, optype, &cv);
Py_XDECREF(curkey);
Py_XDECREF(curvalue);
if (rv < 0) {
goto GT_ITER_DONE;
}
}
GT_ITER_DONE:
Py_XDECREF(iter);
if (rv < 0) {
goto GT_DONE;
}
} else {
rv = handle_single_keyop(self, kobj, casobj, 0, optype, &cv);
if (rv < 0) {
goto GT_DONE;
}
}
mres = (pycbc_MultiResult*)pycbc_multiresult_new(self);
if (optype == PYCBC_CMD_DELETE) {
if (pycbc_maybe_set_quiet(mres, is_quiet) == -1) {
goto GT_DONE;
}
err = lcb_remove(self->instance, mres, ncmds, cv.cmdlist.remove);
} else {
err = lcb_unlock(self->instance, mres, ncmds, cv.cmdlist.unlock);
}
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
err = pycbc_oputil_wait_common(self);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
goto GT_DONE;
}
if (!pycbc_multiresult_maybe_raise(mres)) {
ret = (PyObject*)mres;
}
GT_DONE:
pycbc_common_vars_free(&cv);
ret = pycbc_make_retval(argopts, &ret, &mres);
Py_XDECREF(mres);
return ret;
}
PyObject *
pycbc_Connection__http_request(pycbc_Connection *self,
PyObject *args,
PyObject *kwargs)
{
int rv;
int method;
int reqtype;
unsigned short value_format = 0;
lcb_error_t err;
const char *body = NULL;
PyObject *ret = NULL;
PyObject *quiet_O = NULL;
PyObject *chunked_O = NULL;
PyObject *fetch_headers_O = Py_False;
pycbc_strlen_t nbody = 0;
const char *path = NULL;
const char *content_type = NULL;
pycbc_HttpResult *htres;
lcb_http_request_t l_htreq;
lcb_http_cmd_t htcmd = { 0 };
static char *kwlist[] = {
"type", "method", "path", "content_type", "post_data",
"response_format", "quiet", "fetch_headers",
"chunked", NULL
};
rv = PyArg_ParseTupleAndKeywords(args, kwargs,
"iis|zz#HOOO", kwlist,
&reqtype,
&method,
&path,
&content_type,
&body,
&nbody,
&value_format,
&quiet_O,
&fetch_headers_O,
&chunked_O);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
if (-1 == pycbc_oputil_conn_lock(self)) {
return NULL;
}
htres = pycbc_httpresult_new(self);
htres->key = pycbc_SimpleStringZ(path);
htres->format = value_format;
htres->htflags = 0;
if (quiet_O != NULL && quiet_O != Py_None && PyObject_IsTrue(quiet_O)) {
htres->htflags |= PYCBC_HTRES_F_QUIET;
}
if (fetch_headers_O && PyObject_IsTrue(fetch_headers_O)) {
htres->headers = PyDict_New();
}
if (chunked_O && PyObject_IsTrue(chunked_O)) {
htcmd.v.v0.chunked = 1;
htres->rctx = lcbex_vrow_create();
htres->rctx->callback = http_vrow_callback;
htres->rctx->user_cookie = htres;
htres->htflags |= PYCBC_HTRES_F_CHUNKED;
}
htcmd.v.v1.body = body;
htcmd.v.v1.nbody = nbody;
htcmd.v.v1.content_type = content_type;
htcmd.v.v1.path = path;
htcmd.v.v1.npath = strlen(path);
htcmd.v.v1.method = method;
err = lcb_make_http_request(self->instance,
htres,
reqtype,
&htcmd,
&l_htreq);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
htres->htreq = l_htreq;
if (htcmd.v.v0.chunked) {
ret = (PyObject*)htres;
htres = NULL;
goto GT_DONE;
}
self->nremaining++;
err = pycbc_oputil_wait_common(self);
if (err != LCB_SUCCESS) {
self->nremaining--;
PYCBC_EXCTHROW_WAIT(err);
goto GT_DONE;
}
if (maybe_raise(htres)) {
goto GT_DONE;
}
ret = (PyObject*)htres;
htres = NULL;
GT_DONE:
Py_XDECREF(htres);
pycbc_oputil_conn_unlock(self);
return ret;
}
