orientdb4r 0.2.7 → 0.2.8

data/lib/orientdb4r/rest/client.rb

@@ -17,7 +17,9 @@ module Orientdb4r
       options_pattern = { :host => 'localhost', :port => 2480, :ssl => false }
       verify_and_sanitize_options(options, options_pattern)
 
-      @nodes << RestClientNode.new(options[:host], options[:port], options[:ssl])
+      raise ArgumentError, 'no node type defined in context' unless Orientdb4r::context.include? :node_type
+      @nodes << Orientdb4r::context[:node_type].new(options[:host], options[:port], options[:ssl])
+      Orientdb4r::logger.debug "client with communication driver: #{a_node.identification}"
     end
 
 
@@ -89,12 +91,9 @@ module Orientdb4r
 
       u = options.include?(:user) ? options[:user] : user
       p = options.include?(:password) ? options[:password] : password
-      begin
-        # uses one-off request because of additional authentication to the server
-        response = a_node.oo_request :method => :get, :user => u, :password => p, :uri => 'server'
-      rescue
-        raise OrientdbError
-      end
+
+      # uses one-off request because of additional authentication to the server
+      response = a_node.oo_request :method => :get, :user => u, :password => p, :uri => 'server'
       process_response(response)
     end
 
@@ -110,13 +109,10 @@ module Orientdb4r
 
       u = options.include?(:user) ? options[:user] : user
       p = options.include?(:password) ? options[:password] : password
-      begin
-        # uses one-off request because of additional authentication to the server
-        response = a_node.oo_request :method => :post, :user => u, :password => p, \
-            :uri => "database/#{options[:database]}/#{options[:type]}"
-      rescue
-        raise OrientdbError
-      end
+
+      # uses one-off request because of additional authentication to the server
+      response = a_node.oo_request :method => :post, :user => u, :password => p, \
+          :uri => "database/#{options[:database]}/#{options[:type]}"
       process_response(response)
     end
 
@@ -135,13 +131,12 @@ module Orientdb4r
 
       u = options.include?(:user) ? options[:user] : user
       p = options.include?(:password) ? options[:password] : password
-      begin
-        # uses one-off request because of additional authentication to the server
-        response = a_node.oo_request :method => :get, :user => u, :password => p, \
-            :uri => "database/#{options[:database]}"
-      rescue
-        raise NotFoundError
-      end
+
+      # uses one-off request because of additional authentication to the server
+      response = a_node.oo_request :method => :get, :user => u, :password => p, \
+          :uri => "database/#{options[:database]}"
+
+      # NotFoundError cannot be raised - no way how to recognize from 401 bad auth
       process_response(response)
     end
 
@@ -156,12 +151,12 @@ module Orientdb4r
 
       limit = ''
       limit = "/#{options[:limit]}" if !options.nil? and options.include?(:limit)
-      begin
-        response = a_node.request(:method => :get, :uri => "query/#{@database}/sql/#{CGI::escape(sql)}#{limit}")
-      rescue
-        raise NotFoundError
+
+      response = a_node.request(:method => :get, :uri => "query/#{@database}/sql/#{CGI::escape(sql)}#{limit}")
+      entries = process_response(response) do
+        raise NotFoundError, 'record not found' if response.body =~ /ORecordNotFoundException/
       end
-      entries = process_response(response)
+
       rslt = entries['result']
       # mixin all document entries (they have '@class' attribute)
       rslt.each { |doc| doc.extend Orientdb4r::DocumentMetadata unless doc['@class'].nil? }
@@ -171,11 +166,7 @@ module Orientdb4r
 
     def command(sql) #:nodoc:
       raise ArgumentError, 'command is blank' if blank? sql
-      begin
-        response = a_node.request(:method => :post, :uri => "command/#{@database}/sql/#{CGI::escape(sql)}")
-      rescue
-        raise OrientdbError
-      end
+      response = a_node.request(:method => :post, :uri => "command/#{@database}/sql/#{CGI::escape(sql)}")
       process_response(response)
     end
 
@@ -186,22 +177,19 @@ module Orientdb4r
       raise ArgumentError, "class name is blank" if blank?(name)
 
       if compare_versions(server_version, '1.1.0') >= 0
-        begin
-          response = a_node.request(:method => :get, :uri => "class/#{@database}/#{name}")
-        rescue
-          raise NotFoundError
+        response = a_node.request(:method => :get, :uri => "class/#{@database}/#{name}")
+        rslt = process_response(response) do
+          raise NotFoundError, 'class not found' if response.body =~ /Invalid class/
         end
-        rslt = process_response(response)
+
         classes = [rslt]
       else
         # there is bug in REST API [v1.0.0, fixed in r5902], only data are returned
         # workaround - use metadate delivered by 'connect'
-        begin
-          response = a_node.request(:method => :get, :uri => "connect/#{@database}")
-        rescue
-          raise NotFoundError
+        response = a_node.request(:method => :get, :uri => "connect/#{@database}")
+        connect_info = process_response(response) do
+          raise NotFoundError, 'class not found' if response.body =~ /Invalid class/
         end
-        connect_info = process_response response
 
         classes = connect_info['classes'].select { |i| i['name'] == name }
         raise NotFoundError, "class not found, name=#{name}" unless 1 == classes.size
@@ -225,13 +213,12 @@ module Orientdb4r
     # ----------------------------------------------------------------- DOCUMENT
 
     def create_document(doc)
-      begin
-        response = a_node.request(:method => :post, :uri => "document/#{@database}", \
-            :content_type => 'application/json', :data => doc.to_json)
-      rescue
-        raise DataError
+      response = a_node.request(:method => :post, :uri => "document/#{@database}", \
+          :content_type => 'application/json', :data => doc.to_json)
+      rid = process_response(response)  do
+        raise DataError, 'validation problem' if response.body =~ /OValidationException/
       end
-      rid = process_response(response)
+
       raise ArgumentError, "invalid RID format, RID=#{rid}" unless rid =~ /^#[0-9]+:[0-9]+/
       rid
     end
@@ -242,12 +229,12 @@ module Orientdb4r
       # remove the '#' prefix
       rid = rid[1..-1] if rid.start_with? '#'
 
-      begin
-        response = a_node.request(:method => :get, :uri => "document/#{@database}/#{rid}")
-      rescue
-        raise NotFoundError
+      response = a_node.request(:method => :get, :uri => "document/#{@database}/#{rid}")
+      rslt = process_response(response) do
+        raise NotFoundError, 'record not found' if response.body =~ /ORecordNotFoundException/
+        raise NotFoundError, 'record not found' if response.body =~ /Record with id .* was not found/ # why after delete?
       end
-      rslt = process_response(response)
+
       rslt.extend Orientdb4r::DocumentMetadata
       rslt
     end
@@ -261,11 +248,11 @@ module Orientdb4r
       rid = doc.delete '@rid'
       rid = rid[1..-1] if rid.start_with? '#'
 
-      begin
-        a_node.request(:method => :put, :uri => "document/#{@database}/#{rid}", \
-            :content_type => 'application/json', :data => doc.to_json)
-      rescue
-        raise DataError
+      response = a_node.request(:method => :put, :uri => "document/#{@database}/#{rid}", \
+          :content_type => 'application/json', :data => doc.to_json)
+      process_response(response) do
+        raise DataError, 'concurrent modification' if response.body =~ /OConcurrentModificationException/
+        raise DataError, 'validation problem' if response.body =~ /OValidationException/
       end
       # empty http response
     end
@@ -276,10 +263,9 @@ module Orientdb4r
       # remove the '#' prefix
       rid = rid[1..-1] if rid.start_with? '#'
 
-      begin
-        response = a_node.request(:method => :delete, :uri => "document/#{@database}/#{rid}")
-      rescue
-        raise DataError
+      response = a_node.request(:method => :delete, :uri => "document/#{@database}/#{rid}")
+      process_response(response) do
+        raise NotFoundError, 'record not found' if response.body =~ /ORecordNotFoundException/
       end
       # empty http response
     end
@@ -293,18 +279,22 @@ module Orientdb4r
       def process_response(response)
         raise ArgumentError, 'response is null' if response.nil?
 
+        if block_given?
+          yield
+        end
+
+
         # return code
-        if 200 != response.code and 2 == (response.code / 100)
-          Orientdb4r::logger.warn "expected return code 200, but received #{response.code}"
-        elsif 401 == response.code
-          raise UnauthorizedError, '401 Unauthorized'
-        elsif 200 != response.code
-          msg = response.body.gsub("\n", ' ')
-          msg = "#{msg[0..100]} ..." if msg.size > 100
-          raise OrientdbError, "unexpected return code, code=#{response.code}, body=#{msg}"
+        if 401 == response.code
+          raise UnauthorizedError, compose_error_message(response)
+        elsif 500 == response.code
+          raise ServerError, compose_error_message(response)
+        elsif 2 != (response.code / 100)
+          raise OrientdbError, "unexpected return code, code=#{response.code}, body=#{compose_error_message(response)}"
         end
 
-        content_type = response.headers[:content_type]
+        content_type = response.headers[:content_type] if Orientdb4r::context[:node_type] == RestClientNode
+        content_type = response.headers['Content-Type'] if Orientdb4r::context[:node_type] == ExconNode
         content_type ||= 'text/plain'
 
         rslt = case
@@ -319,6 +309,17 @@ module Orientdb4r
         rslt
       end
 
+
+      ###
+      # Composes message of an error raised if the HTTP response doesn't
+      # correspond with expectation.
+      def compose_error_message(http_response, max_len=200)
+        msg = http_response.body.gsub("\n", ' ')
+        msg = "#{msg[0..max_len]} ..." if msg.size > max_len
+        msg
+      end
+
+
       # @deprecated
       def process_restclient_response(response, options={})
         raise ArgumentError, 'response is null' if response.nil?

data/lib/orientdb4r/rest/excon_node.rb

@@ -0,0 +1,80 @@
+require 'excon'
+
+module Orientdb4r
+
+  ###
+  # This class represents a single sever/node in the Distributed Multi-Master Architecture
+  # accessible view REST API and 'excon' library on the client side.
+  class ExconNode < RestNode
+
+
+    def identification #:nodoc:
+      'excon'
+    end
+
+
+    def oo_request(options) #:nodoc:
+      address = "#{url}/#{options[:uri]}"
+      headers = {}
+      headers['Authorization'] = basic_auth_header(options[:user], options[:password]) if options.include?(:user)
+      headers['Cookie'] = "#{SESSION_COOKIE_NAME}=#{session_id}" unless session_id.nil?
+      response = ::Excon.send options[:method].to_sym, address, :headers => headers
+
+      def response.code
+        status
+      end
+
+      response
+    end
+
+
+    def request(options) #:nodoc:
+      raise OrientdbError, 'long life connection not initialized' if @connection.nil?
+
+      head = headers
+      head['Content-Type'] = options[:content_type] if options.include? :content_type
+      options[:headers] = head
+
+      options[:body] = options[:data] if options.include? :data # just other naming convention
+      options.delete :data
+      options[:path] = options[:uri] if options.include? :uri   # just other naming convention
+      options.delete :uri
+
+      response = @connection.request options
+
+      def response.code
+        status
+      end
+
+      response
+    end
+
+
+    def post_connect(user, password, http_response) #:nodoc:
+      @basic_auth = basic_auth_header(user, password)
+
+      cookies = CGI::Cookie::parse(http_response.headers['Set-Cookie'])
+      @session_id = cookies[SESSION_COOKIE_NAME][0]
+
+      @connection = Excon.new(url) if @connection.nil?
+    end
+
+
+    def cleanup #:nodoc:
+      @session_id = nil
+      @basic_auth = nil
+      @connection = nil
+    end
+
+
+    private
+
+      ###
+      # Get request headers prepared with session ID and Basic Auth.
+      def headers
+        {'Authorization' => @basic_auth, 'Cookie' => "#{SESSION_COOKIE_NAME}=#{session_id}"}
+      end
+
+  end
+
+end

data/lib/orientdb4r/rest/node.rb

@@ -8,7 +8,7 @@ module Orientdb4r
     # Name of cookie that represents a session.
     SESSION_COOKIE_NAME = 'OSESSIONID'
 
-    attr_reader :ssl
+    attr_reader :ssl, :session_id
 
     ###
     # Constructor.
@@ -31,10 +31,6 @@ module Orientdb4r
     # after successful connect.
     def post_connect(user, password, http_response)
       raise NotImplementedError, 'this should be overridden by subclass'
-
-# excon
-#      cookies = CGI::Cookie::parse(http_response.headers['Set-Cookie'])
-#      @session_id = cookies[SESSION_COOKIE_NAME][0]
     end
 
 
@@ -60,20 +56,6 @@ module Orientdb4r
       "Basic #{b64}"
     end
 
-
-# excon   ###
-#    # Get request headers prepared with session ID and Basic Auth.
-#    def headers
-#      {'Authorization' => @basic_auth, 'Cookie' => "#{SESSION_COOKIE_NAME}=#{session_id}"}
-#    end
-
-# excon   ###
-#    # Gets a connection object which is reusable across multiple requests.
-#    def connection
-#      @connection = Excon.new(url) if @connection.nil?
-#      @connection
-#    end
-
   end
 
 end

data/lib/orientdb4r/rest/restclient_node.rb

@@ -1,3 +1,5 @@
+require 'rest_client'
+
 module Orientdb4r
 
   ###
@@ -5,7 +7,10 @@ module Orientdb4r
   # accessible view REST API and 'rest-client' library on the client side.
   class RestClientNode < RestNode
 
-    attr_reader :session_id
+
+    def identification #:nodoc:
+      'rest-client'
+    end
 
 
     def oo_request(options) #:nodoc:
@@ -13,13 +18,10 @@ module Orientdb4r
         options[:url] = "#{url}/#{options[:uri]}"
         options.delete :uri
         response = ::RestClient::Request.new(options).execute
-      rescue ::RestClient::Unauthorized
-        # fake the response object
-        response = "401 Unauthorized"
-        def response.code
-          401
-        end
+      rescue ::RestClient::Exception => e
+        response = transform_error2_response(e)
       end
+
       response
     end
 
@@ -37,12 +39,8 @@ module Orientdb4r
         else
           response = @resource[options[:uri]].send options[:method].to_sym, data
         end
-      rescue ::RestClient::Unauthorized
-        # fake the response object
-        response = "401 Unauthorized"
-        def response.code
-          401
-        end
+      rescue ::RestClient::Exception => e
+        response = transform_error2_response(e)
       end
 
       response
@@ -65,6 +63,23 @@ module Orientdb4r
       @resource = nil
     end
 
+
+    private
+
+      ###
+      # Fakes an error thrown by the library into a response object with methods
+      # 'code' and 'body'.
+      def transform_error2_response(error)
+        response = ["#{error.message}: #{error.http_body}", error.http_code]
+        def response.body
+          self[0]
+        end
+        def response.code
+          self[1]
+        end
+        response
+      end
+
   end
 
 end

data/lib/orientdb4r/version.rb

@@ -2,6 +2,7 @@ module Orientdb4r
 
   # Version history.
   VERSION_HISTORY = [
+    ['0.2.8', '2012-07-16', "New exception handling, added feature Client#create_class(:properties)"],
     ['0.2.7', '2012-07-07', "Added method Client#class_exists?"],
     ['0.2.6', '2012-07-03', "BF #8, BF #6"],
     ['0.2.5', '2012-07-01', "Added 'get_database' into database CRUD"],

data/lib/orientdb4r.rb

@@ -1,7 +1,6 @@
 require 'json'
 require 'base64'
 require 'logger'
-require 'rest_client'
 require 'orientdb4r/version'
 
 
@@ -18,6 +17,7 @@ module Orientdb4r
   autoload :Node,           'orientdb4r/node'
   autoload :RestNode,       'orientdb4r/rest/node'
   autoload :RestClientNode, 'orientdb4r/rest/restclient_node'
+  autoload :ExconNode,      'orientdb4r/rest/excon_node'
 
 
   class << self
@@ -43,7 +43,7 @@ module Orientdb4r
       RestClient.proxy = url
     end
 
-    attr_accessor :logger
+    attr_accessor :logger, :context
 
   end
 
@@ -58,6 +58,10 @@ module Orientdb4r
   # Error indicating that access to the resource requires user authentication.
   class UnauthorizedError < OrientdbError; end
 
+  ###
+  # Error indicating that the server encountered an unexpected condition which prevented it from fulfilling the request.
+  class ServerError < OrientdbError; end
+
   ###
   # Error indicating problems with communicating with the database.
   class ConnectionError < OrientdbError; end
@@ -79,7 +83,13 @@ Orientdb4r::logger = Logger.new(STDOUT)
 Orientdb4r::logger.level = Logger::INFO
 
 Orientdb4r::logger.info \
-  "Orientdb4r #{Orientdb4r::VERSION}, running on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+    "Orientdb4r #{Orientdb4r::VERSION}, running on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+
+
+# Configuration of context.
+Orientdb4r::context = {}
+Orientdb4r::context[:node_type] = Orientdb4r::RestClientNode
+#Orientdb4r::context[:node_type] = Orientdb4r::ExconNode
 
 
 #Orientdb4r::logger.level = Logger::DEBUG

data/test/test_database.rb

@@ -42,6 +42,10 @@ class TestDatabase < Test::Unit::TestCase
     assert_raise Orientdb4r::UnauthorizedError do
       @client.connect :database => 'unknown_db', :user => 'admin', :password => 'admin'
     end
+    # bad DB name with '/' => wrong REST resource
+    assert_raise Orientdb4r::ServerError do
+      @client.connect :database => 'temp/temp', :user => 'admin', :password => 'admin'
+    end
     # bad credentials
     assert_raise Orientdb4r::UnauthorizedError do
       @client.connect :database => 'temp', :user => 'admin1', :password => 'admin'
@@ -97,7 +101,7 @@ class TestDatabase < Test::Unit::TestCase
   ###
   # GET DATABASE
   def test_get_database
-    # not connected
+    # not connected - allowed with additional authentication
     assert_nothing_thrown do @client.get_database :database => 'temp', :user => 'admin', :password => 'admin' ; end
     assert_raise Orientdb4r::ConnectionError do @client.get_database; end
     # connected
@@ -108,12 +112,15 @@ class TestDatabase < Test::Unit::TestCase
     assert_not_nil rslt
     assert_instance_of Hash, rslt
     assert rslt.include? 'classes'
-    assert @client.database_exists?(:database => 'temp', :user => 'admin', :password => 'admin')
-    assert @client.database_exists?(:database => 'temp') # use credentials of logged in user
 
     # bad databases
     assert_raise Orientdb4r::UnauthorizedError do @client.get_database :database => 'UnknownDB'; end
-    assert_raise Orientdb4r::NotFoundError do @client.get_database :database => 'temp/admin'; end
+    assert_raise Orientdb4r::ServerError do @client.get_database :database => 'temp/admin'; end # bad REST resource
+
+
+    # database_exists?
+    assert @client.database_exists?(:database => 'temp', :user => 'admin', :password => 'admin')
+    assert @client.database_exists?(:database => 'temp') # use credentials of logged in user
     assert !@client.database_exists?(:database => 'UnknownDB')
     assert !@client.database_exists?(:database => 'temp/admin')
   end

data/test/test_ddo.rb

@@ -68,7 +68,7 @@ class TestDdo < Test::Unit::TestCase
     assert @client.class_exists?(CLASS)
     assert_nothing_thrown do @client.get_class(CLASS); end # raises an Error if no class found
     # already exist
-    assert_raise Orientdb4r::OrientdbError do @client.create_class(CLASS); end
+    assert_raise Orientdb4r::ServerError do @client.create_class(CLASS); end
 
     # create with :force=>true
     assert_nothing_thrown do @client.create_class(CLASS, :force => true); end
@@ -85,7 +85,7 @@ class TestDdo < Test::Unit::TestCase
     assert_equal 'OUser', clazz.super_class
 
     # bad super class
-    assert_raise Orientdb4r::OrientdbError do @client.create_class(CLASS, :extends => 'nonExistingSuperClass'); end
+    assert_raise Orientdb4r::ServerError do @client.create_class(CLASS, :extends => 'nonExistingSuperClass'); end
   end
 
 
@@ -121,7 +121,7 @@ class TestDdo < Test::Unit::TestCase
     assert_nil clazz.property(:prop1).linked_class
 
     # already exist
-    assert_raise Orientdb4r::OrientdbError do @client.create_property(CLASS, 'prop1', :integer); end
+    assert_raise Orientdb4r::ServerError do @client.create_property(CLASS, 'prop1', :integer); end
   end
 
 
@@ -135,12 +135,12 @@ class TestDdo < Test::Unit::TestCase
     assert_equal 'OUser', clazz.property(:friends).linked_class
 
     # unknow linked-class
-    assert_raise Orientdb4r::OrientdbError do
+    assert_raise Orientdb4r::ServerError do
       @client.create_property(CLASS, 'friends2', :linkset, :linked_class => 'UnknownClass')
     end
 
     # already exist
-    assert_raise Orientdb4r::OrientdbError do
+    assert_raise Orientdb4r::ServerError do
       @client.create_property(CLASS, 'friends', :linkset, :linked_class => 'OUser');
     end
   end
@@ -183,6 +183,44 @@ class TestDdo < Test::Unit::TestCase
     assert_nil user.min
     assert_nil user.max
     assert_equal 'OUser', user.linked_class
+
+
+    # properties direct as parametr
+    @client.drop_class CLASS
+    assert_nothing_thrown do
+      @client.create_class(CLASS, :properties => [
+          { :property => 'prop1_q', :type => :integer },
+          { :property => 'prop2_q', :type => :string, :mandatory => true, :notnull => true, :min => 1, :max => 99 },
+          { :property => 'user_q',  :type => :linkset, :linked_class => 'OUser', :mandatory => true }
+      ])
+    end
+
+    clazz = @client.get_class(CLASS)
+    assert_equal 3, clazz.properties.size
+
+    prop1 = clazz.property(:prop1_q)
+    assert_equal 'INTEGER', prop1.type
+    assert !prop1.mandatory
+    assert !prop1.not_null
+    assert_nil prop1.min
+    assert_nil prop1.max
+    assert_nil prop1.linked_class
+
+    prop2 = clazz.property(:prop2_q)
+    assert_equal 'STRING', prop2.type
+    assert prop2.mandatory
+    assert prop2.not_null
+    assert_equal '1', prop2.min
+    assert_equal '99',  prop2.max
+    assert_nil prop2.linked_class
+
+    user = clazz.property(:user_q)
+    assert_equal 'LINKSET', user.type
+    assert user.mandatory
+    assert !user.not_null
+    assert_nil user.min
+    assert_nil user.max
+    assert_equal 'OUser', user.linked_class
   end
 
 end

data/test/test_dmo.rb

@@ -52,11 +52,11 @@ class TestDmo < Test::Unit::TestCase
     assert_equal urids.size, @client.query("SELECT FROM #{CLASS} WHERE prop2 = 'linkset'")[0]['friends'].size
 
     # table doesn't exist
-    assert_raise Orientdb4r::OrientdbError do
+    assert_raise Orientdb4r::ServerError do
       @client.command "INSERT INTO #{CLASS}x (prop1, prop2, friends) VALUES (1, 'linkset', [#{urids.join(',')}])"
     end
     # bad syntax
-    assert_raise Orientdb4r::OrientdbError do
+    assert_raise Orientdb4r::ServerError do
       @client.command 'xxx'
     end
 
@@ -94,15 +94,17 @@ class TestDmo < Test::Unit::TestCase
     assert_equal 1, gr.select { |e| e if e['@class'] == 'ORole' }.size
 
     # table doesn't exist
-    assert_raise Orientdb4r::NotFoundError do
+    assert_raise Orientdb4r::ServerError do
       @client.query 'SELECT FROM OUserX'
     end
     # bad syntax
-    assert_raise Orientdb4r::NotFoundError do
+    assert_raise Orientdb4r::ServerError do
       @client.query 'xxx'
     end
+    # record not found
+    assert_raise Orientdb4r::NotFoundError do @client.query 'SELECT FROM #4:1111'; end
     # used for INSERT
-    assert_raise Orientdb4r::NotFoundError do
+    assert_raise Orientdb4r::ServerError do
       @client.query "INSERT INTO #{CLASS} (prop1, prop2, friends) VALUES (0, 'string0', [])"
     end
   end