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 int
modify_event_python(pycbc_IOPSWrapper *pio, pycbc_Event *ev,
pycbc_evaction_t action, lcb_socket_t newsock, void *arg)
{
int ret;
PyObject *result;
PyObject *o_arg;
PyObject *meth = NULL;
PyObject *argtuple;
short flags = 0;
unsigned long usecs = 0;
argtuple = PyTuple_New(3);
Py_INCREF((PyObject *)ev);
PyTuple_SET_ITEM(argtuple, 0, (PyObject *)ev);
PyTuple_SET_ITEM(argtuple, 1, pycbc_IntFromL(action));
if (ev->type == PYCBC_EVTYPE_IO) {
flags = *(short*)arg;
o_arg = pycbc_IntFromL(flags);
((pycbc_IOEvent *)ev)->fd = newsock;
meth = pio->modevent;
} else {
usecs = *(lcb_uint32_t*)arg;
o_arg = pycbc_IntFromL(usecs);
meth = pio->modtimer;
}
PyTuple_SET_ITEM(argtuple, 2, o_arg);
result = PyObject_CallObject(meth, argtuple);
Py_DECREF(argtuple);
Py_XDECREF(result);
if (ev->type == PYCBC_EVTYPE_IO) {
pycbc_IOEvent *evio = (pycbc_IOEvent*)ev;
evio->flags = flags;
}
if (action == PYCBC_EVACTION_WATCH) {
ev->state = PYCBC_EVSTATE_ACTIVE;
} else {
ev->state = PYCBC_EVSTATE_SUSPENDED;
}
if (!result) {
ret = -1;
PYCBC_EXC_WRAP(PYCBC_EXC_INTERNAL, 0, "Couldn't invoke IO Function");
} else {
ret = 0;
}
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 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;
}
static PyObject *
IOEvent_fileno(pycbc_IOEvent *self, PyObject *args)
{
(void)args;
return pycbc_IntFromL((lcb_socket_t)self->fd);
}
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;
}
