Class: OvirtSDK4::HttpClient

Inherits:

Object

• Object
• OvirtSDK4::HttpClient

Defined in:

ext/ovirtsdk4c/ov_http_client.c

Instance Method Summary

• #close ⇒ Object

  Define the methods:.

• #initialize(*args) ⇒ Object constructor
• #inspect ⇒ Object
• #send(request) ⇒ Object
• #to_s ⇒ Object
• #wait(request) ⇒ Object

Constructor Details

#initialize(*args) ⇒ Object

# File 'ext/ovirtsdk4c/ov_http_client.c', line 510

static VALUE ov_http_client_initialize(int argc, VALUE* argv, VALUE self) {
    VALUE opt;
    VALUE opts;
    long connections;
    long pipeline;
    ov_http_client_object* ptr;

    /* Get the pointer to the native object: */
    ov_http_client_ptr(self, ptr);

    /* Check the number of arguments: */
    if (argc > 1) {
        rb_raise(ov_error_class, "Expected at most one argument, 'opts', but received %d", argc);
    }
    opts = argc > 0? argv[0]: Qnil;
    if (NIL_P(opts)) {
        opts = rb_hash_new();
    }
    else {
        Check_Type(opts, T_HASH);
    }

    /* Get the value of the 'ca_file' parameter: */
    opt = rb_hash_aref(opts, CA_FILE_SYMBOL);
    if (NIL_P(opt)) {
        ptr->ca_file = NULL;
    }
    else {
        Check_Type(opt, T_STRING);
        ptr->ca_file = ov_string_dup(opt);
    }

    /* Get the value of the 'insecure' parameter: */
    opt = rb_hash_aref(opts, INSECURE_SYMBOL);
    ptr->insecure = NIL_P(opt)? false: RTEST(opt);

    /* Get the value of the 'debug' parameter: */
    opt = rb_hash_aref(opts, DEBUG_SYMBOL);
    ptr->debug = NIL_P(opt)? false: RTEST(opt);

    /* Get the value of the 'compress' parameter: */
    opt = rb_hash_aref(opts, COMPRESS_SYMBOL);
    ptr->compress = NIL_P(opt)? true: RTEST(opt);

    /* Get the value of the 'timeout' parameter: */
    opt = rb_hash_aref(opts, TIMEOUT_SYMBOL);
    if (NIL_P(opt)) {
        ptr->timeout = 0;
    }
    else {
        Check_Type(opt, T_FIXNUM);
        ptr->timeout = NUM2INT(opt);
    }

    /* Get the value of the 'connect_timeout' parameter: */
    opt = rb_hash_aref(opts, CONNECT_TIMEOUT_SYMBOL);
    if (NIL_P(opt)) {
        ptr->connect_timeout = 0;
    }
    else {
        Check_Type(opt, T_FIXNUM);
        ptr->connect_timeout = NUM2INT(opt);
    }

    /* Get the value of the 'proxy_url' parameter: */
    opt = rb_hash_aref(opts, PROXY_URL_SYMBOL);
    if (NIL_P(opt)) {
        ptr->proxy_url = NULL;
    }
    else {
        Check_Type(opt, T_STRING);
        ptr->proxy_url = ov_string_dup(opt);
    }

    /* Get the value of the 'proxy_username' parameter: */
    opt = rb_hash_aref(opts, PROXY_USERNAME_SYMBOL);
    if (NIL_P(opt)) {
        ptr->proxy_username = NULL;
    }
    else {
        Check_Type(opt, T_STRING);
        ptr->proxy_username = ov_string_dup(opt);
    }

    /* Get the value of the 'proxy_password' parameter: */
    opt = rb_hash_aref(opts, PROXY_PASSWORD_SYMBOL);
    if (NIL_P(opt)) {
        ptr->proxy_password = NULL;
    }
    else {
        Check_Type(opt, T_STRING);
        ptr->proxy_password = ov_string_dup(opt);
    }

    /* Get the value of the 'log' parameter: */
    opt = rb_hash_aref(opts, LOG_SYMBOL);
    ptr->log = opt;

    /* Get the value of the 'pipeline' parameter: */
    opt = rb_hash_aref(opts, PIPELINE_SYMBOL);
    if (NIL_P(opt)) {
        pipeline = 0;
    }
    else {
        Check_Type(opt, T_FIXNUM);
        pipeline = NUM2LONG(opt);
    }
    if (pipeline < 0) {
        rb_raise(rb_eArgError, "The maximum pipeline length can't be %ld, minimum is 0.", pipeline);
    }

    /* Get the value of the 'connections' parameter: */
    opt = rb_hash_aref(opts, CONNECTIONS_SYMBOL);
    if (NIL_P(opt)) {
        connections = 1;
    }
    else {
        Check_Type(opt, T_FIXNUM);
        connections = NUM2LONG(opt);
    }
    if (connections < 1) {
        rb_raise(rb_eArgError, "The maximum number of connections can't be %ld, minimum is 1.", connections);
    }

   /* Get the value of the 'cookies' parameter. If it is a string it will be used as the path of the file where the
      cookies will be stored. If it is any other thing it will be treated as a boolean flag indicating if cookies
      should be enabled but not loaded/saved from/to any file. */
    opt = rb_hash_aref(opts, COOKIES_SYMBOL);
    if (TYPE(opt) == T_STRING) {
        ptr->cookies = ov_string_dup(opt);
    }
    else if (RTEST(opt)) {
        ptr->cookies = ov_string_dup(rb_str_new2(""));
    }
    else {
        ptr->cookies = NULL;
    }

    /* Create the queue that contains requests that haven't been sent to libcurl yet: */
    ptr->queue = rb_ary_new();

    /* Create the hash that contains the transfers are pending an completed. Both use the identity of the request
       as key. */
    ptr->completed = rb_funcall(rb_hash_new(), COMPARE_BY_IDENTITY_ID, 0);
    ptr->pending = rb_funcall(rb_hash_new(), COMPARE_BY_IDENTITY_ID, 0);

    /* Calculate the max number of requests that can be handled by libcurl simultaneously. For versions of libcurl
       newer than 7.30.0 the limit can be increased when using pipelining. For older versions it can't be increased
       because libcurl would create additional connections for the requests that can't be pipelined. */
    ptr->limit = connections;
    if (pipeline > 0 && libcurl_version->version_num >= 0x071e00 /* 7.30.0 */) {
        ptr->limit *= pipeline;
    }

    /* Create the libcurl multi handle: */
    ptr->handle = curl_multi_init();
    if (ptr->handle == NULL) {
        rb_raise(ov_error_class, "Can't create libcurl multi object");
    }

    /* Create the libcurl share handle in order to share cookie data: */
    ptr->share = curl_share_init();
    if (ptr->share == NULL) {
        rb_raise(ov_error_class, "Can't create libcurl share object");
    }
    if (ptr->cookies != NULL) {
        curl_share_setopt(ptr->share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
    }

    /* Enable pipelining: */
    if (pipeline > 0) {
        curl_multi_setopt(ptr->handle, CURLMOPT_PIPELINING, CURLPIPE_HTTP1);
        if (libcurl_version->version_num >= 0x071e00 /* 7.30.0 */) {
            curl_multi_setopt(ptr->handle, CURLMOPT_MAX_PIPELINE_LENGTH, pipeline);
        }
        else {
            ov_http_client_log_warn(
                ptr->log,
                "Can't set maximum pipeline length to %d, it isn't supported by libcurl %s. Upgrade to 7.30.0 or "
                "newer to avoid this issue.",
                pipeline,
                libcurl_version->version
            );
        }
    }

    /* Set the max number of connections: */
    if (connections > 0) {
        if (libcurl_version->version_num >= 0x071e00 /* 7.30.0 */) {
            curl_multi_setopt(ptr->handle, CURLMOPT_MAX_HOST_CONNECTIONS, connections);
            curl_multi_setopt(ptr->handle, CURLMOPT_MAX_TOTAL_CONNECTIONS, connections);
        }
        else {
            ov_http_client_log_warn(
                ptr->log,
                "Can't set maximum number of connections to %d, it isn't supported by libcurl %s. Upgrade to 7.30.0 "
                "or newer to avoid this issue.",
                connections,
                libcurl_version->version
            );
        }
        if (libcurl_version->version_num >= 0x070f03 /* 7.16.3 */) {
            curl_multi_setopt(ptr->handle, CURLMOPT_MAXCONNECTS, connections);
        }
        else {
            ov_http_client_log_warn(
                ptr->log,
                "Can't set total maximum connection cache size to %d, it isn't supported by libcurl %s. Upgrade to "
                "7.16.3 or newer to avoid this issue.",
                connections,
                libcurl_version->version
            );
        }
    }

    return self;
}

Instance Method Details

#close ⇒ Object

Define the methods:

# File 'ext/ovirtsdk4c/ov_http_client.c', line 249

static VALUE ov_http_client_close(VALUE self) {
    ov_http_client_object* ptr;

    /* Get the pointer to the native object and check that it isn't closed: */
    ov_http_client_ptr(self, ptr);
    ov_http_client_check_closed(ptr);

    /* Release the resources used by libcurl: */
    curl_multi_cleanup(ptr->handle);
    ptr->handle = NULL;

    return Qnil;
}

#inspect ⇒ Object

# File 'ext/ovirtsdk4c/ov_http_client.c', line 1155

static VALUE ov_http_client_inspect(VALUE self) {
    ov_http_client_object* ptr;

    ov_http_client_ptr(self, ptr);
    return rb_sprintf("#<%"PRIsVALUE":%p>", ov_http_client_class, ptr);
}

#send(request) ⇒ Object

# File 'ext/ovirtsdk4c/ov_http_client.c', line 1092

static VALUE ov_http_client_send(VALUE self, VALUE request) {
    ov_http_client_object* ptr;

    /* Get the pointer to the native object and check that it isn't closed: */
    ov_http_client_ptr(self, ptr);
    ov_http_client_check_closed(ptr);

    /* If the limit hasn't been reached then submit the request directly to libcurl, otherwise put it in the queue: */
    if (RHASH_SIZE(ptr->pending) < ptr->limit) {
        ov_http_client_submit(self, request);
    }
    else {
        rb_ary_push(ptr->queue, request);
    }

    return Qnil;
}

#to_s ⇒ Object

# File 'ext/ovirtsdk4c/ov_http_client.c', line 1155

static VALUE ov_http_client_inspect(VALUE self) {
    ov_http_client_object* ptr;

    ov_http_client_ptr(self, ptr);
    return rb_sprintf("#<%"PRIsVALUE":%p>", ov_http_client_class, ptr);
}

#wait(request) ⇒ Object

# File 'ext/ovirtsdk4c/ov_http_client.c', line 1110

static VALUE ov_http_client_wait(VALUE self, VALUE request) {
    VALUE next;
    VALUE result;
    ov_http_client_object* ptr;
    ov_http_client_wait_context context;

    /* Get the pointer to the native object and check that it isn't closed: */
    ov_http_client_ptr(self, ptr);
    ov_http_client_check_closed(ptr);

    /* Work till the transfer has been completed. */
    context.handle = ptr->handle;
    context.code = CURLE_OK;
    context.cancel = false;
    for (;;) {
        /* Move requests from the queue to libcurl: */
        while (RARRAY_LEN(ptr->queue) > 0 && RHASH_SIZE(ptr->pending) < ptr->limit) {
            next = rb_ary_shift(ptr->queue);
            ov_http_client_submit(self, next);
        }

        /* Check if the response is already available, if so then return it: */
        result = rb_hash_delete(ptr->completed, request);
        if (!NIL_P(result)) {
            return result;
        }

        /* If the response isn't available yet, then do some real work: */
        rb_thread_call_without_gvl(
            ov_http_client_wait_task,
            &context,
            ov_http_client_wait_cancel,
            &context
        );
        if (context.cancel) {
            return Qnil;
        }
        if (context.code != CURLE_OK) {
            rb_raise(ov_error_class, "Unexpected error while waiting: %s", curl_easy_strerror(context.code));
        }
    }

    return Qnil;
}