orientdb4r 0.2.10 → 0.3.0

data/README.rdoc

@@ -63,9 +63,7 @@ see Wiki page for more sample at https://github.com/veny/orientdb4r/wiki
 
 === Important Upgrade Notice
 
-* 2012-06-19 [v0.2.1]: Client#create_class - parameter given to a block has new method 'link' to define a linked property
-* 2012-06-17 [v0.2.0]: Client#get_class raises Orientdb4r::NotFoundError instead of ArgumentError
-
+* see changelog.txt
 
 
 == FEATURES/PROBLEMS

data/changelog.txt

@@ -1,20 +1,19 @@
-0.3.0 07/x/12
-===============
-- 'rest-client' replaced by 'excon' for HTTP communication with Keep-Alive
-- introduced support for distributed server
+0.3.0 2012-08-01
+- introduced support for cluster of distributed servers
+- initial strategies for load balancing: sequence, round robin
+- Keep-Alive feature: Excon HTTP library is fully working
 
-0.2.10 /07/07/21
+0.2.10 2012-07-21
 - experimental support for Excon HTTP library with Keep-Alive connection
 
-0.2.9 /07/07/18
+0.2.9 2012-07-18
 - introduced class Rid
 - added feature Client#delete_database
 
-
-0.2.8 /07/07/16
+0.2.8 2012-07-16
 - changed and stabilized exception handling
 - added feature Client#create_class(:properties)
 
-0.2.7 07/07/12
+0.2.7 2012-07-07
 - changed design to support distributed server
 - added method Client#class_exists?

data/fstudy/flat_class_perf.rb

@@ -20,7 +20,7 @@ class FlatClassPerf < FStudy::Case
     client.command 'DELETE FROM User'
   end
   def data
-    1.upto(10) do |i|
+    1.upto(10000) do |i|
       Orientdb4r::logger.info "...done: #{i}" if 0 == (i % 1000)
       first_name = dg.word
       surname = dg.word

data/lib/orientdb4r/client.rb

@@ -9,7 +9,10 @@ module Orientdb4r
     # # Regexp to validate format of providet version.
     SERVER_VERSION_PATTERN = /^\d+\.\d+\.\d+/
 
+    attr_reader :user, :password, :database
     attr_reader :server_version
+    attr_reader :nodes, :connection_library
+    attr_reader :load_balancing, :lb_strategy
 
     ###
     # Constructor.
@@ -181,7 +184,7 @@ module Orientdb4r
       opt_pattern = { :mode => :nil }
       verify_options(options, opt_pattern)
       if :strict == options[:mode]
-        response = a_node.request(:method => :get, :uri => "connect/#{@database}") # TODO there cannot be REST
+        response = call_server(:method => :get, :uri => "connect/#{@database}") # TODO there cannot be REST
         connect_info = process_response response
         children = connect_info['classes'].select { |i| i['superClass'] == name }
         unless children.empty?
@@ -256,8 +259,35 @@ module Orientdb4r
 
     protected
 
-      def a_node
-        @nodes[0]
+      ###
+      # Calls the server with a specific task.
+      # Returns a response according to communication channel (e.g. HTTP response).
+      def call_server(options)
+        lb_all_bad_msg = 'all nodes failed to communicate with server!'
+        response = nil
+
+        # credentials if not defined explicitly
+        options[:user] = user unless options.include? :user
+        options[:password] = password unless options.include? :password
+
+        idx = lb_strategy.node_index
+        raise OrientdbError, lb_all_bad_msg if idx.nil? # no good node found
+
+        begin
+          node = @nodes[idx]
+          begin
+            response = node.request options
+            lb_strategy.good_one idx
+            return response
+
+          rescue NodeError => e
+            Orientdb4r::logger.error "node error, index=#{idx}, msg=#{e.message}, #{node}"
+            lb_strategy.bad_one idx
+            idx = lb_strategy.node_index
+          end
+        end until idx.nil? and response.nil? # both 'nil' <= we tried all nodes and all with problem
+
+        raise OrientdbError, lb_all_bad_msg
       end
 
 
@@ -267,6 +297,7 @@ module Orientdb4r
         raise ConnectionError, 'not connected' unless @connected
       end
 
+
       ###
       # Around advice to meassure and print the method time.
       def time_around(&block)

data/lib/orientdb4r/load_balancing.rb

@@ -0,0 +1,89 @@
+module Orientdb4r
+
+  ###
+  # Base class for implementation of load balancing strategy.
+  class LBStrategy
+
+    # If occures a new try to communicate from node can be tested.
+    RECOVERY_TIMEOUT = 30
+
+    attr_reader :nodes_count, :bad_nodes
+
+    ###
+    # Constructor.
+    def initialize nodes_count
+      @nodes_count = nodes_count
+      @bad_nodes = {}
+    end
+
+    ###
+    # Gets index of node to be used for next request
+    # or 'nil' if there is no one next.
+    def node_index
+      raise NotImplementedError, 'this should be overridden in subclass'
+    end
+
+    ###
+    # Marks an index as good that means it can be used for next server calls.
+    def good_one(idx)
+      @bad_nodes.delete idx
+    end
+
+    ###
+    # Marks an index as bad that means it will be not used until:
+    # * there is other 'good' node
+    # * timeout
+    def bad_one(idx)
+      @bad_nodes[idx] = Time.now
+    end
+
+    protected
+
+      def search_next_good(bad_idx)
+        Orientdb4r::logger.warn "identified bad node, idx=#{bad_idx}, age=#{Time.now - @bad_nodes[bad_idx]} [s]"
+        1.upto(nodes_count) do |i|
+          candidate = (i + bad_idx) % nodes_count
+          unless @bad_nodes.include? candidate
+            Orientdb4r::logger.debug "found good node, idx=#{candidate}"
+            return candidate
+          end
+        end
+
+        # TODO implement search based on LRU for next round
+
+        Orientdb4r::logger.error 'no nodes more, all invalid'
+        nil
+      end
+
+  end
+
+  ###
+  # Implementation of Sequence strategy.
+  # Assigns work in the order of nodes defined by the client initialization.
+  class Sequence < LBStrategy
+
+    def node_index #:nodoc:
+      @last_index = 0 if @last_index.nil?
+
+      @last_index = search_next_good(@last_index) if @bad_nodes.include? @last_index
+      @last_index
+    end
+
+  end
+
+  ###
+  # Implementation of Round Robin strategy.
+  # Assigns work in round-robin order per nodes defined by the client initialization.
+  class RoundRobin < LBStrategy
+
+    def node_index #:nodoc:
+      @last_index = -1 if @last_index.nil?
+
+      @last_index = (@last_index + 1) % nodes_count
+      @last_index = search_next_good(@last_index) if @bad_nodes.include? @last_index
+      @last_index
+    end
+
+  end
+
+end

data/lib/orientdb4r/node.rb

@@ -7,6 +7,7 @@ module Orientdb4r
     include Utils
 
     attr_reader :host, :port # they are immutable
+    attr_reader :session_id
 
     ###
     # Constructor.
@@ -21,7 +22,7 @@ module Orientdb4r
     ###
     # Cleans up resources used by the node.
     def cleanup
-      raise NotImplementedError, 'this should be overridden by subclass'
+      @session_id = nil
     end
 
 
@@ -31,6 +32,11 @@ module Orientdb4r
       raise NotImplementedError, 'this should be overridden by subclass'
     end
 
+
+    def to_s  #:nodoc:
+      "Node(host=#{host},port=#{port})"
+    end
+
   end
 
 end

data/lib/orientdb4r/rest/client.rb

@@ -9,35 +9,45 @@ module Orientdb4r
     before [:create_document, :get_document, :update_document, :delete_document], :assert_connected
     around [:query, :command], :time_around
 
-    attr_reader :user, :password, :database, :http_lib
-
 
     def initialize(options) #:nodoc:
       super()
       options_pattern = { :host => 'localhost', :port => 2480, :ssl => false,
-                          :nodes => :optional,
-                          :connection_library => :restclient}
+                          :nodes => :optional, :load_balancing => :sequence,
+                          :connection_library => Orientdb4r::connection_library}
       verify_and_sanitize_options(options, options_pattern)
 
       # fake nodes for single server
-      unless options[:nodes].nil?
+      if options[:nodes].nil?
         options[:nodes] = [{:host => options[:host], :port => options[:port], :ssl => options[:ssl]}]
       end
       raise ArgumentError, 'nodes has to be arrray' unless options[:nodes].is_a? Array
 
-      node_clazz = case options[:connection_library]
+      # instantiate nodes accroding to HTTP library
+      @connection_library = options[:connection_library]
+      node_clazz = case connection_library
         when :restclient then Orientdb4r::RestClientNode
         when :excon then Orientdb4r::ExconNode
-        else raise ArgumentError, "unknown connection library: #{options[:connection_library]}"
+        else raise ArgumentError, "unknown connection library: #{connection_library}"
       end
-      @http_lib = options[:connection_library]
 
+      # nodes
       options[:nodes].each do |node_options|
-        @nodes << node_clazz.new(options[:host], options[:port], options[:ssl])
         verify_and_sanitize_options(node_options, options_pattern)
+        @nodes << node_clazz.new(node_options[:host], node_options[:port], node_options[:ssl])
+      end
+
+      # load balancing
+      @load_balancing = options[:load_balancing]
+      @lb_strategy = case load_balancing
+        when :sequence then Orientdb4r::Sequence.new nodes.size
+        when :round_robin then Orientdb4r::RoundRobin.new nodes.size
+        else raise ArgumentError, "unknow load balancing type: #{load_balancing}"
       end
 
-      Orientdb4r::logger.info "client initialized, #{@nodes.size} node(s) with connection library = #{options[:connection_library]}"
+
+      Orientdb4r::logger.info "client initialized with #{@nodes.size} node(s) "
+      Orientdb4r::logger.info "connection_library=#{options[:connection_library]}, load_balancing=#{load_balancing}"
     end
 
 
@@ -50,9 +60,8 @@ module Orientdb4r
       @user = options[:user]
       @password = options[:password]
 
-      node = a_node
       begin
-        response = node.oo_request(:method => :get, :uri => "connect/#{@database}", :user => user, :password => password)
+        response = call_server(:method => :get, :uri => "connect/#{@database}")
       rescue
         @connected = false
         @server_version = nil
@@ -63,7 +72,6 @@ module Orientdb4r
         raise ConnectionError
       end
       rslt = process_response response
-      node.post_connect(user, password, response)
       decorate_classes_with_model(rslt['classes'])
 
       # try to read server version
@@ -77,7 +85,7 @@ module Orientdb4r
         @server_version = DEFAULT_SERVER_VERSION
       end
 
-      Orientdb4r::logger.debug "successfully connected to server, version=#{server_version}, session=#{node.session_id}"
+      Orientdb4r::logger.debug "successfully connected to server, version=#{server_version}"
       @connected = true
       rslt
     end
@@ -87,7 +95,7 @@ module Orientdb4r
       return unless @connected
 
       begin
-        a_node.request(:method => :get, :uri => 'disconnect')
+        call_server(:method => :get, :uri => 'disconnect')
         # https://groups.google.com/forum/?fromgroups#!topic/orient-database/5MAMCvFavTc
         # Disconnect doesn't require you're authenticated.
         # It always returns 401 because some browsers intercept this and avoid to reuse the same session again.
@@ -107,11 +115,8 @@ module Orientdb4r
       options_pattern = { :user => :optional, :password => :optional }
       verify_options(options, options_pattern)
 
-      u = options.include?(:user) ? options[:user] : user
-      p = options.include?(:password) ? options[:password] : password
-
-      # uses one-off request because of additional authentication to the server
-      response = a_node.oo_request :method => :get, :user => u, :password => p, :uri => 'server'
+      # additional authentication allowed, overriden in 'call_server' if not defined
+      response = call_server :method => :get, :uri => 'server'
       process_response(response)
     end
 
@@ -125,34 +130,31 @@ module Orientdb4r
       }
       verify_and_sanitize_options(options, options_pattern)
 
-      u = options.include?(:user) ? options[:user] : user
-      p = options.include?(:password) ? options[:password] : password
-
-      # 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]}"
+      # additional authentication allowed, overriden in 'call_server' if not defined
+      response = call_server_one_off :method => :post, :uri => "database/#{options[:database]}/#{options[:type]}"
       process_response(response)
     end
 
 
+    #> curl --user admin:admin http://localhost:2480/database/temp
     def get_database(options=nil) #:nodoc:
       raise ArgumentError, 'options have to be a Hash' if !options.nil? and !options.kind_of? Hash
 
       if options.nil?
-        # use values from connect
+        # use database from connect
         raise ConnectionError, 'client has to be connected if no params' unless connected?
-        options = { :database => database, :user => user, :password => password }
+        options = { :database => database }
       end
 
       options_pattern = { :database => :mandatory, :user => :optional, :password => :optional }
       verify_options(options, options_pattern)
 
-      u = options.include?(:user) ? options[:user] : user
-      p = options.include?(:password) ? options[:password] : password
+      # additional authentication allowed, overriden in 'call_server' if not defined
+      params = {:method => :get, :uri => "database/#{options[:database]}"}
+      params[:user] = options[:user] if options.include? :user
+      params[:password] = options[:password] if options.include? :password
 
-      # 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]}"
+      response = call_server params
 
       # NotFoundError cannot be raised - no way how to recognize from 401 bad auth
       process_response(response)
@@ -165,12 +167,8 @@ module Orientdb4r
       }
       verify_and_sanitize_options(options, options_pattern)
 
-      u = options.include?(:user) ? options[:user] : user
-      p = options.include?(:password) ? options[:password] : password
-
-      # uses one-off request because of additional authentication to the server
-      response = a_node.oo_request :method => :delete, :user => u, :password => p, \
-          :uri => "database/#{options[:database]}"
+      # additional authentication allowed, overriden in 'call_server' if not defined
+      response = call_server_one_off :method => :delete, :uri => "database/#{options[:database]}"
       process_response(response)
     end
 
@@ -186,7 +184,7 @@ module Orientdb4r
       limit = ''
       limit = "/#{options[:limit]}" if !options.nil? and options.include?(:limit)
 
-      response = a_node.request(:method => :get, :uri => "query/#{@database}/sql/#{CGI::escape(sql)}#{limit}")
+      response = call_server(: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
@@ -200,7 +198,7 @@ module Orientdb4r
 
     def command(sql) #:nodoc:
       raise ArgumentError, 'command is blank' if blank? sql
-      response = a_node.request(:method => :post, :uri => "command/#{@database}/sql/#{CGI::escape(sql)}")
+      response = call_server(:method => :post, :uri => "command/#{@database}/sql/#{CGI::escape(sql)}")
       process_response(response)
     end
 
@@ -211,7 +209,7 @@ module Orientdb4r
       raise ArgumentError, "class name is blank" if blank?(name)
 
       if compare_versions(server_version, '1.1.0') >= 0
-        response = a_node.request(:method => :get, :uri => "class/#{@database}/#{name}")
+        response = call_server(:method => :get, :uri => "class/#{@database}/#{name}")
         rslt = process_response(response) do
           raise NotFoundError, 'class not found' if response.body =~ /Invalid class/
         end
@@ -220,7 +218,7 @@ module Orientdb4r
       else
         # there is bug in REST API [v1.0.0, fixed in r5902], only data are returned
         # workaround - use metadate delivered by 'connect'
-        response = a_node.request(:method => :get, :uri => "connect/#{@database}")
+        response = call_server(:method => :get, :uri => "connect/#{@database}")
         connect_info = process_response(response) do
           raise NotFoundError, 'class not found' if response.body =~ /Invalid class/
         end
@@ -247,7 +245,7 @@ module Orientdb4r
     # ----------------------------------------------------------------- DOCUMENT
 
     def create_document(doc) #:nodoc:
-      response = a_node.request(:method => :post, :uri => "document/#{@database}", \
+      response = call_server(:method => :post, :uri => "document/#{@database}", \
           :content_type => 'application/json', :data => doc.to_json)
       srid = process_response(response)  do
         raise DataError, 'validation problem' if response.body =~ /OValidationException/
@@ -259,7 +257,7 @@ module Orientdb4r
 
     def get_document(rid) #:nodoc:
       rid = Rid.new(rid) unless rid.is_a? Rid
-      response = a_node.request(:method => :get, :uri => "document/#{@database}/#{rid.unprefixed}")
+      response = call_server(:method => :get, :uri => "document/#{@database}/#{rid.unprefixed}")
       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?
@@ -278,7 +276,7 @@ module Orientdb4r
       rid = doc.doc_rid
       doc.delete '@rid' # will be not updated
 
-      response = a_node.request(:method => :put, :uri => "document/#{@database}/#{rid.unprefixed}", \
+      response = call_server(:method => :put, :uri => "document/#{@database}/#{rid.unprefixed}", \
           :content_type => 'application/json', :data => doc.to_json)
       process_response(response) do
         raise DataError, 'concurrent modification' if response.body =~ /OConcurrentModificationException/
@@ -291,13 +289,14 @@ module Orientdb4r
     def delete_document(rid) #:nodoc:
       rid = Rid.new(rid) unless rid.is_a? Rid
 
-      response = a_node.request(:method => :delete, :uri => "document/#{@database}/#{rid.unprefixed}")
+      response = call_server(:method => :delete, :uri => "document/#{@database}/#{rid.unprefixed}")
       process_response(response) do
         raise NotFoundError, 'record not found' if response.body =~ /ORecordNotFoundException/
       end
       # empty http response
     end
 
+
     # ------------------------------------------------------------------ Helpers
 
     private
@@ -321,8 +320,8 @@ module Orientdb4r
           raise OrientdbError, "unexpected return code, code=#{response.code}, body=#{compose_error_message(response)}"
         end
 
-        content_type = response.headers[:content_type] if http_lib == :restclient
-        content_type = response.headers['Content-Type'] if http_lib == :excon
+        content_type = response.headers[:content_type] if connection_library == :restclient
+        content_type = response.headers['Content-Type'] if connection_library == :excon
         content_type ||= 'text/plain'
 
         rslt = case

data/lib/orientdb4r/rest/excon_node.rb

@@ -7,37 +7,48 @@ module Orientdb4r
   # accessible view REST API and 'excon' library on the client side.
   class ExconNode < RestNode
 
-    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
+      verify_options(options, {:user => :mandatory, :password => :mandatory, \
+          :uri => :mandatory, :method => :mandatory, :content_type => :optional, :data => :optional})
+
+      opts = options.clone # if not cloned we change original hash map that cannot be used more with load balancing
+
+      # Auth + Cookie + Content-Type
+      opts[:headers] = headers(opts)
+      opts.delete :user
+      opts.delete :password
+
+      opts[:body] = opts[:data] if opts.include? :data # just other naming convention
+      opts.delete :data
+      opts[:path] = opts[:uri] if opts.include? :uri   # just other naming convention
+      opts.delete :uri
+
+      was_ok = false
+      begin
+        response = connection.request opts
+        was_ok = (2 == (response.status / 100))
+
+        # store session ID if received to reuse in next request
+        cookies = CGI::Cookie::parse(response.headers['Set-Cookie'])
+        sessid = cookies[SESSION_COOKIE_NAME][0]
+        if session_id != sessid
+          @session_id = sessid
+          Orientdb4r::logger.debug "new session id: #{session_id}"
+        end
+
+        def response.code
+          status
+        end
+
+      rescue Excon::Errors::SocketError
+        raise NodeError
+      end
 
-      def response.code
-        status
+      # this is workaround for a strange behavior:
+      # excon delivered magic response status '1' when previous request was not 20x
+      unless was_ok
+        connection.reset
+        Orientdb4r::logger.debug 'response code not 20x -> connection reset'
       end
 
       response
@@ -45,28 +56,47 @@ module Orientdb4r
 
 
     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
+      super
+      connection.reset
       @connection = nil
     end
 
 
+    # ---------------------------------------------------------- Assistant Stuff
+
     private
 
+      ###
+      # Gets Excon connection.
+      def connection
+        @connection ||= Excon::Connection.new(url)
+          #:read_timeout => self.class.read_timeout,
+          #:write_timeout => self.class.write_timeout,
+          #:connect_timeout => self.class.connect_timeout
+      end
+
       ###
       # Get request headers prepared with session ID and Basic Auth.
-      def headers
-        {'Authorization' => @basic_auth, 'Cookie' => "#{SESSION_COOKIE_NAME}=#{session_id}"}
+      def headers(options)
+        rslt = {'Authorization' => basic_auth_header(options[:user], options[:password])}
+        rslt['Cookie'] = "#{SESSION_COOKIE_NAME}=#{session_id}" unless session_id.nil?
+        rslt['Content-Type'] = options[:content_type] if options.include? :content_type
+        rslt
+      end
+
+      ###
+      # Gets value of the Basic Auth header.
+      def basic_auth_header(user, password)
+        b64 = Base64.encode64("#{user}:#{password}").delete("\r\n")
+        "Basic #{b64}"
       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, :session_id
+    attr_reader :ssl
 
     ###
     # Constructor.
@@ -26,36 +26,16 @@ module Orientdb4r
 
     # ----------------------------------------------------------- RestNode Stuff
 
-    ###
-    # Initializes a long life connection with credentials and session ID
-    # after successful connect.
-    def post_connect(user, password, http_response)
-      raise NotImplementedError, 'this should be overridden by subclass'
-    end
-
 
     ###
-    # Sends an one-off request to the remote server.
-    def oo_request(options)
-      raise NotImplementedError, 'this should be overridden by subclass'
-    end
-
-
-    ###
-    # Sends a request to the remote server
-    # based on a connection object which is reusable across multiple requests.
+    # Sends a HTTP request to the remote server.
+    # Use following if possible:
+    # * session_id
+    # * Keep-Alive (if possible)
     def request(options)
       raise NotImplementedError, 'this should be overridden by subclass'
     end
 
-
-    ###
-    # Gets value of the Basic Auth header.
-    def basic_auth_header(user, password)
-      b64 = Base64.encode64("#{user}:#{password}").delete("\r\n")
-      "Basic #{b64}"
-    end
-
   end
 
 end

data/lib/orientdb4r/rest/restclient_node.rb

@@ -4,35 +4,41 @@ module Orientdb4r
 
   ###
   # This class represents a single sever/node in the Distributed Multi-Master Architecture
-  # accessible view REST API and 'rest-client' library on the client side.
+  # accessible via REST API and 'rest-client' library on the client side.
   class RestClientNode < RestNode
 
-    def oo_request(options) #:nodoc:
-      begin
-        options[:url] = "#{url}/#{options[:uri]}"
-        options.delete :uri
-        response = ::RestClient::Request.new(options).execute
-      rescue ::RestClient::Exception => e
-        response = transform_error2_response(e)
-      end
+    def request(options) #:nodoc:
+      verify_options(options, {:user => :mandatory, :password => :mandatory, \
+          :uri => :mandatory, :method => :mandatory, :content_type => :optional, :data => :optional})
 
-      response
-    end
+      opts = options.clone # if not cloned we change original hash map that cannot be used more with load balancing
 
+      # URL
+      opts[:url] = "#{url}/#{opts[:uri]}"
+      opts.delete :uri
 
-    def request(options) #:nodoc:
-      raise OrientdbError, 'long life connection not initialized' if @resource.nil?
+      # data
+      data = opts.delete :data
+      data = '' if data.nil? and :post == opts[:method] # POST has to have data
+      opts[:payload] = data unless data.nil?
+
+      # headers
+      opts[:cookies] = { SESSION_COOKIE_NAME => session_id} unless session_id.nil?
 
-      data = options[:data]
-      options.delete :data
-      data = '' if data.nil? and :post == options[:method] # POST has to have data
       begin
-        # e.g. @resource['disconnect'].get
-        if data.nil?
-          response = @resource[options[:uri]].send options[:method].to_sym
-        else
-          response = @resource[options[:uri]].send options[:method].to_sym, data
+        response = ::RestClient::Request.new(opts).execute
+
+        # store session ID if received to reuse in next request
+        sessid = response.cookies[SESSION_COOKIE_NAME]
+        if session_id != sessid
+          @session_id = sessid
+          Orientdb4r::logger.debug "new session id: #{session_id}"
         end
+
+      rescue Errno::ECONNREFUSED
+        raise NodeError
+      rescue ::RestClient::ServerBrokeConnection
+        raise NodeError
       rescue ::RestClient::Exception => e
         response = transform_error2_response(e)
       end
@@ -41,23 +47,6 @@ module Orientdb4r
     end
 
 
-    def post_connect(user, password, http_response) #:nodoc:
-      @basic_auth = basic_auth_header(user, password)
-      @session_id = http_response.cookies[SESSION_COOKIE_NAME]
-
-      @resource = ::RestClient::Resource.new(url, \
-            :user => user, :password => password, \
-            :cookies => { SESSION_COOKIE_NAME => session_id})
-    end
-
-
-    def cleanup #:nodoc:
-      @session_id = nil
-      @basic_auth = nil
-      @resource = nil
-    end
-
-
     private
 
       ###

data/lib/orientdb4r/utils.rb

@@ -28,7 +28,7 @@ module Orientdb4r
 
       # set default values if missing in options
       pattern.each do |k,v|
-        options[k] = v if !v.nil? and !options.keys.include? k
+        options[k] = v if !v.nil? and :optional != v and !options.keys.include? k
       end
       options
     end

data/lib/orientdb4r/version.rb

@@ -2,6 +2,7 @@ module Orientdb4r
 
   # Version history.
   VERSION_HISTORY = [
+    ['0.3.0',   '2012-08-01', "Added support for cluster of distributed servers + load balancing"],
     ['0.2.10',  '2012-07-21', "Experimental support for Excon HTTP library with Keep-Alive connection"],
     ['0.2.9',   '2012-07-18', "Added feature Client#delete_database, New class Rid"],
     ['0.2.8',   '2012-07-16', "New exception handling, added feature Client#create_class(:properties)"],

data/lib/orientdb4r.rb

@@ -19,6 +19,8 @@ module Orientdb4r
   autoload :RestNode,       'orientdb4r/rest/node'
   autoload :RestClientNode, 'orientdb4r/rest/restclient_node'
   autoload :ExconNode,      'orientdb4r/rest/excon_node'
+  autoload :Sequence,       'orientdb4r/load_balancing'
+  autoload :RoundRobin,     'orientdb4r/load_balancing'
 
 
   class << self
@@ -44,8 +46,15 @@ module Orientdb4r
       RestClient.proxy = url
     end
 
+    ###
+    # Logger used for logging output
     attr_accessor :logger
 
+    ###
+    # Predefined connection library.
+    # Can be overriden by option in client initialization.
+    attr_accessor :connection_library
+
   end
 
 
@@ -76,6 +85,13 @@ module Orientdb4r
   # mismatched types or incorrect cardinality.
   class DataError < OrientdbError; end
 
+  # ---------------------------------------------------------- System Exceptions
+
+  ###
+  # This exception represents a fatal failure which meens that the node is not accessible more.
+  # e.g. connection broken pipe
+  class NodeError < OrientdbError; end
+
 end
 
 
@@ -83,6 +99,10 @@ end
 Orientdb4r::logger = Logger.new(STDOUT)
 Orientdb4r::logger.level = Logger::INFO
 
+# Default connection library
+Orientdb4r::connection_library = :restclient
+#Orientdb4r::connection_library = :excon
+
 Orientdb4r::logger.info \
     "Orientdb4r #{Orientdb4r::VERSION}, running on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
 

data/test/test_database.rb

@@ -6,6 +6,9 @@ require 'orientdb4r'
 # * CONNECT
 # * DISCONNECT
 # * CREATE DATABASE
+# * GET DATABASE
+# * DELETE DATABASE
+# * SERVER info
 class TestDatabase < Test::Unit::TestCase
 
   Orientdb4r::logger.level = Logger::DEBUG
@@ -23,13 +26,9 @@ class TestDatabase < Test::Unit::TestCase
     assert rslt.size > 0
     assert rslt.include? 'classes'
 
-    #assert_equal 'localhost', @client.host # TODO moved to Node; mock?
-    #assert_equal 2480, @client.port
-    #assert_equal false, @client.ssl
     assert_equal 'admin', @client.user
     assert_equal 'admin', @client.password
     assert_equal 'temp', @client.database
-    #assert_not_nil @client.session_id
     assert_not_nil @client.server_version
 
     # connection refused
@@ -63,13 +62,9 @@ class TestDatabase < Test::Unit::TestCase
     # unable to query after disconnect
     assert_raise Orientdb4r::ConnectionError do @client.query 'SELECT FROM OUser'; end
 
-    #assert_equal 'localhost', @client.host # TODO moved to Node; mock?
-    #assert_equal 2480, @client.port
-    #assert_equal false, @client.ssl
     assert_nil @client.user
     assert_nil @client.password
     assert_nil @client.database
-    #assert_nil @client.session_id
     assert_nil @client.server_version
   end
 
@@ -181,4 +176,21 @@ class TestDatabase < Test::Unit::TestCase
     assert_raise Orientdb4r::ConnectionError do @client.delete_document('#1:0'); end
   end
 
+
+  ###
+  # Tests using of session ID.
+  def test_session_id
+    client = Orientdb4r.client :instance => :new
+    assert_nil client.nodes[0].session_id
+    client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    session_id = client.nodes[0].session_id
+    assert_not_nil session_id
+    client.query 'SELECT count(*) FROM OUser'
+    assert_equal session_id, client.nodes[0].session_id
+    client.get_class 'OUser'
+    assert_equal session_id, client.nodes[0].session_id
+    client.disconnect
+    assert_nil client.nodes[0].session_id
+  end
+
 end

data/test/test_distributed.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require 'orientdb4r'
+
+###
+# This class tests communication with OrientDB cluster and load balancing.
+class TestDatabase < Test::Unit::TestCase
+
+  Orientdb4r::logger.level = Logger::DEBUG
+
+
+  ###
+  # Test inintialization of single node.
+  def test_one_node_initialization
+    client = Orientdb4r.client :instance => :new
+    assert_not_nil client.nodes
+    assert_instance_of Array, client.nodes
+    assert_equal 1, client.nodes.size
+    assert_equal 2480, client.nodes[0].port
+    assert_equal false, client.nodes[0].ssl
+  end
+
+  ###
+  # Test inintialization of more nodes.
+  def test_nodes_initialization
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}], :instance => :new
+    assert_not_nil client.nodes
+    assert_instance_of Array, client.nodes
+    assert_equal 2, client.nodes.size
+    assert_equal 2480, client.nodes[0].port
+    assert_equal 2481, client.nodes[1].port
+    assert_equal false, client.nodes[0].ssl
+    assert_equal false, client.nodes[1].ssl
+  end
+
+  ###
+  # Test default Sequence strategy.
+  def test_sequence_loadbalancing
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}], :instance => :new
+    lb_strategy = client.lb_strategy
+    assert_not_nil lb_strategy
+    assert_instance_of Orientdb4r::Sequence, lb_strategy
+    assert_equal 0, lb_strategy.node_index
+    assert_equal 0, lb_strategy.node_index
+    assert_equal client.nodes[0], client.nodes[client.lb_strategy.node_index]
+    assert_equal client.nodes[0], client.nodes[client.lb_strategy.node_index]
+  end
+
+  ###
+  # Test RoundRobin strategy.
+  def test_roundrobin_loadbalancing
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}], :load_balancing => :round_robin, :instance => :new
+    lb_strategy = client.lb_strategy
+    assert_not_nil lb_strategy
+    assert_instance_of Orientdb4r::RoundRobin, lb_strategy
+    assert_equal 0, lb_strategy.node_index
+    assert_equal 1, lb_strategy.node_index
+    assert_equal 0, lb_strategy.node_index
+    assert_equal client.nodes[1], client.nodes[client.lb_strategy.node_index]
+    assert_equal client.nodes[0], client.nodes[client.lb_strategy.node_index]
+    assert_equal client.nodes[1], client.nodes[client.lb_strategy.node_index]
+  end
+
+  def test_load_balancing_in_problems
+    # invalid port
+    client = Orientdb4r.client :port => 9999, :instance => :new
+    assert_raise Orientdb4r::ConnectionError do
+      client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    end
+    # opened port, but not REST
+    client = Orientdb4r.client :port => 2424, :instance => :new
+    assert_raise Orientdb4r::ConnectionError do
+      client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    end
+
+    # invalid ports - both
+    client = Orientdb4r.client :nodes => [{:port => 9998}, {:port => 9999}], :instance => :new
+    begin
+      client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+      assert_equal 0, 1, "Orientdb4r::ConnectionError EXPECTED"
+    rescue Orientdb4r::ConnectionError => e
+      assert_equal 'all nodes failed to communicate with server!', e.message
+    end
+
+
+    # more nodes
+
+    # first node bad, second must work (sequence)
+    client = Orientdb4r.client :nodes => [{:port => 2481}, {}], :instance => :new
+    assert_nothing_thrown do # there has to be ERROR in log
+      client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    end
+    assert_equal 1, client.lb_strategy.bad_nodes.size
+    assert client.lb_strategy.bad_nodes.include? 0
+
+    # second node bad => second call has to be realized by first one (round robin)
+    client = Orientdb4r.client :nodes => [{}, {:port => 2481}], :load_balancing => :round_robin, :instance => :new
+    assert client.lb_strategy.bad_nodes.empty?
+    client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    assert client.lb_strategy.bad_nodes.empty?
+    client.query 'SELECT FROM OUser'
+    assert_equal 1, client.lb_strategy.bad_nodes.size
+    assert client.lb_strategy.bad_nodes.include? 1
+  end
+
+end

data/test/test_utils.rb

@@ -25,6 +25,14 @@ class TestDmo < Test::Unit::TestCase
     assert_equal 2, options.size
     assert_equal 'X', options[:a]
     assert_equal 'B', options[:b]
+
+    # :optional cannot be set as default value
+    opt_pattern = {:a => :optional, :b => 'B'}
+    options = {}
+    verify_and_sanitize_options(options, opt_pattern)
+    assert_equal 1, options.size
+    assert !options.include?(:a)
+    assert_equal 'B', options[:b]
   end
 
   def test_compare_versions

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orientdb4r
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -53,6 +53,7 @@ files:
 - lib/orientdb4r.rb
 - lib/orientdb4r/chained_error.rb
 - lib/orientdb4r/client.rb
+- lib/orientdb4r/load_balancing.rb
 - lib/orientdb4r/node.rb
 - lib/orientdb4r/rest/client.rb
 - lib/orientdb4r/rest/excon_node.rb
@@ -66,6 +67,7 @@ files:
 - test/readme_sample.rb
 - test/test_database.rb
 - test/test_ddo.rb
+- test/test_distributed.rb
 - test/test_dmo.rb
 - test/test_document_crud.rb
 - test/test_utils.rb
@@ -98,6 +100,7 @@ test_files:
 - test/readme_sample.rb
 - test/test_database.rb
 - test/test_ddo.rb
+- test/test_distributed.rb
 - test/test_dmo.rb
 - test/test_document_crud.rb
 - test/test_utils.rb