couchbase 1.3.15 → 3.0.0.alpha.5

data/ext/couchbase_ext/utils.c

@@ -1,558 +0,0 @@
-/* vim: ft=c et ts=8 sts=4 sw=4 cino=
- *
- *   Copyright 2011, 2012 Couchbase, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "couchbase_ext.h"
-
-    void
-cb_gc_protect_ptr(struct cb_bucket_st *bucket, void *ptr, mark_f mark_func)
-{
-    st_insert(bucket->object_space, (st_index_t)ptr, (st_data_t)mark_func);
-}
-
-    void
-cb_gc_unprotect_ptr(struct cb_bucket_st *bucket, void *ptr)
-{
-    st_delete(bucket->object_space, (st_index_t*)&ptr, NULL);
-}
-
-struct proc_params_st
-{
-    struct cb_bucket_st *bucket;
-    VALUE recv;
-    ID mid;
-    int argc;
-    VALUE *argv;
-    VALUE exc;
-};
-
-    static VALUE
-do_async_error_notify(VALUE ptr)
-{
-    struct proc_params_st *p = (struct proc_params_st *)ptr;
-    return rb_funcall(p->bucket->on_error_proc, cb_id_call, 1, p->exc);
-}
-
-    void
-cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc)
-{
-    if (bucket->on_error_proc != Qnil) {
-        struct proc_params_st params;
-        int fail;
-        params.bucket = bucket;
-        params.exc = exc;
-        rb_protect(do_async_error_notify, (VALUE)&params, &fail);
-        if (fail) {
-            rb_warning("Couchbase::Bucket#on_error shouldn't raise exceptions");
-        }
-    } else {
-        if (NIL_P(bucket->exception)) {
-            bucket->exception = exc;
-        }
-    }
-}
-
-    int
-cb_bucket_connected_bang(struct cb_bucket_st *bucket, VALUE operation)
-{
-    if (bucket->type == LCB_TYPE_BUCKET &&
-            (bucket->handle == NULL || !bucket->connected)) {
-        VALUE exc = rb_exc_new2(cb_eConnectError, "not connected to the server");
-        rb_ivar_set(exc, cb_id_iv_operation, operation);
-        rb_ivar_set(exc, cb_id_iv_value, bucket->self);
-        if (bucket->async) {
-            cb_async_error_notify(bucket, exc);
-        } else {
-            rb_exc_raise(exc);
-        }
-        return 0;
-    }
-    return 1;
-}
-
-    static VALUE
-func_call_failed(VALUE ptr, VALUE exc)
-{
-    struct proc_params_st *p = (struct proc_params_st *)ptr;
-    cb_async_error_notify(p->bucket, exc);
-    return Qnil;
-}
-
-    static VALUE
-do_func_call(VALUE ptr)
-{
-    struct proc_params_st *p = (struct proc_params_st *)ptr;
-    return rb_funcall2(p->recv, p->mid, p->argc, p->argv);
-}
-
-    VALUE
-cb_proc_call(struct cb_bucket_st *bucket, VALUE recv, int argc, ...)
-{
-    VALUE *argv;
-    va_list ar;
-    int arity;
-    int ii;
-    struct proc_params_st params;
-
-    arity = FIX2INT(rb_funcall(recv, cb_id_arity, 0));
-    if (arity < 0) {
-        arity = argc;
-    }
-    if (arity > 0) {
-        va_init_list(ar, argc);
-        argv = ALLOCA_N(VALUE, argc);
-        for (ii = 0; ii < arity; ++ii) {
-            if (ii < argc) {
-                argv[ii] = va_arg(ar, VALUE);
-            } else {
-                argv[ii] = Qnil;
-            }
-        }
-        va_end(ar);
-    } else {
-        argv = NULL;
-    }
-    params.bucket = bucket;
-    params.recv = recv;
-    params.mid = cb_id_call;
-    params.argc = arity;
-    params.argv = argv;
-    return rb_rescue2(do_func_call, (VALUE)&params,
-            func_call_failed, (VALUE)&params,
-            rb_eException, (VALUE)0);
-}
-
-VALUE
-cb_hash_delete(VALUE hash, VALUE key)
-{
-    return rb_funcall(hash, cb_id_delete, 1, key);
-}
-
-/* Helper to convert return code from libcouchbase to meaningful exception.
- * Returns nil if the code considering successful and exception object
- * otherwise. Store given string to exceptions as message, and also
- * initialize +error+ attribute with given return code.  */
-    VALUE
-cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
-        lcb_http_status_t status)
-{
-    VALUE klass, exc, str;
-    char buf[300];
-
-    if ((rc == LCB_SUCCESS && (status == 0 || status / 100 == 2)) ||
-            rc == LCB_AUTH_CONTINUE) {
-        return Qnil;
-    }
-    switch (rc) {
-        case LCB_AUTH_ERROR:
-            klass = cb_eAuthError;
-            break;
-        case LCB_DELTA_BADVAL:
-            klass = cb_eDeltaBadvalError;
-            break;
-        case LCB_E2BIG:
-            klass = cb_eTooBigError;
-            break;
-        case LCB_EBUSY:
-            klass = cb_eBusyError;
-            break;
-        case LCB_EINTERNAL:
-            klass = cb_eInternalError;
-            break;
-        case LCB_EINVAL:
-            klass = cb_eInvalidError;
-            break;
-        case LCB_ENOMEM:
-            klass = cb_eNoMemoryError;
-            break;
-        case LCB_ERANGE:
-            klass = cb_eRangeError;
-            break;
-        case LCB_ETMPFAIL:
-            klass = cb_eTmpFailError;
-            break;
-        case LCB_KEY_EEXISTS:
-            klass = cb_eKeyExistsError;
-            break;
-        case LCB_KEY_ENOENT:
-            klass = cb_eNotFoundError;
-            break;
-        case LCB_DLOPEN_FAILED:
-            klass = cb_eDlopenFailedError;
-            break;
-        case LCB_DLSYM_FAILED:
-            klass = cb_eDlsymFailedError;
-            break;
-        case LCB_NETWORK_ERROR:
-            klass = cb_eNetworkError;
-            break;
-        case LCB_NOT_MY_VBUCKET:
-            klass = cb_eNotMyVbucketError;
-            break;
-        case LCB_NOT_STORED:
-            klass = cb_eNotStoredError;
-            break;
-        case LCB_NOT_SUPPORTED:
-            klass = cb_eNotSupportedError;
-            break;
-        case LCB_UNKNOWN_COMMAND:
-            klass = cb_eUnknownCommandError;
-            break;
-        case LCB_UNKNOWN_HOST:
-            klass = cb_eUnknownHostError;
-            break;
-        case LCB_PROTOCOL_ERROR:
-            klass = cb_eProtocolError;
-            break;
-        case LCB_ETIMEDOUT:
-            klass = cb_eTimeoutError;
-            break;
-        case LCB_CONNECT_ERROR:
-            klass = cb_eConnectError;
-            break;
-        case LCB_BUCKET_ENOENT:
-            klass = cb_eBucketNotFoundError;
-            break;
-        case LCB_CLIENT_ENOMEM:
-            klass = cb_eClientNoMemoryError;
-            break;
-        case LCB_CLIENT_ETMPFAIL:
-            klass = cb_eClientTmpFailError;
-            break;
-        case LCB_EBADHANDLE:
-            klass = cb_eBadHandleError;
-            break;
-        case LCB_SERVER_BUG:
-            klass = cb_eServerBug;
-            break;
-        case LCB_PLUGIN_VERSION_MISMATCH:
-            klass = cb_ePluginVersionMismatch;
-            break;
-        case LCB_INVALID_HOST_FORMAT:
-            klass = cb_eInvalidHostFormat;
-            break;
-        case LCB_INVALID_CHAR:
-            klass = cb_eInvalidChar;
-            break;
-        case LCB_DURABILITY_ETOOMANY:
-            klass = cb_eDurabilityTooMany;
-            break;
-        case LCB_DUPLICATE_COMMANDS:
-            klass = cb_eDuplicateCommands;
-            break;
-        case LCB_NO_MATCHING_SERVER:
-            klass = cb_eNoMatchingServer;
-            break;
-        case LCB_BAD_ENVIRONMENT:
-            klass = cb_eBadEnvironment;
-            break;
-        case LCB_BUSY:
-            klass = cb_eBusyError;
-            break;
-        case LCB_INVALID_USERNAME:
-            klass = cb_eInvalidUsername;
-            break;
-        case LCB_ERROR:
-            /* fall through */
-        default:
-            klass = cb_eLibcouchbaseError;
-    }
-
-    str = rb_str_buf_new2(msg ? msg : "");
-    if (msg) {
-        str = rb_str_buf_new2(msg);
-        rb_str_buf_cat2(str, ", ");
-    } else {
-        str = rb_str_buf_new2("");
-    }
-    rb_str_buf_cat2(str, lcb_strerror(NULL, rc));
-    rb_str_buf_cat2(str, " (");
-    if (key != Qnil) {
-        snprintf(buf, 300, "key=\"%s\", ", RSTRING_PTR(key));
-        rb_str_buf_cat2(str, buf);
-    }
-    if (status > 0) {
-        const char *reason = NULL;
-        klass = cb_eHTTPError;
-        snprintf(buf, 300, "status=\"%d\"", status);
-        rb_str_buf_cat2(str, buf);
-        switch (status) {
-            case LCB_HTTP_STATUS_BAD_REQUEST:
-                reason = " (Bad Request)";
-                break;
-            case LCB_HTTP_STATUS_UNAUTHORIZED:
-                reason = " (Unauthorized)";
-                break;
-            case LCB_HTTP_STATUS_PAYMENT_REQUIRED:
-                reason = " (Payment Required)";
-                break;
-            case LCB_HTTP_STATUS_FORBIDDEN:
-                reason = " (Forbidden)";
-                break;
-            case LCB_HTTP_STATUS_NOT_FOUND:
-                reason = " (Not Found)";
-                break;
-            case LCB_HTTP_STATUS_METHOD_NOT_ALLOWED:
-                reason = " (Method Not Allowed)";
-                break;
-            case LCB_HTTP_STATUS_NOT_ACCEPTABLE:
-                reason = " (Not Acceptable)";
-                break;
-            case LCB_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED:
-                reason = " (Proxy Authentication Required)";
-                break;
-            case LCB_HTTP_STATUS_REQUEST_TIMEOUT:
-                reason = " (Request Timeout)";
-                break;
-            case LCB_HTTP_STATUS_CONFLICT:
-                reason = " (Conflict)";
-                break;
-            case LCB_HTTP_STATUS_GONE:
-                reason = " (Gone)";
-                break;
-            case LCB_HTTP_STATUS_LENGTH_REQUIRED:
-                reason = " (Length Required)";
-                break;
-            case LCB_HTTP_STATUS_PRECONDITION_FAILED:
-                reason = " (Precondition Failed)";
-                break;
-            case LCB_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE:
-                reason = " (Request Entity Too Large)";
-                break;
-            case LCB_HTTP_STATUS_REQUEST_URI_TOO_LONG:
-                reason = " (Request Uri Too Long)";
-                break;
-            case LCB_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE:
-                reason = " (Unsupported Media Type)";
-                break;
-            case LCB_HTTP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE:
-                reason = " (Requested Range Not Satisfiable)";
-                break;
-            case LCB_HTTP_STATUS_EXPECTATION_FAILED:
-                reason = " (Expectation Failed)";
-                break;
-            case LCB_HTTP_STATUS_UNPROCESSABLE_ENTITY:
-                reason = " (Unprocessable Entity)";
-                break;
-            case LCB_HTTP_STATUS_LOCKED:
-                reason = " (Locked)";
-                break;
-            case LCB_HTTP_STATUS_FAILED_DEPENDENCY:
-                reason = " (Failed Dependency)";
-                break;
-            case LCB_HTTP_STATUS_INTERNAL_SERVER_ERROR:
-                reason = " (Internal Server Error)";
-                break;
-            case LCB_HTTP_STATUS_NOT_IMPLEMENTED:
-                reason = " (Not Implemented)";
-                break;
-            case LCB_HTTP_STATUS_BAD_GATEWAY:
-                reason = " (Bad Gateway)";
-                break;
-            case LCB_HTTP_STATUS_SERVICE_UNAVAILABLE:
-                reason = " (Service Unavailable)";
-                break;
-            case LCB_HTTP_STATUS_GATEWAY_TIMEOUT:
-                reason = " (Gateway Timeout)";
-                break;
-            case LCB_HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED:
-                reason = " (Http Version Not Supported)";
-                break;
-            case LCB_HTTP_STATUS_INSUFFICIENT_STORAGE:
-                reason = " (Insufficient Storage)";
-                break;
-            default:
-                reason = "";
-        }
-        rb_str_buf_cat2(str, reason);
-        rb_str_buf_cat2(str, ", ");
-
-    }
-    snprintf(buf, 300, "error=0x%02x)", rc);
-    rb_str_buf_cat2(str, buf);
-    exc = rb_exc_new3(klass, str);
-    rb_ivar_set(exc, cb_id_iv_error, INT2FIX(rc));
-    rb_ivar_set(exc, cb_id_iv_key, key);
-    rb_ivar_set(exc, cb_id_iv_cas, Qnil);
-    rb_ivar_set(exc, cb_id_iv_operation, Qnil);
-    rb_ivar_set(exc, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
-    return exc;
-}
-
-    VALUE
-cb_check_error(lcb_error_t rc, const char *msg, VALUE key)
-{
-    return cb_check_error_with_status(rc, msg, key, 0);
-}
-
-    static VALUE
-do_encode(VALUE *args)
-{
-    VALUE val = args[0];
-    uint32_t *flags = (uint32_t *)args[1];
-    VALUE transcoder = args[2];
-    VALUE options = args[3];
-    VALUE ret;
-
-    ret = rb_funcall(transcoder, cb_id_dump, 3, val, ULONG2NUM(*flags), options);
-    Check_Type(ret, T_ARRAY);
-    if (RARRAY_LEN(ret) != 2) {
-        rb_raise(rb_eArgError, "#dump method of transcoder should return two items");
-    }
-    *flags = NUM2ULONG(rb_ary_entry(ret, 1));
-    return rb_ary_entry(ret, 0);
-}
-
-    static VALUE
-do_decode(VALUE *args)
-{
-    VALUE blob = args[0];
-    VALUE transcoder = args[2];
-    VALUE flags = args[1];
-    VALUE options = args[3];
-
-    return rb_funcall(transcoder, cb_id_load, 3, blob, ULONG2NUM(flags), options);
-}
-
-    static VALUE
-coding_failed(VALUE unused, VALUE exc)
-{
-    (void)unused;
-    return exc;
-}
-
-    VALUE
-cb_encode_value(VALUE transcoder, VALUE val, uint32_t *flags, VALUE options)
-{
-    VALUE args[4];
-
-    args[0] = val;
-    args[1] = (VALUE)flags;
-    args[2] = transcoder;
-    args[3] = options;
-
-    /* if nil, just pass value through */
-    if (NIL_P(args[2])) {
-        return val;
-    }
-    /* bytestring or exception object */
-    return rb_rescue(do_encode, (VALUE)args, coding_failed, 0);
-}
-
-    VALUE
-cb_decode_value(VALUE transcoder, VALUE blob, uint32_t flags, VALUE options)
-{
-    VALUE args[4];
-
-    /* first it must be bytestring */
-    if (TYPE(blob) != T_STRING) {
-        return Qundef;
-    }
-    args[0] = blob;
-    args[1] = (VALUE)flags;
-    args[2] = transcoder;
-    args[3] = options;
-
-    /* if nil, just pass blob through */
-    if (NIL_P(args[2])) {
-        return blob;
-    }
-    /* the value or exception object */
-    return rb_rescue(do_decode, (VALUE)args, coding_failed, 0);
-}
-
-    void
-cb_strip_key_prefix(struct cb_bucket_st *bucket, VALUE key)
-{
-    if (RTEST(bucket->key_prefix_val)) {
-        rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), cb_vStrEmpty);
-    }
-}
-
-    VALUE
-cb_unify_key(struct cb_bucket_st *bucket, VALUE key, int apply_prefix)
-{
-    VALUE ret = Qnil, tmp;
-
-    if (RTEST(bucket->key_prefix_val) && apply_prefix) {
-        ret = rb_str_dup(bucket->key_prefix_val);
-    }
-    switch (TYPE(key)) {
-        case T_STRING:
-            return NIL_P(ret) ? key : rb_str_concat(ret, key);
-        case T_SYMBOL:
-            tmp = STR_NEW_CSTR(rb_id2name(SYM2ID(key)));
-            return NIL_P(ret) ? tmp : rb_str_concat(ret, tmp);
-        default:    /* call #to_str or raise error */
-            tmp = StringValue(key);
-            return NIL_P(ret) ? tmp : rb_str_concat(ret, tmp);
-    }
-}
-
-    void
-cb_build_headers(struct cb_context_st *ctx, const char * const *headers)
-{
-    if (!ctx->headers_built) {
-        VALUE key = Qnil, val;
-        for (size_t ii = 1; *headers != NULL; ++ii, ++headers) {
-            if (ii % 2 == 0) {
-                if (key == Qnil) {
-                    break;
-                }
-                val = rb_hash_aref(ctx->headers_val, key);
-                switch (TYPE(val)) {
-                    case T_NIL:
-                        rb_hash_aset(ctx->headers_val, key, STR_NEW_CSTR(*headers));
-                        break;
-                    case T_ARRAY:
-                        rb_ary_push(val, STR_NEW_CSTR(*headers));
-                        break;
-                    default:
-                        {
-                            VALUE ary = rb_ary_new();
-                            rb_ary_push(ary, val);
-                            rb_ary_push(ary, STR_NEW_CSTR(*headers));
-                            rb_hash_aset(ctx->headers_val, key, ary);
-                        }
-                }
-            } else {
-                key = STR_NEW_CSTR(*headers);
-            }
-        }
-        ctx->headers_built = 1;
-    }
-}
-
-    int
-cb_first_value_i(VALUE key, VALUE value, VALUE arg)
-{
-    VALUE *val = (VALUE *)arg;
-
-    *val = value;
-    (void)key;
-    return ST_STOP;
-}
-
-#ifndef HAVE_RB_HASH_LOOKUP2
-    VALUE
-rb_hash_lookup2(VALUE hash, VALUE key, VALUE dflt)
-{
-    if (RTEST(rb_funcall2(hash, cb_id_has_key_p, 1, &key))) {
-        dflt = rb_hash_aref(hash, key);
-    }
-    return dflt;
-}
-#endif