pione 0.2.2 → 0.3.0

data/lib/pione/location/{exception.rb → location-exception.rb}

@@ -18,7 +18,7 @@ module Pione
     # NotFound is raised when there isn't data on the location.
     class NotFound < LocationError
       def message
-        "%s not found" % @location.inspect
+        "location \"%s\" not found" % @location.address
       end
     end
 
@@ -29,10 +29,22 @@ module Pione
       end
     end
 
+    # GitError is raised when git command operation fails.
     class GitError < LocationError
       def message
         "%s: %s" % [@option[:message], @location.address]
       end
     end
+
+    # NotLocal is raised when local location is expected but it is other type location.
+    class NotLocal < LocationError
+      def initialize(location)
+        @location = location
+      end
+
+      def message
+        "the location \"%s\" should local location" % @location.address
+      end
+    end
   end
 end

data/lib/pione/{uri-scheme/basic-scheme.rb → location/location-scheme.rb}

@@ -1,7 +1,7 @@
 module Pione
-  module URIScheme
-    # BasicScheme is a URI scheme for PIONE.
-    class BasicScheme < ::URI::Generic
+  module Location
+    # LocationScheme is a URI scheme for Location.
+    class LocationScheme < ::URI::Generic
       # Returns true always because classes inheriting BasicScheme are supported
       # by PIONE system.
       # @api private
@@ -19,9 +19,10 @@ module Pione
 
     # Returns a new scheme. Use this method for inheriting BasicScheme if you
     # create new scheme.
+    #
     # @return [Class]
-    def BasicScheme(name, opts={})
-      klass = Class.new(BasicScheme)
+    def LocationScheme(name, opts={})
+      klass = Class.new(LocationScheme)
 
       def klass.inherited(scheme)
         name = self.instance_variable_get(:@scheme_name)
@@ -35,6 +36,6 @@ module Pione
 
       return klass
     end
-    module_function :BasicScheme
+    module_function :LocationScheme
   end
 end

data/lib/pione/{uri-scheme → location}/myftp-scheme.rb

@@ -1,12 +1,12 @@
 module Pione
-  module URIScheme
+  module Location
     # MyFTPScheme is a special scheme for launching PIONE embedded ftp server.
     #
     # @example
     #   URI.parse("myftp:./output")
     # @example
     #   URI.parse("myftp://abc:123@192.168.0.32:45321/home/keita/pione/output")
-    class MyFTPScheme < BasicScheme('myftp', :storage => true)
+    class MyFTPScheme < LocationScheme('myftp', :storage => true)
       PORT = 39123
 
       COMPONENT = [:scheme, :user, :password, :host, :port, :path]

data/lib/pione/log.rb

@@ -4,10 +4,11 @@ module Pione
   end
 end
 
-require 'pione/log/message-log'
-require 'pione/log/process-record'
-require 'pione/log/process-log'
-require 'pione/log/xes-log'
-require 'pione/log/domain-log'
-require 'pione/log/system-log'
+require 'pione/log/system-log'     # system log framwork
+require 'pione/log/debug'          # debug message utility
+require 'pione/log/message-log'    # user messages from rule engine
+require 'pione/log/process-record' # record of event log
+require 'pione/log/process-log'    # event log of processing
+require 'pione/log/xes-log'        # XES format
+require 'pione/log/domain-log'     # domain informations in tuple space
 

data/lib/pione/log/debug.rb

@@ -0,0 +1,75 @@
+module Pione
+  module Log
+    # Debug is a log utility module for showing debug messages. Messages are
+    # shown when according debug flags (system, rule_engine,
+    # presence_notification, communication, ignored_exception) are available. 
+    module Debug
+      # Show a debug message about PIONE system activity. This message is
+      # visible when +Global.debug_system+ is true.
+      def self.system(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_system
+          print(:system, msg_or_exc, pos, &b)
+        end
+      end
+
+      # Show a debug message about rule engine activity. This message is visible
+      # when +Global.debug_rule_engine+ is true in client side.
+      def self.rule_engine(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_rule_engine
+          print(:rule_engine, msg_or_exc, pos, &b)
+        end
+      end
+
+      # Show a debug message about presence notifier. This message is visible
+      # when +Global.debug_presence_notification+ is true.
+      def self.presence_notification(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_presence_notification
+          print(:presence_notifier, msg_or_exc, pos, &b)
+        end
+      end
+
+      # Show a debug message abount object communication. This message is
+      # visible when +Global.debug_communication+ is true.
+      def self.communication(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_communication
+          print(:communication, msg_or_exc, pos, &b)
+        end
+      end
+
+      # Show a ignored exception. This message is visible when
+      # +Global.debug_ignored_exception+ is true.
+      def self.ignored_exception(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_ignored_exception
+          print(:ignored_exception, msg_or_exc, pos, &b)
+        end
+      end
+
+      private
+
+      # Print a debug message or an exception.
+      def self.print(type, msg_or_exc, pos, &b)
+        _msg_or_exc = block_given? ? b.call : msg_or_exc
+        if msg_or_exc.is_a?(Exception)
+          print_exception(type, _msg_or_exc, pos)
+        else
+          print_debug_message(type, _msg_or_exc, pos)
+        end
+      end
+
+      # Print a debug message.
+      def self.print_debug_message(type, msg, pos)
+        SystemLog.debug("%s: %s" % [prefix(type), msg], pos)
+      end
+
+      # Print an exception.
+      def self.print_exception(type, e, pos)
+        backtrace = e.backtrace.map{|line|  "    %s" % line}.join("\n")
+        SystemLog.debug("%s: %s - %s\n%s" % [prefix(type), e.class, e.message, backtrace], pos)
+      end
+
+      def self.prefix(type)
+        type.to_s.underline
+      end
+    end
+  end
+end

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

@@ -26,10 +26,9 @@ module Pione
           :system_machine => Uname.machine,
           :system_version => Uname.version,
           :system_release => Uname.release,
-          :params => handler.params.textize,
-          :original_params => handler.original_params.textize,
+          :params => handler.param_set.textize,
           :inputs => inputs_string(handler.inputs),
-          :domain => handler.domain,
+          :domain => handler.domain_id,
           :domain_location => @domain_location.uri.to_s,
           :dry_run => handler.dry_run.to_s
         }
@@ -52,7 +51,7 @@ module Pione
 
       # Build a record string for inputs.
       #
-      # @param inputs [Array<Tuple::DataTuple>]
+      # @param inputs [Array<TupleSpace::DataTuple>]
       #   input tuples
       # @return [String]
       #   a record string
@@ -68,7 +67,7 @@ module Pione
 
       # Build a data tuple string.
       #
-      # @param input [Tuple::DataTuple]
+      # @param input [TupleSpace::DataTuple]
       #   data tuple
       # @param i [Integer]
       #   index number

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

@@ -1,6 +1,6 @@
 module Pione
   module Log
-    # ConsoleMessage is a set of utility methods for sending messages to user.
+    # MessageLog is a set of utility methods for sending messages to user.
     module MessageLog
       # @api private
       MESSAGE_QUEUE = Queue.new
@@ -174,7 +174,7 @@ module Pione
       #
       # @api private
       def message(type, head, color, msg, level=0)
-        write(Tuple[:message].new(type: type, head: head, color: color, contents: msg, level: level))
+        write(TupleSpace::MessageTuple.new(type: type, head: head, color: color, contents: msg, level: level))
       rescue NoMethodError
         MESSAGE_QUEUE.push "%s%s %s" % ["  "*level, ("%5s" % head).color(color), msg]
       end

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

@@ -15,45 +15,39 @@ module Pione
           ProcessLog.instance_variable_get(:@format)[name] = self
         end
 
+        # Return true if the formatter name is known.
+        def known?(name)
+          ProcessLog.instance_variable_get(:@format).has_key?(name)
+        end
+
         # Return the named formatter class.
-        #
-        # @param name [Symbol]
-        #   formatter name
-        # @return [Class]
-        #   formatter class
         def [](name)
           ProcessLog.instance_variable_get(:@format)[name]
         end
 
-        # Read log files and return the process log.
-        #
-        # @param location [Location]
-        #   path of process log file
-        # @return [Hash{String => ProcessLog}]
-        #   pairs of log id and the log
+        # Read the raw log file and return the process log table grouped by log id.
         def read(location)
+          # create local cache of raw log for performance
           cache = location
           unless location.scheme == "local"
             cache = Location[Temppath.create]
             cache.create(location.read)
           end
+
+          # read all records
           records = cache.path.each_line.map do |line|
-            JSON.parse(line).inject({}) do |data, pair|
-              data[pair[0].to_sym] = pair[1]
-              data
-            end.tap do |table|
-              break ProcessRecord.build(table)
-            end
+            JSON.parse(line).inject({}) do |data, (key, val)|
+              data.tap {data[key.to_sym] = val}
+            end.tap {|data| break ProcessRecord.build(data)}
           end
-          group_by(:log_id, records).inject({}) do |table, pair|
-            key, _records = pair
-            table[key] = new(_records)
+
+          # group records by log id
+          group_by(:log_id, records).inject({}) do |table, (key, _records)|
+            table.tap {table[key] = new(_records)}
           end
         end
 
         # Set record filter.
-        #
-        # @yield block
         def set_filter(&block)
           @filter_block = block
         end
@@ -61,9 +55,6 @@ module Pione
         attr_reader :filter_block
 
         # Return the record table grouped by the key.
-        #
-        # @return [Hash{String => Array<ProcessRecord>}]
-        #   grouping records table
         def group_by(key, records)
           records.inject({}) do |table, record|
             table[record.send(key)] ||= []

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

@@ -193,6 +193,7 @@ module Pione
     class TaskProcessRecord < ProcessRecord
       set_type :task_process
       field :name
+      field :package_id
       field :rule_name
       field :rule_type
       field :inputs

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

@@ -1,107 +1,217 @@
 module Pione
   module Log
     module SystemLog
-      # Log the fatal message.
-      #
-      # @param msg [String]
-      #   the fatal message
-      def fatal(msg)
-        Global.system_logger.fatal(msg)
+      # Log the fatal message. This level is used when system will go to shutdown.
+      def self.fatal(msg, pos=caller(1).first)
+        Global.system_logger.fatal(msg, pos)
       end
-      module_function :fatal
 
       # Log the error message.
-      #
-      # @param msg [String]
-      #   the error message
-      def error(msg)
-        Global.system_logger.error(msg)
+      def self.error(msg, pos=caller(1).first)
+        Global.system_logger.error(msg, pos)
       end
-      module_function :error
 
       # Log the warn message.
-      #
-      # @param msg [String]
-      #   the warn message
-      def warn(msg)
-        Global.system_logger.warn(msg)
+      def self.warn(msg, pos=caller(1).first)
+        Global.system_logger.warn(msg, pos)
       end
-      module_function :warn
 
       # Log the info message.
-      #
-      # @param msg [String]
-      #   the info message
-      def info(msg)
-        Global.system_logger.info(msg)
+      def self.info(msg, pos=caller(1).first)
+        Global.system_logger.info(msg, pos)
       end
-      module_function :info
 
       # Log the debug message.
-      #
-      # @param msg [String]
-      #   the debug message
-      def debug(msg)
-        Global.system_logger.debug(msg)
+      def self.debug(msg, pos=caller(1).first)
+        Global.system_logger.debug(msg, pos)
+      end
+
+      def self.terminate
+        Global.system_logger.terminate
       end
-      module_function :debug
     end
 
+    # SystemLogger is a interface for system logger implementations.
     class SystemLogger
+      @logger = {} # logger class table
+
+      # Return logger class of the type.
+      def self.of(type)
+        @logger[type]
+      end
+
+      # Register the logger class with the type.
+      def self.register(type, logger_class)
+        @logger[type] = logger_class
+      end
+
+      # Return the log level.
+      def level
+        raise NotImplementedError
+      end
+
+      # Set the log level.
+      def level=(level)
+        raise NotImplementedError
+      end
+
       # Log the fatal message.
-      #
-      # @param msg [String]
-      #   the fatal message
-      def fatal(msg)
+      def fatal(msg, pos=caller(1).first)
         raise NotImplementedError
       end
 
       # Log the error message.
-      #
-      # @param msg [String]
-      #   the error message
-      def error(msg)
+      def error(msg, pos=caller(1).first)
         raise NotImplementedError
       end
 
       # Log the warn message.
-      #
-      # @param msg [String]
-      #   the warn message
-      def warn(msg)
+      def warn(msg, pos=caller(1).first)
         raise NotImplementedError
       end
 
       # Log the info message.
-      #
-      # @param msg [String]
-      #   the info message
-      def info(msg)
+      def info(msg, pos=caller(1).first)
         raise NotImplementedError
       end
 
       # Log the debug message.
-      #
-      # @param msg [String]
-      #   the debug message
-      def debug(msg)
+      def debug(msg, pos=caller(1).first)
+        raise NotImplementedError
+      end
+
+      # Terminate the logger.
+      def terminate
+        raise NotImplementedError
+      end
+
+      # Return true if some messages are queued.
+      def queued?
         raise NotImplementedError
       end
     end
 
+    # PioneSystemLogger is a PIONE original logger. This generates very colorful
+    # message for identifiability and detailed informations.
+    class PioneSystemLogger < SystemLogger
+      attr_accessor :level
+
+      def initialize(out = $stdout)
+        @queue = Queue.new
+        @thread = make_writer_thread
+        @level = :info
+        @out = out
+      end
+
+      def fatal(msg, pos=caller(1).first); push(:fatal, msg, pos); end
+      def error(msg, pos=caller(1).first); push(:error, msg, pos); end
+      def warn (msg, pos=caller(1).first); push(:warn , msg, pos); end
+      def info (msg, pos=caller(1).first); push(:info , msg, pos); end
+      def debug(msg, pos=caller(1).first); push(:debug, msg, pos); end
+
+      def terminate
+        timeout(3) do
+          while @thread.alive?
+            if @queue.empty?
+              @thread.kill.join
+              break
+            else
+              sleep 0.1
+            end
+          end
+        end
+      rescue Timeout::Error
+        # kill writer thread
+        @thread.kill if @thread.alive?
+
+        # don't use logger because it is dead at this time
+        @out.puts("*** system logger has been terminated unsafety, some messages maybe lost ***")
+      end
+
+      def queued?
+        not(@queue.empty?)
+      end
+
+      private
+
+      def make_writer_thread
+        Thread.new do
+          while true do
+            level, msg, pos, time = @queue.pop
+            print(level, msg, pos, time)
+          end
+        end
+      end
+
+      def push(level, msg, pos)
+        @queue.push([level, msg, pos, Time.now])
+      end
+
+      def color_of(level)
+        Global.send("pione_system_logger_%s" % level)
+      end
+
+      def print(level, msg, pos, time)
+        if level == :info
+          @out.puts "%s: %s" % [level.to_s.color(color_of(level)), msg]
+        else
+          @out.puts "%s: %s [%s] (%s, #%s)" % [level.to_s.color(color_of(level)), msg, pos, time.iso8601(3), Process.pid]
+        end
+      end
+    end
+
     # StandardSystemLogger is a logger using Ruby standard Logger.
-    class StandardSystemLogger
-      forward! :@logger, :fatal, :error, :warn, :info, :debug
+    class RubyStandardSystemLogger < SystemLogger
+      forward! :@logger, :level, :level=
 
-      def initialize(out)
+      def initialize(out = $stdout)
         @logger = Logger.new(out)
       end
+
+      def fatal(msg, pos=caller(1).first); @logger.fatal(msg); end
+      def error(msg, pos=caller(1).first); @logger.error(msg); end
+      def warn (msg, pos=caller(1).first); @logger.warn(msg) ; end
+      def info (msg, pos=caller(1).first); @logger.info(msg) ; end
+      def debug(msg, pos=caller(1).first); @logger.debug(msg); end
+
+      def terminate
+        # ignore
+      end
+
+      def queued?
+        false
+      end
     end
 
-    class SyslogSystemLogger < StandardSystemLogger
+    # SyslogSystemLogger is a logger using syslog("syslog-logger" gem).
+    class SyslogSystemLogger < SystemLogger
+      forward! :@logger, :level, :level=
+
       def initialize
         @logger = Logger::Syslog.new('pione')
       end
+
+      def fatal(msg, pos=caller(1).first); @logger.fatal(msg); end
+      def error(msg, pos=caller(1).first); @logger.error(msg); end
+      def warn (msg, pos=caller(1).first); @logger.warn(msg) ; end
+      def info (msg, pos=caller(1).first); @logger.info(msg) ; end
+      def debug(msg, pos=caller(1).first); @logger.debug(msg); end
+
+      def terminate
+        # ignore
+      end
+
+      def queued?
+        false
+      end
     end
+
+    #
+    # register loggers
+    #
+
+    SystemLogger.register(:pione, PioneSystemLogger)
+    SystemLogger.register(:ruby, RubyStandardSystemLogger)
+    SystemLogger.register(:syslog, SyslogSystemLogger)
   end
 end