vagas-orientdb4r 0.5.2

data/lib/orientdb4r.rb

@@ -0,0 +1,115 @@
+require 'json'
+require 'base64'
+require 'logger'
+require 'orientdb4r/version'
+
+
+###
+# This module represents the entry point for using the Ruby OrientDB client.
+module Orientdb4r
+
+  module Binary
+    autoload :BinClient,      'orientdb4r/bin/client'
+  end
+
+  autoload :Utils,            'orientdb4r/utils'
+  autoload :Client,           'orientdb4r/client'
+  autoload :RestClient,       'orientdb4r/rest/client'
+  autoload :Rid,              'orientdb4r/rid'
+  autoload :HashExtension,    'orientdb4r/rest/model'
+  autoload :OClass,           'orientdb4r/rest/model'
+  autoload :ChainedError,     'orientdb4r/chained_error'
+  autoload :Node,             'orientdb4r/node'
+  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'
+  autoload :DocumentMetadata, 'orientdb4r/rest/model'
+
+  MUTEX_CLIENT = Mutex.new
+
+  class << self
+
+    ###
+    # Gets a new database client or an existing for the current thread.
+    # === options
+    #  * :instance => :new
+    #  * :binary => true
+    #  * :connection_library => :restclient | :excon
+    def client options={}
+      if :new == options[:instance]
+        options.delete :instance
+        return options.delete(:binary) ? Binary::BinClient.new(options) : RestClient.new(options)
+      end
+
+      MUTEX_CLIENT.synchronize {
+        client = options.delete(:binary) ? Binary::BinClient.new(options) : RestClient.new(options)
+        Thread.current[:orientdb_client] ||= client
+        #Thread.current[:orientdb_client] ||= BinClient.new options
+      }
+    end
+
+    ###
+    # Logger used for logging output
+    attr_accessor :logger
+
+  end
+
+
+  ###
+  # Basic error that indicates an unexpected situation during the client call.
+  class OrientdbError < StandardError
+    include ChainedError
+  end
+
+  ###
+  # Error indicating that the request is malformed of invalid somehow.
+  class InvalidRequestError < OrientdbError; end
+
+  ###
+  # Error indicating that access to the resource requires user authentication.
+  class UnauthorizedError < OrientdbError; end
+
+  ###
+  # Error indicating a conflict between database state and the request
+  class StateConflictError < 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
+
+  ###
+  # Error raised to inform that an object identified by RID cannot be get.
+  class NotFoundError < OrientdbError; end
+
+  ###
+  # Error indicating that manipulation against the given data resulted in some illegal operation,
+  # 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
+
+
+# Configuration of logging.
+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::logger.level = Logger::DEBUG
+#client = Orientdb4r.client
+#client.connect :database => 'temp', :user => 'admin', :password => 'admin'

data/lib/orientdb4r/bin/client.rb

@@ -0,0 +1,86 @@
+require 'socket'
+require 'bindata'
+require 'orientdb4r/bin/constants'
+require 'orientdb4r/bin/protocol_factory'
+require 'orientdb4r/bin/io'
+require 'orientdb4r/bin/connection'
+
+module Orientdb4r
+
+  module Binary
+
+    ###
+    # This client implements the binary protocol.
+    class BinClient < Client
+      include Binary::Constants
+      include Binary::OIO
+
+      attr_reader :server_connection
+      attr_reader :db_connection
+      attr_reader :protocol
+      attr_reader :protocol_version
+
+
+      def initialize(options) #:nodoc:
+        super()
+        options_pattern = {
+          :host => 'localhost', :port => 2424
+        }
+        verify_and_sanitize_options(options, options_pattern)
+
+        @host = options[:host]
+        @port = options[:port]
+      end
+
+
+      # --------------------------------------------------------------- CONNECTION
+
+      def connect options #:nodoc:
+        options_pattern = { :database => :mandatory, :user => :mandatory, :password => :mandatory, :session => :optional, :db_type => 'document' }
+        verify_and_sanitize_options(options, options_pattern)
+
+        @socket = TCPSocket.open(@host, @port)
+        @protocol_version = BinData::Int16be.read(@socket).to_i
+
+        Orientdb4r::logger.info "Binary protocol version: #{@protocol_version}"
+
+        # check minimal protocol version which is supported
+        @protocol = ProtocolFactory.get_protocol(protocol_version)
+
+        command = protocol::DbOpenRequest.new(:protocol_version => protocol_version, :db_name => options[:database], :user => options[:user], :password => options[:password])
+
+        resp = req_resp(@socket, command, protocol::DbOpenResponse.new)
+        db_connection = Orientdb4r::Binary::Connection.new(resp.session, options)
+        Orientdb4r::logger.info "Database connected, session=#{db_connection.session_id}"
+      end
+
+
+      def disconnect #:nodoc:
+        @socket.close
+        @protocol = nil
+        @protocol_version = 0
+        @db_connection.close unless @db_connection.nil?
+        @server_connection.close unless @server_connection.nil?
+        @db_connection = nil
+      end
+
+
+      def server(options={})
+        raise NotImplementedError, 'this should be overridden by concrete client'
+      end
+
+
+      # ------------------------------------------------------------------ Helpers
+
+      private
+
+        # Gets a hash of parameters.
+        def params(args = {})
+          args.merge({ session: connection.session })
+        end
+
+    end
+
+  end
+
+end

data/lib/orientdb4r/bin/connection.rb

@@ -0,0 +1,29 @@
+module Orientdb4r
+
+  module Binary
+
+    class Connection
+
+      attr_reader :session_id
+      attr_reader :params
+
+      def initialize(session_id, params)
+        @session_id = session_id
+        @params = params
+      end
+
+      def connected?
+        !session_id.nil? and session_id < 0
+      end
+
+      def close
+        @params.clear
+        @params = nil
+        @session_id = 0
+      end
+
+    end
+
+  end
+
+end

data/lib/orientdb4r/bin/constants.rb

@@ -0,0 +1,20 @@
+module Orientdb4r
+
+  module Binary
+
+    module Constants
+
+      MINIMAL_PROTOCOL_VERSION = 28 # ODB v2.0.5
+
+      REQUEST_SHUTDOWN         =  1
+      REQUEST_CONNECT          =  2
+      REQUEST_DB_OPEN          =  3
+
+      STATUS_OK      = 0
+      STATUS_ERROR   = 1
+
+    end
+
+  end
+
+end

data/lib/orientdb4r/bin/io.rb

@@ -0,0 +1,38 @@
+require 'bindata'
+require 'orientdb4r/bin/constants'
+
+module Orientdb4r
+
+  module Binary
+
+    module OIO
+
+      def req_resp(socket, req, resp)
+        req.write(socket)
+
+        status = BinData::Int8.read(socket).to_i
+        if ::Orientdb4r::Binary::Constants::STATUS_ERROR == status
+          errors = protocol::Errors.read(socket)
+          exceptions = errors[:exceptions]
+          Orientdb4r::logger.error "exception(s): #{exceptions}"
+
+          # if exceptions[0] && exceptions[0][:exception_class] == "com.orientechnologies.orient.core.exception.ORecordNotFoundException"
+          #   raise RecordNotFound.new(session)
+          # else
+          #  raise ServerError.new(session, *exceptions)
+          # end
+          raise ServerError, exceptions[0..-2]
+        end
+
+BinData::trace_reading do
+        resp.read(socket)
+end
+        resp
+      end
+
+
+    end
+
+  end
+
+end

data/lib/orientdb4r/bin/protocol28.rb

@@ -0,0 +1,101 @@
+require 'bindata'
+
+module Orientdb4r
+
+  module Binary
+
+    class Protocol28
+
+      # Common Constructs -----------------------------------------------------
+
+      class ProtocolString < BinData::Primitive
+        endian :big
+
+        int32  :len,  :value => lambda { data.length }
+        string :data, :read_length => :len, :onlyif => :not_blank?
+
+        def get;   self.data; end
+        def set(v) self.data = v; end
+
+        def not_blank?
+          len > 0
+        end
+      end
+
+
+      class Errors < BinData::Record
+        endian :big
+
+        int32 :session
+        array :exceptions, read_until: -> { element[:is_error] < 1 } do
+          int8 :is_error
+          protocol_string :exception_class, onlyif: -> { 1 == is_error }
+          protocol_string :exception_message, onlyif: -> { 1 == is_error }
+        end
+
+        int32 :len
+        skip  :length => :len
+      end
+
+      # -----------------------------------------------------------------------
+
+      class DbOpenRequest < BinData::Record
+        endian :big
+
+        int8            :operation,       :value => ::Orientdb4r::Binary::Constants::REQUEST_DB_OPEN
+        int32           :session,         :value => -123456
+
+        protocol_string :driver_name,     :value => Orientdb4r::DRIVER_NAME
+        protocol_string :driver_version,  :value => Orientdb4r::VERSION
+        int16           :protocol_version
+        protocol_string :client_id
+        protocol_string :serialization_impl, :value => 'ORecordDocument2csv'
+        int8            :token_based,     :value => 0
+        protocol_string :db_name
+        protocol_string :db_type,         :value => 'document'
+        protocol_string :user
+        protocol_string :password
+      end
+
+      class DbOpenResponse < BinData::Record
+        endian :big
+
+        int32 :session
+        skip :length => 8
+        int16 :num_of_clusters
+        array :clusters, :initial_length => :num_of_clusters do
+          protocol_string :name
+          int16 :cluster_id
+        end
+        #int8 :cluster_config_bytes
+        protocol_string :cluster_config_bytes
+        #skip :length => 4
+        #protocol_string :neco
+        protocol_string :orientdb_release
+      end
+
+      class Connect < BinData::Record
+          endian :big
+
+          int8            :operation,       :value => 2
+          int32           :session,         :value => -1 #NEW_SESSION
+          protocol_string :driver,          :value => 'Orientdb4r Ruby Client'
+          protocol_string :driver_version,  :value => Orientdb4r::VERSION
+          int16           :version
+          protocol_string :client_id
+          protocol_string :user
+          protocol_string :password
+        end
+
+class ConnectAnswer < BinData::Record
+      endian :big
+
+      skip length: 4
+      int32 :session
+    end
+
+    end
+
+  end
+
+end

data/lib/orientdb4r/bin/protocol_factory.rb

@@ -0,0 +1,25 @@
+require 'orientdb4r/bin/protocol28'
+
+module Orientdb4r
+  
+  class ProtocolFactory
+
+	PROTOCOLS = {
+		28 => Orientdb4r::Binary::Protocol28
+	}
+
+	def self.get_protocol(version)
+	  return PROTOCOLS[version] if PROTOCOLS.include? version
+
+	  #search for a smaller one
+	  PROTOCOLS.keys.sort.each do |key|
+	  	next if key > version
+	  	return if key < version
+	  end
+
+	  raise OrientdbError, "Unsupported protocol version, desired=#{version}, supported=#{PROTOCOLS.key.sort}"
+	end
+  
+  end
+
+end

data/lib/orientdb4r/chained_error.rb

@@ -0,0 +1,37 @@
+module Orientdb4r
+
+  ###
+  # This mixin extends an error to be able to track a chain of exceptions.
+  module ChainedError
+
+    attr_reader :cause
+
+    ###
+    # Constructor.
+    def initialize message = nil, cause = $!
+      super message unless message.nil?
+      super $! if message.nil? and !cause.nil?
+      @cause = cause
+    end
+
+    ###
+    # Modification of original method Error#set_backtrace
+    # to descend the full depth of the exception chain.
+    def set_backtrace bt
+      unless cause.nil?
+        cause.backtrace.reverse.each do |line|
+          if bt.last == line
+            bt.pop
+            next
+          end
+          break
+        end
+        bt.push "<<<CAUSED BY>>>: #{cause.class}: #{cause.message}"
+        bt.concat cause.backtrace
+      end
+      super bt
+    end
+
+  end
+
+end