pione 0.2.2 → 0.3.0

data/.gitignore

@@ -1,5 +1,6 @@
 *~
 \#*
+.\#*
 
 .bundle
 .EosLog

data/.simplecov

@@ -1,5 +1,6 @@
 require 'coveralls'
 Coveralls.wear!
+SimpleCov.command_name 'bacon'
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter

data/History.txt

@@ -1,5 +1,14 @@
 # History
 
+## 0.3.0(2013/10/20)
+
+* Improved multi-inheritance package system.
+* Added package database.
+* Added package cache system.
+* Improved language parser and interpreter.
+* Refactored many codes.
+* Improved test coverage.
+
 ## 0.2.2(2013/07/02)
 
 * Enabled to load remote package.

data/Rakefile

@@ -1,8 +1,6 @@
 require "bundler/gem_tasks"
 require "pione"
 
-$stand_alone = "bin/pione-client --stand-aline"
-
 desc 'generate HTML API documentation'
 task 'html' do
   sh 'bundle exec yard doc -o html --hide-void-return --no-api --private'
@@ -13,77 +11,9 @@ task 'html:undoc' do
   sh 'bundle exec yard stats --list-undoc --no-api --private --compact'
 end
 
-desc 'count characters in input direcotry'
-task 'example:CountChar' do
-  sh "ruby -I lib %s -i %s %s" % [
-    $stand_alone,
-    "example/CountChar/text",
-    "example/CountChar/CountChar.pione"
-  ]
-end
-
-desc 'count characters in input direcotry with debug mode'
-task 'example:CountChar:debug_mode' do
-  sh "ruby -I lib %s -i %s -d %s" % [
-    $stand_alone,
-    "example/CountChar/text",
-    "example/CountChar/CountChar.pione"
-  ]
-end
-
-desc 'count characters by stream'
-task 'example:CountCharStream' do
-  sh "ruby -I lib %s -s %s" % [
-    $stand_alone,
-    "example/CountChar/CountCharStream.pione"
-  ]
-end
-
-desc 'count characters by stream with debug mode'
-task 'example:CountCharStream:debug_mode' do
-  sh "ruby -I lib %s -s -d %s" % [
-    $stand_alone,
-    "example/CountChar/CountCharStream.pione"
-  ]
-end
-
-desc 'sum numbers in file'
-task 'example:Sum' do
-  sh "ruby -I lib %s -i %s %s" % [
-    $stand_alone,
-    "example/Sum/input",
-    "example/Sum/Sum.pione"
-  ]
-end
-
-desc 'sum numbers in file with debug mode'
-task 'example:Sum:debug_mode' do
-  sh "ruby -I lib %s -i %s -d %s" % [
-    $stand_alone,
-    "example/Sum/input",
-    "example/Sum/Sum.pione"
-  ]
-end
-
-desc 'fib calc'
-task 'example:Fib' do
-  sh "ruby -I lib %s %s" % [
-    $stand_alone,
-    "example/Fib/Fib.pione",
-  ]
-end
-
-desc 'fib calc with debug mode'
-task 'example:Fib:debug' do
-  sh "ruby -I lib %s -d %s" % [
-    $stand_alone,
-    "example/Fib/Fib.pione"
-  ]
-end
-
 desc 'execute basic tests'
 task 'test' do
-  sh "bundle exec bacon -I lib -rsimplecov test/parser/spec_*.rb test/transformer/spec_*.rb test/model/spec_*.rb test/log/spec_*.rb test/location/spec_*.rb test/component/spec_*.rb test/util/spec_*.rb test/tuple/spec_*.rb test/uri-scheme/spec_*.rb test/agent/spec_logger.rb test/agent/spec_messenger.rb test/agent/spec_rule-provider.rb test/rule-handler/spec_action-handler.rb test/rule-handler/spec_flow-handler.rb test/rule-handler/spec_update-criteria.rb test/tuple-space/spec_data-finder.rb test/system/spec_*.rb test/command/spec_*.rb"
+  sh "bundle exec bacon -rsimplecov -a"
 end
 
 desc 'parser test'

data/example/Fib/Fib.pione

@@ -1,7 +1,8 @@
-@ author :: "Keita Yamaguchi"
-@ "Fib.pione calculates the value of Fibonacci number."
+.@ PackageName :: "Fib"
+.@ Editor :: "keita.yamaguchi@gmail.com"
+.@ "Fib.pione calculates the value of Fibonacci number."
 
-param ($NUM := 3)
+param $NUM := 3
 
 Rule Main
   output 'result.txt'
@@ -11,21 +12,21 @@ Flow
 End
 
 Rule Fib0
-  @ "the value of fib(0) is 0"
+  .@ "the value of fib(0) is 0"
   output 'fib0.txt'
 Action
   echo -n '0' > fib0.txt
 End
 
 Rule Fib1
-  @ "the value of fib(1) is 1"
+  .@ "the value of fib(1) is 1"
   output 'fib1.txt'
 Action
   echo -n '1' > fib1.txt
 End
 
 Rule Fib
-  @ "fib(n) is fib(0), fib(1), or fib(n-1) + fib(n-2)"
+  .@ "fib(n) is fib(0), fib(1), or fib(n-1) + fib(n-2)"
   output 'fib{$N}.txt'
   param $N
 Flow
@@ -44,7 +45,7 @@ Flow
 End
 
 Rule Calc
-  @ "calculate the value of fib(n-1) + fib(n-2)"
+  .@ "calculate the value of fib(n-1) + fib(n-2)"
   input 'fib{$P1}.txt'
   input 'fib{$P2}.txt'
   output 'fib{$N}.txt'
@@ -56,7 +57,7 @@ Action
 End
 
 Rule Result
-  @ "make the result"
+  .@ "make the result"
   input 'fib*.txt'
   output 'result.txt'
 Action

data/example/HelloWorld/HelloWorld.pione

@@ -1,3 +1,5 @@
+.@ PackageName :: "HelloWorld"
+
 Rule Main
   output 'message.txt'
 Action

data/example/HelloWorld/pione-package.json

@@ -0,0 +1,15 @@
+{
+  "PackageName": "HelloWorld",
+  "Parents": [
+
+  ],
+  "Documents": [
+    "HelloWorld.pione"
+  ],
+  "Scenarios": [
+    "scenario"
+  ],
+  "Bins": [
+
+  ]
+}

data/example/HelloWorld/scenario/Scenario.pione

@@ -0,0 +1,2 @@
+.@ ScenarioName :: "HelloWorld"
+.@ ParamSet :: "{}"

data/example/HelloWorld/scenario/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "HelloWorld",
+  "ParamSet": "{}",
+  "Inputs": [
+
+  ],
+  "Outputs": [
+    "output/message.txt"
+  ]
+}

data/example/SerialProcessing/SerialProcessing.pione

@@ -1,3 +1,5 @@
+.@ PackageName :: "SerialProcessing"
+
 Rule Main
   output '*.a'.all
   output '*.b'.all

data/example/SerialProcessing/pione-package.json

@@ -0,0 +1,15 @@
+{
+  "PackageName": "SerialProcessing",
+  "Parents": [
+
+  ],
+  "Documents": [
+    "SerialProcessing.pione"
+  ],
+  "Scenarios": [
+    "scenario"
+  ],
+  "Bins": [
+
+  ]
+}

data/example/SerialProcessing/scenario/Scenario.pione

@@ -0,0 +1 @@
+.@ ScenarioName :: "SerialProcessing Test"

data/example/SerialProcessing/scenario/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "SerialProcessing Test",
+  "ParamSet": null,
+  "Inputs": [
+
+  ],
+  "Outputs": [
+
+  ]
+}

data/lib/pione.rb

@@ -1,9 +1,11 @@
+Thread.abort_on_exception = true
+
 #
 # load libraries
 #
 
 # bundler
-require 'bundler/setup'
+require 'bundler/setup' rescue nil
 
 # standard
 require 'set'
@@ -31,6 +33,7 @@ require 'logger'
 require 'ostruct'
 require 'net/ftp'
 require 'net/http'
+require 'fiber'
 
 # gems
 require 'uuidtools'
@@ -49,59 +52,49 @@ require 'pione/patch/em-ftpd-patch' # patch
 require 'sys/cpu'
 require 'structx'
 require 'syslog-logger'
-require 'zipruby'
+require 'zip'
+require 'zip/filesystem'
 require 'retriable'
 require 'childprocess'
+require 'lettercase/core_ext'
 
+# configuration for childprcess
 ChildProcess.posix_spawn = true
 
 #
 # load pione
 #
 
-require 'pione/version'
-require 'pione/util'
-require 'pione/patch'
-require 'pione/uri-scheme'
-require 'pione/location'
-require 'pione/log'
-require 'pione/system'
-
-Pione.module_exec {const_set(:PioneObject, Pione::System::PioneObject)}
-Pione.module_exec {const_set(:Global, Pione::System::Global)}
-
-require 'pione/relay'
-require 'pione/tuple-space'
-require 'pione/rule-handler.rb'
-require 'pione/model'
-require 'pione/component'
-require 'pione/tuple'
-require 'pione/parser'
-require 'pione/transformer'
-require 'pione/agent'
-require 'pione/front'
-require 'pione/command'
+require 'pione/version'     # PIONE version information
+require 'pione/util'        # various helper functions
+require 'pione/patch'       # patches for libraries
+require 'pione/location'    # location system for data and package
+require 'pione/log'         # log and format
+require 'pione/global'      # global variable manager
+require 'pione/system'      # PIONE system functions
+require 'pione/relay'       # relay connection
+require 'pione/package'     # package system
+require 'pione/lang'        # PIONE languge
+require 'pione/tuple-space' # tuple space functions
+require 'pione/rule-engine' # rule processing behaviors
+require 'pione/agent'       # agent system
+require 'pione/front'       # command front interface
+require 'pione/command'     # command definitions
 
 #
 # other settings
 #
+
 module Pione
-  include System
+  # expand name spaces
   include Relay
-  include Util
   include Log::MessageLog
-  include Model
   include TupleSpace
-  include Parser
-  include Transformer
 
   extend Util::Evaluatable
-
-  module_function :debug_mode
-  module_function :debug_mode=
-  module_function :debug_mode?
 end
 
-include Pione
-Thread.abort_on_exception = true
+# initialize PIONE system
 Pione::System::Init.new.init
+
+# now, we are enable to start processing!

data/lib/pione/agent.rb

@@ -3,15 +3,15 @@ module Pione
   module Agent; end
 end
 
+require 'pione/agent/agent-exception'
 require 'pione/agent/basic-agent'
 require 'pione/agent/tuple-space-client'
-require 'pione/agent/command-listener'
+require 'pione/agent/job-terminator'
 require 'pione/agent/task-worker'
 require 'pione/agent/input-generator'
-require 'pione/agent/rule-provider'
 require 'pione/agent/logger'
 require 'pione/agent/broker'
 require 'pione/agent/process-manager'
-require 'pione/agent/trivial-routine-worker'
-require 'pione/agent/tuple-space-server-client-life-checker'
 require 'pione/agent/messenger'
+require 'pione/agent/tuple-space-provider'
+require 'pione/agent/tuple-space-receiver'

data/lib/pione/agent/agent-exception.rb

@@ -0,0 +1,52 @@
+module Pione
+  module Agent
+    # TerminationError is raised when the agent reaches trasition termination.
+    class TerminationError < StandardError
+      def initialize(agent, states)
+        @agent = agent
+        @states = states
+      end
+
+      def message
+        "agent %s has reached termination([%s])" % [@agent, @states.map{|s| s.to_s}.join(", ")]
+      end
+    end
+
+    # TimeoutError is raised when the agent is timeouted.
+    class TimeoutError < StandardError
+      attr_reader :agent        # agent timeouted
+      attr_reader :agent_states # agent states
+      attr_reader :sec          # timeout second
+
+      def initialize(agent, states, sec)
+        @agent = agent
+        @states = states
+        @sec = sec
+      end
+
+      def message
+        sec = @sec ? "(%s sec)" % @sec : ""
+        "%s timeouted %s at state [%s]" % [@agent, sec, @states.map{|s| s.to_s}.join(", ")]
+      end
+    end
+
+    # ConnectionError is raised when agent is disconnected from other process unexpectedly.
+    class ConnectionError < StandardError; end
+
+    # TupleSpaceError is raised when tuple space is something bad.
+    class TupleSpaceError < StandardError; end
+
+    # Restart is raised when the agent should restart activity.
+    class Restart < StandardError; end
+
+    class UnknownInputGeneratorMethod
+      def initialize(name)
+        @name = name
+      end
+
+      def message
+        "input generator method \"%s\" is unknown" % @name
+      end
+    end
+  end
+end

data/lib/pione/agent/basic-agent.rb

@@ -1,330 +1,337 @@
 module Pione
   module Agent
-    # @api private
     @table = Hash.new
 
     class << self
       # Returns a class corresponding to the agent type.
-      # @param [Symbol] type
-      #   agent type
-      # @return [Pione::Agent::BasicAgent]
-      #   agent class
       def [](type)
         @table[type]
       end
 
       # Sets an agent of the system.
-      # @param [Pione::Agent::BasicAgent] klass
-      #   agent class
-      # @return [void]
       def set_agent(klass)
         @table[klass.agent_type] = klass
       end
     end
 
-    # Aborting is an exception for aborting agents.
-    class Aborting < Exception; end
-
-    # TransitionError happens when
-    class TransitionError < StandardError; end
-
-    # TimeoutStateWaiting happens when not reached expected in time.
-    class TimeoutStateWaiting < StandardError
-      # expected status
-      attr_reader :expected
-
-      # current status
-      attr_reader :current
-
-      # Creates an exception.
-      #
-      # @param [Symbol] expected
-      #   expected state
-      # @param [Symbol] current
-      #   current state
-      def initialize(expected, current)
-        @expected_state = expected
-        @current_state = current
-      end
-
-      # @private
-      def message
-        msg = "expected state is '%s' but current state is '%s'"
-        msg % [@expected_state, @current_state]
-      end
-    end
-
     # StateTransitionSingleMethod provides state transition singleton methods.
     module StateTransitionSingletonMethod
-      # Sets pre-defined states when the module is extended by others.
-      # @api private
-      def self.extended(mod)
-        mod.define_state :initialized
-        mod.define_state :terminated
-        mod.define_state :error
-
-        mod.define_state_transition :error => :terminated
-      end
+      # Defines a new transition.
+      def define_transition(name)
+        @transitions ||= []
+        unless @transitions.include?(name)
+          @transitions << name
 
-      # Defines new agent state.
-      # @param [Symbol] name
-      #   state name
-      # @return [void]
-      def define_state(name)
-        @states ||= []
-        unless @states.include?(name)
-          @states << name
-
-          # define an instance method for checking current state
-          define_method("#{name}?") do
-            @__current_state__ == name
-          end
-
-          # define an instance method for transition
+          # define empty transition method
           unless method_defined?("transit_to_#{name}")
-            define_method("transit_to_#{name}"){}
+            define_method("transit_to_#{name}") {}
           end
         end
       end
 
-      # Returns all states.
-      # @return [Array<Symbol>]
-      #   state name list
-      def states
-        @states
+      # Returns transition chain table.
+      def transition_chain
+        @transition_chain ||= {nil => :init}
       end
 
-      # Returns state transition table.
-      # @return [Hash{Symbol => Symbol}]
-      #   state transition table
-      def state_transition_table
-        @__state_transition_table__ ||= {nil => :initialized}
-      end
-
-      # Defines a state transition.
-      # @param [Hash{Symbol => Symbol}] data
-      #   state transition as the key value pair of from-state and to-state
-      # @return [void]
-      def define_state_transition(data)
-        table = state_transition_table
-        table.merge!(data)
+      # Define a transition chain.
+      def chain(data)
+        data.each do |k, v|
+          raise ArgumentError.new(k) if not(@transitions.include?(k))
+          if not(v.is_a?(Proc))
+            (v.is_a?(Array) ? v : [v]).each do |_v|
+              raise ArgumentError.new(_v) if not(@transitions.include?(_v))
+            end
+          end
+        end
+        transition_chain.merge!(data)
       end
 
-      # Returns exception handler table.
-      # @return [Hash{Symbol => Symbol}]
-      #   exception handler table
-      def exception_handler_table
-        @__exception_handler_table__ ||= {}
+      # Return exception handler table.
+      def exception_handler
+        @exception_handler ||= {}
       end
 
-      # Defines a state for handling exceptions.
-      # @param [Hash{Exception => Symbol}] data
-      #   exception handler definition
-      # @return [void]
-      # @example
-      #   define_exception_handler(StopIetration => :end_process)
+      # Define a transition for handling exceptions.
       def define_exception_handler(data)
-        table = exception_handler_table
-        table.merge!(data)
+        exception_handler.merge!(data)
       end
 
       # Creates an agent and starts it.
-      # @param [Array<Object>] args
-      #   arguments of state change
       def start(*args, &b)
-        agent = new(*args)
-        b.call(self) if block_given?
-        agent.start
-        return agent
+        agent = new(*args, &b)
+        return agent.start
+      end
+    end
+
+    # BasicAgent is a super class for all PIONE agents.
+    class BasicAgent < PioneObject
+      include DRbUndumped
+      extend StateTransitionSingletonMethod
+
+      #
+      # variables
+      #
+
+      @transitions = Array.new
+      @transition_chain = Hash.new
+      @exception_handler = Hash.new
+
+      #
+      # default transitions
+      #
+
+      define_transition :init
+      define_transition :terminate
+
+      #
+      # class methods
+      #
+
+      def self.inherited(subclass)
+        subclass.instance_variable_set(:@transitions, @transitions.clone)
+        subclass.instance_variable_set(:@transition_chain, @transition_chain.clone)
+        subclass.instance_variable_set(:@exception_handler, @exception_handler.clone)
       end
 
-      # Returns list of exceptions
-      # @return [Array<Exception>]
-      #   exceptions
-      def known_exceptions
-        exception_handler_table.keys
+      # Set the agent type.
+      def self.set_agent_type(agent_type, klass=nil)
+        @agent_type = agent_type
+        Agent.set_agent(klass) if klass
       end
-    end
 
-    # StateTransitionMethod provides state transition methods.
-    module StateTransitionMethod
-      # State transition thread.
-      attr_reader :running_thread
+      # Return the agent type.
+      def self.agent_type
+        @agent_type
+      end
+
+      #
+      # instance methods
+      #
 
-      attr_accessor :show_agent_status
+      forward :class, :agent_type
+      attr_reader :chain_threads # transition chain thread group
+
+      def initialize
+        @chain_threads = ThreadGroup.new
+
+        # for wait_until_before method
+        @__wait_until_before_mutex__ = Mutex.new
+        @__wait_until_before_cv__ = Hash.new {|h, k| h[k] = ConditionVariable.new}
+
+        # for wait_until_after method
+        @__wait_until_after_mutex__ = Mutex.new
+        @__wait_until_after_cv__ = Hash.new {|h, k| h[k] = ConditionVariable.new}
+      end
 
       # Start agent activity.
-      # @return the agent
       def start
-        raise TransitionError.new(current_state) if current_state == :terminated
+        unless @chain_threads.list.empty?
+          raise TerminationError.new(self, states)
+        end
 
+        # save current thread
         @__owner_thread__ = Thread.current
-        @__result__ = nil
-        @running_thread = Thread.new { start_running }
+
+        # start a new chain thread
+        @chain_threads.add(start_running(:init, [], AgentState.new, true))
+        @chain_threads.enclose
+
         return self
       end
 
-      # Return state of current agent.
-      # @return [Symbol]
-      #   state of current agent
-      def current_state
-        @__current_state__ ||= nil
-      end
+      # Fire the transtion with inputs.
+      def transit(transition, transition_inputs)
+        # wake up threads that wait by wait_until_before method
+        if @__wait_until_before_cv__.has_key?(transition)
+          @__wait_until_before_mutex__.synchronize do
+            @__wait_until_before_cv__[transition].broadcast
+          end
+        end
+
+        # mark current transition
+        Thread.current[:agent_state] =
+          AgentState.new(previous: Thread.current[:agent_state].previous, current: transition)
+
+        # call transition
+        result = call_transition_method(transition, transition_inputs)
+        result = result.nil? ? [] : result
+        result = result.is_a?(Array) ? result : [result]
+
+        # unmark current transition and mark previous transition
+        Thread.current[:agent_state] = AgentState.new(previous: transition, current: nil)
 
-      # Transits to the next state.
-      # @return [void]
-      def transit
-        # raise error if the current state is terminated
-        if current_state == :terminated
-          raise TransitionError.new(current_state)
+        # wake up threads that wait by wait_until_after method
+        if @__wait_until_after_cv__.has_key?(transition)
+          @__wait_until_after_mutex__.synchronize do
+            @__wait_until_after_cv__[transition].broadcast
+          end
         end
 
-        state_transition_table = self.class.state_transition_table
-        begin
-          next_state = get_next_state(state_transition_table[current_state])
-          set_current_state(next_state)
-          p next_state if @show_agent_status
-          @__result__ = call_transition_method(current_state, *@__result__)
-        rescue Aborting
-          raise
-        rescue Exception => e
-          if error_state = exception_handler(e)
-            # known exception : go error state
-            set_next_state(error_state)
-            @__result__ = [e]
+        return transition, result
+      rescue StandardError => e
+        # error handling
+        if error_transition = get_exception_handler(e)
+          raise unless error_transition.is_a?(Symbol)
+          return transit(error_transition, [e])
+        else
+          if @__owner_thread and @__owner_thread__.alive?
+            @__owner_thread__.raise e
           else
-            # unknown exception : raise it to owner thread
-            if @__owner_thread__.alive?
-              @__owner_thread__.raise e
-            else
-              raise e
-            end
+            raise e
           end
         end
       end
 
-      # Sleep till the agent becomes the state.
-      def wait_till(state, sec=5)
-        begin
-          timeout(sec) do
-            sleep 0.1 while not(current_state == state)
+      # Return agent states.
+      def states
+        @chain_threads.list.map {|th| th[:agent_state]}
+      end
+
+      # Sleep until before the agent fires the transition.
+      def wait_until_before(transition, sec=10)
+        timeout(sec) do
+          @__wait_until_before_mutex__.synchronize do
+            @__wait_until_before_cv__[transition].wait(@__wait_until_before_mutex__)
           end
-        rescue Timeout::Error
-          raise TimeoutStateWaiting.new(state, current_state)
         end
+      rescue Timeout::Error
+        raise TimeoutError.new(self, @chain_threads.list.map{|th| th[:agent_state]}, sec)
       end
 
-      # Terminate to transit.
-      def terminate
-        begin
-          res = call_transition_method(:terminated)
-        rescue DRb::DRbConnError, DRb::ReplyReaderThreadError => e
-          Util::ErrorReport.warn("raised a connection error when we terminated", self, e, __FILE__, __LINE__)
+      def wait_until(transition, sec=10)
+        unless @chain_threads.list.any? {|th| th[:agent_state] and th[:agent_state].current == transition}
+          wait_until_before(transition, sec)
         end
-        # set agent state
-        set_current_state(:terminated)
-        return res
       end
 
-      private
-
-      # Set new agent's state.
-      def set_current_state(state)
-        @__current_state__ = state
+      # Sleep until after the agent fires the transition.
+      def wait_until_after(transition, sec=10)
+        timeout(sec) do
+          @__wait_until_after_mutex__.synchronize do
+            @__wait_until_after_cv__[transition].wait(@__wait_until_after_mutex__)
+          end
+        end
+      rescue Timeout::Error => e
+        raise TimeoutError.new(self, @chain_threads.list.map{|th| th[:agent_state]}, sec)
       end
 
-      # Return a transition method of the state.
-      def transition_method(state)
-        method("transit_to_#{state}")
+      # Sleep caller thread until the agent is terminated.
+      def wait_until_terminated(sec=10)
+        unless terminated?
+          wait_until_after(:terminate, sec)
+          @chain_threads.list.each {|thread| thread.join}
+        end
       end
 
-      # Call a transition method.
-      def call_transition_method(state, *args)
-        method = transition_method(state)
-        arity = method.arity
-        _args = args[0...arity]
-        method.call(*_args)
-      end
+      # Terminate the agent activity.
+      def terminate
+        state = nil
 
-      # Returns the handling state for the exception.
-      def exception_handler(e)
-        handler = nil
-        table = self.class.exception_handler_table
-        e.class.ancestors.each do |mod|
-          if table.has_key?(mod)
-            handler = table[mod]
-            break
+        Thread.new {
+
+          # kill all chain threads
+          @chain_threads.list.each do |thread|
+            state = thread[:agent_state] # save last state
+            unless thread == Thread.current
+              thread.kill
+              thread.join
+            end
           end
-        end
-        return handler
-      end
 
-      # Start to transit agent's state.
-      # For example, logger should transit initialized, logging, logging, ...
-      def start_running
-        begin
-          while not(terminated?)
-            transit
+          # fire "terminate" transtion
+          begin
+            Thread.current[:agent_state] = state || AgentState.new
+            transit(:terminate, [])
+          rescue DRb::DRbConnError, DRbPatch::ReplyReaderError => e
+            Log::Debug.warn("raised a connection error when we terminated", self, e)
           end
-        rescue Aborting
-          # do nothing, agent will be dead...
-        end
+        }.join
       end
 
-      def set_next_state(state)
-        @__next_state__ = state
+      # Return true if the agent has been terminated.
+      def terminated?
+        return (@chain_threads.list.empty? and @chain_threads.enclosed?)
       end
 
-      def get_next_state(state)
-        if @__next_state__
-          next_state = @__next_state__
-          @__next_state__ = nil
-          return next_state
-        else
-          next_state = state.kind_of?(Proc) ? state.call(self, @__result__) : state
-          unless next_state
-            msg = "unknown state transition: #{current_state} -> #{state} at #{self}"
-            raise ScriptError.new(msg)
+      private
+
+      # Start transition chain.
+      def start_running(transition, result, state, free)
+        thread = free ? Util::FreeThreadGenerator.method(:generate) : Thread.method(:new)
+        thread.call do
+          begin
+            Thread.current[:agent_state] = state
+            while true
+              # fire the transition
+              # NOTE: transition name is maybe changed by the result of firing
+              _transition, result, count = transit(transition, result)
+              state = Thread.current[:agent_state]
+
+              begin
+                # go next transition
+                next_transitions = get_next_transitions(_transition, result)
+                transition, *branches = next_transitions
+                # handle transition branches
+                branches.each {|t| start_running(t, result, state, false)}
+              rescue TerminationError
+                break # end loop after terminate transition
+              end
+            end
+          rescue Exception => e
+            # throw the exception to command's runnning thread
+            if Global.command and Global.command.running_thread and Global.command.running_thread.alive?
+              Global.command.running_thread.raise e
+            else
+              raise e
+            end
           end
-          return next_state
         end
       end
 
-      # Abort the agent.
-      def abort
-        if @running_thread.alive?
-          # raise Aborting exception
-          @running_thread.raise Aborting
-          # wait to stop the thread
-          @running_thread.join
-        end if @running_thread
+      # Call the transition method.
+      def call_transition_method(transition, args)
+        method = method("transit_to_#{transition}")
+        method.call(*args[0,method.arity])
       end
-    end
 
-    # BasicAgent is a super class for PIONE agents.
-    class BasicAgent < PioneObject
-      include DRbUndumped
-      extend StateTransitionSingletonMethod
-      include StateTransitionMethod
+      # Get transtion for the exception.
+      def get_exception_handler(e)
+        table = self.class.exception_handler
+        e.class.ancestors.each do |mod|
+          return table[mod] if table.has_key?(mod)
+        end
+      end
 
-      def self.inherited(subclass)
-        states.each {|state| subclass.define_state state }
-        define_state_transition(state_transition_table)
+      # Get next transitions based on transition chain table with previous transition result.
+      def get_next_transitions(transition, result)
+        next_transitions = self.class.transition_chain[transition]
+        if next_transitions.is_a?(Proc)
+          next_transitions = next_transitions.call(self, *result)
+        end
+        if next_transitions.nil? or (next_transitions == [])
+          raise TerminationError.new(self, states)
+        end
+        return next_transitions
       end
+    end
 
-      # Set the agent type.
-      def self.set_agent_type(agent_type)
-        @agent_type = agent_type
+    # AgentState represents a state of agent. The state is a pair of previous
+    # transiton and current transition.
+    class AgentState < StructX
+      member :previous
+      member :current
+
+      def previous?(state)
+        previous == state
       end
 
-      # Return the agent type.
-      def self.agent_type
-        @agent_type
+      def current?(state)
+        current == state
       end
 
-      # Return agent type of the object.
-      def agent_type
-        self.class.agent_type
+      def to_s
+        "<%s=>%s>" % [previous, current]
       end
     end
   end