pione 0.1.2 → 0.1.3

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

@@ -3,38 +3,59 @@ module Pione
     # This is a class for +pione-task-worker+ command. +pione-task-worker+
     # starts a task worker agent with tuple space server.
     class PioneTaskWorker < ChildProcess
-      set_program_name("pione-task-worker") do
-        parent_front = @no_parent_mode ? "nil" : @parent_front.uri
-        "<front=%s, parent-front=%s>" % [Global.front.uri, parent_front]
+      define_info do
+        set_name "pione-task-worker"
+        set_tail {|cmd|
+          "{Front: %s, ParentFront: %s}" % [
+            Global.front.uri, cmd.option[:no_parent_mode] ? "nil" : cmd.option[:parent_front].uri
+          ]
+        }
+        set_banner <<BANNER
+Run task worker process. This command is launched by other processes like
+pione-client or pione-broker.
+BANNER
       end
 
-      set_program_message <<TXT
-Runs task worker process. This command is launched by other processes like
-pione-client or pione-broker.
-TXT
+      define_option do
+        use Option::ChildProcessOption
 
-      use_option_module CommandOption::ChildProcessOption
+        default :features, Model::Feature::EmptyFeature.new
 
-      # --connection-id
-      define_option('--connection-id=ID', 'set connection id') do |id|
-        @connection_id = id
-      end
+        # --connection-id
+        option('--connection-id=ID', 'set connection id') do |data, id|
+          data[:connection_id] = id
+        end
 
-      # --feature
-      define_option('--features="FEATURES"', 'set features') do |features|
-        begin
-          features = DocumentTransformer.new.apply(
-            DocumentParser.new.feature_expr.parse(features)
-          )
-          @features = features
-        rescue Parslet::ParseFailed => e
-          puts "invalid parameters: " + str
-          Util::ErrorReport.print(e)
-          abort
+        # --feature
+        option('--features=FEATURES', 'set features') do |data, features|
+          begin
+            features = DocumentTransformer.new.apply(
+              DocumentParser.new.feature_expr.parse(features)
+            )
+            data[:features] = features
+          rescue Parslet::ParseFailed => e
+            puts "invalid parameters: " + str
+            Util::ErrorReport.print(e)
+            abort
+          end
+        end
+
+        validate do |data|
+          # check requisite options
+          abort("error: no connection id") if data[:connection_id].nil?
+
+          # get the parent front server
+          begin
+            data[: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
       end
 
-      attr_reader :connection_id
       attr_reader :agent
       attr_reader :tuple_space_server
 
@@ -44,50 +65,26 @@ TXT
         Pione::Front::TaskWorkerFront.new(self)
       end
 
-      def validate_options
-        super
-
-        # check requisite options
-        if @connection_id.nil?
-          abort("error: no connection id")
-        end
-
-        # get the parent front server
-        begin
-          @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
-
-      def prepare
-        super
-
-        @tuple_space_server = @parent_front.get_tuple_space_server(@connection_id)
-        @features = Model::Feature::EmptyFeature.new unless @features
-        @agent = Pione::Agent[:task_worker].new(@tuple_space_server, @features)
+      prepare do
+        @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)
 
         # connect caller front
-        @parent_front.add_task_worker_front(Global.front, @connection_id)
+        option[:parent_front].add_task_worker_front(Global.front, option[:connection_id])
 
         abort("pione-task-worker error: no tuple space server") unless @tuple_space_server
 
         # get base uri
-        if @tuple_space_server.base_uri.scheme == "dropbox"
-          Resource::Dropbox.init(@tuple_space_server)
-          unless Resource::Dropbox.ready?
+        if @tuple_space_server.base_location.kind_of?(Location::DropboxLocation)
+          Location::Dropbox.init(@tuple_space_server)
+          unless Location::Dropbox.ready?
             abort("You aren't ready to access Dropbox.")
           end
         end
       end
 
-      def start
-        super
-
+      start do
         # start task worker activity
         @agent.start
         @command_listener.start
@@ -95,18 +92,12 @@ TXT
         # wait...
         begin
           @agent.running_thread.join
-          # terminate
-          terminate
         rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-          terminate
+          # ignore
         end
       end
 
-      # Terminate the task worker. Kill the agent and disconnect from parent
-      # front.
-      #
-      # @return [void]
-      def terminate
+      terminate do
         Global.monitor.synchronize do
           begin
             return if @terminated
@@ -118,7 +109,7 @@ TXT
             end
 
             # disconnect parent front
-            @parent_front.remove_task_worker_front(self, @connection_id)
+            option[:parent_front].remove_task_worker_front(self, option[:connection_id])
 
             # flag
             @terminated = true
@@ -127,7 +118,6 @@ TXT
           rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
             # ignore
           end
-          super
         end
       end
     end

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

@@ -2,86 +2,77 @@ module Pione
   module Command
     # PioneTupleSpaceProvider is for +pione-tuple-space-provider+ command.
     class PioneTupleSpaceProvider < ChildProcess
-      set_program_name("pione-tuple-space-provider") do
-        parent_front = @no_parent_mode ? "nil" : @parent_front.uri
-        "<front=%s, parent-front=%s>" % [Global.front.uri, parent_front]
-      end
-
-      set_program_message <<TXT
-Runs 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.
+      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
-
-      use_option_module CommandOption::TupleSpaceProviderOption
-
-      attr_reader :tuple_space_provider
-
-      def initialize
-        super
-        @parent_front = nil
-        @notifier_addresses = []
       end
 
-      # @api private
-      def validate_options
-        super
+      define_option do
+        use Option::TupleSpaceProviderOption
+
+        default :notifier_addresses, []
 
-        # broadcast addresses
-        @notifier_addresses.each do |uri|
-          unless uri.scheme == "broadcast"
-            abort("error: invalid broadcast address '%s'" % uri.to_s)
+        validate do |data|
+          # broadcast addresses
+          data[:notifier_addresses].each do |uri|
+            unless uri.scheme == "broadcast"
+              abort("error: invalid broadcast address '%s'" % uri.to_s)
+            end
           end
         end
       end
 
+      attr_reader :tuple_space_provider
+
       # @api private
       def create_front
         Pione::Front::TupleSpaceProviderFront.new(self)
       end
 
-      # @api private
-      def prepare
-        super
-
+      prepare do
         # setup notifier addresses
-        unless @notifier_addresses.empty?
-          Global.tuple_space_provider_broadcast_addresses = @notifier_addresses
+        unless option[:notifier_addresses].empty?
+          Global.tuple_space_provider_broadcast_addresses = option[:notifier_addresses]
         end
 
         # make tuple space provider
         @tuple_space_provider = TupleSpaceProvider.new
       end
 
-      # @api private
-      def start
-        super
-
+      start do
         # start provider activity
         @tuple_space_provider.start
 
         begin
           # set my URI to caller front as its provider
-          unless @no_parent_mode
-            @parent_front.set_tuple_space_provider(Global.front.uri)
+          unless option[:no_parent_mode]
+            option[:parent_front].set_tuple_space_provider(Global.front.uri)
           end
 
           # wait
           DRb.thread.join
         rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-          terminate
+          # ignore
         end
       end
 
-      # @api private
-      def terminate
+      terminate do
         Global.monitor.synchronize do
-          @tuple_space_provider.terminate
-          super
+          begin
+            @tuple_space_provider.terminate
+          rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
+            abort
+          end
         end
-      rescue DRb::DRbConnError, DRb::ReplyReaderThreadError
-        abort
       end
     end
   end

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

@@ -1,18 +1,29 @@
 module Pione
   module Command
+    # PioneTupleSpaceReceiver is a command that launchs tuple space receiver
+    # agent.
     class PioneTupleSpaceReceiver < ChildProcess
-      set_program_name("pione-tuple-space-receiver") do
-        parent_front = @no_parent_mode ? "nil" : @parent_front.uri
-        "<front=%s, parent=%s>" % [Global.front.uri, parent_front]
-      end
-
-      set_program_message <<TXT
-Runs tuple space receiver process for receiving tuple space presence
+      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
+      end
 
-      use_option_module CommandOption::TupleSpaceReceiverOption
+      define_option do
+        use Option::PresenceNotifierOption
+
+        option("--presence-port=PORT", "set presence port number") do |data, port|
+          Global.presence_port = port.to_i
+        end
+      end
 
       attr_reader :tuple_space_receiver
 
@@ -20,39 +31,30 @@ TXT
         Front::TupleSpaceReceiverFront.new(self)
       end
 
-      def prepare
-        super
+      prepare do
         @tuple_space_receiver = TupleSpaceReceiver.new
       end
 
-      def start
-        super
+      start do
+        begin
+          # start provider activity
+          @tuple_space_receiver.start
 
-        # start provider activity
-        @tuple_space_receiver.start
+          # 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
 
-        # set my uri to parent front as its provider
-        unless @no_parent_mode
-          @parent_front.set_tuple_space_receiver(Global.front.uri)
+          # wait
+          DRb.thread.join
+        rescue DRb::ReplyReaderThreadError => e
+          # ignore reply reader error
         end
-
-        # wait
-        DRb.thread.join
-      rescue DRb::ReplyReaderThreadError => e
-        # ignore reply reader error
       end
 
-      # Terminate the tuple space recevier.
-      #
-      # @return [void]
-      def terminate
+      terminate do
         Global.monitor.synchronize do
-          begin
-            @tuple_space_receiver.terminate
-          rescue DRb::DRbConnError
-            # ignore
-          end
-          super
+          @tuple_space_receiver.terminate
         end
       end
     end

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

@@ -1,55 +1,58 @@
 module Pione
   module Command
+    # PioneTupleSpaceView is a command that shows and searchs tuples in tuple
+    # spaces.
     class PioneTupleSpaceViewer < BasicCommand
-      set_program_name("pione-tuple-space-viewer")
-
-      define_option('-i', '--identifier=NAME', 'show tuples that have the identifier') do |name|
-        @identifiers << name
+      define_info do
+        set_name "pione-tuple-space-viewer"
+        set_banner "Show and search tuples in tuple spaces."
       end
 
-      define_option('-e', '--exclude=NAME', 'exclude the tuple identifier') do |name|
-        @exclusions << name
-      end
+      define_option do
+        default :identifiers, []
+        default :exclusions, []
 
-      define_option('--package=NAME', 'show tuples which domain has the package name') do |name|
-        @package = name
-      end
+        option('-i', '--identifier=NAME', 'show tuples that have the identifier') do |data, name|
+          data[:identifiers] << name
+        end
 
-      define_option('--rule=NAME', 'show tuples which domain has the rule name') do |name|
-        @rule = name
-      end
+        option('-e', '--exclude=NAME', 'exclude the tuple identifier') do |data, name|
+          data[:exclusions] << name
+        end
 
-      define_option('--rule-path=NAME', 'show tuples which domain has the rule path') do |path|
-        @rule_path = path
-      end
+        option('--package=NAME', 'show tuples which domain has the package name') do |data, name|
+          data[:package] = name
+        end
 
-      define_option('--data-name=NAME', 'show tuples that has the the name') do |name|
-        @data_name = name
-      end
+        option('--rule=NAME', 'show tuples which domain has the rule name') do |data, name|
+          data[:rule] = name
+        end
 
-      define_option(
-        '--type=TYPE',
-        'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
-      ) do |bag_type|
-        @bag_type = bag_type.to_sym
-      end
+        option('--rule-path=NAME', 'show tuples which domain has the rule path') do |data, path|
+          data[:rule_path] = path
+        end
+
+        option('--data-name=NAME', 'show tuples that has the the name') do |data, name|
+          data[:data_name] = name
+        end
+
+        option(
+          '--type=TYPE',
+          'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
+        ) do |data, bag_type|
+          data[:bag_type] = bag_type.to_sym
+        end
 
-      define_option('--client=ADDRESS', 'druby address of target client process') do |address|
-        @address = address
+        option('--client=ADDRESS', 'druby address of target client process') do |data, address|
+          data[:address] = address
+        end
       end
 
       def initialize
-        @identifiers = []
-        @exclusions = []
-        @package = nil
-        @rule = nil
-        @rule_path = nil
-        @data_name = nil
-        @bag_type = nil
         @tuple_space_servers = []
       end
 
-      def prepare
+      prepare do
         require 'pp'
         find_tuple_space_servers
 
@@ -59,20 +62,20 @@ module Pione
         end
       end
 
-      def start
+      start do
         # print each bags
         @tuple_space_servers.each do |address, tuple_space_server|
           puts "TupleSpaceServer: %s" % Terminal.red(address)
           puts "-"*78
-          if @bag_type == :bag or @bag_type.nil?
+          if option[:bag_type] == :bag or option[:bag_type].nil?
             puts "*** bag ***"
             show_bag(tuple_space_server, :bag)
           end
-          if @bag_type == :read_waiter or @bag_type.nil?
+          if option[:bag_type] == :read_waiter or option[:bag_type].nil?
             puts "*** read waiter ***"
             show_bag(tuple_space_server, :read_waiter)
           end
-          if @bag_type == :take_waiter or @bag_type.nil?
+          if option[:bag_type] == :take_waiter or option[:bag_type].nil?
             puts "*** take waiter ***"
             show_bag(tuple_space_server, :take_waiter)
           end
@@ -88,14 +91,20 @@ module Pione
 
       private
 
+      # Find tuple space servers.
+      #
+      # @return [void]
       def find_tuple_space_servers
-        if @address
-          @tuple_space_servers << [@address, get_tuple_space_server(@address)]
+        if option[:address]
+          @tuple_space_servers << [option[:address], get_tuple_space_server(option[:address])]
         else
           find_tuple_space_servers_in_range
         end
       end
 
+      # Find tuple space server in some port range. This scans ports of the address.
+      #
+      # @return [void]
       def find_tuple_space_servers_in_range
         Global.client_front_port_range.each do |port|
           begin
@@ -107,31 +116,38 @@ module Pione
         end
       end
 
-      # Gets a tuple space server from the address.
+      # Get a tuple space server from the address.
       def get_tuple_space_server(address)
         ref = DRbObject.new_with_uri(address)
         ref.ping
         ref.tuple_space_server
       end
 
+      # Show tuples of the typed bag in the tuple space server.
+      #
+      # @param tuple_space_server [TupleSpaceServer]
+      #   tuple space server
+      # @param type [Symbol]
+      #   bag type
+      # @return [void]
       def show_bag(tuple_space_server, type)
         tuple_space_server.all_tuples(type).each do |tuple|
-          next if not(@identifiers.empty?) and not(@identifiers.include?(tuple.first.to_s))
-          next if @exclusions.include?(tuple.first.to_s)
+          next if not(option[:identifiers].empty?) and not(option[:identifiers].include?(tuple.first.to_s))
+          next if option[:exclusions].include?(tuple.first.to_s)
 
           t = Tuple.from_array(tuple)
 
           # rule_path
-          if @rule_path
+          if option[:rule_path]
             if t.respond_to?(:domain)
-              next unless /^(#{@rule_path})/.match(t.domain)
+              next unless /^(#{option[:rule_path]})/.match(t.domain)
             else
               next
             end
           end
 
           # name
-          if @data_name
+          if option[:data_name]
             if t.kind_of?(Tuple::Data) and t.respond_to?(:name)
               next unless Model::DataExpr.new(@data_name).match(t.name)
             else