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; }