ilios 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97cd17ec9e27eba88f4200dc050417934daa8820a8c6621b47ffa0e76d4f38be
-  data.tar.gz: '0508e6e770984ba635caa2a587a69a7a2a0b7eedab2016dfa1292480ddf81ea6'
+  metadata.gz: 9a0eec8f797b5f1c0cd369a5f43f004d6acf3a27870580689ede24d637035d35
+  data.tar.gz: 7ca5100a6125c8b6069597b4c23b26ce5313fc0222a625f9e17933ec73270562
 SHA512:
-  metadata.gz: b882a9744b4cde1c74429c6a4ab3bc8de0338ac0e7b56a9bd657ad0c843a35c77deaa884e2a898c5b5ae5a4dff5c8d8aadfce30a4000dbf4df103e7376bd3b1c
-  data.tar.gz: 66757dbdfc249e68613f1ace36092520b8efad5d82db1f41a15ba8b0b2226502abd6bb288a9e7a73d6e82f7c0491bb2f86de3e977b4556cced7ae50c4feff439
+  metadata.gz: c200386bf0f73dc3adea1cf56abb3778e2b968ae14309841e15e0c11f52778b663c4271e0119bea9b472a94b137c62adaa2f2a118ea89bfe2d2c8eff64ff6ca0
+  data.tar.gz: 152eadf8000d73569e604d9c681b9e410c15a066c947c196ba66619fc776f3089a489a9363967766ee87c4ac05421960b628994e9e581e94ddf883b04810db86

data/README.md

@@ -20,14 +20,14 @@ This gem's installer will install the DataStax C/C++ Driver to the appropriate l
 However, if you prefer to install the DataStax C/C++ Driver manually, you can do so by executing:
 
 ```sh
-$ bundle config set --local build.ilios --with-cpp-driver-dir=/path/to/cassandra-cpp-driver-installed-dir
+$ bundle config set --local build.ilios --with-cassandra-driver-dir=/path/to/cassandra-cpp-driver-installed-dir
 $ bundle add ilios
 ```
 
 or
 
 ```sh
-$ gem install ilios -- --with-cpp-driver-dir=/path/to/cassandra-cpp-driver-installed-dir
+$ gem install ilios -- --with-cassandra-driver-dir=/path/to/cassandra-cpp-driver-installed-dir
 ```
 
 ## Requirements
@@ -58,13 +58,13 @@ Then, you can run the following code.
 ```ruby
 require 'ilios'
 
-Ilios::Cassandra.config = {
-  keyspace: 'ilios',
-  hosts: ['127.0.0.1'],
-}
+cluster = Ilios::Cassandra::Cluster.new
+cluster.keyspace('ilios')
+cluster.hosts(['127.0.0.1'])
+session = cluster.connect
 
 # Create the table
-statement = Ilios::Cassandra.session.prepare(<<~CQL)
+statement = session.prepare(<<~CQL)
   CREATE TABLE IF NOT EXISTS ilios.example (
     id bigint,
     message text,
@@ -73,10 +73,10 @@ statement = Ilios::Cassandra.session.prepare(<<~CQL)
   ) WITH compaction = { 'class' : 'LeveledCompactionStrategy' }
   AND gc_grace_seconds = 691200;
 CQL
-Ilios::Cassandra.session.execute(statement)
+session.execute(statement)
 
 # Insert the records
-statement = Ilios::Cassandra.session.prepare(<<~CQL)
+statement = session.prepare(<<~CQL)
   INSERT INTO ilios.example (
     id,
     message,
@@ -90,16 +90,16 @@ CQL
     message: 'Hello World',
     created_at: Time.now,
   })
-  Ilios::Cassandra.session.execute(statement)
+  session.execute(statement)
 end
 
 # Select the records
-statement = Ilios::Cassandra.session.prepare(<<~CQL)
+statement = session.prepare(<<~CQL)
   SELECT * FROM ilios.example
 CQL
 statement.idempotent = true
 statement.page_size = 25
-result = Ilios::Cassandra.session.execute(statement)
+result = session.execute(statement)
 result.each do |row|
   p row
 end
@@ -115,7 +115,7 @@ end
 `Ilios::Cassandra::Session#prepare` and `Ilios::Cassandra::Session#execute` are provided as synchronous API.
 
 ```ruby
-statement = Ilios::Cassandra.session.prepare(<<~CQL)
+statement = session.prepare(<<~CQL)
   SELECT * FROM ilios.example
 CQL
 result = Ilios::Cassandra.session.execute(statement)
@@ -125,7 +125,7 @@ result = Ilios::Cassandra.session.execute(statement)
 `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)
+prepare_future = session.prepare_async(<<~CQL)
   INSERT INTO ilios.example (
     id,
     message,
@@ -142,7 +142,7 @@ prepare_future.on_success { |statement|
       message: 'Hello World',
       created_at: Time.now,
     })
-    result_future = Ilios::Cassandra.session.execute_async(statement)
+    result_future = session.execute_async(statement)
     result_future.on_success { |result|
       p result
       p "success"

data/ext/ilios/cluster.c

@@ -0,0 +1,250 @@
+#include "ilios.h"
+
+static void cluster_mark(void *ptr);
+static void cluster_destroy(void *ptr);
+static size_t cluster_memsize(const void *ptr);
+static void cluster_compact(void *ptr);
+
+const rb_data_type_t cassandra_cluster_data_type = {
+    "Ilios::Cassandra::Cluster",
+    {
+        cluster_mark,
+        cluster_destroy,
+        cluster_memsize,
+        cluster_compact,
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+static VALUE cluster_allocator(VALUE klass)
+{
+    CassandraCluster *cassandra_cluster;
+    return CREATE_CLUSTER(cassandra_cluster);
+}
+
+/**
+ * Creates a new cluster.
+ *
+ * @return [Cassandra::Cluster] A new cluster.
+ */
+static VALUE cluster_initialize(VALUE self)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cassandra_cluster->cluster = cass_cluster_new();
+
+    return self;
+}
+
+/**
+ * Connects a session.
+ *
+ * @return [Cassandra::Session] A new session object.
+ * @raise [RuntimeError] If no host is specified to connect in +config+ method.
+ * @raise [Cassandra::ConnectError] If the connection fails for any reason.
+ */
+static VALUE cluster_connect(VALUE self)
+{
+    CassandraSession *cassandra_session;
+    CassandraCluster *cassandra_cluster;
+    VALUE cassandra_session_obj;
+    const char *keyspace = "";
+
+    GET_CLUSTER(self, cassandra_cluster);
+    if (cassandra_cluster->keyspace) {
+        keyspace = StringValueCStr(cassandra_cluster->keyspace);
+    }
+
+    cassandra_session_obj = CREATE_SESSION(cassandra_session);
+    cassandra_session->cluster_obj = self;
+    cassandra_session->session = cass_session_new();
+    cassandra_session->connect_future = cass_session_connect_keyspace(cassandra_session->session, cassandra_cluster->cluster, keyspace);
+    nogvl_future_wait(cassandra_session->connect_future);
+
+    if (cass_future_error_code(cassandra_session->connect_future) != CASS_OK) {
+        char error[4096] = { 0 };
+
+        strncpy(error, cass_error_desc(cass_future_error_code(cassandra_session->connect_future)), sizeof(error) - 1);
+        rb_raise(eConnectError, "Unable to connect: %s", error);
+        return Qnil;
+    }
+
+    return cassandra_session_obj;
+}
+
+/**
+ * Sets the contact points.
+ *
+ * @param hosts [Array<String>] An array of contact points.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_hosts(VALUE self, VALUE hosts)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+
+    Check_Type(hosts, T_ARRAY);
+    if (RARRAY_LEN(hosts) == 0) {
+        rb_raise(rb_eArgError, "No host exists.");
+    }
+
+    for (int i = 0; i < RARRAY_LEN(hosts); i++) {
+        VALUE host = RARRAY_AREF(hosts, i);
+        cass_cluster_set_contact_points(cassandra_cluster->cluster, StringValueCStr(host));
+    }
+
+    return self;
+}
+
+/**
+ * Sets the port number.
+ * Default is +9042+.
+ *
+ * @param port [Integer] A port number.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_port(VALUE self, VALUE port)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cass_cluster_set_port(cassandra_cluster->cluster, NUM2INT(port));
+
+    return self;
+}
+
+/**
+ * Sets the keyspace.
+ *
+ * @param keyspace [Integer] A keyspace.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_keyspace(VALUE self, VALUE keyspace)
+{
+    CassandraCluster *cassandra_cluster;
+
+    StringValue(keyspace);
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cassandra_cluster->keyspace = keyspace;
+
+    return self;
+}
+
+/**
+ * Sets the timeout for connecting to a node.
+ * Default is +5000+ milliseconds.
+ *
+ * @param timeout_ms [Integer] A connect timeout in milliseconds.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_connect_timeout(VALUE self, VALUE timeout_ms)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cass_cluster_set_connect_timeout(cassandra_cluster->cluster, NUM2UINT(timeout_ms));
+
+    return self;
+}
+
+/**
+ * Sets the timeout for waiting for a response from a node.
+ * Default is +12000+ milliseconds.
+ *
+ * @param timeout_ms [Integer] A request timeout in milliseconds.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_request_timeout(VALUE self, VALUE timeout_ms)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cass_cluster_set_request_timeout(cassandra_cluster->cluster, NUM2UINT(timeout_ms));
+
+    return self;
+}
+
+/**
+ * Sets the timeout for waiting for DNS name resolution.
+ * Default is +2000+ milliseconds.
+ *
+ * @param timeout_ms [Integer] A request timeout in milliseconds.
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_resolve_timeout(VALUE self, VALUE timeout_ms)
+{
+    CassandraCluster *cassandra_cluster;
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cass_cluster_set_resolve_timeout(cassandra_cluster->cluster, NUM2UINT(timeout_ms));
+
+    return self;
+}
+
+/**
+ * Enable constant speculative executions with the supplied settings.
+ *
+ * @param constant_delay_ms [Integer]
+ * @param max_speculative_executions [Integer]
+ * @return [Cassandra::Cluster] self.
+ */
+static VALUE cluster_constant_speculative_execution_policy(VALUE self, VALUE constant_delay_ms, VALUE max_speculative_executions)
+{
+    CassandraCluster *cassandra_cluster;
+
+    if (NUM2LONG(constant_delay_ms) < 0 || NUM2INT(max_speculative_executions) < 0) {
+        rb_raise(rb_eArgError, "Bad parameters.");
+    }
+
+    GET_CLUSTER(self, cassandra_cluster);
+    cass_cluster_set_constant_speculative_execution_policy(cassandra_cluster->cluster, NUM2LONG(constant_delay_ms), NUM2INT(max_speculative_executions));
+
+    return self;
+}
+
+static void cluster_mark(void *ptr)
+{
+    CassandraCluster *cassandra_cluster = (CassandraCluster *)ptr;
+    rb_gc_mark_movable(cassandra_cluster->keyspace);
+}
+
+static void cluster_destroy(void *ptr)
+{
+    CassandraCluster *cassandra_cluster = (CassandraCluster *)ptr;
+
+    if (cassandra_cluster->cluster) {
+        cass_cluster_free(cassandra_cluster->cluster);
+    }
+    xfree(cassandra_cluster);
+}
+
+static size_t cluster_memsize(const void *ptr)
+{
+    return sizeof(CassandraCluster);
+}
+
+static void cluster_compact(void *ptr)
+{
+    CassandraCluster *cassandra_cluster = (CassandraCluster *)ptr;
+
+    cassandra_cluster->keyspace = rb_gc_location(cassandra_cluster->keyspace);
+}
+
+void Init_cluster(void)
+{
+    rb_define_alloc_func(cCluster, cluster_allocator);
+    rb_define_method(cCluster, "initialize", cluster_initialize, 0);
+    rb_define_method(cCluster, "connect", cluster_connect, 0);
+    rb_define_method(cCluster, "hosts", cluster_hosts, 1);
+    rb_define_method(cCluster, "port", cluster_port, 1);
+    rb_define_method(cCluster, "keyspace", cluster_keyspace, 1);
+    rb_define_method(cCluster, "connect_timeout", cluster_connect_timeout, 1);
+    rb_define_method(cCluster, "request_timeout", cluster_request_timeout, 1);
+    rb_define_method(cCluster, "resolve_timeout", cluster_resolve_timeout, 1);
+    rb_define_method(cCluster, "constant_speculative_execution_policy", cluster_constant_speculative_execution_policy, 2);
+
+}

data/ext/ilios/extconf.rb

@@ -9,20 +9,6 @@ require 'native-package-installer'
 have_func('malloc_usable_size')
 have_func('malloc_size')
 
-unless find_executable('cmake')
-  puts '--------------------------------------------------'
-  puts 'Error: cmake is required to build this gem'
-  puts '--------------------------------------------------'
-  raise
-end
-
-if RUBY_PLATFORM.include?('darwin') && !find_executable('install_name_tool')
-  puts('------------------------------------------------------')
-  puts('Error: install_name_tool is required to build this gem')
-  puts('------------------------------------------------------')
-  raise
-end
-
 def num_cpu_cores
   cores =
     begin
@@ -156,6 +142,21 @@ if (dir = with_config('--with-cassandra-driver-dir'))
   $CPPFLAGS += " -I#{dir}/include"
   $LDFLAGS += " -L#{dir}/lib -Wl,-rpath,#{dir}/lib -lcassandra"
 else
+
+  unless find_executable('cmake')
+    puts '--------------------------------------------------'
+    puts 'Error: cmake is required to build this gem'
+    puts '--------------------------------------------------'
+    raise
+  end
+
+  if RUBY_PLATFORM.include?('darwin') && !find_executable('install_name_tool')
+    puts('------------------------------------------------------')
+    puts('Error: install_name_tool is required to build this gem')
+    puts('------------------------------------------------------')
+    raise
+  end
+
   LibuvInstaller.install
   CassandraDriverInstaller.install
 end

data/ext/ilios/ilios.c

@@ -2,6 +2,7 @@
 
 VALUE mIlios;
 VALUE mCassandra;
+VALUE cCluster;
 VALUE cSession;
 VALUE cStatement;
 VALUE cResult;
@@ -12,19 +13,11 @@ VALUE eStatementError;
 
 VALUE cQueue;
 
-VALUE id_cvar_config;
-VALUE id_shuffle;
 VALUE id_to_time;
 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>
@@ -65,8 +58,11 @@ static void ilios_free(void *ptr)
 
 void Init_ilios(void)
 {
+    rb_ext_ractor_safe(true);
+
     mIlios = rb_define_module("Ilios");
     mCassandra = rb_define_module_under(mIlios, "Cassandra");
+    cCluster = rb_define_class_under(mCassandra, "Cluster", rb_cObject);
     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);
@@ -77,21 +73,13 @@ void Init_ilios(void)
 
     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_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_cluster();
     Init_session();
     Init_statement();
     Init_result();

data/ext/ilios/ilios.h

@@ -9,10 +9,14 @@
 #include "ruby/thread.h"
 #include "ruby/encoding.h"
 
+#define DEFAULT_PAGE_SIZE 10000
+
+#define GET_CLUSTER(obj, var)   TypedData_Get_Struct(obj, CassandraCluster, &cassandra_cluster_data_type, var)
 #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_CLUSTER(var)     TypedData_Make_Struct(cCluster, CassandraCluster, &cassandra_cluster_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)
@@ -26,9 +30,13 @@ typedef enum {
 typedef struct
 {
     CassCluster* cluster;
-    CassFuture* connect_future;
+    VALUE keyspace;
+} CassandraCluster;
+typedef struct
+{
     CassSession* session;
-
+    CassFuture* connect_future;
+    VALUE cluster_obj;
 } CassandraSession;
 
 typedef struct
@@ -60,6 +68,7 @@ typedef struct
     bool already_waited;
 } CassandraFuture;
 
+extern const rb_data_type_t cassandra_cluster_data_type;
 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;
@@ -67,6 +76,7 @@ extern const rb_data_type_t cassandra_future_data_type;
 
 extern VALUE mIlios;
 extern VALUE mCassandra;
+extern VALUE cCluster;
 extern VALUE cSession;
 extern VALUE cStatement;
 extern VALUE cResult;
@@ -77,21 +87,13 @@ extern VALUE eStatementError;
 
 extern VALUE cQueue;
 
-extern VALUE id_cvar_config;
-extern VALUE id_shuffle;
 extern VALUE id_to_time;
 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_cluster(void);
 extern void Init_session(void);
 extern void Init_statement(void);
 extern void Init_result(void);

data/ext/ilios/session.c

@@ -1,15 +1,17 @@
 #include "ilios.h"
 
+static void session_mark(void *ptr);
 static void session_destroy(void *ptr);
 static size_t session_memsize(const void *ptr);
+static void session_compact(void *ptr);
 
 const rb_data_type_t cassandra_session_data_type = {
     "Ilios::Cassandra::Session",
     {
-        NULL,
+        session_mark,
         session_destroy,
         session_memsize,
-        NULL,
+        session_compact,
     },
     0, 0,
     RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
@@ -121,6 +123,12 @@ static VALUE session_execute(VALUE self, VALUE statement)
     return cassandra_result_obj;
 }
 
+static void session_mark(void *ptr)
+{
+    CassandraSession *cassandra_session = (CassandraSession *)ptr;
+    rb_gc_mark_movable(cassandra_session->cluster_obj);
+}
+
 static void session_destroy(void *ptr)
 {
     CassandraSession *cassandra_session = (CassandraSession *)ptr;
@@ -131,9 +139,6 @@ static void session_destroy(void *ptr)
     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);
 }
 
@@ -142,6 +147,13 @@ static size_t session_memsize(const void *ptr)
     return sizeof(CassandraSession);
 }
 
+static void session_compact(void *ptr)
+{
+    CassandraSession *cassandra_session = (CassandraSession *)ptr;
+
+    cassandra_session->cluster_obj = rb_gc_location(cassandra_session->cluster_obj);
+}
+
 void Init_session(void)
 {
     rb_undef_alloc_func(cSession);

data/ext/ilios/statement.c

@@ -19,10 +19,7 @@ const rb_data_type_t cassandra_statement_data_type = {
 
 void statement_default_config(CassandraStatement *cassandra_statement)
 {
-    VALUE config = rb_cvar_get(mCassandra, id_cvar_config);
-
-    cass_statement_set_request_timeout(cassandra_statement->statement, NUM2INT(rb_hash_aref(config, sym_timeout_ms)));
-    cass_statement_set_paging_size(cassandra_statement->statement, NUM2INT(rb_hash_aref(config, sym_page_size)));
+    cass_statement_set_paging_size(cassandra_statement->statement, DEFAULT_PAGE_SIZE);
 }
 
 static int hash_cb(VALUE key, VALUE value, VALUE statement)
@@ -235,7 +232,6 @@ static void statement_compact(void *ptr)
     cassandra_statement->session_obj = rb_gc_location(cassandra_statement->session_obj);
 }
 
-
 void Init_statement(void)
 {
     rb_undef_alloc_func(cStatement);

data/lib/ilios/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Ilios
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
   public_constant :VERSION
 
   CASSANDRA_CPP_DRIVER_VERSION = '2.17.1'

data/lib/ilios.rb

@@ -2,39 +2,3 @@
 
 require 'ilios.so'
 require 'ilios/version'
-
-module Ilios
-  module Cassandra
-    # The default options.
-    @@config = {
-      keyspace: 'ilios',
-      hosts: ['127.0.0.1'],
-      timeout_ms: 5_000,
-      constant_delay_ms: 15_000,
-      max_speculative_executions: 2,
-      page_size: 10_000
-    }
-
-    #
-    # Configures the option for connection or execution.
-    # The default value will be overridden by the specified option.
-    #
-    # @param config [Hash] A hash object contained the options.
-    #
-    def self.config=(config)
-      @@config = @@config.merge(config)
-    end
-
-    #
-    # Connects a session to the keyspace specified in +config+ method.
-    # The session object will be memorized by each threads.
-    #
-    # @return [Cassandra::Session] The session object.
-    # @raise [RuntimeError] If no host is specified to connect in +config+ method.
-    # @raise [Cassandra::ConnectError] If the connection fails for any reason.
-    #
-    def self.session
-      Thread.current[:ilios_cassandra_session] ||= connect
-    end
-  end
-end

data/sig/ilios.rbs

@@ -2,9 +2,16 @@ module Ilios
   VERSION: String
 
   module Cassandra
-    def self.config=: (Hash[Symbol, untyped]) -> void
-    def self.session: () -> Ilios::Cassandra::Session
-    def self.connect: () -> Ilios::Cassandra::Session
+    class Cluster
+      def connect: () -> Ilios::Cassandra::Session
+      def hosts: (Array[String]) -> self
+      def port: (Integer) -> self
+      def keyspace: (String) -> self
+      def connect_timeout: (Integer) -> self
+      def request_timeout: (Integer) -> self
+      def resolve_timeout: (Integer) -> self
+      def constant_speculative_execution_policy: (Integer, Integer) -> self
+    end
 
     class Session
       def prepare_async: (String) -> Ilios::Cassandra::Future

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ilios
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Watson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-27 00:00:00.000000000 Z
+date: 2023-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_portile2
@@ -51,7 +51,7 @@ files:
 - README.md
 - Rakefile
 - docker-compose.yml
-- ext/ilios/cassandra.c
+- ext/ilios/cluster.c
 - ext/ilios/extconf.rb
 - ext/ilios/future.c
 - ext/ilios/ilios.c
@@ -71,7 +71,7 @@ metadata:
   homepage_uri: https://github.com/Watson1978/ilios
   source_code_uri: https://github.com/Watson1978/ilios
   bug_tracker_uri: https://github.com/Watson1978/ilios/issues
-  documentation_uri: https://www.rubydoc.info/gems/ilios/0.3.1
+  documentation_uri: https://www.rubydoc.info/gems/ilios/0.4.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []

data/ext/ilios/cassandra.c

@@ -1,64 +0,0 @@
-#include "ilios.h"
-
-/**
- * Connects a session to the keyspace specified in +config+ method.
- *
- * @return [Cassandra::Session] A new session object.
- * @raise [RuntimeError] If no host is specified to connect in +config+ method.
- * @raise [Cassandra::ConnectError] If the connection fails for any reason.
- */
-static VALUE cassandra_connect(VALUE self)
-{
-    CassandraSession *cassandra_session;
-    VALUE cassandra_session_obj;
-    VALUE config;
-    VALUE hosts;
-    VALUE keyspace;
-
-    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, 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) {
-        char error[4096] = { 0 };
-
-        strncpy(error, cass_error_desc(cass_future_error_code(cassandra_session->connect_future)), sizeof(error) - 1);
-        cass_future_free(cassandra_session->connect_future);
-        cass_session_free(cassandra_session->session);
-        cass_cluster_free(cassandra_session->cluster);
-        rb_raise(eConnectError, "Unable to connect: %s", error);
-        return Qnil;
-    }
-
-    return cassandra_session_obj;
-}
-
-void Init_cassandra(void)
-{
-    rb_define_module_function(mCassandra, "connect", cassandra_connect, 0);
-}