neospace 0.0.1 → 1.7.0

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class PullAllResponseHandler < ResponseHandler
+          delegate :bolt_connection, to: :connection
+          delegate :statement_keys, to: :run_handler
+          attr_reader :connection
+
+          def initialize(statement, run_handler, connection, metadata_extractor)
+            super(connection)
+            @statement = statement
+            @previous = run_handler
+            @metadate_extractor = metadata_extractor
+            @records = []
+          end
+
+          def consume
+            @ignore_records = true
+            @records.clear
+            finalize
+            @summary
+          rescue StandardError => e
+            on_failure(e)
+            raise e
+          end
+
+          def summary
+            unless @finished
+              while (record = fetch)
+                @records << record
+              end
+            end
+            @summary ||= Summary::InternalResultSummary.new(@statement, run_handler.result_available_after,
+                                                            bolt_connection)
+          end
+
+          def peek
+            @records.first || ((@records << fetch).first unless @finished)
+          end
+
+          def next
+            peek
+            @records.shift
+          end
+
+          def on_success
+            @finished = true
+            summary
+
+            after_success(nil)
+
+            @failure = nil
+          end
+
+          def failure
+            summary
+            super
+          end
+
+          def on_failure(error)
+            summary
+            @finished = true
+
+            after_failure(error)
+
+            @failure = error
+          end
+
+          def finalize
+            summary unless @ignore_records
+            super
+          end
+
+          private
+
+          def run_handler
+            @previous
+          end
+
+          def fetch
+            run_handler.finalize
+            bolt_connection_fetch = Bolt::Connection.fetch(bolt_connection, request)
+            case bolt_connection_fetch
+            when -1
+              check_status(Bolt::Connection.status(bolt_connection))
+            when 1
+              InternalRecord.new(run_handler.statement_keys,
+                                 Value::ValueAdapter.to_ruby(Bolt::Connection.field_values(bolt_connection)))
+            else
+              @finished = true
+              check_summary_failure
+              nil
+            end
+          rescue StandardError => e
+            on_failure(e)
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class ResponseHandler
+          include ErrorHandling
+
+          delegate :bolt_connection, to: :connection
+          attr_reader :connection, :failure
+          attr_accessor :request, :previous
+
+          def initialize(connection)
+            @connection = connection
+          end
+
+          def finalize
+            return if @finished
+            @finished = true
+            begin
+              previous&.finalize
+            ensure
+              Bolt::Connection.fetch_summary(bolt_connection, request)
+              check_summary_failure
+            end
+          end
+
+          private
+
+          def check_summary_failure
+            summary
+            if Bolt::Connection.summary_success(bolt_connection) == 1
+              after_success(nil)
+            else
+              return if previous&.failure
+              @failure = Value::ValueAdapter.to_ruby(Bolt::Connection.failure(bolt_connection))
+              raise new_neo4j_error(**@failure)
+            end
+          end
+
+          def summary; end
+
+          def after_success(metadata); end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class RunResponseHandler < ResponseHandler
+          attr_reader :result_available_after
+
+          def initialize(connection, metadata_extractor)
+            super(connection)
+            @statement_keys = []
+            @metadata_extractor = metadata_extractor
+          end
+
+          def statement_keys
+            finalize
+            @statement_keys
+          end
+
+          def finalize
+            return if @finished
+            super
+            @statement_keys = Value::ValueAdapter.to_ruby(Bolt::Connection.field_names(bolt_connection)).map(&:to_sym)
+            metadata = Value::ValueAdapter.to_ruby(Bolt::Connection.metadata(bolt_connection))
+            @result_available_after = metadata[:result_available_after] || metadata[:t_first]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class SessionPullAllResponseHandler < PullAllResponseHandler
+          def initialize(statement, run_handler, connection, bookmarks_holder, metadata_extractor)
+            super(statement, run_handler, connection, metadata_extractor)
+            @bookmarks_holder = bookmarks_holder
+          end
+
+          def after_success(metadata)
+            @bookmarks_holder.bookmarks = connection.last_bookmark
+            release_connection
+            # @bookmarks_holder.bookmarks = @metadata_extractor.extract_bookmarks(metadata)
+          end
+
+          def after_failure(_error)
+            release_connection
+          end
+
+          private
+
+          def release_connection
+            connection.release
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class TransactionPullAllResponseHandler < PullAllResponseHandler
+          def initialize(statement, run_handler, connection, tx, metadata_extractor)
+            super(statement, run_handler, connection, metadata_extractor)
+            @tx = tx
+            @tx.chain run_handler, self
+          end
+
+          def after_success(_metadata); end
+
+          def after_failure(_error)
+            @tx.mark_terminated
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalDriver
+        extend AutoClosable
+        include ErrorHandling
+
+        attr_reader :session_factory
+        delegate :verify_connectivity, to: :session_factory
+        auto_closable :session
+
+        def initialize(session_factory, logger, resolver)
+          @session_factory = session_factory
+          @closed = Concurrent::AtomicBoolean.new(false)
+          # The below hold references to callbacks called from c,
+          # this prevents garbage collection before driver is garbage collected
+          @logger = logger
+          @resolver = resolver
+        end
+
+        def session(*args)
+          new_session(*Neo4j::Driver::Internal::RubySignature.session(args))
+        end
+
+        def close
+          session_factory.close if @closed.make_true
+          # Bolt::Connector.destroy(@connector)
+        end
+
+        private
+
+        def new_session(mode, bookmarks)
+          assert_open
+          session_factory.new_instance(mode, bookmarks)
+        end
+
+        def assert_open
+          raise Exceptions::IllegalStateException, 'This driver instance has already been closed' if @closed.true?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalLogger
+        include ErrorHandling
+
+        class << self
+          def register(bolt_config, logger)
+            return unless logger
+            new(bolt_config, logger)
+          end
+        end
+
+        def initialize(bolt_config, logger)
+          @logger = logger
+          @funcs = []
+          bolt_log = Bolt::Log.create(nil)
+          %i[error warning info debug].each do |method|
+            Bolt::Log.send("set_#{method}_func", bolt_log, func(method))
+          end
+          check_error Bolt::Config.set_log(bolt_config, bolt_log)
+        end
+
+        def func(method)
+          Proc.new { |_ptr, message| @logger.send(method, message) }.tap(&@funcs.method(:<<))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalRecord
+        attr_reader :keys, :values
+        delegate :first, to: :values
+
+        def initialize(keys, values)
+          @keys = keys
+          @values = values
+        end
+
+        def [](key)
+          field_index = key.is_a?(Integer) ? key : @keys.index(key.to_sym)
+          @values[field_index] if field_index
+        end
+
+        def to_h
+          keys.zip(values).to_h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalResolver
+        include ErrorHandling
+
+        class << self
+          def register(bolt_config, resolver)
+            return unless resolver
+            new(bolt_config, resolver)
+          end
+        end
+
+        def initialize(bolt_config, resolver)
+          @address_resolver_func = ->(_ptr, address, set) {
+            resolver.call(BoltServerAddress.new(Bolt::Address.host(address).first,
+                                                Bolt::Address.port(address).first.to_i)).each do |server_address|
+              bolt_address = Bolt::Address.create(server_address.host, server_address.port.to_s)
+              check_error Bolt::AddressSet.add(set, bolt_address)
+            end
+          }
+
+          address_resolver = Bolt::AddressResolver.create(nil, @address_resolver_func)
+          check_error Bolt::Config.set_address_resolver(bolt_config, address_resolver)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalStatementResult
+        include Enumerable
+
+        delegate :consume, :failure, :summary, :finalize, to: :@pull_all_handler
+
+        def initialize(run_handler, pull_all_handler)
+          @run_handler = run_handler
+          @pull_all_handler = pull_all_handler
+        end
+
+        def single
+          @pull_all_handler.next.tap do |record|
+            raise Exceptions::NoSuchRecordException.empty unless record
+            raise Exceptions::NoSuchRecordException.too_many if has_next?
+          end
+        end
+
+        def next
+          @pull_all_handler.next.tap do |record|
+            raise Exceptions::NoSuchRecordException.no_more unless record
+          end
+        end
+
+        def peek
+          @pull_all_handler.peek.tap do |record|
+            raise Exceptions::NoSuchRecordException.no_peek_past unless record
+          end
+        end
+
+        def has_next?
+          @pull_all_handler.peek
+        end
+
+        def each
+          yield @pull_all_handler.next while has_next?
+        end
+
+        def keys
+          @keys ||= begin
+            @pull_all_handler.peek
+            @pull_all_handler.statement_keys
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/messaging/bolt_protocol.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Messaging
+        module BoltProtocol
+          def self.for_version(version)
+            case version
+            when V1::BoltProtocolV1::VERSION
+              V1::BoltProtocolV1::INSTANCE
+            when V2::BoltProtocolV2::VERSION
+              V2::BoltProtocolV2::INSTANCE
+            when V3::BoltProtocolV3::VERSION
+              V3::BoltProtocolV3::INSTANCE
+            else
+              raise Exceptions::ClientException, "Unknown protocol version: #{version}"
+            end
+          end
+        end
+      end
+    end
+  end
+end