arango-driver 3.5.0.alpha0

data/lib/arango/request_batch.rb

@@ -0,0 +1,174 @@
+module Arango
+  class RequestBatch
+    include Arango::Helper::Satisfaction
+    include Arango::Helper::Return
+    include Arango::Helper::DatabaseAssignment
+    include Arango::Helper::ServerAssignment
+
+    # Initialize a new request batch.
+    # Request must be a Hash with the keys:
+    # - :id, optional
+    # - :action, required
+    # - :url, required
+    # - :body, optional
+    # @param server [Arango::Server] The server the requests should be run on. One of server or database must be given.
+    # @param database [Arango::Database] The database the requests should be run on. One of server or database must be given.
+    # @param requests [Array<Hash>, Hash] Array of requests or a single request as Hash, optional.
+    # @return [Arango::RequestBatch]
+    def initialize(server: nil, database: nil, requests: [])
+      @id = 1
+      if database
+        assign_database(database)
+      elsif server
+        assign_server(server)
+      else
+        raise Arango::Error.new(err: :server_or_database_must_be_given)
+      end
+      send(:requests=, requests)
+      @boundary = "ArangoDriverRequestPart"
+      @headers = { 'Content-Type' => "multipart/form-data; boundary=#{@boundary}" }
+    end
+
+    attr_reader :database, :requests, :server
+
+    # Assign a bunch of requests.
+    # @param requests [Array<Hash>, Hash] Array of requests or a single request as Hash, optional.
+    # @return [Array<Hash>]
+    def requests=(requests)
+      requests = [requests] unless requests.is_a?(Array)
+      @requests = {}
+      requests.each do |request|
+        add_request(**request)
+      end
+      return @requests
+    end
+
+    # Add a single request
+    # @param id [String] optional
+    # @param action [String]
+    # @param url [String]
+    # @param body [Hash] optional
+    def add_request(get: nil, head: nil, patch: nil, post: nil, put: nil, delete: nil, body: nil, query: nil, headers: nil, block: nil, promise: nil)
+      id = @id.to_s
+      @id += 1
+      @requests[id] = {
+        id:     id,
+        body:   body,
+        query:  query,
+        block: block,
+        headers: headers,
+        promise: promise
+      }.delete_if{|_,v| v.nil?}
+      @requests[id][:action] = if get then @requests[id][:url] = get; 'GET'
+                               elsif head then @requests[id][:url] = head; 'HEAD'
+                               elsif patch then @requests[id][:url] = patch; 'PATCH'
+                               elsif post then @requests[id][:url] = post; 'POST'
+                               elsif put then @requests[id][:url] = put; 'PUT'
+                               elsif delete then @requests[id][:url] = delete; 'DELETE'
+                               end
+      @requests[id]
+    end
+    alias modify_request add_request
+
+    def delete_request(id)
+      @requests.delete(id)
+      @requests
+    end
+
+    # Execute the request batch.
+    # @return [Hash<Arango::Result]
+    def execute
+      body = ""
+      @requests.each do |id, request|
+        body << "--#{@boundary}\r\n"
+        body << "Content-Type: application/x-arango-batchpart\r\n"
+        body << "Content-Id: #{id}\r\n\r\n"
+        url = "/#{request[:url]}"
+        if request.key?(:query)
+          url << '?'
+          url << URI.encode_www_form(request[:query])
+        end
+        body << "#{request[:action]} #{url} HTTP/1.1\r\n"
+        if request.key?(:headers)
+          request[:headers].each do |header, value|
+            body << "#{header}: #{value}\r\n"
+          end
+        end
+        body << "\r\n"
+        unless request[:body].nil?
+          request[:body].delete_if{|_,v| v.nil?}
+          body << "#{Oj.dump(request[:body], mode: :json)}\r\n"
+        end
+      end
+      body << "--#{@boundary}--\r\n\r\n" if @requests.length > 0
+      result = if @database
+                 @database.request(post: '_api/batch', body: body, headers: @headers)
+               else
+                 @server.request(post: '_api/batch', body: body, headers: @headers)
+               end
+      result_hash = _parse_result(result)
+      _check_for_errors(result_hash)
+      final_result = result_hash
+      result_hash.each_key do |id|
+        request = @requests[id.to_s]
+        if request.key?(:block)
+          result = result_hash[id]
+          if request.key?(:promise)
+            block_result = request[:block].call(result)
+            final_result = request[:promise].resolve(block_result)
+          else
+            final_result = request[:block].call(result)
+          end
+        end
+      end
+      final_result
+    end
+
+    private
+
+    def _check_for_errors(result_hash)
+      result_hash.each do |k, result|
+        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,
+                                    action: '', url: '', request: { request_part: k })
+        end
+      end
+      result_hash
+    end
+
+    def _parse_result(result)
+      parts = result.split("--#{@boundary}")
+      result_hash = {}
+      parts.each do |part|
+        if part == "" || part == "--"
+          false
+        else
+          key = nil
+          is_json = false
+          body = nil
+          code = 0
+          lines = part.split("\r\n")
+          lines.each do |line|
+            if line.start_with?('Content-Id: ')
+              key = line[12..-1]
+            elsif line.start_with?('HTTP/1.1 ')
+              code = line[9..12].to_i
+            elsif line.start_with?('Content-Type: application/json')
+              is_json = true
+            elsif line.start_with?('{') || line.start_with?('[')
+              if is_json
+                body = Oj.load(line, mode: :json, smybol_keys: true)
+              else
+                body = line
+              end
+            end
+          end
+          res = Arango::Result.new(is_json ? body : { body: body })
+          res.response_code = code
+          result_hash[key.to_sym] = res
+        end
+      end
+      result_hash
+    end
+  end
+end

data/lib/arango/result.rb

@@ -0,0 +1,130 @@
+module Arango
+  class Result
+    def initialize(result)
+      @result = result ? result : {}
+      @is_array = @result.class == Array
+      @result.transform_keys!(&:to_sym) unless @is_array
+    end
+
+    attr_accessor :response_code
+
+    # standard fields
+    def code
+      return @result[:code] if @result.key?(:code)
+      nil
+    end
+
+    def error?
+      return @result[:error] if @result.key?(:error)
+      false
+    end
+
+    def error_message
+      return @result[:errorMessage] if @result.key?(:errorMessage)
+      nil
+    end
+    alias errorMessage error_message
+
+    def error_num
+      return @result[:errorNum] if @result.key?(:errorNum)
+      nil
+    end
+    alias errorNum error_num
+
+    # access to all other fields
+    def [](field_name_or_index)
+      return @result[field_name_or_index] if @is_array
+      field_name_y = field_name_or_index.to_sym
+      return @result[field_name_y] if @result.key?(field_name_y)
+      field_name_s = field_name_or_index.to_s
+      field_name_lcy = field_name_s.camelize(:lower).to_sym
+      return @result[field_name_lcy] if @result.key?(field_name_lcy)
+      field_name_ucy = field_name_s.camelize(:upper).to_sym
+      return @result[field_name_ucy] if @result.key?(field_name_ucy)
+      nil
+    end
+
+    def []=(field_name_or_index, value)
+      return @result[field_name_or_index] = value if @is_array
+      field_name_y = field_name_or_index.to_sym
+      return @result[field_name_y] = value if @result.key?(field_name_y)
+      field_name_s = field_name_or_index.to_s
+      field_name_lcy = field_name_s.camelize(:lower).to_sym
+      return @result[field_name_lcy] = value if @result.key?(field_name_lcy)
+      field_name_ucy = field_name_s.camelize(:upper).to_sym
+      return @result[field_name_ucy] = value if @result.key?(field_name_ucy)
+      nil
+    end
+
+    def method_missing(field_name_or_index, *args, &block)
+      return self[field_name_or_index] = args[0] if field_name_or_index.to_s.end_with?('=')
+      return self[field_name_or_index] if @is_array
+      field_name_or_index = field_name_or_index.to_sym
+      return self[field_name_or_index] if key?(field_name_or_index)
+      @result.send(field_name_or_index, *args, &block)
+    end
+
+    # convenience
+    def delete_if(*args, &block)
+      @result.delete_if(*args, &block)
+    end
+
+    def empty?
+      @result.empty?
+    end
+
+    def first
+      @result.first
+    end
+
+    def is_array?
+      @is_array
+    end
+
+    def key?(key)
+      return false if @is_array
+      field_name_y = key.to_sym
+      return true if @result.key?(field_name_y)
+      field_name_s = key.to_s
+      field_name_lcy = field_name_s.camelize(:lower).to_sym
+      return true if @result.key?(field_name_lcy)
+      field_name_ucy = field_name_s.camelize(:upper).to_sym
+      return true if @result.key?(field_name_ucy)
+      false
+    end
+    alias has_key? key?
+
+    def map(*args, &block)
+      @result.map(*args, &block)
+    end
+
+    def raw_result
+      @result
+    end
+
+    def to_underscored_h
+      hash = to_h
+      hash.transform_keys { |k| k.to_s.underscore }
+    end
+
+    def to_h
+      return @result unless @is_array
+      @result.to_h
+    end
+    alias to_hash to_h
+
+    def to_a
+      return @result if @is_array
+      @result.to_a
+    end
+
+    def to_ary
+      return @result.to_ary if @is_array
+      to_a
+    end
+
+    def to_s
+      @result.to_s
+    end
+  end
+end

data/lib/arango/search_view.rb

@@ -0,0 +1,23 @@
+module Arango
+  class SearchView
+    def initialize
+
+    end
+
+    def create
+    end
+
+    def properties
+
+    end
+
+    def properties=
+
+    end
+    alias replace_properties properties=
+
+    def update_properties
+
+    end
+  end
+end

data/lib/arango/server.rb

@@ -0,0 +1,68 @@
+# === SERVER ===
+
+module Arango
+  class Server
+    include Arango::Helper::Satisfaction
+
+    include Arango::Server::Administration
+    include Arango::Server::Config
+    include Arango::Server::Databases
+    include Arango::Server::Monitoring
+    include Arango::Server::Tasks
+    include Arango::Server::OpalSupport
+
+    # Connect to a ArangoDB server.
+    # @param username [String]
+    # @param password [String]
+    # @param host [String]
+    # @param port [String]
+    # @param tls [Boolean] Use TLS for the connection, optional, default: false.
+    # @return [Arango::Server]
+    def initialize(username: "root", password:, host: "localhost", warning: true, port: "8529", return_output: false, timeout: 5, tls: false)
+      @tls = tls
+      @host = host
+      @port = port
+      @username = username
+      @password = password
+      @options = { body: {}, headers: {}, query: {}, userpwd: "#{username}:#{password}" }
+      @return_output = return_output
+      @warning = warning
+      @active_cache = active_cache
+      @timeout = timeout
+      set_base_uri
+      @request = Arango::Request.new(base_uri: @base_uri, options: @options)
+    end
+
+    def endpoint
+      "tcp://#{@host}:#{@port}"
+    end
+
+    def request(*args)
+      @request.request(*args)
+    end
+
+    # Returns information about the currently running transactions.
+    # @return [Arango::Result]
+    def transactions
+      request(get: '_admin/wal/transactions')
+    end
+
+    # Check if transactions are running on server.
+    # @return [Boolean]
+    def transactions_running?
+      transactions.running_transactions > 0
+    end
+
+    private
+
+    def download(*args)
+      @request.download(*args)
+    end
+
+    def set_base_uri
+      @base_uri = "http"
+      @base_uri += "s" if @tls
+      @base_uri += "://#{@host}:#{@port}"
+    end
+  end
+end

data/lib/arango/server/administration.rb

@@ -0,0 +1,296 @@
+module Arango
+  class Server
+    module Administration
+      # Check availability of the server.
+      # @return [Boolean]
+      def available?
+        200 == request(get: '_admin/server/availability').code
+      end
+
+      # Returns information about all coordinator endpoints (cluster only).
+      # @return [Array<String>]
+      def cluster_endpoints
+        if in_cluster?
+          endpoints = request(get: "_api/cluster/endpoints").endpoints
+          endpoints.map { |e| e[:endpoint] }
+        end
+      end
+
+      # Returns information about all server endpoints.
+      # @return [Array<String>]
+      def endpoints
+        endpoints = request(get: "_api/endpoint")
+        endpoints.map { |e| e[:endpoint] }
+      end
+
+      # Send back what was sent in, headers, post body etc.
+      # @param request_hash [Hash] The request body.
+      # @return [Hash]
+      def echo(request_hash)
+        result = request(post: "_admin/echo", body: request_hash)
+        Oj.load(result.requestBody, symbol_keys: true)
+      end
+
+      # Return server database engine information
+      # @return [Arango::Result]
+      def engine
+        @engine ||= request(get: '_api/engine')
+      end
+
+      # Return true if the server uses the mmfiles engine.
+      # @return [Boolean]
+      def mmfiles?
+        'mmfiles' == engine.name
+      end
+
+      # Return true if the server uses the rocksdb engine.
+      # @return [Boolean]
+      def rocksdb?
+        'rocksdb' == engine.name
+      end
+
+      # Read global logs from the server.
+      # Log levels for the upto and level params:
+      # - fatal or 0
+      # - error or 1
+      # - warning or 2
+      # - info or 3
+      # - debug or 4
+      # The parameters upto and level are mutually exclusive.
+      # All params are optional.
+      # @param upto [Symbol, String, Integer] Returns all log entries up to log level upto. The default value is info.
+      # @param level [Symbol, String, Integer]Returns all log entries of log level level.
+      # @param start Returns all log entries such that their log entry identifier (lid value) is greater or equal to start.
+      # @param size [Integer] Restricts the result to at most size log entries.
+      # @param offset [Integer] Starts to return log entries skipping the first offset log entries. offset and size can be used for pagination.
+      # @param search [String] Only return the log entries containing the text specified in search.
+      # @param sort [Symbol, String] Sort the log entries either ascending (if sort is :asc) or descending (if sort is :desc) according to their lid values.
+      # @return [Arango::Result]
+      def log(upto: nil, level: nil, start: nil, size: nil, offset: nil, search: nil, sort: nil)
+        sort = sort.to_s if sort
+        satisfy_category?(sort, [nil, "asc", "desc"])
+        query = { start: start, size: size, offset: offset, search: search, sort: sort }
+        if upto
+          upto = upto.to_s
+          satisfy_category?(upto, [nil, "fatal", 0, "error", 1, "warning", 2, "info", 3, "debug", 4])
+          query[:upto] = upto
+        elsif level
+          level = level.to_s
+          satisfy_category?(level, [nil, "fatal", 0, "error", 1, "warning", 2, "info", 3, "debug", 4])
+          query[:level] = level
+        end
+        request(get: "_admin/log", query: query)
+      end
+
+      # Returns the current log level settings
+      # @return [Arango::Result]
+      def log_level
+        request(get: "_admin/log/level")
+      end
+
+      # Modifies the current log level settings
+      # @param log_level_object [Arango::Result, Hash] Must contain all keys as obtained by log_level. Best is to get the object by calling log_level,
+      #                                                modifying it, and passing it here.
+      # @return Arango::Result
+      def log_level=(log_level_object)
+        body = if log_level_object.class == Arango::Result
+                 log_level_object.to_h
+               else
+                 log_level_object
+               end
+        request(put: "_admin/log/level", body: body)
+      end
+
+      # Return mode information about a server.
+      # @return [Symbol] one of :default or :readonly
+      def mode
+        request(get: "_admin/server/mode").mode.to_sym
+      end
+
+      # Set server mode.
+      # @param mode [String, Symbol] one of :default or :readonly
+      # @return [Symbol] one of :default or :readonly
+      def mode=(mode)
+        satisfy_category?(mode, ["default", "readonly", :default, :readonly])
+        body = { mode: mode.to_s }
+        request(put: "_admin/server/mode", body: body).mode
+      end
+
+      # Check if server is read only.
+      # @return [Boolean]
+      def read_only?
+        :readonly == mode
+      end
+
+      # Reloads the routing information from the collection routing.
+      # @return true
+      def reload_routing
+        request(get: "_admin/routing/reload")
+        true
+      end
+
+      # Returns the role of a server in a cluster.
+      # SINGLE: the server is a standalone server without clustering
+      # COORDINATOR: the server is a Coordinator in a cluster
+      # PRIMARY: the server is a DBServer in a cluster
+      # SECONDARY: this role is not used anymore
+      # AGENT: the server is an Agency node in a cluster
+      # UNDEFINED: in a cluster, UNDEFINED is returned if the server role cannot be
+      # determined.
+      # @return [String]
+      def role
+        @role ||= request(get: '_admin/server/role').role
+      end
+
+      # Check if server role is AGENT.
+      # @return [Boolean]
+      def agent?
+        role == 'AGENT'
+      end
+
+      # Check if server role is COORDINATOR.
+      # @return [Boolean]
+      def coordinator?
+        role == 'COORDINATOR'
+      end
+
+      # Check if server role is PRIMARY.
+      # @return [Boolean]
+      def primary?
+        role == 'PRIMARY'
+      end
+
+      # Check if server role is SECONDARY.
+      # @return [Boolean]
+      def secondary?
+        role == 'SECONDARY'
+      end
+
+      # Check if server role is SINGLE.
+      # @return [Boolean]
+      def single?
+        role == 'SINGLE'
+      end
+
+      # Check if server is part of a cluster.
+      # @return [Boolean]
+      def in_cluster?
+        coordinator? || primary? || agent? || secondary?
+      end
+
+      # Returns the id of a server in a cluster.
+      # @return [Boolean]
+      def server_id
+        request(get: "_admin/server/id").serverId if in_cluster?
+      end
+
+      # Returns the statistics information.
+      # @return [Arango::Result]
+      def statistics
+        request(get: "_admin/statistics")
+      end
+
+      # Returns a description of the statistics returned by /_admin/statistics.
+      # @return [Arango::Result]
+      def statistics_description
+        request(get: "_admin/statistics-description")
+      end
+
+      # Returns status information about the server.
+      # @return [Arango::Result]
+      def status
+        request(get: "_admin/status")
+      end
+
+      # Check if the server has the enterprise license.
+      # @return [Boolean]
+      def enterprise?
+        @enterprise ||= (status.license == 'enterprise')
+      end
+
+      # The servers current system time as a Unix timestamp with microsecond precision of the server
+      # @return [Float]
+      def time
+        request(get: "_admin/time").time
+      end
+
+      # Return server version details.
+      # The response will contain a details attribute with additional information about included components
+      # and their versions. The attribute names and internals of the details object may vary depending on platform and ArangoDB version.
+      # @return [Arango::Result]
+      def detailed_version
+        request(get: "_api/version", query: { details: true })
+      end
+
+      # The server version string. The string has the format “major.minor.sub”. major and minor will be numeric, and sub may contain a number or
+      # a textual version.
+      # @return [String]
+      def version
+        request(get: "_api/version").version
+      end
+
+      # Returns the database version that this server requires.
+      # @return [String]
+      def target_version
+        request(get: "_admin/database/target-version").version
+      end
+
+      # Flushes the write-ahead log. By flushing the currently active write-ahead
+      # logfile, the data in it can be transferred to collection journals and
+      # datafiles. This is useful to ensure that all data for a collection is
+      # present in the collection journals and datafiles, for example, when dumping
+      # the data of a collection.
+      # @param wait_for_sync [Boolean] Whether or not the operation should block until the not-yet synchronized data in the write-ahead log was
+      #                                synchronized to disk.
+      # @param wait_for_collector [Boolean] Whether or not the operation should block until the data in the flushed log has been collected by the
+      #                                     write-ahead log garbage collector. Note that setting this option to true might block for a long time if
+      #                                     there are long-running transactions and the write-ahead log garbage collector cannot
+      #                                     finish garbage collection.
+      def flush_wal(wait_for_sync: nil, wait_for_collector: nil)
+        body = {
+          waitForSync: wait_for_sync,
+          waitForCollector: wait_for_collector
+        }
+        !!request(put: "_admin/wal/flush", body: body)
+      end
+
+      # Retrieves the configuration of the write-ahead log. Properties:
+      # - allow_oversize_entries: whether or not operations that are bigger than a single logfile can be executed and stored
+      # - log_file_size: the size of each write-ahead logfile
+      # - historic_logfiles: the maximum number of historic logfiles to keep
+      # - reserve_logfiles: the maximum number of reserve logfiles that ArangoDB allocates in the background
+      # - throttle_wait: the maximum wait time that operations will wait before they get aborted if case of write-throttling (in milliseconds)
+      # - throttle_when_pending: the number of unprocessed garbage-collection operations that, when reached, will activate write-throttling.
+      #                          A value of 0 means that write-throttling will not be triggered.
+      # return [Arango::Result]
+      def wal_properties
+        result = request(get: "_admin/wal/properties")
+        raise "WAL properties not available." if result.response_code >= 500
+        result
+      end
+
+      # Configures the behavior of the write-ahead log.
+      # @param properties_object [Arango::Result] Obtain the object with wal_properties, modify and pass here.
+      #
+      def wal_properties=(properties_object)
+        body = {
+          allowOversizeEntries: properties_object.allow_oversize_entries,
+          logfileSize: properties_object.logfile_size,
+          historicLogfiles: properties_object.historic_logfiles,
+          reserveLogfiles: properties_object.reserve_logfiles,
+          throttleWait: properties_object.throttle_wait,
+          throttleWhenPending: properties_object.throttle_when_pending
+        }
+        result = request(put: "_admin/wal/properties", body: body)
+        raise "WAL properties not available." if result.response_code >= 500
+        result
+      end
+
+      # Shutdown the server.
+      # @return [Boolean] True if request was successful.
+      def shutdown
+        200 == request(delete: "_admin/shutdown").response_code
+      end
+    end
+  end
+end