pione 0.3.2 → 0.4.0

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

@@ -1,45 +1,28 @@
 module Pione
   module Command
-    # PioneCommand is a facade command for PIONE's various functions.
+    # `PioneCommand` is a facade command for PIONE's various functions.
     class PioneCommand < BasicCommand
-      # subcommand table
-      @subcommand = {}
-
-      class << self
-        attr_reader :subcommand
-
-        # Add the subcommand.
-        def add_subcommand(name, command)
-          @subcommand[name] = command
-        end
-      end
-
       #
       # basic informations
       #
 
-      option_parser_mode :order!
-      command_name "pione"
-      command_banner "PIONE is a rule-based workflow engine."
+      define(:toplevel, true)
+      define(:name, "pione")
+      define(:desc, "PIONE's utility command set")
 
       #
-      # options
+      # requirements
       #
 
-      #
-      # command lifecycle: execution phase
-      #
-
-      execute :subcommand
-
-      def execute_subcommand
-        name = @argv.first
-        if cmd = self.class.subcommand[name]
-          cmd.run(@argv.drop(1))
-        else
-          abort("no such subcommand: %s" % name)
-        end
-      end
+      require 'pione/command/pione-action'
+      require 'pione/command/pione-clean'
+      require 'pione/command/pione-config'
+      require 'pione/command/pione-diagnosis'
+      require 'pione/command/pione-lang'
+      require 'pione/command/pione-log'
+      require 'pione/command/pione-package'
+      require 'pione/command/pione-val'
+      require 'pione/command/pione-compile'
     end
   end
 end

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

@@ -0,0 +1,90 @@
+module Pione
+  module Command
+    # PioneCompile is a subcommand body of "pione compile".
+    class PioneCompile < BasicCommand
+      #
+      # basic informations
+      #
+
+      define(:name, "pione compile")
+      define(:desc, "translate from PNML to PIONE document")
+
+      #
+      # arguments
+      #
+
+      argument(:source) do |item|
+        item.type = :location
+        item.desc = "source PNML file"
+      end
+
+      #
+      # options
+      #
+
+      option(CommonOption.debug)
+
+      option(:flow_name) do |item|
+        item.type = :string
+        item.long = '--flow-name'
+        item.arg  = 'NAME'
+        item.desc = 'Set flow name'
+      end
+
+      option(:package_name) do |item|
+        item.type = :string
+        item.long = '--package-name'
+        item.arg  = 'NAME'
+        item.desc = 'Set package name'
+      end
+
+      option(:editor) do |item|
+        item.type = :string
+        item.long = '--editor'
+        item.arg  = 'NAME'
+        item.desc = 'Set package editor'
+      end
+
+      option(:tag) do |item|
+        item.type = :string
+        item.long = '--tag'
+        item.arg  = 'NAME'
+        item.desc = 'Set package tag'
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :compile_pnml
+        item << :print
+      end
+
+      execution(:compile_pnml) do |item|
+        item.desc = "Compile from PNML to PIONE"
+
+        item.assign(:result) do
+          net = PNML::Reader.read(model[:source])
+          option = {
+            :flow_name => model[:flow_name],
+            :package_name => model[:package_name],
+            :editor => model[:editor],
+            :tag => model[:tag]
+          }
+          PNML::Compiler.new(net, option).compile
+        end
+      end
+
+      execution(:print) do |item|
+        item.desc = "Print the PIONE document"
+
+        item.process do
+          print model[:result]
+        end
+      end
+    end
+
+    PioneCommand.define_subcommand("compile", PioneCompile)
+  end
+end

data/lib/pione/command/pione-config-get.rb

@@ -0,0 +1,53 @@
+module Pione
+  module Command
+    # `PioneConfigGet` is a command for getting a value of PIONE global
+    # variable.
+    class PioneConfigGet < BasicCommand
+      #
+      # basic informations
+      #
+
+      define(:name, "get")
+      define(:desc, "Get a value of PIONE global variable")
+
+      #
+      # arguments
+      #
+
+      argument(:name) do |item|
+        item.type = :string
+        item.desc = "Variable name"
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.debug
+      option PioneConfigOption.file
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << PioneConfigAction.load_config
+        item << :get
+      end
+
+      execution(:get) do |item|
+        desc = "Get the value"
+
+        item.process do
+          puts model[:config].get(model[:name])
+        end
+
+        item.exception(Global::UnconfigurableVariableError) do |e|
+          cmd.abort("'%s' is not a configurable item name." % model[:name])
+        end
+      end
+    end
+
+    PioneConfig.define_subcommand("get", PioneConfigGet)
+  end
+end

data/lib/pione/command/pione-config-list.rb

@@ -0,0 +1,64 @@
+module Pione
+  module Command
+    # `PioneConfigList` is a command that lists PIONE global variables.
+    class PioneConfigList < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "list")
+      define(:desc, "List PIONE global variables")
+
+      #
+      # options
+      #
+
+      option CommonOption.debug
+      option PioneConfigOption.file
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :collect_items
+        item << :print
+      end
+
+      execution(:collect_items) do |item|
+        item.desc = "List"
+
+        # make items table
+        item.assign(:table) {Hash.new}
+
+        # push configurable global items
+        item.process do
+          Global.item.each do |key, item|
+            if item.configurable?
+              model[:table][key] = item.init
+            end
+          end
+        end
+
+        # push items in config file
+        item.process do
+          Global::Config.new(model[:file]).each do |name, value|
+            model[:table][name] = value
+          end
+        end
+      end
+
+      execution(:print) do |item|
+        item.desc = "Print a list of configurable items"
+
+        item.process do
+          model[:table].keys.sort.each do |name|
+            puts "%s: %s" % [name, model[:table][name]]
+          end
+        end
+      end
+    end
+
+    PioneConfig.define_subcommand("list", PioneConfigList)
+  end
+end

data/lib/pione/command/pione-config-set.rb

@@ -0,0 +1,59 @@
+module Pione
+  module Command
+    # `PioneConfigSet` is a command for setting a value of PIONE global
+    # variable.
+    class PioneConfigSet < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "set")
+      define(:desc, "Set a value of PIONE global variable")
+
+      #
+      # arguments
+      #
+
+      argument(:name) do |item|
+        item.type = :string
+        item.desc = "variable name"
+      end
+
+      argument(:value) do |item|
+        item.type = :string
+        item.desc = "variable value"
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.debug
+      option PioneConfigOption.file
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << PioneConfigAction.load_config
+        item << :set
+        item << PioneConfigAction.save_config
+      end
+
+      execution(:set) do |item|
+        item.desc = "Set the value"
+
+        item.process do
+          model[:config].set(model[:name], model[:value])
+        end
+
+        item.exception(Global::UnconfigurableVariableError) do |e|
+          cmd.abort("'%s' is not a configurable item name." % cmd.name)
+        end
+      end
+    end
+
+    PioneConfig.define_subcommand("set", PioneConfigSet)
+  end
+end

data/lib/pione/command/pione-config-unset.rb

@@ -0,0 +1,50 @@
+module Pione
+  module Command
+    # `PioneConfigUnset` is a command for unsetting a value of PIONE global
+    # variable.
+    class PioneConfigUnset < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "unset")
+      define(:desc, "Unset a value of PIONE global variable")
+
+      #
+      # arguments
+      #
+
+      argument(:name) do |item|
+        item.type = :string
+        item.desc = "variable name"
+      end
+
+      #
+      # options
+      #
+
+      option CommonOption.debug
+      option PioneConfigOption.file
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << PioneConfigAction.load_config
+        item << :unset
+        item << PioneConfigAction.save_config
+      end
+
+      execution(:unset) do |item|
+        item.desc = "Unset the item"
+
+        item.process do
+          model[:config].unset(model[:name])
+        end
+      end
+    end
+
+    PioneConfig.define_subcommand("unset", PioneConfigUnset)
+  end
+end

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

@@ -0,0 +1,61 @@
+module Pione
+  module Command
+    # `PioneConfig` is a utility set for PIONE global variables.
+    class PioneConfig < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "config")
+      define(:desc, "Configure PIONE global variables")
+
+      #
+      # requirements
+      #
+
+      require 'pione/command/pione-config-get'
+      require 'pione/command/pione-config-list'
+      require 'pione/command/pione-config-set'
+      require 'pione/command/pione-config-unset'
+    end
+
+    # `PioneConfigOption` is a set of common options for `pione config`
+    # subcommands.
+    module PioneConfigOption
+      extend Rootage::OptionCollection
+
+      define(:file) do |item|
+        item.short = "-f"
+        item.long = "--file"
+        item.arg  = "PATH"
+        item.desc = "path of config file"
+        item.type = :path
+        item.default = Global.config_path
+      end
+    end
+
+    # `PioneConfigAction` is a set of common actions for `pione config`
+    # subcommands.
+    module PioneConfigAction
+      extend Rootage::ActionCollection
+
+      define(:load_config) do |item|
+        item.desc = "Load PIONE configuration"
+
+        item.assign(:config) do
+          Global::Config.new(model[:file])
+        end
+      end
+
+      define(:save_config) do |item|
+        item.desc = "Save the configuration"
+
+        item.process do
+          model[:config].save(model[:file])
+        end
+      end
+    end
+
+    PioneCommand.define_subcommand("config", PioneConfig)
+  end
+end

data/lib/pione/command/pione-diagnosis-notification.rb

@@ -0,0 +1,235 @@
+module Pione
+  module Command
+    class PioneDiagnosisNotification < BasicCommand
+      #
+      # command definitions
+      #
+
+      define(:name, "notification")
+      define(:desc, "Diagnose notification settings")
+      define(:front, Front::DiagnosisNotificationFront)
+
+      #
+      # options
+      #
+
+      option CommonOption.debug
+      option CommonOption.color
+      option NotificationOption.notification_targets
+      option NotificationOption.notification_receivers
+
+      option(:type) do |item|
+        item.type  = :string
+        item.range = ["transmitter", "receiver", "both"]
+        item.long  = "--type"
+        item.arg   = "NAME"
+        item.desc  = "transmitter, receiver, or both"
+        item.init  = "both"
+      end
+
+      option(:timeout) do |item|
+        item.type    = :positive_integer
+        item.long    = "--timeout"
+        item.arg     = "N"
+        item.desc    = "timeout after N second"
+        item.init = 10
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |item|
+        item << :thread_groups
+        item << :message
+      end
+
+      setup(:thread_groups) do |item|
+        item.desc = "Make thread groups"
+
+        item.assign(:transmitting_threads) {ThreadGroup.new}
+        item.assign(:receiver_threads) {ThreadGroup.new}
+      end
+
+      setup(:message) do |item|
+        item.assign(:message) do
+          test(transmitter?)
+          "The notification target address seems %s: %s"
+        end
+
+        item.assign(:message) do
+          test(receiver?)
+          "The notification receiver address seems %s: %s"
+        end
+
+        item.assign(:message) do
+          test(both?)
+          "The notification target and receiver address seem %s: %s and %s"
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :diagnosis
+      end
+
+      execution(:diagnosis) do |item|
+        item.desc = "Diagnose notification address settings"
+
+        item.assign(:target_addrs) do
+          Global.notification_targets.map{|uri| uri.to_s}
+        end
+
+        item.assign(:receiver_addrs) do
+          Global.notification_receivers.map{|uri| uri.to_s}
+        end
+
+        item.process do
+          test(transmitter?)
+
+          Timeout.timeout(model[:timeout]) {transmit_notification}
+          Log::SystemLog.info(model[:message] % ["fine", model[:target_addrs]])
+        end
+
+        item.process do
+          test(receiver?)
+
+          Timeout.timeout(model[:timeout]) {receive_notification}
+          Log::SystemLog.info(model[:message] % ["fine", model[:receiver_addrs]])
+        end
+
+        item.process do
+          test(both?)
+
+          g = ThreadsWait.new
+          g.join_nowait(Thread.new {transmit_notification})
+          g.join_nowait(Thread.new {receive_notification})
+          Timeout.timeout(model[:timeout]) {g.all_waits}
+          Log::SystemLog.info(model[:message] % ["fine", model[:target_addrs], model[:receive_addrs]])
+        end
+
+        item.exception(Timeout::Error) do
+          test(transmitter?)
+          cmd.abort(model[:message] % ["bad", model[:target_addrs]])
+        end
+
+        item.exception(Timeout::Error) do
+          test(receiver?)
+          cmd.abort(model[:message] % ["bad", model[:receiver_addrs]])
+        end
+
+        item.exception(Timeout::Error) do
+          test(both?)
+          cmd.abort(msg % ["bad", model[:target_addrs], model[:receive_addrs]])
+        end
+      end
+
+      #
+      # command lifecycle: termination phase
+      #
+
+      phase(:termination) do |item|
+        item << :thread_groups
+      end
+
+      termination(:thread_groups) do |item|
+        item.desc = "Terminate all threads"
+
+        item.process do
+          model[:transmitting_threads].list.each {|thread| thread.terminate}
+          model[:receiver_threads].list.each {|thread| thread.terminate}
+        end
+      end
+    end
+
+    class PioneDiagnosisNotificationContext < Rootage::CommandContext
+      NOTIFIER = "PIONE_DIAGNOSIS_NOTIFICATION"
+
+      def transmitter?
+        model[:type] == "transmitter"
+      end
+
+      def receiver?
+        model[:type] == "receiver"
+      end
+
+      def both?
+        model[:type] == "both"
+      end
+
+      # Transmit test notification messages to targets repeatedly.
+      def transmit_notification
+        Global.notification_targets.each do |uri|
+          transmitter_id = uri.to_s
+
+          thread = Thread.new do
+            # register the current thread to front server
+            Thread.current[:transmitter_id] = transmitter_id
+            model[:front].register_transmitting_thread(Thread.current)
+
+            # build a notification message
+            message = Notification::Message.new(
+              NOTIFIER, "TEST", {"front" => model[:front].uri, "transmitter_id" => transmitter_id}
+            )
+
+            # create a transmitter
+            transmitter = Notification::Transmitter.new(uri)
+
+            # trasmitting loop for "TEST" notifications
+            begin
+              loop do
+                transmitter.transmit(message)
+                Log::SystemLog.info('Notification message has been sent to "%s".' % uri)
+
+                sleep 1
+              end
+            ensure
+              transmitter.close
+            end
+          end
+
+          model[:transmitting_threads].add(thread)
+        end
+
+        model[:transmitting_threads].list.each {|thread| thread.join}
+      end
+
+      def receive_notification
+        Global.notification_receivers.each do |uri|
+          thread = Thread.new do
+            receiver = Notification::Receiver.new(uri)
+
+            begin
+              loop do
+                Log::SystemLog.info('Notification receiver is waiting at "%s".' % uri.to_s)
+                transmitter_host, message = receiver.receive
+                Log::SystemLog.info('Notification has been received from "%s".' % transmitter_host)
+
+                begin
+                  DRbObject.new_with_uri(message["front"]).touch(message["transmitter_id"])
+                  Log::SystemLog.info('Receiver has touched transmitter at "%s".' % message["front"])
+                  break
+                rescue Object => e
+                  Log::SystemLog.warn(e.message)
+                end
+              end
+            ensure
+              receiver.close
+            end
+          end
+
+          model[:receiver_threads].add(thread)
+        end
+
+        model[:receiver_threads].list.each {|thread| thread.join}
+      end
+    end
+
+    PioneDiagnosisNotification.define(:process_context_class, PioneDiagnosisNotificationContext)
+
+    PioneDiagnosis.define_subcommand("notification", PioneDiagnosisNotification)
+  end
+end