def _handle_done(self, resp, mres):
self.done = True
self._c_handle = None
if resp.rc:
if resp.rc == C.LCB_HTTP_ERROR:
try:
raise PyCBC.exc_http(self.value)
except:
mres._add_err(sys.exc_info())
else:
mres._add_bad_rc(resp.rc, self)
if resp.nvalue:
self.value = buf2str(resp.value, resp.nvalue)
try:
self.value = PyCBC.json_decode(self.value)
except:
pass
if resp.htresp:
if not self.value and resp.htresp.nbody:
self.value = buf2str(resp.htresp.body, resp.htresp.nbody)
self.http_status = resp.htresp.htstatus
if self._parent._is_async:
try:
mres._maybe_throw()
self._invoke_async(mres, is_final=True)
except:
mres.errback(mres, *sys.exc_info())
finally:
del self._parent
def _handle_done(self, resp, mres):
self.done = True
self._c_handle = None
if resp.rc:
if resp.rc == C.LCB_HTTP_ERROR:
try:
raise PyCBC.exc_http(self.value)
except:
mres._add_err(sys.exc_info())
else:
mres._add_bad_rc(resp.rc, self)
if resp.nvalue:
self.value = buf2str(resp.value, resp.nvalue)
try:
self.value = PyCBC.json_decode(self.value)
except:
pass
if resp.htresp:
if not self.value and resp.htresp.nbody:
self.value = buf2str(resp.htresp.body, resp.htresp.nbody)
self.http_status = resp.htresp.htstatus
if self._parent._is_async:
try:
mres._maybe_throw()
self._invoke_async(mres, is_final=True)
except:
mres.errback(mres, *sys.exc_info())
finally:
del self._parent
def _modify_helpers(**kw):
ret = {}
for k, v in kw.items():
ret[k] = PyCBC.get(k)
PyCBC.configure(k, v)
# print("Modification requested!")
return ret
def _maybe_throw(self):
"""
Throw any deferred exceptions set via :meth:`_add_err`
"""
if self._err:
ex_cls, ex_obj, ex_bt = self._err
self._err = None
PyCBC.raise_helper(ex_cls, ex_obj, ex_bt)
def _maybe_throw(self):
"""
Throw any deferred exceptions set via :meth:`_add_err`
"""
if self._err:
ex_cls, ex_obj, ex_bt = self._err
self._err = None
PyCBC.raise_helper(ex_cls, ex_obj, ex_bt)
def _modify_helpers(**kw):
ret = {}
for k, v in kw.items():
ret[k] = PyCBC.get(k)
PyCBC.configure(k, v)
# print("Modification requested!")
return ret
def _handle_response(self, mres, resp):
result = self
headers = result.headers
if resp.headers:
ix = 0
while True:
pp = resp.headers[ix]
if pp == ffi.NULL:
break
key = from_cstring(resp.headers[ix])
value = from_cstring(resp.headers[ix+1])
headers[key] = value
ix += 2
result.rc = resp.rc
result.htcode = resp.htstatus
if resp.rc:
mres._add_bad_rc(resp.rc)
elif not self.success and not mres._quiet:
try:
raise PyCBC.exc_http(self.value, response=self)
except PyCBC.default_exception:
mres._add_err(sys.exc_info())
if resp.nbody:
buf = bytes(ffi.buffer(ffi.cast('const char*', resp.body), resp.nbody))
tc = self._parent._tc
try:
result.http_data = tc.decode_value(buf, self._format)
except:
if not self._quiet:
mres._add_err(sys.exc_info())
result.http_data = buf
def __init__(self,
path,
method=C.LCB_HTTP_METHOD_GET,
type=C.LCB_HTTP_TYPE_VIEW,
response_format=FMT_JSON,
content_type='application_json',
post_data=None,
quiet=False):
super(HttpRequest, self).__init__()
self.key = path
self._parent = None
self._format = response_format
self._quiet = quiet
self._type = type
if not path:
raise PyCBC.exc_args('Must provide path')
def _do_schedule(parent, mres):
bm = BufManager(ffi)
cmd = ffi.new('lcb_CMDHTTP*')
cmd.type = self._type
cmd.method = method
C._Cb_set_key(cmd, *bm.new_cbuf(path))
cmd.body, cmd.nbody = bm.new_cbuf(post_data)
cmd.content_type = bm.new_cstr(content_type)
rc = C.lcb_http3(parent._lcbh, mres._cdata, cmd)
if rc:
raise PyCBC.exc_lcb(rc, 'Scheduling HTTP request')
self.__sched = _do_schedule
def _pipeline_end(self):
if self._pipeline_queue is None:
PyCBC.exc_pipeline('No pipeline in progress!')
C.lcb_wait(self._lcbh)
results = self._pipeline_queue
self._pipeline_queue = None
rv = []
for mres in results:
mres._maybe_throw()
if mres._is_single:
rv.append(mres.unwrap_single())
else:
rv.append(mres)
return rv
def __init__(self, path, method=C.LCB_HTTP_METHOD_GET,
type=C.LCB_HTTP_TYPE_VIEW, response_format=FMT_JSON,
content_type='application_json', post_data=None, quiet=False):
super(HttpRequest, self).__init__()
self.key = path
self._parent = None
self._format = response_format
self._quiet = quiet
self._type = type
if not path:
raise PyCBC.exc_args('Must provide path')
def _do_schedule(parent, mres):
bm = BufManager(ffi)
cmd = ffi.new('lcb_CMDHTTP*')
cmd.type = self._type
cmd.method = method
C._Cb_set_key(cmd, *bm.new_cbuf(path))
cmd.body, cmd.nbody = bm.new_cbuf(post_data)
cmd.content_type = bm.new_cstr(content_type)
rc = C.lcb_http3(parent._lcbh, mres._cdata, cmd)
if rc:
raise PyCBC.exc_lcb(rc, 'Scheduling HTTP request')
self.__sched = _do_schedule
def _do_lock(self):
if self._lockmode == LOCKMODE_NONE:
return
elif self._lockmode == LOCKMODE_EXC:
if not self._lock.acquire(False):
raise PyCBC.exc_lock()
else:
self._lock.acquire(True)
def _thr_lockop(self, arg):
# Used by tests
if not self._lockmode:
raise PyCBC.exc_lock()
if not arg:
self._lock.acquire(True)
else:
self._lock.release()
def _do_schedule(parent, mres):
bm = BufManager(ffi)
cmd = ffi.new('lcb_CMDHTTP*')
cmd.type = self._type
cmd.method = method
C._Cb_set_key(cmd, *bm.new_cbuf(path))
cmd.body, cmd.nbody = bm.new_cbuf(post_data)
cmd.content_type = bm.new_cstr(content_type)
rc = C.lcb_http3(parent._lcbh, mres._cdata, cmd)
if rc:
raise PyCBC.exc_lcb(rc, 'Scheduling HTTP request')
def _do_schedule(parent, mres):
bm = BufManager(ffi)
cmd = ffi.new('lcb_CMDHTTP*')
cmd.type = self._type
cmd.method = method
C._Cb_set_key(cmd, *bm.new_cbuf(path))
cmd.body, cmd.nbody = bm.new_cbuf(post_data)
cmd.content_type = bm.new_cstr(content_type)
rc = C.lcb_http3(parent._lcbh, mres._cdata, cmd)
if rc:
raise PyCBC.exc_lcb(rc, 'Scheduling HTTP request')
def _on_single_row(self, instance, cbtype, resp):
mres = ffi.from_handle(resp.cookie)
if resp.rflags & C.LCB_RESP_F_FINAL:
if resp.nvalue:
self.value = bytes(ffi.buffer(resp.value, resp.nvalue))
self._step(mres, True)
self._done(mres, resp.rc,
resp.htresp.htstatus if resp.htresp else 0)
return
# Actually parse the row here!
row = {}
if resp.nkey:
row['key'] = PyCBC.json_decode(buf2str(resp.key, resp.nkey))
if resp.nvalue:
row['value'] = PyCBC.json_decode(buf2str(resp.value, resp.nvalue))
if resp.docid:
# Document ID is always a simple string, so no need to decode
row['id'] = buf2str(resp.docid, resp.ndocid)
if resp.docresp:
py_doc = ValueResult()
l_doc = resp.docresp
row['__DOCRESULT__'] = py_doc
py_doc.key = row['id']
py_doc.flags = l_doc.itmflags
py_doc.cas = l_doc.cas
py_doc.rc = l_doc.rc
if not resp.docresp.rc:
buf = bytes(ffi.buffer(l_doc.value, l_doc.nvalue))
try:
tc = self._parent._tc
py_doc.value = tc.decode_value(buf, py_doc.flags)
except:
py_doc.value = buf[::]
# So now that we have a row..
self.rows.append(row)
self._step(mres, False)
def _on_single_row(self, instance, cbtype, resp):
mres = ffi.from_handle(resp.cookie)
if resp.rflags & C.LCB_RESP_F_FINAL:
self._handle_done(resp, mres)
return
if resp.rc != C.LCB_SUCCESS:
mres._add_bad_rc(resp.rc, self)
return
row = {}
if resp.nkey:
row['key'] = PyCBC.json_decode(buf2str(resp.key, resp.nkey))
if resp.nvalue:
row['value'] = PyCBC.json_decode(buf2str(resp.value, resp.nvalue))
if resp.docid:
# Document ID is always a simple string, so no need to decode
row['id'] = buf2str(resp.docid, resp.ndocid)
if resp.docresp:
py_doc = ValueResult()
l_doc = resp.docresp
row['__DOCRESULT__'] = py_doc
py_doc.key = row['id']
py_doc.flags = l_doc.itmflags
py_doc.cas = l_doc.cas
py_doc.rc = l_doc.rc
if not resp.docresp.rc:
buf = bytes(ffi.buffer(l_doc.value, l_doc.nvalue))
try:
tc = self._parent._tc
py_doc.value = tc.decode_value(buf, py_doc.flags)
except:
py_doc.value = buf[::]
# So now that we have a row..
self.rows.append(row)
if self._parent._is_async:
self._invoke_async(mres)
def _on_single_row(self, instance, cbtype, resp):
mres = ffi.from_handle(resp.cookie)
if resp.rflags & C.LCB_RESP_F_FINAL:
self._handle_done(resp, mres)
return
if resp.rc != C.LCB_SUCCESS:
mres._add_bad_rc(resp.rc, self)
return
row = {}
if resp.nkey:
row['key'] = PyCBC.json_decode(buf2str(resp.key, resp.nkey))
if resp.nvalue:
row['value'] = PyCBC.json_decode(buf2str(resp.value, resp.nvalue))
if resp.docid:
# Document ID is always a simple string, so no need to decode
row['id'] = buf2str(resp.docid, resp.ndocid)
if resp.docresp:
py_doc = ValueResult()
l_doc = resp.docresp
row['__DOCRESULT__'] = py_doc
py_doc.key = row['id']
py_doc.flags = l_doc.itmflags
py_doc.cas = l_doc.cas
py_doc.rc = l_doc.rc
if not resp.docresp.rc:
buf = bytes(ffi.buffer(l_doc.value, l_doc.nvalue))
try:
tc = self._parent._tc
py_doc.value = tc.decode_value(buf, py_doc.flags)
except:
py_doc.value = buf[::]
# So now that we have a row..
self.rows.append(row)
if self._parent._is_async:
self._invoke_async(mres)
def _on_single_row(self, instance, cbtype, resp):
mres = ffi.from_handle(resp.cookie)
if resp.rflags & C.LCB_RESP_F_FINAL:
if resp.nrow:
self.value = bytes(ffi.buffer(resp.row, resp.nrow))
self._step(mres, True)
self._done(mres, resp.rc,
resp.htresp.htstatus if resp.htresp else 0)
else:
# Simply parse the row
try:
row = PyCBC.json_decode(bytes(ffi.buffer(resp.row, resp.nrow)))
self.rows.append(row)
except:
mres._add_err(sys.exc_info())
self._step(mres, False)
def _handle_response(self, mres, resp):
result = self
headers = result.headers
if resp.headers:
ix = 0
while True:
pp = resp.headers[ix]
if pp == ffi.NULL:
break
key = from_cstring(resp.headers[ix])
value = from_cstring(resp.headers[ix + 1])
headers[key] = value
ix += 2
result.rc = resp.rc
result.htcode = resp.htstatus
if resp.rc:
mres._add_bad_rc(resp.rc)
elif not self.success and not mres._quiet:
try:
raise PyCBC.exc_http(self.value, response=self)
except PyCBC.default_exception:
mres._add_err(sys.exc_info())
if resp.nbody:
buf = bytes(
ffi.buffer(ffi.cast('const char*', resp.body), resp.nbody))
tc = self._parent._tc
try:
result.http_data = tc.decode_value(buf, self._format)
except:
if not self._quiet:
mres._add_err(sys.exc_info())
result.http_data = buf
def __repr__(self):
return PyCBC.result_reprfunc(self)
def _do_json_decode(self, value):
return PyCBC.json_decode(value)
def _do_json_decode(self, value):
return PyCBC.json_decode(value)
def _chk_no_pipeline(self, msg='Pipeline active'):
if self._pipeline_queue is not None:
PyCBC.exc_pipeline(msg)
def make_result(self, key, value):
vr = PyCBC.sd_result_type() # type: _SDResult
vr.key = key
vr._specs = value
return vr
def __repr__(self):
return PyCBC.obsinfo_reprfunc(self)
def __repr__(self):
return PyCBC.result_reprfunc(self)
def __repr__(self):
return PyCBC.obsinfo_reprfunc(self)
def _get_helper(k):
return PyCBC.get(k)
def _get_helper(k):
return PyCBC.get(k)
def _do_pickle_decode(self, value):
return PyCBC.pickle_decode(value)
def _add_exc_wrap(self, *args, **kw):
try:
PyCBC.exc_common(*args, **kw)
except PyCBC.default_exception:
self._add_err(sys.exc_info())
def _do_pickle_decode(self, value):
return PyCBC.pickle_decode(value)
