arangorb3 0.0.10

data/lib/Index.rb

@@ -0,0 +1,126 @@
+  # === INDEXES ===
+
+module Arango
+  class Index
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Collection_Return
+
+    def self.new(*args)
+      hash = args[0]
+      super unless hash.is_a?(Hash)
+      collection = hash[:collection]
+      if collection.is_a?(Arango::Collection) && collection.database.server.active_cache && !hash[:id].nil?
+        cache_name = "#{collection.database.name}/#{collection.name}/#{hash[:id]}"
+        cached = collection.database.server.cache.cache.dig(:index, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:type, :sparse, :unique, :fields, :deduplicate, :geoJson,
+            :minLength].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(collection:, body: {}, id: nil, type: "hash", unique: nil,
+      fields:, sparse: nil, geoJson: nil, minLength: nil, deduplicate: nil,
+      cache_name: 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]     ||= geoJson
+      body[:minLength]   ||= minLength
+
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_accessor :id, :unique, :fields, :key, :sparse, :geoJson, :minLenght,
+      :deduplicate, :cache_name
+    attr_reader :type, :database, :collection, :server
+
+    def type=(type)
+      satisfy_category?(type, ["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
+      @geoJson     = result[:geoJson]     || @geoJson
+      @minLength   = result[:minLength]   || @minLength
+      @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": @geoJson,
+        "minLength": @minLength,
+        "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":     @geoJson,
+        "minLength":   @minLength,
+        "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/Replication.rb

@@ -0,0 +1,237 @@
+# === REPLICATION ===
+
+module Arango
+  class Replication
+    include Arango::Helper_Error
+
+    def initialize(master:, slave:, includeSystem: true,
+      initialSyncMaxWaitTime: nil, incremental: nil,
+      restrictCollections: nil, connectTimeout: nil,
+      autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil,
+      requireFromPresent: nil, idleMaxWaitTime: nil, restrictType: nil,
+      maxConnectRetries: nil, adaptivePolling: nil,
+      connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil,
+      verbose: nil)
+      assign_master(master)
+      assign_slave(slave)
+      assign_restrictType(restrictType)
+      assign_restrictCollections(restrictCollections)
+      @includeSytem = includeSystem
+      @initialSyncMaxWaitTime = initialSyncMaxWaitTime,
+      @incremental = incremental
+      @connectTimeout = connectTimeout
+      @autoResync = autoResync
+      @idleMinWaitTime = idleMinWaitTime
+      @requestTimeout = requestTimeout
+      @requireFromPresent = requireFromPresent
+      @idleMaxWaitTime = idleMaxWaitTime
+      @maxConnectRetries = maxConnectRetries
+      @adaptivePolling = adaptivePolling
+      @connectionRetryWaitTime = connectionRetryWaitTime
+      @autoResyncRetries = autoResyncRetries
+      @chunkSize = chunkSize
+      @verbose = verbose
+    end
+
+    attr_accessor :endpoint, :username, :password, :includeSystem,
+      :initialSyncMaxWaitTime, :incremental, :verbose, :connectTimeout,
+      :autoResync, :idleMinWaitTime, :requestTimeout, :requireFromPresent,
+      :idleMaxWaitTime, :maxConnectRetries, :adaptivePolling,
+      :connectionRetryWaitTime, :autoResyncRetries, :chunkSize
+    attr_reader :master, :slave, :restrictType, :restrictCollections
+
+    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 restrictType=(restrictType)
+      satisfy_category?(restrictType, ["include", "exclude", nil])
+      @restrictType = restrictType
+    end
+    alias assign_restrictType restrictType=
+
+    def restrictCollections=(restrictCollections)
+      if restrictCollections.nil?
+        @restrictCollections = nil
+      else
+        satisfy_class?(restrictCollections, [Arango::Collection, String], true)
+        @restrictCollections = restrictCollections.map do |v|
+          case v
+          when String
+            v
+          when Arango::Collection
+            v.name
+          end
+        end
+      end
+    end
+    alias assign_restrictCollections restrictCollections=
+
+
+    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": {
+          "includeSytem": @includeSystem,
+          "initialSyncMaxWaitTime": @initialSyncMaxWaitTime,
+          "restrictType": @restrictType,
+          "incremental": @incremental,
+          "restrictCollections": @restrictCollections,
+          "verbose": @verbose,
+          "connectTimeout": @connectTimeout,
+          "autoResync": @autoResync,
+          "idleMinWaitTime": @idleMinWaitTime,
+          "requestTimeout": @requestTimeout,
+          "requireFromPresent": @requireFromPresent,
+          "idleMaxWaitTime": @idleMaxWaitTime,
+          "maxConnectRetries": @maxConnectRetries,
+          "adaptivePolling": @adaptivePolling,
+          "connectionRetryWaitTime": @connectionRetryWaitTime,
+          "autoResyncRetries": @autoResyncRetries,
+          "chunkSize": @chunkSize
+        }.delete_if{|k,v| v.nil?}
+      }
+    end
+
+# SYNCRONISATION
+
+    def sync
+      body = {
+        "username": @master_server.username,
+        "password": @master_server.password,
+        "endpoint": @master_server.endpoint,
+        "database": @master.name,
+        "restrictType":  @restrictType,
+        "incremental":   @incremental,
+        "includeSystem": @includeSystem,
+        "restrictCollections":    @restrictCollections,
+        "initialSyncMaxWaitTime": @initialSyncMaxWaitTime
+      }
+      @slave.request("PUT", "_api/replication/sync", body: body)
+    end
+
+# ENSLAVING
+
+    def enslave
+      body = {
+        "username": @master_server.username,
+        "password": @master_server.password,
+        "includeSystem": @includeSystem,
+        "endpoint":      @server.endpoint,
+        "initialSyncMaxWaitTime": @initialSyncMaxWaitTime,
+        "database":        @database.name,
+        "verbose":         verbose,
+        "connectTimeout":  @connectTimeout,
+        "autoResync":      @autoResync,
+        "idleMinWaitTime": @idleMinWaitTime,
+        "requestTimeout":  @requestTimeout,
+        "requireFromPresent": @requireFromPresent,
+        "idleMaxWaitTime":   @idleMaxWaitTime,
+        "restrictType":      @restrictType,
+        "maxConnectRetries": @maxConnectRetries,
+        "adaptivePolling":   @adaptivePolling,
+        "connectionRetryWaitTime": @connectionRetryWaitTime,
+        "restrictCollections":     @restrictCollections,
+        "autoResyncRetries": @autoResyncRetries,
+        "chunkSize":          @chunkSize
+      }
+      @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,
+        "endpoint": @master_server.endpoint,
+        "database": @master.name,
+        "verbose":  @verbose,
+        "autoResync": @autoResync,
+        "autoStart":  @autoStart,
+        "chunkSize":  @chunkSize,
+        "includeSystem":   @includeSystem,
+        "connectTimeout":  @connectTimeout,
+        "idleMinWaitTime": @idleMinWaitTime,
+        "requestTimeout":  @requestTimeout,
+        "restrictType":    @restrictType,
+        "requireFromPresent":      @requireFromPresent,
+        "idleMaxWaitTime":         @idleMaxWaitTime,
+        "maxConnectRetries":       @maxConnectRetries,
+        "adaptivePolling":         @adaptivePolling,
+        "initialSyncMaxWaitTime":  @initialSyncMaxWaitTime,
+        "connectionRetryWaitTime": @connectionRetryWaitTime,
+        "restrictCollections":     @restrictCollections,
+        "autoResyncRetries":       @autoResyncRetries
+      }
+      @slave.request("PUT", "_api/replication/applier-config", body: body)
+    end
+    alias modifyReplication modify
+
+    # LOGGER
+
+    def logger
+      @slave.request("GET", "_api/replication/logger-state")
+    end
+
+    def loggerFollow(from: nil, to: nil, chunkSize: nil, includeSystem: nil)
+      query = {
+        "from": from,
+        "to":   to,
+        "chunkSize":     chunkSize,
+        "includeSystem": includeSystem
+      }
+      @slave.request("GET", "_api/replication/logger-follow", query: query)
+    end
+
+    def loggerFirstTick
+      @slave.request("GET", "_api/replication/logger-first-tick", key: :firstTick)
+    end
+
+    def loggerRangeTick
+      @slave.request("GET", "_api/replication/logger-tick-ranges")
+    end
+
+    # SERVER-ID
+
+    def serverId
+      @slave.request("GET", "_api/replication/server-id", key: :serverId)
+    end
+  end
+end

data/lib/Request.rb

@@ -0,0 +1,143 @@
+module Arango
+  class Request
+    def initialize(return_output:, base_uri:, options:, verbose:, async:)
+      @return_output = return_output
+      @base_uri = base_uri
+      @options = options
+      @verbose = verbose
+      @async = async
+    end
+
+    attr_accessor :return_output, :base_uri, :options, :verbose, :async
+
+    def request(action, url, body: {}, headers: {}, query: {},
+      key: nil, return_direct_result: @return_output, skip_to_json: false,
+      keepNull: false, skip_parsing: false)
+      send_url = "#{@base_uri}/"
+      send_url += url
+
+      if body.is_a?(Hash)
+        body.delete_if{|k,v| v.nil?} unless keepNull
+      end
+      query.delete_if{|k,v| v.nil?}
+      headers.delete_if{|k,v| v.nil?}
+      options = @options.merge({body: body, query: query})
+      options[:headers].merge!(headers)
+
+      if ["GET", "HEAD", "DELETE"].include?(action)
+        options.delete(:body)
+      end
+
+      if @verbose
+        puts "\n===REQUEST==="
+        puts "#{action} #{send_url}\n"
+        puts JSON.pretty_generate(options)
+        puts "==============="
+      end
+
+      if !skip_to_json && !options[:body].nil?
+        options[:body] = Oj.dump(options[:body], mode: :json)
+      end
+      options.delete_if{|k,v| v.empty?}
+
+      begin
+        response = case action
+        when "GET"
+          HTTParty.get(send_url, options)
+        when "HEAD"
+          HTTParty.head(send_url, options)
+        when "PATCH"
+          HTTParty.patch(send_url, options)
+        when "POST"
+          HTTParty.post(send_url, options)
+        when "PUT"
+          HTTParty.put(send_url, options)
+        when "DELETE"
+          HTTParty.delete(send_url, options)
+        end
+      rescue Exception => e
+        raise Arango::Error.new err: :impossible_to_connect_with_database,
+          data: {"error": e.message}
+      end
+
+      if @verbose
+        puts "\n===RESPONSE==="
+        puts "CODE: #{response.code}"
+      end
+
+      case @async
+      when :store
+        val = response.headers["x-arango-async-id"]
+        if @verbose
+          puts val
+          puts "==============="
+        end
+        return val
+      when true
+        puts "===============" if @verbose
+        return true
+      end
+
+      if skip_parsing
+        val = response.parsed_response
+        if @verbose
+          puts val
+          puts "==============="
+        end
+        return val
+      end
+
+      begin
+        result = Oj.load(response.parsed_response, mode: :json, symbol_keys: true)
+      rescue Exception => e
+        raise Arango::Error.new err: :impossible_to_parse_arangodb_response,
+          data: {"response": response.parsed_response, "action": action, "url": send_url,
+            "request": JSON.pretty_generate(options)}
+      end
+
+      if @verbose
+        case result
+        when Hash, Array
+          puts JSON.pretty_generate(result)
+        else
+          puts "#{result}\n"
+        end
+        puts "==============="
+      end
+
+      case result
+      when Hash
+        if result[:error]
+          raise Arango::ErrorDB.new message: result[:errorMessage],
+            code: result[:code], data: result, errorNum: result[:errorNum],
+            action: action, url: send_url, request: options
+        elsif return_direct_result
+          return result
+        end
+      when Array, NilClass
+        return result
+      else
+        raise Arango::Error.new message: "ArangoRB didn't return a valid result",
+          data: {"response": response, "action": action, "url": send_url, "request": JSON.pretty_generate(options)}
+      end
+      return key.nil? ? result.delete_if{|k,v| k == :error || k == :code} : result[key]
+    end
+
+    def download(url:, path:, body: {}, headers: {}, query: {})
+      send_url = "#{@base_uri}/"
+      send_url += url
+      body.delete_if{|k,v| v.nil?}
+      query.delete_if{|k,v| v.nil?}
+      headers.delete_if{|k,v| v.nil?}
+      body = Oj.dump(body, mode: :json)
+      options = @options.merge({body: body, query: query, headers: headers, stream_body: true})
+      puts "\n#{action} #{send_url}\n" if @verbose
+      File.open(path, "w") do |file|
+        file.binmode
+        HTTParty.post(send_url, options) do |fragment|
+          file.write(fragment)
+        end
+      end
+    end
+  end
+end