neospace 0.0.1 → 1.7.0

data/ffi/bolt/lifecycle.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Lifecycle
+    extend Bolt::Library
+    attach_function :startup, :Bolt_startup, [], :void
+    attach_function :shutdown, :Bolt_shutdown, [], :void
+  end
+end

data/ffi/bolt/list.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bolt
+  module List
+    extend Bolt::Library
+
+    attach_function :resize, :BoltList_resize, %i[pointer int32], :void
+    attach_function :value, :BoltList_value, %i[pointer int32], :pointer
+  end
+end

data/ffi/bolt/log.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Log
+    extend Bolt::Library
+
+    callback :log_func, %i[pointer string], :void
+
+    attach_function :create, :BoltLog_create, %i[pointer], :auto_pointer
+    attach_function :destroy, :BoltLog_destroy, %i[pointer], :void
+    attach_function :set_error_func, :BoltLog_set_error_func, %i[pointer log_func], :void
+    attach_function :set_warning_func, :BoltLog_set_warning_func, %i[pointer log_func], :void
+    attach_function :set_info_func, :BoltLog_set_info_func, %i[pointer log_func], :void
+    attach_function :set_debug_func, :BoltLog_set_debug_func, %i[pointer log_func], :void
+  end
+end

data/ffi/bolt/socket_options.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bolt
+  module SocketOptions
+    extend Bolt::Library
+
+    attach_function :create, :BoltSocketOptions_create, [], :auto_pointer
+    attach_function :destroy, :BoltSocketOptions_destroy, [:pointer], :void
+    attach_function :get_connect_timeout, :BoltSocketOptions_get_connect_timeout, [:pointer], :int32_t
+    attach_function :set_connect_timeout, :BoltSocketOptions_set_connect_timeout, %i[pointer int32_t], :int32_t
+    attach_function :get_keep_alive, :BoltSocketOptions_get_keep_alive, [:pointer], :int32_t
+    attach_function :set_keep_alive, :BoltSocketOptions_set_keep_alive, %i[pointer int32_t], :int32_t
+  end
+end

data/ffi/bolt/status.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Status
+    extend Bolt::Library
+    # Not connected
+    BOLT_CONNECTION_STATE_DISCONNECTED = 0
+    # Connected but not authenticated
+    BOLT_CONNECTION_STATE_CONNECTED = 1
+    # Connected and authenticated
+    BOLT_CONNECTION_STATE_READY = 2
+    # Recoverable failure
+    BOLT_CONNECTION_STATE_FAILED = 3
+    # Unrecoverable failure
+    BOLT_CONNECTION_STATE_DEFUNCT = 4
+
+    typedef :int32, :bolt_connection_state
+
+    attach_function :create, :BoltStatus_create, [], :auto_pointer
+    attach_function :destroy, :BoltStatus_destroy, [:pointer], :void
+    attach_function :get_state, :BoltStatus_get_state, [:pointer], :bolt_connection_state
+    attach_function :get_error, :BoltStatus_get_error, [:pointer], :int32
+    attach_function :get_error_context, :BoltStatus_get_error_context, [:pointer], :string
+  end
+end

data/ffi/bolt/string.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Bolt
+  module String
+    extend Bolt::Library
+
+    attach_function :get, :BoltString_get, [:pointer], :pointer
+  end
+end

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 pointer int32], :void
+    attach_function :format_as_structure, :BoltValue_format_as_Structure, %i[pointer int16 int32], :void
+  end
+end

data/ffi/neo4j/driver.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Workaround for missing zeitwerk support in jruby-9.2.8.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 Retry
+        end
+        module Summary
+        end
+        module Util
+        end
+        module Value
+        end
+      end
+      module Net
+      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 'fiddle'
+require 'loader'
+require 'recursive-open-struct'
+
+module Neo4j
+  module Driver
+  end
+end
+
+Loader.load
+
+Neo4j::Driver::Record = Neo4j::Driver::Internal::InternalRecord
+Neo4j::Driver::StatementResult = Neo4j::Driver::Internal::InternalStatementResult
+Neo4j::Driver::Transaction = Neo4j::Driver::Internal::ExplicitTransaction

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,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class AuthTokens
+      class << self
+        def basic(username, password)
+          Internal::Validator.require_non_nil_credentials!(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,40 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class Config < Hash
+      class TrustStrategy
+        class << self
+          def trust_all_certificates; end
+        end
+      end
+
+      class << self
+        # How can following Java config options be expressed in seabolt:
+        # withLeakedSessionsLogging
+        # withConnectionLivenessCheckTimeout
+        # withTrustStrategy TRUST_ALL_CERTIFICATES, TRUST_CUSTOM_CA_SIGNED_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATE
+        # and in the reverse what those seabolt options correspond to in java:
+        # BoltConfig_set_user_agent
+
+        def default_config
+          {
+             logger: ActiveSupport::Logger.new(STDOUT, level: ::Logger::ERROR), # :set_log
+             leaked_session_logging: false,
+             #connection_liveness_check_timeout: -1, # Not configured
+             max_connection_lifetime: 1.hour, # :set_max_connection_life_time
+             max_connection_pool_size: 100, #:set_max_pool_size
+             connection_acquisition_timeout: 1.minute, #:set_max_connection_acquisition_time
+             encryption: true, # :set_transport
+             trust_strategy: :trust_all_certificates,
+             connection_timeout: 30.seconds, # BoltSocketOptions_set_connect_timeout
+             max_transaction_retry_time: Internal::Retry::ExponentialBackoffRetryLogic::DEFAULT_MAX_RETRY_TIME,
+             #resolver: nil # :set_address_resolver
+             keep_alive: true, # BoltSocketOptions_set_keep_alive
+             # ???? BoltConfig_set_user_agent
+          }
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/graph_database.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class GraphDatabase
+      VALID_ROUTING_SCHEMES =
+        [Internal::DriverFactory::BOLT_ROUTING_URI_SCHEME, Internal::DriverFactory::NEO4J_URI_SCHEME].freeze
+
+      Bolt::Lifecycle.startup
+
+      at_exit do
+        Bolt::Lifecycle.shutdown
+      end
+
+      class << self
+        extend AutoClosable
+
+        auto_closable :driver, :routing_driver
+
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = nil)
+          unless auth_token.is_a? FFI::Pointer
+            raise Exceptions::AuthenticationException, 'Unsupported authentication token'
+          end
+          config = Config.default_config.merge(config || {})
+
+          Internal::DriverFactory.new.new_instance(uri, auth_token, config)
+        end
+
+        def routing_driver(routing_uris, auth_toke, config)
+          assert_routing_uris(routing_uris)
+
+          routing_uris.each do |uri|
+            return driver(uri, auth_toke, config)
+          rescue Exceptions::ServiceUnavailableException => e
+            # log.warn("Unable to create routing driver for URI: #{uri}", e)
+          end
+
+          raise Exceptions::ServiceUnavailableException, 'Failed to discover an available server'
+        end
+
+        private
+
+        def assert_routing_uris(uris)
+          scheme = (uris.map(&method(:URI)).map(&:scheme) - VALID_ROUTING_SCHEMES).first
+          return unless scheme
+          raise ArgumentError,
+                "Illegal URI scheme, expected URI scheme '#{scheme}' to be among '[#{VALID_ROUTING_SCHEMES.join ', '}]'"
+        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,106 @@
+# 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, config)
+            @connector = connector
+            @config = config
+            @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)
+            set_config(:set_run, config)
+            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)
+            set_config(:set_begin, config)
+            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.force_encoding(Encoding::UTF_8)
+          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
+
+          def set_config(method_prefix, config)
+            return unless config
+            config.each do |key, value|
+              case key
+              when :timeout
+                check_error Bolt::Connection.send("#{method_prefix}_tx_timeout", bolt_connection,
+                                                  DurationNormalizer.milliseconds(value))
+              when :metadata
+                bolt_value = Bolt::Value.create
+                Value::ValueAdapter.to_neo(bolt_value, value)
+                check_error Bolt::Connection.send("#{method_prefix}_tx_metadata", bolt_connection, bolt_value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end