void
http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie, lcb_error_t error, const lcb_http_resp_t *resp)
{
struct context_st *ctx = (struct context_st *)cookie;
struct bucket_st *bucket = ctx->bucket;
VALUE key, val, res;
key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
ctx->exception = cb_check_error_with_status(error,
"failed to execute HTTP request", key, resp->v.v0.status);
val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
if (ctx->exception != Qnil) {
cb_gc_protect(bucket, ctx->exception);
lcb_cancel_http_request(bucket->handle, request);
}
if (resp->v.v0.headers) {
cb_build_headers(ctx, resp->v.v0.headers);
}
if (ctx->proc != Qnil) {
if (ctx->extended) {
res = rb_class_new_instance(0, NULL, cResult);
rb_ivar_set(res, id_iv_error, ctx->exception);
rb_ivar_set(res, id_iv_operation, sym_http_request);
rb_ivar_set(res, id_iv_key, key);
rb_ivar_set(res, id_iv_value, val);
rb_ivar_set(res, id_iv_completed, Qfalse);
rb_ivar_set(res, id_iv_headers, ctx->headers_val);
} else {
res = val;
}
cb_proc_call(ctx->proc, 1, res);
}
(void)handle;
}
/*
* Execute {Bucket::CouchRequest}
*
* @since 1.2.0
*/
VALUE
cb_http_request_perform(VALUE self)
{
struct cb_http_request_st *req = DATA_PTR(self);
struct cb_context_st *ctx;
VALUE rv, exc;
lcb_error_t err;
struct cb_bucket_st *bucket = req->bucket;
if (bucket->handle == NULL) {
rb_raise(cb_eConnectError, "closed connection");
}
ctx = cb_context_alloc(bucket);
ctx->rv = Qnil;
ctx->proc = rb_block_given_p() ? rb_block_proc() : req->on_body_callback;
ctx->extended = req->extended;
ctx->request = req;
ctx->headers_val = rb_hash_new();
err = lcb_make_http_request(bucket->handle, (const void *)ctx,
req->type, &req->cmd, &req->request);
exc = cb_check_error(err, "failed to schedule document request",
STR_NEW(req->cmd.v.v0.path, req->cmd.v.v0.npath));
if (exc != Qnil) {
lcb_cancel_http_request(bucket->handle, req->request);
rb_exc_raise(exc);
}
req->running = 1;
req->ctx = ctx;
if (bucket->async) {
return Qnil;
} else {
lcb_wait(bucket->handle);
if (req->completed) {
rv = ctx->rv;
exc = ctx->exception;
cb_context_free(ctx);
if (exc != Qnil) {
rb_exc_raise(exc);
}
return rv;
} else {
return Qnil;
}
}
return Qnil;
}
void
cb_http_request_free(void *ptr)
{
struct cb_http_request_st *request = ptr;
if (request) {
request->running = 0;
if (TYPE(request->bucket_obj) == T_DATA
&& RDATA(request->bucket_obj)->dfree == (RUBY_DATA_FUNC)cb_bucket_free
&& !request->completed) {
lcb_cancel_http_request(request->bucket->handle, request->request);
}
free((char *)request->cmd.v.v0.content_type);
free((char *)request->cmd.v.v0.path);
free((char *)request->cmd.v.v0.body);
}
xfree(request);
}
static void
destroy_req(N1QLREQ *req)
{
if (req->htreq) {
lcb_cancel_http_request(req->instance, req->htreq);
req->htreq = NULL;
}
if (req->callback) {
lcb_RESPN1QL resp = { 0 };
invoke_row(req, &resp, 1);
}
if (req->parser) {
lcbjsp_free(req->parser);
}
free(req);
}
static void
HttpResult_dealloc(pycbc_HttpResult *self)
{
if (self->u.htreq) {
if (self->parent) {
if (self->htype == PYCBC_HTTP_HVIEW) {
lcb_view_cancel(self->parent->instance, self->u.vh);
} else {
lcb_cancel_http_request(self->parent->instance, self->u.htreq);
}
}
self->u.htreq = NULL;
}
Py_XDECREF(self->http_data);
Py_XDECREF(self->headers);
Py_XDECREF(self->parent);
pycbc_Result_dealloc((pycbc_Result*)self);
}
static void
HttpResult_dealloc(pycbc_HttpResult *self)
{
pycbc_Connection *parent = self->parent;
self->parent = NULL;
if (self->htreq) {
lcb_cancel_http_request(parent->instance, self->htreq);
self->htreq = NULL;
}
Py_XDECREF(self->http_data);
Py_XDECREF(parent);
Py_XDECREF(self->headers);
Py_XDECREF(self->rowsbuf);
Py_XDECREF(self->callback);
if (self->rctx) {
lcbex_vrow_free(self->rctx);
self->rctx = NULL;
}
pycbc_Result_dealloc((pycbc_Result*)self);
}
