neo4j-ruby-driver 0.1.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc232aeb41f6d375e3b6b4b10add564b614bab08b4b10da7ac2a0e3be87c47b3
-  data.tar.gz: c5106737007e4b022902e966b477edf212b6b37b8888835a491e08cc63736ebd
+  metadata.gz: ac7628f26dea26f54328c47736001a148b7b864771b50036b659f7f4d92ffa50
+  data.tar.gz: 318537bb1949cb5f917b0f34183edbffc9ff1927239d7a3d8180ea07fdb97924
 SHA512:
-  metadata.gz: dabbfa13632a1456ba101c5d4cf60d2e51562d9debbbc4b5222958655b5f98e027cd68a1453f0d3f014e7380540bbb50e4ff04c6d0361e26a7dc734927a9d8d8
-  data.tar.gz: 9f7a54ac9c14240b191b34079e8e843e227d5e248cd04811b2fdaeebd7b536e43d9707a18056c704307380abf75b2246364ca2181f3baba2a19a6c17e2525201
+  metadata.gz: 03a0ed4e03c81c7ba6d3804adf329c8a44cf3a1a13437b2f147ca398789300b4736cfca683d1b928fb709351464e4d1cd930d89acf439efab8ac19d750dd75b0
+  data.tar.gz: acff913f890a863009fe45ac24ca63ed56fd89414ba81183e5740fcbc77e2e3b10f9b0f444113f8f38ea615f43ecde81eb7813ebfc67aa6ce080a6d5fe3d6407

data/ffi/bolt/config.rb

@@ -3,6 +3,10 @@
 module Bolt
   module Config
     extend Bolt::Library
+
+    BOLT_SCHEME_DIRECT = 0
+    BOLT_SCHEME_NEO4J = 1
+
     typedef :int32_t, :bolt_scheme
     typedef :int32_t, :bolt_transport
 

data/ffi/neo4j/driver/graph_database.rb

@@ -3,6 +3,9 @@
 module Neo4j
   module Driver
     class GraphDatabase
+      VALID_ROUTING_SCHEMES =
+        [Internal::DriverFactory::BOLT_ROUTING_URI_SCHEME, Internal::DriverFactory::NEO4J_URI_SCHEME].freeze
+
       Bolt::Lifecycle.startup
 
       at_exit do
@@ -12,17 +15,36 @@ module Neo4j
       class << self
         extend AutoClosable
 
-        auto_closable :driver
+        auto_closable :driver, :routing_driver
 
         def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = nil)
-          raise Exceptions::AuthenticationException, 'Unsupported authentication token' unless auth_token
+          unless auth_token.is_a? FFI::Pointer
+            raise Exceptions::AuthenticationException, 'Unsupported authentication token'
+          end
           config ||= Config.default_config
-          # routing_settings = config.routing_settings
-          # retry_settings = config.retry_settings
-          routing_settings = nil
-          retry_settings = nil
 
-          Internal::DriverFactory.new.new_instance(uri, auth_token, routing_settings, retry_settings, config)
+          Internal::DriverFactory.new.new_instance(uri, auth_token, config)
+        end
+
+        def routing_driver(routing_uris, auth_toke, config)
+          assert_routing_uris(routing_uris)
+
+          routing_uris.each do |uri|
+            return driver(uri, auth_toke, config)
+          rescue Exceptions::ServiceUnavailableException => e
+            # log.warn("Unable to create routing driver for URI: #{uri}", e)
+          end
+
+          raise Exceptions::ServiceUnavailableException, 'Failed to discover an available server'
+        end
+
+        private
+
+        def assert_routing_uris(uris)
+          scheme = (uris.map(&method(:URI)).map(&:scheme) - VALID_ROUTING_SCHEMES).first
+          return unless scheme
+          raise ArgumentError,
+                "Illegal URI scheme, expected URI scheme '#{scheme}' to be among [#{VALID_ROUTING_SCHEMES.join ', '}]"
         end
       end
     end

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

@@ -10,20 +10,23 @@ module Neo4j
         NEO4J_URI_SCHEME = 'neo4j'
         DEFAULT_PORT = 7687
 
-        def new_instance(uri, auth_token, routing_settings, retry_settings, config)
+        def new_instance(uri, auth_token, config)
           uri = URI(uri)
-          connector, logger = create_connector(uri, auth_token, config)
+          routing_context = routing_context(uri)
+          connector, logger = create_connector(uri, auth_token, routing_context, config)
           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)
+          create_driver(connector, logger, retry_logic, config).tap(&:verify_connectivity)
         end
 
         private
 
-        def create_connector(uri, auth_token, config)
+        def create_connector(uri, auth_token, routing_context, config)
           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)
+          set_routing_context(bolt_config, routing_context)
+          set_scheme(bolt_config, uri, routing_context)
           [Bolt::Connector.create(address, auth_token, bolt_config), logger]
         end
 
@@ -54,6 +57,17 @@ module Neo4j
           check_error Bolt::Config.set_socket_options(bolt_config, socket_options) if socket_options
         end
 
+        def routing_context(uri)
+          query = uri.query
+          return if query.blank?
+          URI.decode_www_form(query).to_h
+        end
+
+        def set_routing_context(bolt_config, routing_context)
+          value = Bolt::Value.create
+          check_error Bolt::Config.set_routing_context(bolt_config, Value::ValueAdapter.to_neo(value, routing_context))
+        end
+
         def host(uri)
           uri.host.tap { |host| raise ArgumentError, "Invalid address format `#{uri}`" unless host }
         end
@@ -63,20 +77,30 @@ module Neo4j
             DEFAULT_PORT
         end
 
-        def create_driver(scheme, connector, logger, routing_settings, retry_logic, config)
+        def set_scheme(bolt_config, uri, routing_context)
+          check_error Bolt::Config.set_scheme(bolt_config, scheme(uri, routing_context))
+        end
+
+        def scheme(uri, routing_context)
+          scheme = uri.scheme
           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, retry_logic, config)
+            assert_no_routing_context(uri, routing_context)
+            Bolt::Config::BOLT_SCHEME_DIRECT
           when BOLT_ROUTING_URI_SCHEME, NEO4J_URI_SCHEME
-            # create_routing_driver( security_plan, address, connection_ool, eventExecutorGroup, routingSettings, retryLogic, metrics, config );
+            Bolt::Config::BOLT_SCHEME_NEO4J
           else
             raise Exceptions::ClientException, "Unsupported URI scheme: #{scheme}"
           end
         end
 
-        def create_direct_driver(connector, logger, retry_logic, config)
+        def assert_no_routing_context(uri, routing_context)
+          if routing_context
+            raise ArgumentError, "Routing parameters are not supported with scheme 'bolt'. Given URI: '#{uri}'"
+          end
+        end
+
+        def create_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)

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

@@ -9,21 +9,29 @@ module Neo4j
             # Identifies a successful operation which is defined as 0
           when Bolt::Error::BOLT_SUCCESS # 0
             nil
+
             # Permission denied
           when Bolt::Error::BOLT_PERMISSION_DENIED # 7
             throw Exceptions::AuthenticationException.new(error_code, 'Permission denied')
+
             # Connection refused
-          when Bolt::Error::BOLT_CONNECTION_REFUSED
+          when Bolt::Error::BOLT_CONNECTION_REFUSED # 11
             throw Exceptions::ServiceUnavailableException.new(error_code, 'unable to acquire connection')
+
             # Connection pool is full
-          when Bolt::Error::BOLT_POOL_FULL
+          when Bolt::Error::BOLT_POOL_FULL # 0x600
             throw Exceptions::ClientException.new(
               error_code,
               'Unable to acquire connection from the pool within configured maximum time of ' \
               "#{@config[:connection_acquisition_timeout] * 1000}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))
+
             # Error set in connection
-          when Bolt::Error::BOLT_CONNECTION_HAS_MORE_INFO, Bolt::Error::BOLT_STATUS_SET
+          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)
           else
@@ -71,7 +79,7 @@ module Neo4j
           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})"
+            "text: #{Bolt::Error.get_string(error_code)}, context: #{error_ctx})"
           )
         end
       end

data/lib/neo4j/driver/version.rb

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

metadata

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