arango-driver 3.5.0.alpha0

data/lib/arango/helper/server_assignment.rb

@@ -0,0 +1,13 @@
+module Arango
+  module Helper
+    module ServerAssignment
+
+      protected
+
+      def assign_server(server)
+        satisfy_class?(server, [Arango::Server])
+        @server = server
+      end
+    end
+  end
+end

data/lib/arango/helper/traversal.rb

@@ -0,0 +1,12 @@
+module Arango
+  module Helper
+    module Traversal
+      def traversal(body: {}, direction: nil, edge_collection: nil, expander: nil, filter: nil, init: nil, item_order: nil, max_depth: nil,
+                    max_iterations: nil, min_depth: nil, order: nil, sort: nil, strategy: nil, uniqueness: nil, visitor: nil)
+        Arango::Traversal.new(body: body, direction: direction, edge_collection: edge_collection, expander: expander, filter: filter, init: init,
+                              item_order: item_order, max_depth: max_depth, max_iterations: max_iterations, min_depth: min_depth, order: order,
+                              sort: sort, strategy: strategy, uniqueness: uniqueness, vertex: self, visitor: visitor)
+      end
+    end
+  end
+end

data/lib/arango/index.rb

@@ -0,0 +1,103 @@
+  # === INDEXES ===
+
+module Arango
+  class Index
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::CollectionAssignment
+
+    def initialize(collection:, fields:, body: {}, cache_name: nil, deduplicate: nil, geo_json: nil, id: nil, min_length: nil, sparse: nil,
+                   type: "hash", unique: nil)
+      assign_collection(collection)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:index, cache_name, self)
+      end
+      body[:type]        ||= type
+      body[:id]          ||= id
+      body[:sparse]      ||= sparse
+      body[:unique]      ||= unique
+      body[:fields]      ||= fields.is_a?(String) ? [fields] : fields
+      body[:deduplicate] ||= deduplicate
+      body[:geoJson]     ||= geo_json
+      body[:minLength]   ||= min_length
+
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_accessor :cache_name, :deduplicate, :fields, :geo_json, :id, :key, :min_length, :sparse, :unique
+    attr_reader :collection, :database, :server, :type
+
+    def type=(type)
+      satisfy_category?(type, %w[hash skiplist persistent geo fulltext primary])
+      @type = type
+    end
+    alias assign_type type=
+
+    def body=(result)
+      @body        = result
+      @id          = result[:id] || @id
+      @key         = @id&.split("/")&.dig(1)
+      @type        = assign_type(result[:type] || @type)
+      @unique      = result[:unique]      || @unique
+      @fields      = result[:fields]      || @fields
+      @sparse      = result[:sparse]      || @sparse
+      @geo_json     = result[:geoJson]     || @geo_json
+      @min_length   = result[:minLength]   || @min_length
+      @deduplicate = result[:deduplicate] || @deduplicate
+      if @server.active_cache && @cache_name.nil?
+        @cache_name = "#{@database.name}/#{@collection.name}/#{@id}"
+        @server.cache.save(:index, @cache_name, self)
+      end
+    end
+    alias assign_attributes body=
+
+# === DEFINE ===
+
+    def to_h
+      {
+        key: @key,
+        id: @id,
+        body: @body,
+        type: @type,
+        sparse: @sparse,
+        unique: @unique,
+        fields: @fields,
+        idCache: @idCache,
+        geoJson: @geo_json,
+        minLength: @min_length,
+        deduplicate: @deduplicate,
+        collection: @collection.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+# === COMMANDS ===
+
+    def retrieve
+      result = @database.request("GET", "_api/index/#{@id}")
+      return_element(result)
+    end
+
+    def create
+      body = {
+        fields:      @fields,
+        unique:      @unique,
+        type:        @type,
+        id:          @id,
+        geoJson:     @geo_json,
+        minLength:   @min_length,
+        deduplicate: @deduplicate
+      }
+      query = { collection: @collection.name }
+      result = @database.request("POST", "_api/index", body: body, query: query)
+      return_element(result)
+    end
+
+    def destroy
+      result = @database.request("DELETE", "_api/index/#{@id}")
+      return_delete(result)
+    end
+  end
+end

data/lib/arango/replication.rb

@@ -0,0 +1,231 @@
+# === REPLICATION ===
+
+module Arango
+  class Replication
+    include Arango::Helper::Satisfaction
+
+    def initialize(master:, slave:, adaptive_polling: nil, auto_resync: nil, auto_resync_retries: nil, chunk_size: nil, connect_timeout: nil,
+                   connection_retry_wait_time: nil, idle_max_wait_time: nil, idle_min_wait_time: nil, include_system: true, incremental: nil,
+                   initial_sync_max_wait_time: nil, max_connect_retries: nil, request_timeout: nil, require_from_present: nil,
+                   restrict_collections: nil, restrict_type: nil, verbose: nil)
+      @adaptive_polling = adaptive_polling
+      @auto_resync = auto_resync
+      @auto_resync_retries = auto_resync_retries
+      @chunk_size = chunk_size
+      @connect_timeout = connect_timeout
+      @connection_retry_wait_time = connection_retry_wait_time
+      @idle_max_wait_time = idle_max_wait_time
+      @idle_min_wait_time = idle_min_wait_time
+      @include_system = include_system
+      @incremental = incremental
+      @initial_sync_max_wait_time = initial_sync_max_wait_time,
+      @max_connect_retries = max_connect_retries
+      @request_timeout = request_timeout
+      @require_from_present = require_from_present
+      @verbose = verbose
+      assign_master(master)
+      assign_restrict_collections(restrict_collections)
+      assign_restrict_type(restrict_type)
+      assign_slave(slave)
+    end
+
+    attr_accessor :adaptive_polling, :auto_resync, :auto_resync_retries, :chunk_size, :connect_timeout, :connection_retry_wait_time, :endpoint,
+                  :idle_max_wait_time, :idle_min_wait_time, :include_system, :incremental, :initial_sync_max_wait_time, :max_connect_retries,
+                  :password, :request_timeout, :require_from_present, :username, :verbose
+    attr_reader :master, :restrict_collections, :restrict_type, :slave
+
+    def master=(master)
+      satisfy_class?(master, [Arango::Database])
+      @master = master
+      @master_server = @master.server
+    end
+    alias assign_master master=
+
+    def slave=(slave)
+      satisfy_class?(slave, [Arango::Database])
+      @slave = slave
+      @slave_server = @slave.server
+    end
+    alias assign_slave slave=
+
+    def restrict_type=(restrict_type)
+      satisfy_category?(restrict_type, ["include", "exclude", nil])
+      @restrict_type = restrict_type
+    end
+    alias assign_restrict_type restrict_type=
+
+    def restrict_collections=(restrict_collections)
+      if restrict_collections.nil?
+        @restrict_collections = nil
+      else
+        satisfy_class?(restrict_collections, [Arango::Collection, String], true)
+        @restrict_collections = restrict_collections.map do |v|
+          case v
+          when String
+            v
+          when Arango::Collection
+            v.name
+          end
+        end
+      end
+    end
+    alias assign_restrict_collections restrict_collections=
+
+
+    def to_h
+      master
+      {
+        master: {
+          database: @master.name,
+          username: @master_server.username,
+          endpoint: @master_server.endpoint
+        },
+        slave: {
+          database: @slave.name,
+          username: @slave_server.username,
+          endpoint: @slave_server.endpoint
+        },
+        options: {
+          adaptivePolling: @adaptive_polling,
+          autoResync: @auto_resync,
+          autoResyncRetries: @auto_resync_retries,
+          chunkSize: @chunk_size,
+          connectionRetryWaitTime: @connection_retry_wait_time,
+          connectTimeout: @connect_timeout,
+          idleMaxWaitTime: @idle_max_wait_time,
+          idleMinWaitTime: @idle_min_wait_time,
+          includeSystem: @include_system,
+          incremental: @incremental,
+          initialSyncMaxWaitTime: @initial_sync_max_wait_time,
+          maxConnectRetries: @max_connect_retries,
+          requestTimeout: @request_timeout,
+          requireFromPresent: @require_from_present,
+          restrictCollections: @restrict_collections,
+          restrictType: @restrict_type,
+          verbose: @verbose
+        }.delete_if{|k,v| v.nil?}
+      }
+    end
+
+# SYNCRONISATION
+
+    def sync
+      body = {
+        username: @master_server.username,
+        password: @master_server.password,
+        database: @master.name,
+        endpoint: @master_server.endpoint,
+        includeSystem: @include_system,
+        incremental:   @incremental,
+        initialSyncMaxWaitTime: @initial_sync_max_wait_time,
+        restrictCollections:    @restrict_collections,
+        restrictType:  @restrict_type
+      }
+      @slave.request("PUT", "_api/replication/sync", body: body)
+    end
+
+# ENSLAVING
+
+    def enslave
+      body = {
+        username: @master_server.username,
+        password: @master_server.password,
+        database: @database.name,
+        endpoint: @server.endpoint,
+        adaptivePolling:   @adaptive_polling,
+        autoResync:        @auto_resync,
+        autoResyncRetries: @auto_resync_retries,
+        chunkSize:         @chunk_size,
+        connectionRetryWaitTime: @connection_retry_wait_time,
+        connectTimeout:    @connect_timeout,
+        idleMaxWaitTime:   @idle_max_wait_time,
+        idleMinWaitTime:   @idle_min_wait_time,
+        includeSystem:     @include_system,
+        initialSyncMaxWaitTime: @initial_sync_max_wait_time,
+        maxConnectRetries: @max_connect_retries,
+        requestTimeout:    @request_timeout,
+        requireFromPresent: @require_from_present,
+        restrictCollections: @restrict_collections,
+        restrictType:      @restrict_type,
+        verbose:           @verbose
+      }
+      @slave.request("PUT", "_api/replication/make-slave", body: body)
+    end
+
+# REPLICATION
+
+    def start(from: nil)
+      @slave.request("PUT", "_api/replication/applier-start", query: {from: from})
+    end
+
+    def stop
+      @slave.request("PUT", "_api/replication/applier-stop")
+    end
+
+    def state
+      @slave.request("GET", "_api/replication/applier-state")
+    end
+
+    def configuration
+      @slave.request("GET", "_api/replication/applier-config")
+    end
+
+    def modify
+      body = {
+        username: @master_server.username,
+        password: @master_server.password,
+        database: @master.name,
+        endpoint: @master_server.endpoint,
+        adaptivePolling:  @adaptive_polling,
+        autoResync: @auto_resync,
+        autoResyncRetries: @auto_resync_retries,
+        autoStart:  @auto_start, # TODO
+        chunkSize:  @chunk_size,
+        connectionRetryWaitTime: @connection_retry_wait_time,
+        connectTimeout:  @connect_timeout,
+        idleMaxWaitTime: @idle_max_wait_time,
+        idleMinWaitTime: @idle_min_wait_time,
+        includeSystem:   @include_system,
+        initialSyncMaxWaitTime: @initial_sync_max_wait_time,
+        maxConnectRetries: @max_connect_retries,
+        requestTimeout:  @request_timeout,
+        requireFromPresent: @require_from_present,
+        restrictCollections: @restrict_collections,
+        restrictType:    @restrict_type,
+        verbose:  @verbose
+      }
+      @slave.request("PUT", "_api/replication/applier-config", body: body)
+    end
+    alias modify_replication modify
+
+    # LOGGER
+
+    def logger
+      @slave.request("GET", "_api/replication/logger-state")
+    end
+
+    def logger_follow(from: nil, to: nil, chunk_size: nil, include_system: nil)
+      query = {
+        from: from,
+        to:   to,
+        chunkSize:     chunk_size,
+        includeSystem: include_system
+      }
+      @slave.request("GET", "_api/replication/logger-follow", query: query)
+    end
+
+    def logger_first_tick
+      @slave.request("GET", "_api/replication/logger-first-tick", key: :firstTick)
+    end
+
+    def logger_range_tick
+      @slave.request("GET", "_api/replication/logger-tick-ranges")
+    end
+
+    # SERVER-ID
+
+    def server_id
+      @slave.request("GET", "_api/replication/server-id", key: :serverId)
+    end
+  end
+end

data/lib/arango/request.rb

@@ -0,0 +1,92 @@
+module Arango
+  class Request
+    def initialize(base_uri:, options:)
+      @base_uri = base_uri
+      @default_options = options
+    end
+
+    attr_accessor :base_uri, :default_options
+
+    def request(get: nil, head: nil, patch: nil, post: nil, put: nil, delete: nil,
+                db: nil, body: {}, headers: nil, query: nil, keep_null: false, block: nil)
+      # TODO uri safety, '..', etc., maybe arango is guarded? not sure.
+
+      if body.class == Hash
+        body.delete_if{|_,v| v.nil?} unless keep_null
+        body = Oj.dump(body, mode: :json)
+      elsif body.class == Array
+        body = Oj.dump(body, mode: :json)
+      end
+
+      options = @default_options.merge({ body: body })
+
+      if query
+        query.delete_if{|_,v| v.nil?}
+        options[:params] = query
+      end
+
+      if headers
+        headers.delete_if{|_,v| v.nil?}
+        options[:headers] = {} unless options.key?(:headers)
+        options[:headers] = options[:headers].merge(headers)
+      end
+
+      options.delete_if{|_,v| v.nil? || v.empty?}
+
+      dbcontext = db ? "_db/#{db}/" : nil
+
+      #STDERR.puts "ROPTS #{options} P g #{get} u #{put} s #{post} d #{delete} c #{patch} h #{head}"
+
+      begin
+        response = if get then Typhoeus.get("#{@base_uri}/#{dbcontext}#{get}", options)
+                   elsif head then Typhoeus.head("#{@base_uri}/#{dbcontext}#{head}", options)
+                   elsif patch then Typhoeus.patch("#{@base_uri}/#{dbcontext}#{patch}", options)
+                   elsif post then Typhoeus.post("#{@base_uri}/#{dbcontext}#{post}", options)
+                   elsif put then Typhoeus.put("#{@base_uri}/#{dbcontext}#{put}", options)
+                   elsif delete then Typhoeus.delete("#{@base_uri}/#{dbcontext}#{delete}", options)
+                   end
+      rescue Exception => e
+        raise Arango::Error.new err: :impossible_to_connect_with_database, data: { error: e.message }
+      end
+
+      if headers && headers.key?("Content-Type") && headers["Content-Type"].start_with?("multipart/form-data")
+        return response.response_body
+      end
+
+      begin
+        json_result = unless response.response_body.empty?
+                        Oj.load(response.response_body, mode: :json, symbol_keys: true)
+                      else
+                        {}
+                      end
+        result = Arango::Result.new(json_result)
+        result.response_code = response.response_code
+      rescue Exception => e
+        raise Arango::Error.new err: :impossible_to_parse_arangodb_response,
+          data: { response: response.response_body, request: JSON.pretty_generate(options) }
+      end
+
+      if !result.is_array? && result.error?
+        raise Arango::ErrorDB.new(message: result.error_message, code: result.code, data: result.to_h, error_num: result.error_num, request: options)
+      end
+
+      block ? block.call(result) : result
+    end
+
+    def download(url:, path:, body: {}, headers: {}, query: {})
+      send_url = "#{@base_uri}/"
+      send_url += url
+      body.delete_if{|_,v| v.nil?}
+      query.delete_if{|_,v| v.nil?}
+      headers.delete_if{|_,v| v.nil?}
+      body = Oj.dump(body, mode: :json)
+      options = @default_options.merge({body: body, query: query, headers: headers, stream_body: true})
+      File.open(path, "w") do |file|
+        file.binmode
+        Typhoeus.post(send_url, options) do |fragment|
+          file.write(fragment)
+        end
+      end
+    end
+  end
+end