arcadedb 0.3.3 → 0.5.0

data/lib/arcade/api/operations.rb

@@ -1,5 +1,6 @@
 module Arcade
  module  Api
+   extend Primitives
 =begin
   This is a simple admin interface
 
@@ -8,7 +9,7 @@ module Arcade
   $ Arcade::Api.drop_database   <a string>  # returns true if successfull
 
   $ Arcade::Api.create_document <database>, <type>,  attributes
-  $ Arcade::Api.execute( <database> ) { <query> }
+  $ Arcade::Api.execute( <database>  [, session_id:  some_session_id ]) { <query> }
   $ Arcade::Api.query( <database> ) { <query> }
   $ Arcade::Api.get_record <database>,  rid  #  returns a hash
 
@@ -22,46 +23,53 @@ module Arcade
 
 =end
 
+    # ------------------------------ Service methods  ------------------------------------------------- #
+    # ------------------------------                  ------------------------------------------------- #
+    # ------------------------------ databases        ------------------------------------------------- #
+    #  returns an array of databases present on the database-server                                     #
 
     def self.databases
       get_data 'databases'
     end
 
+    # ------------------------------ create database  ------------------------------------------------- #
+    #  creates a database if not present                                                                #
     def self.create_database name
-      unless databases.include?( name.to_s )
-      payload = { "command" => "create database #{name}" }.to_json
-        post_data  "server", { body: payload }.merge( auth ).merge( json )
-      end
-    rescue QueryError => e
+      return if databases.include?( name.to_s )
+      payload = { "command" => "create database #{name}" }
+        post_data  "server", payload
+    rescue  Arcade::QueryError => e
       logger.fatal "Create database #{name} through \"POST create/#{name}\" failed"
       logger.fatal  e
       raise
     end
 
+    # ------------------------------  drop  database  ------------------------------------------------- #
+    #  deletes the given database                                                                       #
     def self.drop_database name
-      if databases.include?( name.to_s )
-      payload = { "command" => "drop database #{name}" }.to_json
-        post_data  "server", { body: payload }.merge( auth ).merge( json )
-      end
+      return unless databases.include?( name.to_s )
+      payload = {"command" => "drop database #{name}" }
+       post_data  "server",  payload
+    rescue Arcade::QueryError => e
+      logger.fatal "Drop database #{name} through \"POST drop database/#{name}\" failed"
+      raise
     end
     # ------------------------------  create document ------------------------------------------------- #
-    # adds a document to the database
+    # adds a document to the specified database table
     #
     # specify database-fields as hash-type parameters
     #
     # i.e   Arcade::Api.create_document 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
     #
     # returns the rid of the inserted dataset
-    # 
-    def self.create_document database, type, **attributes
-      payload = { "@type" => type }.merge( attributes ).to_json
-      logger.debug "C: #{payload}"
-      options = if session.nil?
-                  { body: payload }.merge( auth ).merge( json )
-                else
-        { body: payload }.merge( auth ).merge( json ).merge( headers: { "arcadedb-session-id" => session })
-                end
-      post_data "document/#{database}", options
+    #
+    def self.create_document database, type, session_id: nil, **attributes
+      payload = { "@type" => type }.merge( attributes )
+      if session_id.nil?
+        post_data "document/#{database}", payload
+      else
+        post_transaction "document/#{database}", payload, session_id: session_id
+      end
     end
 
     # ------------------------------  execute         ------------------------------------------------- #
@@ -71,32 +79,26 @@ module Arcade
     #
     # returns an Array of results (if propriate)
     # i.e
-    # Arcade::Api.execcute( "devel" ) { 'select from test  ' }
+    # Arcade::Api.execute( "devel" ) { 'select from test  ' }
     #  =y [{"@rid"=>"#57:0", "@type"=>"test", "name"=>"Hugo"}, {"@rid"=>"#60:0", "@type"=>"test", "name"=>"Hubert"}]
     #
-    def self.execute database, query=nil
-      pl = query.nil? ? provide_payload(yield) : provide_payload(query)
-      options =   { body: pl }.merge( auth ).merge( json )
-      unless session.nil?
-        options = options.merge( headers: { "arcadedb-session-id" => session })
+    def self.execute database, session_id: nil
+      pl = provide_payload(yield)
+      if session_id.nil?
+        post_data "command/#{database}" , pl
+      else
+        post_transaction "command/#{database}" , pl, session_id: session_id
       end
-      post_data "command/#{database}" , options
-    rescue Arcade::QueryError => e
-#        puts e.methods
-        #puts e.exception
-       # puts e.full_message
-        if   e.message =~ /retry/
-          retry
-        else
-          raise   e.message
-        end
     end
 
     # ------------------------------  query           ------------------------------------------------- #
     # same for idempotent queries
-    def self.query database, query
-      options = { body: provide_payload(query)  }.merge( auth ).merge( json )
-      post_data   "query/#{database}" , options
+    def self.query database, query, session_id: nil
+      if session_id.nil?
+        post_data   "query/#{database}" , provide_payload(query)
+      else
+        post_transaction "query/#{database}" , provide_payload(query), session_id: session_id
+      end
     end
 
     # ------------------------------  get_record      ------------------------------------------------- #
@@ -114,7 +116,7 @@ module Arcade
       if rid.rid?
       get_data  "document/#{database}/#{rid}"
       else
-        raise Arcade::Error "Get requires a rid input"
+        raise Error "Get requires a rid input"
       end
     end
 
@@ -133,20 +135,17 @@ module Arcade
     #
     def self.property database, type, **args
 
-      begin_transaction database
+      s= begin_transaction database
       success = args.map do | name, format |
-        r= execute(database) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
-        if r.nil?
-          false
-        else
-          r.keys == [ :propertyName, :typeName, :operation ] && r[:operation] == 'create property'
-        end
+        r= execute(database, session_id: s) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
+        r.nil? ?  false : r[:operation] == 'create property'
       end.uniq
       if success == [true]
-        commit database
+        commit database, session_id: s
         true
       else
-        rollback database
+        rollback database log: false, session_id: s
+        false
       end
 
 
@@ -155,54 +154,23 @@ module Arcade
     # ------------------------------ index            ------------------------------------------------- #
     def self.index database, type,  name ,  *properties
       properties = properties.map( &:to_s )
-      unique_requested = "unique" if properties.delete("unique")  
+      unique_requested = "unique" if properties.delete("unique")
       unique_requested = "notunique" if  properties.delete("notunique" )
       automatic = true if
       properties << name  if properties.empty?
-  #    puts " create index  #{type.to_s}[#{name.to_s}] on #{type} ( #{properties.join(',')} ) #{unique_requested}" 
-      #    VV 22.10: providing an index-name raises an  Error (  Encountered " "(" "( "" at line 1, column 44. Was expecting one of:     <EOF>      <SCHEMA> ...     <NULL_STRATEGY> ...     ";" ...     "," ...   )) )
-      #    named  indices droped for now
-      success = execute(database) {" create index   on #{type} ( #{properties.join(',')} ) #{unique_requested}" } &.first
+      success = execute(database) {" create index IF NOT EXISTS on #{type} (#{properties.join(', ')}) #{unique_requested}" } &.first
 #      puts "success: #{success}"
-      success && success.keys == [ :totalIndexed, :name, :operation ] &&   success[:operation] == 'create index' 
-
-    end
-
+       success[:operation] == 'create index'
 
-    # ------------------------------ transaction      ------------------------------------------------- #
-    #
-    def self.begin_transaction database
-      result  = Typhoeus.post Arcade::Config.base_uri + "begin/#{database}", auth
-      @session_id = result.headers["arcadedb-session-id"]
-
-      # returns the session-id 
     end
 
 
-    # ------------------------------ commit           ------------------------------------------------- #
-    def self.commit database
-    options =  auth.merge( headers: { "arcadedb-session-id" => session })
-      post_data  "commit/#{database}", options
-      @session_id =  nil
-    end
-
-    # ------------------------------ rollback         ------------------------------------------------- #
-    def  self.rollback database, publish_error=true
-      options =  auth.merge( headers: { "arcadedb-session-id" => session })
-      post_data  "rollback/#{database}", options
-      @session_id =  nil
-      raise Arcade::RollbackError "A Transaction has been rolled back"   if publish_error
-    end
-
     private
 
      def self.logger
        Database.logger
      end
 
-    def self.session
-      @session_id
-    end
 
     def self. provide_payload( the_yield, action: :post )
       unless the_yield.is_a? Hash
@@ -231,76 +199,20 @@ module Arcade
                                       [ :serializer, value.to_sym ]
                                     end
                                   when :language
-                                    if [:sql, :cypher, :gremlin, :neo4j ].include? value.to_sym
+                                    if [:sql, :cypher, :gremlin, :neo4j, :sqlscript, :graphql, :mongo ].include? value.to_sym
                                       [ :language,  value.to_sym ]
                                     end
                                   end # case
-                                end .to_h ).to_json # map
-    end
-
-    def self.get_data command, options = auth
-      result  = Typhoeus.get Arcade::Config.base_uri + command, options
-      analyse_result(result, command)
+                                end .to_h ) # map
     end
 
 
-    def self.post_data command, options = auth
-   #   puts "Post DATA #{command} #{options}"   # debug
-      i = 0; a=""
-      loop do
-        result  = Typhoeus.post Arcade::Config.base_uri + command, options
-        #  Code: 503 – Service Unavailable
-        if result.response_code.to_i == 503  #  retry two times
-          i += 1
-          raise Arcade::QueryError, JSON.parse( result.response_body, symbolize_names: true )[:result] if i > 3
-          sleep 0.1
-        else
-         a= analyse_result(result, command )
-          break
-        end
-      end
-      a
-    end
 
-    # returns the json-response
-    def self.analyse_result r, command
-      if r.success?
-          return nil  if r.response_code == 204  # no content
-          result = JSON.parse( r.response_body, symbolize_names: true )[:result]
-          if result == [{}]
-           []
-          else
-            result
-          end
-        elsif r.timed_out?
-          raise Arcade::Error "Timeout Error", caller
-          []
-        elsif r.response_code > 0
-          logger.error  "Execution Failure – Code: #{ r.response_code } – #{r.status_message} "
-          error_message = JSON.parse( r.response_body, symbolize_names: true )
-          logger.error  "ErrorMessage:  #{ error_message[:detail]} "
-          if error_message[:detail] =~ /Duplicated key/
-            raise Arcade::IndexError, error_message[:detail]
-          else
-          # available fields:  :detail, :exception, error
-            puts  error_message[:detail]
-            #raise  error_message[:detail], caller
-          end
-        end
-    end
     def self.auth
        @a ||= { httpauth: :basic,
-         username: Arcade::Config.admin[:user],
-         password: Arcade::Config.admin[:pass] }
+         username: Config.admin[:user],
+         password: Config.admin[:pass] }
     end
 
-    def self.json
-      { headers: { "Content-Type" => "application/json"} }
-    end
-#  not tested
-    def self.delete_data command
-      result  = Typhoeus.delete Arcade::Config.base_uri + command, auth
-      analyse_result(result, command)
-    end
   end
 end

data/lib/arcade/api/primitives.rb

@@ -0,0 +1,126 @@
+module Arcade
+ module  Api
+   module Primitives
+
+  # This module handles the interaction with the database through HTTPX
+  #
+   # ------------------------------  http ------------------------------------------------------------ #
+   # persistent http handle to the database
+
+    def http
+#     break_on = -> (response) { response.status == 500  }
+      @http ||= HTTPX.plugin(:basic_auth).basic_auth(auth[:username], auth[:password])
+                  .plugin(:persistent)
+                  .plugin(:circuit_breaker)
+   #               .plugin(:circuit_breaker, circuit_breaker_break_on: break_on)
+    end
+
+    # ------------------------------  get data -------------------------------------------------------- #
+    def get_data command
+      case response = http.get( Config.base_uri + command )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+         raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+      else
+        #   # http error
+             raise   response
+      end
+
+      JSON.parse( response.body, symbolize_names: true )[:result]
+      #      alternative to `raise for status `
+#      case response = http.basic_auth(auth[:username], auth[:password]).get( Config.base_uri + command )
+#      in { status: 200..203, body:  }
+#        puts "success: #{JSON.parse(body, symbolize_names: true)[:result]}"
+#      in { status: 400..499, body:  }
+#        puts "client error: #{body.json}"
+#      in { status: 500.., body:  }
+#          puts "server error: #{body.to_s}"
+#      in { error: error  }
+#          puts "error: #{error.message}"
+#      else
+#          raise "unexpected: #{response}"
+#      end
+#      puts "result : #{response}"
+#      puts "code: #{response.status}"
+#      analyse_result(response, command)
+    end
+
+    # ------------------------------ post data -------------------------------------------------------- #
+    def post_data command,  payload
+      case response = http.post( Config.base_uri + command, json:  payload )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+           detail = response.json( symbolize_names: true )[:detail]
+           if  detail =~ /Please retry the operation/ 
+             logger.error "--------------------------------"
+             logger.error " ----> Operation repeated <---- "
+             logger.error detail
+             logger.error "The query --> #{payload.inspect}"
+             logger.error "--------------------------------"
+             sleep 1
+             post_data command,  payload
+           else
+           raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+           end
+      else
+        #   # http error
+             raise   response
+      end
+  #    response.raise_for_status
+    end
+
+    # ------------------------------ transaction      ------------------------------------------------- #
+    #
+    # The payload, optional as a JSON, accepts the following parameters:
+    # isolationLevel:  READ_COMMITTED (default)  or REPEATABLE_READ.  (not implemented)
+    #
+    def begin_transaction database
+      result  = http.post Config.base_uri + "begin/#{database}"
+      # returns the session-id
+      result.headers["arcadedb-session-id"] 
+    end
+
+    # ------------------------------ post transaction ------------------------------------------------- #
+    def post_transaction command, params, session_id:
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      case response = http_a.post( Config.base_uri + command, json:  params )
+        in {status: 200..299}
+          # success
+        JSON.parse( response.body, symbolize_names: true )[:result]
+         in {status: 400..}
+           ## debug
+#          puts "Command: #{command}"
+#           puts "params: #{params}"
+#           puts response.json( symbolize_names: true  )
+           raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+      else
+        #   # http error
+             raise   response
+      end
+    end
+
+    # ------------------------------ commit           ------------------------------------------------- #
+    def commit database, session_id:
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      response = http_a.post( Config.base_uri + "commit/#{database}" )
+      response.status  #  returns 204 --> success
+                       #          403 --> invalid credentials
+                       #          500 --> Transaction  not begun
+
+    end
+
+    # ------------------------------ rollback         ------------------------------------------------- #
+    def rollback database, session_id: , log: true
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      response = http_a.post( Config.base_uri + "rollback/#{database}" )
+      logger.info  "A Transaction has been rolled back"   if log
+      response.status    # returns 500 !
+    end
+  end
+ end
+end
+