arangorb 0.1.0 → 1.0.0

data/lib/ArangoRB_DB.rb

@@ -1,26 +1,30 @@
 # === DATABASE ===
 
-class ArangoDB < ArangoS
-  def initialize(database: @@database)
+class ArangoDatabase < ArangoServer
+  def initialize(database: @@database)  # TESTED
     if database.is_a?(String)
       @database = database
+    elsif database.is_a?(ArangoDatabase)
+      @database = database.database
     else
-      raise "database should be a String, not a #{database.class}"
+      raise "database should be a String or an ArangoDatabase instance, not a #{database.class}"
     end
   end
 
-  attr_reader :database
+  attr_reader :database # TESTED
 
   # === GET ===
 
-  def self.info
-    result = get("/_api/database/current")
-    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"]
+  def info  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/database/current", @@request)
+    return result.headers["x-arango-async-id"] if @@async == "store"
+    result = result.parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"].delete_if{|k,v| k == "error" || k == "code"}
   end
 
   # === POST ===
 
-  def create(username: nil, passwd: nil, users: nil)
+  def create(username: nil, passwd: nil, users: nil)  # TESTED
     body = {
       "name" => @database,
       "username" => username,
@@ -28,83 +32,100 @@ class ArangoDB < ArangoS
       "users" => users
     }
     body = body.delete_if{|k,v| v.nil?}.to_json
-    new_DB = { :body => body }
-    result = self.class.post("/_api/database", new_DB)
-    @@verbose ? result : result["error"] ? result["errorMessage"] : ArangoDB.new(database: @database)
+    request = @@request.merge({ :body => body })
+    result = self.class.post("/_api/database", request)
+    @@async == "store" ? result.headers["x-arango-async-id"] : @@verbose ? result.parsed_response : result.parsed_response["error"] ? result.parsed_response["errorMessage"] : self
   end
 
   # === DELETE ===
 
-  def destroy
-    result = self.class.delete("/_api/database/#{@database}")
-    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"]
+  def destroy  # TESTED
+    result = self.class.delete("/_api/database/#{@database}", @@request)
+    self.class.return_result(result: result, caseTrue: true)
   end
 
   # === LISTS ===
 
-  def self.databases(user: nil)
-    result = user.nil? ? get("/_api/database") : get("/_api/database/#{user}")
-    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"].map{|x| ArangoDB.new(database: x)}
+  def self.databases(user: nil)  # TESTED
+    user = user.user if user.is_a?(ArangoUser)
+    result = user.nil? ? get("/_api/database") : get("/_api/database/#{user}", @@request)
+    return result.headers["x-arango-async-id"] if @@async == "store"
+    result = result.parsed_response
+    @@verbose ? result : result["error"] ? result["errorMessage"] : result["result"].map{|x| ArangoDatabase.new(database: x)}
   end
 
-  def collections(excludeSystem: true)
+  def collections(excludeSystem: true)  # TESTED
     query = { "excludeSystem": excludeSystem }.delete_if{|k,v| v.nil?}
-    new_Document = { :query => query }
-    result = self.class.get("/_db/#{@database}/_api/collection", new_Document)
-    if @@verbose
-      return result
+    request = @@request.merge({ :query => query })
+    result = self.class.get("/_db/#{@database}/_api/collection", request)
+    if @@async == "store"
+      result.headers["x-arango-async-id"]
     else
-      if result["error"]
-        return result["errorMessage"]
+      result = result.parsed_response
+      if @@verbose
+        result
       else
-        return result["result"].map{|x| ArangoC.new(database: @database, collection: x["name"])}
+        if result["error"]
+          result["errorMessage"]
+        else
+          result["result"].map{|x| ArangoCollection.new(database: @database, collection: x["name"])}
+        end
       end
     end
   end
 
-  def graphs
-    result = self.class.get("/_db/#{@database}/_api/gharial")
-    if @@verbose
-      return result
+  def graphs  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/gharial", @@request)
+    if @@async == "store"
+      result.headers["x-arango-async-id"]
     else
-      if result["error"]
-        return result["errorMessage"]
+      result = result.parsed_response
+      if @@verbose
+        result
       else
-        return result["graphs"].map{|x| ArangoG.new(database: @database, graph: x["_key"], edgeDefinitions: x["edgeDefinitions"], orphanCollections: x["orphanCollections"])}
+        if result["error"]
+          result["errorMessage"]
+        else
+          result["graphs"].map{|x| ArangoGraph.new(database: @database, graph: x["_key"], edgeDefinitions: x["edgeDefinitions"], orphanCollections: x["orphanCollections"])}
+        end
       end
     end
   end
 
-  def functions
-    self.class.get("/_db/#{@database}/_api/aqlfunction").parsed_response
+  def functions  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/aqlfunction", @@request)
+    self.class.return_result result: result
   end
 
   # === QUERY ===
 
-  def propertiesQuery
-    result = self.class.get("/_db/#{@database}/_api/query/properties").parsed_response
-    return_result(result)
+  def propertiesQuery  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/query/properties", @@request)
+    self.class.return_result result: result
   end
 
-  def currentQuery
-    self.class.get("/_db/#{@database}/_api/query/current").parsed_response
+  def currentQuery  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/query/current", @@request)
+    self.class.return_result result: result
   end
 
-  def slowQuery
-    self.class.get("/_db/#{@database}/_api/query/slow").parsed_response
+  def slowQuery  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/query/slow", @@request)
+    self.class.return_result result: result
   end
 
-  def stopSlowQuery
-    result = self.class.delete("/_db/#{@database}/_api/query/slow").parsed_response
-    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  def stopSlowQuery  # TESTED
+    result = self.class.delete("/_db/#{@database}/_api/query/slow", @@request)
+    self.class.return_result result: result, caseTrue: true
   end
 
-  def killQuery(id:)
-    result = self.class.delete("/_db/#{@database}/_api/query/#{id}").parsed_response
-    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  def killQuery(query:)  # TESTED
+    id = query.is_a?(ArangoAQL) ? query.id : query.is_a?(String) ? query : nil
+    result = self.class.delete("/_db/#{@database}/_api/query/#{id}", @@request)
+    self.class.return_result result: result, caseTrue: true
   end
 
-  def changePropertiesQuery(slowQueryThreshold: nil, enabled: nil, maxSlowQueries: nil, trackSlowQueries: nil, maxQueryStringLength: nil)
+  def changePropertiesQuery(slowQueryThreshold: nil, enabled: nil, maxSlowQueries: nil, trackSlowQueries: nil, maxQueryStringLength: nil)  # TESTED
     body = {
       "slowQueryThreshold" => slowQueryThreshold,
       "enabled" => enabled,
@@ -112,59 +133,264 @@ class ArangoDB < ArangoS
       "trackSlowQueries" => trackSlowQueries,
       "maxQueryStringLength" => maxQueryStringLength
     }.delete_if{|k,v| v.nil?}
-    new_Document = { :body => body.to_json }
-    result = self.class.put("/_db/#{@database}/_api/query/properties", new_Document).parsed_response
-    return_result(result)
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.put("/_db/#{@database}/_api/query/properties", request)
+    self.class.return_result result: result
   end
 
 # === CACHE ===
 
-  def clearCache
-    result = self.class.delete("/_db/#{@database}/_api/query-cache").parsed_response
-    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  def clearCache  # TESTED
+    result = self.class.delete("/_db/#{@database}/_api/query-cache", @@request)
+    self.class.return_result result: result, caseTrue: true
   end
 
-  def propertyCache
-    self.class.get("/_db/#{@database}/_api/query-cache/properties").parsed_response
+  def propertyCache  # TESTED
+    result = self.class.get("/_db/#{@database}/_api/query-cache/properties", @@request)
+    self.class.return_result result: result
   end
 
-  def changePropertyCache(mode: nil, maxResults: nil)
+  def changePropertyCache(mode: nil, maxResults: nil)  # TESTED
     body = { "mode" => mode, "maxResults" => maxResults }.delete_if{|k,v| v.nil?}
-    new_Document = { :body => body.to_json }
-    self.class.put("/_db/#{@database}/_api/query-cache/properties", new_Document).parsed_response
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.put("/_db/#{@database}/_api/query-cache/properties", request)
+    self.class.return_result result: result
   end
 
   # === AQL FUNCTION ===
 
-  def createFunction(code:, name:, isDeterministic: nil)
+  def createFunction(code:, name:, isDeterministic: nil)  # TESTED
     body = {
       "code" => code,
       "name" => name,
       "isDeterministic" => isDeterministic
     }.delete_if{|k,v| v.nil?}
-    new_Document = { :body => body.to_json }
-    result = self.class.post("/_db/#{@database}/_api/aqlfunction", new_Document).parsed_response
-    return_result(result)
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.post("/_db/#{@database}/_api/aqlfunction", request)
+    self.class.return_result result: result
   end
 
-  def deleteFunction(name:)
-    result = self.class.delete("/_db/#{@database}/_api/aqlfunction/#{name}")
-    @@verbose ? result : result["error"] ? result["errorMessage"] : true
+  def deleteFunction(name:) # TESTED
+    result = self.class.delete("/_db/#{@database}/_api/aqlfunction/#{name}", @@request)
+    self.class.return_result result: result, caseTrue: true
   end
 
-  # === UTILITY ===
+  # # === ASYNC ===
+  #
+  # def pendingAsync # TESTED
+  #   result = self.class.get("/_db/#{@database}/_api/job/pending")
+  #   return_result_async result: result
+  # end
+  #
+  # def fetchAsync(id:) # TESTED
+  #   result = self.class.put("/_db/#{@database}/_api/job/#{id}")
+  #   return_result_async result: result
+  # end
+  #
+  # def retrieveAsync(type:) # TESTED
+  #   result = self.class.get("/_db/#{@database}/_api/job/#{type}")
+  #   return_result_async result: result
+  # end
+  #
+  # def retrieveDoneAsync # TESTED
+  #   retrieveAsync(type: "done")
+  # end
+  #
+  # def retrievePendingAsync # TESTED
+  #   retrieveAsync(type: "pending")
+  # end
+  #
+  # def cancelAsync(id:) # TESTED
+  #   result = self.class.put("/_db/#{@database}/_api/job/#{id}/cancel")
+  #   return_result_async result: result
+  # end
+  #
+  # def destroyAsync(type:) # TESTED
+  #   result = self.class.delete("/_db/#{@database}/_api/job/#{type}")
+  #   return_result_async result: result, caseTrue: true
+  # end
+  #
+  # def destroyAllAsync # TESTED
+  #   destroyAsync(type: "all")
+  # end
+  #
+  # def destroyExpiredAsync # TESTED
+  #   destroyAsync(type: "expired")
+  # end
 
-  def return_result(result)
-    if @@verbose
-      result
-    else
-      if result["error"]
-        result["errorMessage"]
-      else
-        result.delete("error")
-        result.delete("code")
-        result
-      end
-    end
+  # === REPLICATION ===
+
+  def inventory(includeSystem: false) # TESTED
+    query = { "includeSystem": includeSystem }
+    request = @@request.merge({ :query => query })
+    result = self.class.get("/_db/#{@database}/_api/replication/inventory", request)
+    self.class.return_result result: result
+  end
+
+  def clusterInventory(includeSystem: false) # TESTED
+    query = { "includeSystem": includeSystem }
+    request = @@request.merge({ :query => query })
+    result = self.class.get("/_db/#{@database}/_api/replication/clusterInventory", request)
+    self.class.return_result result: result
+  end
+
+  def logger # TESTED
+    result = self.class.get("/_db/#{@database}/_api/replication/logger-state")
+    self.class.return_result result: result
+  end
+
+  def loggerFollow(from: nil, to: nil, chunkSize: nil, includeSystem: false) # TESTED
+    query = {
+      "from": from,
+      "to": to,
+      "chunkSize": chunkSize,
+      "includeSystem": includeSystem
+    }.delete_if{|k,v| v.nil?}
+    request = @@request.merge({ :query => query })
+    result = self.class.get("/_db/#{@database}/_api/replication/logger-follow", request)
+    self.class.return_result result: result
+  end
+
+  def firstTick # TESTED
+    result = self.class.get("/_db/#{@database}/_api/replication/logger-first-tick")
+    self.class.return_result result: result, key: "firstTick"
+  end
+
+  def rangeTick # TESTED
+    result = self.class.get("/_db/#{@database}/_api/replication/logger-tick-ranges")
+    self.class.return_result result: result
+  end
+
+  def sync(endpoint: "tcp://#{@@server}:#{@@port}", username: @@username, password: @@password, includeSystem: false, database: @database, initialSyncMaxWaitTime: nil, restrictType: nil, incremental: nil, restrictCollections: nil)
+    body = {
+      "username" => username,
+      "password" => password,
+      "includeSystem" => includeSystem,
+      "endpoint" => endpoint,
+      "initialSyncMaxWaitTime" => initialSyncMaxWaitTime,
+      "database" => database,
+      "restrictType" => restrictType,
+      "incremental" => incremental,
+      "restrictCollections" =>  restrictCollections
+    }.delete_if{|k,v| v.nil?}
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.put("/_db/#{database}/_api/replication/sync", request)
+    self.class.return_result result: result
   end
+
+  def configurationReplication # TESTED
+    result = self.class.get("/_db/#{@database}/_api/replication/applier-config", @@request)
+    self.class.return_result result: result
+  end
+
+  def modifyConfigurationReplication(endpoint: "tcp://#{@@server}:#{@@port}", username: @@username, password: @@password, database: @database, includeSystem: false, verbose: false, connectTimeout: nil, autoResync: nil, idleMinWaitTime: nil, requestTimeout: nil, requireFromPresent: nil, idleMaxWaitTime: nil, restrictCollections: nil, restrictType: nil, initialSyncMaxWaitTime: nil, maxConnectRetries: nil, autoStart: nil, adaptivePolling: nil, connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil) # TESTED
+    body = {
+      "username" => username,
+      "password" => password,
+      "includeSystem" => includeSystem,
+      "endpoint" => endpoint,
+      "initialSyncMaxWaitTime" => initialSyncMaxWaitTime,
+      "database" => database,
+      "verbose" => verbose,
+      "connectTimeout" => connectTimeout,
+      "autoResync" => autoResync,
+      "idleMinWaitTime" => idleMinWaitTime,
+      "requestTimeout" => requestTimeout,
+      "requireFromPresent" => requireFromPresent,
+      "idleMaxWaitTime" => idleMaxWaitTime,
+      "restrictType" => restrictType,
+      "maxConnectRetries" => maxConnectRetries,
+      "autoStart" => autoStart,
+      "adaptivePolling" => adaptivePolling,
+      "connectionRetryWaitTime" => connectionRetryWaitTime,
+      "restrictCollections" =>  restrictCollections,
+      "autoResyncRetries" => autoResyncRetries,
+      "chunkSize" => chunkSize
+    }.delete_if{|k,v| v.nil?}
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.put("/_db/#{database}/_api/replication/applier-config", request)
+    self.class.return_result result: result
+  end
+
+  def startReplication(from: nil)
+    query = {from: from}.delete_if{|k,v| v.nil?}
+    request = @@request.merge({ :query => query })
+    result = self.class.put("/_db/#{@database}/_api/replication/applier-start", request)
+    self.class.return_result result: result
+  end
+
+  def stopReplication
+    result = self.class.put("/_db/#{@database}/_api/replication/applier-stop", @@request)
+    self.class.return_result result: result
+  end
+
+  def stateReplication
+    result = self.class.get("/_db/#{@database}/_api/replication/applier-state", @@request)
+    self.class.return_result result: result
+  end
+
+  def enslave(username: @@username, includeSystem: false, endpoint: "tcp://#{@@server}:#{@@port}", verbose: false, connectTimeout: nil, autoResync: nil, password: @@password, database: @database,  idleMinWaitTime: nil, requestTimeout: nil, requireFromPresent: nil, idleMaxWaitTime: nil, restrictCollections: nil, restrictType: nil, initialSyncMaxWaitTime: nil, maxConnectRetries: nil, adaptivePolling: nil, connectionRetryWaitTime: nil, autoResyncRetries: nil, chunkSize: nil)
+    body = {
+      "username" => username,
+      "password" => password,
+      "includeSystem" => includeSystem,
+      "endpoint" => endpoint,
+      "initialSyncMaxWaitTime" => initialSyncMaxWaitTime,
+      "database" => database,
+      "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
+    }.delete_if{|k,v| v.nil?}
+    request = @@request.merge({ :body => body.to_json })
+    result = self.class.put("/_db/#{@database}/_api/replication/make-slave", request)
+    self.class.return_result result: result
+  end
+
+  # === USER ===
+
+  def grant(user: @@user) # TESTED
+    user = user.user if user.is_a?(ArangoUser)
+    body = { "grant" => "rw" }.to_json
+    request = @@request.merge({ :body => body })
+    result = self.class.put("/_api/user/#{user}/database/#{@database}", request)
+    self.class.return_result result: result, caseTrue: true
+  end
+
+  def revoke(user: @@user) # TESTED
+    user = user.user if user.is_a?(ArangoUser)
+    body = { "grant" => "none" }.to_json
+    request = @@request.merge({ :body => body })
+    result = self.class.put("/_api/user/#{user}/database/#{@database}", request)
+    self.class.return_result result: result, caseTrue: true
+  end
+
+  # # === UTILITY ===
+  #
+  # def return_result_async(result:, caseTrue: false)
+  #   result = result.parsed_response
+  #   if @@verbose || !result.is_a?(Hash)
+  #     result
+  #   else
+  #     if result["error"]
+  #       result["errorMessage"]
+  #     else
+  #       if caseTrue
+  #         true
+  #       else
+  #         result.delete_if{|k,v| k == "error" || k == "code"}
+  #       end
+  #     end
+  #   end
+  # end
 end