pione 0.2.2 → 0.3.0

data/lib/pione/command/pione-task-worker.rb

@@ -1,149 +1,166 @@
 module Pione
   module Command
-    # This is a class for +pione-task-worker+ command. +pione-task-worker+
-    # starts a task worker agent with tuple space server.
-    class PioneTaskWorker < ChildProcess
-      define_info do
-        set_name "pione-task-worker"
-        set_tail {|cmd|
-          begin
-            "{Front: %s, ParentFront: %s}" % [
-              Global.front.uri, cmd.option[:no_parent_mode] ? "nil" : cmd.option[:parent_front].uri
-            ]
-          rescue => e
-            Util::ErrorReport.warn("faild to get command line options.", self, e, __FILE__, __LINE__)
-          end
-        }
-        set_banner <<BANNER
-Run task worker process. This command is launched by other processes like
-pione-client or pione-broker.
-BANNER
+    # This is a body for +pione-task-worker+ command.
+    class PioneTaskWorker < BasicCommand
+      #
+      # basic informations
+      #
+
+      command_name "pione-task-worker" do |cmd|
+        "front: %s, parent: %s" % [Global.front.uri, cmd.option[:parent_front].uri]
       end
 
-      define_option do
-        use :color
-        use :debug
-        use :my_ip_address
-        use :no_parent
-        use :parent_front
-
-        define(:connection_id) do |item|
-          item.long = '--connection-id=ID'
-          item.desc = 'set connection id'
-          item.value = proc {|id| id}
-        end
+      command_banner(Util::Indentation.cut(<<-TEXT))
+        Run a task worker process. This command assumes to be launched by
+        pione-client or pione-broker, so you should not execute this by hand.
+      TEXT
 
-        define(:features) do |item|
-          item.long = '--features=FEATURES'
-          item.desc = 'set features'
-          item.value = proc do |features|
-            begin
-              DocumentTransformer.new.apply(
-                DocumentParser.new.feature_expr.parse(features)
-              )
-            rescue Parslet::ParseFailed => e
-              puts "invalid parameters: " + str
-              Util::ErrorReport.print(e)
-              abort
-            end
-          end
-        end
+      command_front Front::TaskWorkerFront
 
-        validate do |option|
-          # check requisite options
-          abort("error: no connection id") if option[:connection_id].nil?
-
-          # get the parent front server
-          begin
-            option[:parent_front].uuid
-          rescue => e
-            if Pione.debug_mode?
-              debug_message "pione-task-worker cannot get the parent front server: %s" % e
-            end
-            abort
-          end
-        end
+      #
+      # options
+      #
+
+      use_option :color
+      use_option :debug
+      use_option :my_ip_address
+      use_option :parent_front
+      use_option :features
+
+      define_option(:tuple_space_id) do |item|
+        item.long = '--tuple-space-id=UUID'
+        item.desc = 'tuple space id that the worker joins'
+        item.requisite = true
+        item.value = proc {|id| id}
+      end
+
+      #
+      # class methods
+      #
+
+      # Create a new process of +pione-task-worker+ command.
+      def self.spawn(features, tuple_space_id)
+        spawner = Spawner.new("pione-task-worker")
+
+        # debug options
+        spawner.option("--debug=system") if Global.debug_system
+        spawner.option("--debug=ignored_exception") if Global.debug_ignored_exception
+        spawner.option("--debug=rule_engine") if Global.debug_rule_engine
+        spawner.option("--debug=communication") if Global.debug_communication
+        spawner.option("--debug=presence_notification") if Global.debug_presence_notification
+
+        # requisite options
+        spawner.option("--parent-front", Global.front.uri)
+        spawner.option("--tuple-space-id", tuple_space_id)
+        spawner.option("--features", features) if features
+
+        # optionals
+        spawner.option("--color") if Global.color_enabled
+
+        spawner.spawn # this method returns child front
       end
 
+      #
+      # instance methods
+      #
+
       attr_reader :agent
       attr_reader :tuple_space_server
 
-      private
+      #
+      # command lifecycle: setup phase
+      #
 
-      def create_front
-        Pione::Front::TaskWorkerFront.new(self)
-      end
+      setup_phase :timeout => 15
+      setup :parent_process_connection, :module => CommonCommandAction
+      setup :tuple_space
+      setup :agent
+      setup :base_location
+      setup :job_terminator
+
+      # Get tuple space from parent process and test the connection.
+      def setup_tuple_space
+        @tuple_space = option[:parent_front].get_tuple_space(option[:tuple_space_id])
 
-      prepare do
-        begin
-          @tuple_space_server = option[:parent_front].get_tuple_space_server(option[:connection_id])
-          @agent = Pione::Agent[:task_worker].new(@tuple_space_server, option[:features])
-          @command_listener = Pione::Agent[:command_listener].new(@tuple_space_server, self)
+        unless @tuple_space
+          abort("%s cannot get tuple space \"%s\"." % [command_name, option[:tuple_space_id]])
+        end
 
-          # connect caller front
-          option[:parent_front].add_task_worker_front(Global.front, option[:connection_id])
+        if Util.error?(:timeout => 3) {@tuple_space.uuid}
+          abort("%s cannot connect to tuple space." % command_name)
+        end
+      end
 
-          abort("pione-task-worker error: no tuple space server") unless @tuple_space_server
+      # Create a task worker agent.
+      def setup_agent
+        @agent = Agent::TaskWorker.new(@tuple_space, option[:expressive_features])
+      end
 
-          # get base uri
-          if @tuple_space_server.base_location.kind_of?(Location::DropboxLocation)
-            Location::Dropbox.init(@tuple_space_server)
-            unless Location::Dropbox.ready?
+      # Setup base location.
+      def setup_base_location
+        if @tuple_space.base_location.kind_of?(Location::DropboxLocation)
+          Location::Dropbox.init(@tuple_space)
+          unless Location::Dropbox.ready?
             abort("You aren't ready to access Dropbox.")
-            end
           end
-        rescue => e
-          msg = "Exception raised in preparing task-worker, go termination process."
-          Util::ErrorReport.warn(msg, self, e, __FILE__, __LINE__)
-          call_terminations
         end
       end
 
-      start do
-        # start task worker activity
+      # Create a job terminator and setup the action.
+      def setup_job_terminator
+        @job_terminator = Agent::JobTerminator.new(@tuple_space) do
+          terminate
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      handle_execution_exception(DRb::DRbConnError) do |cmd, e|
+        Log::Debug.system do
+          "%s goes termination phase because the exception was catched: %s" % [cmd.command_name, e.message]
+        end
+        cmd.terminate
+      end
+      execute :job_terminator
+      execute :agent
+
+      # Start the job terminator.
+      def execute_job_terminator
+        @job_terminator.start
+      end
+
+      # Start task worker activity and wait the termination.
+      def execute_agent
         @agent.start
-        @command_listener.start
+        @agent.wait_until_terminated(nil)
+      end
 
-        # wait...
-        begin
-          @agent.running_thread.join
-        rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-          # ignore
+      #
+      # command lifecycle: termination phase
+      #
+
+      termination_phase :timeout => 10
+      terminate :job_terminator
+      terminate :agent
+      terminate :parent_process_connection, :module => CommonCommandAction
+
+      # Terminate job terminator.
+      def terminate_job_terminator
+        if @job_terminator and not(@job_terminator.terminated?)
+          @job_terminator.terminate
         end
       end
 
-      terminate do
-        Global.monitor.synchronize do
-          begin
-            # flag
-            return if @terminated
-            @terminated = true
-
-            # terminate the agent
-            if @agent
-              @agent.terminate
-
-              Timeout.timeout(5) do
-                while true
-                  break if @agent.terminated? and @agent.running_thread and @agent.running_thread.stop?
-                  sleep 1
-                end
-              end
-            end
-
-            # disconnect parent front
-            option[:parent_front].remove_task_worker_front(self, option[:connection_id])
-
-          rescue DRb::DRbConnError, DRb::ReplyReaderThreadError => e
-            Util::ErrorReport.warn("Disconnected in termination process of task worker agent.", self, e, __FILE__, __LINE__)
-          rescue ThreadError => e
-            # tuple space may be closed
-            Util::ErrorReport.warn("Failed in termination process of task worker agent.", self, e, __FILE__, __LINE__)
-          rescue Timeout::Error => e
-            Util::ErrorReport.warn("Timeouted in termination of pione-task-worker.", self, e, __FILE__, __LINE__)
-          end
+      # Terminate task worker agent.
+      def terminate_agent
+        if @agent
+          @agent.terminate
+          @agent.wait_until_terminated(nil)
         end
       end
     end
   end
 end
+

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

@@ -1,68 +1,101 @@
 module Pione
   module Command
     # PioneTupleSpaceProvider is for +pione-tuple-space-provider+ command.
-    class PioneTupleSpaceProvider < ChildProcess
-      define_info do
-        set_name "pione-tuple-space-provider"
-        set_tail {|cmd|
-          front_uri = begin Global.front.uri rescue "failed" end
-          parent_front = begin cmd.option[:no_parent_mode] ? "nil" : cmd.option[:parent_front].uri rescue "failed" end
-          "{Front: %s, ParentFront: %s}" % [front_uri, parent_front]
-        }
-        set_banner <<TXT
-Run tuple space provider process for sending tuple space presence notifier. This
-command is launched by other processes like pione-client or pione-relay
-normally, but you can force to start by calling with --no-parent option.
-TXT
-      end
+    class PioneTupleSpaceProvider < BasicCommand
+      #
+      # command info
+      #
 
-      define_option do
-        use :debug
-        use :color
-        use :my_ip_address
-        use :no_parent
-        use :parent_front
-        use :presence_notification_address
-        use :show_communication
-        use :show_presence_notifier
+      command_name "pione-tuple-space-provider" do |cmd|
+        "front: %s, parent: %s" % [Global.front.uri, cmd.option[:parent_front].uri]
       end
 
-      attr_reader :tuple_space_provider
+      command_banner(Util::Indentation.cut(<<-TXT))
+        Run tuple space provider process for sending tuple space presence
+        notifier. This command assumes to be launched by other processes like
+        pione-client or pione-relay.
+      TXT
 
-      # @api private
-      def create_front
-        Pione::Front::TupleSpaceProviderFront.new(self)
+      command_front Pione::Front::TupleSpaceProviderFront do |cmd|
+        [cmd.option[:parent_front].get_tuple_space(nil)]
       end
 
-      prepare do
-        # make tuple space provider
-        @tuple_space_provider = TupleSpaceProvider.new
-      end
+      #
+      # options
+      #
+
+      use_option :color
+      use_option :debug
+      use_option :my_ip_address
+      use_option :parent_front
+      use_option :presence_notification_address
+
+      #
+      # class methods
+      #
 
-      start do
-        # start provider activity
-        @tuple_space_provider.start
+      # Create a new process of tuple space provider command.
+      def self.spawn
+        spawner = Spawner.new(command_name)
 
-        begin
-          # set my URI to caller front as its provider
-          unless option[:no_parent_mode]
-            option[:parent_front].set_tuple_space_provider(Global.front.uri)
-          end
+        # debug options
+        spawner.option("--debug=system") if Global.debug_system
+        spawner.option("--debug=ignored_exception") if Global.debug_ignored_exception
+        spawner.option("--debug=rule_engine") if Global.debug_rule_engine
+        spawner.option("--debug=communication") if Global.debug_communication
+        spawner.option("--debug=presence_notification") if Global.debug_presence_notification
 
-          # wait
-          DRb.thread.join
-        rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-          # ignore
+        # requisite options
+        spawner.option("--parent-front", Global.front.uri)
+        spawner.option("--my-ip-address", Global.my_ip_address)
+        Global.presence_notification_addresses.each do |address|
+          spawner.option("--presence-notification-address", address.to_s)
         end
+
+        # optionals
+        spawner.option("--color") if Global.color_enabled
+
+        spawner.spawn
+      end
+
+      #
+      # instance methods
+      #
+
+      attr_reader :agent
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      setup_phase :timeout => 5
+      setup :parent_process_connection, :module => CommonCommandAction
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      execute :agent
+
+      # Start agent activity and wait the termination.
+      def execute_agent
+        @agent = Agent::TupleSpaceProvider.start(Global.front)
+        @agent.wait_until_terminated(nil)
       end
 
-      terminate do
-        Global.monitor.synchronize do
-          begin
-            @tuple_space_provider.terminate
-          rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-            abort
-          end
+      #
+      # command lifecycle: termination phase
+      #
+
+      termination_phase :timeout => 5
+      terminate :agent
+      terminate :parent_process_connection, :module => CommonCommandAction
+
+      # Terminate agent.
+      def terminate_agent
+        if @agent and not(@agent.terminated?)
+          @agent.terminate
+          @agent.wait_until_terminated(nil)
         end
       end
     end

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

@@ -2,70 +2,109 @@ module Pione
   module Command
     # PioneTupleSpaceReceiver is a command that launchs tuple space receiver
     # agent.
-    class PioneTupleSpaceReceiver < ChildProcess
-      define_info do
-        set_name "pione-tuple-space-receiver"
-        set_tail {|cmd|
-          front = Global.front.uri
-          parent_front = cmd.option[:no_parent_mode] ? "nil" : cmd.option[:parent_front].uri
-          "{Front: %s, ParentFront: %s}" % [front, parent_front]
-        }
-        set_banner <<TXT
-Run tuple space receiver process for receiving tuple space presence
-notifier. This command is launched by other processes like pione-broker
-normally, but you can force to start by calling with --no-parent option.
-TXT
+    class PioneTupleSpaceReceiver < BasicCommand
+      #
+      # basic informations
+      #
+
+      command_name "pione-tuple-space-receiver" do |cmd|
+        "front: %s, parent: %s" % [Global.front.uri, cmd.option[:parent_front].uri]
       end
 
-      define_option do
-        use :debug
-        use :color
-        use :my_ip_address
-        use :no_parent
-        use :parent_front
-        use :show_communication
-        use :show_presence_notifier
-
-        define(:presence_port) do |item|
-          item.long = "--presence-port=PORT"
-          item.desc = "set presence port number"
-          item.action = lambda do |option, port|
-            Global.presence_port = port.to_i
-          end
+      command_banner(Util::Indentation.cut(<<-TXT))
+        Run tuple space receiver process for receiving tuple space presence
+        notifier. This command is launched by other processes like pione-broker
+        normally, but you can force to start by calling with --no-parent option.
+      TXT
+
+      command_front Front::TupleSpaceReceiverFront
+
+      #
+      # options
+      #
+
+      use_option :color
+      use_option :debug
+      use_option :my_ip_address
+      use_option :parent_front
+
+      define_option(:presence_port) do |item|
+        item.long = "--presence-port=PORT"
+        item.desc = "set presence port number"
+        item.action = lambda do |_, _, port|
+          Global.presence_port = port.to_i
         end
       end
 
-      attr_reader :tuple_space_receiver
+      #
+      # class methods
+      #
+
+      # Create a new process of tuple space provider command.
+      def self.spawn
+        spawner = Spawner.new("pione-tuple-space-receiver")
+
+        # debug options
+        spawner.option("--debug=system") if Global.debug_system
+        spawner.option("--debug=ignored_exception") if Global.debug_ignored_exception
+        spawner.option("--debug=rule_engine") if Global.debug_rule_engine
+        spawner.option("--debug=communication") if Global.debug_communication
+        spawner.option("--debug=presence_notification") if Global.debug_presence_notification
+
+        # requisite options
+        spawner.option("--parent-front", Global.front.uri)
+        spawner.option("--my-ip-address", Global.my_ip_address)
+        spawner.option("--presence-port", Global.presence_port.to_s)
+
+        # optionals
+        spawner.option("--color") if Global.color_enabled
 
-      def create_front
-        Front::TupleSpaceReceiverFront.new(self)
+        spawner.spawn
       end
 
-      prepare do
-        @tuple_space_receiver = TupleSpaceReceiver.new
+      #
+      # instance methods
+      #
+
+      attr_reader :tuple_space_receiver
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      setup :parent_process_connection, :module => CommonCommandAction
+      setup :broker
+
+      # set my uri to parent front as its provider
+      def setup_broker
+        option[:parent_front].set_tuple_space_receiver(Global.front.uri)
       end
 
-      start do
-        begin
-          # start provider activity
-          @tuple_space_receiver.start
+      #
+      # command lifecycle: execution phase
+      #
 
-          # set my uri to parent front as its provider
-          unless option[:no_parent_mode]
-            option[:parent_front].set_tuple_space_receiver(Global.front.uri)
-          end
+      execute :agent
 
-          # wait
-          DRb.thread.join
-        rescue DRb::ReplyReaderThreadError => e
-          # ignore reply reader error
-        end
+      # create a tuple space receiver agent
+      def execute_agent
+        @agent = Agent::TupleSpaceReceiver.start(option[:parent_front])
+        @agent.wait_until_terminated(nil)
+      rescue Agent::ConnectionError
+        Log::SystemLog.fatal("pione-tuple-space-receiver is terminated because pione-borker may be dead.")
+        terminate
       end
 
-      terminate do
-        Global.monitor.synchronize do
-          @tuple_space_receiver.terminate
-        end
+      #
+      # command lifecycle: termination phase
+      #
+
+      termination_phase :timeout => 5
+      terminate :agent
+      terminate :parent_process_connection, :module => CommonCommandAction
+
+      def terminate_agent
+        @agent.terminate if @agent
       end
     end
   end