ilios 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c20c800bf59b7673cdb60ce4dd5086412e3461f4fa75f8f729eef7b2bba3ade
-  data.tar.gz: 1edb52689033a9047388c4be27f81ac3c1078fefcd845bc6f03c8d0080983670
+  metadata.gz: dc846b97514ac6b86eccf9a06eee87d35396f26746974e6927d7d99f0bcf33ed
+  data.tar.gz: cd91086e384b4af2fc3a39cb0c5234722947dbb8dc097782a4508df9bf73615f
 SHA512:
-  metadata.gz: 0724d14f13175a62b25aeda0926ea4f9bb6593f64c75cf871bf55426594ec2cf1b4d76fcd61a86a85c686cec49902e37b0f9302bce9933467c688d55dad9c78d
-  data.tar.gz: 7c3cd165e571bbdccbf627a2bb50aadfa84a02188fed7ede80a6bb41d7bfb7b75d43c0b31ab92dcf9de882d3dbfd7a5170663708e72023c9c640da9b3bedf14d
+  metadata.gz: bf94440639db92113db0a8c06a05f2409139644268988aa7c2c94f202bab494d035fd6107596010f07222feecbe92cad8c3f14ed169061d16d91fe69db8f05f9
+  data.tar.gz: 2b514895a3a71380e5fab10198a92e1dc1a9cdea7d84d10dad344658f14efbc7884c8fa49e3c80bcd9a8cb7942f0cb1d846a7e92cfca9ae02ff8b785989c6db5

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 1.2.0
+
+- Fix cluster setters silently ignoring invalid values in `Cluster#port`, `#protocol_version`, `#connect_timeout`, `#request_timeout` and `#resolve_timeout` (#36)
+- Fix segfault when a `Cluster` created by `allocate` or `dup` is used without running `initialize` (#37)
+- Yield the failure reason as an `Ilios::Cassandra::ExecutionError` to `Future#on_failure` blocks that accept an argument, including variadic blocks (e.g. `{ |*args| }`); zero-arity blocks are unchanged (#40)
+- The synchronous API (`Session#prepare`, `Session#execute`, `Result#next_page`, `Cluster#connect`) now raises errors carrying the server-reported message and a `#code` Integer, same as `Future#on_failure` (#40)
+- `Ilios::Cassandra::StatementError` also carries a `#code` Integer, so `#code` is answered by every error class the driver raises (#40)
+- Fix `Future#on_success` RBS signature to allow the `Statement` yielded by `prepare_async` (#42)
+
 ## 1.1.2
 
 - Support username/password authentication with `Cluster#credentials` (#33)

data/README.md

@@ -226,8 +226,12 @@ prepare_future.on_success { |statement|
       p result
       p "success"
     }
-    result_future.on_failure {
-      p "fail"
+    # `error` is an `Ilios::Cassandra::ExecutionError` (a StandardError with
+    # a #code Integer attribute); the block is optional-arity, so `{ p "fail" }`
+    # still works without it.
+    result_future.on_failure { |error|
+      p error.message
+      p error.code
     }
 
     futures << result_future

data/ext/ilios/cluster.c

@@ -23,6 +23,36 @@ static VALUE cluster_allocator(VALUE klass)
     return CREATE_CLUSTER(cassandra_cluster);
 }
 
+static void cluster_check_error(CassError error, const char *name)
+{
+    if (error != CASS_OK) {
+        rb_raise(rb_eArgError, "Invalid %s: %s", name, cass_error_desc(error));
+    }
+}
+
+// Casting a negative value to unsigned wraps it into a huge number, so check
+// the range on the signed value NUM2LONG/NUM2LL already produced. Converting a
+// second time would run to_int again, which may return a different value.
+static unsigned cluster_value_to_uint(VALUE value, const char *name)
+{
+    long v = NUM2LONG(value);
+
+    if (v < 0 || v > UINT_MAX) {
+        rb_raise(rb_eRangeError, "Invalid %s: %ld", name, v);
+    }
+    return (unsigned)v;
+}
+
+static cass_uint64_t cluster_value_to_uint64(VALUE value, const char *name)
+{
+    long long v = NUM2LL(value);
+
+    if (v < 0) {
+        rb_raise(rb_eRangeError, "Invalid %s: %lld", name, v);
+    }
+    return (cass_uint64_t)v;
+}
+
 /**
  * Creates a new cluster.
  *
@@ -32,7 +62,7 @@ static VALUE cluster_initialize(VALUE self)
 {
     CassandraCluster *cassandra_cluster;
 
-    GET_CLUSTER(self, cassandra_cluster);
+    GET_UNINITIALIZED_CLUSTER(self, cassandra_cluster);
     cassandra_cluster->cluster = cass_cluster_new();
 
     return self;
@@ -65,12 +95,10 @@ static VALUE cluster_connect(VALUE self)
     nogvl_future_wait(connect_future);
 
     if (cass_future_error_code(connect_future) != CASS_OK) {
-        char error[4096] = { 0 };
+        VALUE error = ilios_future_error_new(eConnectError, "Unable to connect", connect_future);
 
-        strncpy(error, cass_error_desc(cass_future_error_code(connect_future)), sizeof(error) - 1);
         cass_future_free(connect_future);
-        rb_raise(eConnectError, "Unable to connect: %s", error);
-        return Qnil;
+        rb_exc_raise(error);
     }
     cass_future_free(connect_future);
 
@@ -110,13 +138,14 @@ static VALUE cluster_hosts(VALUE self, VALUE hosts)
  *
  * @param port [Integer] A port number.
  * @return [Cassandra::Cluster] self.
+ * @raise [ArgumentError] If the port is zero or negative.
  */
 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));
+    cluster_check_error(cass_cluster_set_port(cassandra_cluster->cluster, NUM2INT(port)), "port");
 
     return self;
 }
@@ -141,17 +170,30 @@ static VALUE cluster_keyspace(VALUE self, VALUE keyspace)
 
 /**
  * Sets the protocol version. The driver will automatically downgrade to the lowest supported protocol version.
- * Default is +PROTOCOL_VERSION_V4+.
+ * Default is +PROTOCOL_VERSION_V4+, or +PROTOCOL_VERSION_DSEV1+ against DSE.
+ *
+ * The driver accepts +PROTOCOL_VERSION_V3+, +PROTOCOL_VERSION_V4+,
+ * +PROTOCOL_VERSION_DSEV1+ and +PROTOCOL_VERSION_DSEV2+ only. It ignores
+ * +PROTOCOL_VERSION_V1+ and +PROTOCOL_VERSION_V2+, which are below the lowest
+ * version it supports, and +PROTOCOL_VERSION_V5+, which is a beta version it
+ * enables through a separate setting instead. Each of those leaves the version
+ * unchanged and is reported on the driver's error log.
  *
  * @param version [Integer] A protocol version.
  * @return [Cassandra::Cluster] self.
+ * @raise [RangeError] If a negative value was given.
  */
 static VALUE cluster_protocol_version(VALUE self, VALUE version)
 {
     CassandraCluster *cassandra_cluster;
+    int v = NUM2INT(version);
+
+    if (v < 0) {
+        rb_raise(rb_eRangeError, "Invalid protocol_version: %d", v);
+    }
 
     GET_CLUSTER(self, cassandra_cluster);
-    cass_cluster_set_protocol_version(cassandra_cluster->cluster, NUM2INT(version));
+    cass_cluster_set_protocol_version(cassandra_cluster->cluster, v);
 
     return self;
 }
@@ -162,13 +204,14 @@ static VALUE cluster_protocol_version(VALUE self, VALUE version)
  *
  * @param timeout_ms [Integer] A connect timeout in milliseconds.
  * @return [Cassandra::Cluster] self.
+ * @raise [RangeError] If a negative value was given.
  */
 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));
+    cass_cluster_set_connect_timeout(cassandra_cluster->cluster, cluster_value_to_uint(timeout_ms, "connect_timeout"));
 
     return self;
 }
@@ -179,13 +222,14 @@ static VALUE cluster_connect_timeout(VALUE self, VALUE timeout_ms)
  *
  * @param timeout_ms [Integer] A request timeout in milliseconds.
  * @return [Cassandra::Cluster] self.
+ * @raise [RangeError] If a negative value was given.
  */
 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));
+    cass_cluster_set_request_timeout(cassandra_cluster->cluster, cluster_value_to_uint(timeout_ms, "request_timeout"));
 
     return self;
 }
@@ -196,13 +240,14 @@ static VALUE cluster_request_timeout(VALUE self, VALUE timeout_ms)
  *
  * @param timeout_ms [Integer] A request timeout in milliseconds.
  * @return [Cassandra::Cluster] self.
+ * @raise [RangeError] If a negative value was given.
  */
 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));
+    cass_cluster_set_resolve_timeout(cassandra_cluster->cluster, cluster_value_to_uint(timeout_ms, "resolve_timeout"));
 
     return self;
 }
@@ -217,13 +262,15 @@ static VALUE cluster_resolve_timeout(VALUE self, VALUE timeout_ms)
 static VALUE cluster_constant_speculative_execution_policy(VALUE self, VALUE constant_delay_ms, VALUE max_speculative_executions)
 {
     CassandraCluster *cassandra_cluster;
+    long delay = NUM2LONG(constant_delay_ms);
+    int max_executions = NUM2INT(max_speculative_executions);
 
-    if (NUM2LONG(constant_delay_ms) < 0 || NUM2INT(max_speculative_executions) < 0) {
+    if (delay < 0 || max_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));
+    cluster_check_error(cass_cluster_set_constant_speculative_execution_policy(cassandra_cluster->cluster, delay, max_executions), "constant_speculative_execution_policy");
 
     return self;
 }
@@ -248,39 +295,10 @@ static VALUE cluster_credentials(VALUE self, VALUE username, VALUE password)
     return self;
 }
 
-static void cluster_check_error(CassError error, const char *name)
-{
-    if (error != CASS_OK) {
-        rb_raise(rb_eArgError, "Invalid %s: %s", name, cass_error_desc(error));
-    }
-}
-
-// Casting a negative value to unsigned wraps it into a huge number, so check
-// the range on the signed value NUM2LONG/NUM2LL already produced. Converting a
-// second time would run to_int again, which may return a different value.
-static unsigned cluster_value_to_uint(VALUE value, const char *name)
-{
-    long v = NUM2LONG(value);
-
-    if (v < 0 || v > UINT_MAX) {
-        rb_raise(rb_eRangeError, "Invalid %s: %ld", name, v);
-    }
-    return (unsigned)v;
-}
-
-static cass_uint64_t cluster_value_to_uint64(VALUE value, const char *name)
-{
-    long long v = NUM2LL(value);
-
-    if (v < 0) {
-        rb_raise(rb_eRangeError, "Invalid %s: %lld", name, v);
-    }
-    return (cass_uint64_t)v;
-}
-
-// The driver only rejects CASS_CONSISTENCY_UNKNOWN at set time; any other
-// out-of-range value is accepted and later fails every query with an
-// opaque protocol error, so validate the range here.
+// The driver only rejects CASS_CONSISTENCY_UNKNOWN (0xFFFF) at set time; any
+// other out-of-range value is accepted and later fails every query with an
+// opaque protocol error, so validate the range here. This also keeps UNKNOWN
+// away from the driver, which is why the setters ignore its return value.
 static void cluster_check_consistency(long value, const char *name)
 {
     if (value < CASS_CONSISTENCY_ANY || value > CASS_CONSISTENCY_LOCAL_ONE) {
@@ -347,7 +365,7 @@ static VALUE cluster_consistency(VALUE self, VALUE consistency)
     CassConsistency consistency_value = cluster_value_to_consistency(consistency, "consistency");
 
     GET_CLUSTER(self, cassandra_cluster);
-    cluster_check_error(cass_cluster_set_consistency(cassandra_cluster->cluster, consistency_value), "consistency");
+    cass_cluster_set_consistency(cassandra_cluster->cluster, consistency_value);
 
     return self;
 }
@@ -378,7 +396,7 @@ static VALUE cluster_serial_consistency(VALUE self, VALUE consistency)
     }
 
     GET_CLUSTER(self, cassandra_cluster);
-    cluster_check_error(cass_cluster_set_serial_consistency(cassandra_cluster->cluster, consistency_value), "serial_consistency");
+    cass_cluster_set_serial_consistency(cassandra_cluster->cluster, consistency_value);
 
     return self;
 }

data/ext/ilios/future.c

@@ -136,7 +136,13 @@ static void future_result_success_yield(CassandraFuture *cassandra_future)
 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);
+        if (rb_proc_arity(cassandra_future->on_failure_block)) {
+            VALUE error = ilios_future_error_new(eExecutionError, NULL, cassandra_future->future);
+
+            rb_proc_call_with_block(cassandra_future->on_failure_block, 1, &error, Qnil);
+        } else {
+            rb_proc_call_with_block(cassandra_future->on_failure_block, 0, NULL, Qnil);
+        }
     }
 }
 
@@ -317,6 +323,9 @@ static VALUE future_on_failure_synchronize(VALUE future)
 /**
  * Run block when future resolves to error.
  *
+ * @yieldparam error [Cassandra::ExecutionError] The failure reason. Only
+ *   yielded when the block accepts an argument; a zero-arity block is still
+ *   called with no arguments.
  * @return [Cassandra::Future] self.
  * @raise [Cassandra::ExecutionError] If this method will be called twice.
  * @raise [ArgumentError] If no block was given.

data/ext/ilios/ilios.c

@@ -1,5 +1,7 @@
 #include "ilios.h"
 
+#include <string.h>
+
 VALUE mIlios;
 VALUE mCassandra;
 VALUE cCluster;
@@ -21,6 +23,7 @@ VALUE id_push;
 VALUE id_pop;
 VALUE id_alive;
 VALUE id_report_on_exception;
+VALUE id_code;
 VALUE sym_unsupported_column_type;
 
 #if defined(HAVE_MALLOC_USABLE_SIZE)
@@ -74,6 +77,45 @@ static VALUE cassandra_set_log_level(VALUE self, VALUE log_level)
     return self;
 }
 
+VALUE ilios_error_new(VALUE exception_class, VALUE message, CassError error_code)
+{
+    VALUE error = rb_exc_new_str(exception_class, message);
+
+    rb_ivar_set(error, id_code, INT2NUM(error_code));
+
+    return error;
+}
+
+VALUE ilios_future_error_new(VALUE exception_class, const char *prefix, CassFuture *future)
+{
+    CassError error_code;
+    const char *message;
+    size_t message_length;
+    VALUE body;
+    VALUE full_message;
+
+    error_code = cass_future_error_code(future);
+    cass_future_error_message(future, &message, &message_length);
+    if (message_length == 0) {
+        message = cass_error_desc(error_code);
+        message_length = strlen(message);
+    }
+
+    // The driver hands back the server's raw bytes, which rb_str_new would
+    // tag ASCII-8BIT; CQL identifiers and literals are UTF-8, so tag it
+    // UTF-8 and keep the prefixed message in that encoding too. The message
+    // can also carry driver-local text (strerror output, host names), which
+    // is not guaranteed UTF-8, so replace invalid bytes rather than handing
+    // back a string that raises ArgumentError on the first regexp match.
+    body = rb_utf8_str_new(message, message_length);
+    if (rb_enc_str_coderange(body) == ENC_CODERANGE_BROKEN) {
+        body = rb_str_scrub(body, Qnil);
+    }
+    full_message = prefix ? rb_enc_sprintf(rb_utf8_encoding(), "%s: %"PRIsVALUE, prefix, body) : body;
+
+    return ilios_error_new(exception_class, full_message, error_code);
+}
+
 void Init_ilios(void)
 {
     rb_ext_ractor_safe(true);
@@ -88,6 +130,11 @@ void Init_ilios(void)
     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);
+    // @code is only set on errors built by ilios_error_new; the ones raised
+    // elsewhere via plain rb_raise leave #code nil.
+    rb_define_attr(eExecutionError, "code", 1, 0);
+    rb_define_attr(eConnectError, "code", 1, 0);
+    rb_define_attr(eStatementError, "code", 1, 0);
 
     cSizedQueue = rb_const_get(rb_cThread, rb_intern("SizedQueue"));
     rb_require("set");
@@ -101,6 +148,7 @@ void Init_ilios(void)
     id_pop = rb_intern("pop");
     id_alive = rb_intern("alive?");
     id_report_on_exception = rb_intern("report_on_exception=");
+    id_code = rb_intern("@code");
     sym_unsupported_column_type = ID2SYM(rb_intern("unsupported_column_type"));
 
     rb_define_module_function(mCassandra, "log_level", cassandra_set_log_level, 1);

data/ext/ilios/ilios.h

@@ -11,7 +11,16 @@
 
 #define DEFAULT_PAGE_SIZE 10000
 
-#define GET_CLUSTER(obj, var)   TypedData_Get_Struct(obj, CassandraCluster, &cassandra_cluster_data_type, var)
+// Cluster exposes an allocator, so allocate and dup both produce an instance
+// that never ran initialize. Reject it here instead of handing NULL to the
+// driver, which segfaults.
+#define GET_CLUSTER(obj, var)   do { \
+    GET_UNINITIALIZED_CLUSTER(obj, var); \
+    if ((var)->cluster == NULL) { \
+        rb_raise(rb_eRuntimeError, "uninitialized Ilios::Cassandra::Cluster"); \
+    } \
+} while (0)
+#define GET_UNINITIALIZED_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)
@@ -118,6 +127,7 @@ extern VALUE id_push;
 extern VALUE id_pop;
 extern VALUE id_alive;
 extern VALUE id_report_on_exception;
+extern VALUE id_code;
 extern VALUE sym_unsupported_column_type;
 
 extern void Init_cluster(void);
@@ -136,5 +146,17 @@ extern void statement_default_config(CassandraStatement *cassandra_statement);
 extern CassStatement *statement_build_for_execution(CassandraStatement *cassandra_statement);
 extern void result_await(CassandraResult *cassandra_result);
 
+// Builds an exception of `exception_class` carrying `message` and `@code`
+// (readable via #code) set to the CassError value.
+extern VALUE ilios_error_new(VALUE exception_class, VALUE message, CassError error_code);
+
+// Builds an exception of `exception_class` from `future`'s error: the
+// driver's server-reported message (falling back to the generic
+// cass_error_desc when the driver returns none), formatted as
+// "<prefix>: <message>" when `prefix` is non-NULL, or the bare message when
+// `prefix` is NULL. `future` must still be alive (not yet cass_future_free'd)
+// when this is called.
+extern VALUE ilios_future_error_new(VALUE exception_class, const char *prefix, CassFuture *future);
+
 
 #endif // ILIOS_H

data/ext/ilios/result.c

@@ -22,10 +22,9 @@ 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 };
+        VALUE error = ilios_future_error_new(eExecutionError, "Unable to wait executing", cassandra_result->future);
 
-        strncpy(error, cass_error_desc(cass_future_error_code(cassandra_result->future)), sizeof(error) - 1);
-        rb_raise(eExecutionError, "Unable to wait executing: %s", error);
+        rb_exc_raise(error);
     }
 
     if (cassandra_result->result == NULL) {
@@ -66,8 +65,10 @@ static VALUE result_next_page(VALUE self)
 
     error_code = cass_future_error_code(result_future);
     if (error_code != CASS_OK) {
+        VALUE error = ilios_future_error_new(eExecutionError, "Unable to wait executing", result_future);
+
         cass_future_free(result_future);
-        rb_raise(eExecutionError, "Unable to wait executing: %s", cass_error_desc(error_code));
+        rb_exc_raise(error);
     }
 
     cass_result_free(cassandra_result->result);
@@ -80,10 +81,20 @@ static VALUE result_next_page(VALUE self)
     return self;
 }
 
+// No CassFuture is involved here: this fires while decoding an already
+// fetched row's column value.
+static VALUE result_check_value_error_new(CassError error_code, VALUE key)
+{
+    VALUE message = rb_enc_sprintf(rb_utf8_encoding(), "Unable to get value of %"PRIsVALUE" column: %s",
+                                   key, cass_error_desc(error_code));
+
+    return ilios_error_new(eExecutionError, message, error_code);
+}
+
 static void result_check_value(CassError error_code, VALUE key)
 {
     if (error_code != CASS_OK) {
-        rb_raise(eExecutionError, "Unable to get value of %"PRIsVALUE" column: %s", key, cass_error_desc(error_code));
+        rb_exc_raise(result_check_value_error_new(error_code, key));
     }
 }
 

data/ext/ilios/session.c

@@ -56,11 +56,10 @@ static VALUE session_prepare(VALUE self, VALUE query)
     nogvl_future_wait(prepare_future);
 
     if (cass_future_error_code(prepare_future) != CASS_OK) {
-        char error[4096] = { 0 };
+        VALUE error = ilios_future_error_new(eExecutionError, "Unable to prepare query", prepare_future);
 
-        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);
+        rb_exc_raise(error);
     }
 
     cassandra_statement_obj = CREATE_STATEMENT(cassandra_statement);

data/ext/ilios/statement.c

@@ -141,7 +141,10 @@ static void statement_bind_collection(statement_bind_target *target, const CassD
 static void statement_bind_check(CassError result, VALUE key)
 {
     if (result != CASS_OK) {
-        rb_raise(eStatementError, "Failed to bind value of %"PRIsVALUE" column: %s", key, cass_error_desc(result));
+        VALUE message = rb_enc_sprintf(rb_utf8_encoding(), "Failed to bind value of %"PRIsVALUE" column: %s",
+                                       key, cass_error_desc(result));
+
+        rb_exc_raise(ilios_error_new(eStatementError, message, result));
     }
 }
 

data/lib/ilios/version.rb

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

data/sig/ilios.rbs

@@ -75,9 +75,21 @@ module Ilios
       def idempotent=: (bool) -> self
     end
 
+    class ExecutionError < StandardError
+      def code: () -> Integer?
+    end
+
+    class ConnectError < StandardError
+      def code: () -> Integer?
+    end
+
+    class StatementError < StandardError
+      def code: () -> Integer?
+    end
+
     class Future
-      def on_success: () { (Ilios::Cassandra::Result) -> void } -> self
-      def on_failure: () { () -> void } -> self
+      def on_success: () { (Ilios::Cassandra::Result | Ilios::Cassandra::Statement) -> void } -> self
+      def on_failure: () { (Ilios::Cassandra::ExecutionError) -> void } -> self
       def await: () -> self
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ilios
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Watson
@@ -58,7 +58,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/1.1.2
+  documentation_uri: https://www.rubydoc.info/gems/ilios/1.2.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: