neospace 0.0.1 → 1.7.0

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class BoltServerAddress
+        include Net::ServerAddress
+
+        attr_reader :host, :port
+
+        def initialize(host, port)
+          @host = host
+          @port = port
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module BookmarksHolder
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :bookmarks
+        end
+
+        def initialize
+          @bookmarks = []
+        end
+
+        def bookmarks=(bookmarks)
+          bookmarks = Array(bookmarks).select(&:present?)
+          @bookmarks = bookmarks if bookmarks.present?
+        end
+
+        NO_OP = Class.new do
+          include BookmarksHolder
+
+          def bookmarks=; end
+        end.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class DirectConnectionProvider
+        include ErrorHandling
+
+        def initialize(connector, config)
+          @connector = connector
+          @config = config
+        end
+
+        def acquire_connection(mode)
+          Async::DirectConnection.new(@connector, mode, @config)
+        end
+
+        def verify_connectivity
+          acquire_connection(AccessMode::READ).release
+        end
+
+        def close
+          Bolt::Connector.destroy(@connector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class DriverFactory
+        include ErrorHandling
+        BOLT_URI_SCHEME = 'bolt'
+        BOLT_ROUTING_URI_SCHEME = 'bolt+routing'
+        NEO4J_URI_SCHEME = 'neo4j'
+        DEFAULT_PORT = 7687
+
+        def new_instance(uri, auth_token, config)
+          uri = URI(uri)
+          routing_context = routing_context(uri)
+          connector, logger, resolver = create_connector(uri, auth_token, routing_context, config)
+          retry_logic = Retry::ExponentialBackoffRetryLogic.new(config[:max_transaction_retry_time], config[:logger])
+          create_driver(connector, logger, resolver, retry_logic, config).tap(&:verify_connectivity)
+        end
+
+        private
+
+        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)
+          resolver = InternalResolver.register(bolt_config, config[:resolver])
+          [Bolt::Connector.create(address, auth_token, bolt_config), logger, resolver]
+        end
+
+        def bolt_config(config)
+          bolt_config = Bolt::Config.create
+          config.each do |key, value|
+            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, DurationNormalizer.milliseconds(value))
+            when :connection_acquisition_timeout
+              check_error Bolt::Config.set_max_connection_acquisition_time(bolt_config,
+                                                                           DurationNormalizer.milliseconds(value))
+            when :encryption
+              check_error Bolt::Config.set_transport(
+                bolt_config,
+                value ? Bolt::Config::BOLT_TRANSPORT_ENCRYPTED : Bolt::Config::BOLT_TRANSPORT_PLAINTEXT
+              )
+            end
+          end
+          check_error Bolt::Config.set_user_agent(bolt_config, "neo4j-ruby-driver #{Neo4j::Driver::VERSION}")
+          bolt_config
+        end
+
+        def set_socket_options(bolt_config, config)
+          socket_options = Bolt::SocketOptions.create
+          config.each do |key, value|
+            case key
+            when :connection_timeout
+              check_error Bolt::SocketOptions.set_connect_timeout(socket_options,
+                                                                  DurationNormalizer.milliseconds(value))
+            when :keep_alive
+              check_error Bolt::SocketOptions.set_keep_alive(socket_options, value ? 1 : 0)
+            end
+          end
+          check_error Bolt::Config.set_socket_options(bolt_config, 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
+
+        def port(uri)
+          uri.port&.tap { |port| raise ArgumentError, "Illegal port:  #{port}" unless (0..65_535).cover?(port) } ||
+            DEFAULT_PORT
+        end
+
+        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_context)
+            Bolt::Config::BOLT_SCHEME_DIRECT
+          when BOLT_ROUTING_URI_SCHEME, NEO4J_URI_SCHEME
+            Bolt::Config::BOLT_SCHEME_NEO4J
+          else
+            raise Exceptions::ClientException, "Unsupported URI scheme: #{scheme}"
+          end
+        end
+
+        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, resolver, retry_logic, config)
+          connection_provider = DirectConnectionProvider.new(connector, config)
+          session_factory = create_session_factory(connection_provider, retry_logic, config)
+          InternalDriver.new(session_factory, logger, resolver)
+        end
+
+        def create_session_factory(connection_provider, retry_logic = nil, config = nil)
+          SessionFactoryImpl.new(connection_provider, retry_logic, config)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module ErrorHandling
+        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
+            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 # 11
+            throw Exceptions::ServiceUnavailableException.new(error_code, 'unable to acquire connection')
+
+            # Connection pool is 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 ' \
+              "#{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,
+              '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)
+          else
+            unqualified_error(error_code, status)
+          end
+        end
+
+        def on_failure(_error); end
+
+        def check_status(status)
+          check_error(Bolt::Status.get_error(status), status)
+        end
+
+        def with_status
+          status = Bolt::Status.create
+          yield status
+        ensure
+          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 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)
+          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
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class ExplicitTransaction
+        include ErrorHandling
+
+        delegate :finalize, to: :@handler
+
+        def initialize(connection, session)
+          @connection = connection
+          @protocol = connection.protocol
+          @session = session
+          @state = :active
+        end
+
+        def begin(initial_bookmarks, config)
+          chain @protocol.begin_transaction(@connection, initial_bookmarks, config)
+          finalize if initial_bookmarks.present?
+          self
+        rescue StandardError => e
+          @connection.release
+          raise e
+        end
+
+        def run(query, parameters = {})
+          ensure_can_run_queries
+          @result&.failure
+          @result = @protocol.run_in_explicit_transaction(@connection, Statement.new(query, parameters), self)
+        end
+
+        def success
+          @state = :marked_success if @state == :active
+        end
+
+        def failure
+          @state = :marked_failed if %i[active marked_success].include? @state
+        end
+
+        def mark_terminated
+          @state = :terminated
+        end
+
+        def close
+          case @state
+          when :marked_success
+            commit
+          when :committed, :rolled_back
+            nil
+          else
+            rollback
+          end
+        end
+
+        def open?
+          !%i[committed rolled_back].include? @state
+        end
+
+        def chain(*handlers)
+          handlers.each do |handler|
+            handler.previous = @handler
+            @handler = handler
+          end
+        end
+
+        private
+
+        def commit
+          case @state
+          when :committed
+            nil
+          when :rolled_back
+            raise Exceptions::ClientExceptiom, "Can't commit, transaction has been rolled back"
+          else
+            begin
+              do_commit
+              # handleCommitOrRollback( error )
+            ensure
+              transaction_closed(:committed)
+            end
+          end
+        end
+
+        def do_commit
+          if @state == :terminated
+            raise Exceptions::ClientException, "Transaction can't be committed. " \
+          'It has been rolled back either because of an error or explicit termination'
+          end
+
+          # @session.bookmarks = @protocol.commit_transaction(@connection)
+          chain @protocol.commit_transaction(@connection)
+          finalize
+          @session.bookmarks = @connection.last_bookmark
+        end
+
+        def rollback
+          case @state
+          when :committed
+            raise ClientException, "Can't rollback, transaction has been committed"
+          when :rolled_back
+            nil
+          else
+            begin
+              do_rollback
+              # resultCursors.retrieveNotConsumedError()
+              # handleCommitOrRollback( error )
+            ensure
+              transaction_closed(:rolled_back)
+            end
+          end
+        end
+
+        def do_rollback
+          return if @state == :terminated
+
+          chain @protocol.rollback_transaction(@connection)
+          finalize
+        end
+
+        def transaction_closed(new_state)
+          @state = new_state
+          @session.release_connection
+        end
+
+        def ensure_can_run_queries
+          reason =
+            case @state
+            when :committed
+              'Cannot run more statements in this transaction, it has been committed'
+            when :rolled_back
+              'Cannot run more statements in this transaction, it has been rolled back'
+            when :marked_failed
+              'Cannot run more statements in this transaction, it has been marked for failure. ' \
+            'Please either rollback or close this transaction'
+            when :terminated
+              'Cannot run more statements in this transaction, ' \
+            'it has either experienced an fatal error or was explicitly terminated'
+            end
+
+          raise Exceptions::ClientException, reason if reason
+        end
+      end
+    end
+  end
+end