neo4j-ruby-driver 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac7628f26dea26f54328c47736001a148b7b864771b50036b659f7f4d92ffa50
-  data.tar.gz: 318537bb1949cb5f917b0f34183edbffc9ff1927239d7a3d8180ea07fdb97924
+  metadata.gz: d120aee905184fbdec88e8492508aaf5ca5ab442e584d80d7047370b8d9b38f8
+  data.tar.gz: f029e5705dbdc89b2ed0f27e224f4711a6ddbdf5c9968925a0a7fe0e8cd164e1
 SHA512:
-  metadata.gz: 03a0ed4e03c81c7ba6d3804adf329c8a44cf3a1a13437b2f147ca398789300b4736cfca683d1b928fb709351464e4d1cd930d89acf439efab8ac19d750dd75b0
-  data.tar.gz: acff913f890a863009fe45ac24ca63ed56fd89414ba81183e5740fcbc77e2e3b10f9b0f444113f8f38ea615f43ecde81eb7813ebfc67aa6ce080a6d5fe3d6407
+  metadata.gz: cb2ee849c0c8952ae992ba23b4068a750454772a49b8d891c81abf184c5f6440f4295a38b266e51fc466521c8dfcd1a722f84db16f50e29bd28a6c2fd0e411a0
+  data.tar.gz: 5efbeb6d55973470fa765bb6b46417f02c63713c4a2637847ff99bda193483b8751b6b7ca378b40a550cf25a0ea2cd0c39a4e459effc886a11d0fb746e3654c0

data/ffi/bolt/status.rb

@@ -3,6 +3,16 @@
 module Bolt
   module Status
     extend Bolt::Library
+    # Not connected
+    BOLT_CONNECTION_STATE_DISCONNECTED = 0
+    # Connected but not authenticated
+    BOLT_CONNECTION_STATE_CONNECTED = 1
+    # Connected and authenticated
+    BOLT_CONNECTION_STATE_READY = 2
+    # Recoverable failure
+    BOLT_CONNECTION_STATE_FAILED = 3
+    # Unrecoverable failure
+    BOLT_CONNECTION_STATE_DEFUNCT = 4
 
     typedef :int32, :bolt_connection_state
 

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

@@ -37,9 +37,10 @@ module Neo4j
             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)
+              check_error Bolt::Config.set_max_connection_life_time(bolt_config, DurationNormalizer.milliseconds(value))
             when :connection_acquisition_timeout
-              check_error Bolt::Config.set_max_connection_acquisition_time(bolt_config, value)
+              check_error Bolt::Config.set_max_connection_acquisition_time(bolt_config,
+                                                                           DurationNormalizer.milliseconds(value))
             end
           end
           check_error Bolt::Config.set_user_agent(bolt_config, 'seabolt-cmake/1.7')
@@ -51,7 +52,8 @@ module Neo4j
           config.each do |key, value|
             case key
             when :connection_timeout
-              check_error Bolt::SocketOptions.set_connect_timeout(socket_options ||= Bolt::SocketOptions.create, value)
+              check_error Bolt::SocketOptions.set_connect_timeout(socket_options ||= Bolt::SocketOptions.create,
+                                                                  DurationNormalizer.milliseconds(value))
             end
           end
           check_error Bolt::Config.set_socket_options(bolt_config, socket_options) if socket_options

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

@@ -4,7 +4,7 @@ module Neo4j
   module Driver
     module Internal
       module ErrorHandling
-        def check_error(error_code, status = nil, error_text = nil)
+        def check_error(error_code, status = nil)
           case error_code
             # Identifies a successful operation which is defined as 0
           when Bolt::Error::BOLT_SUCCESS # 0
@@ -23,19 +23,22 @@ module Neo4j
             throw Exceptions::ClientException.new(
               error_code,
               'Unable to acquire connection from the pool within configured maximum time of ' \
-              "#{@config[:connection_acquisition_timeout] * 1000}ms"
+              "#{DurationNormalizer.milliseconds(@config[:connection_acquisition_timeout])}ms"
             )
 
             # Routing table retrieval failed
           when Bolt::Error::BOLT_ROUTING_UNABLE_TO_RETRIEVE_ROUTING_TABLE # 0x800
-            throw Exceptions::ServiceUnavailableException.new(error_code, Bolt::Error.get_string(error_code))
+            throw Exceptions::ServiceUnavailableException.new(
+              error_code,
+              'Could not perform discovery. No routing servers available.'
+            )
 
             # Error set in connection
           when Bolt::Error::BOLT_CONNECTION_HAS_MORE_INFO, Bolt::Error::BOLT_STATUS_SET # 0xFFE, 0xFFF
             status = Bolt::Connection.status(bolt_connection)
-            unqualified_error(error_code, status, error_text)
+            unqualified_error(error_code, status)
           else
-            unqualified_error(error_code, status, error_text)
+            unqualified_error(error_code, status)
           end
         end
 
@@ -69,18 +72,35 @@ module Neo4j
 
         private
 
+        def exception_class(state)
+          case state
+          when Bolt::Status::BOLT_CONNECTION_STATE_DEFUNCT
+            Exceptions::SessionExpiredException
+          else
+            Exceptions::Neo4jException
+          end
+        end
+
         def throw(error)
           on_failure(error)
           raise error
         end
 
-        def unqualified_error(error_code, status, error_text)
-          error_ctx = status && Bolt::Status.get_error_context(status)
-          throw Exceptions::Neo4jException.new(
-            error_code,
-            "#{error_text || 'Unknown Bolt failure'} (code: #{error_code.to_s(16)}, " \
-            "text: #{Bolt::Error.get_string(error_code)}, context: #{error_ctx})"
-          )
+        def unqualified_error(error_code, status)
+          details = details(error_code, status)
+          throw exception_class(details[:state]).new(error_code,
+                                                     details.map { |key, value| "#{key}: `#{value}`" }.join(', '))
+        end
+
+        def details(error_code, status)
+          details = {
+            code: error_code.to_s(16),
+            error: Bolt::Error.get_string(error_code)
+          }
+          return details unless status
+          details.merge(state: Bolt::Status.get_state(status),
+                        error: Bolt::Status.get_error(status),
+                        error_context: Bolt::Status.get_error_context(status))
         end
       end
     end

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

@@ -17,6 +17,7 @@ module Neo4j
 
         def begin(initial_bookmarks, config)
           chain @protocol.begin_transaction(@connection, initial_bookmarks, config)
+          finalize if initial_bookmarks.present?
           self
         rescue StandardError => e
           @connection.release

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

@@ -5,8 +5,8 @@ module Neo4j
     module Internal
       module Retry
         class ExponentialBackoffRetryLogic
-          DEFAULT_MAX_RETRY_TIME = 30
-          INITIAL_RETRY_DELAY = 1
+          DEFAULT_MAX_RETRY_TIME = 30.seconds
+          INITIAL_RETRY_DELAY = 1.second
           RETRY_DELAY_MULTIPLIER = 2.0
           RETRY_DELAY_JITTER_FACTOR = 0.2
 
@@ -19,8 +19,8 @@ module Neo4j
             next_delay = INITIAL_RETRY_DELAY
             start_time = nil
             errors = nil
-            loop do
-              return yield
+            begin
+              yield
             rescue Exceptions::Neo4jException => error
               if can_retry_on?(error)
                 curr_time = current_time
@@ -28,11 +28,11 @@ module Neo4j
                 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
+                  @log&.warn { "Transaction failed and will be retried in #{delay_with_jitter}ms\n#{error}" }
+                  sleep(delay_with_jitter)
                   next_delay *= RETRY_DELAY_MULTIPLIER
                   (errors ||= []) << error
-                  next
+                  retry
                 end
               end
               add_suppressed(error, errors)

data/lib/neo4j/driver/internal/duration_normalizer.rb

@@ -16,6 +16,10 @@ module Neo4j
             [months_i, days_i, seconds_i, nonanoseconds.round]
           end
 
+          def milliseconds(duration)
+            duration.in_milliseconds.round
+          end
+
           private
 
           def divmod(number, factor)

data/lib/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '0.2.0'
+    VERSION = '0.2.1'
   end
 end

data/lib/neo4j_ruby_driver.rb

@@ -14,6 +14,7 @@ end
 # End workaround
 
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/numeric/time'
 require 'active_support/duration'
 require 'active_support/time'
 require 'neo4j/driver'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 2020-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport