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

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

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

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

@@ -0,0 +1,33 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V4
+        class MessageWriterV4 < 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) # new
+            result.put(Request::PullMessage::SIGNATURE, Encode::PullMessageEncoder.new) # 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/v41/bolt_protocol_v41.rb

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

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

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

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V43
+        # Bolt message format v4.3
+        class MessageFormatV43
+          def new_writer(output)
+            MessageWriterV43.new(output)
+          end
+
+          def new_reader(input)
+            Common::CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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 < 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::RouteMessage::SIGNATURE, Encode::RouteMessageEncoder.new) # new
+
+            result.put(Request::DiscardMessage::SIGNATURE, Encode::DiscardMessageEncoder.new)
+            result.put(Request::PullMessage::SIGNATURE, Encode::PullMessageEncoder.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/v44/bolt_protocol_v44.rb

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

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V44
+        # Bolt message format v4.4
+        class MessageFormatV44
+          def new_writer(output)
+            MessageWriterV44.new(output)
+          end
+
+          def new_reader(input)
+            CommonMessageReader.new(input)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module V44
+        class MessageWriterV44 < AbstractMessageWriter
+          def initialize(output)
+            super(output, build_encoders)
+          end
+
+          private
+
+          def build_encoders
+            {
+              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
+              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
+              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
+              Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder.new,
+              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
+              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
+              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
+              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
+              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
+              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,82 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalMetrics
+        def initialize(logger)
+          @connection_pool_metrics = Concurrent::Map.new
+          @log = logger
+        end
+
+        def put_pool_metrics(pool_id, server_address, pool)
+          @connection_pool_metrics[pool_id] = InternalConnectionPoolMetrics.new(pool_id, server_address, pool)
+        end
+
+        def remove_pool_metrics(id)
+          @connection_pool_metrics.delete(id)
+        end
+
+        def before_creating(pool_id, creating_event)
+          pool_metrics(pool_id).before_creating(creating_event)
+        end
+
+        def after_created(pool_id, creating_event)
+          pool_metrics(pool_id).after_created(creating_event)
+        end
+
+        def after_failed_to_create(pool_id)
+          pool_metrics(pool_id).after_failed_to_create
+        end
+
+        def after_closed(pool_id)
+          pool_metrics(pool_id).after_closed
+        end
+
+        def before_acquiring_or_creating(pool_id, acquire_event)
+          pool_metrics(pool_id).before_acquiring_or_creating(acquire_event)
+        end
+
+        def after_acquiring_or_creating(pool_id)
+          pool_metrics(pool_id).after_acquiring_or_creating
+        end
+
+        def after_acquired_or_created(pool_id, acquire_event)
+          pool_metrics(pool_id).after_acquired_or_created(acquire_event)
+        end
+
+        def after_connection_created(pool_id, in_use_event)
+          pool_metrics(pool_id).acquired(in_use_event)
+        end
+
+        def after_connection_released(pool_id, in_use_event)
+          pool_metrics(pool_id).released(in_use_event)
+        end
+
+        def after_timed_out_to_acquire_or_create(pool_id)
+          pool_metrics(pool_id).after_timed_out_to_acquire_or_create
+        end
+
+        def create_listener_event
+          TimeRecorderListenerEvent.new
+        end
+
+        def connection_pool_metrics
+          @connection_pool_metrics.values.freeze
+        end
+
+        def to_s
+          "PoolMetrics=#{@connection_pool_metrics.each_pair.to_h}"
+        end
+
+        private
+
+        def pool_metrics(pool_id)
+          @connection_pool_metrics[pool_id] ||
+            begin
+              @log.warn("Failed to find pool metrics with id `#{pool_id}` in #{@connection_pool_metrics.each_pair.to_h}.")
+              ConnectionPoolMetricsListener::DEV_NULL_POOL_METRICS_LISTENER
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class InternalMetricsProvider
+        attr_reader :metrics
+        alias metrics_listener metrics
+
+        def initialize(logger)
+          @metrics = InternalMetrics.new(logger)
+        end
+
+        def metrics_enabled?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      module ListenerEvent
+        DEV_NULL_LISTENER_EVENT =
+          Class.new do
+            def start
+            end
+
+            def elapsed
+              0
+            end
+          end.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      module MetricsProvider
+        METRICS_DISABLED_PROVIDER =
+          Class.new do
+            def metrics
+              # To outside users, we forbidden their access to the metrics API
+              raise Exceptions::ClientException, "Driver metrics not enabled. To access driver metrics, you need to enabled driver metrics in the driver's configuration."
+            end
+
+            def metrics_listener
+              # Internally we can still register callbacks to this empty metrics listener.
+              InternalAbstractMetrics::DEV_NULL_METRICS
+            end
+
+            def metrics_enabled?
+              false
+            end
+          end.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class TimeRecorderListenerEvent
+        def start
+          @start_time = Util::Clock::System.millis
+        end
+
+        def elapsed
+          Util::Clock::System.millis - @start_time
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/byte_array_incompatible_packer.rb

@@ -0,0 +1,12 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      class ByteArrayIncompatiblePacker
+        include PackStream::Packer
+        def pack_bytes_header(_size)
+          raise PackStream::UnPackable.new('Packing bytes is not supported as the current server this driver connected to does not support unpack bytes.')
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_input.rb

@@ -0,0 +1,47 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      module PackInput
+        def read_char
+          read_exactly(1)
+        end
+
+        def read_byte
+          read_exactly(1).unpack1('c')
+        end
+
+        def read_ubyte
+          read_exactly(1).unpack1('C')
+        end
+
+        def read_short
+          read_exactly(2).unpack1('s>')
+        end
+
+        def read_ushort
+          read_exactly(2).unpack1('S>')
+        end
+
+        def read_int
+          read_exactly(4).unpack1('l>')
+        end
+
+        def read_uint
+          read_exactly(4).unpack1('L>')
+        end
+
+        def read_long
+          read_exactly(8).unpack1('q>')
+        end
+
+        def read_ulong
+          read_exactly(8).unpack1('Q>')
+        end
+
+        def read_double
+          read_exactly(8).unpack1('G')
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_output.rb

@@ -0,0 +1,39 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      module PackOutput
+        ## Produce a single byte
+        def write_byte(value)
+          value.is_a?(String) ? write(value) : write_value(value, 'c')
+        end
+
+        ## Produce a 4-byte signed integer
+        def write_short(value)
+          write_value(value, 's>')
+        end
+
+        ## Produce a 4-byte signed integer
+        def write_int(value)
+          write_value(value, 'l>')
+        end
+
+        ## Produce an 8-byte signed integer
+        def write_long(value)
+          write_value(value, 'q>')
+        end
+
+        ## Produce an 8-byte IEEE 754 "double format" floating-point number
+        def write_double(value)
+          write_value(value, 'G')
+        end
+
+        private
+
+        def write_value(value, directive)
+          write([value].pack(directive))
+          self
+        end
+      end
+    end
+  end
+end