neo4j-ruby-driver 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f25d2880441e748a0152d2f23afa956891bde3fd90e9c15886e21784ef0da61b
-  data.tar.gz: 82edb2e592d1fd45f895290d49f5f7d6533193e2406d7eadae89d0344082f986
+  metadata.gz: 7c7d38011d191d0e26b26b02e6b147672b27806cd66d9ebb416d326bc8ed0406
+  data.tar.gz: 8bef825331172211356c41ba82a7b5d5c927f939d6e0a716fb6a7f0a18cfb947
 SHA512:
-  metadata.gz: 29f37f4671b277a5b276f43bd4549a998f0ca17fbd80cfd41128d98e84fa9d64d594cfd271600e27f5fa9d20d0f33dab08c7c378790921143d5a0cf6441a9d2f
-  data.tar.gz: d2012cb64c0336afbfdf7e15b18f38295f35f1d4c88da068ce73abf8743bd672a800f984962040c70c9f6c64b65bbfc5d3e09a5eb881c60e5c714894ee019d2e
+  metadata.gz: 2ceec98de33377a4dea166d894ba5c6179ff7510744c6efbaa07fbb5dfbd237c0b08278587f9ebf410f601a41e006d395cbcc3f0ebd9114439348bc24bab25d3
+  data.tar.gz: 16c1bb6ba7b910c86f8dc605980c393a8a4f10e0fa57eeeeb109b6fea25efaacb5125f14518666960fc0050ea82a3a64d2c8bd260db79a084522af4a701fc0f4

data/ffi/bolt/config.rb

@@ -3,10 +3,35 @@
 module Bolt
   module Config
     extend Bolt::Library
+    typedef :int32_t, :bolt_scheme
+    typedef :int32_t, :bolt_transport
+
     attach_function :create, :BoltConfig_create, [], :auto_pointer
     attach_function :destroy, :BoltConfig_destroy, [:pointer], :void
+    attach_function :get_scheme, :BoltConfig_get_scheme, [:pointer], :bolt_scheme
+    attach_function :set_scheme, :BoltConfig_set_scheme, %i[pointer bolt_scheme], :int32_t
+    attach_function :get_transport, :BoltConfig_get_transport, [:pointer], :bolt_transport
+    attach_function :set_transport, :BoltConfig_set_transport, %i[pointer bolt_transport], :int32_t
+    attach_function :get_trust, :BoltConfig_get_trust, [:pointer], :pointer
+    attach_function :set_trust, :BoltConfig_set_trust, %i[pointer pointer], :int32_t
+    attach_function :get_user_agent, :BoltConfig_get_user_agent, [:pointer], :string
+    attach_function :set_user_agent, :BoltConfig_set_user_agent, %i[pointer string], :int32
+    attach_function :get_routing_context, :BoltConfig_get_routing_context, [:pointer], :pointer
+    attach_function :set_routing_context, :BoltConfig_set_routing_context, %i[pointer pointer], :int32_t
+    attach_function :get_address_resolver, :BoltConfig_get_address_resolver, [:pointer], :pointer
+    attach_function :set_address_resolver, :BoltConfig_set_address_resolver, %i[pointer pointer], :int32_t
     attach_function :get_log, :BoltConfig_get_log, [:pointer], :pointer
     attach_function :set_log, :BoltConfig_set_log, %i[pointer pointer], :int32
-    attach_function :set_user_agent, :BoltConfig_set_user_agent, %i[pointer string], :int32
+    attach_function :get_max_pool_size, :BoltConfig_get_max_pool_size, [:pointer], :int32_t
+    attach_function :set_max_pool_size, :BoltConfig_set_max_pool_size, %i[pointer int32_t], :int32_t
+    attach_function :get_max_connection_life_time, :BoltConfig_get_max_connection_life_time, [:pointer], :int32_t
+    attach_function :set_max_connection_life_time, :BoltConfig_set_max_connection_life_time, %i[pointer int32_t],
+                    :int32_t
+    attach_function :get_max_connection_acquisition_time, :BoltConfig_get_max_connection_acquisition_time, [:pointer],
+                    :int32_t
+    attach_function :set_max_connection_acquisition_time, :BoltConfig_set_max_connection_acquisition_time,
+                    %i[pointer int32_t], :int32_t
+    attach_function :get_socket_options, :BoltConfig_get_socket_options, [:pointer], :pointer
+    attach_function :set_socket_options, :BoltConfig_set_socket_options, %i[pointer pointer], :int32_t
   end
 end

data/ffi/bolt/socket_options.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bolt
+  module SocketOptions
+    extend Bolt::Library
+
+    attach_function :create, :BoltSocketOptions_create, [], :auto_pointer
+    attach_function :destroy, :BoltSocketOptions_destroy, [:pointer], :void
+    attach_function :get_connect_timeout, :BoltSocketOptions_get_connect_timeout, [:pointer], :int32_t
+    attach_function :set_connect_timeout, :BoltSocketOptions_set_connect_timeout, %i[pointer int32_t], :int32_t
+    attach_function :get_keep_alive, :BoltSocketOptions_get_keep_alive, [:pointer], :int32_t
+    attach_function :set_keep_alive, :BoltSocketOptions_set_keep_alive, %i[pointer int32_t], :int32_t
+  end
+end

data/ffi/neo4j/driver.rb

@@ -19,6 +19,8 @@ if RUBY_PLATFORM.match?(/java/)
           module V3
           end
         end
+        module Retry
+        end
         module Summary
         end
         module Util

data/ffi/neo4j/driver/config.rb

@@ -2,7 +2,7 @@
 
 module Neo4j
   module Driver
-    class Config
+    class Config < Hash
       class TrustStrategy
         class << self
           def trust_all_certificates; end

data/ffi/neo4j/driver/graph_database.rb

@@ -14,9 +14,9 @@ module Neo4j
 
         auto_closable :driver
 
-        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = {})
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = nil)
           raise Exceptions::AuthenticationException, 'Unsupported authentication token' unless auth_token
-          # config ||= Config.default_config
+          config ||= Config.default_config
           # routing_settings = config.routing_settings
           # retry_settings = config.retry_settings
           routing_settings = nil

data/ffi/neo4j/driver/internal/async/direct_connection.rb

@@ -10,8 +10,9 @@ module Neo4j
           attr_reader :protocol
           attr_reader :bolt_connection
 
-          def initialize(connector, mode)
+          def initialize(connector, mode, config)
             @connector = connector
+            @config = config
             @bolt_connection = with_status { |status| Bolt::Connector.acquire(@connector, mode, status) }
 
             # @protocol = Messaging::BoltProtocol.for_version(Bolt::Connection.server(bolt_connection).first)

data/ffi/neo4j/driver/internal/direct_connection_provider.rb

@@ -6,12 +6,13 @@ module Neo4j
       class DirectConnectionProvider
         include ErrorHandling
 
-        def initialize(connector)
+        def initialize(connector, config)
           @connector = connector
+          @config = config
         end
 
         def acquire_connection(mode)
-          Async::DirectConnection.new(@connector, mode)
+          Async::DirectConnection.new(@connector, mode, @config)
         end
 
         def verify_connectivity

data/ffi/neo4j/driver/internal/driver_factory.rb

@@ -13,7 +13,8 @@ module Neo4j
         def new_instance(uri, auth_token, routing_settings, retry_settings, config)
           uri = URI(uri)
           connector, logger = create_connector(uri, auth_token, config)
-          create_driver(uri.scheme, connector, logger, routing_settings).tap(&:verify_connectivity)
+          retry_logic = Retry::ExponentialBackoffRetryLogic.new(config[:max_transaction_retry_time], config[:logger])
+          create_driver(uri.scheme, connector, logger, routing_settings, retry_logic, config).tap(&:verify_connectivity)
         end
 
         private
@@ -22,19 +23,37 @@ module Neo4j
           address = Bolt::Address.create(host(uri).gsub(/^\[(.*)\]$/, '\\1'), port(uri).to_s)
           bolt_config = bolt_config(config)
           logger = InternalLogger.register(bolt_config, config[:logger])
+          set_socket_options(bolt_config, config)
           [Bolt::Connector.create(address, auth_token, bolt_config), logger]
         end
 
         def bolt_config(config)
           bolt_config = Bolt::Config.create
           config.each do |key, value|
-            # case key
-            # end
+            case key
+            when :max_connection_pool_size
+              check_error Bolt::Config.set_max_pool_size(bolt_config, value)
+            when :max_connection_life_time
+              check_error Bolt::Config.set_max_connection_life_time(bolt_config, value)
+            when :connection_acquisition_timeout
+              check_error Bolt::Config.set_max_connection_acquisition_time(bolt_config, value)
+            end
           end
           check_error Bolt::Config.set_user_agent(bolt_config, 'seabolt-cmake/1.7')
           bolt_config
         end
 
+        def set_socket_options(bolt_config, config)
+          socket_options = nil
+          config.each do |key, value|
+            case key
+            when :connection_timeout
+              check_error Bolt::SocketOptions.set_connect_timeout(socket_options ||= Bolt::SocketOptions.create, value)
+            end
+          end
+          check_error Bolt::Config.set_socket_options(bolt_config, socket_options) if socket_options
+        end
+
         def host(uri)
           uri.host.tap { |host| raise ArgumentError, "Invalid address format `#{uri}`" unless host }
         end
@@ -44,12 +63,12 @@ module Neo4j
             DEFAULT_PORT
         end
 
-        def create_driver(scheme, connector, logger, routing_settings)
+        def create_driver(scheme, connector, logger, routing_settings, retry_logic, config)
           case scheme
           when BOLT_URI_SCHEME
             # assert_no_routing_context( uri, routing_settings )
             # return createDirectDriver( securityPlan, address, connectionPool, retryLogic, metrics, config );
-            create_direct_driver(connector, logger)
+            create_direct_driver(connector, logger, retry_logic, config)
           when BOLT_ROUTING_URI_SCHEME, NEO4J_URI_SCHEME
             # create_routing_driver( security_plan, address, connection_ool, eventExecutorGroup, routingSettings, retryLogic, metrics, config );
           else
@@ -57,9 +76,9 @@ module Neo4j
           end
         end
 
-        def create_direct_driver(connector, logger)
-          connection_provider = DirectConnectionProvider.new(connector)
-          session_factory = create_session_factory(connection_provider)
+        def create_direct_driver(connector, logger, retry_logic, config)
+          connection_provider = DirectConnectionProvider.new(connector, config)
+          session_factory = create_session_factory(connection_provider, retry_logic, config)
           InternalDriver.new(session_factory, logger)
         end
 

data/ffi/neo4j/driver/internal/error_handling.rb

@@ -15,6 +15,13 @@ module Neo4j
             # Connection refused
           when Bolt::Error::BOLT_CONNECTION_REFUSED
             throw Exceptions::ServiceUnavailableException.new(error_code, 'unable to acquire connection')
+            # Connection pool is full
+          when Bolt::Error::BOLT_POOL_FULL
+            throw Exceptions::ClientException.new(
+              error_code,
+              'Unable to acquire connection from the pool within configured maximum time of ' \
+              "#{@config[:connection_acquisition_timeout] * 1000}ms"
+            )
             # Error set in connection
           when Bolt::Error::BOLT_CONNECTION_HAS_MORE_INFO, Bolt::Error::BOLT_STATUS_SET
             status = Bolt::Connection.status(bolt_connection)
@@ -37,6 +44,21 @@ module Neo4j
           check_status(status)
         end
 
+        def new_neo4j_error(code:, message:)
+          case code.split('.')[1]
+          when 'ClientError'
+            if code.casecmp('Neo.ClientError.Security.Unauthorized').zero?
+              Exceptions::AuthenticationException
+            else
+              Exceptions::ClientException
+            end
+          when 'TransientError'
+            Exceptions::TransientException
+          else
+            Exceptions::DatabaseException
+          end.new(code, message)
+        end
+
         private
 
         def throw(error)

data/ffi/neo4j/driver/internal/handlers/pull_all_response_handler.rb

@@ -5,8 +5,6 @@ module Neo4j
     module Internal
       module Handlers
         class PullAllResponseHandler < ResponseHandler
-          include ErrorHandling
-
           delegate :bolt_connection, to: :connection
           delegate :statement_keys, to: :run_handler
           attr_reader :connection

data/ffi/neo4j/driver/internal/handlers/response_handler.rb

@@ -5,6 +5,8 @@ module Neo4j
     module Internal
       module Handlers
         class ResponseHandler
+          include ErrorHandling
+
           delegate :bolt_connection, to: :connection
           attr_reader :connection, :failure
           attr_accessor :request, :previous
@@ -33,7 +35,7 @@ module Neo4j
             else
               return if previous&.failure
               @failure = Value::ValueAdapter.to_ruby(Bolt::Connection.failure(bolt_connection))
-              raise Exceptions::ClientException.new(@failure[:code], @failure[:message])
+              raise new_neo4j_error(@failure)
             end
           end
 

data/ffi/neo4j/driver/internal/network_session.rb

@@ -15,12 +15,7 @@ module Neo4j
           @open = Concurrent::AtomicBoolean.new(true)
           @connection_provider = connection_provider
           @mode = mode
-          # @retry_logic = retry_logic
-          @retry_logic = Class.new do
-            def retry
-              yield
-            end
-          end.new
+          @retry_logic = retry_logic
         end
 
         def run(statement, parameters = {}, config = nil)

data/ffi/neo4j/driver/internal/retry/exponential_backoff_retry_logic.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Retry
+        class ExponentialBackoffRetryLogic
+          DEFAULT_MAX_RETRY_TIME = 30
+          INITIAL_RETRY_DELAY = 1
+          RETRY_DELAY_MULTIPLIER = 2.0
+          RETRY_DELAY_JITTER_FACTOR = 0.2
+
+          def initialize(max_retry_time = nil, logger = nil)
+            @max_retry_time = max_retry_time || DEFAULT_MAX_RETRY_TIME
+            @log = logger
+          end
+
+          def retry
+            next_delay = INITIAL_RETRY_DELAY
+            start_time = nil
+            errors = nil
+            loop do
+              return yield
+            rescue Exceptions::Neo4jException => error
+              if can_retry_on?(error)
+                curr_time = current_time
+                start_time ||= curr_time
+                elapsed_time = curr_time - start_time
+                if elapsed_time < @max_retry_time
+                  delay_with_jitter = compute_delay_with_jitter(next_delay)
+                  @log&.warn("Transaction failed and will be retried in #{delay_with_jitter}ms", error)
+                  sleep(delay_with_jitter) # verify time units
+                  next_delay *= RETRY_DELAY_MULTIPLIER
+                  (errors ||= []) << error
+                  next
+                end
+              end
+              add_suppressed(error, errors)
+              raise error
+            end
+          end
+
+          private
+
+          def can_retry_on?(error)
+            error.is_a?(Exceptions::SessionExpiredException) ||
+              error.is_a?(Exceptions::ServiceUnavailableException) ||
+              transient_error?(error)
+          end
+
+          def transient_error?(error)
+            # Retries should not happen when transaction was explicitly terminated by the user.
+            # Termination of transaction might result in two different error codes depending on where it was
+            # terminated. These are really client errors but classification on the server is not entirely correct and
+            # they are classified as transient.
+            error.is_a?(Exceptions::TransientException) &&
+              !%w[Neo.TransientError.Transaction.Terminated Neo.TransientError.Transaction.LockClientStopped]
+                 .include?(error.code)
+          end
+
+          def compute_delay_with_jitter(delay)
+            jitter = delay * RETRY_DELAY_JITTER_FACTOR
+            min = delay - jitter
+            max = delay + jitter
+            @rand ||= Random.new
+            @rand.rand(min..max)
+          end
+
+          def current_time
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+
+          def add_suppressed(error, suppressed_errors)
+            suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '0.1.9'
+    VERSION = '0.1.10'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-28 00:00:00.000000000 Z
+date: 2019-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -239,11 +239,11 @@ files:
 - ffi/bolt/lifecycle.rb
 - ffi/bolt/list.rb
 - ffi/bolt/log.rb
+- ffi/bolt/socket_options.rb
 - ffi/bolt/status.rb
 - ffi/bolt/string.rb
 - ffi/bolt/structure.rb
 - ffi/bolt/value.rb
-- ffi/bolt/values_private.rb
 - ffi/neo4j/driver.rb
 - ffi/neo4j/driver/access_mode.rb
 - ffi/neo4j/driver/auth_tokens.rb
@@ -270,6 +270,7 @@ files:
 - ffi/neo4j/driver/internal/messaging/v2/bolt_protocol_v2.rb
 - ffi/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb
 - ffi/neo4j/driver/internal/network_session.rb
+- ffi/neo4j/driver/internal/retry/exponential_backoff_retry_logic.rb
 - ffi/neo4j/driver/internal/session_factory_impl.rb
 - ffi/neo4j/driver/internal/summary/internal_result_summary.rb
 - ffi/neo4j/driver/internal/summary/internal_server_info.rb

data/ffi/bolt/values_private.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module ValuesPrivate
-    extend FFI::Library
-
-    typedef :pointer, :bolt_value
-    # typedef BoltData, :bolt_data
-    # typedef BoltExtendedValue, :bolt_extended_value
-    #
-    # class BoltValue < FFI::Struct
-    #   layout :type, :int16,
-    #          :subtype, :int16,
-    #          :size, :int16,
-    #          :data_size, :uint64,
-    #          :data, :bolt_data
-    # end
-    #
-    # class BoltData < FFI::Union
-    #   layout :as_char, [:char, 16],
-    #          :as_uint32, [:uint32, 4],
-    #          :as_int8, [:int8_t, 16],
-    #          :as_int16, [:int16, 8],
-    #          :as_int32, [:int32, 4],
-    #          :as_int64, [:int64, 2],
-    #          :as_double, [:double, 2],
-    #          :extended, :bolt_extended_value
-    # end
-
-    class BoltExtendedValue < FFI::Union
-      layout :as_ptr, :pointer,
-             :as_char, :string,
-             :as_value, :bolt_value
-    end
-  end
-end