pione 0.3.2 → 0.4.0

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

@@ -7,99 +7,117 @@ module Pione
       # basic informations
       #
 
-      command_name "pione-tuple-space-viewer"
-      command_banner "Show and search tuples in tuple spaces."
+      define(:name, "pione-tuple-space-viewer")
+      define(:desc, "Show and search tuples in tuple spaces")
 
       #
-      # command options
+      # requirements
       #
 
-      use_option :color
-      use_option :debug
+      require :pp
 
-      define_option(:identifiers) do |item|
+      #
+      # arguments
+      #
+
+      argument(:address) do |item|
+        item.type = :location
+        item.desc = "Tuple space address"
+        item.missing = "You should set tuple space address"
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:identifiers) do |item|
+        item.type  = :string
         item.short = '-i'
-        item.long = '--identifier=NAME'
-        item.desc = 'show tuples that have the identifier'
-        item.default = []
-        item.values = lambda {|name| name}
+        item.long  = '--identifier'
+        item.arg   = 'NAME'
+        item.desc  = 'show tuples that have the identifier'
+
+        item.assign do |val|
+          (model[:identifiers] || []) << val
+        end
       end
 
-      define_option(:exclusions) do |item|
+      option(:exclusions) do |item|
+        item.type = :string
         item.short = '-e'
-        item.long = '--exclude=NAME'
+        item.long = '--exclude'
+        item.arg  = 'NAME'
         item.desc = 'exclude the tuple identifier'
-        item.default = []
-        item.values = lambda {|name| name}
+
+        item.assign do |val|
+          (model[:exclusions] || []) << val
+        end
       end
 
-      define_option(:package) do |item|
-        item.long = '--package=NAME'
+      option(:package) do |item|
+        item.type = :string
+        item.long = '--package'
+        item.arg  = 'NAME'
         item.desc = 'show tuples which domain has the package name'
-        item.value = lambda {|name| name}
       end
 
-      define_option(:rule) do |item|
-        item.long = '--rule=NAME'
+      option(:rule) do |item|
+        item.type = :string
+        item.long = '--rule'
+        item.arg  = 'NAME'
         item.desc = 'show tuples which domain has the rule name'
-        item.value = lambda {|name| name}
       end
 
-      define_option(:rule_path) do |item|
-        item.long = '--rule-path=NAME'
+      option(:rule_path) do |item|
+        item.type = :string
+        item.long = '--rule-path'
+        item.arg  = 'NAME'
         item.desc = 'show tuples which domain has the rule path'
-        item.value = lambda {|path| path}
       end
 
-      define_option(:data_name) do |item|
-        item.long = '--data-name=NAME'
+      option(:data_name) do |item|
+        item.type = :string
+        item.long = '--data-name'
+        item.arg  = 'NAME'
         item.desc = 'show tuples that has the the name'
-        item.value = lambda {|name| name}
       end
 
-      define_option(:bag_type) do |item|
-        item.long = '--type=TYPE'
+      option(:bag_type) do |item|
+        item.type = :symbol
+        item.long = '--type'
+        item.arg  = 'TYPE'
         item.desc = 'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
-        item.value = lambda {|bag_type| bag_type.to_sym}
       end
 
-      define_option(:address) do |item|
-        item.long = '--client=ADDRESS'
+      option(:address) do |item|
+        item.type = :string
+        item.long = '--client '
+        item.arg  = 'ADDRESS'
         item.desc = 'druby address of target client process'
-        item.value = lambda {|address| address}
-      end
-
-      #
-      # instance methods
-      #
-
-      def initialize(*argv)
-        super
-        @tuple_spaces = []
       end
 
       #
       # command lifecycle: setup phase
       #
 
-      setup :pp
-      setup :tuple_space
-
-      def setup_pp
-        require 'pp'
+      phase(:setup) do |item|
+        item << :tuple_space
       end
 
-      def setup_tuple_space
-        unless @argv.size > 0
-          abort("you should set tuple space address")
-        end
+      setup(:tuple_space) do |item|
+        item.desc = "Setup tuple space"
 
-        address = @argv.first
-        @tuple_spaces = get_tuple_space(address)
+        item.assign(:tuple_space) do
+          get_tuple_space(model[:address])
+        end
 
         # the tuple space not found
-        if @tuple_spaces.empty?
-          abort("No tuple space servers.")
+        item.process do
+          test(model[:tuple_spaces].empty?)
+          cmd.abort("No tuple space servers.")
         end
       end
 
@@ -107,40 +125,42 @@ module Pione
       # command lifecycle: execution phase
       #
 
-      execute :print_bag
+      phase(:execution) do |item|
+        item << :print_bag
+      end
 
-      def execute_print_bag
-        @tuple_spaces.each do |address, tuple_space_server|
-          puts "TupleSpaceServer: %s" % address.color(:red)
-          puts "-"*78
-          if option[:bag_type] == :bag or option[:bag_type].nil?
-            puts "*** bag ***"
-            show_bag(tuple_space_server, :bag)
-          end
-          if option[:bag_type] == :read_waiter or option[:bag_type].nil?
-            puts "*** read waiter ***"
-            show_bag(tuple_space_server, :read_waiter)
-          end
-          if option[:bag_type] == :take_waiter or option[:bag_type].nil?
-            puts "*** take waiter ***"
-            show_bag(tuple_space_server, :take_waiter)
-          end
+      execution(:print_bag) do |item|
+        item.desc = "Print tuples in bag"
+
+        item.process do
+          model[:tuple_spaces].each do |address, tuple_space_server|
+            puts "TupleSpaceServer: %s" % address.color(:red)
+            puts "-"*78
+            if option[:bag_type] == :bag or option[:bag_type].nil?
+              puts "*** bag ***"
+              show_bag(tuple_space_server, :bag)
+            end
+            if option[:bag_type] == :read_waiter or option[:bag_type].nil?
+              puts "*** read waiter ***"
+              show_bag(tuple_space_server, :read_waiter)
+            end
+            if option[:bag_type] == :take_waiter or option[:bag_type].nil?
+              puts "*** take waiter ***"
+              show_bag(tuple_space_server, :take_waiter)
+            end
 
-          # summary
-          puts "*** summary ***"
-          puts "task: %s" % tuple_space_server.task_size
-          puts "working: %s" % tuple_space_server.working_size
-          puts "finished: %s" % tuple_space_server.finished_size
-          puts "data: %s" % tuple_space_server.data_size
+            # summary
+            puts "*** summary ***"
+            puts "task: %s" % tuple_space_server.task_size
+            puts "working: %s" % tuple_space_server.working_size
+            puts "finished: %s" % tuple_space_server.finished_size
+            puts "data: %s" % tuple_space_server.data_size
+          end
         end
       end
+    end
 
-      #
-      # helper methods
-      #
-
-      private
-
+    class PioneTupleSpaceViewerContext < Rootage::CommandContext
       # Get a tuple space from the address.
       def get_tuple_space(address)
         ref = DRbObject.new_with_uri(address)
@@ -183,6 +203,8 @@ module Pione
           puts res
         end
       end
+
+      PioneTupleSpaceViewer.define(:process_context_class, PioneTupleSpaceViewerContext)
     end
   end
 end

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

@@ -1,70 +1,70 @@
 module Pione
   module Command
-    # PioneVal command enables you to get evaluation result of PIONE expressions from out of PIONE system.
+    # `PioneVal` is a command that enables to get evaluation value of PIONE
+    # expressions from out side of PIONE system.
     class PioneVal < BasicCommand
       #
-      # basic informations
+      # informations
       #
 
-      command_name "pione-val"
-      command_banner "Get the evaluation result value of the PIONE expression."
-      PioneCommand.add_subcommand("val", self)
+      define(:name, "val")
+      define(:desc, "Get the value of the PIONE expression")
 
       #
-      # options
+      # arguments
       #
 
-      use_option :debug
-
-      define_option(:domain_info) do |item|
-        item.long = '--domain-info=LOCATION'
-        item.desc = 'location of Domain info file'
-        item.default = Location["./domain.dump"]
-        item.value = lambda {|location| Location[location]}
+      argument(:expr) do |item|
+        item.type    = :string
+        item.desc    = "PIONE expression string that is evaluated"
+        item.missing = "There is no expression."
       end
 
       #
-      # command lifecycle: setup phase
+      # options
       #
 
-      setup :expression
-      setup :domain_info
+      option CommonOption.debug
+      option CommonOption.domain_dump_location
 
-      # get expression string
-      def setup_expression
-        @str = @argv.first || abort("error: no expressions")
-      end
+      #
+      # command lifecycle: setup phase
+      #
 
-      # Read a domain info file.
-      def setup_domain_info
-        if option[:domain_info].exist?
-          @domain_info = System::DomainInfo.read(option[:domain_info])
-        end
+      phase(:setup) do |item|
+        item << CommonAction.load_domain_dump
       end
 
       #
       # command lifecycle: execution phase
       #
 
-      execute :evaluate
-      execute :print
+      phase(:execution) do |seq|
+        seq << :evaluation
+        seq << :print
+      end
+
+      execution(:evaluation) do |item|
+        item.desc = "Evaluate expression string as PIONE expression"
+
+        item.assign(:val) do
+          Pione.val(model[:expr], model[:domain_dump])
+        end
 
-      # Evaluate expression string as PIONE expression.
-      def execute_evaluate
-        @val = Pione.val(@str, @domain_info)
-      rescue Lang::UnboundError => e
-        if option[:domain_info].exist?
-          raise
-        else
-          abort("domain info file '%s' not found" % option[:domain_info].uri.to_s)
+        item.exception do |e|
+          cmd.abort(e)
         end
       end
 
-      # Print evaluation result.
-      def execute_print
-        $stdout.puts @val
+      execution(:print) do |item|
+        item.desc = "Print the evaluation value"
+
+        item.process do
+          puts model[:val]
+        end
       end
     end
+
+    PioneCommand.define_subcommand("val", PioneVal)
   end
 end
-

data/lib/pione/command/spawner.rb

@@ -5,48 +5,53 @@ module Pione
     class Spawner
       attr_reader :pid         # PID of spawned child process
       attr_reader :child_front # front URI of spawned child process
+      attr_reader :thread      # watch thread for spawned child process
 
-      def initialize(name)
-        @name = name # callee command name
-        @args = []   # callee command arguments
+      def initialize(model, name)
+        @model = model # caller's model
+        @name = name   # callee command name
+        @argv = []     # callee command arguments
       end
 
       # Spawn the command process.
       def spawn
-        Log::Debug.system("process \"%s\" is spawned with arguments %s" % [@name, @args])
+        Log::Debug.system('process "%{name}" is spawned with arguments %{argv}' % {name: @name, argv: @argv})
 
         # create a new process and watch it
-        pid = Process.spawn(@name, *@args)
-
-        # register PID to front server for termination
-        Global.front.child[pid] = nil if Global.front
+        @pid = Process.spawn(@name, *@argv)
 
         # keep to watch child process
-        thread = Process.detach(pid)
-
-        begin
-          # find child front while child process is alive
-          retriable :on => [SpawnerRetry, Timeout::Error], :tries => 30, :interval => 0.1 do
-            # when process is dead, raise an error
-            if thread.nil? or not(thread.alive?)
-              raise SpawnError.new("%s failed to spawn %s." % [Global.command.command_name, @name])
-            end
+        @thread = Process.detach(@pid)
 
+        # find child front while child process is alive
+        Timeout.timeout(10) do
+          while @thread and @thread.alive? do
             # find front and save its uri and pid
-            @child_front = find_child_front(pid) || (raise SpawnerRetry)
-            @pid = pid
-            @thread = thread
+            if child_front = find_child_front(@pid)
+              @child_front = child_front
 
-            return self
+              return self
+            else
+              sleep 0.1
+            end
           end
-        rescue Exception => e
-          raise SpawnError.new("%s failed to spawn %s: %s" % [Global.command.command_name, @name, e.message])
+
+          # when process is dead, raise an error
+          raise SpawnError.new(@model[:scenario_name], @name, @argv, "child process is dead")
+        end
+      rescue Timeout::Error
+        raise SpawnError.new(@model[:scenario_name], @name, @argv, "timed out")
+      rescue Object => e
+        if e.kind_of?(SpawnError)
+          raise
+        else
+          raise SpawnError.new(@model[:scenario_name], @name, @argv, e.message)
         end
       end
 
       # Append arguments to the command.
-      def option(*args)
-        @args += args
+      def option(*argv)
+        @argv += argv.map {|val| val.to_s}
       end
 
       # Register the block that is executed when the spawned process is terminated.
@@ -63,11 +68,13 @@ module Pione
       # URI to children table of my front, so we get it from my front and create
       # the reference.
       def find_child_front(pid)
-        if child_front_uri = Global.front.child[pid]
-          return DRbObject.new_with_uri(child_front_uri).tap do |front|
+        if child_front_uri = @model[:front].child_front_uri(pid)
+          return DRbObject.new_with_uri(child_front_uri.to_s).tap do |front|
             timeout(1) {front.ping} # test connection
           end
         end
+      rescue Timeout::Error
+        return nil
       end
     end
   end