pione 0.1.4 → 0.2.0

data/lib/pione/log/process-record.rb

@@ -1,6 +1,7 @@
 module Pione
   module Log
-    # UnknownProcessRecordType is raised when we find unknown process types.
+    # UnknownProcessRecordType is raised when we find unknown process record
+    # types.
     class UnknownProcessRecordType < StandardError
       # @param type [Symbol]
       #   type name
@@ -8,15 +9,18 @@ module Pione
         @type = type
       end
 
-      # @api private
       def message
         'Unknown process type "%s"' % @type
       end
     end
 
     # ProcessRecord is a class that represents records of process log. Records
-    # are in tuple spaces and handled by PIONE's logger agent.
+    # are in tuple spaces and handled by PIONE's process logger agent. If you
+    # want to add record type, you need to create the subclass of this.
     class ProcessRecord
+      include SimpleIdentity
+      ignore_identity :log_id
+
       # known process record types and classes
       TYPE_TABLE = {}
 
@@ -52,15 +56,19 @@ module Pione
         #
         # @param name [Symbol]
         #   field name of the record
+        # @param type [Class]
+        #   field data type
         # @return [void]
         def field(name)
           unless (@fields ||= []).include?(name)
             @fields << name
 
+            # field reader
             define_method(name) do
               instance_variable_get("@%s" % name)
             end
 
+            # field writer
             define_method("%s=" % name) do |val|
               val = Time.parse(val) if name == :timestamp and val.kind_of?(String)
               instance_variable_set("@%s" % name, val)
@@ -68,9 +76,10 @@ module Pione
           end
         end
 
-        # @api private
-        def inherited(klass)
-          klass.instance_variable_set(:@fields, @fields.clone)
+        # Subclass inherites superclass's fields.
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__ignore_identities__, @__ignore_identities__.clone)
+          subclass.instance_variable_set(:@fields, @fields.clone)
         end
       end
 
@@ -84,6 +93,11 @@ module Pione
       #   transition name
       field :transition
 
+      # @!attribute [rw]
+      # @return [String]
+      #   log_id
+      field :log_id
+
       forward! :class, :type, :fields
 
       # Create a new process log record.
@@ -106,15 +120,15 @@ module Pione
         end
       end
 
-      # Format as JSON string.
+      # Format as a JSON string.
       #
       # @return [String]
       #   JSON string
-      def format
-        JSON.dump(to_hash)
+      def format(log_id)
+        JSON.dump(to_hash.merge(log_id: log_id))
       end
 
-      # Convert record into a hash table.
+      # Convert the record into a hash table.
       #
       # @return [Hash]
       #   hash table representation of the record
@@ -129,7 +143,6 @@ module Pione
         end
       end
 
-      # @api private
       def to_json(*args)
         to_hash.to_json(*args)
       end

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

@@ -0,0 +1,107 @@
+module Pione
+  module Log
+    module SystemLog
+      # Log the fatal message.
+      #
+      # @param msg [String]
+      #   the fatal message
+      def fatal(msg)
+        Global.system_logger.fatal(msg)
+      end
+      module_function :fatal
+
+      # Log the error message.
+      #
+      # @param msg [String]
+      #   the error message
+      def error(msg)
+        Global.system_logger.error(msg)
+      end
+      module_function :error
+
+      # Log the warn message.
+      #
+      # @param msg [String]
+      #   the warn message
+      def warn(msg)
+        Global.system_logger.warn(msg)
+      end
+      module_function :warn
+
+      # Log the info message.
+      #
+      # @param msg [String]
+      #   the info message
+      def info(msg)
+        Global.system_logger.info(msg)
+      end
+      module_function :info
+
+      # Log the debug message.
+      #
+      # @param msg [String]
+      #   the debug message
+      def debug(msg)
+        Global.system_logger.debug(msg)
+      end
+      module_function :debug
+    end
+
+    class SystemLogger
+      # Log the fatal message.
+      #
+      # @param msg [String]
+      #   the fatal message
+      def fatal(msg)
+        raise NotImplementedError
+      end
+
+      # Log the error message.
+      #
+      # @param msg [String]
+      #   the error message
+      def error(msg)
+        raise NotImplementedError
+      end
+
+      # Log the warn message.
+      #
+      # @param msg [String]
+      #   the warn message
+      def warn(msg)
+        raise NotImplementedError
+      end
+
+      # Log the info message.
+      #
+      # @param msg [String]
+      #   the info message
+      def info(msg)
+        raise NotImplementedError
+      end
+
+      # Log the debug message.
+      #
+      # @param msg [String]
+      #   the debug message
+      def debug(msg)
+        raise NotImplementedError
+      end
+    end
+
+    # StandardSystemLogger is a logger using Ruby standard Logger.
+    class StandardSystemLogger
+      forward! :@logger, :fatal, :error, :warn, :info, :debug
+
+      def initialize(out)
+        @logger = Logger.new(out)
+      end
+    end
+
+    class SyslogSystemLogger < StandardSystemLogger
+      def initialize
+        @logger = Logger::Syslog.new('pione')
+      end
+    end
+  end
+end

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

@@ -1,9 +1,21 @@
 module Pione
   module Log
     # XESLog is a class for XES formatted log.
-    class XESLog < ProcessLogFormatter
+    class XESLog < ProcessLog
       set_format_name :xes
 
+      attr_reader :agent_activity_log
+      attr_reader :rule_process_log
+      attr_reader :task_process_log
+
+      # @param records [Array<ProcessRecord>]
+      #   log records
+      def initialize(records)
+        @agent_activity_log = AgentActivityLog.new(records)
+        @rule_process_log = RuleProcessLog.new(records)
+        @task_process_log = TaskProcessLog.new(records)
+      end
+
       # Format as a XML document.
       #
       # @return [String]
@@ -14,7 +26,7 @@ module Pione
           XES::Document.new.tap do |doc|
             doc.log = XES::Log.default.tap do |log|
               log.concept_name = "PIONE process log"
-              log.traces += [format_agent_activity + format_rule_process + format_task_process].flatten.select(&filter)
+              log.traces += [format_agent_activity + [format_rule_process, format_task_process]].flatten.select(&filter)
               log.traces.flatten!
             end
             if doc.formattable?
@@ -33,43 +45,39 @@ module Pione
       #
       # @return [Array<XES::Trace>]
       def format_agent_activity
-        @bundles.map do |bundle|
-          bundle.agent_activity_log.group_by(:agent_uuid).map do |agent_uuid, records|
-            XES::Trace.new.tap do |trace|
-              trace.attributes << XES.string("pione:traceType", "agent_activity")
-              trace.identity_id = agent_uuid
-              trace.events = records.sort{|a, b| a.timestamp <=> b.timestamp}.map do |record|
-                XES::Event.new.tap do |event|
-                  event.concept_name = record.state
-                  event.org_resource = record.agent_type
-                  event.time_timestamp = record.timestamp
-                  event.lifecycle_transition = record.transition
-                end
+        @agent_activity_log.group_by(:agent_uuid).map do |agent_uuid, records|
+          XES::Trace.new.tap do |trace|
+            trace.attributes << XES.string("pione:traceType", "agent_activity")
+            trace.identity_id = agent_uuid
+            trace.events = records.sort{|a, b| a.timestamp <=> b.timestamp}.map do |record|
+              XES::Event.new.tap do |event|
+                event.concept_name = record.state
+                event.org_resource = record.agent_type
+                event.time_timestamp = record.timestamp
+                event.lifecycle_transition = record.transition
               end
             end
-          end.flatten
-        end
+          end
+        end.flatten
       end
 
       # Format rule process records.
       #
-      # @return [Array<XES::Trace>]
+      # @return [XES::Trace]
       def format_rule_process
-        @bundles.map do |bundle|
-          XES::Trace.new.tap do |trace|
-            trace.concept_name = "rule_process %s" % Util.generate_uuid
-            trace.attributes << XES.string("pione:traceType", "rule_process")
-            trace.events = bundle.rule_process_log.records.map do |record|
-              XES::Event.new.tap do |event|
-                # standard attributes
-                event.concept_name = record.name
-                event.org_resource = record.caller
-                event.time_timestamp = record.timestamp
-                event.lifecycle_transition = record.transition
+        XES::Trace.new.tap do |trace|
+          trace.concept_name = "rule_process %s" % Util::UUID.generate
+          trace.attributes << XES.string("pione:traceType", "rule_process")
+          trace.events = @rule_process_log.records.map do |record|
+            XES::Event.new.tap do |event|
+              # standard attributes
+              event.concept_name = record.name
+              event.org_resource = record.caller
+              event.time_timestamp = record.timestamp
+              event.lifecycle_transition = record.transition
 
-                # pione extension attributes
-                event.attributes << XES.string("pione:ruleType", record.rule_type)
-              end
+              # pione extension attributes
+              event.attributes << XES.string("pione:ruleType", record.rule_type)
             end
           end
         end
@@ -77,25 +85,23 @@ module Pione
 
       # Format task process records.
       #
-      # @return [Array<XES::Trace>]
+      # @return [XES::Trace]
       def format_task_process
-        @bundles.map do |bundle|
-          XES::Trace.new.tap do |trace|
-            trace.concept_name = "task process %s" % Util.generate_uuid
-            trace.attributes << XES.string("pione:traceType", "task_process")
-            trace.events = bundle.task_process_log.records.map do |record|
-              XES::Event.new.tap do |event|
-                # standard attributes
-                event.concept_name = record.name
-                # event.org_resource = record.caller
-                event.time_timestamp = record.timestamp
-                event.lifecycle_transition = record.transition
+        XES::Trace.new.tap do |trace|
+          trace.concept_name = "task process %s" % Util::UUID.generate
+          trace.attributes << XES.string("pione:traceType", "task_process")
+          trace.events = @task_process_log.records.map do |record|
+            XES::Event.new.tap do |event|
+              # standard attributes
+              event.concept_name = record.name
+              # event.org_resource = record.caller
+              event.time_timestamp = record.timestamp
+              event.lifecycle_transition = record.transition
 
-                # pione extension attributes
-                event.attributes << XES.string("pione:ruleType", record.rule_type)
-                event.attributes << XES.string("pione:inputs", record.inputs)
-                event.attributes << XES.string("pione:parameters", record.parameters)
-              end
+              # pione extension attributes
+              event.attributes << XES.string("pione:ruleType", record.rule_type)
+              event.attributes << XES.string("pione:inputs", record.inputs)
+              event.attributes << XES.string("pione:parameters", record.parameters)
             end
           end
         end

data/lib/pione/model.rb

@@ -14,16 +14,14 @@ require 'pione/model/variable'
 require 'pione/model/variable-table'
 require 'pione/model/data-expr'
 require 'pione/model/parameters'
-require 'pione/model/package'
+require 'pione/model/package-expr'
 require 'pione/model/ticket-expr'
 require 'pione/model/rule-expr'
-require 'pione/model/binary-operator'
 require 'pione/model/message'
 require 'pione/model/call-rule'
 require 'pione/model/assignment'
 require 'pione/model/block'
 require 'pione/model/constraints'
-require 'pione/model/rule'
 
 module Pione
   # Model is a name space for all PIONE models.

data/lib/pione/model/assignment.rb

@@ -43,6 +43,7 @@ module Pione
       #   self
       def eval(vtable)
         vtable.set(@variable, @expr)
+        return @expr
       end
 
       # Set truth of toplevel assignment.

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

@@ -25,21 +25,26 @@ module Pione
     # MethodNotFound is an exception class for the case of method missing.
     class MethodNotFound < StandardError
       attr_reader :name
-      attr_reader :obj
+      attr_reader :receiver
+      attr_reader :arguments
 
       # Creates an exception.
-      # @param [String, Symbol] name
+      # @param name [String]
       #   method name
-      # @param [BasicModel] obj
+      # @param receiver [Callable]
       #   method reciever
-      def initialize(name, obj)
+      # @param arguments [Array<Callable>]
+      #   method arguments
+      def initialize(name, receiver, *arguments)
         @name = name
-        @obj = obj
+        @receiver = receiver
+        @arguments = arguments
       end
 
-      # @api private
       def message
-        "PIONE method \"%s\" is not found in %s" % [@name, @obj.inspect]
+        rec_type = @receiver.pione_model_type
+        arg_types = @arguments.map{|arg| arg.pione_model_type}.join(" -> ")
+        "PIONE method \"%s\" is not found: %s. %s" % [@name, rec_type, arg_types]
       end
     end
 
@@ -162,17 +167,19 @@ module Pione
 
       # Call pione model object method.
       #
-      # @param [String] name
-      #   method name
-      # @param [Array] args
+      # @param vtable [VariableTable]
+      #   variable table
+      # @param name [String]
+      #   method's name
+      # @param args [Array]
       #   method's arguments
       # @return [Object]
-      #   method's result
-      def call_pione_method(name, *args)
+      #   the result
+      def call_pione_method(vtable, name, *args)
         if pione_method = pione_model_type.find_method(name, self, *args)
-          pione_method.call(self, *args)
+          pione_method.call(vtable, self, *args)
         else
-          raise MethodNotFound.new(name, self)
+          raise MethodNotFound.new(name, self, *args)
         end
       end
 
@@ -184,6 +191,8 @@ module Pione
     end
 
     class Element < BasicModel
+      include SimpleIdentity
+
       class << self
         attr_reader :sequence_class
 
@@ -200,13 +209,20 @@ module Pione
     end
 
     class Value < Element
+      include SimpleIdentity
+
       attr_reader :value
 
-      # @param value [Integer]
+      # @param value [Object]
       #   value in ruby
       def initialize(value)
         @value = value
       end
+
+      def inspect
+        '#<%s "%s">' % [self.class.name, @value]
+      end
+      alias :to_s :inspect
     end
   end
 end