pione 0.1.0

data/test/agent/spec_task-worker.rb

@@ -0,0 +1,307 @@
+require_relative '../test-util'
+
+describe 'Pione::Agent::TaskWorker' do
+  describe 'transition' do
+    before do
+      DRb.start_service
+      create_remote_tuple_space_server
+      features = Feature::AndExpr.new(
+        Feature::PossibleExpr.new('A'),
+        Feature::PossibleExpr.new('B'),
+        Feature::PossibleExpr.new('C')
+      )
+      @worker = Agent::TaskWorker.new(tuple_space_server, features)
+    end
+
+    after do
+      tuple_space_server.terminate
+    end
+
+    it 'should take a task' do
+      task = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(task)
+      @worker.__send__(:transit_to_initialized)
+      @worker.__send__(:transit_to_task_waiting).should == task
+    end
+
+    it 'should wait taking a task because of features' do
+      task = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature::RequisiteExpr.new('X'),
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(task)
+      should.raise(Timeout::Error) do
+        timeout(1) do
+          @worker.__send__(:transit_to_task_waiting)
+        end
+      end
+    end
+
+    it 'should not wait taking a task because of features' do
+      task = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature::RequisiteExpr.new('A'),
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(task)
+      @worker.__send__(:transit_to_task_waiting).should == task
+    end
+
+    it 'should take a rule' do
+      task1 = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      rule = Tuple[:rule].new('&main:Test', :fake_content, :known)
+      write(rule)
+      task2, result = @worker.__send__(:transit_to_rule_loading, task1)
+      result.should == :fake_content
+      task2.should == task1
+    end
+
+    it 'should raise an exception because a rule is unknown' do
+      task = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      rule = Tuple[:rule].new('&main:Test', :fake_content, :unknown)
+      write(rule)
+      should.raise(Agent::TaskWorker::UnknownRuleError) do
+        @worker.__send__(:transit_to_rule_loading, task)
+      end
+    end
+
+    it 'should execute a task' do
+      task1 = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(Tuple[:working].new(task1.domain, "test"))
+      rule = ActionRule.new(
+        RuleExpr.new(Package.new('main'), 'Test'),
+        RuleCondition.new(
+          [],
+          [DataExpr.new('out.txt')],
+          Parameters.empty,
+          Feature.empty
+        ),
+        ActionBlock.new("expr 1 + 2 > out.txt")
+      )
+      Pione.quiet_mode do
+        task2, handler, result =
+          @worker.__send__(:transit_to_task_executing, task1, rule)
+        task2.should == task1
+        result.first.name.should == "out.txt"
+      end
+    end
+
+    it 'should write output data tuples' do
+      task1 = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(Tuple[:working].new(task1.domain, "test"))
+      rule = FlowRule.new(
+        RuleExpr.new(Package.new('main'), 'Test'),
+        RuleCondition.new([], [], Parameters.empty, Feature.empty),
+        :dummy
+      )
+      handler1 = RuleHandler::FlowHandler.new(
+        tuple_space_server, rule, [], Parameters.empty, []
+      )
+      result = [Tuple[:data].new('&main:Test', '1.a', nil, Time.now)]
+      task2, handler2 =
+        @worker.__send__(:transit_to_data_outputing, task1, handler1, result)
+      task2.should == task1
+      handler2.should == handler1
+      read(Tuple[:data].new(name: '1.a'))
+    end
+
+    it 'should write a finished_task tuple' do
+      task = Tuple[:task].new(
+        '&main:Test',
+        [],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [], Parameters.empty),
+        []
+      )
+      write(Tuple[:working].new(task.domain, "test"))
+      rule = FlowRule.new(
+        RuleExpr.new(Package.new('main'), 'Test'),
+        RuleCondition.new([], [], Parameters.empty, Feature.empty),
+        :dummy
+      )
+      handler = RuleHandler::FlowHandler.new(
+        tuple_space_server, rule, [], Parameters.empty, []
+      )
+      @worker.__send__(:transit_to_task_finishing, task, handler)
+      finished_task = read(Tuple[:finished].any)
+      finished_task.domain.should == handler.domain
+      finished_task.outputs.should == []
+    end
+  end
+
+  describe 'running' do
+    before do
+      DRb.start_service
+      create_remote_tuple_space_server
+
+      Agent[:logger].start(tuple_space_server, File.open("out.txt", "w+"))
+
+      # process info
+      write(Tuple[:process_info].new('spec_task-worker', 'testid'))
+
+      # setup workers
+      @worker1 = Agent[:task_worker].start(tuple_space_server)
+      @worker2 = Agent[:task_worker].start(tuple_space_server)
+      @worker3 = Agent[:task_worker].start(tuple_space_server)
+
+      # make a task
+      @uri = "local:/tmp/1.a"
+      Resource[@uri].create "abc"
+      @data = Tuple[:data].new(domain: 'test', name: "1.a", uri: @uri)
+      @task1 = Tuple[:task].new(
+        "&main:test",
+        [@data],
+        Parameters.empty,
+        Feature.empty,
+        ID.domain_id("main", "Test", [@data], Parameters.empty),
+        []
+      )
+
+      # make a rule
+      doc = Pione::Document.parse <<-DOCUMENT
+        Rule test
+          input  '*.a'
+          output '{$*}.b'.stdout
+        Action
+        echo -n "input: `cat {$I[1]}`"
+        End
+      DOCUMENT
+      write(
+        Tuple[:rule].new(
+          rule_path: "&main:test",
+          content: doc["&main:test"],
+          status: :known
+        )
+      )
+
+      # workers are waiting tasks
+      @worker1.wait_till(:task_waiting)
+      @worker2.wait_till(:task_waiting)
+      @worker3.wait_till(:task_waiting)
+    end
+
+    after do
+      @worker1.terminate
+      @worker2.terminate
+      @worker3.terminate
+      tuple_space_server.terminate
+    end
+
+    it "should wait tasks" do
+      # check agent state
+      @worker1.current_state.should == :task_waiting
+      @worker2.current_state.should == :task_waiting
+      @worker3.current_state.should == :task_waiting
+
+      # check exceptions
+      check_exceptions
+    end
+
+    it "should say hello and bye" do
+      ## check hello message
+
+      # check agent tuples
+      agents = read_all(Tuple[:agent].any)
+      agents.should.include @worker1.to_agent_tuple
+      agents.should.include @worker2.to_agent_tuple
+      agents.should.include @worker3.to_agent_tuple
+
+      # check worker counter
+      tuple_space_server.current_task_worker_size.should == 3
+
+      # terminate workers
+      @worker1.terminate
+      @worker2.terminate
+      @worker3.terminate
+
+      # wait to terminate
+      @worker1.wait_till(:terminated)
+      @worker2.wait_till(:terminated)
+      @worker3.wait_till(:terminated)
+
+      ## check bye message
+
+      # check agent tuples
+      agents = read_all(Tuple[:agent].any)
+      agents.should.not.include @worker1.to_agent_tuple
+      agents.should.not.include @worker2.to_agent_tuple
+      agents.should.not.include @worker3.to_agent_tuple
+
+      # check agent counter
+      tuple_space_server.current_task_worker_size.should == 0
+
+      # check exceptions
+      check_exceptions
+    end
+
+    it "should process tasks" do
+      # terminate worker2,3
+      @worker2.terminate
+      @worker3.terminate
+      @worker2.wait_till(:terminated)
+      @worker3.wait_till(:terminated)
+
+      # check state
+      @worker1.current_state.should == :task_waiting
+      @worker2.running_thread.should.not.be.alive
+      @worker3.running_thread.should.not.be.alive
+
+      # process task on @worker1
+      @worker1.wait_till(:task_waiting)
+      write(@task1)
+
+      # process task
+      observe_exceptions do
+        sleep 0.3
+        # check finished tuple
+        finished = read(Tuple[:finished].any)
+        # check result data
+        data = read(Tuple[:data].new(name: "1.b"))
+        Resource[data.uri].read.should == "input: abc"
+      end
+    end
+  end
+end

data/test/agent/spec_tuple-space-client.rb

@@ -0,0 +1,30 @@
+require_relative '../test-util'
+
+class TestTupleSpaceClient < Agent::TupleSpaceClient
+  define_state :test1
+  define_state :test2
+  define_state :test3
+
+  define_state_transition :initialized => :test1
+  define_state_transition :test1 => :test2
+  define_state_transition :test2 => :test3
+  define_state_transition :test3 => :terminated
+end
+
+describe 'Pione::Agent::TupleSpaceClient' do
+  before do
+    DRb.start_service
+    create_remote_tuple_space_server
+  end
+
+  after do
+    DRb.stop_service
+  end
+
+  it 'should say "hello"' do
+    ts = TestTupleSpaceClient.new(tuple_space_server)
+    ts.current_state.should == nil
+    ts.transit
+    ts.should.initialized
+  end
+end

data/test/model/spec_assignment.rb

@@ -0,0 +1,51 @@
+require_relative '../test-util'
+
+describe 'Model::Assignment' do
+  it 'should be equal' do
+    x1 = Assignment.new(Variable.new("X"), PioneString.new("a"))
+    x2 = Assignment.new(Variable.new("X"), PioneString.new("a"))
+    x1.should.be.equal x2
+  end
+
+  it 'should not be equal' do
+    x1 = Assignment.new(Variable.new("X"), PioneString.new("a"))
+    x2 = Assignment.new(Variable.new("X"), PioneString.new("b"))
+    y1 = Assignment.new(Variable.new("Y"), PioneString.new("a"))
+    y2 = Assignment.new(Variable.new("Y"), PioneString.new("b"))
+    x1.should.not.be.equal x2
+    x1.should.not.be.equal y1
+    x1.should.not.be.equal y2
+  end
+
+  it 'should push variable and value into variable table' do
+    Assignment.new(
+      Variable.new("X"),
+      PioneString.new("a")
+    ).eval(VariableTable.new).should == PioneString.new("a")
+  end
+
+  it 'should evaluate the value' do
+    vtable = VariableTable.new
+    Assignment.new(
+      Variable.new("X"),
+      Message.new("as_string", 1.to_pione)
+    ).eval(vtable)
+    Variable.new("X").eval(vtable).should == "1".to_pione
+  end
+
+  it 'should update variable table' do
+    vtable = VariableTable.new
+    Assignment.new(
+      Variable.new("X"),
+      "a".to_pione
+    ).eval(vtable).should == "a".to_pione
+    vtable.get(Variable.new("X")).should == "a".to_pione
+    Assignment.new(
+      Variable.new("Y"),
+      Variable.new("Z")
+    ).eval(vtable).should == Variable.new("Z")
+    vtable.get(Variable.new("Y")).should == Variable.new("Z")
+    vtable.set(Variable.new("Z"), "b".to_pione)
+    vtable.get(Variable.new("Y")).should == "b".to_pione
+  end
+end

data/test/model/spec_binary-operator.rb

@@ -0,0 +1,39 @@
+require_relative '../test-util'
+
+describe 'Model::BinaryOperator' do
+  before do
+    @a = Model::BinaryOperator.new(
+      "%",
+      Model::PioneInteger.new(5),
+      Model::PioneInteger.new(2)
+    )
+    @b = Model::BinaryOperator.new(
+      "+",
+      Model::PioneString.new("abc"),
+      Model::PioneString.new("def")
+    )
+  end
+
+  it 'should equal' do
+    @a.should == Model::BinaryOperator.new(
+      "%",
+      Model::PioneInteger.new(5),
+      Model::PioneInteger.new(2)
+    )
+    @b.should == Model::BinaryOperator.new(
+      "+",
+      Model::PioneString.new("abc"),
+      Model::PioneString.new("def")
+    )
+  end
+
+  it 'should not equal' do
+    @a.should.not == @b
+  end
+
+  it 'should send message' do
+    vtable = VariableTable.new
+    @a.eval(vtable).should == Model::PioneInteger.new(1)
+    @b.eval(vtable).should == Model::PioneString.new("abcdef")
+  end
+end

data/test/model/spec_block.rb

@@ -0,0 +1,154 @@
+require_relative '../test-util'
+
+describe 'Model::ActionBlock' do
+  it 'should be equal' do
+    ActionBlock.new("eccho 'a'").should ==
+      ActionBlock.new("eccho 'a'")
+  end
+
+  it 'should not be equal' do
+    ActionBlock.new("eccho 'a'").should.not ==
+      ActionBlock.new("eccho 'b'")
+  end
+
+  it 'should expand variables' do
+    block = ActionBlock.new("{$var1} {$var2} {$var3}")
+    vtable = VariableTable.new
+    vtable.set(Variable.new("var1"), "a".to_pione)
+    vtable.set(Variable.new("var2"), "b".to_pione)
+    vtable.set(Variable.new("var3"), "c".to_pione)
+    block.eval(vtable).should == ActionBlock.new("a b c")
+  end
+end
+
+describe 'Model::FlowBlock' do
+  it 'should be equal' do
+    FlowBlock.new(
+      CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+    ).should == FlowBlock.new(
+      Model::CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+    )
+  end
+
+  it 'should not equal' do
+    FlowBlock.new(
+      CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+    ).should.not == FlowBlock.new(
+      CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+    )
+  end
+
+  it 'should get flow elements' do
+    FlowBlock.new(
+      CallRule.new(RuleExpr.new(Package.new("test"), "a")),
+      CallRule.new(RuleExpr.new(Package.new("test"), "b")),
+      CallRule.new(RuleExpr.new(Package.new("test"), "c"))
+    ).elements.should == [
+      CallRule.new(RuleExpr.new(Package.new("test"), "a")),
+      CallRule.new(RuleExpr.new(Package.new("test"), "b")),
+      CallRule.new(RuleExpr.new(Package.new("test"), "c"))
+    ]
+  end
+
+  it 'should evaluate and get call-rule elements' do
+    x = CallRule.new(RuleExpr.new(Package.new("test"), "x"))
+    y = CallRule.new(RuleExpr.new(Package.new("test"), "y"))
+    z = CallRule.new(RuleExpr.new(Package.new("test"), "z"))
+    vtable = VariableTable.new
+    block = FlowBlock.new(
+      Assignment.new(Variable.new("X"), Variable.new("Y")),
+      Assignment.new(Variable.new("Y"), Variable.new("Z")),
+      ConditionalBlock.new(
+        Variable.new("A"),
+        { PioneBoolean.true =>
+          FlowBlock.new(Assignment.new(Variable.new("Z"), 1.to_pione)),
+        }
+      ),
+      Assignment.new(Variable.new("A"), PioneBoolean.true),
+      ConditionalBlock.new(
+        Message.new("==", Variable.new("Z"), 1.to_pione),
+        { PioneBoolean.true => FlowBlock.new(z) }
+      ),
+      x,
+      y
+    )
+    new_block = block.eval(vtable)
+    new_block.elements.should.include x
+    new_block.elements.should.include y
+    new_block.elements.should.include z
+    new_block.elements.each{|rule| rule.should.kind_of(CallRule)}
+  end
+end
+
+describe 'Model::ConditionalBlock' do
+  it 'should be equal' do
+    ConditionalBlock.new(
+      Variable.new("X"),
+      { "a".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+        ),
+        "b".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+        )
+      }
+    ).should == ConditionalBlock.new(
+      Variable.new("X"),
+      { "a".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+        ),
+        "b".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+        )
+      }
+    )
+  end
+
+  it 'should not be equal' do
+    ConditionalBlock.new(
+      Variable.new("X"),
+      { "a".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+        ),
+        "b".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+        )
+      }
+    ).should != ConditionalBlock.new(
+      Variable.new("Y"),
+      { "a".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+        ),
+        "b".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+        )
+      }
+    )
+  end
+
+  it 'should evaluate' do
+    vtable = VariableTable.new
+    block = ConditionalBlock.new(
+      Variable.new("X"),
+      { "a".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "a"))
+        ),
+        "b".to_pione =>
+        FlowBlock.new(
+          CallRule.new(RuleExpr.new(Package.new("test"), "b"))
+        )
+      }
+    )
+    vtable.set(Variable.new("X"), "a".to_pione)
+    block.eval(vtable).should ==
+      FlowBlock.new(CallRule.new(RuleExpr.new(Package.new("test"), "a")))
+  end
+end