trilogy 2.5.0 → 2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0730bbbdae7e8eab195c4ad745e223bcd55fe6299f98cb324c88beea15ebdc5e
-  data.tar.gz: 7779f268cbfae85bf5575f680ebff9fee6d22b78bb5d3d315ba664969ab9618a
+  metadata.gz: d015527cefe1e66b73b4db1d31b98e3db6ab616edb1fb2da947054a55818f338
+  data.tar.gz: 315bdd0e7dabf0f37ed69f5cd0884a702a7502443b1e26e5b01bec90b122e11d
 SHA512:
-  metadata.gz: 42c81e496210cfc0538ef1dd9f4f7c34e2ce94de45e5bcfe4c5815839c463a6b3ae78af529b88c63a670b3cd2035a6b931ef76fdfe1ec508f6b7851858b664d2
-  data.tar.gz: ad05962a8a47cea68ab66188badf405fe96342587bd86d91faf43dd028dc641949ea58d9a6d25547e820c4700c6cd9548d70a2494f0a215b08bb8a61c9c920c8
+  metadata.gz: b6e50321b8493b6ea8137d534e0fa8eedc5b7388093fee5e910dbe8c6bd81c0e0dc9c8d9c448895096fb8bd0244a0ee65b19b5f580c3b9137c76c9af221f0ab2
+  data.tar.gz: 7d8b81caf8faaadc4ef548ffddab7a73f9b8d4d6ede5a0f9078c6ea65cd195f83bdcacdf5a3d7b71d76503161a689d8ac66b058a4c605a915f9a9dcf4aa56cdd

data/README.md

@@ -27,7 +27,6 @@ $ gem install trilogy
 ``` ruby
 client = Trilogy.new(host: "127.0.0.1", port: 3306, username: "root", read_timeout: 2)
 if client.ping
-  client.query_options[:database_timezone] = :utc
   client.change_db "mydb"
 
   result = client.query("SELECT id, created_at FROM users LIMIT 10")
@@ -63,7 +62,7 @@ bundle exec rake build
 
 The official Ruby bindings are inside of the canonical trilogy repository itself.
 
-1. Fork it ( https://github.com/github/trilogy/fork )
+1. Fork it ( https://github.com/trilogy-libraries/trilogy/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/ext/trilogy-ruby/cext.c

@@ -18,7 +18,7 @@
 VALUE Trilogy_CastError;
 static VALUE Trilogy_BaseConnectionError, Trilogy_ProtocolError, Trilogy_SSLError, Trilogy_QueryError,
     Trilogy_ConnectionClosedError, Trilogy_ConnectionRefusedError, Trilogy_ConnectionResetError,
-    Trilogy_TimeoutError, Trilogy_SyscallError, Trilogy_Result;
+    Trilogy_TimeoutError, Trilogy_SyscallError, Trilogy_Result, Trilogy_EOFError;
 
 static ID id_socket, id_host, id_port, id_username, id_password, id_found_rows, id_connect_timeout, id_read_timeout,
     id_write_timeout, id_keepalive_enabled, id_keepalive_idle, id_keepalive_interval, id_keepalive_count,
@@ -43,9 +43,7 @@ static void mark_trilogy(void *ptr)
 static void free_trilogy(void *ptr)
 {
     struct trilogy_ctx *ctx = ptr;
-    if (ctx->conn.socket != NULL) {
-        trilogy_free(&ctx->conn);
-    }
+    trilogy_free(&ctx->conn);
     xfree(ptr);
 }
 
@@ -96,7 +94,7 @@ static void trilogy_syserr_fail_str(int e, VALUE msg)
         rb_raise(Trilogy_ConnectionResetError, "%" PRIsVALUE, msg);
     } else if (e == EPIPE) {
         // Backwards compatibility: This error class makes no sense, but matches legacy behavior
-        rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION", msg);
+        rb_raise(Trilogy_EOFError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION: EPIPE", msg);
     } else {
         VALUE exc = rb_funcall(Trilogy_SyscallError, id_from_errno, 2, INT2NUM(e), msg);
         rb_exc_raise(exc);
@@ -158,6 +156,10 @@ static void handle_trilogy_error(struct trilogy_ctx *ctx, int rc, const char *ms
         rb_raise(Trilogy_BaseConnectionError, "%" PRIsVALUE ": TRILOGY_DNS_ERROR", rbmsg);
     }
 
+    case TRILOGY_CLOSED_CONNECTION: {
+        rb_raise(Trilogy_EOFError, "%" PRIsVALUE ": TRILOGY_CLOSED_CONNECTION", rbmsg);
+    }
+
     default:
         rb_raise(Trilogy_QueryError, "%" PRIsVALUE ": %s", rbmsg, trilogy_error(rc));
     }
@@ -305,6 +307,7 @@ static int try_connect(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake,
     int rc = args.rc;
 
     if (rc != TRILOGY_OK) {
+        trilogy_sock_close(sock);
         return rc;
     }
 
@@ -312,8 +315,10 @@ static int try_connect(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake,
 escape the GVL on each wait operation without going through call_without_gvl */
     sock->wait_cb = _cb_ruby_wait;
     rc = trilogy_connect_send_socket(&ctx->conn, sock);
-    if (rc < 0)
+    if (rc < 0) {
+        trilogy_sock_close(sock);
         return rc;
+    }
 
     while (1) {
         rc = trilogy_connect_recv(&ctx->conn, handshake);
@@ -421,7 +426,7 @@ static void authenticate(struct trilogy_ctx *ctx, trilogy_handshake_t *handshake
     }
 }
 
-static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VALUE opts)
+static VALUE rb_trilogy_connect(VALUE self, VALUE encoding, VALUE charset, VALUE opts)
 {
     struct trilogy_ctx *ctx = get_ctx(self);
     trilogy_sockopt_t connopt = {0};
@@ -432,7 +437,6 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VA
     connopt.encoding = NUM2INT(charset);
 
     Check_Type(opts, T_HASH);
-    rb_ivar_set(self, id_connection_options, opts);
 
     if ((val = rb_hash_lookup(opts, ID2SYM(id_ssl_mode))) != Qnil) {
         Check_Type(val, T_FIXNUM);
@@ -574,9 +578,6 @@ static VALUE rb_trilogy_initialize(VALUE self, VALUE encoding, VALUE charset, VA
     }
 
     int rc = try_connect(ctx, &handshake, &connopt);
-    if (rc == TRILOGY_TIMEOUT) {
-        rb_raise(Trilogy_TimeoutError, "trilogy_connect_recv");
-    }
     if (rc != TRILOGY_OK) {
         if (connopt.path) {
             handle_trilogy_error(ctx, rc, "trilogy_connect - unable to connect to %s", connopt.path);
@@ -1100,7 +1101,7 @@ RUBY_FUNC_EXPORTED void Init_cext()
     VALUE Trilogy = rb_const_get(rb_cObject, rb_intern("Trilogy"));
     rb_define_alloc_func(Trilogy, allocate_trilogy);
 
-    rb_define_private_method(Trilogy, "_initialize", rb_trilogy_initialize, 3);
+    rb_define_private_method(Trilogy, "_connect", rb_trilogy_connect, 3);
     rb_define_method(Trilogy, "change_db", rb_trilogy_change_db, 1);
     rb_define_alias(Trilogy, "select_db", "change_db");
     rb_define_method(Trilogy, "query", rb_trilogy_query, 1);
@@ -1176,6 +1177,9 @@ RUBY_FUNC_EXPORTED void Init_cext()
     Trilogy_CastError = rb_const_get(Trilogy, rb_intern("CastError"));
     rb_global_variable(&Trilogy_CastError);
 
+    Trilogy_EOFError = rb_const_get(Trilogy, rb_intern("EOFError"));
+    rb_global_variable(&Trilogy_EOFError);
+
     id_socket = rb_intern("socket");
     id_host = rb_intern("host");
     id_port = rb_intern("port");

data/ext/trilogy-ruby/extconf.rb

@@ -2,8 +2,12 @@ require "mkmf"
 
 # concatenate trilogy library sources to allow the compiler to optimise across
 # source files
+
+trilogy_src_dir = File.realpath("src", __dir__)
 File.binwrite("trilogy.c",
-  Dir["#{__dir__}/src/**/*.c"].map { |src| File.binread(src) }.join)
+  Dir["#{trilogy_src_dir}/**/*.c"].map { |src|
+    %{#line 1 "#{src}"\n} + File.binread(src)
+  }.join)
 
 $objs = %w[trilogy.o cast.o cext.o]
 $CFLAGS << " -I #{__dir__}/inc -std=gnu99 -fvisibility=hidden"

data/ext/trilogy-ruby/src/buffer.c

@@ -57,4 +57,9 @@ int trilogy_buffer_putc(trilogy_buffer_t *buffer, uint8_t c)
     return TRILOGY_OK;
 }
 
-void trilogy_buffer_free(trilogy_buffer_t *buffer) { free(buffer->buff); }
+void trilogy_buffer_free(trilogy_buffer_t *buffer)
+{
+    free(buffer->buff);
+    buffer->buff = NULL;
+    buffer->len = buffer->cap = 0;
+}

data/ext/trilogy-ruby/src/socket.c

@@ -100,8 +100,15 @@ static int _cb_raw_close(trilogy_sock_t *_sock)
     if (sock->fd != -1) {
         rc = close(sock->fd);
     }
+
     if (sock->addr) {
-        freeaddrinfo(sock->addr);
+        if (sock->base.opts.hostname == NULL && sock->base.opts.path != NULL) {
+            /* We created these with calloc so must free them instead of calling freeaddrinfo */
+            free(sock->addr->ai_addr);
+            free(sock->addr);
+        } else {
+            freeaddrinfo(sock->addr);
+        }
     }
 
     free(sock->base.opts.hostname);
@@ -189,12 +196,21 @@ static int raw_connect_internal(struct trilogy_sock *sock, const struct addrinfo
 {
     int sockerr;
     socklen_t sockerr_len = sizeof(sockerr);
+    int rc = TRILOGY_SYSERR;
 
     sock->fd = socket(ai->ai_family, SOCK_STREAM, ai->ai_protocol);
     if (sock->fd < 0) {
         return TRILOGY_SYSERR;
     }
 
+#ifdef TCP_NODELAY
+    if (sock->addr->ai_family != PF_UNIX) {
+        int flags = 1;
+        if (setsockopt(sock->fd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags)) < 0) {
+            goto fail;
+        }
+    }
+#endif
     if (sock->base.opts.keepalive_enabled) {
         int flags = 1;
         if (setsockopt(sock->fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags)) < 0) {
@@ -236,8 +252,8 @@ static int raw_connect_internal(struct trilogy_sock *sock, const struct addrinfo
         }
     }
 
-    if (trilogy_sock_wait_write((trilogy_sock_t *)sock) < 0) {
-        goto fail;
+    if ((rc = trilogy_sock_wait_write((trilogy_sock_t *)sock)) < 0) {
+        goto failrc;
     }
 
     if (getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &sockerr, &sockerr_len) < 0) {
@@ -255,9 +271,11 @@ static int raw_connect_internal(struct trilogy_sock *sock, const struct addrinfo
     return TRILOGY_OK;
 
 fail:
+    rc = TRILOGY_SYSERR;
+failrc:
     close(sock->fd);
     sock->fd = -1;
-    return TRILOGY_SYSERR;
+    return rc;
 }
 
 static int _cb_raw_connect(trilogy_sock_t *_sock)
@@ -369,6 +387,9 @@ static ssize_t ssl_io_return(struct trilogy_sock *sock, ssize_t ret)
         int rc = SSL_get_error(sock->ssl, (int)ret);
         if (rc == SSL_ERROR_WANT_WRITE || rc == SSL_ERROR_WANT_READ) {
             return (ssize_t)TRILOGY_AGAIN;
+        } else if (rc == SSL_ERROR_ZERO_RETURN) {
+            // Server has closed the connection for writing by sending the close_notify alert
+            return (ssize_t)TRILOGY_CLOSED_CONNECTION;
         } else if (rc == SSL_ERROR_SYSCALL && !ERR_peek_error()) {
             if (errno == 0) {
                 // On OpenSSL <= 1.1.1, SSL_ERROR_SYSCALL with an errno value

data/lib/trilogy/error.rb

@@ -20,7 +20,7 @@ class Trilogy
       .select { |c| c.is_a?(Class) && c < SystemCallError }
       .each do |c|
         errno_name = c.to_s.split('::').last
-        ERRORS[c::Errno] = const_set(errno_name, Class.new(c) { include Trilogy::Error })
+        ERRORS[c::Errno] = const_set(errno_name, Class.new(c) { include Trilogy::ConnectionError })
       end
 
     ERRORS.freeze
@@ -112,7 +112,13 @@ class Trilogy
     include ConnectionError
   end
 
+  # Raised on attempt to use connection which was explicitly closed by the user
   class ConnectionClosed < IOError
     include ConnectionError
   end
+
+  # Occurs when a socket read or write returns EOF or when an operation is
+  # attempted on a socket which previously encountered an error.
+  class EOFError < BaseConnectionError
+  end
 end

data/lib/trilogy/version.rb

@@ -1,3 +1,3 @@
 class Trilogy
-  VERSION = "2.5.0"
+  VERSION = "2.6.1"
 end

data/lib/trilogy.rb

@@ -8,12 +8,14 @@ require "trilogy/encoding"
 
 class Trilogy
   def initialize(options = {})
-    options[:port] = options[:port].to_i if options.key?(:port)
+    options[:port] = options[:port].to_i if options[:port]
     mysql_encoding = options[:encoding] || "utf8mb4"
     encoding = Trilogy::Encoding.find(mysql_encoding)
     charset = Trilogy::Encoding.charset(mysql_encoding)
+    @connection_options = options
+    @connected_host = nil
 
-    _initialize(encoding, charset, options)
+    _connect(encoding, charset, options)
   end
 
   def connection_options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trilogy
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.1
 platform: ruby
 authors:
 - GitHub Engineering
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2024-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy