orientdb-binary 0.6.0

data/lib/orientdb_binary/protocols/record_load.rb

@@ -0,0 +1,65 @@
+module OrientdbBinary
+  module Protocols
+
+    class RecordLoad < BinData::Record
+      include OrientdbBinary::Protocols::Base
+
+      endian :big
+
+      int8 :operation, value: OrientdbBinary::OperationTypes::REQUEST_RECORD_LOAD
+      int32 :session
+
+      int16 :cluster_id
+      int64 :cluster_position
+      protocol_string :fetch_plan
+      int8 :ignore_cache
+      int8 :load_tombstones
+    end
+
+    class RecordLoadAnswer < BinData::Record
+      endian :big
+
+      int32 :session
+      int8 :payload_status
+      array :collection, initial_length: :payload_status do
+        protocol_string :content
+        int32 :version
+        record_type :record_type
+      end
+
+      array :prefetched_records, read_until: -> {element.payload_status == 0}, onlyif: -> {payload_status > 0} do
+        int8  :payload_status
+        int16 :marker, onlyif: -> {payload_status > 0}
+        record_type :record_type, onlyif: -> {payload_status > 0}
+        int16 :cluster_id, onlyif: -> {payload_status > 0}
+        int64 :position, onlyif: -> {payload_status > 0}
+        int32 :version, onlyif: -> {payload_status > 0}
+        protocol_string :content, onlyif: -> {payload_status > 0}
+      end
+
+      def process(options)
+        colls = self.collection.map do |record|
+          opts = {
+            :@rid => "##{options[:cluster_id]}:#{options[:cluster_position]}",
+            :@version => record[:version],
+            :@type => record[:record_type]
+          }
+          OrientdbBinary::Parser::Deserializer.new().deserialize(record[:content], opts)
+        end
+
+        prefetched = self.prefetched_records.map do |record|
+          if record[:payload_status] > 0
+            opts = {
+              :@rid => "##{record[:cluster_id]}:#{record[:position]}",
+              :@version => record[:version],
+              :@type => record[:record_type]
+            }
+            OrientdbBinary::Parser::Deserializer.new().deserialize(record[:content], opts)
+          end
+        end
+
+        {collection: colls, prefetched_records: prefetched.delete_if {|rec| !rec}}
+      end
+    end
+  end
+end

data/lib/orientdb_binary/protocols/record_update.rb

@@ -0,0 +1,27 @@
+module OrientdbBinary
+  module Protocols
+
+    class RecordUpdate < BinData::Record
+      include OrientdbBinary::Protocols::Base
+
+      endian :big
+
+      int8 :operation, value: OrientdbBinary::OperationTypes::REQUEST_RECORD_UPDATE
+      int32 :session
+
+      int16 :cluster_id
+      int64 :cluster_position
+      protocol_string :record_content
+      int32 :record_version
+      int8 :record_type
+      int8 :mode
+    end
+
+    class RecordUpdateAnswer < BinData::Record
+      endian :big
+
+      int32 :session
+      int32 :record_version
+    end
+  end
+end

data/lib/orientdb_binary/protocols/shutdown.rb

@@ -0,0 +1,21 @@
+module OrientdbBinary
+  module Protocols
+
+    class Shutdown < BinData::Record
+      include OrientdbBinary::Protocols::Base
+
+      endian :big
+
+      int8 :operation, value: OrientdbBinary::OperationTypes::REQUEST_SHUTDOWN
+      int32 :session
+      protocol_string :user
+      protocol_string :password
+    end
+
+    class ShutdownAnswer < BinData::Record
+      endian :big
+
+      rest :message
+    end
+  end
+end

data/lib/orientdb_binary/server.rb

@@ -0,0 +1,71 @@
+require 'orientdb_binary/protocols/connect'
+require 'orientdb_binary/protocols/db_exist'
+require 'orientdb_binary/protocols/db_create'
+require 'orientdb_binary/protocols/db_drop'
+require 'orientdb_binary/protocols/db_freeze'
+require 'orientdb_binary/protocols/db_release'
+require 'orientdb_binary/protocols/shutdown'
+require 'orientdb_binary/protocols/config_list'
+require 'orientdb_binary/protocols/config_get'
+require 'orientdb_binary/protocols/config_set'
+
+module OrientdbBinary
+  class Server < OrientdbBinary::OrientdbBase
+    def self.connect(options)
+      Server.new(options)
+    end
+
+    def connect(args)
+      connection = OrientdbBinary::Protocols::Connect.new(
+                                                            protocol: protocol,
+                                                            user: args[:user],
+                                                            password: args[:password]
+                                                          ).process(socket)
+      @session = connection[:session] || OrientdbBinary::OperationTypes::NEW_SESSION
+      @connected = true if @session > OrientdbBinary::OperationTypes::NEW_SESSION
+      connection
+    end
+
+    def db_exists?(name)
+      answer = OrientdbBinary::Protocols::DbExist.new(session: session, database: name).process(socket)
+      answer[:exists] == 1
+    end
+
+    def db_create(name, type, storage)
+      OrientdbBinary::Protocols::DbCreate.new(session: session, name: name, type: type, storage: storage).process(socket)
+    end
+
+    def db_drop(name, storage)
+      OrientdbBinary::Protocols::DbDrop.new(session: session, name: name, storage: storage).process(socket)
+    end
+
+    def list
+      OrientdbBinary::Protocols::DbList.new(session: session).process(socket).process
+    end
+
+    def db_freeze(name, storage)
+      OrientdbBinary::Protocols::DbFreeze.new(session: session, name: name, storage: storage).process(socket)
+    end
+
+    def db_release(name, storage)
+      OrientdbBinary::Protocols::DbRelease.new(session: session, name: name, storage: storage).process(socket)
+    end
+
+    def get_config(key)
+      OrientdbBinary::Protocols::ConfigGet.new(session: session, option_key: key).process(socket)
+    end
+
+    def set_config(key, value)
+      OrientdbBinary::Protocols::ConfigSet.new(session: session, option_key: key.to_s, option_value: value.to_s).process(socket)
+    end
+
+    def config_list
+      OrientdbBinary::Protocols::ConfigList.new(session: session).process(socket)
+    end
+
+    def shutdown
+      OrientdbBinary::Protocols::Shutdown.new(session: session, user: @options[:user], password: @options[:password]).process(socket)
+    end
+
+  end
+end

data/orientdb-binary.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'orientdb_binary/config'
+
+Gem::Specification.new do |spec|
+  spec.name          = "orientdb-binary"
+  spec.version       = OrientdbBinary::VERSION
+  spec.authors       = ["Michal Ostrowski"]
+  spec.email         = ["ostrowski.michal@gmail.com"]
+  spec.summary       = %q{OrientDB native client for Ruby 2}
+  spec.description   = %q{Graph Database OrientDB native client for Ruby}
+  spec.homepage      = "http://orientdb-binary.espresse.net"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", '~> 0.9'
+  spec.add_development_dependency "simplecov", '~> 0.8'
+
+  spec.add_runtime_dependency "bindata", "~> 1.8"
+end

data/test/database/test_database.rb

@@ -0,0 +1,193 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+describe OrientdbBinary::Database do
+  before do
+    @server = OrientdbBinary::Server.new(TestHelper::SERVER)
+    @server.connect(TestHelper::SERVER_USER)
+
+    if @server.db_exists? TestHelper::TEST_DB[:db]
+      @server.db_drop TestHelper::TEST_DB[:db], TestHelper::TEST_DB[:storage]
+    end
+    @server.db_create(TestHelper::TEST_DB[:db], 'document', TestHelper::TEST_DB[:storage])
+
+    @db = OrientdbBinary::Database.new(TestHelper::SERVER)
+    @open = @db.open(TestHelper::TEST_DB.merge(TestHelper::TEST_DB_USER))
+  end
+
+  after do
+    if @server.db_exists? TestHelper::TEST_DB[:db]
+      @server.db_drop TestHelper::TEST_DB[:db], TestHelper::TEST_DB[:storage]
+    end
+    @db.disconnect
+    assert !@db.connected?
+    @server.disconnect
+  end
+
+  describe 'database' do
+    it "should be opened" do
+      assert @db.connected?
+    end
+
+    it "should have info about build" do
+      assert @open[:orientdb_release].length > 0
+    end
+
+    it "should count records" do
+      assert @db.count_records[:count_records] == 12 #(6 OIdentity + 3 OUser + 3 ORole)
+    end
+
+    it "should reload database" do
+      answer = @db.reload()
+      assert_equal answer[:num_of_clusters], answer[:clusters].length
+    end
+
+    it "should add datasegment" do
+      assert @db.add_datasegment(name: 'test_datasegment', location: 'test_location')[:segment_id] > 0
+    end
+
+    it "should add datasegment providing name only" do
+      assert @db.add_datasegment(name: 'test_datasegment_1')[:segment_id] > 0
+    end
+
+    it "should drop datasegment" do
+      @db.add_datasegment(name: 'test_datasegment', location: 'test_location')
+      assert @db.drop_datasegment(name: 'test_datasegment')[:succeed]
+    end
+
+    describe 'datacluster' do
+      before do
+        @db.add_datasegment(name: 'test_datasegment', location: 'test_location')
+        @datacluster = @db.add_datacluster(type: 'MEMORY', name: 'testmemory', location: 'test_location', datasegment_name: 'test_datasegment')
+      end
+
+      after do
+        @db.drop_datacluster(cluster_id: @datacluster[:cluster_id]) if @datacluster
+      end
+
+      it "should add" do
+        assert @db.reload()[:clusters].last[:cluster_name] == "testmemory"
+      end
+
+      it "should add datacluster without optional params" do
+        datacluster = @db.add_datacluster(name: 'test_cluster', datasegment_name: 'default')
+        assert @db.reload()[:clusters].last[:cluster_name] == "test_cluster"
+        @db.drop_datacluster(cluster_id: datacluster[:cluster_id])
+      end
+
+      it "should drop" do
+        @db.drop_datacluster(cluster_id: @datacluster[:cluster_id])
+        @db.reload()[:clusters]
+        assert @db.reload()[:clusters].last[:cluster_name] != "testmemory"
+        @datacluster = nil
+      end
+
+      it "should drop datacluster when providing name of it" do
+        @db.drop_datacluster(cluster_name: 'testmemory')
+      end
+
+      it "should count" do
+        assert_equal 6, @db.count_datacluster(cluster_ids: [0,1,2])[:records_in_clusters]
+      end
+
+      it "should count clusters by name" do
+        assert_equal 6, @db.count_datacluster(cluster_names: ['internal','index','manindex'])[:records_in_clusters]
+      end
+
+      it "should return datarange" do
+        range = @db.datarange_datacluster(cluster_id: 0)
+        assert_equal 0, range[:record_id_begin]
+        assert_equal 2, range[:record_id_end]
+      end
+
+      it "should return datarange" do
+        range = @db.datarange_datacluster(cluster_name: 'internal')
+        assert_equal 0, range[:record_id_begin]
+        assert_equal 2, range[:record_id_end]
+      end
+    end
+
+    describe "record" do
+      it "should be possible to add it" do
+        params = {
+          datasegment_id: -1,
+          cluster_id: 5,
+          record_content: "OUser@name:\"other_admin\",password:\"{SHA-256}8C6976E5B5410415BDE908BD4DEE15DFB167A9C873FC4BB8A81F6F2AB448A918\",status:\"ACTIVE\",roles:<#4:0>",
+          record_type: 100,
+          mode: 0
+        }
+        record = @db.create_record(params)
+        match = record[:@rid].match /#(?<version>\d+):(?<position>\d+)/
+        assert match[:position].to_i > 0
+      end
+
+      it "should be possible to add object with class" do
+        record = {
+          :@class => "OUser",
+          name: "other_admin",
+          password: "{SHA-256}8C6976E5B5410415BDE908BD4DEE15DFB167A9C873FC4BB8A81F6F2AB448A918",
+          status: "ACTIVE",
+          roles: (Set.new ["#4:0"])
+        }
+        record = @db.create_record_from_object(record)
+        match = record[:@rid].match /#(?<version>\d+):(?<position>\d+)/
+        assert match[:position].to_i == 0 #cluster_id is set to default and s there is no records position is to 0
+      end
+
+      it "should be possible to add object with cluster" do
+        record = {
+          :@class => "OUser",
+          :@cluster => "ouser",
+          name: "other_admin",
+          password: "{SHA-256}8C6976E5B5410415BDE908BD4DEE15DFB167A9C873FC4BB8A81F6F2AB448A918",
+          status: "ACTIVE",
+          roles: (Set.new ["#4:0"])
+        }
+        record = @db.create_record_from_object(record)
+        match = record[:@rid].match /#(?<version>\d+):(?<position>\d+)/
+        assert match[:position].to_i > 0
+      end
+
+      it "should be able to read content" do
+        record = @db.load_record(cluster_id: 5, cluster_position: 0, fetch_plan: "*:0", ignore_cache: 1, load_tombstones: 0)
+        assert record[:collection].length > 0
+      end
+
+      it "should be able to load record by providing rid only" do
+        record = @db.load_record(rid: "#5:0")
+        assert record[:collection].length > 0
+      end
+
+      it "should be able to pre-fetch linked collection" do
+        record = @db.load_record(cluster_id: 5, cluster_position: 0, fetch_plan: "*:-1", ignore_cache: 1, load_tombstones: 0)
+        assert_equal record[:prefetched_records].length, 1
+      end
+
+      it "should be able to update" do
+        params = {
+          cluster_id: 5,
+          cluster_position: 0,
+          record_content: "OUser@name:\"other_admin\",password:\"{SHA-256}8C6976E5B5410415BDE908BD4DEE15DFB167A9C873FC4BB8A81F6F2AB448A918\",status:\"ACTIVE\",roles:<#4:0>",
+          record_version: 0,
+          record_type: 100,
+          mode: 0
+        }
+        record = @db.update_record(params)
+        assert_equal record[:record_version], 1
+      end
+
+      describe "delete" do
+        before do
+          @delete_action = @db.delete_record(cluster_id: 5, cluster_position: 0, record_version: 0, mode: 0)
+        end
+        it "should hav epayload status set to 1" do
+          assert_equal 1, @delete_action[:payload_status]
+        end
+
+        it "should not load record" do
+           assert_equal 0, @db.load_record(cluster_id: 5, cluster_position: 0, fetch_plan: "*:-1", ignore_cache: 1, load_tombstones: 0)[:collection].length
+        end
+      end
+    end
+  end
+end

data/test/database/test_deserializer.rb

@@ -0,0 +1,140 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+describe OrientdbBinary::Parser do
+
+  describe 'Deserializer' do
+    before do
+      @parser = OrientdbBinary::Parser::Deserializer.new
+    end
+
+    describe "parsing sets" do
+      before do
+        record = "DocWithSets@a_set:<\"one\",\"two\",3,#12:1>"
+        @result = @parser.deserialize_document(record)
+      end
+
+      it "should be Set" do
+        assert_equal @result[:a_set].class, Set
+      end
+
+      it "should find 4 elements" do
+        assert_equal @result[:a_set].length, 4
+      end
+
+      it "should parse string in set" do
+        assert @result[:a_set].include? "one"
+      end
+
+      it "should parse integer in set" do
+        assert @result[:a_set].include? 3
+      end
+
+      it "should parse rid in set" do
+        assert @result[:a_set].include? "#12:1"
+      end
+    end
+
+    describe "parsing primitives" do
+      before do
+        record = "@date:#{Date.today.to_datetime.to_time.to_i}a,time:#{DateTime.now.to_time.to_i}t,name:\"HEY BO DIDDLEY\",song_type:\"cover\",is_active:true,performances:5,stars:5.234f,price:12c,type:\"song\",out_followed_by:<#11:0,#11:1,#11:2,#11:3,#11:4>,out_written_by:#9:7,out_sung_by:#9:8,in_followed_by:<#11:10,#11:150,#11:2578,#11:5574>                                                                                                                                                                                                           "
+        @result = @parser.deserialize_document(record)
+      end
+
+      it "should parse string as String" do
+        assert @result[:name].is_a? String
+      end
+
+      it "should parse string" do
+        assert_equal @result[:name], "HEY BO DIDDLEY"
+      end
+
+      it "should parse int as integer" do
+        assert_equal @result[:performances], 5
+      end
+
+      it "should parse date" do
+        assert @result[:date].is_a? Date
+      end
+
+      it "should parse datetime" do
+        assert @result[:time].is_a? DateTime
+      end
+
+      it "should parse float" do
+        assert @result[:stars].is_a? Float
+      end
+
+      it "should parse big decimals" do
+        assert @result[:price].is_a? BigDecimal
+      end
+
+      it "should parse booleans" do
+        assert @result[:is_active].is_a? TrueClass
+      end
+    end
+
+    describe "parsing hashes" do
+      before do
+        record = "Hash@html:{\"path\":\"html/layout\"}"
+        @result = @parser.deserialize_document(record)
+      end
+
+      it "should parse hash as Hash" do
+        assert @result.is_a? Hash
+      end
+
+      it "should parse hash parameters" do
+        assert_equal @result[:html][:path], "html/layout"
+      end
+    end
+
+    describe "parsing arrays" do
+      before do
+        record = "Array@array:[\"path\",{hash:{path:\"html/layout\"}},2]"
+        @result = @parser.deserialize_document(record)
+      end
+
+      it "should parse array" do
+        assert @result[:array].is_a? Array
+      end
+
+      it "should find 3 elements" do
+        assert_equal @result[:array].length, 3
+      end
+
+      describe "array elements" do
+        it "should parse string" do
+          assert_equal @result[:array][0], "path"
+        end
+
+        it "should parse hash" do
+          assert @result[:array][1].is_a? Hash
+        end
+
+        it "should parse integers" do
+          assert @result[:array][2].is_a? Integer
+        end
+      end
+    end
+
+    describe "parsing documents" do
+      before do
+        record = "schemaVersion:4,classes:[(name:\"OUser\",shortName:,defaultClusterId:4,clusterIds:[4],overSize:0.0f,strictMode:false,properties:[(name:\"password\",type:7,mandatory:true,notNull:true,min:,max:,regexp:,linkedClass:,linkedType:),(name:\"name\",type:7,mandatory:true,notNull:true,min:,max:,regexp:,linkedClass:,linkedType:),(name:\"roles\",type:15,mandatory:false,notNull:false,min:,max:,regexp:,linkedClass:\"ORole\",linkedType:)]),(name:\"ORole\",shortName:,defaultClusterId:3,clusterIds:[3],overSize:0.0f,strictMode:false,properties:[(name:\"mode\",type:17,mandatory:false,notNull:false,min:,max:,regexp:,linkedClass:,linkedType:),(name:\"rules\",type:12,mandatory:false,notNull:false,min:,max:,regexp:,linkedClass:,linkedType:17),(name:\"name\",type:7,mandatory:true,notNull:true,min:,max:,regexp:,linkedClass:,linkedType:)])]"
+        @result = @parser.deserialize_document(record)
+      end
+
+      it "should parse documents" do
+        assert @result[:classes][0][:@type], "d"
+      end
+
+      it "should parse embedded documents" do
+        assert @result[:classes][0][:properties][0][:@type], "d"
+      end
+
+      it "should parse empty objects" do
+        assert_equal @result[:classes][0][:properties][0][:max], nil
+      end
+    end
+  end
+end