drbqs 0.0.17 → 0.0.18

data/spec/integration_test/07_command_server_with_node_spec.rb

@@ -24,6 +24,7 @@ describe DRbQS do
     end
 
     it "should raise error in server." do
+      puts "**** This test output errors to stdout ****"
       @path = File.expand_path(File.join(File.dirname(__FILE__), 'definition/server02.rb'))
       @port = 14071
       lambda do

data/spec/integration_test/08_shutdown_unused_nodes_spec.rb

@@ -12,8 +12,9 @@ describe DRbQS::Server do
 
   it "should send node exit" do
     execute_node = DRbQS::Execution::ExecuteNode.new(@uri, nil, nil)
-    execute_node.execute(1)
-    client_process_id = execute_node.pid[0]
+    client_process_id = fork do
+      execute_node.execute(1)
+    end
     th = Process.detach(client_process_id)
     lambda do
       @max_wait_time.times do |i|

data/spec/integration_test/10_test_server_spec.rb

@@ -7,12 +7,12 @@ describe DRbQS::Test::Server do
   it "should execute as test." do
     DRbQS.define_server do |server, argv, opts|
       5.times do |i|
-        server.queue.add(DRbQS::Task.new(TestCount.new, :calc))
+        server.queue.add(DRbQS::Task.new(TestCountCalc.new, :calc))
       end
     end
     server = DRbQS.create_test_server({})
     data = server.test_exec
     data.should be_an_instance_of Hash
-    TestCount.get.should == 5
+    TestCountCalc.get.should == 5
   end
 end

data/spec/integration_test/11_special_tasks_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/task/task'
+require_relative 'definition/task_obj_definition.rb'
+
+describe DRbQS do
+  class TestValue
+    @file = File.join(File.dirname(__FILE__), 'value.txt')
+
+    def self.set(k, v)
+      open(@file, 'a+') do |f|
+        f.puts "#{k.to_s}\t#{v.to_s}"
+      end
+    end
+
+    def self.get(val)
+      if File.exist?(@file)
+        File.read(@file).each_line do |l|
+          if /^#{val.to_s}/ =~ l
+            return l.split[1].to_i
+          end
+        end
+      end
+      nil
+    end
+
+    def self.clear
+      FileUtils.rm(@file) if File.exist?(@file)
+    end
+  end
+
+  before(:all) do
+    @process_id, @uri = drbqs_fork_server(14110, :task => DRbQS::Task.new(Test1.new, :echo, args: [0])) do |server|
+      server.set_initialization_task(DRbQS::Task.new(TestValue, :set, args: [:first, 1]),
+                                     DRbQS::Task.new(TestValue, :set, args: [:second, 2]))
+      server.set_finalization_task(DRbQS::Task.new(TestValue, :set, args: [:third, 3]),
+                                   DRbQS::Task.new(TestValue, :set, args: [:fourth, 4]))
+    end
+    @node = DRbQS::Node.new(@uri, :log_file => $stdout, :continue => true)
+  end
+
+  it "should execute initialization tasks." do
+    @node.connect
+    TestValue.get(:first).should == 1
+    TestValue.get(:second).should == 2
+  end
+
+  it "should execute finalization tasks" do
+    @node.calculate
+    sleep(1)                    # Wait finish of task.
+    TestValue.get(:third).should == 3
+    TestValue.get(:fourth).should == 4
+  end
+
+  after(:all) do
+    TestValue.clear
+    lambda do
+      drbqs_wait_kill_server(@process_id, 30)
+    end.should_not raise_error
+  end
+end

data/spec/integration_test/12_multiple_workers_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/task/task'
+require_relative 'definition/task_obj_definition.rb'
+
+describe DRbQS do
+  before(:all) do
+    @dir = 'test_pid_dir'
+    FileUtils.mkdir(@dir) unless File.exist?(@dir)
+    @number_of_task = 10
+    @tasks = @number_of_task.times.map do |i|
+      DRbQS::Task.new(TestPID.new, :save, args: [@dir])
+    end
+    @process_number = 3
+    @process_id, @uri = drbqs_fork_server(14120, :task => @tasks)
+    @node = DRbQS::Node.new(@uri, :log_file => $stdout, :continue => true, :process => @process_number)
+  end
+
+  it "should calculate" do
+    @node.connect
+    lambda do
+      @node.calculate
+    end.should_not raise_error
+    paths = Dir.glob(File.join(@dir, '*')).select do |file|
+      /^\d+$/ =~ File.basename(file)
+    end
+    paths.uniq.should have(@process_number).items
+    n = 0
+    paths.each do |path|
+      n += File.read(path).to_i
+    end
+    n.should == @number_of_task
+  end
+
+  after(:all) do
+    TestCount.clear
+    lambda do
+      drbqs_wait_kill_server(@process_id)
+    end.should_not raise_error
+    FileUtils.rm_r(@dir) if File.exist?(@dir)
+  end
+
+end

data/spec/integration_test/definition/task_obj_definition.rb

@@ -1,14 +1,26 @@
-class Test1
-  @@execute_echo_number = 0
+class TestCount
+  @@file = File.join(File.dirname(__FILE__), 'count.txt')
 
   def echo(*args)
-    puts "execute Test1#echo(*#{args.inspect.strip})"
-    @@execute_echo_number += 1
+    open(@@file, 'a+') do |f|
+      f.puts "count"
+    end
     args
   end
 
   def self.get_execute_echo_number
-    @@execute_echo_number
+    File.read(@@file).lines.to_a.size
+  end
+
+  def self.clear
+    FileUtils.rm(@@file) if File.exist?(@@file)
+  end
+end
+
+class Test1
+  def echo(*args)
+    puts "execute Test1#echo(*#{args.inspect.strip})"
+    args
   end
 end
 
@@ -48,7 +60,7 @@ class TestSum
   end
 end
 
-class TestCount
+class TestCountCalc
   @@count = 0
 
   def calc
@@ -61,3 +73,18 @@ class TestCount
     n
   end
 end
+
+class TestPID
+  def save(dir)
+    path = File.join(dir, "#{Process.pid}")
+    if File.exist?(path)
+      n = File.read(path).to_i + 1
+    else
+      n = 1
+    end
+    Kernel.open(path, 'w') do |f|
+      f.print n.to_s
+    end
+    true
+  end
+end

data/spec/node/connection_spec.rb

@@ -20,9 +20,9 @@ describe DRbQS::Node::Connection do
   end
 
   it "should get initialization." do
-    ary = [:initialize, [1, 2], :size, []]
-    @message.write(ary)
-    @connection.get_initialization.should == ary[1..-1]
+    ary = DRbQS::Task.new([1, 2], :size).simple_drb_args
+    @message.write([:initialize, ary])
+    @connection.get_initialization.should == ary
   end
 
   it "should get no finalization method." do
@@ -30,9 +30,9 @@ describe DRbQS::Node::Connection do
   end
 
   it "should get finalization." do
-    ary = [:finalize, [1, 2], :size, []]
-    @message.write(ary)
-    @connection.get_finalization.should == ary[1..-1]
+    ary = DRbQS::Task.new([1, 2], :size).simple_drb_args
+    @message.write([:finalize, ary])
+    @connection.get_finalization.should == ary
   end
 
   it "should raise error for invalid signal." do

data/spec/node/node_spec.rb

@@ -22,12 +22,20 @@ describe DRbQS::Node do
     end
 
     it "should connect to server." do
+      node_number = 10
       DRb::DRbObject.should_receive(:new_with_uri).and_return(@drb_object)
       node_connection = mock('node connection')
-      node_connection.stub(:node_number).and_return(10)
+      node_connection.stub(:node_number).and_return(node_number)
       node_connection.stub(:get_initialization).and_return(nil)
+      task_client = mock('task client')
+      task_client.stub(:node_number).and_return(node_number)
+      worker = mock('worker')
+      worker.stub(:create_process)
+      worker.stub(:on_error)
+      worker.stub(:on_result)
       DRbQS::Node::Connection.should_receive(:new).and_return(node_connection)
-      DRbQS::Node::TaskClient.should_receive(:new)
+      DRbQS::Node::TaskClient.should_receive(:new).and_return(task_client)
+      DRbQS::Worker::ProcessSet.should_receive(:new).and_return(worker)
       subject.connect
     end
   end

data/spec/node/state_spec.rb

@@ -1,79 +1,178 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe DRbQS::Node::State do
+  def make_all_processes_wait
+    @process_number.times do |i|
+      subject.change(i, :wait)
+    end
+  end
+
+  before(:all) do
+    @process_number = 3
+  end
+
   subject do
-    DRbQS::Node::State.new(:wait)
+    DRbQS::Node::State.new(:wait, @process_number)
   end
 
-  context "when state is :wait" do
+  context "when getting process number" do
+    it "should yield each process number." do
+      wids = []
+      subject.each_worker_id do |wid|
+        wids << wid
+      end
+      wids.sort.should == @process_number.times.to_a.sort
+    end
+
+    it "should get waiting process number." do
+      subject.waiting_worker_id.sort.should ==  @process_number.times.to_a.sort
+    end
+
+    it "should get waiting process number with not waiting process." do
+      waiting = []
+      @process_number.times do |i|
+        if i == 2
+          subject.change(i, :calculate)
+        else
+          waiting << i
+        end
+      end
+      subject.waiting_worker_id.sort.should == waiting
+    end
+  end
+
+  context "when requesting new tasks" do
     before(:each) do
-      subject.change(:wait)
+      make_all_processes_wait
     end
 
-    it "should change to :wait." do
-      lambda do
-        subject.change_to_wait
-      end.should_not change { subject.state }
+    it "should request." do
+      subject.request?.should be_true
+    end
+
+    it "should request for all processes." do
+      subject.request_task_number.should == @process_number
+    end
+
+    it "should request except for one process." do
+      subject.change(0, :calculate)
+      subject.request_task_number.should == @process_number - 1
+    end
+  end
+
+  context "when state is :wait" do
+    before(:each) do
+      @process_number.times do |i|
+        subject.change(i, :wait)
+      end
     end
 
     it "should change to :sleep." do
-      lambda do
-        subject.change_to_sleep
-      end.should change { subject.state }.from(:wait).to(:sleep)
+      subject.change_to_sleep
+      @process_number.times do |i|
+        subject.get_state(i).should == :sleep
+      end
     end
 
-    it "should change to :calculate." do
-      lambda do
-        subject.change_to_calculate
-      end.should change { subject.state }.from(:wait).to(:calculate)
+    it "should sleep." do
+      subject.sleep_with_auto_wakeup
+      @process_number.times do |i|
+        subject.get_state(i).should == :sleep
+      end
+    end
+
+    it "should wakeup." do
+      subject.wakeup_sleeping_worker
+      @process_number.times do |i|
+        subject.get_state(i).should == :wait
+      end
     end
   end
 
   context "when state is :sleep" do
     before(:each) do
-      subject.change(:sleep)
+      @process_number.times do |i|
+        subject.change(i, :sleep)
+      end
     end
 
     it "should change to :sleep." do
-      lambda do
-        subject.change_to_wait
-      end.should change { subject.state }.from(:sleep).to(:wait)
+      subject.change_to_sleep
+      @process_number.times do |i|
+        subject.get_state(i).should == :sleep
+      end
     end
 
-    it "should change to :sleep." do
-      lambda do
-        subject.change_to_sleep
-      end.should_not change { subject.state }
+    it "should sleep." do
+      subject.sleep_with_auto_wakeup
+      @process_number.times do |i|
+        subject.get_state(i).should == :sleep
+      end
     end
 
-    it "should change to :calculate." do
-      lambda do
-        subject.change_to_calculate
-      end.should change { subject.state }.from(:sleep).to(:calculate)
+    it "should wakeup." do
+      subject.wakeup_sleeping_worker
+      @process_number.times do |i|
+        subject.get_state(i).should == :wait
+      end
     end
   end
 
   context "when state is :calculate" do
     before(:each) do
-      subject.change(:calculate)
+      @process_number.times do |i|
+        subject.change(i, :calculate)
+      end
     end
 
     it "should change to :sleep." do
-      lambda do
-        subject.change_to_wait
-      end.should_not change { subject.state }
+      subject.change_to_sleep
+      @process_number.times do |i|
+        subject.get_state(i).should == :calculate
+      end
+    end
+
+    it "should sleep." do
+      subject.sleep_with_auto_wakeup
+      @process_number.times do |i|
+        subject.get_state(i).should == :calculate
+      end
+    end
+
+    it "should wakeup." do
+      subject.wakeup_sleeping_worker
+      @process_number.times do |i|
+        subject.get_state(i).should == :calculate
+      end
+    end
+  end
+
+  context "when state is :calculate" do
+    before(:each) do
+      @process_number.times do |i|
+        subject.change(i, :exit)
+      end
     end
 
     it "should change to :sleep." do
-      lambda do
-        subject.change_to_sleep
-      end.should_not change { subject.state }
+      subject.change_to_sleep
+      @process_number.times do |i|
+        subject.get_state(i).should == :exit
+      end
     end
 
-    it "should change to :calculate." do
-      lambda do
-        subject.change_to_calculate
-      end.should_not change { subject.state }
+    it "should sleep." do
+      subject.sleep_with_auto_wakeup
+      @process_number.times do |i|
+        subject.get_state(i).should == :exit
+      end
+    end
+
+    it "should wakeup." do
+      subject.wakeup_sleeping_worker
+      @process_number.times do |i|
+        subject.get_state(i).should == :exit
+      end
     end
   end
 
@@ -91,50 +190,35 @@ describe DRbQS::Node::State do
 
   context "when setting load average" do
     subject do
-      DRbQS::Node::State.new(:wait, :max_loadavg => 2)
+      DRbQS::Node::State.new(:wait, 1, :max_loadavg => 2)
     end
 
     it "should be true" do
       subject.stub(:get_load_average).and_return([2.0, 2,0, 2.0])
-      subject.system_busy?.should be_true
+      subject.__send__(:system_busy?).should be_true
     end
 
     it "should be nil" do
       subject.stub(:get_load_average).and_return([1.0, 1,0, 1.0])
-      subject.system_busy?.should be_nil
+      subject.__send__(:system_busy?).should be_nil
     end
   end
 
-  context "when changing state to finish calculating" do
-    before(:each) do
-      subject.change(:calculate)
-    end
-
-    it "should change to :wait." do
-      lambda do
-        subject.change_to_finish_calculating
-      end.should change { subject.state }.from(:calculate).to(:wait)
-    end
-
-    it "should change to :sleep." do
-      subject.change_to_sleep
-      lambda do
-        subject.change_to_finish_calculating
-      end.should change { subject.state }.from(:calculate).to(:sleep)
+  context "when setting auto wakeup" do
+    before(:all) do
+      @check_worker_id = 0
     end
-  end
 
-  context "when setting auto wakeup" do
     subject do
-      DRbQS::Node::State.new(:wait, :sleep_time => 0)
+      DRbQS::Node::State.new(:wait, 1, :sleep_time => 0)
     end
 
     it "should do nothing." do
+      make_all_processes_wait
       subject.stub(:system_busy?).and_return(nil)
-      subject.change(:wait)
       lambda do
         subject.wakeup_automatically_for_unbusy_system
-      end.should_not change { subject.state }
+      end.should_not change { subject.get_state(@check_worker_id) }
     end
 
     it "should do nothing." do
@@ -142,7 +226,7 @@ describe DRbQS::Node::State do
       subject.sleep_with_auto_wakeup
       lambda do
         subject.wakeup_automatically_for_unbusy_system
-      end.should change { subject.state }.from(:sleep).to(:wait)
+      end.should change { subject.get_state(@check_worker_id) }.from(:sleep).to(:wait)
     end
   end
 end