pione 0.3.2 → 0.4.0

data/lib/pione/command/common.rb

@@ -0,0 +1,198 @@
+module Pione
+  module Command
+    class BasicItem < StructX
+      # `name` is item name. This is used as a reference at controller.
+      member :name
+
+      # Attribute name in model.
+      member :model_name
+
+      # The action's description, this is shown in verbose help.
+      member :desc
+
+      # Context class, instance of this class is used as context of
+      # process. This context class should inherit `ProcessContext`.
+      member :context
+
+      # Processes, this includes blocks that is definded by #define_process,
+      # #define_assignment, and #define_condition
+      member :processes, :default => lambda {[]}
+
+      # Exception handlers.
+      member :exception_handlers, :default => lambda {[]}
+
+      # Define a process that is executed just after pre-process. This is used
+      # for setting values excluding command model, for example global values.
+      #
+      # @yieldparam val [Object]
+      #   arbitrary value, this is passed from #execute
+      def process(&block)
+        self.processes << Proc.new do |cmd, args|
+          catch(:failure) do
+            create_context(cmd).instance_exec(*args, &block)
+          end
+        end
+      end
+
+      # Define an assignment process. This assigns the result value of the block
+      # to model. This is same as #action excluding model assignment.
+      #
+      # @param name [Symbol]
+      #   attribute name in model
+      # @yieldparam val [Object]
+      #   normalized option value
+      def assign(name=(self.model_name || self.name), &block)
+        self.processes << Proc.new do |cmd, args|
+          catch(:failure) do
+            res = create_context(cmd).instance_exec(cmd, *args, &block)
+            if name
+              cmd.model[name] = res
+            end
+          end
+        end
+      end
+
+      # Define a condition. This is a process simply, but goes to quit the whale
+      # action halfway if it fails.
+      #
+      # @yieldparam val [Object]
+      #   arbitrary value, this is passed from #execute
+      def condition(&block)
+        self.processes << Proc.new do |cmd, args|
+          res = catch(:failure) do
+            create_context(cmd).instance_exec(*args, &block)
+            true
+          end
+          throw :quit unless res
+        end
+      end
+
+      # Define an exception handler.
+      #
+      # @param exceptions [Array<Class>]
+      #   exception classes that handler should handle, that is assumed `StandardError` if empty
+      # @yieldparam e [Exception]
+      #   raised exception object
+      # @yieldparam args [Array]
+      #   arbitrary objects
+      def exception(*exceptions, &block)
+        if exceptions.empty?
+          exceptions = [StandardError]
+        end
+        self.exception_handlers << ExceptionHandler.new(exceptions, block)
+      end
+
+      # Copy the object. This is shallow copy, but arrays are cloned.
+      #
+      # @return [Command::BasicItem]
+      #   copied object
+      def copy
+        self.class.new.tap do |obj|
+          self.each_pair do |key, val|
+            obj.set(key => val.is_a?(Array) ? val.clone : val)
+          end
+        end
+      end
+
+      # Execute the action.
+      #
+      # @param cmd [Command::PlainCommand]
+      #   command
+      # @param args [Array]
+      #   arbitrary objects, this is passed to process's block
+      # @return [void]
+      def execute(cmd, *args)
+        # catch "quit" message here
+        catch(:quit) do
+          processes.each {|block| block.call(cmd, args)}
+        end
+      rescue Exception => e
+        exception_handlers.find do |handler|
+          catch(:failure) { handler.try_to_handle(create_context(cmd), e, args) }
+        end
+      end
+
+      private
+
+      # Create a context object for processing.
+      #
+      # @param cmd [Command::PlainCommand]
+      # @return [ProcessContext]
+      #   a context object for processing
+      def create_context(cmd)
+        (self.context || ProcessContext).new(cmd)
+      end
+    end
+
+    module CollectionInterface
+      attr_reader :items
+
+      def item_class
+        raise NotImplemented
+      end
+
+      # Define a new item.
+      def define(name, &b)
+        item = item_class.new.tap do |item|
+          item.name = name
+          b.call(item)
+        end
+
+        @items ||= []
+        @items << item
+
+        # define a getter method if this is a module
+        if self.kind_of?(Module)
+          singleton_class.send(:define_method, name) {item}
+        end
+      end
+
+      # Use the item as command option. If block is given, apply the block with
+      # cloned item and use it.
+      #
+      # @param item [OptionItem]
+      #   option item
+      # @yield [item]
+      #   the cloned item
+      def use(item, &b)
+        unless item.kind_of?(item_class)
+          raise ArgumentError.new(item)
+        end
+
+        if block_given?
+          _item = item.copy
+          b.call(_item)
+          @items << _item
+        else
+          @items << item
+        end
+
+        # define a getter method if this is a module
+        if self.kind_of?(Module)
+          singleton_class.send(:define_method, name) {item}
+        end
+      end
+    end
+
+    # `ExceptionHandler` is a handler of exception for action item.
+    class ExceptionHandler
+      def initialize(exceptions, block)
+        @exceptions = exceptions
+        @block = block
+      end
+
+      def try_to_handle(context, e, *args)
+        if @exceptions.any?{|ec| e.kind_of?(ec)}
+          handle(context, e, *args)
+          return true
+        end
+
+        return false
+      end
+
+      def handle(context, e, *args)
+        context.instance_exec(e, *args, &@block)
+      end
+    end
+  end
+end

data/lib/pione/command/option.rb

@@ -1,256 +1,211 @@
 module Pione
   module Command
-    # OptionItem is an option item for PIONE command.
-    class OptionItem < StructX
-      member :name      # option name
-      member :short     # short option (same as standard OptionParser)
-      member :long      # long option (same as standard OptionParser)
-      member :desc      # option description (same as standard OpionParser)
-      member :default   # default value
-      member :value     # value
-      member :values    # ???
-      member :action    # option action
-      member :validator # option validator
-      member :requisite # requisite option flag
-    end
+    # CommonOption provides common options for almost pione commands.
+    module CommonOption
+      extend Rootage::OptionCollection
 
-    # OptionInterface provides basic methods for option modules. All option
-    # modules should be extended by this.
-    module OptionInterface
-      attr_reader :items
+      define(:color) do |item|
+        item.type = :boolean
+        item.long = '--color'
+        item.arg  = 'BOOLEAN'
+        item.desc = 'Turn on/off color mode'
 
-      # Define a new option for the command.
-      def define(name, &b)
-        item = OptionItem.new.tap do |item|
-          item.name = name
-          b.call(item)
-        end
+        item.process {|val| Global.color_enabled = val}
+      end
 
-        if self.kind_of?(Module)
-          singleton_class.send(:define_method, name) {item}
-        else
-          @items << item
+      define(:debug) do |item|
+        item.type    = :string
+        item.range   =
+          ["system", "rule_engine", "ignored_exception", "notification", "communication"]
+        item.long    = '--debug'
+        item.arg     = '[TYPE]'
+        item.desc    = "Turn on debug mode about the type"
+        item.default = "system"
+
+        item.process do |type|
+          Global.system_logger.level = :debug
+          case type
+          when "system", nil
+            Global.debug_system = true
+          when "rule_engine"
+            Global.debug_rule_engine = true
+          when "notification"
+            Global.debug_notification = true
+          when "communication"
+            Global.debug_communication = true
+          when "ignored_exception"
+            Global.debug_ignored_exception = true
+          else
+            raise OptionError.new(cmd, 'Unknown debug type "%s"' % type)
+          end
         end
       end
 
-      # Install the option module with configuration +option+.
-      def use(item_name, option={})
-        @items << CommonOption.send(item_name).set(option)
+      define(:features) do |item|
+        item.type = :string
+        item.long = '--features'
+        item.arg  = 'FEATURES'
+        item.desc = 'Set features'
+
+        item.process {|val| Global.features = val}
+
+        item.exception(Parslet::ParseFailed) do |e, val|
+          arg = {features: val, reason: e.message}
+          raise OptionError.new(
+            cmd, 'The feature expression "%{features}" is invalid: %{reason}' % arg
+          )
+        end
       end
-    end
 
-    # OptionDefinition is a class for holding option definitions.
-    class OptionDefinition
-      attr_accessor :parser_mode
-
-      # Creata a command option context.
-      def initialize
-        extend OptionInterface
-        @items = []      # option item definitions
-        @default = {}    # default value table
-        @validators = [] # option validators
-        @parser_mode = :parse!
-      end
+      define(:communication_address) do |item|
+        item.type = :uri
+        item.long = "--communication-address"
+        item.arg  = 'URI'
+        item.desc = "Set the IP address for interprocess communication"
 
-      def item(name)
-        @items.find {|item| item.name == name}
+        item.process {|address| Global.communication_address = address}
       end
 
-      # Parse the command options.
-      def parse(argv, command_name, command_banner)
-        data = Hash.new
-
-        # parse options
-        OptionParser.new do |opt|
-          # set banner
-          opt.banner = "Usage: %s [options]" % command_name
-          opt.banner << "\n\n" + command_banner + "\n" if command_banner
-
-          # set version
-          opt.program_name = command_name
-          opt.version = Pione::VERSION
-
-          # default values
-          @items.each {|item| data[item.name] = item.default if item.default}
-          data.merge!(@default)
-
-          # setup option parser
-          @items.sort{|a,b| a.long <=> b.long}.each {|item| setup_item(command_name, opt, data, item)}
-        end.send(@parser_mode, argv)
+      define(:parent_front) do |item|
+        item.type = :uri
+        item.long = '--parent-front'
+        item.arg  = 'URI'
+        item.desc = 'set parent front URI'
 
-        # check option's validness
-        check(data)
+        item.assign {|uri| DRbObject.new_with_uri(uri.to_s)}
 
-        return data
-      end
+        item.process do |uri|
+          timeout(1) {model[:parent_front].ping}
+        end
 
-      # Define the default value.
-      def default(name, value)
-        @default[name] = value
+        item.exception(Exception) do |e, uri|
+          arg = {name: cmd.name, uri: uri.to_s, reason: e.message}
+          raise HideableOptionError.new(
+            cmd, '"%{name}" has failed to connect to parent front "%{uri}": %{reason}' % arg
+          )
+        end
       end
 
-      def validate(&b)
-        @validators << b
+      define(:task_worker_size) do |item|
+        item.type  = :integer
+        item.short = '-t'
+        item.long  = '--task-worker-size'
+        item.arg   = 'N'
+        item.desc  = 'Set task worker size that this process creates'
+        item.init  = [Util::CPU.core_number - 1, 1].max
       end
 
-      private
-
-      # Setup the option item.
-      def setup_item(command_name, opt, data, item)
-        defs = [item.short, item.long, item.desc].compact
-        [ :setup_item_action,
-          :setup_item_values,
-          :setup_item_value,
-          :setup_item_static_value
-        ].find {|method_name| send(method_name, command_name, opt, data, item, defs)}
-      end
+      define(:domain_dump_location) do |item|
+        item.type = :location
+        item.long = '--domain-dump'
+        item.arg  = 'LOCATION'
+        item.desc = 'Import the domain dump file'
 
-      def setup_item_action(command_name, opt, data, item, defs)
-        if item.action
-          opt.on(*defs, Proc.new{|*args| self.instance_exec(command_name, data, *args, &item.action)})
+        item.process do |location|
+          unless location.exist?
+            raise OptionError.new(
+              cmd, 'The location doesn\'t exist: %{location}' % {location: location}
+            )
+          end
         end
-      end
 
-      def setup_item_values(command_name, opt, data, item, defs)
-        if item.values.kind_of?(Proc)
-          opt.on(*defs, Proc.new{|*args| data[item.name] << self.instance_exec(*args, &item.values)})
+        item.assign(:domain_dump_location) do |location|
+          test(location.file?)
+          location
         end
-      end
 
-      def setup_item_value(command_name, opt, data, item, defs)
-        case item.value
-        when Proc
-          opt.on(*defs, Proc.new{|*args| data[item.name] = self.instance_exec(*args, &item.value)})
-        when :as_is
-          opt.on(*defs, Proc.new{|*args| data[item.name] = args.first})
+        item.assign(:domain_dump_location) do |location|
+          test(location.directory?)
+
+          # find default domain dump file
+          _location = location + System::DomainDump::FILENAME
+          if _location.exist?
+            _location
+          else
+            raise OptionError.new(
+              cmd, 'The location doesn\'t exist: %{location}' % {location: _location}
+            )
+          end
         end
       end
 
-      def setup_item_static_value(command_name, opt, data, item, defs)
-        if item.value
-          opt.on(*defs, Proc.new{ data[item.name] = item.value})
+      define(:file_cache_method) do |item|
+        item.type = :symbol
+        item.long = '--file-cache-method'
+        item.arg  = 'NAME'
+        item.desc = 'use NAME as a file cache method'
+
+        item.process do |name|
+          System::FileCache.set_cache_method(name)
         end
       end
 
-      # Check validness of the command options.
-      def check(data)
-        # check requisite options
-        @items.each do |item|
-          if item.requisite and not(data[item.name])
-            raise OptionError.new("option \"%s\" is requisite" % [item.long])
-          end
-        end
+      define(:file_sliding) do |item|
+        item.type    = :boolean
+        item.long    = '--file-sliding'
+        item.arg     = '[BOOLEAN]'
+        item.desc    = 'Enable/disable to slide files in file server'
+        item.default = true
 
-        # apply validators
-        @validators.each {|validator| validator.call(data)}
+        item.process do |val|
+          Global.file_sliding = val
+        end
       end
     end
 
-    # CommonOption provides common options for pione commands.
-    module CommonOption
-      extend OptionInterface
+    # `NotificationOption` provides for notification options.
+    module NotificationOption
+      extend Rootage::OptionCollection
 
-      define(:color) do |item|
-        item.long = '--[no-]color'
-        item.desc = 'turn on/off color mode'
-        item.action = proc {|_, _, bool|
-          Global.color_enabled = bool
-          Sickill::Rainbow.enabled = bool
-        }
-      end
+      define(:notification_targets) do |item|
+        item.type = :string
+        item.long = '--notification-target'
+        item.arg  = 'URI'
+        item.desc = 'Target address that notifications are sent to'
+        item.init = Global.notification_targets
 
-      define(:daemon) do |item|
-        item.long = "--daemon"
-        item.desc = "turn on daemon mode"
-        item.default = false
-        item.value = true
-      end
+        item.assign(:__defined_notification_targets__) do |address|
+          test(not(model[:__defined_notification_targets__]))
 
-      define(:debug) do |item|
-        item.long = '--debug[=TYPE]'
-        item.desc = "turn on debug mode about the type(system / rule_engine / ignored_exception / presence_notifier / communication)"
-        item.action = proc {|command_nane, _, type|
-          Global.system_logger.level = :debug
-          case type
-          when "system", nil
-            Global.debug_system = true
-          when "rule_engine"
-            Global.debug_rule_engine = true
-          when "presence_notification"
-            Global.debug_presence_notification = true
-          when "communication"
-            Global.debug_communication = true
-          when "ignored_exception"
-            Global.debug_ignored_exception = true
+          Global.notification_targets.clear
+          true
+        end
+
+        item.process do |address|
+          uri = Notification::Address.target_address_to_uri(address.strip)
+          if ["pnb", "pnm", "pnu"].include?(uri.scheme)
+            Global.notification_targets << uri
           else
-            raise OptionError.new("option error: unknown debug type \"=%s\"" % type)
+            cmd.abort('"%s" seems not to be a notification address.' % address)
           end
-        }
+        end
       end
 
-      define(:features) do |item|
-        item.long = '--features=FEATURES'
-        item.desc = 'set features'
-        item.action = proc {|command_name, option, features|
-          begin
-            # store features
-            Global.features = features
-          rescue Parslet::ParseFailed => e
-            raise OptionError.new(
-              "invalid feature expression \"%s\" is given for %s" % [features, command_name]
-            )
-          end
-        }
-      end
+      define(:notification_receivers) do |item|
+        item.type = :string
+        item.long = "--notification-receiver"
+        item.arg  = "URI"
+        item.desc = "Receiver address that notifications are received at"
+        item.init = Global.notification_receivers
 
-      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
+        # clear default notification address
+        item.assign(:__defined_notification_receivers__) do |address|
+          test(not(model[:__defined_notification_receivers__]))
 
-      define(:parent_front) do |item|
-        item.long = '--parent-front=URI'
-        item.desc = 'set parent front URI'
-        item.requisite = true
-        item.action = proc do |command_name, option, uri|
-          begin
-            option[:parent_front] = DRbObject.new_with_uri(uri)
-            timeout(1) {option[:parent_front].ping}
-          rescue Exception => e
-            raise HideableOptionError.new(
-              "%s couldn't connect to parent front \"%s\": %s" % [command_name, uri, e.message]
-            )
-          end
+          Global.notification_receivers.clear
+          true
         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 = []
+        # check the address and append it to receivers
+        item.process do |address|
+          uri = Notification::Address.receiver_address_to_uri(address.strip)
+          if ["pnb", "pnm", "pnu"].include?(uri.scheme)
+            Global.notification_receivers << uri
+          else
+            cmd.abort('"%s" seems not to be a notification address.' % address)
           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(: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 = [Util::CPU.core_number - 1, 1].max
-        item.value = proc {|n| n.to_i}
-      end
     end
   end
 end