pione 0.1.2 → 0.1.3

data/lib/pione/command/child-process.rb

@@ -1,20 +1,29 @@
 module Pione
   module Command
+    # ChildProcess is a superclass for commands that are children of other
+    # processes.
     class ChildProcess < FrontOwnerCommand
-      use_option_module CommandOption::ChildProcessOption
-      attr_reader :parent_front
+      define_option do
+        default :no_parent_front, false
 
-      # @api private
-      def validate_options
-        if not(@no_parent_mode) and @parent_front.nil?
-          abort("option error: no caller front address")
+        # --parent-front
+        option('--parent-front=URI', 'set parent front URI') do |data, uri|
+          data[:parent_front] = DRbObject.new_with_uri(uri)
+        end
+
+        # --no-parent
+        option('--no-parent', 'turn on no parent mode') do |data|
+          data[:no_parent_mode] = true
         end
-      end
 
-      # @api private
-      def prepare
-        super
+        validate do |data|
+          if not(data[:no_parent_mode]) and data[:parent_front].nil?
+            abort("option error: no caller front address")
+          end
+        end
+      end
 
+      prepare do
         # "ppid == 1" means the parent is dead
         terminater = Proc.new do
           if Process.ppid == 1
@@ -28,19 +37,13 @@ module Pione
         @watchdog = Agent::TrivialRoutineWorker.new(terminater)
       end
 
-      # @api private
-      def start
+      start do
         @watchdog.start
       end
 
-      # Terminate the child front. Kill watchdog.
-      #
-      # @return [void]
-      def terminate
+      terminate do
         # kill watchdog
         @watchdog.terminate
-        # go to other termination processes
-        super
       end
     end
   end

data/lib/pione/command/daemon-process.rb

@@ -1,17 +1,18 @@
 module Pione
   module Command
+    # DaemonProcess is a class for commands that enable to daemonize.
     class DaemonProcess < FrontOwnerCommand
-      use_option_module CommandOption::DaemonOption
+      define_option do
+        default :daemon, false
 
-      def initialize
-        super
-        @daemon = false
+        # --daemon
+        option("--daemon", "turn on daemon mode") do |data|
+          data[:daemon] = true
+        end
       end
 
-      def prepare
-        super
-        puts Global.front.uri
-        Process.daemon(true, true) if @daemon
+      prepare(:post) do
+        Process.daemon(true, true) if option[:daemon]
       end
     end
   end

data/lib/pione/command/front-owner-command.rb

@@ -1,26 +1,14 @@
 module Pione
   module Command
+    # FrontOwnerCommand is a parent of classes that own front server.
     class FrontOwnerCommand < BasicCommand
-      define_option("--my-ip-address=ADDRESS", "set my IP address") do |address|
-        Global.my_ip_address = address
-      end
-
-      # Runs the command.
-      #
-      # @return [void]
-      def run
-        parse_options
-        validate_options
-        setup_front
-        prepare
-        setup_program_name
-        start
+      define_option do
+        option("--my-ip-address=ADDRESS", "set my IP address") do |data, address|
+          Global.my_ip_address = address
+        end
       end
 
-      # Setup font server.
-      #
-      # @return [void]
-      def setup_front
+      prepare do
         Global.front = create_front
       end
 
@@ -32,15 +20,10 @@ module Pione
         raise NotImplementedError
       end
 
-      # Terminate PIONE front. Stop DRb service.
-      #
-      # @return [void]
-      def terminate
+      terminate do
         Global.monitor.synchronize do
           # stop DRb service
-          DRb.stop_service
-          # go to other termination processes
-          super
+          # DRb.stop_service
         end
       end
     end

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

@@ -1,45 +1,44 @@
 module Pione
   module Command
+    # PioneBroker is a command for starting a PIONE broker agent. Brokers
+    # provides task processing ability to the system.
     class PioneBroker < DaemonProcess
-      set_program_name "pione-broker" do
-        "--task-worker %s" % @task_worker
+      define_info do
+        set_name "pione-broker"
+        set_tail {|cmd| "{TaskWorker: %s}" % cmd.option[:task_worker]}
+        set_banner "Run broker agent to launch task workers."
       end
 
-      set_program_message <<TXT
-Runs the broker to launch task workers.
-TXT
+      define_option do
+        use Option::TupleSpaceReceiverOption
+        use Option::TaskWorkerOwnerOption
 
-      use_option_module CommandOption::TupleSpaceReceiverOption
-      use_option_module CommandOption::TaskWorkerOwnerOption
+        validate do |data|
+          unless data[:task_worker] > 0
+            abort("error: no task worker resources")
+          end
+        end
+      end
 
       attr_reader :broker
 
-      def initialize
-        @task_worker = [Util.core_number - 1, 1].max
-        @features = nil
-      end
-
       def create_front
         Front::BrokerFront.new(self)
       end
 
-      def validate_options
-        unless @task_worker > 0
-          abort("error: no task worker resources")
-        end
-      end
-
-      def prepare
-        super
-        @broker = Pione::Agent[:broker].new(@features, task_worker_resource: @task_worker)
+      prepare do
+        @broker = Pione::Agent[:broker].new(
+          option[:features],
+          task_worker_resource: option[:task_worker]
+        )
         @tuple_space_receiver = Pione::TupleSpaceReceiver.instance
       end
 
-      def start
-        # start broker
+      start do
+        # start broker agent
         @broker.start
 
-        # start tuple space receiver
+        # start tuple space receiver with the broker agent
         @tuple_space_receiver.register(@broker)
 
         # wait
@@ -49,6 +48,10 @@ TXT
           retry
         end
       end
+
+      terminate do
+        @broker.terminate
+      end
     end
   end
 end

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

@@ -1,13 +1,13 @@
 module Pione
   module Command
+    # PioneClean is a command for clearing temporary files of PIONE system.
     class PioneClean < BasicCommand
-      set_program_name("pione-clean")
-
-      set_program_message <<TXT
-Cleans working directories and file cache directories.
-TXT
+      define_info do
+        set_name "pione-clean"
+        set_banner "Clean working directories and file cache directories."
+      end
 
-      def start
+      start do
         FileUtils.remove_entry_secure(Global.working_directory_root)
         FileUtils.remove_entry_secure(Global.file_cache_directory_root)
       end

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

@@ -1,142 +1,146 @@
 module Pione
   module Command
+    # PioneClient is a command to request processing.
     class PioneClient < FrontOwnerCommand
-      use_option_module CommandOption::TaskWorkerOwnerOption
-      use_option_module CommandOption::TupleSpaceProviderOwnerOption
-
-      set_program_name("pione-client") do
-        [@filename, "-o %s" % @output_uri, @stream ? "--stream" : ""].join(" ")
+      define_info do
+        set_name "pione-client"
+        set_tail {|cmd|
+          args = [cmd.option[:filename], cmd.option[:output_uri], cmd.option[:stream]]
+          "{Document: %s, OutputURI: %s, Stream: %s}" % args
+        }
+        set_banner "Requests to process PIONE document."
       end
 
-      set_program_message "Requests to process PIONE document."
+      define_option do
+        use Option::TaskWorkerOwnerOption
+        use Option::TupleSpaceProviderOwnerOption
+
+        default :output_location, Location["local:./output/"]
+        default :stream, false
+        default :params, Model::Parameters.empty
+        default :dry_run, false
+        default :task_worker, [Util.core_number - 1, 1].max
+        default :request_task_worker, 1
+        default :stand_alone, false
+        default :relay, nil
+        default :filename, "-"
+        default :without_tuple_space_provider, false
+        default :features, "^Interactive"
+        default :list_params, false
+
+        # --input
+        option('-i LOCATION', '--input=LOCATION', 'set input directory') do |data, uri|
+          begin
+            data[:input_location] = Location[uri]
+          rescue ArgumentError
+            abort("opiton error: bad location '%s'" % uri)
+          end
+        end
 
-      # --input-uri
-      define_option('-i URI', '--input=URI', 'set input directory URI') do |uri|
-        parsed = URI.parse(uri)
-        unless parsed.scheme
-          parsed = URI.parse("local:%s" % Pathname.new(uri).expand_path)
+        # --output
+        option('-o LOCATION', '--output=LOCATION', 'set output directory') do |data, uri|
+          begin
+            data[:output_location] = Location[uri]
+          rescue ArgumentError
+            abort("opiton error: bad location '%s'" % uri)
+          end
         end
-        @input_uri = parsed.as_directory
-      end
 
-      # --output-uri
-      define_option('-o URI', '--output=URI', 'set output directory URI') do |uri|
-        @output_uri = URI.parse(uri)
-      end
+        # --stream
+        option('--stream', 'turn on stream mode') do |data|
+          data[:stream] = true
+        end
 
-      # --log
-      define_option('--log=PATH', 'set log path') do |path|
-        @log_path = path
-      end
+        # --request-task-worker
+        option('--request-task-worker=N', 'set request number of task workers') do |data, n|
+          data[:request_task_worker] = n.to_i
+        end
 
-      # --stream
-      define_option('--stream', 'turn on stream mode') do
-        @stream = true
-      end
+        # --params
+        option('--params="{Var:1,...}"', "set &main:Main rule's parameters") do |data, str|
+          begin
+            params = DocumentTransformer.new.apply(
+              DocumentParser.new.parameters.parse(str)
+            )
+            data[:params].merge!(params)
+          rescue Parslet::ParseFailed => e
+            puts "invalid parameters: " + str
+            Util::ErrorReport.print(e)
+            abort
+          end
+        end
 
-      # --request-task-worker
-      define_option('--request-task-worker=N', 'set request number of task workers') do |n|
-        @request_task_worker = n.to_i
-      end
+        # --stand-alone
+        option('--stand-alone', 'turn on stand alone mode') do |data|
+          data[:stand_alone] = true
+          data[:without_tuple_space_provider] = true
+        end
 
-      # --params
-      define_option('--params="{Var:1,...}"', "set &main:Main rule's parameters") do |str|
-        begin
-          params = DocumentTransformer.new.apply(
-            DocumentParser.new.parameters.parse(str)
-          )
-          @params.merge!(params)
-        rescue Parslet::ParseFailed => e
-          puts "invalid parameters: " + str
-          Util::ErrorReport.print(e)
-          abort
+        # --dry-run
+        option('--dry-run', 'turn on dry run mode') do |data, b|
+          data[:dry_run] = true
         end
-      end
 
-      # --stand-alone
-      define_option('--stand-alone', 'turn on stand alone mode') do
-        @stand_alone = true
-        @without_tuple_space_provider = true
-      end
+        # --relay
+        option('--relay=URI', 'turn on relay mode and set relay address') do |data, uri|
+          data[:relay] = uri
+        end
 
-      # --dry-run
-      define_option('--dry-run', 'turn on dry run mode') do |b|
-        @dry_run = true
-      end
+        # --name
+        option('--name=NAME') do |data, name|
+          data[:name] = name
+        end
 
-      # --relay
-      define_option('--relay=URI', 'turn on relay mode and set relay address') do |uri|
-        @relay = uri
-      end
+        # --list-parameters
+        option('--list-params', 'show user parameter list in the document') do |data|
+          data[:list_params] = true
+        end
 
-      define_option('--name=NAME') do |name|
-        @name = name
-      end
+        validate do |data|
+          unless data[:task_worker] > 0 or
+              (not(data[:stand_alone]) and data[:task_worker] == 0)
+            abort("option error: invalid resource size '%s'" % data[:task_worker])
+          end
 
-      # --list-parameters
-      define_option('--list-params', 'show user parameter list in the document') do
-        @list_params = true
+          if data[:stream] and data[:input_location].nil?
+            abort("option error: no input URI on stream mode")
+          end
+        end
       end
 
+      attr_reader :task_worker
+      attr_reader :features
       attr_reader :tuple_space_server
       attr_reader :name
 
       def initialize
         super()
-        @input_uri = nil
-        @output_uri = URI.parse("local:./output/")
-        @log_path = "log.txt"
-        @stream = false
-        @params = Parameters.empty
-        @dry_run = false
-        @task_worker = [Util.core_number - 1, 1].max
-        @request_task_worker = 1
         @worker_threads = []
-        @stand_alone = false
-        @relay = nil
-        @filename = "-"
-        @without_tuple_space_provider = false
-        @features = "^Interactive"
-        @list_params = false
+        @tuple_space_server = nil
       end
 
       private
 
-      def validate_options
-        unless @task_worker > 0 or (not(@stand_alone) and @task_worker == 0)
-          abort("option error: invalid resource size '%s'" % @task_worker)
-        end
-
-        if @stream and @input_uri.nil?
-          abort("option error: no input URI on stream mode")
-        end
-
-        if not(@input_uri.nil?)
-          unless @input_uri.pione? and @input_uri.storage?
-            abort("opiton error: bad URI scheme '%s'" % @input_uri)
-          end
-        end
-      end
-
       def create_front
         Front::ClientFront.new(self)
       end
 
-      def prepare
-        super
-
+      prepare do
         @filename = ARGF.filename
 
+        # setup log location
+        @log_location = option[:output_location] + Time.now.strftime("pione_%Y%m%d%H%M%S.log")
+
         @tuple_space_server = TupleSpaceServer.new(
-          task_worker_resource: @request_task_worker
+          task_worker_resource: option[:request_task_worker]
         )
 
         # setup base uri
-        case @output_uri.scheme
-        when "local"
-          FileUtils.makedirs(@output_uri.path)
-          @output_uri = @output_uri.absolute
-        when "dropbox"
+        case option[:output_location]
+        when Location::LocalLocation
+          option[:output_location] = Location[option[:output_location].path.expand_path]
+          option[:output_location].path.mkpath
+        when Location::DropboxLocation
           # start session
           session = nil
           consumer_key = nil
@@ -145,7 +149,7 @@ module Pione
           cache = Pathname.new("~/.pione/dropbox_api.cache").expand_path
           if cache.exist?
             session = DropboxSession.deserialize(cache.read)
-            Resource::Dropbox.set_session(session)
+            Location::Dropbox.set_session(session)
             consumer_key = session.instance_variable_get(:@consumer_key)
             consumer_secret = session.instance_variable_get(:@consumer_secret)
           else
@@ -153,7 +157,7 @@ module Pione
             consumer_key = api["key"]
             consumer_secret = api["secret"]
             session = DropboxSession.new(consumer_key, consumer_secret)
-            Resource::Dropbox.set_session(session)
+            Location::Dropbox.set_session(session)
             authorize_url = session.get_authorize_url
             puts "AUTHORIZING", authorize_url
             puts "Please visit that web page and hit 'Allow', then hit Enter here."
@@ -170,43 +174,38 @@ module Pione
           end
 
           # share access token in tuple space
-          Resource::Dropbox.share_access_token(tuple_space_server, consumer_key, consumer_secret)
+          Location::Dropbox.share_access_token(tuple_space_server, consumer_key, consumer_secret)
         end
 
-        @output_uri = @output_uri.as_directory.to_s
-        @tuple_space_server.set_base_uri(@output_uri)
+        @tuple_space_server.set_base_location(option[:output_location])
       end
 
-      def start
+      start do
         read_process_document
 
-        if @list_params
+        if option[:list_params]
           print_parameter_list
-          exit
+          exit!
         end
 
         write_tuples
-        connect_relay if @relay
+        connect_relay if option[:relay]
         start_agents
 
         # start tuple space provider with thread
         # the thread is terminated when the client terminated
-        unless @without_tuple_space_provider
+        unless option[:without_tuple_space_provider]
           @start_tuple_space_provider_thread = Thread.new do
             start_tuple_space_provider
           end
         end
 
         start_workers
-        @agent = Agent[:process_manager].start(@tuple_space_server, @document, @params, @stream)
+        @agent = Agent[:process_manager].start(@tuple_space_server, @document, option[:params], option[:stream])
         @agent.running_thread.join
-        terminate
       end
 
-      # Terminate pione-client command. Kill tuple space provider.
-      #
-      # @return [void]
-      def terminate
+      terminate do
         Global.monitor.synchronize do
           # kill the thread for starting tuple space provider
           if @start_tuple_space_provider_thread
@@ -215,18 +214,20 @@ module Pione
             end
           end
 
+          @logger.terminate
+
           # terminate tuple space provider
           if @tuple_space_provider
             @tuple_space_provider.terminate
           end
-
-          # go to other termination processes.
-          super
         end
       end
 
       private
 
+      # Read PIONE process document.
+      #
+      # @return [void]
       def read_process_document
         # process definition document is not found.
         if ARGF.filename == "-"
@@ -246,15 +247,21 @@ module Pione
         end
       end
 
+      # Write initial tuples.
+      #
+      # @return [void]
       def write_tuples
         [ Tuple[:process_info].new('standalone', 'Standalone'),
-          Tuple[:dry_run].new(@dry_run)
+          Tuple[:dry_run].new(option[:dry_run])
         ].each {|tuple| @tuple_space_server.write(tuple) }
       end
 
+      # Start agent activities.
+      #
+      # @return [void]
       def start_agents
         # logger
-        Agent[:logger].start(@tuple_space_server, File.open(@log_path, "w+"))
+        @logger = Agent[:logger].start(@tuple_space_server, @log_location)
 
         # rule provider
         @rule_loader = Agent[:rule_provider].start(@tuple_space_server)
@@ -262,34 +269,42 @@ module Pione
         @rule_loader.wait_till(:request_waiting)
 
         # input generators
-        generator_method = @stream ? :start_by_stream : :start_by_dir
+        generator_method = option[:stream] ? :start_by_stream : :start_by_dir
         gen = Agent[:input_generator].send(
-          generator_method, @tuple_space_server, @input_uri
+          generator_method, @tuple_space_server, option[:input_location]
         )
 
         # command listener
         @command_listener = Agent[:command_listener].start(@tuple_space_server, self)
       end
 
-      # Wakes up tuple space provider process and push my tuple space server to
-      # it.
+      # Wake up tuple space provider process and connect my tuple space server
+      # to it.
       def start_tuple_space_provider
         @tuple_space_provider = Pione::TupleSpaceProvider.instance
         @tuple_space_provider.add_tuple_space_server(@tuple_space_server)
       end
 
+      # Start task workers.
+      #
+      # @return [void]
       def start_workers
-        @task_worker.times do
-          Thread.new { Agent[:task_worker].spawn(Global.front, Util.generate_uuid, @features) }
+        option[:task_worker].times do
+          Thread.new {
+            Agent[:task_worker].spawn(Global.front, Util.generate_uuid, option[:features])
+          }
         end
       end
 
+      # Connect relay server.
+      #
+      # @return [void]
       def connect_relay
         Global.relay_tuple_space_server = @tuple_space_server
-        @relay_ref = DRbObject.new_with_uri(@relay)
+        @relay_ref = DRbObject.new_with_uri(option[:relay])
         @relay_ref.__connect
         if Global.show_communication
-          puts "you connected the relay: %s" % @relay
+          puts "you connected the relay: %s" % option[:relay]
         end
         # watchdog for the relay server
         Thread.start do