ilios 0.1.0

data/ext/ilios/ilios.c

@@ -0,0 +1,107 @@
+#include "ilios.h"
+
+VALUE mIlios;
+VALUE mCassandra;
+VALUE cSession;
+VALUE cStatement;
+VALUE cResult;
+VALUE cFuture;
+VALUE eConnectError;
+VALUE eExecutionError;
+VALUE eStatementError;
+
+VALUE cQueue;
+
+VALUE id_cvar_config;
+VALUE id_shuffle;
+VALUE id_to_time;
+VALUE id_abort_on_exception_set;
+VALUE id_new;
+VALUE id_push;
+VALUE id_pop;
+VALUE sym_unsupported_column_type;
+VALUE sym_keyspace;
+VALUE sym_hosts;
+VALUE sym_timeout_ms;
+VALUE sym_constant_delay_ms;
+VALUE sym_max_speculative_executions;
+VALUE sym_page_size;
+
+#if defined(HAVE_MALLOC_USABLE_SIZE)
+#include <malloc.h>
+#elif defined(HAVE_MALLOC_SIZE)
+#include <malloc/malloc.h>
+#endif
+
+static ssize_t ilios_malloc_size(void *ptr)
+{
+#if defined(HAVE_MALLOC_USABLE_SIZE)
+    return malloc_usable_size(ptr);
+#elif defined(HAVE_MALLOC_SIZE)
+    return malloc_size(ptr);
+#endif
+}
+
+static void *ilios_malloc(size_t size)
+{
+    rb_gc_adjust_memory_usage(size);
+    return malloc(size);
+}
+
+static void *ilios_realloc(void *ptr, size_t size)
+{
+    ssize_t before_size = ilios_malloc_size(ptr);
+    rb_gc_adjust_memory_usage(size - before_size);
+    return realloc(ptr, size);
+}
+
+static void ilios_free(void *ptr)
+{
+    if (ptr) {
+        ssize_t size = ilios_malloc_size(ptr);
+        rb_gc_adjust_memory_usage(-size);
+        free(ptr);
+    }
+}
+
+void Init_ilios(void)
+{
+    mIlios = rb_define_module("Ilios");
+    mCassandra = rb_define_module_under(mIlios, "Cassandra");
+    cSession = rb_define_class_under(mCassandra, "Session", rb_cObject);
+    cStatement = rb_define_class_under(mCassandra, "Statement", rb_cObject);
+    cResult = rb_define_class_under(mCassandra, "Result", rb_cObject);
+    cFuture = rb_define_class_under(mCassandra, "Future", rb_cObject);
+    eConnectError = rb_define_class_under(mCassandra, "ConnectError", rb_eStandardError);
+    eExecutionError = rb_define_class_under(mCassandra, "ExecutionError", rb_eStandardError);
+    eStatementError = rb_define_class_under(mCassandra, "StatementError", rb_eStandardError);
+
+    cQueue = rb_const_get(rb_cThread, rb_intern("Queue"));
+
+    id_cvar_config = rb_intern("@@config");
+    id_shuffle = rb_intern("shuffle");
+    id_to_time = rb_intern("to_time");
+    id_abort_on_exception_set = rb_intern("abort_on_exception=");
+    id_new = rb_intern("new");
+    id_push = rb_intern("push");
+    id_pop = rb_intern("pop");
+    sym_unsupported_column_type = ID2SYM(rb_intern("unsupported_column_type"));
+    sym_keyspace = ID2SYM(rb_intern("keyspace"));
+    sym_hosts = ID2SYM(rb_intern("hosts"));
+    sym_timeout_ms = ID2SYM(rb_intern("timeout_ms"));
+    sym_constant_delay_ms = ID2SYM(rb_intern("constant_delay_ms"));
+    sym_max_speculative_executions = ID2SYM(rb_intern("max_speculative_executions"));
+    sym_page_size = ID2SYM(rb_intern("page_size"));
+
+    Init_cassandra();
+    Init_session();
+    Init_statement();
+    Init_result();
+    Init_future();
+
+    cass_log_set_level(CASS_LOG_ERROR);
+
+#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE)
+    cass_alloc_set_functions(ilios_malloc, ilios_realloc, ilios_free);
+#endif
+}

data/ext/ilios/ilios.h

@@ -0,0 +1,105 @@
+#ifndef ILIOS_H
+#define ILIOS_H
+
+#include <stdint.h>
+#include <float.h>
+#include <cassandra.h>
+#include <uv.h>
+#include "ruby.h"
+#include "ruby/thread.h"
+
+#define GET_SESSION(obj, var)   TypedData_Get_Struct(obj, CassandraSession, &cassandra_session_data_type, var)
+#define GET_STATEMENT(obj, var) TypedData_Get_Struct(obj, CassandraStatement, &cassandra_statement_data_type, var)
+#define GET_RESULT(obj, var)    TypedData_Get_Struct(obj, CassandraResult, &cassandra_result_data_type, var)
+#define GET_FUTURE(obj, var)    TypedData_Get_Struct(obj, CassandraFuture, &cassandra_future_data_type, var)
+#define CREATE_SESSION(var)     TypedData_Make_Struct(cSession, CassandraSession, &cassandra_session_data_type, var)
+#define CREATE_STATEMENT(var)   TypedData_Make_Struct(cStatement, CassandraStatement, &cassandra_statement_data_type, var)
+#define CREATE_RESULT(var)      TypedData_Make_Struct(cResult, CassandraResult, &cassandra_result_data_type, var)
+#define CREATE_FUTURE(var)      TypedData_Make_Struct(cFuture, CassandraFuture, &cassandra_future_data_type, var)
+
+typedef enum {
+  prepare_async,
+  execute_async
+} future_kind;
+
+typedef struct
+{
+    CassCluster* cluster;
+    CassFuture* connect_future;
+    CassSession* session;
+
+} CassandraSession;
+
+typedef struct
+{
+    CassStatement* statement;
+    const CassPrepared* prepared;
+    VALUE session_obj;
+} CassandraStatement;
+
+typedef struct
+{
+    const CassResult *result;
+    CassFuture *future;
+    VALUE statement_obj;
+} CassandraResult;
+
+typedef struct
+{
+    CassFuture *future;
+    future_kind kind;
+
+    VALUE session_obj;
+    VALUE statement_obj;
+    VALUE on_success_block;
+    VALUE on_failure_block;
+    VALUE proc_mutex;
+} CassandraFuture;
+
+extern const rb_data_type_t cassandra_session_data_type;
+extern const rb_data_type_t cassandra_statement_data_type;
+extern const rb_data_type_t cassandra_result_data_type;
+extern const rb_data_type_t cassandra_future_data_type;
+
+extern VALUE mIlios;
+extern VALUE mCassandra;
+extern VALUE cSession;
+extern VALUE cStatement;
+extern VALUE cResult;
+extern VALUE cFuture;
+extern VALUE eConnectError;
+extern VALUE eExecutionError;
+extern VALUE eStatementError;
+
+extern VALUE cQueue;
+
+extern VALUE id_cvar_config;
+extern VALUE id_shuffle;
+extern VALUE id_to_time;
+extern VALUE id_abort_on_exception_set;
+extern VALUE id_new;
+extern VALUE id_push;
+extern VALUE id_pop;
+extern VALUE sym_unsupported_column_type;
+extern VALUE sym_keyspace;
+extern VALUE sym_hosts;
+extern VALUE sym_timeout_ms;
+extern VALUE sym_constant_delay_ms;
+extern VALUE sym_max_speculative_executions;
+extern VALUE sym_page_size;
+
+extern void Init_cassandra(void);
+extern void Init_session(void);
+extern void Init_statement(void);
+extern void Init_result(void);
+extern void Init_future(void);
+
+extern void nogvl_future_wait(CassFuture *future);
+extern CassFuture *nogvl_session_prepare(CassSession* session, VALUE query);
+extern CassFuture *nogvl_session_execute(CassSession* session, CassStatement* statement);
+
+extern void statement_default_config(CassandraStatement *cassandra_statement);
+extern void result_await(CassandraResult *cassandra_result);
+
+
+#endif // ILIOS_H

data/ext/ilios/nogvl.c

@@ -0,0 +1,53 @@
+#include "ilios.h"
+
+typedef struct {
+    CassSession* session;
+    const char *query;
+} nogvl_session_prepare_args;
+
+typedef struct {
+    CassSession* session;
+    CassStatement* statement;
+} nogvl_session_execute_args;
+
+static void *nogvl_future_wait_cb(void *ptr)
+{
+    CassFuture *future = (CassFuture *)ptr;
+    cass_future_wait(future);
+    return NULL;
+}
+
+void nogvl_future_wait(CassFuture *future)
+{
+    rb_thread_call_without_gvl(nogvl_future_wait_cb, future, RUBY_UBF_PROCESS, 0);
+}
+
+static void *nogvl_session_prepare_cb(void *ptr)
+{
+    nogvl_session_prepare_args *args = (nogvl_session_prepare_args *)ptr;
+    CassFuture *prepare_future;
+
+    prepare_future = cass_session_prepare(args->session, args->query);
+    return (void *)prepare_future;
+}
+
+CassFuture *nogvl_session_prepare(CassSession* session, VALUE query)
+{
+    nogvl_session_prepare_args args = { session, StringValueCStr(query) };
+    return (CassFuture *)rb_thread_call_without_gvl(nogvl_session_prepare_cb, &args, RUBY_UBF_PROCESS, 0);
+}
+
+static void *nogvl_session_execute_cb(void *ptr)
+{
+    nogvl_session_execute_args *args = (nogvl_session_execute_args *)ptr;
+    CassFuture *result_future;
+
+    result_future = cass_session_execute(args->session, args->statement);
+    return (void *)result_future;
+}
+
+CassFuture *nogvl_session_execute(CassSession* session, CassStatement* statement)
+{
+    nogvl_session_execute_args args = { session, statement };
+    return (CassFuture *)rb_thread_call_without_gvl(nogvl_session_execute_cb, &args, RUBY_UBF_PROCESS, 0);
+}

data/ext/ilios/result.c

@@ -0,0 +1,239 @@
+#include "ilios.h"
+
+static void result_mark(void *ptr);
+static void result_destroy(void *ptr);
+static size_t result_memsize(const void *ptr);
+static void result_compact(void *ptr);
+
+const rb_data_type_t cassandra_result_data_type = {
+    "Ilios::Cassandra::Result",
+    {
+        result_mark,
+        result_destroy,
+        result_memsize,
+        result_compact,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+void result_await(CassandraResult *cassandra_result)
+{
+    nogvl_future_wait(cassandra_result->future);
+
+    if (cass_future_error_code(cassandra_result->future) != CASS_OK) {
+        char error[4096] = { 0 };
+
+        strncpy(error, cass_error_desc(cass_future_error_code(cassandra_result->future)), sizeof(error) - 1);
+        rb_raise(eExecutionError, "Unable to wait executing: %s", error);
+    }
+
+    if (cassandra_result->result == NULL) {
+        cassandra_result->result = cass_future_get_result(cassandra_result->future);
+    }
+}
+
+static VALUE result_next_page(VALUE self)
+{
+    CassandraResult *cassandra_result;
+    CassandraStatement *cassandra_statement;
+    CassandraSession *cassandra_session;
+    CassFuture *result_future;
+
+    GET_RESULT(self, cassandra_result);
+
+    if (cass_result_has_more_pages(cassandra_result->result) == cass_false) {
+        return Qnil;
+    }
+
+    GET_STATEMENT(cassandra_result->statement_obj, cassandra_statement);
+    GET_SESSION(cassandra_statement->session_obj, cassandra_session);
+
+    cass_statement_set_paging_state(cassandra_statement->statement, cassandra_result->result);
+
+    result_future = nogvl_session_execute(cassandra_session->session, cassandra_statement->statement);
+
+    cass_result_free(cassandra_result->result);
+    cass_future_free(cassandra_result->future);
+    cassandra_result->result = NULL;
+    cassandra_result->future = result_future;
+
+    result_await(cassandra_result);
+    return self;
+}
+
+static VALUE result_convert_row(const CassResult *result, const CassRow *row, size_t column_count)
+{
+    VALUE key;
+    const char *name;
+    size_t name_length;
+    VALUE hash = rb_hash_new();
+
+    for (size_t i = 0; i < column_count; i++) {
+        const CassValue *value = cass_row_get_column(row, i);
+        const CassValueType type = cass_value_type(value);
+
+        cass_result_column_name(result, i, &name, &name_length);
+        key = rb_str_new(name, name_length);
+
+        if (cass_value_is_null(value)) {
+            rb_hash_aset(hash, key, Qnil);
+            continue;
+        }
+
+        switch (type) {
+        case CASS_VALUE_TYPE_TINY_INT:
+            {
+                cass_int8_t output;
+                cass_value_get_int8(value, &output);
+                rb_hash_aset(hash, key, INT2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_SMALL_INT:
+            {
+                cass_int16_t output;
+                cass_value_get_int16(value, &output);
+                rb_hash_aset(hash, key, INT2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_INT:
+            {
+                cass_int32_t output;
+                cass_value_get_int32(value, &output);
+                rb_hash_aset(hash, key, INT2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_BIGINT:
+            {
+                cass_int64_t output;
+                cass_value_get_int64(value, &output);
+                rb_hash_aset(hash, key, LL2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_FLOAT:
+            {
+                cass_float_t output;
+                cass_value_get_float(value, &output);
+                rb_hash_aset(hash, key, DBL2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_DOUBLE:
+            {
+                cass_double_t output;
+                cass_value_get_double(value, &output);
+                rb_hash_aset(hash, key, DBL2NUM(output));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_BOOLEAN:
+            {
+                cass_bool_t output;
+                cass_value_get_bool(value, &output);
+                rb_hash_aset(hash, key, output == cass_true ? Qtrue : Qfalse);
+            }
+            break;
+
+        case CASS_VALUE_TYPE_TEXT:
+        case CASS_VALUE_TYPE_ASCII:
+        case CASS_VALUE_TYPE_VARCHAR:
+            {
+                const char* s;
+                size_t s_length;
+                cass_value_get_string(value, &s, &s_length);
+                rb_hash_aset(hash, key, rb_str_new(s, s_length));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_TIMESTAMP:
+            {
+                cass_int64_t output;
+                cass_value_get_int64(value, &output);
+                rb_hash_aset(hash, key, rb_time_new(output / 1000, output % 1000 * 1000));
+            }
+            break;
+
+        case CASS_VALUE_TYPE_UUID:
+            {
+                CassUuid output;
+                char uuid[40];
+                cass_value_get_uuid(value, &output);
+                cass_uuid_string(output, uuid);
+                rb_hash_aset(hash, key, rb_str_new2(uuid));
+            }
+            break;
+
+        default:
+            rb_warn("Unsupported type: %d", type);
+            rb_hash_aset(hash, key, sym_unsupported_column_type);
+        }
+    }
+
+    return hash;
+}
+
+static VALUE result_each(VALUE self)
+{
+    CassandraResult *cassandra_result;
+    CassIterator *iterator;
+    size_t column_count;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    GET_RESULT(self, cassandra_result);
+
+    iterator = cass_iterator_from_result(cassandra_result->result);
+    column_count = cass_result_column_count(cassandra_result->result);
+    while (cass_iterator_next(iterator)) {
+        const CassRow *row = cass_iterator_get_row(iterator);
+        rb_yield(result_convert_row(cassandra_result->result, row, column_count));
+    }
+    cass_iterator_free(iterator);
+
+    return self;
+}
+
+static void result_mark(void *ptr)
+{
+    CassandraResult *cassandra_result = (CassandraResult *)ptr;
+    rb_gc_mark_movable(cassandra_result->statement_obj);
+}
+
+static void result_destroy(void *ptr)
+{
+    CassandraResult *cassandra_result = (CassandraResult *)ptr;
+
+    if (cassandra_result->result) {
+        cass_result_free(cassandra_result->result);
+    }
+    if (cassandra_result->future) {
+        cass_future_free(cassandra_result->future);
+    }
+    xfree(cassandra_result);
+}
+
+static size_t result_memsize(const void *ptr)
+{
+    return sizeof(CassandraResult);
+}
+
+static void result_compact(void *ptr)
+{
+    CassandraResult *cassandra_result = (CassandraResult *)ptr;
+
+    cassandra_result->statement_obj = rb_gc_location(cassandra_result->statement_obj);
+}
+
+void Init_result(void)
+{
+    rb_undef_alloc_func(cResult);
+
+    rb_include_module(cResult, rb_mEnumerable);
+
+    rb_define_method(cResult, "next_page", result_next_page, 0);
+    rb_define_method(cResult, "each", result_each, 0);
+}

data/ext/ilios/session.c

@@ -0,0 +1,145 @@
+#include "ilios.h"
+
+static void session_destroy(void *ptr);
+static size_t session_memsize(const void *ptr);
+
+const rb_data_type_t cassandra_session_data_type = {
+    "Ilios::Cassandra::Session",
+    {
+        NULL,
+        session_destroy,
+        session_memsize,
+        NULL,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+static VALUE session_prepare_async(VALUE self, VALUE query)
+{
+    CassandraSession *cassandra_session;
+    CassandraFuture *cassandra_future;
+    CassFuture *prepare_future;
+    VALUE cassandra_future_obj;
+
+    GET_SESSION(self, cassandra_session);
+
+    prepare_future = nogvl_session_prepare(cassandra_session->session, query);
+
+    cassandra_future_obj = CREATE_FUTURE(cassandra_future);
+    cassandra_future->kind = prepare_async;
+    cassandra_future->future = prepare_future;
+    cassandra_future->session_obj = self;
+    cassandra_future->proc_mutex = rb_mutex_new();
+
+    return cassandra_future_obj;
+}
+
+static VALUE session_prepare(VALUE self, VALUE query)
+{
+    CassandraSession *cassandra_session;
+    CassandraStatement *cassandra_statement;
+    CassFuture *prepare_future;
+    VALUE cassandra_statement_obj;
+
+    GET_SESSION(self, cassandra_session);
+
+    prepare_future = nogvl_session_prepare(cassandra_session->session, query);
+    nogvl_future_wait(prepare_future);
+
+    if (cass_future_error_code(prepare_future) != CASS_OK) {
+        char error[4096] = { 0 };
+
+        strncpy(error, cass_error_desc(cass_future_error_code(prepare_future)), sizeof(error) - 1);
+        cass_future_free(prepare_future);
+        rb_raise(eExecutionError, "Unable to prepare query: %s", error);
+    }
+
+    cassandra_statement_obj = CREATE_STATEMENT(cassandra_statement);
+
+    cassandra_statement->prepared = cass_future_get_prepared(prepare_future);
+    cassandra_statement->statement = cass_prepared_bind(cassandra_statement->prepared);
+    cassandra_statement->session_obj = self;
+    cass_future_free(prepare_future);
+
+    statement_default_config(cassandra_statement);
+    return cassandra_statement_obj;
+}
+
+static VALUE session_execute_async(VALUE self, VALUE statement)
+{
+    CassandraSession *cassandra_session;
+    CassandraStatement *cassandra_statement;
+    CassandraFuture *cassandra_future;
+    CassFuture *result_future;
+    VALUE cassandra_future_obj;
+
+    GET_SESSION(self, cassandra_session);
+    GET_STATEMENT(statement, cassandra_statement);
+
+    result_future = nogvl_session_execute(cassandra_session->session, cassandra_statement->statement);
+
+    cassandra_future_obj = CREATE_FUTURE(cassandra_future);
+    cassandra_future->kind = execute_async;
+    cassandra_future->future = result_future;
+    cassandra_future->session_obj = self;
+    cassandra_future->statement_obj = statement;
+    cassandra_future->proc_mutex = rb_mutex_new();
+
+    return cassandra_future_obj;
+}
+
+static VALUE session_execute(VALUE self, VALUE statement)
+{
+    CassandraSession *cassandra_session;
+    CassandraStatement *cassandra_statement;
+    CassandraResult *cassandra_result;
+    CassFuture *result_future;
+    VALUE cassandra_result_obj;
+
+    GET_SESSION(self, cassandra_session);
+    GET_STATEMENT(statement, cassandra_statement);
+
+    result_future = nogvl_session_execute(cassandra_session->session, cassandra_statement->statement);
+
+    cassandra_result_obj = CREATE_RESULT(cassandra_result);
+    cassandra_result->future = result_future;
+    cassandra_result->statement_obj = statement;
+
+    result_await(cassandra_result);
+    return cassandra_result_obj;
+}
+
+static void session_destroy(void *ptr)
+{
+    CassandraSession *cassandra_session = (CassandraSession *)ptr;
+
+    if (cassandra_session->session) {
+        CassFuture *close_future = cass_session_close(cassandra_session->session);
+        nogvl_future_wait(close_future);
+        cass_future_free(close_future);
+        cass_session_free(cassandra_session->session);
+    }
+    if (cassandra_session->connect_future) {
+        cass_future_free(cassandra_session->connect_future);
+    }
+    if (cassandra_session->cluster) {
+        cass_cluster_free(cassandra_session->cluster);
+    }
+    xfree(cassandra_session);
+}
+
+static size_t session_memsize(const void *ptr)
+{
+    return sizeof(CassandraSession);
+}
+
+void Init_session(void)
+{
+    rb_undef_alloc_func(cSession);
+
+    rb_define_method(cSession, "prepare_async", session_prepare_async, 1);
+    rb_define_method(cSession, "prepare", session_prepare, 1);
+    rb_define_method(cSession, "execute_async", session_execute_async, 1);
+    rb_define_method(cSession, "execute", session_execute, 1);
+}