orient_db_client 0.0.1

data/lib/orient_db_client/serializers/serializer7.rb

@@ -0,0 +1,208 @@
+require 'orient_db_client/rid'
+
+require 'base64'
+
+module OrientDbClient
+    module Serializers
+        class Serializer7
+            @@string_matcher = /^"[^"]*"$/
+
+            def serialize(record)
+                unless record[:document]
+                    record = { :document => record }
+                end
+
+                serialize_document(record)
+            end
+
+            private
+
+            def binary_encoding
+                @binary_encoding = @binary_encoding || Encoding.find("ASCII-8BIT")
+            end
+
+            def serialize_document(record, embedded = false)
+                structure = record[:structure] || {}
+                result = []
+                recordClass = ''
+                document = nil
+
+                if record[:document]
+                    recordClass = record[:class] ? "#{record[:class]}@" : ""
+                    document = record[:document]
+                else
+                    document = record
+                end
+
+                document.each do |k, v|
+                    result << "#{k}:#{serialize_item(v, structure[k])}"
+                end
+
+                serialized_document = "#{recordClass}#{result.join(",")}"
+
+                serialized_document = "(#{serialized_document})" if embedded
+
+                serialized_document
+            end
+
+            def serialize_array(value)
+                result = []
+
+                value.each do |item|
+                    result << serialize_item(item)
+                end
+
+                "[#{result.join(",")}]"
+            end
+
+            def serialize_binary(value)
+                "_#{Base64.encode64(value).chomp}_"
+            end
+
+            def serialize_boolean(value)
+                value ? "true" : "false"
+            end
+
+            def serialize_byte(value)
+                "#{value.ord}b"
+            end
+
+            def serialize_date(value)
+                if value.is_a?(Time)
+                    value = Date.new(value.year, value.month, value.day)
+                end
+
+                value = Date.parse(value) unless value.is_a?(Date)
+
+                "#{value.to_time.to_i}a"
+            end
+
+            def serialize_decimal(value)
+                "#{value}c"
+            end
+
+            def serialize_double(value)
+                "#{value}d"
+            end
+
+            def serialize_float(value)
+                "#{value}f"
+            end
+
+            def serialize_item(value, type = nil)
+                case type
+                when :binary
+                    serialize_binary(value)
+                when :boolean
+                    serialize_boolean(value)
+                when :byte
+                    serialize_byte(value)
+                when :collection
+                    serialize_array(value)
+                when :date
+                    serialize_date(value)
+                when :decimal
+                    serialize_decimal(value)
+                when :document
+                    serialize_document(value, true)
+                when :double
+                    serialize_double(value)
+                when :float
+                    serialize_float(value)
+                when :long
+                    serialize_long(value)
+                when :map
+                    serialize_map(value)
+                when :rid
+                    serialize_rid(value)
+                when :short
+                    serialize_short(value)
+                when :string
+                    serialize_string(value)
+                when :time
+                    serialize_time(value)
+                else
+                    serialize_unknown(value)
+                end
+            end
+
+            def serialize_integer(value)
+                value.to_s
+            end
+
+            def serialize_long(value)
+                "#{value}l"
+            end
+
+            def serialize_map(value)
+                result = []
+                value.each do |k, v|
+                    result << "\"#{k.to_s}\":#{serialize_unknown(v)}"
+                end
+
+                "{#{result.join(",")}}"
+            end
+
+            def serialize_nil
+                ''
+            end
+
+            def serialize_rid(value)
+                value = OrientDbClient::Rid.new(value.to_s) unless value.is_a?(OrientDbClient::Rid)
+
+                "#{value.to_s}"
+            end
+
+            def serialize_short(value)
+                "#{value}s"
+            end
+
+            def serialize_string(value)
+                "\"#{value.to_s}\""
+            end
+
+            def serialize_time(value)
+                value = DateTime.parse(value) if value.is_a?(String)
+                value = value.to_time if value.is_a?(DateTime)
+
+                "#{value.to_i}t"
+            end
+
+            def serialize_unknown(value)
+                if value.is_a?(OrientDbClient::Rid)
+                    serialize_rid(value)
+                elsif value.is_a?(String)
+                    if value.encoding.equal?(binary_encoding)
+                        serialize_binary(value)
+                    else
+                        serialize_string(value)
+                    end
+                elsif value.is_a?(Fixnum)
+                    serialize_integer(value)
+                elsif value.is_a?(TrueClass)
+                    serialize_boolean(value)
+                elsif value.is_a?(FalseClass)
+                    serialize_boolean(value)
+                elsif value.is_a?(Float)
+                    serialize_double(value)
+                elsif value.is_a?(Bignum)
+                    serialize_long(value)
+                elsif value.is_a?(Array)
+                    serialize_array(value)
+                elsif value.is_a?(Time)
+                    serialize_time(value)
+                elsif value.is_a?(Date)
+                    serialize_date(value)
+                elsif value.is_a?(Hash)
+                    if value[:document]
+                        serialize_document(value, true)
+                    else
+                        serialize_map(value)
+                    end
+                elsif value.nil?
+                    serialize_nil
+                end
+            end
+        end
+    end
+end

data/lib/orient_db_client/server_session.rb

@@ -0,0 +1,17 @@
+require 'orient_db_client/session'
+
+module OrientDbClient
+	class ServerSession < Session
+		def create_local_database(database, options = {})
+			@connection.create_database(@id, database)
+		end
+
+		def database_exists?(database)
+			@connection.database_exists?(@id, database)
+		end
+
+		def delete_database(database)
+			@connection.delete_database(@id, database)
+		end
+	end
+end

data/lib/orient_db_client/session.rb

@@ -0,0 +1,10 @@
+module OrientDbClient
+	class Session
+		attr_reader :id
+
+		def initialize(id, connection)
+			@id = id
+			@connection = connection
+		end
+	end
+end

data/lib/orient_db_client/types.rb

@@ -0,0 +1,22 @@
+module OrientDbClient
+    module Types
+        [ :BINARY,
+          :BOOLEAN,
+          :BYTE,
+          :COLLECTION,
+          :DATE,
+          :DECIMAL,
+          :DOCUMENT,
+          :DOUBLE,
+          :FLOAT,
+          :LONG,
+          :MAP,
+          :RID,
+          :SHORT,
+          :STRING,
+          :TIME ].each_with_index do |c, i|
+
+            const_set c, i
+        end
+    end
+end

data/lib/orient_db_client/version.rb

@@ -0,0 +1,3 @@
+module OrientDbClient
+  VERSION = "0.0.1"
+end

data/lib/orient_db_client.rb

@@ -0,0 +1,18 @@
+require "orient_db_client/connection"
+require "orient_db_client/version"
+require "orient_db_client/rid"
+
+require "socket"
+
+module OrientDbClient
+	def connect(host, options = {})
+		options = { port: 2424 }.merge(options)
+
+		s = TCPSocket.open(host, options[:port])
+
+		protocol = s.read(2).unpack('s>').first
+
+		Connection.new(s, protocol)
+	end
+	module_function :connect
+end

data/orient_db_client.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "orient_db_client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "orient_db_client"
+  s.version     = OrientDbClient::VERSION
+  s.authors     = ["Ryan Fields"]
+  s.email       = ["ryan.fields@twoleftbeats.com"]
+  s.homepage    = ""
+  s.summary     = %q{Network Binary Protocol client for OrientDB Server}
+  s.description = %q{This gem uses the OrientDB Network Binary Protocol to provide connectivity to an OrientDB Server}
+
+  s.rubyforge_project = "orient_db_client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+end

data/test/integration/connection_test.rb

@@ -0,0 +1,18 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestConnection < MiniTest::Unit::TestCase
+	include ServerConfig
+	include ConnectionHelper
+
+	def setup
+		@connection = connect_to_orientdb(SERVER_OPTIONS)
+	end
+
+	def teardown
+		@connection.close if @connection
+	end
+
+  def test_establishing_a_connection
+    assert_instance_of OrientDbClient::Connection, @connection
+  end
+end

data/test/integration/database_session_9_test.rb

@@ -0,0 +1,82 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestDatabaseSession < MiniTest::Unit::TestCase
+    include ServerConfig
+    include ConnectionHelper
+
+    def setup
+        @options = SERVER_OPTIONS
+        @connection = connect_to_orientdb(SERVER_OPTIONS)
+
+        @session = @connection.open_database(@options["database"], {
+            :user => @options["user"],
+            :password => @options["password"]
+        })
+    end
+
+    def teardown
+        @connection.close if @connection
+    end
+
+  # The protocol documentation for DB_CLOSE is very ambiguous.
+  # As such, this test doesn't really do anything that makes sense...
+  def test_close
+    @session.close
+
+    refute @connection.closed?
+  end
+
+  def test_command
+    result = @session.command("SELECT FROM OUser")
+
+    assert_equal @session.id, result[:session]
+
+    result[:message_content].tap do |content|
+      assert_equal 3, content.length
+  
+      content[0].tap do |record|
+        assert_equal 0, record[:format]
+        assert_equal 4, record[:cluster_id]
+        assert_equal 0, record[:cluster_position]
+
+        record[:document].tap do |doc|
+          assert_equal 'admin', doc['name']
+          assert_equal 'ACTIVE', doc['status']
+
+          doc['roles'].tap do |roles|
+            assert roles.is_a?(Array), "expected Array, but got #{roles.class}"
+
+            assert roles[0].is_a?(OrientDbClient::Rid)
+            assert_equal 3, roles[0].cluster_id
+            assert_equal 0, roles[0].cluster_position
+          end
+        end
+      end
+    end
+  end
+
+  def test_load_record
+    result = @session.load_record("#4:0")
+
+    assert_equal @session.id, result[:session]
+
+    result[:message_content].tap do |record|
+      assert_equal 4, record[:cluster_id]
+      assert_equal 0, record[:cluster_position]
+
+      record[:document].tap do |doc|
+        assert_equal 'admin', doc['name']
+        assert_equal 'ACTIVE', doc['status']
+
+        doc['roles'].tap do |roles|
+          assert roles.is_a?(Array), "expected Array, but got #{roles.class}"
+
+          assert roles[0].is_a?(OrientDbClient::Rid)
+          assert_equal 3, roles[0].cluster_id
+          assert_equal 0, roles[0].cluster_position
+        end
+      end
+    end
+  end
+
+end

data/test/integration/database_session_test.rb

@@ -0,0 +1,222 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestDatabaseSession < MiniTest::Unit::TestCase
+	include ServerConfig
+	include ConnectionHelper
+
+	def setup
+		@options = SERVER_OPTIONS
+		@connection = connect_to_orientdb(SERVER_OPTIONS)
+
+		@session = @connection.open_database(@options["database"], {
+			:user => @options["user"],
+			:password => @options["password"]
+		})
+	end
+
+	def teardown
+		@connection.close if @connection
+	end
+
+  def ensure_cluster_exists(session, cluster_name)
+    if session.cluster_exists?(cluster_name)
+      cluster = session.get_cluster(cluster_name)
+      cluster[:id]
+    else
+      session.create_physical_cluster(cluster_name)
+    end
+  end
+
+  def ensure_cluster_does_not_exist(session, cluster_name)
+    if session.cluster_exists?(cluster_name)
+      session.delete_cluster(session.get_cluster(cluster_name)[:id]) 
+      session.reload     # I know.  Ridiculous
+    end
+  end
+
+  # The protocol documentation for DB_CLOSE is very ambiguous.
+  # As such, this test doesn't really do anything that makes sense...
+  def test_close
+    @session.close
+
+    refute @connection.closed?
+  end
+
+  def test_cluster_exists?
+    # Preform a bit of pre-test cleanup
+    # FIXME: This won't be needed once we have some kind of DB clean in place
+    cluster = @session.get_cluster("OTest")
+    @session.delete_cluster(cluster[:id]) unless cluster.nil?
+
+    assert @session.cluster_exists?(0)
+    refute @session.cluster_exists?("OTest")
+  end
+
+  def test_command
+    result = @session.command("SELECT FROM OUser")
+
+    assert_equal @session.id, result[:session]
+
+    result[:message_content].tap do |content|
+      assert_equal 3, content.length
+  
+      content[0].tap do |record|
+        assert_equal 0, record[:format]
+        assert_equal 4, record[:cluster_id]
+        assert_equal 0, record[:cluster_position]
+
+        record[:document].tap do |doc|
+          assert_equal 'admin', doc['name']
+          assert_equal 'ACTIVE', doc['status']
+
+          doc['roles'].tap do |roles|
+            assert roles.is_a?(Array), "expected Array, but got #{roles.class}"
+
+            assert roles[0].is_a?(OrientDbClient::Rid)
+            assert_equal 3, roles[0].cluster_id
+            assert_equal 0, roles[0].cluster_position
+          end
+        end
+      end
+    end
+  end
+
+  def test_count
+    result = @session.count("ORole")
+
+    assert_equal @session.id, result[:session]
+    assert_equal 3, result[:message_content][:record_count]
+  end
+
+  def test_create_cluster
+    cluster = "OTest"
+    ensure_cluster_does_not_exist(@session, cluster)
+
+    new_cluster = @session.create_physical_cluster(cluster)
+
+    assert_equal 6, new_cluster
+
+    assert @session.cluster_exists?(cluster)
+
+    # Cleanup
+    # FIXME: Necessary due to lack of DB clean strategy
+    @session.delete_cluster(new_cluster) unless new_cluster.nil?
+  end
+
+  def test_create_and_delete_record
+    cluster = "OTest"
+
+    ensure_cluster_exists(@session, cluster)
+    @session.reload
+
+    cluster_id = @session.get_cluster(cluster)[:id]
+    record = { :key1 => "value1" }
+
+    rid = @session.create_record(cluster_id, record)
+    created_record = @session.load_record(rid)
+
+    assert_equal cluster_id, rid.cluster_id
+    assert_equal 0, rid.cluster_position
+
+    refute_nil created_record
+    refute_nil created_record[:document]['key1']
+
+    assert_equal record[:key1], created_record[:document]['key1']
+
+    assert @session.delete_record(rid, created_record[:record_version])
+    assert_nil @session.load_record(rid)
+
+    ensure_cluster_does_not_exist(@session, cluster)
+  end
+
+  def test_delete_cluster
+    # FIXME: Messy due to lack of a proper DB load/clean strategy
+
+    cluster_id = ensure_cluster_exists(@session, "OTest")
+   
+    result = @session.delete_cluster(cluster_id)
+
+    refute @session.cluster_exists?("OTest")
+  end
+
+  def test_get_cluster_by_id
+    cluster_id = 0
+    cluster_name = 'internal'
+
+    result = @session.get_cluster(cluster_id)
+
+    refute_nil result
+    assert_equal cluster_id, result[:id]
+    assert_equal cluster_name, result[:name]
+  end
+
+  def test_get_cluster_by_name
+    cluster_id = 0
+    cluster_name = 'internal'
+
+    result = @session.get_cluster(cluster_name)
+
+    refute_nil result
+    assert_equal cluster_id, result[:id]
+    assert_equal cluster_name, result[:name]
+  end
+
+  def test_get_cluster_noexist
+    cluster_id = 9000
+
+    result = @session.get_cluster(cluster_id)
+
+    assert_nil result
+  end
+
+  def test_get_cluster_datarange
+    cluster_id = 0
+    expected_begin = 0
+    expected_end = 2
+
+    result = @session.get_cluster_datarange(cluster_id)
+
+    result[:message_content].tap do |m|
+      assert expected_begin, m[:begin]
+      assert expected_end, m[:end]
+    end
+  end
+
+  def test_load_record
+    record = @session.load_record("#4:0")
+
+    assert_equal 4, record[:cluster_id]
+    assert_equal 0, record[:cluster_position]
+
+    record[:document].tap do |doc|
+      assert_equal 'admin', doc['name']
+      assert_equal 'ACTIVE', doc['status']
+
+      doc['roles'].tap do |roles|
+        assert roles.is_a?(Array), "expected Array, but got #{roles.class}"
+
+        assert roles[0].is_a?(OrientDbClient::Rid)
+        assert_equal 3, roles[0].cluster_id
+        assert_equal 0, roles[0].cluster_position
+      end
+    end
+  end
+
+  def test_reload
+    cluster = "OTest"
+
+    # FIXME: Messy due to lack of a proper DB load/clean strategy
+    ensure_cluster_does_not_exist(@session, cluster)
+
+    assert_nil @session.get_cluster(cluster)
+    @session.create_physical_cluster(cluster)
+
+    @session.reload
+
+    refute_nil @session.get_cluster(cluster)
+
+    # Cleanup
+    # FIXME: Necessary due to lack of DB clean strategy
+    @session.delete_cluster(@session.get_cluster(cluster)[:id])
+  end
+end

data/test/integration/open_database_test.rb

@@ -0,0 +1,28 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestOpenDatabase < MiniTest::Unit::TestCase
+	include ServerConfig
+	include ConnectionHelper
+
+	def setup
+		@options = SERVER_OPTIONS
+		@connection = connect_to_orientdb(@options)
+	end
+
+	def teardown
+		@connection.close if @connection
+	end
+
+  def test_open_database
+    session = @connection.open_database(@options["database"], {
+    	:user => @options["user"],
+    	:password => @options["password"]
+    })
+
+    refute_nil session.id
+
+    refute_nil session.get_cluster("orids")
+    refute_nil session.get_cluster("ouser")
+    refute_nil session.get_cluster("orole")
+  end
+end

data/test/integration/open_server_test.rb

@@ -0,0 +1,24 @@
+require File.join File.dirname(__FILE__), '..', 'test_helper'
+
+class TestOpenServer < MiniTest::Unit::TestCase
+	include ServerConfig
+	include ConnectionHelper
+
+	def setup
+		@options = SERVER_OPTIONS
+		@connection = connect_to_orientdb(SERVER_OPTIONS)
+	end
+
+	def teardown
+		@connection.close if @connection
+	end
+
+  def test_connect_command
+    session = @connection.open_server({
+    	:user => @options["server_user"],
+    	:password => @options["server_password"]
+    })
+
+    refute_nil session.id
+  end
+end