ilios 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18d160f81c3298017c1e7936a32b3c3668414ebc1c327c59ef24c4ad741aa16a
+  data.tar.gz: d664a164d230db6deea79bdf8f80ad6e2225da9f31640a84868a4b6d4a91062f
+SHA512:
+  metadata.gz: 8d3634a3a2fab8cf35f514cde6fc741f37fb4aa876d8f96cf277d18e90606c5e52682b32731ffd0347bd7666a04df7496d486a0a7861fc189b622b175b2dce0a
+  data.tar.gz: fd1e720c2b4dabe04b973a5db48d993188b630d6ec476bb22710062e11aed5e4fdb42245513b970f9b31508893be13dfa577d30527cb7748c5ccd1368a1c3b9f

data/Dockerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:22.04
+
+RUN apt update && \
+    apt install -y tzdata sudo && \
+    apt install -y curl cmake make gcc g++ git bzip2 zlib1g-dev libgdbm-dev libreadline-dev libffi-dev libssl-dev libyaml-dev && \
+    git clone --depth 1 https://github.com/rbenv/ruby-build.git && \
+    cd ruby-build/bin && ./ruby-build 3.0.6 /usr/local
+
+WORKDIR /opt/ilios

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ilios.gemspec
+gemspec
+
+gem 'minitest', '~> 5.20'
+gem 'rake', '~> 13.0'
+gem 'rake-compiler', '~> 1.2'
+gem 'rubocop', '~> 1.57'
+gem 'rubocop-minitest', '~> 0.33.0'
+gem 'rubocop-performance', '~> 1.19'

data/README.md

@@ -0,0 +1,128 @@
+# Ilios
+
+Ilios that Cassandra driver written by C language for Ruby using [DataStax C/C++ Driver](https://github.com/datastax/cpp-driver).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```sh
+$ bundle add ilios
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```sh
+$ gem install ilios
+```
+
+## Example
+### Basic usage
+
+Create the keyspace in advance using the `cqlsh` command.
+
+```sh
+CREATE KEYSPACE IF NOT EXISTS ilios
+WITH REPLICATION = {
+  'class' : 'SimpleStrategy',
+  'replication_factor' : 1
+};
+```
+
+```ruby
+require 'ilios'
+
+Ilios::Cassandra.config = {
+  keyspace: 'ilios',
+  hosts: ['127.0.0.1'],
+}
+
+# Create the table
+statement = Ilios::Cassandra.session.prepare(<<~CQL)
+  CREATE TABLE IF NOT EXISTS ilios.example (
+    id bigint,
+    message text,
+    created_at timestamp,
+    PRIMARY KEY (id)
+  ) WITH compaction = { 'class' : 'LeveledCompactionStrategy' }
+  AND gc_grace_seconds = 691200;
+CQL
+Ilios::Cassandra.session.execute(statement)
+
+# Insert the records
+statement = Ilios::Cassandra.session.prepare(<<~CQL)
+  INSERT INTO ilios.example (
+    id,
+    message,
+    created_at
+  ) VALUES (?, ?, ?)
+CQL
+
+100.times do |i|
+  statement.bind({
+    id: i,
+    message: 'Hello World',
+    created_at: Time.now,
+  })
+  Ilios::Cassandra.session.execute(statement)
+end
+
+# Select the records
+statement = Ilios::Cassandra.session.prepare(<<~CQL)
+  SELECT * FROM ilios.example
+CQL
+statement.page_size = 25
+result = Ilios::Cassandra.session.execute(statement)
+result.each do |row|
+  p row
+end
+
+while(result.next_page)
+  result.each do |row|
+    p row
+  end
+end
+```
+
+### Synchronous API
+`Ilios::Cassandra::Session#prepare` and `Ilios::Cassandra::Session#execute` are provided as synchronous API.
+
+```ruby
+statement = Ilios::Cassandra.session.prepare(<<~CQL)
+  SELECT * FROM ilios.example
+CQL
+result = Ilios::Cassandra.session.execute(statement)
+```
+
+### Asynchronous API
+`Ilios::Cassandra::Session#prepare_async` and `Ilios::Cassandra::Session#execute_async` are provided as asynchronous API.
+
+```ruby
+prepare_future = Ilios::Cassandra.session.prepare_async(<<~CQL)
+  INSERT INTO ilios.example (
+    id,
+    message,
+    created_at
+  ) VALUES (?, ?, ?)
+CQL
+
+prepare_future.on_success { |statement|
+  statement.bind({
+    id: 1,
+    message: 'Hello World',
+    created_at: Time.now,
+  })
+  result_future = Ilios::Cassandra.session.execute_async(statement)
+  result_future.on_success { |result|
+    p result
+    p "success"
+  }
+  result_future.on_failure {
+    p "fail"
+  }
+}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Watson1978/ilios.

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rake/testtask'
+
+task test: :compile
+task default: :test
+
+Rake::ExtensionTask.new('ilios') do |ext|
+  ext.ext_dir = 'ext/ilios'
+end
+
+Rake::TestTask.new do |task|
+  task.pattern = 'test/test_*.rb'
+end

data/docker-compose.yml

@@ -0,0 +1,20 @@
+version: '3'
+services:
+  cassandra:
+    image: cassandra:4
+    ports:
+    - 9042:9042
+    volumes:
+    - cassandra-data:/var/lib/cassandra
+  ilios:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    depends_on:
+    - cassandra
+    command: bash -c 'sleep infinity'
+    volumes:
+    - "./:/opt/ilios"
+volumes:
+  cassandra-data:
+    driver: local

data/ext/ilios/cassandra.c

@@ -0,0 +1,63 @@
+#include "ilios.h"
+
+static VALUE cassandra_connect(VALUE self)
+{
+    CassandraSession *cassandra_session;
+    VALUE cassandra_session_obj;
+    VALUE config;
+    VALUE hosts;
+    VALUE keyspace;
+    char last_error[4096] = { 0 };
+
+    cassandra_session_obj = CREATE_SESSION(cassandra_session);
+
+    cassandra_session->cluster = cass_cluster_new();
+    cass_cluster_set_protocol_version(cassandra_session->cluster, CASS_PROTOCOL_VERSION_V4);
+
+    config = rb_cvar_get(self, id_cvar_config);
+    cass_cluster_set_request_timeout(cassandra_session->cluster, NUM2UINT(rb_hash_aref(config, sym_timeout_ms)));
+    cass_cluster_set_constant_speculative_execution_policy(cassandra_session->cluster, NUM2LONG(rb_hash_aref(config, sym_constant_delay_ms)), NUM2INT(rb_hash_aref(config, sym_max_speculative_executions)));
+
+    keyspace = rb_hash_aref(config, sym_keyspace);
+    hosts = rb_hash_aref(config, sym_hosts);
+
+    Check_Type(hosts, T_ARRAY);
+    if (RARRAY_LEN(hosts) == 0) {
+        rb_raise(rb_eRuntimeError, "No hosts configured");
+    }
+    if (RARRAY_LEN(hosts) > 1) {
+        // To distribute connections
+        hosts = rb_funcall(hosts, id_shuffle, 0);
+    }
+
+    for (int i = 0; i < RARRAY_LEN(hosts); i++) {
+        VALUE host = RARRAY_AREF(hosts, i);
+
+        cass_cluster_set_contact_points(cassandra_session->cluster, ""); // Clear previous contact points
+        cass_cluster_set_contact_points(cassandra_session->cluster, StringValueCStr(host));
+        cassandra_session->session = cass_session_new();
+        cassandra_session->connect_future =  cass_session_connect_keyspace(cassandra_session->session, cassandra_session->cluster, StringValueCStr(keyspace));
+        nogvl_future_wait(cassandra_session->connect_future);
+
+        if (cass_future_error_code(cassandra_session->connect_future) == CASS_OK) {
+            return cassandra_session_obj;
+        }
+
+        strncpy(last_error, cass_error_desc(cass_future_error_code(cassandra_session->connect_future)), sizeof(last_error) - 1);
+        cass_future_free(cassandra_session->connect_future);
+        cass_session_free(cassandra_session->session);
+        cassandra_session->connect_future = NULL;
+        cassandra_session->session = NULL;
+    }
+
+    cass_cluster_free(cassandra_session->cluster);
+    cassandra_session->cluster = NULL;
+
+    rb_raise(eConnectError, "Unable to connect: %s", last_error);
+    return Qnil;
+}
+
+void Init_cassandra(void)
+{
+    rb_define_module_function(mCassandra, "connect", cassandra_connect, 0);
+}

data/ext/ilios/extconf.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../lib/ilios/version', __dir__)
+require 'fileutils'
+require 'mini_portile2'
+require 'mkmf'
+
+have_func('malloc_usable_size')
+have_func('malloc_size')
+
+CASSANDRA_CPP_DRIVER_INSTALL_PATH = File.expand_path('cpp-driver')
+LIBUV_INSTALL_PATH = File.expand_path('libuv')
+
+unless find_executable('cmake')
+  puts '--------------------------------------------------'
+  puts 'Error: cmake is required to build this gem'
+  puts '--------------------------------------------------'
+  raise
+end
+
+unless File.exist?(LIBUV_INSTALL_PATH)
+  class LibuvRecipe < MiniPortileCMake
+    def configure_prefix
+      "-DCMAKE_INSTALL_PREFIX=#{LIBUV_INSTALL_PATH}"
+    end
+  end
+
+  libuv_recipe = LibuvRecipe.new('libuv', Ilios::LIBUV_VERSION, make_command: 'make -j 3')
+  libuv_recipe.files << {
+    url: "https://github.com/libuv/libuv/archive/v#{Ilios::LIBUV_VERSION}.tar.gz"
+  }
+  libuv_recipe.cook
+  if RUBY_PLATFORM.include?('darwin')
+    unless find_executable('install_name_tool')
+      puts '------------------------------------------------------'
+      puts 'Error: install_name_tool is required to build this gem'
+      puts '------------------------------------------------------'
+      raise
+    end
+    xsystem("install_name_tool -id #{LIBUV_INSTALL_PATH}/lib/libuv.1.dylib #{LIBUV_INSTALL_PATH}/lib/libuv.1.dylib")
+  end
+end
+
+unless File.exist?(CASSANDRA_CPP_DRIVER_INSTALL_PATH)
+  class CassandraRecipe < MiniPortileCMake
+    def initialize(name, version, **kwargs)
+      ENV['LIBUV_ROOT_DIR'] = LIBUV_INSTALL_PATH
+      super(name, version, **kwargs)
+    end
+
+    def configure_prefix
+      "-DCMAKE_INSTALL_PREFIX=#{CASSANDRA_CPP_DRIVER_INSTALL_PATH}"
+    end
+  end
+
+  cassandra_recipe = CassandraRecipe.new('cpp-driver', Ilios::CASSANDRA_CPP_DRIVER_VERSION, make_command: 'make -j 3')
+  cassandra_recipe.files << {
+    url: "https://github.com/datastax/cpp-driver/archive/#{Ilios::CASSANDRA_CPP_DRIVER_VERSION}.tar.gz"
+  }
+  cassandra_recipe.cook
+  if RUBY_PLATFORM.include?('darwin')
+    xsystem("install_name_tool -id #{CASSANDRA_CPP_DRIVER_INSTALL_PATH}/lib/libcassandra.2.dylib #{CASSANDRA_CPP_DRIVER_INSTALL_PATH}/lib/libcassandra.2.dylib")
+  end
+end
+
+FileUtils.rm_rf('ports')
+FileUtils.rm_rf('tmp')
+
+$CPPFLAGS += " -I#{CASSANDRA_CPP_DRIVER_INSTALL_PATH}/include -I#{LIBUV_INSTALL_PATH}/include"
+$LDFLAGS += " -L#{CASSANDRA_CPP_DRIVER_INSTALL_PATH}/lib -Wl,-rpath,#{CASSANDRA_CPP_DRIVER_INSTALL_PATH}/lib -lcassandra"
+$LDFLAGS += " -L#{LIBUV_INSTALL_PATH}/lib -Wl,-rpath,#{LIBUV_INSTALL_PATH}/lib -luv"
+
+create_makefile('ilios')

data/ext/ilios/future.c

@@ -0,0 +1,269 @@
+#include "ilios.h"
+
+#define THREAD_MAX 5
+
+typedef struct
+{
+    VALUE thread[THREAD_MAX];
+    VALUE queue;
+} future_thread_pool;
+
+static future_thread_pool thread_pool_prepare;
+static future_thread_pool thread_pool_execute;
+
+static VALUE future_result_yielder_thread(void *arg);
+static void future_mark(void *ptr);
+static void future_destroy(void *ptr);
+static size_t future_memsize(const void *ptr);
+static void future_compact(void *ptr);
+
+const rb_data_type_t cassandra_future_data_type = {
+    "Ilios::Cassandra::Future",
+    {
+        future_mark,
+        future_destroy,
+        future_memsize,
+        future_compact,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+static void future_thread_pool_init(future_thread_pool *pool)
+{
+    pool->queue = rb_funcall(cQueue, id_new, 0);
+    for (int i = 0; i < THREAD_MAX; i++) {
+        pool->thread[i] = rb_thread_create(future_result_yielder_thread, (void*)pool);
+    }
+}
+
+static inline future_thread_pool *future_thread_pool_get(CassandraFuture *cassandra_future)
+{
+    future_thread_pool *pool = NULL;
+
+    switch (cassandra_future->kind) {
+    case prepare_async:
+        pool = &thread_pool_prepare;
+        break;
+    case execute_async:
+        pool = &thread_pool_execute;
+        break;
+    }
+    return pool;
+}
+
+static inline void future_queue_push(future_thread_pool *pool, VALUE future)
+{
+    rb_funcall(pool->queue, id_push, 1, future);
+}
+
+static inline VALUE future_queue_pop(future_thread_pool *pool)
+{
+    return rb_funcall(pool->queue, id_pop, 0);
+}
+
+static void future_result_success_yield(CassandraFuture *cassandra_future)
+{
+    VALUE obj;
+
+    if (cassandra_future->on_success_block) {
+        if (rb_proc_arity(cassandra_future->on_success_block)) {
+            switch (cassandra_future->kind) {
+            case prepare_async:
+                {
+                    CassandraStatement *cassandra_statement;
+                    VALUE cassandra_statement_obj;
+
+                    cassandra_statement_obj = CREATE_STATEMENT(cassandra_statement);
+                    cassandra_statement->prepared = cass_future_get_prepared(cassandra_future->future);
+                    cassandra_statement->statement = cass_prepared_bind(cassandra_statement->prepared);
+                    cassandra_statement->session_obj = cassandra_future->session_obj;
+
+                    statement_default_config(cassandra_statement);
+
+                    obj = cassandra_statement_obj;
+                }
+                break;
+            case execute_async:
+                {
+                    CassandraResult *cassandra_result;
+                    VALUE cassandra_result_obj;
+
+                    cassandra_result_obj = CREATE_RESULT(cassandra_result);
+                    cassandra_result->result = cass_future_get_result(cassandra_future->future);
+                    cassandra_result->statement_obj = cassandra_future->statement_obj;
+
+                    obj = cassandra_result_obj;
+                }
+                break;
+            }
+
+            rb_proc_call_with_block(cassandra_future->on_success_block, 1, &obj, Qnil);
+        } else {
+            rb_proc_call_with_block(cassandra_future->on_success_block, 0, NULL, Qnil);
+        }
+    }
+}
+
+static void future_result_failure_yield(CassandraFuture *cassandra_future)
+{
+    if (cassandra_future->on_failure_block) {
+        rb_proc_call_with_block(cassandra_future->on_failure_block, 0, NULL, Qnil);
+    }
+}
+
+static VALUE future_result_yielder_synchronize(VALUE arg)
+{
+    CassandraFuture *cassandra_future;
+
+    GET_FUTURE(arg, cassandra_future);
+
+    if (cass_future_error_code(cassandra_future->future) == CASS_OK) {
+        future_result_success_yield(cassandra_future);
+    } else {
+        future_result_failure_yield(cassandra_future);
+    }
+    return Qnil;
+}
+
+static VALUE future_result_yielder(VALUE arg)
+{
+    CassandraFuture *cassandra_future;
+
+    GET_FUTURE(arg, cassandra_future);
+
+    nogvl_future_wait(cassandra_future->future);
+    return rb_mutex_synchronize(cassandra_future->proc_mutex, future_result_yielder_synchronize, arg);
+}
+
+static VALUE future_result_yielder_thread(void *arg)
+{
+    future_thread_pool *pool = (future_thread_pool *)arg;
+
+    while (1) {
+        VALUE future = future_queue_pop(pool);
+        future_result_yielder(future);
+    }
+    return Qnil;
+}
+
+static VALUE future_on_success(VALUE self)
+{
+    CassandraFuture *cassandra_future;
+    bool wakeup_thread = false;
+
+    GET_FUTURE(self, cassandra_future);
+
+    if (cassandra_future->on_success_block) {
+        rb_raise(eExecutionError, "It should not call twice");
+    }
+
+    if (rb_block_given_p()) {
+        rb_mutex_lock(cassandra_future->proc_mutex);
+
+        if (!cassandra_future->on_failure_block) {
+            // Invoke the callback with thread pool only once
+            wakeup_thread = true;
+        }
+
+        cassandra_future->on_success_block = rb_block_proc();
+
+        if (cass_future_ready(cassandra_future->future)) {
+            rb_mutex_unlock(cassandra_future->proc_mutex);
+            if (cass_future_error_code(cassandra_future->future) == CASS_OK) {
+                future_result_success_yield(cassandra_future);
+            }
+            return self;
+        }
+
+        if (wakeup_thread) {
+            future_queue_push(future_thread_pool_get(cassandra_future), self);
+        }
+        rb_mutex_unlock(cassandra_future->proc_mutex);
+    }
+    return self;
+}
+
+static VALUE future_on_failure(VALUE self)
+{
+    CassandraFuture *cassandra_future;
+    bool wakeup_thread = false;
+
+    GET_FUTURE(self, cassandra_future);
+
+    if (cassandra_future->on_failure_block) {
+        rb_raise(eExecutionError, "It should not call twice");
+    }
+
+    if (rb_block_given_p()) {
+        rb_mutex_lock(cassandra_future->proc_mutex);
+
+        if (!cassandra_future->on_success_block) {
+            // Invoke the callback with thread pool only once
+            wakeup_thread = true;
+        }
+
+        cassandra_future->on_failure_block = rb_block_proc();
+
+        if (cass_future_ready(cassandra_future->future)) {
+            rb_mutex_unlock(cassandra_future->proc_mutex);
+            if (cass_future_error_code(cassandra_future->future) != CASS_OK) {
+                future_result_failure_yield(cassandra_future);
+            }
+            return self;
+        }
+
+        if (wakeup_thread) {
+            future_queue_push(future_thread_pool_get(cassandra_future), self);
+        }
+        rb_mutex_unlock(cassandra_future->proc_mutex);
+    }
+    return self;
+}
+
+static void future_mark(void *ptr)
+{
+    CassandraFuture *cassandra_future = (CassandraFuture *)ptr;
+    rb_gc_mark_movable(cassandra_future->session_obj);
+    rb_gc_mark_movable(cassandra_future->statement_obj);
+    rb_gc_mark_movable(cassandra_future->on_success_block);
+    rb_gc_mark_movable(cassandra_future->on_failure_block);
+    rb_gc_mark_movable(cassandra_future->proc_mutex);
+}
+
+static void future_destroy(void *ptr)
+{
+    CassandraFuture *cassandra_future = (CassandraFuture *)ptr;
+
+    if (cassandra_future->future) {
+        cass_future_free(cassandra_future->future);
+    }
+    xfree(cassandra_future);
+}
+
+static size_t future_memsize(const void *ptr)
+{
+    return sizeof(CassandraFuture);
+}
+
+static void future_compact(void *ptr)
+{
+    CassandraFuture *cassandra_future = (CassandraFuture *)ptr;
+
+    cassandra_future->session_obj = rb_gc_location(cassandra_future->session_obj);
+    cassandra_future->statement_obj = rb_gc_location(cassandra_future->statement_obj);
+    cassandra_future->on_success_block = rb_gc_location(cassandra_future->on_success_block);
+    cassandra_future->on_failure_block = rb_gc_location(cassandra_future->on_failure_block);
+    cassandra_future->proc_mutex = rb_gc_location(cassandra_future->proc_mutex);
+}
+
+void Init_future(void)
+{
+    rb_undef_alloc_func(cFuture);
+
+    rb_define_method(cFuture, "on_success", future_on_success, 0);
+    rb_define_method(cFuture, "on_failure", future_on_failure, 0);
+
+    future_thread_pool_init(&thread_pool_prepare);
+    future_thread_pool_init(&thread_pool_execute);
+}