pione 0.2.2 → 0.3.0

data/lib/pione/agent/tuple-space-client.rb

@@ -11,40 +11,26 @@ module Pione
 
       # Send a hello message to the tuple space server.
       def hello
-        write(to_agent_tuple)
+        write(TupleSpace::AgentTuple.new(agent_type: agent_type, uuid: uuid))
       end
 
       # Send a bye message to the tuple space server.
       def bye
         Util.ignore_exception do
-          write(to_bye_tuple)
+          take!(TupleSpace::AgentTuple.new(agent_type: agent_type, uuid: uuid))
         end
       end
 
-      # Makes the agent tuple.
-      # @return [Tuple::Agent]
-      #   the agent tuple
-      def to_agent_tuple
-        Tuple[:agent].new(agent_type: agent_type, uuid: uuid)
-      end
-
-      # Makes the bye tuple.
-      # @return [Tuple::Bye]
-      #   the bye tuple
-      def to_bye_tuple
-        Tuple[:bye].new(agent_type: agent_type, uuid: uuid)
-      end
-
       # Notify the agent happened a exception.
       def notify_exception(e)
         # ignore exception because the exception caused tuple server is down...
         Util.ignore_exception do
-          write(Tuple[:exception].new(uuid, agent_type, e))
+          write(TupleSpace::ExceptionTuple.new(uuid, agent_type, e))
         end
       end
 
       def base_location
-        read(Tuple[:base_location].any).location
+        read(TupleSpace::BaseLocationTuple.any).location
       end
 
       # Protected take.
@@ -81,40 +67,31 @@ module Pione
     end
 
     class TupleSpaceClient < BasicAgent
-      include TupleSpaceServerInterface
+      include TupleSpace::TupleSpaceInterface
       include TupleSpaceClientOperation
 
       # Initialize agent's state.
-      def initialize(tuple_space_server)
+      def initialize(tuple_space)
         super()
-        set_tuple_space_server(tuple_space_server)
+        set_tuple_space(tuple_space)
       end
 
-      def start
-        super()
-        return self
-      end
+      #
+      # transitions
+      #
 
-      # State initialized.
-      def transit_to_initialized
+      def transit_to_init
         hello
       end
 
-      # State terminated
-      def transit_to_terminated
+      def transit_to_terminate
         Util.ignore_exception { bye }
         cancel_current_tuple_entry
       end
 
-      # State error
-      def transit_to_error(e)
-        if e
-          $stderr.puts e
-          $stderr.puts e.backtrace
-        end
-        notify_exception(e)
-        terminate
-      end
+      #
+      # helper methods
+      #
 
       # Redefine hello method with logging.
       def hello
@@ -138,7 +115,7 @@ module Pione
 
       # Override call transition method with logging.
       def call_transition_method(*args)
-        unless [:logger, :command_listener, :messenger].include?(agent_type)
+        unless [:logger, :job_terminator, :messenger].include?(agent_type)
           record = Log::AgentActivityProcessRecord.new.tap do |rec|
             rec.agent_type = agent_type
             rec.agent_uuid = uuid

data/lib/pione/agent/tuple-space-provider.rb

@@ -0,0 +1,66 @@
+module Pione
+  module Agent
+    # TupleSpaceProvider is an agent that provides tuple space.
+    class TupleSpaceProvider < BasicAgent
+      set_agent_type :tuple_space_provider, self
+
+      #
+      # instance methods
+      #
+
+      def initialize(front)
+        super()
+        @front = front
+        @reference = Marshal.dump(/druby:\/\/(.*):(\d+)/.match(@front.uri)[2].to_i)
+      end
+
+      #
+      # agent activities
+      #
+
+      define_transition :send_packet
+      define_transition :sleep
+
+      chain :init => :send_packet
+      chain :send_packet => :sleep
+      chain :sleep => :send_packet
+
+      #
+      # transitions
+      #
+
+      def transit_to_send_packet
+        send_packet
+      end
+
+      def transit_to_sleep
+        sleep 5
+      end
+
+      #
+      # helper methods
+      #
+
+      # Send presence notification packets to tuple space receivers.
+      def send_packet
+        # open a UDP socket
+        socket = UDPSocket.open
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+
+        # send broadcast packets
+        Global.presence_notification_addresses.each do |address|
+          begin
+            Log::Debug.presence_notification do
+              "provider sends presence notification packet from %s to %s" % [@front.uri, address, Time.now]
+            end
+            socket.send(@reference, 0, address.host, address.port)
+          rescue => e
+            Log::SystemLog.warn("tuple space provider agent failed to send a packet: %s" % e.message)
+          end
+        end
+      ensure
+        socket.close
+      end
+    end
+  end
+end

data/lib/pione/agent/tuple-space-receiver.rb

@@ -0,0 +1,137 @@
+module Pione
+  module Agent
+    class TupleSpaceReceiver < BasicAgent
+      #
+      # instance methods
+      #
+
+      # notification handler threads
+      attr_reader :notification_handlers
+
+      def initialize(broker_front)
+        super()
+        @broker_front = broker_front  # broker front
+        @tuple_space = {}             # tuple space table
+        @tuple_space_lock = Mutex.new # lock for tuple space table
+        @notification_handlers = ThreadGroup.new
+      end
+
+      def tuple_spaces
+        @tuple_space_lock.synchronize {@tuple_space.keys}
+      end
+
+      #
+      # agent activities
+      #
+
+      define_transition :receive_packet
+      define_transition :update_broker
+      define_transition :sleep
+
+      chain :init => [:receive_packet, :update_broker]
+      chain :receive_packet => :receive_packet
+      chain :update_broker => :sleep
+      chain :sleep => :update_broker
+
+      #
+      # transitions
+      #
+
+      def transit_to_init
+        @tuple_space = {}
+        @socket = open_socket
+      end
+
+      # Receive tuple space servers and update the table.
+      def transit_to_receive_packet
+        # receive a presence notification
+        data, addr = @socket.recvfrom(1024)
+        ip_address = addr[3]
+        port = Marshal.load(data).to_i
+
+        # handle the notification in new thread
+        thread = Util::FreeThreadGenerator.generate do
+          handle_presence_notification(ip_address, port)
+        end
+        @notification_handlers.add(thread)
+      rescue IOError => e
+        Log::Debug.presence_notification("receiver agent received bad data from %s, so it ignored and reopen socket" % ip_address)
+        reopen_socket
+      end
+
+      # Close receiver socket.
+      def transit_to_terminate
+        # kill threads of presence notification handler
+        @notification_handlers.list.each {|thread| thread.kill.join}
+        # close socket
+        @socket.close unless @socket.closed?
+      end
+
+      def transit_to_update_broker
+        # update tuple space server list
+        @tuple_space_lock.synchronize do
+          # check timespan
+          @tuple_space.delete_if do |server, time|
+            (Time.now - time) > Global.tuple_space_receiver_disconnect_time
+          end
+        end
+
+        # update broker's tuple spaces
+        timeout(3) do
+          @tuple_space_lock.synchronize do
+            @broker_front.update_tuple_space_list(@tuple_space.keys)
+          end
+        end
+      rescue DRb::DRbConnError, Timeout::Error => e
+        Log::SystemLog.fatal("tuple space receiver failed to connect pione-broker: %s" % e.message)
+        raise ConnectionError.new
+      end
+
+      def transit_to_sleep
+        sleep 1
+      end
+
+      #
+      # helper methods
+      #
+
+      private
+
+      # Open a receiver socket.
+      def open_socket
+        socket = UDPSocket.open
+        socket.bind(Socket::INADDR_ANY, Global.presence_port)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+        return socket
+      end
+
+      def reopen_socket
+        @socket.close
+        @socket = open_socket
+      end
+
+      def handle_presence_notification(ip_address, port)
+        # build a reference to provider front
+        provider_front = DRbObject.new_with_uri("druby://%s:%s" % [ip_address, port])
+
+        # check connection
+        Timeout.timeout(3) {provider_front.ping}
+
+        @tuple_space_lock.synchronize do
+          @tuple_space[provider_front.tuple_space] = Time.now
+        end
+
+        Log::Debug.presence_notification do
+          "receiver agent received a presence notification from provider \"%s\"" % provider_front.__drburi
+        end
+      rescue Timeout::Error
+        Log::Debug.presence_notification do
+          "receiver agent ignored the provider \"%s\" that seems to be something bad " % provider_front.__drburi
+        end
+      rescue DRb::DRbConnError, DRbPatch::ReplyReaderError => e
+        reopen_socket
+        Log::Debug.presence_notification("tuple space receiver disconnected: %s" % e)
+      end
+    end
+  end
+end

data/lib/pione/command.rb

@@ -3,11 +3,10 @@ module Pione
   module Command; end
 end
 
+require 'pione/command/command-exception'
+require 'pione/command/spawner'
 require 'pione/command/option'
 require 'pione/command/basic-command'
-require 'pione/command/front-owner-command'
-require 'pione/command/daemon-process'
-require 'pione/command/child-process'
 require 'pione/command/pione-client'
 require 'pione/command/pione-task-worker'
 require 'pione/command/pione-broker'

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

@@ -1,253 +1,393 @@
 module Pione
   module Command
-    # CommandInfo is a strage of program informations.
-    class CommandInfo
-      attr_reader :name
-      attr_reader :tail
-      attr_reader :banner
-
-      def initialize
-        @name = nil
-        @tail = nil
-        @banner = banner
-      end
-
-      # Set progaram name.
-      #
-      # @param name [String]
-      #   process name
-      # @param b [Proc]
-      #   process tail block
-      # @return [void]
-      def set_name(name, &b)
-        @name = name
-      end
-
-      # Set program parameters.
-      def set_tail(&tail)
-        @tail = tail
-      end
-
-      # Set program banner.
-      #
-      # @param banner [String]
-      #   banner message
-      # @return [void]
-      def set_banner(banner)
-        @banner = banner
-      end
-
-      # Setup program name. If the setup process is failed, program name is not
-      # changed.
-      #
-      # @param cmd [BasicCommand]
-      #   command
-      # @return [void]
-      def setup(cmd)
-        $PROGRAM_NAME = "%s %s" % [@name, @tail ? @tail.call(cmd) : ""]
-      end
-    end
-
-    # BasicCommand is a base class for PIONE commands.
-    class BasicCommand < PioneObject
-      @info = CommandInfo.new
-      @option = Option.new(@info.name, @info.banner)
-      @pre_preparations = []
-      @preparations = []
-      @post_preparations = []
-      @pre_starts = []
-      @starts = []
-      @post_starts = []
-      @pre_terminations = []
-      @terminations = []
-      @post_terminations =[]
-
+    # BasicCommand provides PIONE command model. PIONE commands have 4 phases:
+    # "init", "setup", "action", "termination". Concrete commands implement some
+    # processings as each phases.
+    class BasicCommand
       class << self
-        attr_reader :info
-        attr_reader :option
-        attr_reader :pre_preparations
-        attr_reader :preparations
-        attr_reader :post_preparations
-        attr_reader :pre_starts
-        attr_reader :starts
-        attr_reader :post_starts
-        attr_reader :pre_terminations
-        attr_reader :terminations
-        attr_reader :post_terminations
-
-        # @api private
+        attr_reader :option_definition
+        attr_reader :phase_option
+        attr_reader :command_name_block
+        attr_reader :command_front_block
+        attr_reader :init_actions
+        attr_reader :setup_actions
+        attr_reader :execution_actions
+        attr_reader :termination_actions
+        attr_reader :exception_handler
+
         def inherited(subclass)
-          parent_option = self.option
           subclass.instance_eval do
-            @info = CommandInfo.new
-            @option = Option.new(@info.name, @info.banner)
+            @phase_option = {:init => {}, :setup => {}, :execution => {}, :termination => {}}
+            @option_definition = OptionDefinition.new
+            @command_name = nil
+            @command_name_block = nil
+            @command_banner = nil
+            @command_front = nil
+            @command_front_block = nil
+            @init_actions = Array.new
+            @setup_actions = Array.new
+            @execution_actions = Array.new
+            @termination_actions = Array.new
+            @exception_handler = {:init => {}, :setup => {}, :execution => {}, :termination => {}}
+
+            # define init phase actions
+            init :process_name
+            init :signal_trap
+            init :option
+            init :front
+            init :process_additional_information
           end
-          setter = lambda{|name, data| subclass.instance_variable_set(name, data.clone)}
-          setter.call(:@pre_preparations, self.pre_preparations)
-          setter.call(:@preparations, self.preparations)
-          setter.call(:@post_preparations, self.post_preparations)
-          setter.call(:@pre_starts, self.pre_starts)
-          setter.call(:@starts, self.starts)
-          setter.call(:@post_starts, self.post_starts)
-          setter.call(:@pre_terminations, self.pre_terminations)
-          setter.call(:@terminations, self.terminations)
-          setter.call(:@post_terminations, self.post_terminations)
-        end
-
-        # Define command informations.
-        #
-        # @param b [Proc]
-        #   evaluation content in the context of option definition
-        # @return [void]
-        #
-        # @example
-        #   class Cmd < BasicCommand
-        #     define_info do
-        #       set_name   "test"   # set process name
-        #       set_banner "sample" # set banner message
-        #     end
-        #   end
-        def define_info(&b)
-          @info.instance_eval(&b)
-        end
-
-        # Define command option.
-        #
-        # @param b [Proc]
-        #    context of the option definition
-        #
-        # @example
-        #   class Cmd < BasicCommand
-        #     define_option do
-        #       option("-t", "--test", "test option") do |data, arg1|
-        #         data[:test] = true
-        #       end
-        #     end
-        #   end
-        def define_option(&b)
-          @option.instance_eval(&b)
-        end
-
-        # Define a preparation process.
-        #
-        # @param type [Symbol]
-        #   preparation type
-        # @return [void]
-        def prepare(type=nil, &b)
-          case type
-          when :pre
-            @pre_preparations << b
-          when :post
-            @post_preparations << b
+        end
+
+        # Set progaram name or return the name.
+        def command_name(name=nil, &b)
+          if name
+            @command_name = name
+            @command_name_block = block_given? ? b : nil
           else
-            @preparations << b
+            @command_name
           end
         end
 
-        # Define a start process.
-        #
-        # @param type [Symbol]
-        #   start type
-        # @return [void]
-        def start(type=nil, &b)
-          case type
-          when :pre
-            @pre_starts << b
-          when :post
-            @post_starts << b
+        # Set program banner or return the banner.
+        def command_banner(banner=nil)
+          if banner
+            @command_banner = banner
           else
-            @starts << b
+            @command_banner
           end
         end
 
-        # Define a termination process.
-        #
-        # @param type [Symbol]
-        #   termination type
-        # @return [void]
-        def terminate(type=nil, &b)
-          case type
-          when :pre
-            @pre_terminations << b
-          when :post
-            @post_terminations << b
+        # Set command front or return the front class.
+        def command_front(front_class=nil, &b)
+          if front_class
+            @command_front = front_class
+            @command_front_block = b
           else
-            @terminations << b
+            @command_front
           end
         end
 
-        # Run the command.
-        #
-        # @return [void]
+        forward :@option_definition, :use, :use_option
+        forward :@option_definition, :define, :define_option
+        forward :@option_definition, :item, :option_item
+        forward :@option_definition, :default, :option_default
+        forward :@option_definition, :validate, :validate_option
+
+        # Run the command with the arguments.
         def run(argv)
           self.new(argv).run
         end
+
+        # Set setup phase options.
+        def init_phase(option)
+          set_phase_option(:init, option)
+        end
+
+        # Set setup phase options.
+        def setup_phase(option)
+          set_phase_option(:setup, option)
+        end
+
+        # Set execution phase options.
+        def execution_phase(option)
+          set_phase_option(:execution, option)
+        end
+
+        # Set termination phase options.
+        def termination_phase(option)
+          set_phase_option(:termination, option)
+        end
+
+        # Register the action to init phase.
+        def init(action, option={})
+          register_action(@init_actions, action, option)
+        end
+
+        # Register the action to setup phase.
+        def setup(action, option={})
+          register_action(@setup_actions, action, option)
+        end
+
+        # Register the action to execution phase.
+        def execute(action, option={})
+          register_action(@execution_actions, action, option)
+        end
+
+        # Register the action to termination phase.
+        def terminate(action, option={})
+          register_action(@termination_actions, action, option)
+        end
+
+        def handle_exception(phase_name, exceptions, &action)
+          exceptions.each {|e| @exception_handler[phase_name][e] = action}
+        end
+
+        def handle_setup_exception(*exceptions, &action)
+          handle_exception(:setup, exceptions, &action)
+        end
+
+        def handle_execution_exception(*exceptions, &action)
+          handle_exception(:execution, exceptions, &action)
+        end
+
+        def handle_termination_exception(*exceptions, &action)
+          handle_exception(:termination, exceptions, &action)
+        end
+
+        private
+
+        # Set phase option.
+        def set_phase_option(name, option)
+          @phase_option[name] = option
+        end
+
+        # Register the action to the phase.
+        def register_action(phase_actions, action, option={})
+          _action = action.is_a?(Hash) ? action : {[] => action}
+          _action.each do |key, val|
+            phase_actions << [key.is_a?(Array) ? key : [key], val, option]
+          end
+        end
       end
 
-      forward! :class, :option, :info
+      attr_reader :option
+      attr_reader :running_thread
+
+      forward! :class, :option_definition, :command_name, :command_name_block
+      forward! :class, :command_banner, :command_front, :command_front_block
 
       def initialize(argv)
         @argv = argv
+        @option = {}
+        @__exit_status__ = true
+        @__phase_name__ = nil
+        @__action_name__ = nil
+
+        # process has just one command object
+        Global.command = self
       end
 
-      # Run the command.
-      #
-      # @return [void]
+      # Run 4 phase lifecycle of the command. This fires actions in each phase.
       def run
-        receiver = self
-        caller = lambda {|name| self.class.__send__(name).each{|proc| receiver.instance_eval(&proc)}}
-        caller.call(:pre_preparations)
-        caller.call(:preparations)
-        caller.call(:post_preparations)
-        caller.call(:pre_starts)
-        caller.call(:starts)
-        caller.call(:post_starts)
-        call_terminations
-      end
-
-      def call_terminations
-        receiver = self
-        caller = lambda  do |name|
-          self.class.__send__(name).reverse.each do |proc|
-            puts "%s(%s):%s:%s" % [info.name, name, *proc.source_location] if Pione.debug_mode?
-            receiver.instance_eval(&proc)
+        @running_thread = Thread.current
+        enter_phase(:init)
+        enter_phase(:setup)
+        enter_phase(:execution)
+        terminate # => enter_phase(:termination) and exit
+      end
+
+      # Enter setup phase.
+      def enter_phase(phase_name)
+        # avoid double launch
+        return if @__phase_name__ == phase_name
+
+        # show debug message for entering phase
+        Log::Debug.system("%s enters phase \"%s\"" % [command_name, phase_name])
+
+        limit = self.class.phase_option[phase_name][:timeout]
+        phase_keyword, actions = find_phase_actions(phase_name)
+        timeout(limit) do
+          @__phase_name__ = phase_name
+          actions.each do |(targets, action_name, action_option)|
+            # check current mode is target or not
+            if not(targets.empty?) and not(targets.include?(option[:action_mode]))
+              next
+            end
+
+            # show debug message for firing action
+            Log::Debug.system("%s fires action \"%s\" in phase \"%s\"" % [command_name, action_name, phase_name])
+
+            # fire action
+            @__action_name__ = action_name
+            full_action_name = ("%s_%s" % [phase_keyword, action_name]).to_sym
+            if action_option[:module]
+              # call action in command action module
+              instance_eval(&action_option[:module].get(full_action_name))
+            else
+              # call action in self object
+              method(full_action_name).call
+            end
           end
         end
-        caller.call(:pre_terminations)
-        caller.call(:terminations)
-        caller.call(:post_terminations)
+      rescue *self.class.exception_handler[phase_name].keys => e
+        self.class.exception_handler[phase_name][e.class].call(self, e)
+      rescue Timeout::Error
+        args = [command_name, @__action_name__, @__phase_name__, limit]
+        abort("%s timeouted at action \"%s\" in phase \"%s\". (%i sec)" % args)
+      end
+
+      # Terminate the command. Note that this enters in termination phase first,
+      # and command exit.
+      def terminate
+        enter_phase(:termination)
+        exit # end with status code
+      end
+
+      # Return true if it is in init phase.
+      def init?
+        @__phase_name__ == :init
+      end
+
+      # Return true if it is in setup phase.
+      def setup?
+        @__phase_name__ == :setup
+      end
+
+      # Return true if it is in execution phase.
+      def execution?
+        @__phase_name__ == :execution
+      end
+
+      # Return true if it is in termination phase.
+      def termination?
+        @__phase_name__ == :termination
+      end
+
+      # Exit running command and return status.
+      def exit
+        Log::Debug.system("%s exits with status \"%s\"" % [command_name, @__exit_status__])
+        Global.system_logger.terminate
+        Kernel.exit(Global.exit_status)
+      end
+
+      # Exit running command and return failure status. Note that this method
+      # enters termination phase before it exits.
+      def abort(msg_or_exception, pos=caller(1).first)
+        # hide the message because some option errors are meaningless
+        invisible = msg_or_exception.is_a?(HideableOptionError)
+
+        # setup abortion message
+        msg = msg_or_exception.is_a?(Exception) ? msg_or_exception.message : msg_or_exception
+
+        # show the message
+        if invisible
+          Log::Debug.system(msg, pos)
+        else
+          Log::SystemLog.fatal(msg, pos)
+        end
+
+        # set exit status code
+        Global.exit_status = false
+
+        # go to termination phase
+        terminate
       end
 
-      prepare(:pre) do
-        # set signal trap
+      private
+
+      # Initialize process name.
+      def init_process_name
+        $PROGRAM_NAME = command_name
+      end
+
+      # Initialize signal trap actions.
+      def init_signal_trap
+        # explicit exit for signal INT (exit status code: failure)
         Signal.trap(:INT) do
-          begin
-            call_terminations
-          rescue DRb::ReplyReaderThreadError
-            # ignore reply reader error
-          end
+          abort("%s is terminated by signal INT" % command_name)
         end
 
-        Signal.trap(:TERM) { call_terminations }
+        # implicit abortion for signal TERM (exit status code: success)
+        Signal.trap(:TERM) do
+          Log::Debug.system("%s is terminated by signal TERM" % command_name)
+          terminate
+        end
+      end
 
-        # parse options
-        option.parse(@argv)
+      # Initialize command options.
+      def init_option
+        @option = option_definition.parse(@argv, command_name, command_banner)
+      rescue OptionParser::ParseError, OptionError => e
+        abort(e)
       end
 
-      prepare do
-        # validate options
-        option.check
+      # Initialize front server of this process if it needs.
+      def init_front
+        if command_front
+          front_args = command_front_block ? command_front_block.call(self) : []
+          Global.front = command_front.new(*front_args)
+        end
       end
 
-      prepare(:post) do
-        # setup process name
-        info.setup(self)
+      # Modify process name to be with the additional informations.
+      def init_process_additional_information
+        if self.class.command_name_block
+          $PROGRAM_NAME = "%s (%s)" % [command_name, command_name_block.call(self)]
+        end
       end
 
-      terminate(:post) do
-        Global.monitor.synchronize do
-          # exit with no exception
-          exit Global.exit_status
+      # Find phase actions by phase name.
+      def find_phase_actions(phase_name)
+        case phase_name
+        when :init; [:init, self.class.init_actions]
+        when :setup; [:setup, self.class.setup_actions]
+        when :execution; [:execute, self.class.execution_actions]
+        when :termination; [:terminate, self.class.termination_actions]
+        end
+      end
+    end
+
+    module CommandActionInterface
+      class << self
+        def extended(mod)
+          mod.instance_variable_set(:@action, Hash.new)
+        end
+      end
+
+      # Return the named action.
+      def get(name)
+        @action[name] || (raise ActionNotFound.new(self, name))
+      end
+
+      def define_action(name, &b)
+        @action[name] = b
+      end
+    end
+
+    module CommonCommandAction
+      extend CommandActionInterface
+
+      define_action(:terminate_child_process) do |cmd|
+        if Global.front
+          # send signal TERM to the child process
+          Global.front.child.each do |pid, uri|
+            Util.ignore_exception {Process.kill(:TERM, pid)}
+          end
+
+          # wait all children
+          children = Process.waitall.map{|(pid, _)| pid}
+          if not(children.empty?)
+            Log::Debug.system("%s killed #%s" % [cmd.command_name, children.join(", ")])
+          end
+        end
+      end
+
+      define_action(:setup_parent_process_connection) do |cmd|
+        cmd.option[:parent_front].add_child(Process.pid, Global.front.uri)
+        ParentFrontWatchDog.new(self) # start to watch parent process
+      end
+
+      define_action(:terminate_parent_process_connection) do |cmd|
+        # maybe parent process is dead in this timing
+        Util.ignore_exception do
+          cmd.option[:parent_front].remove_child(Process.pid)
+        end
+      end
+    end
+
+    class ParentFrontWatchDog
+      def initialize(command)
+        @command = command
+
+        Thread.new do
+          while true
+            # PPID 1 means the parent process is dead
+            if Process.ppid == 1 or Util.error?{command.option[:parent_front].ping}
+              break @command.terminate
+            end
+            sleep 1
+          end
         end
       end
     end