ovirt-engine-sdk 4.0.1 → 4.4.1

data/ext/ovirtsdk4c/ov_http_response.c

@@ -0,0 +1,210 @@
+/*
+Copyright (c) 2016-2017 Red Hat, 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 <ruby.h>
+
+#include "ov_module.h"
+#include "ov_error.h"
+#include "ov_http_response.h"
+
+/* The class: */
+VALUE ov_http_response_class;
+
+static VALUE BODY_SYMBOL;
+static VALUE CODE_SYMBOL;
+static VALUE HEADERS_SYMBOL;
+static VALUE MESSAGE_SYMBOL;
+
+static void ov_http_response_mark(void* vptr) {
+    ov_http_response_object* ptr;
+
+    ptr = vptr;
+    rb_gc_mark(ptr->body);
+    rb_gc_mark(ptr->code);
+    rb_gc_mark(ptr->headers);
+    rb_gc_mark(ptr->message);
+}
+
+static void ov_http_response_free(void* vptr) {
+    ov_http_response_object* ptr;
+
+    ptr = vptr;
+    xfree(ptr);
+}
+
+rb_data_type_t ov_http_response_type = {
+    .wrap_struct_name = "OVHTTPRESPONSE",
+    .function = {
+        .dmark = ov_http_response_mark,
+        .dfree = ov_http_response_free,
+        .dsize = NULL,
+        .reserved = { NULL, NULL }
+    },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE ov_http_response_alloc(VALUE klass) {
+    ov_http_response_object* ptr;
+
+    ptr = ALLOC(ov_http_response_object);
+    ptr->body = Qnil;
+    ptr->code = Qnil;
+    ptr->headers = Qnil;
+    ptr->message = Qnil;
+    return TypedData_Wrap_Struct(klass, &ov_http_response_type, ptr);
+}
+
+static VALUE ov_http_response_get_body(VALUE self) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    return ptr->body;
+}
+
+static VALUE ov_http_response_set_body(VALUE self, VALUE value) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    if (!NIL_P(value)) {
+        Check_Type(value, T_STRING);
+    }
+    ptr->body = value;
+    return Qnil;
+}
+
+static VALUE ov_http_response_get_code(VALUE self) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    return ptr->code;
+}
+
+static VALUE ov_http_response_set_code(VALUE self, VALUE value) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    if (!NIL_P(value)) {
+        Check_Type(value, T_FIXNUM);
+    }
+    ptr->code = value;
+    return Qnil;
+}
+
+static VALUE ov_http_response_get_headers(VALUE self) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    return ptr->headers;
+}
+
+static VALUE ov_http_response_set_headers(VALUE self, VALUE value) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    if (NIL_P(value)) {
+        ptr->headers = rb_hash_new();
+    }
+    else {
+        Check_Type(value, T_HASH);
+        ptr->headers = value;
+    }
+    return Qnil;
+}
+
+static VALUE ov_http_response_get_message(VALUE self) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    return ptr->message;
+}
+
+static VALUE ov_http_response_set_message(VALUE self, VALUE value) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    if (!NIL_P(value)) {
+        Check_Type(value, T_STRING);
+    }
+    ptr->message = value;
+    return Qnil;
+}
+
+static VALUE ov_http_response_inspect(VALUE self) {
+    ov_http_response_object* ptr;
+
+    ov_http_response_ptr(self, ptr);
+    return rb_sprintf(
+        "#<%"PRIsVALUE":%"PRIsVALUE" %"PRIsVALUE">",
+        ov_http_response_class,
+        ptr->code,
+        ptr->message
+    );
+}
+
+static VALUE ov_http_response_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE opts;
+
+    /* 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 values of the options: */
+    ov_http_response_set_body(self, rb_hash_aref(opts, BODY_SYMBOL));
+    ov_http_response_set_headers(self, rb_hash_aref(opts, HEADERS_SYMBOL));
+    ov_http_response_set_code(self, rb_hash_aref(opts, CODE_SYMBOL));
+    ov_http_response_set_message(self, rb_hash_aref(opts, MESSAGE_SYMBOL));
+
+    return self;
+}
+
+void ov_http_response_define(void) {
+    /* Define the class: */
+    ov_http_response_class = rb_define_class_under(ov_module, "HttpResponse", rb_cData);
+
+    /* Define the constructor: */
+    rb_define_alloc_func(ov_http_response_class, ov_http_response_alloc);
+    rb_define_method(ov_http_response_class, "initialize", ov_http_response_initialize, -1);
+
+    /* Define the methods: */
+    rb_define_method(ov_http_response_class, "body",     ov_http_response_get_body,    0);
+    rb_define_method(ov_http_response_class, "body=",    ov_http_response_set_body,    1);
+    rb_define_method(ov_http_response_class, "code",     ov_http_response_get_code,    0);
+    rb_define_method(ov_http_response_class, "code=",    ov_http_response_set_code,    1);
+    rb_define_method(ov_http_response_class, "headers",  ov_http_response_get_headers, 0);
+    rb_define_method(ov_http_response_class, "headers=", ov_http_response_set_headers, 1);
+    rb_define_method(ov_http_response_class, "message",  ov_http_response_get_message, 0);
+    rb_define_method(ov_http_response_class, "message=", ov_http_response_set_message, 1);
+    rb_define_method(ov_http_response_class, "inspect",  ov_http_response_inspect,     0);
+    rb_define_method(ov_http_response_class, "to_s",     ov_http_response_inspect,     0);
+
+    /* Define the symbols: */
+    BODY_SYMBOL    = ID2SYM(rb_intern("body"));
+    CODE_SYMBOL    = ID2SYM(rb_intern("code"));
+    HEADERS_SYMBOL = ID2SYM(rb_intern("headers"));
+    MESSAGE_SYMBOL = ID2SYM(rb_intern("message"));
+}

data/ext/ovirtsdk4c/ov_http_response.h

@@ -0,0 +1,41 @@
+/*
+Copyright (c) 2016-2017 Red Hat, 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.
+*/
+
+#ifndef __OV_HTTP_RESPONSE_H__
+#define __OV_HTTP_RESPONSE_H__
+
+#include <ruby.h>
+
+/* Data type and class: */
+extern rb_data_type_t ov_http_response_type;
+extern VALUE ov_http_response_class;
+
+/* Content: */
+typedef struct {
+    VALUE body;    /* String */
+    VALUE code;    /* Integer */
+    VALUE headers; /* Hash<String, String> */
+    VALUE message; /* String */
+} ov_http_response_object;
+
+/* Macro to get the pointer: */
+#define ov_http_response_ptr(object, ptr) \
+    TypedData_Get_Struct((object), ov_http_response_object, &ov_http_response_type, (ptr))
+
+/* Initialization function: */
+extern void ov_http_response_define(void);
+
+#endif

data/ext/ovirtsdk4c/ov_http_transfer.c

@@ -0,0 +1,91 @@
+/*
+Copyright (c) 2017 Red Hat, 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 <ruby.h>
+
+#include <stdbool.h>
+
+#include "ov_module.h"
+#include "ov_http_transfer.h"
+
+/* Class: */
+VALUE ov_http_transfer_class;
+
+static void ov_http_transfer_mark(void* vptr) {
+    ov_http_transfer_object* ptr;
+
+    ptr = vptr;
+    rb_gc_mark(ptr->client);
+    rb_gc_mark(ptr->request);
+    rb_gc_mark(ptr->response);
+    rb_gc_mark(ptr->in);
+    rb_gc_mark(ptr->out);
+}
+
+static void ov_http_transfer_free(void* vptr) {
+    ov_http_transfer_object* ptr;
+
+    ptr = vptr;
+    xfree(ptr);
+}
+
+rb_data_type_t ov_http_transfer_type = {
+    .wrap_struct_name = "OVHTTPTRANSFER",
+    .function = {
+        .dmark = ov_http_transfer_mark,
+        .dfree = ov_http_transfer_free,
+        .dsize = NULL,
+        .reserved = { NULL, NULL }
+    },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE ov_http_transfer_alloc(VALUE klass) {
+    ov_http_transfer_object* ptr;
+
+    ptr = ALLOC(ov_http_transfer_object);
+    ptr->client   = Qnil;
+    ptr->request  = Qnil;
+    ptr->response = Qnil;
+    ptr->in       = Qnil;
+    ptr->out      = Qnil;
+    ptr->headers  = NULL;
+    ptr->cancel   = false;
+    return TypedData_Wrap_Struct(klass, &ov_http_transfer_type, ptr);
+}
+
+static VALUE ov_http_transfer_inspect(VALUE self) {
+    ov_http_transfer_object* ptr;
+
+    ov_http_transfer_ptr(self, ptr);
+    return rb_sprintf("#<%"PRIsVALUE":%p>", ov_http_transfer_class, ptr);
+}
+
+void ov_http_transfer_define(void) {
+    /* Define the class: */
+    ov_http_transfer_class = rb_define_class_under(ov_module, "HttpTransfer", rb_cData);
+
+    /* Define the constructor: */
+    rb_define_alloc_func(ov_http_transfer_class, ov_http_transfer_alloc);
+
+    /* Define the methods: */
+    rb_define_method(ov_http_transfer_class, "inspect", ov_http_transfer_inspect, 0);
+    rb_define_method(ov_http_transfer_class, "to_s",    ov_http_transfer_inspect, 0);
+}

data/ext/ovirtsdk4c/ov_http_transfer.h

@@ -0,0 +1,47 @@
+/*
+Copyright (c) 2017 Red Hat, 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.
+*/
+
+#ifndef __OV_HTTP_TRANSFER_H__
+#define __OV_HTTP_TRANSFER_H__
+
+#include <ruby.h>
+
+#include <stdbool.h>
+#include <curl/curl.h>
+
+/* Data type and class: */
+extern rb_data_type_t ov_http_transfer_type;
+extern VALUE ov_http_transfer_class;
+
+/* Content: */
+typedef struct {
+    VALUE client;   /* HttpClient */
+    VALUE request;  /* HttpRequest */
+    VALUE response; /* HttpResponse */
+    VALUE in;       /* IO */
+    VALUE out;      /* IO */
+    struct curl_slist* headers;
+    bool cancel;
+} ov_http_transfer_object;
+
+/* Macro to get the pointer: */
+#define ov_http_transfer_ptr(object, ptr) \
+    TypedData_Get_Struct((object), ov_http_transfer_object, &ov_http_transfer_type, (ptr))
+
+/* Initialization function: */
+extern void ov_http_transfer_define(void);
+
+#endif

data/ext/ovirtsdk4c/ov_module.h

@@ -17,10 +17,10 @@ limitations under the License.
 #ifndef __OV_MODULE_H__
 #define __OV_MODULE_H__
 
-// Module:
+/* Module: */
 extern VALUE ov_module;
 
-// Initialization function:
+/* Initialization function: */
 extern void ov_module_define(void);
 
 #endif

data/ext/ovirtsdk4c/ov_string.c

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2017 Red Hat, 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 <ruby.h>
+#include <string.h>
+
+#include "ov_string.h"
+
+char* ov_string_dup(VALUE str) {
+    long len = 0;
+    char* raw = NULL;
+    char* ptr = NULL;
+
+    if (!NIL_P(str)) {
+        Check_Type(str, T_STRING);
+        len = RSTRING_LEN(str);
+        raw = RSTRING_PTR(str);
+        ptr = (char*) ALLOC_N(char, len + 1);
+        strncpy(ptr, raw, len);
+        ptr[len] = '\0';
+    }
+    return ptr;
+}
+
+void ov_string_free(char* ptr) {
+    if (ptr != NULL) {
+        xfree(ptr);
+    }
+}
+

data/ext/ovirtsdk4c/ov_string.h

@@ -0,0 +1,25 @@
+/*
+Copyright (c) 2017 Red Hat, 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.
+*/
+
+#ifndef __OV_STRING_H__
+#define __OV_STRING_H__
+
+#include <ruby.h>
+
+extern char* ov_string_dup(VALUE str);
+extern void ov_string_free(char* str);
+
+#endif