drbqs 0.0.13 → 0.0.14

data/spec/{ssh_shell_spec.rb → manage/ssh_shell_spec.rb}

@@ -1,10 +1,10 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-require 'drbqs/ssh/shell'
+require 'drbqs/manage/ssh_shell'
 
-describe DRbQS::SSHShell do
+describe DRbQS::Manage::SSHShell do
   it "should split destination" do
-    ssh = DRbQS::SSHShell.new('user@hostname')
+    ssh = DRbQS::Manage::SSHShell.new('user@hostname')
     ssh.user.should == 'user'
     ssh.host.should == 'hostname'
     ssh.port.should be_nil
@@ -12,7 +12,7 @@ describe DRbQS::SSHShell do
   end
 
   it "should split destination including directory" do
-    ssh = DRbQS::SSHShell.new('user@hostname:22', :dir => '/path/to/directory')
+    ssh = DRbQS::Manage::SSHShell.new('user@hostname:22', :dir => '/path/to/directory')
     ssh.user.should == 'user'
     ssh.host.should == 'hostname'
     ssh.port.should == 22
@@ -21,19 +21,19 @@ describe DRbQS::SSHShell do
 
   it "should raise error: not include '@'" do
     lambda do
-      DRbQS::SSHShell.new('userhostname')
+      DRbQS::Manage::SSHShell.new('userhostname')
     end.should raise_error
   end
 
   it "should raise error: empty user name" do
     lambda do
-      DRbQS::SSHShell.new('@hostname')
+      DRbQS::Manage::SSHShell.new('@hostname')
     end.should raise_error
   end
 
   it "should raise error: empty host name" do
     lambda do
-      DRbQS::SSHShell.new('user:22')
+      DRbQS::Manage::SSHShell.new('user:22')
     end.should raise_error
   end
 

data/spec/node/connection_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/node/connection.rb'
+
+describe DRbQS::Node::Connection do
+  before(:all) do
+    @message = Rinda::TupleSpace.new
+    @connection = DRbQS::Node::Connection.new(@message)
+    @node_id = 23
+    @message.write([@connection.id, @node_id])
+  end
+
+  it "should get node ID." do
+    @connection.node_number.should == @node_id
+    @message.take([:server, :connect, nil], 0).should be_true
+  end
+
+  it "should get no initialization method." do
+    @connection.get_initialization.should be_nil
+  end
+
+  it "should get initialization." do
+    ary = [:initialize, [1, 2], :size, []]
+    @message.write(ary)
+    @connection.get_initialization.should == ary[1..-1]
+  end
+
+  it "should get no finalization method." do
+    @connection.get_finalization.should be_nil
+  end
+
+  it "should get finalization." do
+    ary = [:finalize, [1, 2], :size, []]
+    @message.write(ary)
+    @connection.get_finalization.should == ary[1..-1]
+  end
+
+  it "should raise error for invalid signal." do
+    @message.write([@node_id, :alive_p])
+    @connection.respond_signal
+    @message.take([:server, :alive, nil], 0).should be_true
+  end
+
+  it "should respond :alive_p signal" do
+    @message.write([@node_id, :invalid])
+    lambda do
+      @connection.respond_signal
+    end.should raise_error
+  end
+
+  [:exit, :finalize, :exit_after_task].each do |sym|
+    it "should respond #{sym} signal" do
+      @message.write([@node_id, sym])
+      @connection.respond_signal.should == sym
+    end
+  end
+
+  it "should send node error message." do
+    err_mes = "Node Error"
+    @connection.send_node_error(err_mes)
+    ary = @message.take([:server, :node_error, Array])
+    ary[2][0].should == @node_id
+    ary[2][1].should == err_mes
+  end
+
+end

data/spec/node/task_client_spec.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/node/task_client'
+
+describe DRbQS::Node::TaskClient do
+  def init_task_client(node_number = 10)
+    @node_number = node_number
+    @ts_queue = Rinda::TupleSpace.new
+    @ts_result = Rinda::TupleSpace.new
+    @task_client = DRbQS::Node::TaskClient.new(@node_number, @ts_queue, @ts_result)
+  end
+
+  def add_task_to_tuplespace(task_id, task_ary)
+    @ts_queue.write([task_id] + task_ary)
+  end
+
+  def check_empty_queue_tuplespace
+    @ts_queue.read_all([nil, nil, nil, nil]).size.should == 0
+  end
+
+  subject do
+    @task_client
+  end
+
+  context "when we get initial task client" do
+    before(:all) do
+      init_task_client
+    end
+
+    it "should have empty task queue." do
+      subject.task_empty?.should be_true
+    end
+
+    it "should have empty result queue." do
+      subject.result_empty?.should be_true
+    end
+
+    it "should not have calculating task." do
+      subject.calculating_task.should be_nil
+    end
+
+    it "should return no task" do
+      subject.get_task.should be_nil
+    end
+  end
+
+  context "when getting task" do
+    before(:all) do
+      init_task_client
+      @task_id = 3
+      @task_ary = ["hello world", :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+    end
+
+    it "should return task" do
+      subject.get_task.should == @task_ary.dup.unshift(@task_id)
+    end
+
+    it "should take out task from tuplespace." do
+      check_empty_queue_tuplespace
+    end
+  end
+
+  context "when adding new task" do
+    before(:all) do
+      init_task_client(7)
+      @task_id = 3
+      @task_ary = [[1, 3, 5, 7], :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+      subject.add_new_task
+    end
+
+    it "should have non empty task queue." do
+      subject.task_empty?.should_not be_true
+    end
+
+    it "should have empty result queue." do
+      subject.result_empty?.should be_true
+    end
+
+    it "should have calculating task" do
+      subject.calculating_task.should == @task_id
+    end
+
+    it "should take out task from tuplespace." do
+      check_empty_queue_tuplespace
+    end
+
+    it "should get :accept signal." do
+      @ts_result.take([:accept, nil, nil], 0).should == [:accept, @task_id, subject.node_number]
+    end
+  end
+
+  context "when dequeueing a task" do
+    before(:all) do
+      init_task_client(14)
+      @task_id = 8
+      @task_ary = [[1, 3, 5, 7], :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+      subject.add_new_task
+      @dequeued_task = subject.dequeue_task
+    end
+
+    it "should get a task" do
+      @dequeued_task.should == @task_ary
+    end
+
+    it "should have empty task queue." do
+      subject.task_empty?.should be_true      
+    end
+
+    it "should have empty result queue." do
+      subject.result_empty?.should be_true      
+    end
+
+    it "should have calculating task." do
+      subject.calculating_task.should == @task_id      
+    end
+  end
+
+  context "when queueing result" do
+    before(:all) do
+      init_task_client(2)
+      @task_id = 27
+      @task_ary = ["abcdef", :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+      subject.add_new_task
+      @dequeued_task = subject.dequeue_task
+      subject.queue_result(:result_object)
+    end
+
+    it "should have empty task queue." do
+      subject.task_empty?.should be_true      
+    end
+
+    it "should have non empty result queue." do
+      subject.result_empty?.should_not be_true
+    end
+
+    it "should have calculating task." do
+      subject.calculating_task.should == @task_id
+    end
+  end
+
+  context "when sending result" do
+    before(:all) do
+      init_task_client(2)
+      @task_id = 27
+      @task_ary = ["abcdef", :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+      subject.add_new_task
+      @dequeued_task = subject.dequeue_task
+      subject.queue_result(:result_object)
+      @send_returned_value = subject.send_result
+    end
+
+    it "should get nil returned value." do
+      @send_returned_value.should be_nil
+    end
+
+    it "should have empty task queue." do
+      subject.task_empty?.should be_true      
+    end
+
+    it "should have empty result queue." do
+      subject.result_empty?.should_not be_nil
+    end
+
+    it "should not have calculating task." do
+      subject.calculating_task.should be_nil
+    end
+
+    it "should get result from tuplespace." do
+      @ts_result.take([:result, nil, nil, nil], 0).should be_true
+    end
+  end
+
+  context "when setting exit_after_task" do
+    before(:all) do
+      init_task_client(2)
+      @task_id = 27
+      @task_ary = ["abcdef", :size, []]
+      add_task_to_tuplespace(@task_id, @task_ary)
+      subject.add_new_task
+      subject.set_exit_after_task
+      @dequeued_task = subject.dequeue_task
+      subject.queue_result(:result_object)
+    end
+
+    it "should return true" do
+      subject.send_result.should be_true
+    end
+  end
+
+  context "when dumping result queue" do
+    before(:all) do
+      init_task_client(2)
+    end
+
+    it "should return nil for empty result queue." do
+      subject.dump_result_queue.should be_nil
+    end
+
+    it "should return string for non empty result queue." do
+      results = [:result_object1, :result_object2]
+      results.each do |sym|
+        subject.queue_result(sym)
+      end
+      subject.dump_result_queue.should == Marshal.dump(results)
+    end
+  end
+end

data/spec/server/acl_file_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'drbqs/server/acl_file'
+
+describe DRbQS::Server::ACLFile do
+  it "should return an ACL object" do
+    acl = DRbQS::Server::ACLFile.load(File.dirname(__FILE__) + '/data/acl.txt')
+    acl.should be_an_instance_of ACL
+  end
+end

data/spec/{server_check_alive_spec.rb → server/check_alive_spec.rb}

@@ -1,31 +1,35 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-require 'drbqs/server'
+require 'drbqs/server/check_alive'
 
-describe DRbQS::CheckAlive do
+describe DRbQS::Server::CheckAlive do
   it "should raise error with not a number" do
     lambda do
-      DRbQS::CheckAlive.new('abc')
+      DRbQS::Server::CheckAlive.new('abc')
     end.should raise_error
   end
 
   it "should raise error with a minus number" do
     lambda do
-      DRbQS::CheckAlive.new(-10)
+      DRbQS::Server::CheckAlive.new(-10)
     end.should raise_error    
   end
 
   it "should return true" do
-    check = DRbQS::CheckAlive.new(0.1)
-    sleep(0.3)
+    check = DRbQS::Server::CheckAlive.new(0.01)
+    sleep(0.03)
     check.significant_interval?.should be_true
-    check.set_checking
-    sleep(0.01)
-    check.significant_interval?.should be_false
   end
 
   it "should return false" do
-    check = DRbQS::CheckAlive.new(100)
+    check = DRbQS::Server::CheckAlive.new(100)
+    check.significant_interval?.should be_false
+  end
+
+  it "should set checking" do
+    check = DRbQS::Server::CheckAlive.new(0.1)
+    sleep(0.2)
+    check.set_checking
     check.significant_interval?.should be_false
   end
 end

data/spec/{history_spec.rb → server/history_spec.rb}

@@ -1,8 +1,8 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-require 'drbqs/history'
+require 'drbqs/server/history'
 
-describe DRbQS::History do
+describe DRbQS::Server::History do
 
   def check_event(event, *vals)
     event[0].should be_an_instance_of Time
@@ -13,7 +13,7 @@ describe DRbQS::History do
 
   context "when setting events" do
     before(:all) do
-      @history = DRbQS::History.new
+      @history = DRbQS::Server::History.new
       @history.set(1, :abc)
       @history.set(1, :def)
       @history.set(2, 'ABC', 'DEF')
@@ -55,10 +55,14 @@ describe DRbQS::History do
       events = @history.events(3)
       check_event(events[0], :ghi)
     end
+
+    it "should return strings of log" do
+      @history.log_strings.should be_an_instance_of String
+    end
   end
 
   context "when executing a method" do
-    subject { DRbQS::History.new }
+    subject { DRbQS::Server::History.new }
 
     it "should add new event" do
       id = 1

data/spec/server/message_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/server/message.rb'
+require 'drbqs/task/task'
+
+describe DRbQS::Server::Message do
+  before(:all) do
+    @message = Rinda::TupleSpace.new
+    @message_server = DRbQS::Server::Message.new(@message)
+    @node_list = @message_server.instance_variable_get(:@node_list)
+  end
+
+  def set_nodes(num)
+    num.times do |i|
+      id_str = "connect_test_#{i}"
+      @message.write([:server, :connect, id_str])
+      @message_server.get_message.should == [:connect]
+      id_str_reply, id_num = @message.take([id_str, nil])
+    end
+  end
+
+  def clear_all_node
+    @message_server.get_all_nodes.each do |id_num, id_str|
+      @node_list.delete(id_num)
+    end
+  end
+
+  context "when getting messages" do
+    it "should return nil" do
+      @message_server.get_message.should be_nil
+    end
+
+    it "should get :connect message" do
+      5.times do |i|
+        id_str = "connect_test_#{i}"
+        @message.write([:server, :connect, id_str])
+        @message_server.get_message.should == [:connect]
+        id_str_reply, id_num = @message.take([id_str, nil])
+        id_num.should > 0
+      end
+    end
+
+    it "should get :alive message" do
+      node_id = 73
+      @message.write([:server, :alive, node_id])
+      @node_list.should_receive(:set_alive).with(node_id)
+      @message_server.get_message.should == [:alive]
+    end
+
+    it "should get :exit_server message" do
+      @message.write([:server, :exit_server, 'message_test'])
+      @message_server.get_message.should == [:exit_server]
+    end
+
+    it "should get :exit_after_task message" do
+      @message.write([:server, :exit_after_task, 1])
+      @message_server.get_message.should == [:exit_after_task, 1]
+    end
+
+    it "should get :request_status message" do
+      @message.write([:server, :request_status, 'message_test'])
+      @message_server.get_message.should == [:request_status]
+    end
+
+    it "should get :node_error message" do
+      node_id = 74
+      @message.write([:server, :node_error, [node_id, 'Error occurs.']])
+      @node_list.should_receive(:delete).with(node_id)
+      @message_server.get_message.should == [:node_error, node_id]
+    end
+
+    it "should return nil for invalid message" do
+      @message.write([:server, :invalid_message])
+      @message_server.get_message.should be_nil
+    end
+
+    after(:all) do
+      clear_all_node
+    end
+  end
+
+  context "when sending messages" do
+    before(:all) do
+      set_nodes(5)
+    end
+
+    it "should send exit message" do
+      @message_server.send_exit
+      @message_server.get_all_nodes.each do |id_num, id_str|
+        @message.take([id_num, :exit]).should be_true
+      end
+    end
+
+    it "should send finalization message" do
+      @message_server.send_finalization
+      @message_server.get_all_nodes.each do |id_num, id_str|
+        @message.take([id_num, :finalize]).should be_true
+      end
+    end
+
+    it "should send exit_after_task message" do
+      id = @message_server.get_all_nodes.to_a[0][0]
+      @message_server.send_exit_after_task(id)
+      @message.take([id, :exit_after_task]).should be_true
+    end
+
+    it "should send status" do
+      @message_server.send_status({})
+      sym, status = @message.take([:status, nil])
+      status.should be_an_instance_of String
+    end
+
+    after(:all) do
+      clear_all_node
+    end
+  end
+
+  context "when setting special tasks" do
+    it "should set initialization task" do
+      lambda do
+        @message.take([:initialize, nil, Symbol, nil], 0)
+      end.should raise_error Rinda::RequestExpiredError
+      @message_server.set_initialization(DRbQS::Task.new(Object.new, :object_id))
+      @message.take([:initialize, nil, Symbol, nil], 0).should be_true
+    end
+
+    it "should set finalization task" do
+      lambda do
+        @message.take([:finalization, nil, Symbol, nil], 0)
+      end.should raise_error Rinda::RequestExpiredError
+      @message_server.set_finalization(DRbQS::Task.new(Object.new, :object_id))
+      @message.take([:finalization, nil, Symbol, nil], 0).should be_true
+    end
+  end
+
+  context "when checking existence of nodes" do
+    before(:all) do
+      clear_all_node
+    end
+
+    it "should return a hash" do
+      @message_server.get_all_nodes.should be_an_instance_of Hash
+    end
+
+    it "should have no node" do
+      @message_server.node_not_exist?.should be_true
+    end
+
+    it "should return nil" do
+      # Minus ID is invalid. So the node of the ID does not exist.
+      @message_server.node_exist?(-100).should_not be_true
+    end
+
+    it "should return true" do
+      id_str = "checking_node"
+      @message.write([:server, :connect, id_str])
+      @message_server.get_message.should == [:connect]
+      id_str_reply, id_num = @message.take([id_str, nil])
+      @message_server.node_exist?(id_num).should be_true
+    end
+
+    after(:all) do
+      clear_all_node
+    end
+  end
+
+  context "when checking connection" do
+    before(:all) do
+      set_nodes(5)
+    end
+
+    it "should send :alive_p message" do
+      @message_server.check_connection.should == []
+      @message_server.get_all_nodes.each do |id_num, id_str|
+        @message.take([id_num, :alive_p]).should be_true
+      end
+    end
+
+    it "should delete nodes" do
+      node_id_list = @message_server.get_all_nodes.to_a.map do |ary|
+        ary[0]
+      end.sort
+      @message_server.check_connection.sort.should == node_id_list
+      node_id_list.each do |id_num|
+        lambda do
+          @message.take([id_num, :alive_p], 0)
+        end.should raise_error Rinda::RequestExpiredError
+      end
+    end
+
+    after(:all) do
+      clear_all_node
+    end
+  end
+end