neo4j-ruby-driver 0.1.1

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

@@ -0,0 +1,144 @@
+# 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)
+          self
+        rescue StandardError => e
+          @connection.release
+          raise e
+        end
+
+        def run(query, parameters = {})
+          ensure_can_run_queries
+          @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

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

@@ -0,0 +1,101 @@
+# 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)
+
+            # @records.clear
+            @failure = nil
+          end
+
+          def failure
+            # bolt_summary if connection.open?
+          end
+
+          def on_failure(error)
+            @finished = true
+            summary
+
+            after_failure(error)
+
+            @records.clear
+            @failure = error
+          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
+            @finished = true
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Handlers
+        class ResponseHandler
+          delegate :bolt_connection, to: :connection
+          attr_reader :connection
+          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
+              failure = Value::ValueAdapter.to_ruby(Bolt::Connection.failure(bolt_connection))
+              raise Exceptions::ClientException.new(failure[:code], failure[:message])
+            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))
+            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,41 @@
+# 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)
+          @session_factory = session_factory
+          @closed = Concurrent::AtomicBoolean.new(false)
+        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_record.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class InternalRecord
+        attr_reader :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_s)
+          @values[field_index] if field_index
+        end
+      end
+    end
+  end
+end