pione 0.1.0

data/test/agent/spec_basic-agent.rb

@@ -0,0 +1,170 @@
+require_relative '../test-util'
+
+class TestAgentType < Agent::BasicAgent
+  set_agent_type :test_agent_type
+end
+
+class TestStateTransition < Agent::BasicAgent
+  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
+
+class TestLoopStateTransition < Agent::BasicAgent
+  define_state :test
+
+  define_state_transition :initialized => :test
+  define_state_transition :test => :test
+end
+
+class TestConditionalStateTransition < Agent::BasicAgent
+  define_state :test
+  define_state :testA
+  define_state :testB
+
+  define_state_transition :initialized => :test
+  define_state_transition :test => lambda{|agent,result| agent.next_state }
+  define_state_transition :testA => :test
+  define_state_transition :testB => :test
+
+  attr_reader :next_state
+
+  def transit_to_test
+    case @next_state
+    when nil
+      @next_state = :testA
+    when :testA
+      @next_state = :testB
+    when :testB
+      @next_state = :terminated
+    end
+  end
+end
+
+class TestExceptionTransition < Agent::BasicAgent
+  define_state :test
+  define_state :ehandler
+
+  define_state_transition :initialized => :test
+  define_state_transition :test => :terminated
+  define_state_transition :ehandler => :terminated
+
+  define_exception_handler RuntimeError => :ehandler
+
+  def transit_to_test
+    raise RuntimeError.new(:test_exception)
+  end
+
+  def transit_to_ehandler(e)
+  end
+end
+
+describe 'Pione::Agent::BasicAgent' do
+  describe 'agent type' do
+    it 'should get the agent type' do
+      TestAgentType.agent_type.should == :test_agent_type
+      TestAgentType.new.agent_type.should == :test_agent_type
+    end
+  end
+
+  describe 'simple transition' do
+    it 'should return states' do
+      states = TestStateTransition.states
+      states.should.include :initialized
+      states.should.include :test1
+      states.should.include :test2
+      states.should.include :test3
+      states.should.include :terminated
+      states.should.include :error
+    end
+
+    it 'should transit' do
+      ts = TestStateTransition.new
+      ts.current_state.should == nil
+      ts.transit
+      ts.should.initialized
+      ts.transit
+      ts.should.test1
+      ts.transit
+      ts.should.test2
+      ts.transit
+      ts.should.test3
+      ts.transit
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.transit }
+    end
+
+    it 'should run' do
+      ts = TestStateTransition.start
+      ts.wait_till(:terminated)
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.start }
+    end
+
+    it 'should terminate' do
+      ts = TestStateTransition.new
+      ts.transit # to initialized
+      ts.transit # to test1
+      ts.terminate
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.transit }
+    end
+  end
+
+  describe 'loop transition' do
+    it 'should loop' do
+      ts = TestLoopStateTransition.new
+      100.times { ts.transit }
+      ts.should.test
+    end
+
+    it 'should terminate' do
+      ts = TestLoopStateTransition.start
+      sleep 0.1
+      ts.terminate
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.transit }
+    end
+  end
+
+  describe 'conditional transition' do
+    it 'should transit' do
+      ts = TestConditionalStateTransition.new
+      ts.current_state.should.nil
+      ts.transit
+      ts.should.initialized
+      ts.transit
+      ts.should.test
+      ts.transit
+      ts.should.testA
+      ts.transit
+      ts.should.test
+      ts.transit
+      ts.should.testB
+      ts.transit
+      ts.should.test
+      ts.transit
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.transit }
+    end
+  end
+
+  describe 'exception handling transition' do
+    it 'should handle an exception' do
+      ts = TestExceptionTransition.new
+      ts.current_state.should.nil
+      ts.transit
+      ts.should.initialized
+      ts.transit
+      ts.should.ehandler
+      ts.transit
+      ts.should.terminated
+      should.raise(Agent::TransitionError) { ts.transit }
+    end
+  end
+end

data/test/agent/spec_broker.rb

@@ -0,0 +1,36 @@
+require_relative '../test-util'
+
+describe "Pione::Agent::Broker" do
+  before do
+    DRb.start_service
+    @broker_front = Pione::Front::BrokerFront.new(self)
+    @ts_server1 = TupleSpaceServer.new(task_worker_resource: 1)
+    @ts_server2 = TupleSpaceServer.new(task_worker_resource: 2)
+    @ts_server3 = TupleSpaceServer.new(task_worker_resource: 3)
+    @broker1 = Agent[:broker].new(task_worker_resource: 5)
+  end
+
+  after do
+    @broker_front.terminate
+  end
+
+  it "should run workers" do
+    @broker1.start
+    @broker1.task_workers.size.should == 0
+    @broker1.add_tuple_space_server @ts_server1
+    sleep 2
+    @broker1.task_workers.size.should == 5
+    @ts_server1.current_task_worker_size.should == 5
+    @broker1.add_tuple_space_server @ts_server2
+    sleep 2
+    @broker1.task_workers.size.should == 5
+    @ts_server1.current_task_worker_size.should == 2
+    @ts_server2.current_task_worker_size.should == 3
+    @broker1.add_tuple_space_server @ts_server3
+    sleep 2
+    @broker1.task_workers.size.should == 5
+    @ts_server1.current_task_worker_size.should == 1
+    @ts_server2.current_task_worker_size.should == 2
+    @ts_server3.current_task_worker_size.should == 2
+  end
+end

data/test/agent/spec_command-listener.rb

@@ -0,0 +1,30 @@
+require_relative '../test-util'
+
+class TestCommandListener < Pione::Agent::TupleSpaceClient
+  define_state :test
+
+  define_state_transition :initialized => :test
+  define_state_transition :test => :test
+
+  def transit_to_test
+    sleep 0.1
+  end
+end
+
+describe 'Pione::Agent::CommandListener' do
+  before do
+    create_remote_tuple_space_server
+  end
+
+  after do
+    DRb.stop_service
+  end
+
+  it 'should terminate' do
+    agent = TestCommandListener.start(tuple_space_server)
+    agent.wait_till(:test)
+    write(Tuple[:command].new("terminate"))
+    agent.wait_till(:terminated)
+    agent.should.be.terminated
+  end
+end

data/test/agent/spec_input-generator.rb

@@ -0,0 +1,123 @@
+require_relative '../test-util'
+
+describe "Pione::Agent::InputGenerator" do
+  before do
+    @orig = Global.input_generator_stream_check_timespan
+    DRb.start_service
+    create_remote_tuple_space_server
+    Global.input_generator_stream_check_timespan = 0.1
+  end
+
+  after do
+    DRb.stop_service
+    Global.input_generator_stream_check_timespan = @orig
+  end
+
+  describe 'dir generator' do
+    it 'should generate inputs from files in the directory' do
+      Dir.mktmpdir do |dir|
+        # make local uri
+        uri = URI.parse("local:%s" % dir).as_directory
+
+        # create input files
+        Resource[uri + "1.a"].create("11")
+        Resource[uri + "2.b"].create("22")
+        Resource[uri + "3.c"].create("33")
+
+        # make generator and wait to finish it's job
+        generator = Agent[:input_generator].start_by_dir(tuple_space_server, uri)
+        generator.wait_till(:terminated)
+
+        # check exceptions
+        check_exceptions
+
+        # check data
+        count_tuple(Tuple[:data].any).should == 3
+        should.not.raise(Rinda::RequestExpiredError) do
+          (1..3).each do |i|
+            tuple = Tuple[:data].new(name: "#{i}.#{(i+96).chr}", domain: "input")
+            data = read(tuple, 0)
+            should.not.raise(Resource::NotFound) do
+              Resource[URI(data.uri)].read.should == "#{i}#{i}"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'with stream generator' do
+    it 'should stream' do
+      Dir.mktmpdir do |dir|
+        # make local uri
+        uri = URI.parse("local:%s" % dir).as_directory
+
+        # create input files
+        Resource[uri + "1.a"].create("11")
+        Resource[uri + "2.b"].create("22")
+        Resource[uri + "3.c"].create("33")
+
+        # make generator and wait to finish it's job
+        generator = Agent[:input_generator].start_by_stream(tuple_space_server, uri)
+        generator.should.stream
+        generator.terminate
+      end
+    end
+
+    it 'should provide files in a directory by stream generator' do
+      Dir.mktmpdir do |dir|
+        ## initial inputs
+        # make local uri
+        uri = URI.parse("local:%s" % dir).as_directory
+
+        # create input files
+        Resource[uri + "1.a"].create("11")
+        Resource[uri + "2.b"].create("22")
+        Resource[uri + "3.c"].create("33")
+
+        # make generator and wait to finish it's job
+        generator = Agent[:input_generator].start_by_stream(tuple_space_server, uri)
+        generator.wait_till(:sleeping)
+
+        # check exceptions
+        check_exceptions
+
+        # check data
+        count_tuple(Tuple[:data].any).should == 3
+
+        ## an addtional input
+        # create additional files
+        Resource[uri + "4.d"].create("44")
+        sleep 0.2
+        generator.wait_till(:sleeping)
+
+        # check exceptions
+        check_exceptions
+
+        # check data
+        count_tuple(Tuple[:data].any).should == 4
+
+        # create additional files
+        Resource[uri + "5.e"].create("55")
+        sleep 0.2
+        generator.wait_till(:sleeping)
+
+        # check exceptions
+        check_exceptions
+
+        # check data
+        count_tuple(Tuple[:data].any).should == 5
+
+        should.not.raise(Rinda::RequestExpiredError) do
+          (1..3).each do |i|
+            tuple = Tuple[:data].new(name: "#{i}.#{(i+96).chr}", domain: "input")
+            data = read(tuple, 0)
+            should.not.raise(Resource::NotFound) do
+              Resource[URI(data.uri)].read.should == "#{i}#{i}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/agent/spec_logger.rb

@@ -0,0 +1,71 @@
+require_relative '../test-util'
+
+describe "Pione::Agent::Logger" do
+  before do
+    DRb.start_service
+    create_remote_tuple_space_server
+    @buf = StringIO.new("", "w+")
+    @logger = Agent[:logger].start(tuple_space_server, @buf)
+    @msg1 = "e07860f6-18f0-4c1a-8a5a-7d9f3353c83f"
+    @msg2 = "c8fa705d-fc30-42fa-a05f-a2493717dc39"
+  end
+
+  after do
+    DRb.stop_service
+  end
+
+  it "should say hello and bye" do
+    # say hello
+    @logger.wait_till(:take)
+    read_all(Tuple[:agent].any).should.include @logger.to_agent_tuple
+    # say bye
+    @logger.terminate
+    @logger.wait_till(:terminated)
+    read_all(Tuple[:agent].any).should.not.include @logger.to_agent_tuple
+  end
+
+  it "should log messages" do
+    # send log messages
+    write(Tuple[:log].new(Log.new{|msg| msg.add_record(:test, :key, @msg1)}))
+    write(Tuple[:log].new(Log.new{|msg| msg.add_record(:test, :key, @msg2)}))
+    @logger.wait_till(:take)
+    @logger.wait_to_clear_logs
+    # check messages
+    @buf.string.should.include @msg1
+    @buf.string.should.include @msg2
+  end
+
+  it "should terminate logging by terminate message" do
+    # terminate
+    @logger.wait_till(:take)
+    @logger.wait_to_clear_logs
+    @logger.terminate
+    @logger.wait_till(:terminated)
+    # write a message after logger was terminated
+    write(Tuple[:log].new(Log.new{|msg| msg.add_record(:test, :key, @msg1)}))
+    sleep 0.1 # wait a little...
+    @buf.string.should.not.include @msg1
+  end
+
+  it "should terminate logging by exceptions" do
+    # write a message
+    write(Tuple[:log].new(Log.new{|msg| msg.add_record(:test, :key, @msg1)}))
+    @logger.wait_to_clear_logs
+    # remote server is shoutdown
+    remote_drb_server.stop_service
+    DRb.stop_service
+    DRb.remove_server(remote_drb_server)
+    sleep 1
+
+    # write a message after remote server was down
+    Util.ignore_exception do
+      write(Tuple[:log].new(Log.new{|msg| msg.add_record(:test, :key, @msg2)}))
+    end
+    @logger.wait_till(:terminated)
+    # logger is terminated
+    @logger.should.be.terminated
+    # check log content
+    @buf.string.should.include @msg1
+    @buf.string.should.not.include @msg2
+  end
+end

data/test/agent/spec_rule-provider.rb

@@ -0,0 +1,65 @@
+require_relative '../test-util'
+require 'pione/agent/rule-provider'
+
+describe "Agent::RuleProvider" do
+  before do
+    create_remote_tuple_space_server
+    @provider = Agent[:rule_provider].start(tuple_space_server)
+    doc = Document.parse(<<-DOCUMENT)
+      Rule abc
+        input  '*.a'
+        output '{$INPUT[1].MATCH[1]}.b'
+      Action---
+        content "echo 'abc' > {$OUTPUT[1]}"
+      ---End
+
+      Rule xyz
+        input  '*.a'
+        output '{$INPUT[1].MATCH[1]}.b'
+      Action---
+        content "echo 'xyz' > {$OUTPUT[1]}"
+      ---End
+    DOCUMENT
+    @rule_abc = doc['&main:abc']
+    @rule_xyz = doc['&main:xyz']
+    @provider.read_document(doc)
+  end
+
+  it "should provide known rule information" do
+    # wait provider's setup
+    @provider.wait_till(:request_waiting)
+    # write a request
+    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&main:abc'))
+    check_exceptions
+    # check rule tuple
+    should.not.raise(Rinda::RequestExpiredError) do
+      rule = read(Tuple[:rule].new(rule_path: '&main:abc'))
+      rule.status.should == :known
+      rule.content.class.should == Rule::ActionRule
+      rule.content.should == @rule_abc
+    end
+    # write another request
+    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: '&main:xyz'))
+    check_exceptions
+    # check rule tuple
+    should.not.raise(Rinda::RequestExpiredError) do
+      rule = read(Tuple[:rule].new(rule_path: '&main:xyz'))
+      rule.status.should == :known
+      rule.content.class.should == Rule::ActionRule
+      rule.content.should == @rule_xyz
+    end
+  end
+
+  it "should provide unknown rule information" do
+    # wait provider's setup
+    @provider.wait_till(:request_waiting)
+    # write a request
+    write_and_wait_to_be_taken(Tuple[:request_rule].new(rule_path: "aaa"))
+    check_exceptions
+    # check unknown rule tuple
+    should.not.raise(Rinda::RequestExpiredError) do
+      rule = read(Tuple[:rule].new(rule_path: "aaa"))
+      rule.status.should == :unknown
+    end
+  end
+end