pione 0.2.0 → 0.2.1

data/lib/pione.rb

@@ -58,13 +58,7 @@ require 'pione/patch/rinda-patch'
 require 'pione/patch/uri-patch'
 require 'pione/patch/monitor-patch'
 
-# uri-scheme
-require 'pione/uri-scheme/basic-scheme'
-require 'pione/uri-scheme/local-scheme'
-require 'pione/uri-scheme/dropbox-scheme'
-require 'pione/uri-scheme/broadcast-scheme'
-require 'pione/uri-scheme/myftp-scheme'
-
+require 'pione/uri-scheme'
 require 'pione/location'
 require 'pione/log'
 require 'pione/system'
@@ -136,9 +130,6 @@ require 'pione/front/tuple-space-provider-front'
 require 'pione/front/tuple-space-receiver-front'
 require 'pione/front/relay-front'
 
-# command-option
-require 'pione/option'
-
 # command
 require 'pione/command'
 

data/lib/pione/agent/process-manager.rb

@@ -8,12 +8,12 @@ module Pione
       define_state_transition :sleeping => :running
       define_state_transition :running => :sleeping
 
-      attr_reader :document
+      attr_reader :package
 
-      def initialize(tuple_space_server, document, params, stream)
-        raise ArgumentError unless document.main
+      def initialize(tuple_space_server, package, params, stream)
+        raise ArgumentError unless package.find_rule("Main")
         super(tuple_space_server)
-        @document = document
+        @package = package
         @params = params
         @stream = stream
       end
@@ -23,7 +23,8 @@ module Pione
       end
 
       def transit_to_running
-        if handler = @document.root_rule(@params).make_handler(tuple_space_server)
+        root = @package.create_root_rule(@package.find_rule("Main"), @params)
+        if handler = root.make_handler(tuple_space_server)
           handler.handle
         else
           user_message "error: no inputs"

data/lib/pione/agent/rule-provider.rb

@@ -14,15 +14,13 @@ module Pione
         end
       end
 
-      def read_document(doc)
-        doc.rules.each do |rule_path, rule|
-          add_rule(rule_path, rule)
-        end
-      end
-
-      def add_rule(rule_path, content)
-        raise ArgumentError unless content.kind_of?(Component::Rule)
-        @table[rule_path] = content
+      # Read rules from the document or the package.
+      #
+      # @param document [Component::Document,Component::Package]
+      #   document or package
+      # @return [void]
+      def read_rules(document)
+        document.rules.each {|rule| @table[rule.path] = rule}
       end
 
       # Return known rule pathes.

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

@@ -52,7 +52,7 @@ module Pione
         unless thread.alive?
           Process.abort("You cannot run pione-task-worker.")
         end
-        return thread
+        return Util::ProcessInfo.new(pid, thread)
       end
 
       define_state :task_waiting

data/lib/pione/command.rb

@@ -3,6 +3,7 @@ module Pione
   module Command; end
 end
 
+require 'pione/command/option'
 require 'pione/command/basic-command'
 require 'pione/command/front-owner-command'
 require 'pione/command/daemon-process'

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

@@ -48,63 +48,10 @@ module Pione
       end
     end
 
-    # CommandOption is a class for holding option data set.
-    class CommandOption < PioneObject
-      def_delegators :@data, :[], :[]=
-
-      # Creata a command option context.
-      #
-      # @param command_info [CommandInfo]
-      #   command informations
-      def initialize(command_info)
-        extend Option::OptionInterface
-        @command_info = command_info
-        @data = {}
-      end
-
-      # Parse the command options.
-      #
-      # @return [void]
-      def parse
-        OptionParser.new do |opt|
-          # set banner
-          opt.banner = "Usage: %s [options]" % opt.program_name
-          opt.banner << "\n" + @command_info.banner if @command_info.banner
-
-          # set version
-          opt.version = Pione::VERSION
-
-          # set default values
-          default_table.each do |key, value|
-            @data[key] = value
-          end
-
-          # set options
-          definitions.sort{|a,b| a.first <=> b.first}.each do |args, b|
-            opt.on(*args, Proc.new{|*args| self.instance_exec(@data, *args, &b)})
-          end
-        end.parse!(ARGV)
-      rescue OptionParser::InvalidOption => e
-        e.args.each {|arg| $stderr.puts "Unknown option: %s" % arg }
-        abort
-      rescue OptionParser::MissingArgument => e
-        abort(e.message)
-      end
-
-      # Check validness of the command options.
-      #
-      # @return [void]
-      def check
-        validators.each do |validator|
-          validator.call(@data)
-        end
-      end
-    end
-
     # BasicCommand is a base class for PIONE commands.
     class BasicCommand < PioneObject
       @info = CommandInfo.new
-      @option = CommandOption.new(@info).tap {|x| x.use Option::CommonOption}
+      @option = Option.new(@info.name, @info.banner)
       @pre_preparations = []
       @preparations = []
       @post_preparations = []
@@ -133,7 +80,7 @@ module Pione
           parent_option = self.option
           subclass.instance_eval do
             @info = CommandInfo.new
-            @option = CommandOption.new(@info).tap {|x| x.use parent_option}
+            @option = Option.new(@info.name, @info.banner)
           end
           setter = lambda{|name, data| subclass.instance_variable_set(name, data.clone)}
           setter.call(:@pre_preparations, self.pre_preparations)
@@ -232,25 +179,15 @@ module Pione
         # Run the command.
         #
         # @return [void]
-        def run(*args)
-          self.new(*args).run
+        def run(argv)
+          self.new(argv).run
         end
       end
 
-      # Return a command option.
-      #
-      # @return [CommandOption]
-      #   command option
-      def option
-        self.class.option
-      end
+      forward! :class, :option, :info
 
-      # Return a command info.
-      #
-      # @return [CommandInfo]
-      #   command info
-      def info
-        self.class.info
+      def initialize(argv)
+        @argv = argv
       end
 
       # Run the command.
@@ -273,11 +210,7 @@ module Pione
         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?
-            begin
-              receiver.instance_eval(&proc)
-            rescue Object => e
-              Util::ErrorReport.print e
-            end
+            receiver.instance_eval(&proc)
           end
         end
         caller.call(:pre_terminations)
@@ -295,8 +228,10 @@ module Pione
           end
         end
 
+        Signal.trap(:TERM) { call_terminations }
+
         # parse options
-        option.parse
+        option.parse(@argv)
       end
 
       prepare do
@@ -312,7 +247,7 @@ module Pione
       terminate(:post) do
         Global.monitor.synchronize do
           # exit with no exception
-          exit!
+          exit Global.exit_status
         end
       end
     end

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

@@ -4,23 +4,29 @@ module Pione
     # processes.
     class ChildProcess < FrontOwnerCommand
       define_option do
-        default :no_parent_front, false
-
-        # --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
+        define(:parent_front) do |item|
+          item.long = '--parent-front=URI'
+          item.desc = 'set parent front URI'
+          item.default = false
+          item.action = proc do |option, uri|
+            option[:parent_front] = DRbObject.new_with_uri(uri)
+          end
         end
 
-        validate do |data|
-          if not(data[:no_parent_mode]) and data[:parent_front].nil?
-            abort("option error: no caller front address")
+        define(:no_parent) do |item|
+          item.long = '--no-parent'
+          item.desc = 'turn on no parent mode'
+          item.default = false
+          item.action = proc do |option|
+            option[:no_parent_mode] = true
           end
         end
+
+        # validate do |option|
+        #   if not(option[:no_parent_mode]) and option[:parent_front].nil?
+        #     abort("option error: no caller front address")
+        #   end
+        # end
       end
 
       prepare do

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

@@ -2,15 +2,6 @@ module Pione
   module Command
     # DaemonProcess is a class for commands that enable to daemonize.
     class DaemonProcess < FrontOwnerCommand
-      define_option do
-        default :daemon, false
-
-        # --daemon
-        option("--daemon", "turn on daemon mode") do |data|
-          data[:daemon] = true
-        end
-      end
-
       prepare(:post) do
         Process.daemon(true, true) if option[:daemon]
       end

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

@@ -2,12 +2,6 @@ module Pione
   module Command
     # FrontOwnerCommand is a parent of classes that own front server.
     class FrontOwnerCommand < BasicCommand
-      define_option do
-        option("--my-ip-address=ADDRESS", "set my IP address") do |data, address|
-          Global.my_ip_address = address
-        end
-      end
-
       prepare do
         Global.front = create_front
       end

data/lib/pione/command/option.rb

@@ -0,0 +1,243 @@
+module Pione
+  module Command
+    # OptionItem is an option item for PIONE command.
+    class OptionItem < StructX
+      member :name
+      member :short
+      member :long
+      member :desc
+      member :default
+      member :value
+      member :values
+      member :action
+      member :validator
+    end
+
+    # OptionInterface provides basic methods for option modules. All option
+    # modules should be extended by this.
+    module OptionInterface
+      attr_reader :items
+
+      # Define a new option for the command.
+      #
+      # @param args [Array]
+      #   OptionParser arguments
+      # @param b [Proc]
+      #   option action
+      # @return [void]
+      def define(name, &b)
+        item = OptionItem.new.tap do |item|
+          item.name = name
+          b.call(item)
+        end
+
+        if self.kind_of?(Module)
+          singleton_class.send(:define_method, name) {item}
+        else
+          @items << item
+        end
+      end
+
+      # Install the option module.
+      #
+      # @param mod [Module]
+      #   PIONE's option set modules
+      # @return [void]
+      def use(item_name)
+        @items << CommonOption.send(item_name)
+      end
+    end
+
+    # CommandOption is a class for holding option data set.
+    class Option
+      forward! :@option, :"[]", :"[]="
+
+      # Creata a command option context.
+      #
+      # @param command_info [CommandInfo]
+      #   command informations
+      def initialize(program_name, banner)
+        extend OptionInterface
+        @program_name = program_name
+        @banner = banner
+        @option = {}
+        @items = []
+        @validators = []
+      end
+
+      def item(name)
+        @items.find {|item| item.name == name}
+      end
+
+      # Parse the command options.
+      #
+      # @return [void]
+      def parse(argv)
+        OptionParser.new do |opt|
+          # set banner
+          opt.banner = "Usage: %s [options]" % @program_name
+          opt.banner << "\n" + @banner if @banner
+
+          # set version
+          opt.program_name = @program_name
+          opt.version = Pione::VERSION
+
+          # default values
+          @items.each {|item| @option[item.name] = item.default if item.default}
+
+          # setup option parser
+          @items.sort{|a,b| a.long <=> b.long}.each {|item| setup_item(opt, item)}
+        end.parse!(argv)
+      rescue OptionParser::InvalidOption => e
+        e.args.each {|arg| $stderr.puts "Unknown option: %s" % arg }
+        abort
+      rescue OptionParser::MissingArgument => e
+        abort(e.message)
+      end
+
+      def default(name, value)
+        @option[name] = value
+      end
+
+      def validate(&b)
+        @validators << b
+      end
+
+      # Check validness of the command options.
+      #
+      # @return [void]
+      def check
+        @validators.each do |validator|
+          validator.call(@option)
+        end
+      end
+
+      private
+
+      SETUP_ITEM_LIST = [
+        :setup_item_action,
+        :setup_item_values,
+        :setup_item_value,
+        :setup_item_static_value
+      ]
+
+      # Setup the option item.
+      def setup_item(opt, item)
+        defs = [item.short, item.long, item.desc].compact
+        SETUP_ITEM_LIST.find {|name| send(name, opt, item, defs)}
+      end
+
+      def setup_item_action(opt, item, defs)
+        if item.action
+          opt.on(*defs, Proc.new{|*args| self.instance_exec(@option, *args, &item.action)})
+        end
+      end
+
+      def setup_item_values(opt, item, defs)
+        if item.values.kind_of?(Proc)
+          opt.on(*defs, Proc.new{|*args| @option[item.name] << self.instance_exec(*args, &item.values)})
+        end
+      end
+
+      def setup_item_value(opt, item, defs)
+        if item.value.kind_of?(Proc)
+          opt.on(*defs, Proc.new{|*args| @option[item.name] = self.instance_exec(*args, &item.value)})
+        end
+      end
+
+      def setup_item_static_value(opt, item, defs)
+        if item.value
+          opt.on(*defs, Proc.new{ @option[item.name] = item.value})
+        end
+      end
+    end
+
+    # CommonOption provides common options for pione commands.
+    module CommonOption
+      extend OptionInterface
+
+      define(:color) do |item|
+        item.long = '--[no-]color'
+        item.desc = 'turn on/off color mode'
+        item.action = proc {|_, bool| Sickill::Rainbow.enabled = bool}
+      end
+
+      define(:daemon) do |item|
+        item.long = "--daemon"
+        item.desc = "turn on daemon mode"
+        item.default = false
+        item.value = true
+      end
+
+      define(:debug) do |item|
+        item.long = '--debug'
+        item.desc = "turn on debug mode"
+        item.action = proc {Pione.debug_mode = true}
+      end
+
+      define(:features) do |item|
+        item.long = '--features=FEATURES'
+        item.desc = 'set features'
+        item.value = proc {|features| features}
+      end
+
+      define(:my_ip_address) do |item|
+        item.long = "--my-ip-address=ADDRESS"
+        item.desc = "set my IP address"
+        item.action = proc {|_, address| Global.my_ip_address = address}
+      end
+
+      define(:no_parent) do |item|
+        item.long = '--no-parent'
+        item.desc = 'turn on no parent mode'
+        item.action = proc {|option| option[:no_parent_mode] = true}
+      end
+
+      define(:parent_front) do |item|
+        item.long = '--parent-front=URI'
+        item.desc = 'set parent front URI'
+        item.action = proc do |option, uri|
+          option[:parent_front] = DRbObject.new_with_uri(uri)
+        end
+      end
+
+      define(:presence_notification_address) do |item|
+        item.long = "--presence-notification-address=255.255.255.255:%s" % Global.presence_port
+        item.desc = "set the address for sending presence notifier"
+        item.action = proc do |_, address|
+          # clear addresses at first time
+          unless @__option_notifier_address__
+            @__option_notifier_address__ = true
+            Global.presence_notification_addresses = []
+          end
+          # add the address
+          address = address =~ /^broadcast/ ? address : "broadcast://%s" % address
+          uri = URI.parse(address)
+          uri.host = "255.255.255.255" if uri.host.nil?
+          uri.port = Global.presence_port if uri.port.nil?
+          Global.presence_notification_addresses << uri
+        end
+      end
+
+      define(:show_communication) do |item|
+        item.long = '--show-communication'
+        item.desc = "show object communication"
+        item.action = proc {Global.show_communication = true}
+      end
+
+      define(:show_presence_notifier) do |item|
+        item.long = "--show-presence-notifier"
+        item.desc = "show presence notifier informations"
+        item.action = proc {Global.show_presence_notifier = true}
+      end
+
+      define(:task_worker) do |item|
+        item.short = '-t N'
+        item.long = '--task-worker=N'
+        item.desc = 'set task worker number that this process creates'
+        item.default = Agent::TaskWorker.default_number
+        item.value = proc {|n| n.to_i}
+      end
+    end
+  end
+end