neo4j-ruby-driver 0.1.1

data/ffi/bolt/structure.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Structure
+    extend Bolt::Library
+
+    attach_function :code, :BoltStructure_code, %i[pointer], :int16
+    attach_function :value, :BoltStructure_value, %i[pointer int32], :pointer
+  end
+end

data/ffi/bolt/value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Value
+    extend Bolt::Library
+
+    enum :bolt_type,
+         %i[bolt_null
+            bolt_boolean
+            bolt_integer
+            bolt_float
+            bolt_string
+            bolt_dictionary
+            bolt_list
+            bolt_bytes
+            bolt_structure]
+
+    attach_function :create, :BoltValue_create, [], :auto_pointer
+    attach_function :destroy, :BoltValue_destroy, %i[pointer], :void
+    attach_function :duplicate, :BoltValue_duplicate, %i[pointer], :auto_pointer
+    attach_function :copy, :BoltValue_copy, %i[pointer pointer], :void
+    attach_function :size, :BoltValue_size, %i[pointer], :int32
+    attach_function :type, :BoltValue_type, %i[pointer], :bolt_type
+    attach_function :to_string, :BoltValue_to_string, %i[pointer pointer int32 pointer], :int32
+    attach_function :format_as_null, :BoltValue_format_as_Null, %i[pointer], :void
+    attach_function :format_as_boolean, :BoltValue_format_as_Boolean, %i[pointer char], :void
+    attach_function :format_as_integer, :BoltValue_format_as_Integer, %i[pointer int64], :void
+    attach_function :format_as_float, :BoltValue_format_as_Float, %i[pointer double], :void
+    attach_function :format_as_string, :BoltValue_format_as_String, %i[pointer string int32], :void
+    attach_function :format_as_dictionary, :BoltValue_format_as_Dictionary, %i[pointer int32], :void
+    attach_function :format_as_list, :BoltValue_format_as_List, %i[pointer int32], :void
+    attach_function :format_as_bytes, :BoltValue_format_as_Bytes, %i[pointer string int32], :void
+    attach_function :format_as_structure, :BoltValue_format_as_Structure, %i[pointer int16 int32], :void
+  end
+end

data/ffi/bolt/values_private.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Bolt
+  module ValuesPrivate
+    extend FFI::Library
+
+    typedef :pointer, :bolt_value
+    # typedef BoltData, :bolt_data
+    # typedef BoltExtendedValue, :bolt_extended_value
+    #
+    # class BoltValue < FFI::Struct
+    #   layout :type, :int16,
+    #          :subtype, :int16,
+    #          :size, :int16,
+    #          :data_size, :uint64,
+    #          :data, :bolt_data
+    # end
+    #
+    # class BoltData < FFI::Union
+    #   layout :as_char, [:char, 16],
+    #          :as_uint32, [:uint32, 4],
+    #          :as_int8, [:int8_t, 16],
+    #          :as_int16, [:int16, 8],
+    #          :as_int32, [:int32, 4],
+    #          :as_int64, [:int64, 2],
+    #          :as_double, [:double, 2],
+    #          :extended, :bolt_extended_value
+    # end
+
+    class BoltExtendedValue < FFI::Union
+      layout :as_ptr, :pointer,
+             :as_char, :string,
+             :as_value, :bolt_value
+    end
+  end
+end

data/ffi/neo4j/driver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Workaround for missing zeitwerk support in jruby-9.2.7.0
+if RUBY_PLATFORM.match?(/java/)
+  module Bolt
+  end
+  module Neo4j
+    module Driver
+      module Internal
+        module Async
+        end
+        module Handlers
+        end
+        module Messaging
+          module V1
+          end
+          module V2
+          end
+          module V3
+          end
+        end
+        module Summary
+        end
+        module Util
+        end
+        module Value
+        end
+      end
+      module Summary
+      end
+      module Types
+      end
+    end
+  end
+end
+# End workaround
+
+require 'active_support/concern'
+require 'active_support/core_ext/array/grouping'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_reference'
+require 'ffi'
+require 'loader'
+require 'recursive-open-struct'
+Loader.load

data/ffi/neo4j/driver/access_mode.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module AccessMode
+      WRITE = 0
+      READ = 1
+    end
+  end
+end

data/ffi/neo4j/driver/auth_tokens.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class AuthTokens
+      class << self
+        def basic(username, password)
+          Bolt::Auth.basic(username, password, nil)
+        end
+
+        def none
+          Bolt::Auth.none
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class Config
+      class TrustStrategy
+        def self.trust_all_certificates; end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/graph_database.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class GraphDatabase
+      Bolt::Lifecycle.startup
+
+      at_exit do
+        Bolt::Lifecycle.shutdown
+      end
+
+      class << self
+        extend AutoClosable
+
+        auto_closable :driver
+
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = {})
+          config ||= Config.default_config
+          # routing_settings = config.routing_settings
+          # retry_settings = config.retry_settings
+          routing_settings = nil
+          retry_settings = nil
+
+          Internal::DriverFactory.new.new_instance(uri, auth_token, routing_settings, retry_settings, config)
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/async/access_mode_connection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Async
+        class AccessModeConnection
+          attr_reader :connection, :mode
+          delegate :open?, :protocol, :release, :reset, :write_and_flush, to: :connection
+
+          def initialize(connection, mode)
+            @connection = connection
+            @mode = mode
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/async/direct_connection.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Async
+        class DirectConnection
+          include ErrorHandling
+
+          attr_reader :protocol
+          attr_reader :bolt_connection
+
+          def initialize(connector, mode)
+            @connector = connector
+            @bolt_connection = with_status { |status| Bolt::Connector.acquire(@connector, mode, status) }
+
+            # @protocol = Messaging::BoltProtocol.for_version(Bolt::Connection.server(bolt_connection).first)
+            @protocol = Messaging::BoltProtocol.for_version(3)
+            @status = Concurrent::AtomicReference.new(:open)
+          end
+
+          def write_and_flush(statement, parameters, boomarks_holder, config, run_handler, pull_handler)
+            check_error Bolt::Connection.clear_run(bolt_connection)
+            check_error Bolt::Connection.set_run_cypher(bolt_connection, statement, statement.size, parameters.size)
+            parameters.each_with_index do |(name, object), index|
+              name = name.to_s
+              Value::ValueAdapter.to_neo(
+                Bolt::Connection.set_run_cypher_parameter(bolt_connection, index, name, name.size), object
+              )
+            end
+            set_bookmarks(:set_run_bookmarks, boomarks_holder.bookmarks)
+            register(run_handler, Bolt::Connection.load_run_request(bolt_connection))
+            register(pull_handler, Bolt::Connection.load_pull_request(bolt_connection, -1))
+            flush
+          end
+
+          def flush
+            check_error Bolt::Connection.flush(bolt_connection)
+          end
+
+          def begin(bookmarks, config, begin_handler)
+            check_error Bolt::Connection.clear_begin(bolt_connection)
+            set_bookmarks(:set_begin_bookmarks, bookmarks)
+            register(begin_handler, Bolt::Connection.load_begin_request(bolt_connection))
+          end
+
+          def commit(handler)
+            register(handler, Bolt::Connection.load_commit_request(bolt_connection))
+            flush
+          end
+
+          def rollback(handler)
+            register(handler, Bolt::Connection.load_rollback_request(bolt_connection))
+            flush
+          end
+
+          def release
+            return unless @status.compare_and_set(:open, :terminated)
+            Bolt::Connector.release(@connector, bolt_connection)
+            @bolt_connection = nil
+          end
+
+          def open?
+            @status.get == :open
+          end
+
+          def last_bookmark
+            Bolt::Connection.last_bookmark(bolt_connection).first
+          end
+
+          private
+
+          def register(handler, error_code)
+            check_error(error_code)
+            handler.request = Bolt::Connection.last_request(bolt_connection)
+          end
+
+          def set_bookmarks(method, bookmarks)
+            return unless bookmarks.present?
+            value = Bolt::Value.create
+            Value::ValueAdapter.to_neo(value, bookmarks)
+            check_error Bolt::Connection.send(method, bolt_connection, value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module BookmarksHolder
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :bookmarks
+        end
+
+        def initialize
+          @bookmarks = []
+        end
+
+        def bookmarks=(bookmarks)
+          bookmarks = Array(bookmarks).select(&:present?)
+          @bookmarks = bookmarks if bookmarks.present?
+        end
+
+        NO_OP = Class.new do
+          include BookmarksHolder
+
+          def bookmarks=; end
+        end.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class DirectConnectionProvider
+        include ErrorHandling
+
+        def initialize(connector)
+          @connector = connector
+        end
+
+        def acquire_connection(mode)
+          Async::DirectConnection.new(@connector, mode)
+        end
+
+        def verify_connectivity
+          acquire_connection(AccessMode::READ).release
+        end
+
+        def close
+          Bolt::Connector.destroy(@connector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class DriverFactory
+        def new_instance(uri, auth_token, routing_settings, retry_settings, config)
+          connector = create_connector(uri, auth_token)
+          create_driver(uri, connector).tap(&:verify_connectivity)
+        end
+
+        private
+
+        def create_connector(uri, auth_token)
+          uri = URI(uri)
+          address = Bolt::Address.create(uri.host, uri.port.to_s)
+          config = Bolt::Config.create
+          Bolt::Config.set_user_agent(config, 'seabolt-cmake/1.7')
+          Bolt::Connector.create(address, auth_token, config)
+        end
+
+        def create_driver(uri, connector)
+          create_direct_driver(connector)
+        end
+
+        def create_direct_driver(connector)
+          connection_provider = DirectConnectionProvider.new(connector)
+          session_factory = create_session_factory(connection_provider)
+          InternalDriver.new(session_factory)
+        end
+
+        def create_session_factory(connection_provider, retry_logic = nil, config = nil)
+          SessionFactoryImpl.new(connection_provider, retry_logic, config)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module ErrorHandling
+        def check_error(error_code, status = nil, error_text = nil)
+          case error_code
+            # Identifies a successful operation which is defined as 0
+          when Bolt::Error::BOLT_SUCCESS # 0
+            nil
+            # Permission denied
+          when Bolt::Error::BOLT_PERMISSION_DENIED # 7
+            failure Exceptions::AuthenticationException.new(error_code, 'Permission denied')
+            # Connection refused
+          when Bolt::Error::BOLT_CONNECTION_REFUSED
+            failure Exceptions::ServiceUnavailableException.new(error_code, 'unable to acquire connection')
+          else
+            error_ctx = status && Bolt::Status.get_error_context(status)
+            failure Exceptions::Neo4jException.new(
+              error_code,
+              "#{error_text || 'Unknown Bolt failure'} (code: #{error_code.to_s(16)}, " \
+           "text: #{Bolt::Error.get_string(error_code)}, context: #{error_ctx})"
+            )
+          end
+        end
+
+        def on_failure(_error); end
+
+        def check_status(status)
+          check_error(Bolt::Status.get_error(status), status)
+        end
+
+        def with_status
+          status = Bolt::Status.create
+          yield status
+        ensure
+          check_status(status)
+        end
+
+        private
+
+        def failure(error)
+          on_failure(error)
+          raise error
+        end
+      end
+    end
+  end
+end