static PyObject*
Bucket__connect(pycbc_Bucket *self)
{
lcb_error_t err;
if (self->flags & PYCBC_CONN_F_CONNECTED) {
Py_RETURN_NONE;
}
err = lcb_connect(self->instance);
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 NULL;
}
pycbc_oputil_wait_common(self);
if ((self->flags & PYCBC_CONN_F_ASYNC) == 0) {
err = lcb_get_bootstrap_status(self->instance);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
return NULL;
}
}
Py_RETURN_NONE;
}
/**
* Fetches a bunch of results from the network. Returns False when
* no more results remain.
*/
PyObject *
pycbc_HttpResult__fetch(pycbc_HttpResult *self)
{
lcb_error_t err;
PyObject *ret = NULL;
if (-1 == pycbc_oputil_conn_lock(self->parent)) {
return NULL;
}
if (!self->htreq) {
ret = Py_None;
Py_INCREF(ret);
goto GT_RET;
}
if (self->parent->flags & PYCBC_CONN_F_ASYNC) {
PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0,
"_fetch() should not be called with an async "
"connection");
goto GT_RET;
} else if (self->parent->pipeline_queue) {
PYCBC_EXC_WRAP(PYCBC_EXC_PIPELINE, 0,
"HTTP requests cannot be executed in pipeline context");
}
if (!self->rowsbuf) {
self->rowsbuf = PyList_New(0);
}
err = pycbc_oputil_wait_common(self->parent);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
goto GT_RET;
} else {
if (maybe_raise(self)) {
goto GT_RET;
}
ret = self->rowsbuf;
self->rowsbuf = NULL;
}
if (!pycbc_assert(self->parent->nremaining == 0)) {
fprintf(stderr, "Remaining count unexpected. Adjusting");
self->parent->nremaining = 0;
}
GT_RET:
pycbc_oputil_conn_unlock(self->parent);
return ret;
}
PyObject *
pycbc_Bucket__end_pipeline(pycbc_Bucket *self)
{
PyObject *rv;
int ii;
if (!self->pipeline_queue) {
PYCBC_EXC_WRAP(PYCBC_EXC_PIPELINE, 0,
"No pipeline in progress");
return NULL;
}
rv = self->pipeline_queue;
if (!self->nremaining) {
goto GT_DONE;
}
pycbc_oputil_wait_common(self);
pycbc_assert(self->nremaining == 0);
for (ii = 0; ii < PyList_GET_SIZE(self->pipeline_queue); ii++) {
PyObject *retitem;
pycbc_MultiResult *mres =
(pycbc_MultiResult *)PyList_GET_ITEM(self->pipeline_queue, ii);
if (pycbc_multiresult_maybe_raise(mres)) {
rv = NULL;
break;
}
/** Returns new reference to something */
retitem = pycbc_multiresult_get_result(mres);
if (retitem != (PyObject *)mres) {
PyList_SetItem(self->pipeline_queue, ii, retitem);
} else {
Py_DECREF(mres);
}
}
GT_DONE:
if (rv) {
Py_INCREF(rv);
pycbc_assert(rv == self->pipeline_queue);
}
Py_XDECREF(self->pipeline_queue);
self->pipeline_queue = NULL;
return rv;
}
/**
* Fetches a bunch of results from the network. Returns False when
* no more results remain.
*/
PyObject *
pycbc_HttpResult__fetch(pycbc_HttpResult *self)
{
lcb_error_t err;
PyObject *ret = NULL;
if (-1 == pycbc_oputil_conn_lock(self->parent)) {
return NULL;
}
if (!self->htreq) {
ret = Py_None;
Py_INCREF(ret);
goto GT_RET;
}
if (!self->rowsbuf) {
self->rowsbuf = PyList_New(0);
}
err = pycbc_oputil_wait_common(self->parent);
if (err != LCB_SUCCESS) {
PYCBC_EXCTHROW_WAIT(err);
goto GT_RET;
} else {
if (maybe_raise(self)) {
goto GT_RET;
}
ret = self->rowsbuf;
self->rowsbuf = NULL;
}
if (!pycbc_assert(self->parent->nremaining == 0)) {
fprintf(stderr, "Remaining count unexpected. Adjusting");
self->parent->nremaining = 0;
}
GT_RET:
pycbc_oputil_conn_unlock(self->parent);
return ret;
}
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 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_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;
}
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;
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 *
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;
}
