neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

@@ -1,82 +0,0 @@
-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_h 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 = channel.message_dispatcher
-
-            message = Request::GoodbyeMessage::GOODBYE
-            message_dispatcher.enqueue(Handlers::NoOpResponseHandler::INSTANCE)
-            channel.write_and_flush(message)
-
-            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)
-            Util::ResultHolder.new.tap do |result_holder|
-              connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(result_holder))
-            end
-          end
-
-          def rollback_transaction(connection)
-            Util::ResultHolder.new.tap do |result_holder|
-              connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new(result_holder))
-            end
-          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_handler = Handlers::RunResponseHandler.new(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, 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

@@ -1,17 +0,0 @@
-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(new_value_unpacker(input))
-
-          def new_value_unpacker(input) = Async::Connection::StreamReader.new(input)
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V3
-        class MessageWriterV3 < AbstractMessageWriter
-          COMMON_ENCODERS = {
-            Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder,
-            Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder,
-            Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder,
-            Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder,
-            Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder,
-            Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder,
-            Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder,
-          }
-          private
-
-          def build_encoders
-            COMMON_ENCODERS.merge(
-              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder,
-              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder,
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-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

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

@@ -1,13 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V4
-        class MessageFormatV4 < V3::MessageFormatV3
-          def new_writer(output)
-            MessageWriterV4.new(output)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V4
-        class MessageWriterV4 < V3::MessageWriterV3
-          private
-
-          def build_encoders
-            COMMON_ENCODERS.merge(
-              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder,
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v41/bolt_protocol_v41.rb

@@ -1,25 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V41
-        class BoltProtocolV41 < V4::BoltProtocolV4
-          VERSION = BoltProtocolVersion.new(4, 1)
-          INSTANCE = new
-
-          def create_message_format
-            V4::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
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v42/bolt_protocol_v42.rb

@@ -1,13 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V42
-        # Bolt V4.2 is identical to V4.1
-        class BoltProtocolV42 < V41::BoltProtocolV41
-          VERSION = BoltProtocolVersion.new(4,2)
-          INSTANCE = new
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v43/bolt_protocol_v43.rb

@@ -1,19 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V43
-        # Definition of the Bolt Protocol 4.3
-
-        # The version 4.3 use most of the 4.2 behaviours, but it extends it with new messages such as ROUTE
-        class BoltProtocolV43 < V42::BoltProtocolV42
-          VERSION = BoltProtocolVersion.new(4,3)
-          INSTANCE = new
-
-          def create_message_format
-            MessageFormatV43.new
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v43/message_format_v43.rb

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V43
-        # Bolt message format v4.3
-        class MessageFormatV43 < V4::MessageFormatV4
-          def new_writer(output)
-            MessageWriterV43.new(output)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v43/message_writer_v43.rb

@@ -1,20 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V43
-
-        # Bolt message writer v4.3
-        # This version is able to encode all the versions existing on v4.2, but it encodes
-
-        # new messages such as ROUTE
-        class MessageWriterV43 < V4::MessageWriterV4
-          private
-
-          def build_encoders
-            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v44/bolt_protocol_v44.rb

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V44
-        # Definition of the Bolt Protocol 4.4
-        class BoltProtocolV44 < V43::BoltProtocolV43
-          VERSION = BoltProtocolVersion.new(4,4)
-          INSTANCE = new
-
-          def create_message_format
-            MessageFormatV44.new
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v44/message_format_v44.rb

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V44
-        # Bolt message format v4.4
-        class MessageFormatV44 < V43::MessageFormatV43
-          def new_writer(output)
-            MessageWriterV44.new(output)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v44/message_writer_v44.rb

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V44
-        class MessageWriterV44 < V4::MessageWriterV4
-          private
-
-          def build_encoders
-            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v5/bolt_protocol_v5.rb

@@ -1,21 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V5
-        # Definition of the Bolt Protocol 5.0
-        class BoltProtocolV5 < V44::BoltProtocolV44
-          VERSION = BoltProtocolVersion.new(5, 0)
-          INSTANCE = new
-
-          def create_message_format
-            MessageFormatV5.new
-          end
-
-          protected
-
-          def include_date_time_utc_patch_in_hello = false
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v5/message_format_v5.rb

@@ -1,18 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V5
-        # Bolt message format v5.0
-        class MessageFormatV5 < V44::MessageFormatV44
-          def new_writer(output)
-            output.date_time_utc_enabled = true
-            super
-          end
-          def new_value_unpacker(input)
-            ValueUnpackerV5.new(input)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v5/value_unpacker_v5.rb

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V5
-        class ValueUnpackerV5 < Async::Connection::StreamReader
-          alias unpack_element_id unpack
-
-          def node_fields = 4
-
-          def relationship_fields = 8
-
-          def unbound_relationship_fields = 4
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v51/bolt_protocol_v51.rb

@@ -1,40 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V51
-        class BoltProtocolV51 < V5::BoltProtocolV5
-          VERSION = BoltProtocolVersion.new(5, 1)
-          INSTANCE = new
-
-          def create_message_format
-            MessageFormatV51.new
-          end
-
-          def initialize_channel(channel, user_agent, auth_token, routing_context)
-            message = Request::HelloMessage.new(user_agent, {},
-                                                (routing_context.to_h if routing_context.server_routing_enabled?))
-            handler = Handlers::HelloV51ResponseHandler.new(channel, VERSION)
-
-            channel.message_dispatcher.enqueue(handler)
-            channel.write(message)
-            message = Request::LogonMessage(auth_token)
-            channel.message_dispatcher.enqueue(LogonResponseHandle.new(channel, auth_token))
-            channel.write_and_flush(message)
-          end
-
-          def logoff
-
-          end
-
-          def logon
-
-          end
-
-          def version
-            self.class::VERSION
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v51/message_format_v51.rb

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V51
-        # Bolt message format v4.4
-        class MessageFormatV51 < V5::MessageFormatV5
-          def new_writer(output)
-            MessageWriterV51.new(output)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/v51/message_writer_v51.rb

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module V51
-        class MessageWriterV51 < V44::MessageWriterV44
-          private
-
-          def build_encoders
-            super.merge(
-              LogonMessage.SIGNATURE => Encode::LogonMessageEncoder,
-              LogoffMessage.SIGNATURE => Encode::LogoffMessageEncoder)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/metrics/connection_pool_metrics_listener.rb

@@ -1,34 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Metrics
-      module ConnectionPoolMetricsListener
-        DEV_NULL_POOL_METRICS_LISTENER =
-          Class.new do
-            def before_creating(_listener_event) end
-
-            def after_created(_listener_event) end
-
-            def after_failed_to_create
-            end
-
-            def after_closed
-            end
-
-            def before_acquiring_or_creating(_acquire_event = nil) end
-
-            def after_acquiring_or_creating
-            end
-
-            def after_acquired_or_created(_acquire_event) end
-
-            def after_timed_out_to_acquire_or_create
-            end
-
-            def acquired(_in_use_event) end
-
-            def released(_in_use_event) end
-          end.new
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/metrics/internal_abstract_metrics.rb

@@ -1,46 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Metrics
-      class InternalAbstractMetrics
-        DEV_NULL_METRICS =
-          Class.new do
-            def before_creating(_pool_id, _creating_event) end
-
-            def after_created(_pool_id, _creating_event) end
-
-            def after_failed_to_create(_pool_id) end
-
-            def after_closed(_pool_id) end
-
-            def before_acquiring_or_creating(_pool_id, _acquire_event) end
-
-            def after_acquiring_or_creating(_pool_id) end
-
-            def after_acquired_or_created(_pool_id, _acquire_event) end
-
-            def after_timed_out_to_acquire_or_create(_pool_id) end
-
-            def after_connection_created(_pool_id, _in_use_event) end
-
-            def after_connection_released(_pool_id, _in_use_event) end
-
-            def create_listener_event
-              ListenerEvent::DEV_NULL_LISTENER_EVENT
-            end
-
-            def put_pool_metrics(_id, _address, _connection_pool) end
-
-            def remove_pool_metrics(_pool_id) end
-
-            def connection_pool_metrics
-              Set.new
-            end
-
-            def to_s
-              'Driver metrics not available while driver metrics is not enabled.'
-            end
-          end.new
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/metrics/internal_connection_pool_metrics.rb

@@ -1,105 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Metrics
-      class InternalConnectionPoolMetrics
-        attr_reader :id, :address, :pool
-
-        def initialize(pool_id, address, pool)
-          Internal::Validotor.require_non_nil!(address)
-          Internal::Validotor.require_non_nil!(pool)
-
-          @id = pool_id
-          @address = address
-          @pool = pool
-
-          @closed = Concurrent::AtomicFixnum.new
-
-          # creating = created + failedToCreate
-          @creating = Concurrent::AtomicFixnum.new
-          @created = Concurrent::AtomicFixnum.new
-          @failed_to_create = Concurrent::AtomicFixnum.new
-
-          # acquiring = acquired + timedOutToAcquire + failedToAcquireDueToOtherFailures (which we do not keep track)
-          @acquiring = Concurrent::AtomicFixnum.new
-          @acquired = Concurrent::AtomicFixnum.new
-          @timed_out_to_acquire = Concurrent::AtomicFixnum.new
-
-          @total_acquisition_time = Concurrent::AtomicFixnum.new
-          @total_connection_time = Concurrent::AtomicFixnum.new
-          @total_in_use_time = Concurrent::AtomicFixnum.new
-
-          @total_in_use_count = Concurrent::AtomicFixnum.new
-        end
-
-        def before_creating(conn_event)
-          @creating.increment
-          conn_event.start
-        end
-
-        def after_failed_to_create
-          @failed_to_create.increment
-          @creating.decrement_and_get
-        end
-
-        def after_created(conn_event)
-          @created.increment
-          @creating.decrement
-          elapsed = conn_event.elapsed
-
-          @total_connection_time.increment(elapsed)
-        end
-
-        def after_closed
-          @closed.increment
-        end
-
-        def before_acquiring_or_creating(acquire_event)
-          acquire_event.start
-          @acquiring.increment
-        end
-
-        def after_acquiring_or_creating
-          @acquiring.decrement
-        end
-
-        def after_acquired_or_created(acquire_event)
-          @acquired.increment
-          elapsed = acquire_event.elapsed
-          @total_acquisition_time.increment(elapsed)
-        end
-
-        def after_timed_out_to_acquire_or_create
-          @timed_out_to_acquire.increment
-        end
-
-        def acquired(in_use_event)
-          in_use_event.start
-        end
-
-        def released(in_use_event)
-          @total_in_use_count.increment
-          elapsed = in_use_event.elapsed
-
-          @total_in_use_time.increment(elapsed)
-        end
-
-        def in_use
-          @pool.in_use_connections(@address)
-        end
-
-        def idle
-          @pool.idle_connections(@address)
-        end
-
-        %i[creating created failed_to_create timed_out_to_acquire total_acquisition_time :total_connection_time
-        total_in_use_time total_in_use_count closed acquiring acquired].each do |method|
-          define_method(method) { instance_variable_get(method).value }
-        end
-
-        def to_s
-          "#{@id}[created=#{@created}, closed=#{@closed}, creating=#{@creating}, failed_to_create=#{@failed_to_create}, acquiring=#{@acquiring}, acquired=#{@acquired}, timed_out_to_acquire=#{@timed_out_to_acquire}, in_use=#{@in_use}, idle=#{@idle}, total_acquisition_time=#{@total_acquisition_time}, total_connection_time=#{@total_connection_time}, total_in_use_time=#{@total_in_use_time}, total_in_use_count=#{@totalInUseCount}]"
-        end
-      end
-    end
-  end
-end