pione 0.3.2 → 0.4.0

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

@@ -0,0 +1,22 @@
+module Pione
+  module Command
+    # `PioneLang` is a utility set for PIONE language.
+    class PioneLang < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "lang")
+      define(:desc, "PIONE language utilities")
+
+      #
+      # requirements
+      #
+
+      require 'pione/command/pione-lang-interactive'
+      require 'pione/command/pione-lang-check-syntax'
+    end
+
+    PioneCommand.define_subcommand("lang", PioneLang)
+  end
+end

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

@@ -0,0 +1,163 @@
+module Pione
+  module Command
+    # `PioneLogFormat` is a command that converts PIONE raw log into XES or
+    # other formats.
+    class PioneLogFormat < BasicCommand
+      #
+      # basic informations
+      #
+
+      define(:name, "format")
+      define(:desc, "Convert PIONE raw log into XES or other formats")
+
+      #
+      # arguments
+      #
+
+      argument PioneLogArgument.log_location
+
+      #
+      # options
+      #
+
+      option_pre(:prepare_model) do |item|
+        item.process do
+          model[:trace_types] = []
+          model[:agent_types] = []
+        end
+      end
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      option(:trace_types) do |item|
+        item.type = :string
+        item.long = "--trace-type"
+        item.arg  = "NAME"
+        item.desc = 'Output only the trace type: "agent", "rule", or "task"'
+
+        item.process {|val| model[:trace_types] << val}
+      end
+
+      option(:agent_types) do |item|
+        item.type = :string
+        item.arg  = "NAME"
+        item.long = "--agent-type"
+        item.desc = 'Output only the agent type: "task_worker", "input_generator", ...'
+
+        item.process {|val| model[:agent_types] << val}
+      end
+
+      option(:format) do |item|
+        item.type  = :symbol_downcase
+        item.range = [:xes, :json, :xml]
+        item.long  = "--format"
+        item.arg   = "NAME"
+        item.desc  = 'Set format type'
+        item.init  = :xes
+      end
+
+      option(:log_id) do |item|
+        item.type = :string
+        item.long = "--log-id"
+        item.arg  = "ID"
+        item.desc = "Target log ID"
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |seq|
+        seq << :trace_filters
+        seq << :formatter
+        seq << :raw_log
+      end
+
+      setup(:trace_filters) do |item|
+        item.desc = "Setup trace filters"
+
+        item.assign(:trace_filters) do
+          Array.new
+        end
+
+        # agent filters
+        item.process do
+          test(model[:trace_types].include?("agent"))
+
+          if model[:agent_types].empty?
+            model[:trace_filters] << Proc.new do |trace|
+              trace.attributes.include?(XES.string("pione:traceType", "agent_activity"))
+            end
+          else
+            model[:trace_filters] << Proc.new do |trace|
+              trace.attributes.include?(XES.string("pione:traceType", "agent_activity")) and
+                model[:agent_types].includes?(trace.events.first.org_resource)
+            end
+          end
+        end
+
+        # rule filters
+        item.process do
+          test(model[:trace_types].include?("rule"))
+
+          model[:trace_filters] << Proc.new do |trace|
+            trace.attributes.include?(XES.string("pione:traceType", "rule_process"))
+          end
+        end
+
+        # task filters
+        item.process do
+          test(model[:trace_types].include?("task"))
+
+          model[:trace_filters] << Proc.new do |trace|
+            trace.attributes.include?(XES.string("pione:traceType", "task_process"))
+          end
+        end
+      end
+
+      setup(:formatter) do |item|
+        item.desc = "Setup formatter"
+
+        item.assign(:formatter) do
+          if Log::ProcessLog.known?(model[:format])
+            Log::ProcessLog[model[:format]]
+          else
+            cmd.abort("Unknown format: %s" % model[:format])
+          end
+        end
+      end
+
+      setup(:raw_log) do |item|
+        item.desc = "Read raw log table"
+
+        item.assign(:raw_log_table) do
+          model[:formatter].read(model[:log_location])
+        end
+
+        item.assign(:log_id) do
+          test(not(model[:log_id]))
+          model[:raw_log_table].keys.sort.last
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :format_log
+      end
+
+      execution(:format_log) do |item|
+        item.desc = "Format log file from the event log"
+
+        item.process do
+          puts(model[:raw_log_table][model[:log_id]].format(model[:trace_filters]))
+        end
+      end
+    end
+
+    PioneLog.define_subcommand("format", PioneLogFormat)
+  end
+end

data/lib/pione/command/pione-log-list-id.rb

@@ -0,0 +1,48 @@
+module Pione
+  module Command
+    # `PioneLogListId` is a command that list IDs in PIONE raw log.
+    class PioneLogListId < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "list-id")
+      define(:desc, "List log IDs")
+
+      #
+      # arguments
+      #
+
+      argument PioneLogArgument.log_location
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :list_id
+      end
+
+      execution(:list_id) do |item|
+        item.desc = "List raw log IDs"
+
+        item.process do
+          raw_log_table = Log::XESLog.read(model[:log_location])
+          raw_log_table.keys.each do |log_id|
+            puts log_id
+          end
+        end
+      end
+    end
+
+    PioneLog.define_subcommand("list-id", PioneLogListId)
+  end
+end
+

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

@@ -1,120 +1,38 @@
 module Pione
   module Command
-    # PioneLog is a command for viewing PIONE log or converting into other formats.
+    # `PioneLog` is a command set of log utilities.
     class PioneLog < BasicCommand
       #
       # basic informations
       #
 
-      command_name "pione-log"
-      command_banner "View and convert PIONE log."
-      PioneCommand.add_subcommand("log", self)
+      define(:name, "log")
+      define(:desc, "Log utilities")
 
       #
-      # options
+      # requirements
       #
 
-      use_option :color
-      use_option :debug
-
-      option_default :trace_filter, []
-
-      define_option(:agent_activity) do |item|
-        item.long = "--agent-activity[=TYPE]"
-        item.desc = "output only agent activity log"
-        item.action = proc do |_, option, name|
-          option[:trace_filter] << Proc.new do |trace|
-            trace.attributes.include?(XES.string("pione:traceType", "agent_activity")) and
-              (name.nil? or trace.events.first.org_resource == name)
-          end
-        end
-      end
-
-      define_option(:rule_process) do |item|
-        item.long = "--rule-process"
-        item.desc = "generate rule process log"
-        item.action = proc do |_, option|
-          option[:trace_filter] << Proc.new do |trace|
-            trace.attributes.include?(XES.string("pione:traceType", "rule_process"))
-          end
-        end
-      end
-
-      define_option(:task_process) do |item|
-        item.long = "--task-process"
-        item.desc = "generate task process log"
-        item.action = proc do |_, option|
-          option[:trace_filter] << Proc.new do |trace|
-            trace.attributes.include?(XES.string("pione:traceType", "task_process"))
-          end
-        end
-      end
-
-      define_option(:location) do |item|
-        item.long = "--location=LOCATION"
-        item.desc = "set log location of PIONE process"
-        item.default = Location["local:./output/pione-process.log"]
-        item.value = proc {|location| Location[location]}
-      end
-
-      define_option(:format) do |item|
-        item.long = "--format=(XES|JSON|HTML)"
-        item.desc = "set format type"
-        item.default = :xes
-        item.value = proc {|name| name.downcase.to_sym}
-      end
-
-      define_option(:log_id) do |item|
-        item.long = "--log-id=ID"
-        item.desc = "target log id"
-      end
-
-      validate_option do |option|
-        unless option[:location].exist?
-          abort("File not found in the location: %s" % option[:location].uri.to_s)
-        end
-      end
+      require 'pione/command/pione-log-format'
+      require 'pione/command/pione-log-list-id'
+    end
 
-      #
-      # command lifecycle: setup phase
-      #
+    # `PioneLogArgument` provides common arguments for `pione log` subcommands.
+    module PioneLogArgument
+      extend Rootage::ArgumentCollection
 
-      setup :formatter
-      setup :raw_log
-      setup :log_id
+      define(:log_location) do |item|
+        item.type    = :location
+        item.heading = "location"
+        item.desc    = "Location of PIONE raw log"
 
-      # Setup formatter.
-      def setup_formatter
-        if Log::ProcessLog.known?(option[:format])
-          @formatter = Log::ProcessLog[option[:format]]
-        else
-          abort("Unknown format: %s" % option[:format])
+        item.process do |loc|
+          test(not(loc.exist?))
+          cmd.abort("File not found in the location: %s" % loc.uri)
         end
       end
-
-      # Read raw log table.
-      def setup_raw_log
-        @raw_log_table = @formatter.read(option[:location])
-      end
-
-      def setup_log_id
-        if option[:log_id]
-          @log_id = option[:log_id]
-        else
-          @log_id = @raw_log_table.keys.sort.last
-        end
-      end
-
-      #
-      # command lifecycle: execution phase
-      #
-
-      execute :format_log
-
-      # Format log file from the event log.
-      def execute_format_log
-        puts(@raw_log_table[@log_id].format(option[:trace_filter]))
-      end
     end
+
+    PioneCommand.define_subcommand("log", PioneLog)
   end
 end

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

@@ -0,0 +1,95 @@
+module Pione
+  module Command
+    # `PioneNotificationListener` is a command that listens notification
+    # messages and sends it to registered receivers.
+    class PioneNotificationListener < BasicCommand
+      #
+      # informations
+      #
+
+      define(:toplevel, true)
+      define(:name, "pione-notification-listener")
+      define(:desc, "listen notification messages")
+      define(:front, Front::NotificationListenerFront)
+      define(:model, Model::NotificationListenerModel)
+
+      #
+      # options
+      #
+
+      option CommonOption.color
+      option CommonOption.debug
+      option CommonOption.communication_address
+      option NotificationOption.notification_receivers
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |item|
+        item << :model
+      end
+
+      setup(:model) do |item|
+        item.desc = "Initialize the command model"
+
+        item.assign(:notification_listener_agents) {Array.new}
+        item.assign(:threads) {ThreadsWait.new}
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |item|
+        item << :notification_listener_agents
+      end
+
+      execution(:notification_listener_agents) do |item|
+        item.desc = "Create notification listener agents"
+
+        # launch a listener agent
+        item.process do
+          Global.notification_receivers.each do |address|
+            agent = Agent::NotificationListener.start(model, address)
+            model[:notification_listener_agents] << agent
+            model[:threads].join_nowait(
+              Thread.new {agent.wait_until_terminated(nil)}
+            )
+          end
+        end
+
+        # wait agents
+        item.process do
+          model[:threads].all_waits
+        end
+
+        item.exception(Agent::ConnectionError) do
+          Log::SystemLog.fatal('`pione-notification-listener` is terminated because pione-borker may be dead.')
+          cmd.terminate
+        end
+      end
+
+      #
+      # command lifecycle: termination phase
+      #
+
+      phase(:termination) do |item|
+        item.configure(:timeout => 5)
+        item << :notification_listener_agents
+      end
+
+      termination(:notification_listener_agents) do |item|
+        item.desc = "Terminate notification listener agent"
+
+        item.process do
+          model[:notification_listener_agents].each do |agent|
+            if not(agent.terminated?)
+              agent.terminate
+            end
+          end
+        end
+      end
+    end
+  end
+end