orient_db_client 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in orientdb-client.gemspec
+gemspec

data/README.md

@@ -0,0 +1,71 @@
+OrientDB Client
+===============
+
+This gem is a very rough initial attempt at a Network Binary Protocol driver for OrientDB.
+
+While in this early stage of development, the public interface is subject to change with no warning.
+
+This is my first attempt at building a gem intended for public use.  Expect some difficulty getting this gem up and running in your projects.
+
+
+Supported OrientDB Releases
+---------------------------
+
+I've tested this against OrientDB-1.0rc9 which is the current official release as of writing this README.
+
+
+Basic Usage
+-----------
+
+
+## Server Operations
+
+    require 'orient_db_client`
+
+    connection = OrientDbClient.connect('0.0.0.0', { :port => 2424 })
+
+    server = connection.open_server({
+        :user => 'root',
+        :password => '<password>'
+    })
+
+    server.create_local_database("my_database")
+
+    server.delete_database(database_name)
+
+
+## Database Operations
+
+    require 'orient_db_client`
+
+    connection = OrientDbClient.connect('0.0.0.0', { :port => 2424 })
+
+    database = connection.open_database(database_name, {
+        :user => 'admin',
+        :password => 'admin'
+    })
+
+    cluster_id = database.create_physical_cluster("test")
+
+    record = { :document => { 'key1' => 'value1' } }
+
+    rid = database.create_record(cluster_id, record)
+
+    loaded_record = database.load_record(rid)
+    loaded_record[:document]['key1'] = 'updated'
+
+    version = database.update_record(loaded_record, rid, :incremental)
+
+    edited_record = database.load_record(rid)
+
+    database.delete_record(rid, edited_record[:record_version])
+
+
+Testing
+-------
+
+    rake test:unit
+
+There are integration tests as well, but the testing strategy is extremely flawed.  Start an instance of OrientDB before running.  Most of the tests are run against the "temp" database, which is reset every time OrientDB is started.  The integration test results should not be considered valid unless run against a fresh restart of the OrientDB server.
+
+    rake test:integration

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.name = 'test'
+  t.libs.push "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::TestTask.new do |t|
+	t.name = 'test:unit'
+  t.libs.push "lib"
+  t.test_files = FileList['test/unit/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::TestTask.new do |t|
+	t.name = 'test:integration'
+  t.libs.push "lib"
+  t.test_files = FileList['test/integration/**/*_test.rb']
+  t.verbose = true
+end

data/lib/orient_db_client/connection.rb

@@ -0,0 +1,141 @@
+require 'orient_db_client/database_session'
+require 'orient_db_client/server_session'
+require 'orient_db_client/protocol_factory'
+
+module OrientDbClient
+  class Connection
+  	def initialize(socket, protocol_version, options = {})
+  		@socket = socket
+  		@protocol = (options[:protocol_factory] || ProtocolFactory).get_protocol(protocol_version)
+      @sessions = {}
+  	end
+
+  	def close
+      @socket.close
+  	end
+
+    def close_database(session)
+      @protocol.db_close(@socket, session)
+    end
+
+    def closed?
+      @socket.closed?
+    end
+
+    def cluster_exists?(session, cluster_id_or_name)
+      result = true
+
+      begin
+        if cluster_id_or_name.is_a?(String)
+          @protocol.count(@socket, session, cluster_id_or_name)
+        else
+          @protocol.datacluster_datarange(@socket, session, cluster_id_or_name)
+        end
+      rescue OrientDbClient::ProtocolError => err
+        case err.exception_class
+        when 'java.lang.IndexOutOfBoundsException', 'java.lang.IllegalArgumentException'
+          result = false
+        else
+          throw err
+        end
+      end
+
+      result
+    end
+
+    def command(session, text, options = {})
+      @protocol.command(@socket, session, text, options)
+    end
+
+    def count(session, cluster_name)
+      @protocol.count(@socket, session, cluster_name)
+    end
+
+    def create_database(session, database, options = {})
+      @protocol.db_create(@socket, session, database, options)
+    end
+
+    def create_cluster(session, type, options)
+      result = @protocol.datacluster_add(@socket, session, type, options)
+
+      result[:message_content][:new_cluster_number]
+    end
+
+    def create_record(session, cluster_id, record)
+      response = @protocol.record_create(@socket, session, cluster_id, record)
+      message_content = response[:message_content]
+
+      OrientDbClient::Rid.new(message_content[:cluster_id], message_content[:cluster_position])
+    end
+
+    def database_exists?(session, database)
+      response = @protocol.db_exist(@socket, session, database)
+
+      response[:message_content][:result] == 1
+    end
+
+    def delete_database(session, database)
+      @protocol.db_delete(@socket, session, database)
+    end
+
+    def delete_cluster(session, cluster_id)
+      @protocol.datacluster_remove(@socket, session, cluster_id)
+    end
+
+    def delete_record(session, rid, version)
+      response = @protocol.record_delete(@socket, session, rid.cluster_id, rid.cluster_position, version)
+
+      response[:message_content][:result] == 1
+    end
+
+    def get_cluster_datarange(session, cluster_id)
+      @protocol.datacluster_datarange(@socket, session, cluster_id)
+    end
+
+    def load_record(session, rid)
+      rid = OrientDbClient::Rid.new(rid) if rid.is_a?(String)
+
+      result = @protocol.record_load(@socket, session, rid)
+
+      if result[:message_content]
+        result[:message_content].tap do |r|
+          r[:cluster_id] = rid.cluster_id
+          r[:cluster_position] = rid.cluster_position
+        end
+      end
+
+      result
+    end
+
+    def open_server(options = {})
+      response = @protocol.connect(@socket, options)
+      session = response[:session]
+      message_content = response[:message_content]
+
+      @sessions[session] = ServerSession.new(message_content[:session], self)
+    end
+
+  	def open_database(database, options = {})
+  		response = @protocol.db_open(@socket, database, options)
+      session = response[:session]
+      message_content = response[:message_content]
+
+      @sessions[session] = DatabaseSession.new(message_content[:session], self, message_content[:clusters])
+  	end
+
+    def reload(session)
+      result = @protocol.db_reload(@socket, session)
+      clusters = result[:message_content][:clusters]
+
+      @sessions.values.each do |s|
+        s.send :store_clusters, clusters
+      end
+    end
+
+    def update_record(session, rid, record, version)
+      response = @protocol.record_update(@socket, session, rid.cluster_id, rid.cluster_position, record, version)
+
+      response[:message_content][:record_version]
+    end
+  end
+end

data/lib/orient_db_client/database_session.rb

@@ -0,0 +1,107 @@
+require 'orient_db_client/session'
+
+module OrientDbClient
+	class DatabaseSession < Session
+		attr_reader :clusters
+
+		def initialize(id, connection, clusters = [])
+			super id, connection
+
+			store_clusters(clusters)			
+		end
+
+		def close
+			@connection.close_database(@id)
+		end
+
+		def cluster_exists?(cluster_id)
+			@connection.cluster_exists?(@id, cluster_id)
+		end
+
+		def command(text, options = {})
+			@connection.command(@id, text, options)
+		end
+
+		def count(cluster_name)
+			@connection.count(@id, cluster_name)
+		end
+
+		def create_physical_cluster(name, options = {})
+			options.merge!({ :name => name })
+
+			@connection.create_cluster(@id, :physical, options)
+		end
+
+		def clusters
+			@clusters.values
+		end
+
+		def create_record(cluster_id, record)
+			@connection.create_record(@id, cluster_id, record)
+		end
+
+		def delete_cluster(cluster_id)
+			@connection.delete_cluster(@id, cluster_id)
+		end
+
+		def delete_record(rid_or_cluster_id, cluster_position_or_version, version = nil)
+			if rid_or_cluster_id.is_a?(Fixnum)
+				rid = OrientDbClient::Rid.new(rid_or_cluster_id, cluster_position)
+				version = version
+			else
+				rid = rid_or_cluster_id
+				version = cluster_position_or_version
+			end
+			
+			@connection.delete_record(@id, rid, version)
+		end
+
+		def get_cluster(id)
+			if id.kind_of?(Fixnum)
+				@clusters[id]
+			else
+				@clusters_by_name[id.downcase]
+			end
+		end
+
+		def get_cluster_datarange(cluster_id)
+			@connection.get_cluster_datarange(@id, cluster_id)
+		end
+
+		def load_record(rid_or_cluster_id, cluster_position = nil)
+			if rid_or_cluster_id.is_a?(Fixnum)
+				rid_or_cluster_id = OrientDbClient::Rid.new(rid_or_cluster_id, cluster_position)
+			end
+			
+			@connection.load_record(@id, rid_or_cluster_id)[:message_content]
+		end
+
+		def reload
+			@connection.reload(@id)
+		end
+
+		def update_record(record, rid_or_cluster_id, cluster_position_or_version, version = nil)
+			if rid_or_cluster_id.is_a?(Fixnum)
+				rid = OrientDbClient::Rid.new(rid_or_cluster_id, cluster_position)
+				version = version
+			else
+				rid = rid_or_cluster_id
+				version = cluster_position_or_version
+			end
+			
+			@connection.update_record(@id, rid, record, version)
+		end
+
+		private
+
+		def store_clusters(clusters)
+			@clusters = {}
+			@clusters_by_name = {}
+
+			clusters.each do |cluster|
+				@clusters[cluster[:id]] = cluster
+				@clusters_by_name[cluster[:name].downcase] = cluster
+			end
+		end
+	end
+end

data/lib/orient_db_client/deserializers/deserializer7.rb

@@ -0,0 +1,166 @@
+require 'orient_db_client/rid'
+
+require 'base64'
+
+module OrientDbClient
+    module Deserializers
+        class Deserializer7
+            @@string_matcher = /^"[^"]*"$/
+
+            def deserialize(text)
+                result = { :document => {}, :structure => {} }
+                struct_info = {}
+
+                serialized_record = text
+
+                if m = serialized_record.match(/([^,@]+)@/)
+                    result[:class] = m[1]
+                    serialized_record.gsub!(/^[^@]*@/, '')
+                end
+
+                tokens = serialized_record.split(",")
+                
+                while token = tokens.shift
+                    field, value = parse_field(token, tokens, struct_info)
+
+                    result[:document][field] = value
+                    result[:structure][field] = struct_info[:type]
+                end
+
+                result
+            end
+
+            private
+
+            def close_token!(token, cap, join, tokens)
+                while token[token.length - 1] != cap && tokens.length > 0
+                    token << join if join
+                    token << tokens.shift
+                end
+
+                token
+            end
+
+            def remove_ends(token)
+                token[1...token.length-1]
+            end
+
+            def parse_date(value)
+                time = parse_time(value)
+
+                Date.new(time.year, time.month, time.day)
+            end
+
+            def parse_field(token, tokens, struct_info)
+                field, value = token.split(":", 2)
+
+                field = remove_ends(field) if field.match(@@string_matcher)
+
+                value = parse_value(value, tokens, struct_info)
+
+                return field, value
+            end
+
+            def parse_time(value)
+                Time.at(value[0...value.length - 1].to_i).utc
+            end
+
+            def parse_value(value, tokens, struct_info = {})
+                struct_info[:type] = nil
+
+                case value[0]
+                when '['
+                    close_token!(value, ']', ',', tokens)
+
+                    sub_tokens = remove_ends(value).split(',')
+
+                    value = []
+
+                    while element = sub_tokens.shift
+                        value << parse_value(element, sub_tokens)
+                    end
+
+                    struct_info[:type] = :collection
+
+                    value
+                when '{'
+                    close_token!(value, '}', ',', tokens)
+
+                    struct_info[:type] = :map
+
+                    value = deserialize(remove_ends(value))[:document]
+                when '('
+                    close_token!(value, ')', ',', tokens)
+
+                    struct_info[:type] = :document
+
+                    deserialize remove_ends(value)
+                when '*'
+                    close_token!(value, '*', ',', tokens)
+
+                    struct_info[:type] = :document
+
+                    deserialize remove_ends(value)
+                when '"'
+                    close_token!(value, '"', ',', tokens)
+
+                    struct_info[:type] = :string
+
+                    value.gsub! /^\"/, ''
+                    value.gsub! /\"$/, ''
+                when '_'
+                    close_token!(value, '_', ',', tokens)
+
+                    struct_info[:type] = :binary
+                    value = Base64.decode64(remove_ends(value))
+                when '#'
+                    struct_info[:type] = :rid
+                    value = OrientDbClient::Rid.new(value)
+                else
+
+                    value = if value.length == 0
+                        nil
+                    elsif value == 'null'
+                        nil
+                    elsif value == 'true'
+                        struct_info[:type] = :boolean
+                        true
+                    elsif value == 'false' 
+                        struct_info[:type] = :boolean
+                        false
+                    else
+                        case value[value.length - 1]
+                        when 'b'
+                            struct_info[:type] = :byte
+                            value.to_i
+                        when 's'
+                            struct_info[:type] = :short
+                            value.to_i
+                        when 'l'
+                            struct_info[:type] = :long
+                            value.to_i
+                        when 'f'
+                            struct_info[:type] = :float
+                            value.to_f
+                        when 'd'
+                            struct_info[:type] = :double
+                            value.to_f
+                        when 'c'
+                            struct_info[:type] = :decimal
+                            value.to_f
+                        when 't' 
+                            struct_info[:type] = :time
+                            parse_time(value)
+                        when 'a'
+                            struct_info[:type] = :date
+                            parse_date(value)
+                        else
+                            struct_info[:type] = :integer
+                            value.to_i
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/orient_db_client/exceptions.rb

@@ -0,0 +1,25 @@
+module OrientDbClient
+	class UnsupportedProtocolError < StandardError
+		def initialize(version)
+			super "The host reports protocol version #{version}, which is not currently supported by this driver."
+		end
+	end
+
+	class ProtocolError < StandardError
+		attr_reader	:session
+		attr_reader	:exception_class
+
+		def initialize(session, *exceptions)
+			@session
+			@exception_class = exceptions[0] && exceptions[0][:exception_class]
+
+			super exceptions.map { |exp| [ exp[:exception_class], exp[:exception_message] ].reject { |s| s.nil? }.join(': ') }.join("\n")
+		end
+	end
+
+	class RecordNotFound < ProtocolError
+		def initialize(session)
+			super session
+		end
+	end
+end

data/lib/orient_db_client/network_message.rb

@@ -0,0 +1,42 @@
+module OrientDbClient
+	class NetworkMessage 
+		def initialize(&block)
+			@components = []
+
+			yield(self) unless block.nil?
+		end
+
+		def add(type, value)
+			@components << { :type => :integer, :value => (value && value.length) || 0 } if type == :string
+			@components << { :type => type, :value => value } unless type == :string && value.nil?
+		end
+
+		def pack()
+			packing_list = @components.map do |c|
+				case c[:type]
+					when :byte then 'C'
+					when :integer then 'l>'
+					when :long  then 'q>'
+					when :short then 's>'
+					when :string, :raw_string then 'a*'
+				end
+			end
+
+			content = @components.map do |c|
+				value = c[:value]
+
+				if c[:type] == :byte && value.is_a?(String)
+					c[:value] = value.length > 0 ? value[0].ord : 0
+				end
+
+				c[:value]
+			end
+
+			content.pack packing_list.join(" ")
+		end
+
+		def to_s
+			self.pack
+		end
+	end
+end

data/lib/orient_db_client/protocol_factory.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), 'protocols', 'protocol7')
+require File.join(File.dirname(__FILE__), 'protocols', 'protocol9')
+
+module OrientDbClient
+	class ProtocolFactory
+
+		PROTOCOLS = {
+			'7' => Protocols::Protocol7,
+            '9' => Protocols::Protocol9
+		}
+
+		def self.get_protocol(version)
+			PROTOCOLS[version.to_s] or raise UnsupportedProtocolError.new(version)
+		end
+	end
+end