arango-driver 3.5.0.alpha0

data/lib/arango/server/agency.rb

@@ -0,0 +1,23 @@
+module Arango
+  class Server
+    module Agency
+      def agency_config
+        request("GET", "_api/agency/config")
+      end
+
+      def agency_write(body:, agency_mode: nil)
+        satisfy_category?(agency_mode, ["waitForCommmitted", "waitForSequenced", "noWait", nil])
+        headers = {"X-ArangoDB-Agency-Mode": agency_mode}
+        request("POST", "_api/agency/write", headers: headers,
+                body: body)
+      end
+
+      def agency_read(body:, agency_mode: nil)
+        satisfy_category?(agency_mode, ["waitForCommmitted", "waitForSequenced", "noWait", nil])
+        headers = {"X-ArangoDB-Agency-Mode": agency_mode}
+        request("POST", "_api/agency/read", headers: headers,
+                body: body)
+      end
+    end
+  end
+end

data/lib/arango/server/async.rb

@@ -0,0 +1,51 @@
+module Arango
+  class Server
+    module Async
+      # === ASYNC ===
+
+      def fetch_async(id:)
+        request("PUT", "_api/job/#{id}")
+      end
+
+      def cancel_async(id:)
+        request("PUT", "_api/job/#{id}/cancel", key: :result)
+      end
+
+      def destroy_async(id:, stamp: nil)
+        query = {stamp: stamp}
+        request("DELETE", "_api/job/#{id}", query: query, key: :result)
+      end
+
+      def destroy_async_by_type(type:, stamp: nil)
+        satisfy_category?(type, %w[all expired])
+        query = {stamp: stamp}
+        request("DELETE", "_api/job/#{type}", query: query)
+      end
+
+      def destroy_all_async
+        destroy_async_by_type(type: "all")
+      end
+
+      def destroy_expired_async
+        destroy_async_by_type(type: "expired")
+      end
+
+      def retrieve_async(id:)
+        request("GET", "_api/job/#{id}")
+      end
+
+      def retrieve_async_by_type(type:, count: nil)
+        satisfy_category?(type, %w[done pending])
+        request("GET", "_api/job/#{type}", query: {count: count})
+      end
+
+      def retrieve_done_async(count: nil)
+        retrieve_async_by_type(type: "done", count: count)
+      end
+
+      def retrieve_pending_async(count: nil)
+        retrieve_async_by_type(type: "pending", count: count)
+      end
+    end
+  end
+end

data/lib/arango/server/batch.rb

@@ -0,0 +1,35 @@
+module Arango
+  class Server
+    module Batch
+      # === BATCH ===
+
+      def batch(requests: [])
+        Arango::RequestBatch.new(server: self, requests: requests)
+      end
+
+      def create_dump_batch(ttl:, dbserver: nil)
+        query = { DBserver: dbserver }
+        body = { ttl: ttl }
+        result = request("POST", "_api/replication/batch",
+                         body: body, query: query)
+        return result if return_directly?(result)
+        return result[:id]
+      end
+
+      def destroy_dump_batch(id:, dbserver: nil)
+        query = {DBserver: dbserver}
+        result = request("DELETE", "_api/replication/batch/#{id}", query: query)
+        return_delete(result)
+      end
+
+      def prolong_dump_batch(id:, ttl:, dbserver: nil)
+        query = { DBserver: dbserver }
+        body  = { ttl: ttl }
+        result = request("PUT", "_api/replication/batch/#{id}",
+                         body: body, query: query)
+        return result if return_directly?(result)
+        return true
+      end
+    end
+  end
+end

data/lib/arango/server/config.rb

@@ -0,0 +1,76 @@
+module Arango
+  class Server
+    module Config
+      attr_reader :active_cache, :async, :base_uri, :cache, :host, :password, :port, :return_output, :tls, :username
+      attr_accessor :size, :timeout, :verbose, :warning
+
+      def username=(username)
+        @username = username
+        @options[:basic_auth][:username] = @username
+        @request.options = options
+      end
+
+      def password=(password)
+        @password = password
+        @options[:basic_auth][:password] = @password
+        @request.options = options
+      end
+
+      def host=(host)
+        @host = host
+        update_base_uri
+      end
+
+      def port=(port)
+        @port = port
+        update_base_uri
+      end
+
+      def tls=(tls)
+        satisfy_category?(tls, [false, true])
+        @tls = tls
+        update_base_uri
+      end
+
+      def active_cache=(active)
+        satisfy_category?(active, [true, false])
+        @active_cache = active
+        if @active_cache
+          @cache ||= Arango::Cache.new
+        elsif !@cache.nil?
+          @cache.clear
+        end
+      end
+
+      def return_output=(return_output)
+        satisfy_category?(return_output, [true, false])
+        @return_output = return_output
+        @request.return_output = return_output
+      end
+
+      def verbose=(verbose)
+        satisfy_category?(verbose, [true, false])
+        @verbose = verbose
+        @request.verbose = verbose
+      end
+
+      def async=(async)
+        satisfy_category?(async, ["true", "false", false, true, "store", :store])
+        case async
+        when true, "true"
+          @options[:headers]["x-arango-async"] = "true"
+          @async = true
+        when :store, "store"
+          @options[:headers]["x-arango-async"] = "store"
+          @async = :store
+        when false, "false"
+          @options[:headers].delete("x-arango-async")
+          @async = false
+        end
+        @request.async = @async
+        @request.options = @options
+      end
+      alias assign_async async=
+    end
+  end
+end

data/lib/arango/server/databases.rb

@@ -0,0 +1,71 @@
+module Arango
+  class Server
+    module Databases
+      # Retrieves all databases.
+      # @return [Array<Arango::Database>]
+      def all_databases
+        Arango::Database.all(server: self)
+      end
+
+      # Retrieves all databases the current user can access.
+      # @return [Array<Arango::Database>]
+      def all_user_databases
+        Arango::Database.all_user_databases(server: self)
+      end
+
+      # Retrieves a list of all databases.
+      # @return [Array<String>] List of database names.
+      def list_databases
+        Arango::Database.list(server: self)
+      end
+
+      # Retrieves a list of all databases the current user can access.
+      # @return [Array<String>] List of database names.
+      def list_user_databases
+        Arango::Database.list_user_databases(server: self)
+      end
+
+      # Creates a new database.
+      # @param name [String] The name of the database
+      # @return [Arango::Database] The instance of the database created.
+      def create_database(name)
+        Arango::Database.new(name, server: self).create
+      end
+
+      # Instantiates a new database, but does not store it on th server.
+      # @param name [String] The name of the database
+      # @return [Arango::Database] The instance of the database.
+      def new_database(name)
+        Arango::Database.new(name, server: self)
+      end
+
+      # Removes a database.
+      # @param name [String] The name of the database
+      # @return nil
+      def drop_database(name)
+        Arango::Database.drop(name, server: self)
+      end
+      alias delete_database drop_database
+      alias destroy_database drop_database
+
+      # Get database from server.
+      # @param name [String] The name of the database
+      # @return [Arango::Database] The instance of the database.
+      def get_database(name)
+        db = Arango::Database.get(name, server: self)
+        Arango.current_database = db if Arango.current_server == self
+        db
+      end
+      alias fetch_database get_database
+      alias retrieve_database get_database
+
+      # Check if database exists.
+      # @param name [String] Name of the database.
+      # @return [Boolean]
+      def exist_database?(name)
+        Arango::Database.exist?(name, server: self)
+      end
+      alias database_exist? exist_database?
+    end
+  end
+end

data/lib/arango/server/monitoring.rb

@@ -0,0 +1,17 @@
+module Arango
+  class Server
+    module Monitoring
+      # === MONITORING ===
+
+      def cluster_health
+        request("GET", "_admin/health")
+      end
+
+      def cluster_statistics dbserver:
+        query = {DBserver: dbserver}
+        request("GET", "_admin/clusterStatistics", query: query)
+      end
+
+    end
+  end
+end

data/lib/arango/server/opal_support.rb

@@ -0,0 +1,95 @@
+module Arango
+  class Server
+    module OpalSupport
+      # From the Arango 2.8 documentation:
+      #
+      # Modules Path versus Modules Collection
+      #
+      # ArangoDB comes with predefined modules defined in the file-system under the path specified by
+      # startup.startup-directory. In a standard installation this point to the system share directory.
+      # Even if you are an administrator of ArangoDB you might not have write permissions to this location.
+      # On the other hand, in order to deploy some extension for ArangoDB, you might need to install additional
+      # JavaScript modules. This would require you to become root and copy the files into the share directory.
+      # In order to ease the deployment of extensions, ArangoDB uses a second mechanism to look up JavaScript modules.
+      #
+      # JavaScript modules can either be stored in the filesystem as regular file or
+      # in the database collection _modules.
+      #
+      # If you execute
+      #
+      # require("com/example/extension")
+      #
+      # then ArangoDB will try to locate the corresponding JavaScript as file as follows
+      #
+      #     There is a cache for the results of previous require calls. First of all ArangoDB checks if
+      #     com/example/extension is already in the modules cache. If it is, the export object for this module
+      #     is returned. No further JavaScript is executed.
+      #
+      #     ArangoDB will then check, if there is a file called com/example/extension.js in the system search path.
+      #     If such a file exists, it is executed in a new module context and the value of exports object is returned.
+      #     This value is also stored in the module cache.
+      #
+      #     If no file can be found, ArangoDB will check if the collection _modules contains a document of the form
+      #
+      # {
+      #   path: "/com/example/extension",
+      #   content: "...."
+      # }
+      #
+      # Note: The leading / is important - even if you call require without a leading /. If such a document exists,
+      # then the value of the content attribute must contain the JavaScript code of the module. This string is
+      # executed in a new module context and the value of exports object is returned. This value is also stored
+      # in the module cache.
+      #
+      #
+      # Taken from the Changelog for 3.5.0.rc.1,
+      # https://github.com/arangodb/arangodb/blob/43fa37e35935e095dae31f250456f030da3c451f/CHANGELOG#L826:
+      #
+      # * Do not create `_modules` collection for new databases/installations.
+      #
+      #   `_modules` is only needed for custom modules, and in case a custom
+      #   module is defined via `defineModule`, the _modules collection will
+      #   be created lazily automatically.
+      #
+      #   Existing modules in existing `_modules` collections will remain
+      #   functional even after this change
+      #
+      #
+      #  So this is what we use for storing the opal module in arango and making it available.
+
+      def install_opal_module(database = '_system', force: false)
+        database = database.name unless database.class == String
+        dirname = File.dirname(__FILE__)
+        filename = File.expand_path(File.join(dirname, '..', '..', '..', 'arango_opal.js'))
+        content = File.read(filename)
+        system_db = get_database(database)
+        system_db.create_collection('_modules', is_system: true) unless system_db.collection_exist?('_modules', exclude_system: false)
+        modules_collection = system_db.get_collection('_modules')
+        opal_module_doc = modules_collection.get_document(path: '/opal')
+        if opal_module_doc
+          opal_module_doc.content = content
+          opal_module_doc.update
+        else
+          modules_collection.create_document({ path: '/opal', content: content })
+        end
+      end
+
+      # def install_opal_parser_module(database = '_system', force: false)
+      #   database = database.name unless database.class == String
+      #   dirname = File.dirname(__FILE__)
+      #   filename = File.expand_path(File.join(dirname, '..', '..', '..', 'arango_opal_parser.js'))
+      #   content = File.read(filename)
+      #   system_db = get_database(database)
+      #   system_db.create_collection('_modules', is_system: true) unless system_db.collection_exist?('_modules', exclude_system: false)
+      #   modules_collection = system_db.get_collection('_modules')
+      #   opal_module_doc = modules_collection.get_document(path: '/opal-parser')
+      #   if opal_module_doc
+      #     opal_module_doc.content = content
+      #     opal_module_doc.update
+      #   else
+      #     modules_collection.create_document({ path: '/opal-parser', content: content })
+      #   end
+      # end
+    end
+  end
+end

data/lib/arango/server/tasks.rb

@@ -0,0 +1,69 @@
+module Arango
+  class Server
+    module Tasks
+
+      # Get all tasks.
+      #
+      # @return [Array<Arango::Task>]
+      def all_tasks
+        Arango::Task.all(server: self)
+      end
+
+      # Create a new task with given id, task is saved to the database.
+      # @param id [String]
+      # @param command [String] The javascript code to execute.
+      # @param name [String] The task name, optional.
+      # @param offset [Integer] The number of seconds initial delay, optional.
+      # @param params [Hash] Hash of params to pass to the command, optional.
+      # @param period [Integer] Number of seconds between executions, optional.
+      # @return [Arango::Task]
+      def create_task(id, command:, name: nil, offset: nil, params: nil, period: nil)
+        Arango::Task.new(id, command: command, name: name, offset: offset, params: params, period: period, server: self).create
+      end
+
+      # Get a task from the server.
+      # @param id [String]
+      # @return [Arango::Task]
+      def get_task(id)
+        Arango::Task.get(id, server: self)
+      end
+      alias fetch_task get_task
+      alias retrieve_task get_task
+
+      # Instantiate a new task with given id, task is not saved to the database.
+      # @param id [String]
+      # @param command [String] The javascript code to execute, optional.
+      # @param name [String] The task name, optional.
+      # @param offset [Integer] The number of seconds initial delay, optional.
+      # @param params [Hash] Hash of params to pass to the command, optional.
+      # @param period [Integer] Number of seconds between executions, optional.
+      # @return [Arango::Task]
+      def new_task(id, command: nil, name: nil, offset: nil, params: nil, period: nil)
+        Arango::Task.new(id, command: command, name: name, offset: offset, params: params, period: period, server: self)
+      end
+
+      # Get a list of all task ids.
+      # @return [Array<String>]
+      def list_tasks
+        Arango::Task.list(server: self)
+      end
+
+      # Delete task with given id.
+      # @param id [String]
+      # @return [Boolean] Returns true if task has been deleted.
+      def drop_task(id)
+        Arango::Task.delete(id, server: self)
+      end
+      alias delete_task drop_task
+      alias destroy_task drop_task
+
+      # Checks existence of a task.
+      # @param id [String]
+      # @return [Boolean] Returns true if the task exists, otherwise false.
+      def exist_task?(id)
+        Arango::Task.exist?(id, server: self)
+      end
+      alias task_exist? exist_task?
+    end
+  end
+end

data/lib/arango/server/user.rb

@@ -0,0 +1,22 @@
+module Arango
+  class Server
+    module User
+      # === USER ===
+
+      def user(password: "", name:, extra: {}, active: nil)
+        Arango::User.new(host: self, password: password, name: name, extra: extra,
+                         active: active)
+      end
+
+      def users
+        result = request("GET", "_api/user", key: :result)
+        return result if return_directly?(result)
+        result.map do |user|
+          Arango::User.new(name: user[:user], active: user[:active],
+                           extra: user[:extra], host: self)
+        end
+      end
+
+    end
+  end
+end