comana 0.0.9 → 0.0.10

data/test/test_computationmanager.rb

@@ -0,0 +1,131 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "fileutils"
+require "helper"
+
+#require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+NOW = Time.now
+
+class Comana::ComputationManager
+  #public :latest_modified_time, :started?
+  public :started?
+end
+
+class TC_ComputationManager < Test::Unit::TestCase
+  class CalcYet < Comana::ComputationManager
+    def finished?         ; false     ; end
+  end
+
+  class CalcStarted < Comana::ComputationManager
+    def finished?         ; false     ; end
+  end
+
+  #describe Comana::ComputationManager, "with output, without lock" do
+  class CalcStarted < Comana::ComputationManager
+    def finished?         ; false     ; end
+  end
+
+  #describe Comana::ComputationManager, "terminated" do
+  class CalcTerminated < Comana::ComputationManager
+    def finished?         ; false     ; end
+    def initialize(dir)
+      @dir = dir
+      @lockdir   = "lock_comana"
+      @alive_time = 500
+    end
+  end
+
+  #describe Comana::ComputationManager, "finished" do
+  class CalcFinished    < Comana::ComputationManager
+    def finished?         ; true      ; end
+  end
+
+  #describe Comana::ComputationManager, "cannot execute" do
+  class CalcNotExecutable    < Comana::ComputationManager
+    def calculate
+      end_status = system "" # notExistCommand
+      raise ExecuteError unless end_status
+    end
+
+    def finished?
+      return false
+    end
+
+    def prepare_next
+      #return false
+      raise
+    end
+  end
+
+
+
+
+  def setup
+    calc_dir = "test/not_started"
+    @calc00 = CalcYet.new(calc_dir)
+    File.utime(NOW - 1000 ,NOW - 1000, "#{calc_dir}/input_a")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/input_b")
+    @lockdir = "#{calc_dir}/lock_comana"
+    FileUtils.rm(@lockdir) if File.exist?(@lockdir)
+
+
+    calc_dir = "test/locked"
+    @calc01 = CalcStarted   .new(calc_dir)
+    File.utime(NOW - 1000 ,NOW - 1000, "#{calc_dir}/input_a")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/input_b")
+
+    calc_dir = "test/outputted"
+    @calc02 = CalcStarted   .new(calc_dir)
+    File.utime(NOW - 1000 ,NOW - 1000, "#{calc_dir}/input_a")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/input_b")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/output")
+
+    calc_dir = "test/locked_outputted"
+    @calc_terminated   = CalcTerminated.new(calc_dir)
+    File.utime(NOW - 1000 ,NOW - 1000, "#{calc_dir}/input_a")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/input_b")
+    File.utime(NOW - 9000 ,NOW - 9000, "#{calc_dir}/output")
+    File.utime(NOW - 9000 ,NOW - 9000, "#{calc_dir}/lock_comana")
+    File.utime(NOW - 9000 ,NOW - 9000, "#{calc_dir}/lock_comana/dummy")
+
+    calc_dir = "test/locked_outputted"
+    @calc_finished     = CalcFinished  .new(calc_dir)
+    File.utime(NOW - 1000 ,NOW - 1000, "#{calc_dir}/input_a")
+    File.utime(NOW - 2000 ,NOW - 2000, "#{calc_dir}/input_b")
+
+    calc_dir = "test/not_executable"
+    @calc_not_exe     = CalcNotExecutable  .new(calc_dir)
+    @lockdir = calc_dir + "/lock_comana"
+    Dir.rmdir(@lockdir) if File.exist?(@lockdir)
+  end
+
+  def test_state
+    assert_equal(:yet,        @calc00.state)
+    assert_equal(:started,    @calc01.state)
+    assert_equal(:yet,        @calc02.state)
+    assert_equal(:terminated, @calc_terminated.state)
+    assert_equal(:finished,   @calc_finished.state)
+  end
+
+  def test_latest_modified_time
+    #it "should return latest modified time" do
+    assert_equal(NOW - 1000, @calc00.latest_modified_time)
+  end
+
+  def test_started?
+    #it "should return false without lock." do
+    assert_not_nil(@calc00.started?)
+    assert_equal(false, @calc00.started?)
+
+    #it "should return true with lock." do
+    assert_equal(false, @calc00.started?)
+  end
+
+  def test_start
+    #it "should raise error" do
+    assert_raise(Comana::ComputationManager::ExecuteError){ @calc_not_exe.start}
+  end
+end
+

data/test/test_hostinspector_pbsnodes.rb

@@ -0,0 +1,92 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "fileutils"
+require "helper"
+
+$TEST = true
+
+#describe Comana::HostInspector::do
+class TC_Pbsnodes < Test::Unit::TestCase
+
+  def setup
+    @p00 = Comana::HostInspector::Pbsnodes.new("Br10")
+    @p01 = Comana::HostInspector::Pbsnodes.new("Br09")
+    @p02 = Comana::HostInspector::Pbsnodes.new("Ge00")
+  end
+
+  def test_state
+    assert_equal("Br10", @p00.name)
+    assert_equal("free", @p00.state)
+    assert_equal("1", @p00.np)
+    assert_equal("Br", @p00.properties)
+    assert_equal("cluster", @p00.ntype)
+    assert_equal(
+      {
+        "rectime"   => "1368099478",
+        "varattr"   => "",
+        "jobs"      => "",
+        "state"     => "free",
+        "netload"   => "1636471502",
+        "gres"      => "",
+        "loadave"   => "0.00",
+        "ncpus"     => "4",
+        "physmem"   => "12322444kb",
+        "availmem"  => "20402856kb",
+        "totmem"    => "20702856kb",
+        "idletime"  => "1389153",
+        "nusers"    => "0",
+        "nsessions" => "? 0",
+        "sessions"  => "? 0",
+        "uname"     => "Linux Br10 3.0.0-12-server #20-Ubuntu SMP Fri Oct 7 16:36:30 UTC 2011 x86_64",
+        "opsys"     => "linux"
+      },
+      @p00.status
+    )
+    assert_equal("0", @p00.gpus)
+
+
+    assert_equal("Br09",@p01.name)
+    assert_equal("down",@p01.state)
+    assert_equal("1",@p01.np)
+    assert_equal("Br",@p01.properties)
+    assert_equal("cluster",@p01.ntype)
+    assert_equal({},@p01.status)
+    assert_equal("0",@p01.gpus)
+
+
+    assert_equal("Ge00", @p02.name)
+    assert_equal("job-exclusive", @p02.state)
+    assert_equal("1", @p02.np)
+    assert_equal("Ge", @p02.properties)
+    assert_equal("cluster", @p02.ntype)
+    assert_equal(
+      {
+        "rectime" => "1368442164",
+        "varattr" => "",
+        "jobs" => "6073.os.calc.atom",
+        "state" => "free",
+        "netload" => "18920135352",
+        "gres" => "",
+        "loadave" => "0.63",
+        "ncpus" => "4",
+        "physmem" => "4046772kb",
+        "availmem" => "12143912kb",
+        "totmem" => "12427184kb",
+        "idletime" => "2697087",
+        "nusers" => "0",
+        "nsessions" => "? 0",
+        "sessions" => "? 0",
+        "uname" => "Linux Ge00 3.0.0-12-server #20-Ubuntu SMP Fri Oct 7 16:36:30 UTC 2011 x86_64",
+        "opsys" => "linux"
+      },
+      @p02.status
+    )
+    assert_equal("0", @p02.gpus)
+
+    assert_raise(Comana::HostInspector::Pbsnodes::UnknownNodeError){
+      Comana::HostInspector::Pbsnodes.new("Ge08")
+    }
+  end
+end
+

data/test/test_hostinspector_ping.rb

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+
+#describe Comana::HostInspector::Ping do
+class TC_Ping < Test::Unit::TestCase
+  def setup
+    #context 'not exist or down' do
+    @hi00 = Comana::HostInspector::Ping.new("")
+
+    #context 'exist and alive' do
+    @hi01 = Comana::HostInspector::Ping.new("localhost")
+  end
+
+  def test_alive?
+    assert_equal(false , @hi00.alive?)
+    assert_equal(true  , @hi01.alive?)
+  end
+end
+

data/test/test_hostselector.rb

@@ -0,0 +1,57 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+
+class Comana::HostSelector
+  attr_reader :groups_hosts
+end
+
+class TC_HostSelector < Test::Unit::TestCase
+  def setup
+    groups_hosts = {
+      "GroupA" => ["A00", "A01"],
+      "GroupB" => ["B00", "B01", "B02"]
+    }
+    @hs00 = Comana::HostSelector.new(groups_hosts)
+
+    groups_hosts = {
+      "GroupNil" => nil,
+      "GroupA" => ["A00", "A01"],
+      "GroupB" => ["B00", "B01", "B02"]
+    }
+    @hs01 = Comana::HostSelector.new(groups_hosts)
+  end
+
+  def test_load_file
+    hs = Comana::HostSelector.load_file("example/dot.clustersetting")
+    assert_equal(Comana::HostSelector, hs.class)
+    #pp hs
+    #assert_equal(["A00", "A01", "B00", "B01", "B02"], hs.select_all)
+    assert_equal({"A"=>["A00", "A01"], "B"=>["B00", "B01", "B02"]}, hs.groups_hosts)
+  end
+
+  def test_select_all
+    #it 'should return all hosts' do
+    assert_equal(["A00", "A01", "B00", "B01", "B02"], @hs00.select_all)
+
+    #it 'should return all hosts without nil' do
+    assert_equal(["A00", "A01", "B00", "B01", "B02"], @hs01.select_all)
+  end
+
+  def test_select_group
+    #it 'should return hosts in GroupA' do
+    assert_equal(["A00", "A01"], @hs00.select_group("GroupA"))
+
+    #it 'should raise Comana::HostSelector::NoEntryError' do
+    assert_raise(Comana::HostSelector::NoEntryError){
+      @hs00.select_group("GroupNil")
+    }
+  end
+
+  def test_groups
+    #it 'should return all groups' do
+    assert_equal(["GroupA", "GroupB"], @hs00.groups)
+  end
+end
+

data/test/test_queuesubmitter.rb

@@ -0,0 +1,214 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+class Comana::QueueSubmitter # < ComputationManager
+  public :dump_prologue
+  public :dump_script
+  public :dump_epilogue
+end
+
+class TC_QueueSubmitter < Test::Unit::TestCase
+  def setup
+    opts = {
+      :target => Comana::ComputationManager.new("test/not_started"),
+      :command => "command_line",
+      :cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    @qs_notstarted = Comana::QueueSubmitter.new(opts)
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/queuesubmitter/locked"),
+      :command => "command_line",
+      :cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    @qs_locked = Comana::QueueSubmitter.new(opts)
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/queuesubmitter/unlocked"),
+      :command => "command_line",
+      :cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    @qs_unlocked = Comana::QueueSubmitter.new(opts)
+  end
+
+  def test_initialize
+    opts = {
+      #:target => "dir_name",
+      :command => "command_line",
+      :cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    assert_raise(Comana::QueueSubmitter::InitializeError){
+      Comana::QueueSubmitter.new(opts)
+    }
+
+    opts = {
+      :target => Comana::ComputationManager.new("dir_name"),
+      #:command => "command_line",
+      :cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    assert_raise(Comana::QueueSubmitter::InitializeError){
+      Comana::QueueSubmitter.new(opts)
+    }
+
+    opts = {
+      :target => Comana::ComputationManager.new("dir_name"),
+      :command => "command_line",
+      #:cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    assert_nothing_raised{ Comana::QueueSubmitter.new(opts) }
+
+    opts = {
+      :target => Comana::ComputationManager.new("dir_name"),
+      :command => "command_line",
+      :cluster => "Nodes",
+      #:num_nodes  => 4,
+    }
+    assert_nothing_raised{ Comana::QueueSubmitter.new(opts) }
+  end
+
+  def test_dump_prologue
+    #context "speed mode" do
+    correct = [
+      '#! /bin/sh',
+      'LOGFILE="${PBS_O_WORKDIR}/prologue_script.log"',
+      'echo "hostname                         : `hostname`" >> $LOGFILE',
+      'echo "job id                           : $1" >> $LOGFILE',
+      'echo "job execution user name          : $2" >> $LOGFILE',
+      'echo "job execution group name         : $3" >> $LOGFILE',
+      'echo "job name                         : $4" >> $LOGFILE',
+      'echo "list of requested resource limits: $5" >> $LOGFILE',
+      'echo "job execution queue              : $6" >> $LOGFILE',
+      'echo "job account                      : $7" >> $LOGFILE',
+      'echo "PBS_O_WORKDIR                    : ${PBS_O_WORKDIR}" >> $LOGFILE',
+      'echo "nodes in pbs_nodefile            : " >> $LOGFILE',
+      'cat ${PBS_NODEFILE} >> $LOGFILE',
+      'exit 0',
+    ].join("\n")
+    assert_equal(correct, @qs_notstarted.dump_prologue)
+  end
+
+  def test_dump_script
+    correct = [
+      "#! /bin/sh",
+      "#PBS -N test/not_started",
+      "#PBS -l nodes=4:ppn=1:Nodes,walltime=7:00:00:00",
+      "#PBS -j oe",
+      "",
+      "cd ${PBS_O_WORKDIR} && \\",
+      "command_line",
+    ].join("\n")
+    assert_equal(correct, @qs_notstarted.dump_script)
+
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/not_started"),
+      :command => "command_line",
+      #:cluster => "Nodes",
+      :num_nodes  => 4,
+    }
+    qs = Comana::QueueSubmitter.new(opts)
+    correct = [
+      "#! /bin/sh",
+      "#PBS -N test/not_started",
+      "#PBS -l nodes=4:ppn=1,walltime=7:00:00:00",
+      "#PBS -j oe",
+      "",
+      "cd ${PBS_O_WORKDIR} && \\",
+      "command_line",
+    ].join("\n")
+    assert_equal(correct, qs.dump_script)
+
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/not_started"),
+      :command => "command_line",
+      :cluster => "Nodes",
+      #:num_nodes  => 4,
+    }
+    qs = Comana::QueueSubmitter.new(opts)
+    correct = [
+      "#! /bin/sh",
+      "#PBS -N test/not_started",
+      "#PBS -l nodes=1:ppn=1:Nodes,walltime=7:00:00:00",
+      "#PBS -j oe",
+      "",
+      "cd ${PBS_O_WORKDIR} && \\",
+      "command_line",
+    ].join("\n")
+    assert_equal(correct, qs.dump_script)
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/not_started"),
+      :command => "command_line",
+      #:cluster => "Nodes",
+      #:num_nodes  => 4,
+    }
+    qs = Comana::QueueSubmitter.new(opts)
+    correct = [
+      "#! /bin/sh",
+      "#PBS -N test/not_started",
+      "#PBS -l walltime=7:00:00:00",
+      "#PBS -j oe",
+      "",
+      "cd ${PBS_O_WORKDIR} && \\",
+      "command_line",
+    ].join("\n")
+    assert_equal(correct, qs.dump_script)
+
+    opts = {
+      :target => Comana::ComputationManager.new("test/not_started"),
+      :command => "command_line",
+      #:cluster => "Nodes",
+      #:num_nodes  => 4,
+      :priority => -10,
+    }
+    qs = Comana::QueueSubmitter.new(opts)
+    correct = [
+      "#! /bin/sh",
+      "#PBS -N test/not_started",
+      "#PBS -l walltime=7:00:00:00",
+      "#PBS -p -10",
+      "#PBS -j oe",
+      "",
+      "cd ${PBS_O_WORKDIR} && \\",
+      "command_line",
+    ].join("\n")
+    assert_equal(correct, qs.dump_script)
+
+  end
+
+  def test_dump_epilogue
+    correct = [
+      '#! /bin/sh',
+      'LOGFILE="${PBS_O_WORKDIR}/epilogue_script.log"',
+      'echo "job id                           : $1" >> $LOGFILE',
+      'echo "job execution user name          : $2" >> $LOGFILE',
+      'echo "job execution group name         : $3" >> $LOGFILE',
+      'echo "job name                         : $4" >> $LOGFILE',
+      'echo "session id                       : $5" >> $LOGFILE',
+      'echo "list of requested resource limits: $6" >> $LOGFILE',
+      'echo "list of resources used by job    : $7" >> $LOGFILE',
+      'echo "job execution queue              : $8" >> $LOGFILE',
+      'echo "job account                      : $9" >> $LOGFILE',
+      'echo "job exit code                    : $10" >> $LOGFILE',
+      'exit 0',
+    ].join("\n")
+
+    assert_equal(correct, @qs_notstarted.dump_epilogue)
+  end
+
+  def test_finished?
+    #context "locked" do
+    assert_equal(true, @qs_locked.finished?)
+
+    #context "unlocked" do
+    assert_equal(false, @qs_unlocked.finished?)
+  end
+end