neo4j-ruby-driver 1.7.6 → 4.4.0.alpha.1

data/ruby/neo4j/driver/internal/messaging/request/discard_message.rb

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class DiscardMessage < AbstractStreamingMessage
+          SIGNATURE = 0x2F
+
+          def self.new_discard_all_message(id)
+            new(STREAM_LIMIT_UNLIMITED, id)
+          end
+
+          def name
+            "DISCARD"
+          end
+
+          def signature
+            SIGNATURE
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/goodbye_message.rb

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class GoodbyeMessage
+          SIGNATURE = 0x02
+          GOODBYE = new
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "GOODBYE"
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/hello_message.rb

@@ -0,0 +1,31 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class HelloMessage < MessageWithMetadata
+          SIGNATURE = 0x01
+          USER_AGENT_METADATA_KEY = :user_agent
+          ROUTING_CONTEXT_METADATA_KEY = :routing
+
+          def initialize(user_agent, auth_token, routing_context)
+            super(build_metadata(user_agent, auth_token, routing_context))
+          end
+
+          def to_s
+            metadata_copy = metadata.merge(Security::InternalAuthToken::CREDENTIALS_KEY => '******')
+            "HELLO #{metadata_copy}"
+          end
+
+          private
+
+          def build_metadata(user_agent, auth_token, routing_context)
+            auth_token.merge(
+              USER_AGENT_METADATA_KEY => user_agent,
+              ROUTING_CONTEXT_METADATA_KEY => routing_context
+            ).compact
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/init_message.rb

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class InitMessage < Struct.new(:user_agent, :auth_token)
+          SIGNATURE = 0x01
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "INIT \"#{user_agent}\" {...}"
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/message_with_metadata.rb

@@ -0,0 +1,10 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class MessageWithMetadata < Struct.new(:metadata)
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/multi_database_util.rb

@@ -0,0 +1,26 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class MultiDatabaseUtil
+          class << self
+            def assert_empty_database_name(database_name, bolt_version)
+              if database_name.database_name.present?
+                raise Exceptions::ClientException, "Database name parameter for selecting database is not supported in Bolt Protocol Version #{bolt_version}. Database name: '#{database_name.description}'"
+              end
+            end
+
+            def supports_multi_database(connection)
+              connection.server_version >= Util::ServerVersion::V4_0_0 &&
+                connection.protocol.version >= V4::BoltProtocolV4::VERSION
+            end
+
+            def supports_route_message(connection)
+              connection.protocol.version >= V43::BoltProtocolV43::VERSION
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/pull_all_message.rb

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        # PULL_ALL request message
+        # <p>
+        # Sent by clients to pull the entirety of the remaining stream down.
+        class PullAllMessage
+          SIGNATURE = 0x3F
+          PULL_ALL = new
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            'PULL_ALL'
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/pull_message.rb

@@ -0,0 +1,22 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        # PULL request message
+        # <p>
+        # Sent by clients to pull the entirety of the remaining stream down.
+        class PullMessage < AbstractStreamingMessage
+          SIGNATURE = 0x3F
+
+          def name
+            "PULL"
+          end
+
+          def signature
+            SIGNATURE
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/reset_message.rb

@@ -0,0 +1,32 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        # RESET request message
+        # <p>
+        # Sent by clients to reset a session to a clean state - closing any open transaction or result streams.
+        # This also acknowledges receipt of failures sent by the server. This is required to
+        # allow optimistic sending of multiple messages before responses have been received - pipelining.
+        # <p>
+        # When something goes wrong, we want the server to stop processing our already sent messages,
+        # but the server cannot tell the difference between what was sent before and after we saw the
+        # error.
+        # <p>
+        # This message acts as a barrier after an error, informing the server that we've seen the error
+        # message, and that messages that follow this one are safe to execute.
+        class ResetMessage
+          SIGNATURE = 0x0F
+          RESET = new
+
+          def to_s
+            'RESET'
+          end
+
+          def signature
+            SIGNATURE
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/rollback_message.rb

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class RollbackMessage
+          SIGNATURE = 0x13
+          ROLLBACK = new
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            'ROLLBACK'
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/route_message.rb

@@ -0,0 +1,33 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        # From the application point of view it is not interesting to know about the role a member plays in the cluster. Instead, the application needs to know which
+        # instance can provide the wanted service.
+        # <p>
+        # This message is used to fetch this routing information.
+        class RouteMessage < Struct.new(:routing_context, :bookmark, :database_name, :impersonated_user)
+          SIGNATURE = 0x66
+
+          # Constructor
+
+          # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
+          # @param bookmark         The bookmark used when getting the routing table.
+          # @param databaseName     The name of the database to get the routing table for.
+          # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
+          def initialize(routing_context, bookmark, database_name, impersonated_user)
+            super(routing_context.freeze, bookmark, database_name, impersonated_user)
+          end
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "ROUTE #{values.join(' ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/run_message.rb

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        # RUN request message
+        # <p>
+        # Sent by clients to start a new Tank job for a given query and
+        # parameter set.
+        class RunMessage < Struct.new(:query, :parameters)
+          SIGNATURE = 0x10
+
+          def signature
+            SIGNATURE
+          end
+
+          def to_s
+            "RUN \"#{query}\" #{parameters}"
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/run_with_metadata_message.rb

@@ -0,0 +1,47 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class RunWithMetadataMessage < MessageWithMetadata
+          SIGNATURE = 0x10
+          attr_reader :query, :parameters
+
+          class << self
+            def auto_commit_tx_run_message(query, config, database_name, mode, bookmark, impersonated_user)
+              metadata = Request::TransactionMetadataBuilder.build_metadata(
+                tx_timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+                bookmark: bookmark, impersonated_user: impersonated_user)
+              new(query.text, query.parameters, metadata)
+            end
+
+            def unmanaged_tx_run_message(query)
+              new(query.text, query.parameters, {})
+            end
+          end
+
+          def initialize(query, parameters, metadata)
+            super(metadata)
+            @query = query
+            @parameters = parameters
+          end
+
+          def signature
+            SIGNATURE
+          end
+
+          def eql?(other)
+            super && query.eql?(other.query) && parameters.eql?(other.parameters)
+          end
+
+          def hash
+            [query, parameters, metadata].hash
+          end
+
+          def to_s
+            "RUN \"#{query}\" #{parameters} #{metadata}"
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/request/transaction_metadata_builder.rb

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Request
+        class TransactionMetadataBuilder
+          MODE_READ_VALUE = 'r'
+
+          class << self
+            def build_metadata(tx_timeout:, tx_metadata:, mode:, bookmark:, impersonated_user:,
+                               database_name: DatabaseNameUtil.default_database)
+              { bookmarks: bookmark.presence,
+                tx_timeout: tx_timeout,
+                tx_metadata: tx_metadata.presence,
+                mode: (MODE_READ_VALUE if mode == AccessMode::READ),
+                db: database_name&.database_name,
+                imp_user: impersonated_user
+              }.compact
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/response/failure_message.rb

@@ -0,0 +1,40 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Response
+        # FAILURE response message
+        # <p>
+        # Sent by the server to signal a failed operation.
+        # Terminates response sequence.
+        class FailureMessage
+          SIGNATURE = 0x7F
+
+          attr_reader :code, :message
+
+          def initialize(code, message)
+            @code = code
+            @message = message
+          end
+
+          def to_s
+            "FAILURE #{code} \"#{message}\""
+          end
+
+          def equals(object)
+            return true if self == object
+
+            return false if object.nil? || self.class != object.class
+
+            !(!code.nil? ? !code.equals(object.code) : !object.code.nil?) && !(!message.nil? ? !message.equals(object.message) : !object.message.nil?)
+          end
+
+          def hash_code
+            result = !code.nil? ? code.hash_code : 0
+            result = 31 * result + (!message.nil? ? message.hash_code : 0)
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/response/ignored_message.rb

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Response
+        # IGNORED response message
+
+        # <p>
+        # Sent by the server to signal that an operation has been ignored.
+        # Terminates response sequence.
+        class IgnoredMessage
+          SIGNATURE = 0x7E
+          IGNORED = new
+
+          def to_s
+            "IGNORED {}"
+          end
+
+          def equals(obj)
+            !obj.nil? && obj.class == self.class
+          end
+
+          def hash_code
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/response/record_message.rb

@@ -0,0 +1,33 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Response
+        class RecordMessage
+          SIGNATURE = 0x71
+
+          attr_reader :fields
+
+          def initialize(fields)
+            @fields = fields
+          end
+
+          def to_s
+            "RECORD #{fields}"
+          end
+
+          def equals(object)
+            return true if self == object
+
+            return false if object.nil? || self.class != object.class
+
+            fields == object.fields
+          end
+
+          def hash_code
+            java.util.Arrays.hash_code(fields)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/response/success_message.rb

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Response
+        # SUCCESS response message
+
+        # <p>
+        # Sent by the server to signal a successful operation.
+        # Terminates response sequence.
+        class SuccessMessage
+          SIGNATURE = 0x70
+
+          attr_reader :metadata
+
+          def initialize(metadata)
+            @metadata = metadata
+          end
+
+          def to_s
+            "SUCCESS #{metadata}"
+          end
+
+          def equals(obj)
+            !obj.nil? && obj.class == self.class
+          end
+
+          def hash_code
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -0,0 +1,79 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class BoltProtocolV3
+          VERSION = BoltProtocolVersion.new(3, 0)
+          INSTANCE = new
+          METADATA_EXTRACTOR = Util::MetadataExtractor.new(:t_first, :t_last)
+
+          def create_message_format
+            MessageFormatV3.new
+          end
+
+          def initialize_channel(channel, user_agent, auth_token, routing_context)
+            message = Request::HelloMessage.new(user_agent, auth_token,
+                                                (routing_context.to_map if routing_context.server_routing_enabled?))
+            handler = Handlers::HelloResponseHandler.new(channel, VERSION)
+
+            channel.message_dispatcher.enqueue(handler)
+            channel.write_and_flush(message)
+          end
+
+          def prepare_to_close_channel(channel)
+            message_dispatcher = Connection::ChannelAttributes.message_dispatcher(channel)
+
+            message = Request::GoodbyeMessage::GOODBYE
+            message_dispatcher.enqueue(Handlers::NoOpResponseHandler::INSTANCE)
+            channel.write_and_flush(message, channel.void_promise)
+
+            message_dispatcher.prepare_to_close_channel
+          end
+
+          def begin_transaction(connection, bookmark, config)
+            verify_database_name_before_transaction(connection.database_name)
+            begin_message = Request::BeginMessage.new(bookmark, config, connection.database_name, connection.mode, connection.impersonated_user)
+            connection.write_and_flush(begin_message, Handlers::BeginTxResponseHandler.new)
+          end
+
+          def commit_transaction(connection, bookmark_holder)
+            connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(bookmark_holder))
+          end
+
+          def rollback_transaction(connection)
+            connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new)
+          end
+
+          def run_in_auto_commit_transaction(connection, query, bookmark_holder, config, fetch_size)
+            verify_database_name_before_transaction(connection.database_name)
+
+            run_message = Request::RunWithMetadataMessage.auto_commit_tx_run_message(query, config, connection.database_name, connection.mode, bookmark_holder.bookmark, connection.impersonated_user)
+
+            build_result_cursor_factory(connection, query, bookmark_holder, nil, run_message, fetch_size)
+          end
+
+          def run_in_unmanaged_transaction(connection, query, tx, fetch_size)
+            run_message = Request::RunWithMetadataMessage.unmanaged_tx_run_message(query)
+            build_result_cursor_factory(connection, query, BookmarkHolder::NO_OP, tx, run_message, fetch_size)
+          end
+
+          def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, ignored)
+            run_future = java.util.concurrent.CompletableFuture.new
+            run_handler = Handlers::RunResponseHandler.new(run_future, METADATA_EXTRACTOR, connection, tx)
+            pull_handler = Handlers::PullHandlers.new_bolt_v3_pull_all_handler(query, run_handler, connection, bookmark_holder, tx)
+
+            Cursor::AsyncResultCursorOnlyFactory.new(connection, run_message, run_handler, run_future, pull_handler)
+          end
+
+          def verify_database_name_before_transaction(database_name)
+            Request::MultiDatabaseUtil.assert_empty_database_name(database_name, VERSION)
+          end
+
+          def version
+            self.class::VERSION
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v3/message_format_v3.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class MessageFormatV3
+          def new_writer(output)
+            MessageWriterV3.new(output)
+          end
+
+          def new_reader(input)
+            Common::CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v3/message_writer_v3.rb

@@ -0,0 +1,32 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V3
+        class MessageWriterV3 < AbstractMessageWriter
+          def initialize(output)
+            super(Common::CommonValuePacker.new(output), build_encoders)
+          end
+
+          private
+
+          def build_encoders
+            result = Util::Iterables.new_hash_map_with_size(9)
+            result.put(Request::HelloMessage::SIGNATURE, Encode::HelloMessageEncoder.new)
+            result.put(Request::GoodbyeMessage::SIGNATURE, Encode::GoodbyeMessageEncoder.new)
+
+            result.put(Request::RunWithMetadataMessage::SIGNATURE, Encode::RunWithMetadataMessageEncoder.new)
+            result.put(Request::DiscardAllMessage::SIGNATURE, Encode::DiscardAllMessageEncoder.new)
+            result.put(Request::PullAllMessage::SIGNATURE, Encode::PullAllMessageEncoder.new)
+
+            result.put(Request::BeginMessage::SIGNATURE, Encode::BeginMessageEncoder.new)
+            result.put(Request::CommitMessage::SIGNATURE, Encode::CommitMessageEncoder.new)
+            result.put(Request::RollbackMessage::SIGNATURE, Encode::RollbackMessageEncoder.new)
+            result.put(Request::ResetMessage::SIGNATURE, Encode::ResetMessageEncoder.new)
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/v4/bolt_protocol_v4.rb

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V4
+        class BoltProtocolV4 < V3::BoltProtocolV3
+          VERSION = BoltProtocolVersion.new(4,0)
+          INSTANCE = new
+
+          def create_message_format
+            MessageFormatV4.new
+          end
+
+          def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, fetch_size)
+            run_handler = Handlers::RunResponseHandler.new(V3::BoltProtocolV3::METADATA_EXTRACTOR, connection, tx)
+
+            pull_all_handler = Handlers::PullHandlers.new_bolt_v4_auto_pull_handler(query, run_handler, connection, bookmark_holder, tx, fetch_size)
+            pull_handler = Handlers::PullHandlers.new_bolt_v4_basic_pull_handler(query, run_handler, connection, bookmark_holder, tx)
+
+            Cursor::ResultCursorFactoryImpl.new(connection, run_message, run_handler, pull_handler, pull_all_handler)
+          end
+
+          def verify_database_name_before_transaction(_database_name)
+            # Bolt V4.1 accepts database name
+          end
+        end
+      end
+    end
+  end
+end