pione 0.3.2 → 0.4.0

data/lib/pione/location/https-location.rb

@@ -2,8 +2,10 @@ module Pione
   module Location
     class HTTPSLocation < HTTPLocation
       set_scheme "https"
-      set_real_appendable false
-      set_writable false
+
+      define(:need_caching, true)
+      define(:real_appendable, false)
+      define(:writable, false)
 
       # Send a request HTTPS Get and evaluate the block with the response.
       def http_get(&b)

data/lib/pione/location/local-location.rb

@@ -3,7 +3,10 @@ module Pione
     # LocalLocation represents local disk locations.
     class LocalLocation < DataLocation
       set_scheme "local"
-      set_real_appendable true
+
+      define(:need_caching, false)
+      define(:real_appendable, true)
+      define(:writable, true)
 
       def initialize(uri)
         super(uri.absolute)
@@ -174,7 +177,7 @@ module Pione
         # modify mtime
         begin
           dest.mtime = self.mtime if option[:keep_mtime]
-        rescue NotImplemented
+        rescue NotImplementedError
           msg = "the location operation faild to keep mtime: copy from %s to %s"
           Log::SystemLog.debug(msg % [address, dest.address])
         end
@@ -189,7 +192,7 @@ module Pione
       end
 
       def turn(dest)
-        if dest.kind_of?(LocalLocation)
+        if Global.file_sliding and dest.kind_of?(LocalLocation)
           move(dest)
           link(dest)
         else

data/lib/pione/location/location-exception.rb

@@ -46,5 +46,17 @@ module Pione
         "the location \"%s\" should local location" % @location.address
       end
     end
+
+    # `DropboxLocationUnavailable` is raised when Dropbox location isn't
+    # unavailable.
+    class DropboxLocationUnavailable < LocationError
+      def initialize(message)
+        @message = message
+      end
+
+      def message
+        @message
+      end
+    end
   end
 end

data/lib/pione/location/notification-scheme.rb

@@ -0,0 +1,46 @@
+module Pione
+  module Location
+    # `NotificationBroadcastScheme` is a scheme for PIONE notification protocol
+    # using UDP broadcast.
+    #
+    # @example
+    #     URI.parse("pnb://255.255.255.255:56000")
+    class NotificationBroadcastScheme < LocationScheme('pnb')
+      COMPONENT = [:scheme, :host, :port]
+    end
+
+    # `NotificationUnicastScheme` is a scheme for PIONE notification protocol
+    # using UDP unicast.
+    #
+    # @example
+    #   URI.parse("pnu://192.168.100.10:56000")
+    class NotificationUnicastScheme < LocationScheme('pnu')
+      COMPONENT = [:scheme, :host, :port]
+    end
+
+    # `NotificationMulticastScheme` is a scheme for PIONE notification protocol
+    # using UDP multicast.
+    #
+    # @example
+    #     URI.parse("pnm://239.1.2.3:56000")
+    #     URI.parse("pnm://239.1.2.4.56000?if=192.168.100.100")
+    class NotificationMulticastScheme < LocationScheme('pnm')
+      COMPONENT = [:scheme, :host, :port, :query] # path is fake
+
+      def interface
+        query_table["if"] if query
+      end
+
+      private
+
+      def query_table
+        if query
+          query.split("&").each_with_object({}) do |part, table|
+            key, val = part.split("=")
+            table[key] = val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/log.rb

@@ -4,11 +4,12 @@ module Pione
   end
 end
 
-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
+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/message-log-receiver' # message log receiver
+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

@@ -1,11 +1,11 @@
 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. 
+    # shown when according debug flags (system, rule_engine, 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.
+      # 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)
@@ -13,18 +13,18 @@ module Pione
       end
 
       # Show a debug message about rule engine activity. This message is visible
-      # when +Global.debug_rule_engine+ is true in client side.
+      # 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)
+      # Show a debug message about notification. This message is visible when
+      # `Global.debug_notification` is true.
+      def self.notification(msg_or_exc=nil, pos=caller(1).first, &b)
+        if Global.debug_notification
+          print(:notification, msg_or_exc, pos, &b)
         end
       end
 

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

@@ -41,10 +41,15 @@ module Pione
       #
       # @return [void]
       def save
+        domain_info_location = @domain_location + FILENAME
         text = "== %s\n\n" % Time.now
         text << @record.map{|key, val| "- %s: %s" % [key,val]}.join("\n")
         text << "\n\n"
-        (@domain_location + FILENAME).append(text)
+        if domain_info_location.exist?
+          domain_info_location.append(text)
+        else
+          domain_info_location.create(text)
+        end
       end
 
       private

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

@@ -0,0 +1,32 @@
+module Pione
+  module Log
+    # MessageLogReceiver is an abstract class for message log receivers.
+    class MessageLogReceiver
+      # Receive the message with attributes.
+      #
+      # @param message [String]
+      #   the message
+      # @param level [Integer]
+      #   message depth level
+      # @param header [String]
+      #   message header
+      # @param color [String]
+      #   message color
+      def receiver(message, level, header, color)
+        raise NotImplementedError.new
+      end
+    end
+
+    # `CUIMessageLogReceiver` is a message log receiver for CUI
+    # environment. This receiver prints messages to stdout.
+    class CUIMessageLogReceiver < MessageLogReceiver
+      def initialize(out=$stdout)
+        @out = out
+      end
+
+      def receive(message, level, header, color)
+        @out.puts "%s%s %s" % ["  "*level, ("%5s" % header).color(color), message]
+      end
+    end
+  end
+end

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

@@ -1,118 +1,33 @@
 module Pione
   module Log
-    module SystemLog
-      # 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
-
-      # Log the error message.
-      def self.error(msg, pos=caller(1).first)
-        Global.system_logger.error(msg, pos)
-      end
-
-      # Log the warn message.
-      def self.warn(msg, pos=caller(1).first)
-        Global.system_logger.warn(msg, pos)
-      end
-
-      # Log the info message.
-      def self.info(msg, pos=caller(1).first)
-        Global.system_logger.info(msg, pos)
-      end
-
-      # Log the debug message.
-      def self.debug(msg, pos=caller(1).first)
-        Global.system_logger.debug(msg, pos)
-      end
-
-      def self.terminate
-        Global.system_logger.terminate
-      end
-    end
-
-    # SystemLogger is a interface for system logger implementations.
-    class SystemLogger
-      @logger = {} # logger class table
+    SystemLog = Rootage::Log
+    SystemLog.set_logger_block {Global.system_logger}
 
-      # 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.
-      def fatal(msg, pos=caller(1).first)
-        raise NotImplementedError
-      end
-
-      # Log the error message.
-      def error(msg, pos=caller(1).first)
-        raise NotImplementedError
-      end
-
-      # Log the warn message.
-      def warn(msg, pos=caller(1).first)
-        raise NotImplementedError
-      end
+    # `Log::PioneSystemLogger` is a PIONE original logger. This generates very
+    # colorful message for identifiability and detailed informations.
+    class PioneSystemLogger < Rootage::Logger
+      include DRbUndumped
 
-      # Log the info message.
-      def info(msg, pos=caller(1).first)
-        raise NotImplementedError
-      end
-
-      # Log the debug message.
-      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)
+      def initialize(out = nil)
         @queue = Queue.new
         @thread = make_writer_thread
         @level = :info
+        @lock = Mutex.new
         @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 fatal(msg, pos=caller(1).first, pid=Process.pid); push(:fatal, msg, pos, pid); end
+      def error(msg, pos=caller(1).first, pid=Process.pid); push(:error, msg, pos, pid); end
+      def warn (msg, pos=caller(1).first, pid=Process.pid); push(:warn , msg, pos, pid); end
+      def info (msg, pos=caller(1).first, pid=Process.pid); push(:info , msg, pos, pid); end
+      def debug(msg, pos=caller(1).first, pid=Process.pid); push(:debug, msg, pos, pid); end
 
       def terminate
         timeout(3) do
           while @thread.alive?
-            if @queue.empty?
+            if @queue.empty? and not(@lock.locked?)
               @thread.kill.join
               break
             else
@@ -121,11 +36,11 @@ module Pione
           end
         end
       rescue Timeout::Error
+        # don't use logger here because it is dead at this time
+        $stdout.puts("*** system logger has been terminated unsafety, some messages maybe lost ***")
+      ensure
         # 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?
@@ -134,75 +49,83 @@ module Pione
 
       private
 
+      def level_to_i(level)
+        case level
+        when :fatal; 0
+        when :error; 1
+        when :warn ; 2
+        when :info ; 3
+        when :debug; 4
+        end
+      end
+
       def make_writer_thread
         Thread.new do
           while true do
-            level, msg, pos, time = @queue.pop
-            print(level, msg, pos, time)
+            level, msg, pos, pid, time = @queue.pop
+            @lock.synchronize {print(level, msg, pos, pid, time)}
           end
         end
       end
 
-      def push(level, msg, pos)
-        @queue.push([level, msg, pos, Time.now])
+      def push(level, msg, pos, pid)
+        if level_to_i(@level) >= level_to_i(level)
+          @queue.push([level, msg, pos, pid, Time.now])
+        end
       end
 
       def color_of(level)
         Global.send("pione_system_logger_%s" % level)
       end
 
-      def print(level, msg, pos, time)
+      def print(level, msg, pos, pid, time)
+        out = @out || $stdout
         if level == :info
-          @out.puts "%s: %s" % [level.to_s.color(color_of(level)), msg]
+          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]
+          out.puts "%s: %s [%s] (%s, #%s)" % [level.to_s.color(color_of(level)), msg, pos, time.iso8601(3), pid]
         end
       end
     end
 
-    # StandardSystemLogger is a logger using Ruby standard Logger.
-    class RubyStandardSystemLogger < SystemLogger
-      forward! :@logger, :level, :level=
+    class DelegatableLogger < Rootage::Logger
+      include DRbUndumped
 
-      def initialize(out = $stdout)
-        @logger = Logger.new(out)
+      def initialize(logger)
+        @logger = logger
       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
+      def fatal(msg, pos=caller(1).first, pid=Process.pid)
+        send_message(msg, pos, pid) {@logger.fatal(msg, pos, pid)}
       end
 
-      def queued?
-        false
+      def error(msg, pos=caller(1).first, pid=Process.pid)
+        send_message(msg, pos, pid) {@logger.error(msg, pos, pid)}
       end
-    end
 
-    # SyslogSystemLogger is a logger using syslog("syslog-logger" gem).
-    class SyslogSystemLogger < SystemLogger
-      forward! :@logger, :level, :level=
+      def warn(msg, pos=caller(1).first, pid=Process.pid)
+        send_message(msg, pos, pid) {@logger.warn(msg, pos, pid)}
+      end
 
-      def initialize
-        @logger = Logger::Syslog.new('pione')
+      def info(msg, pos=caller(1).first, pid=Process.pid)
+        send_message(msg, pos, pid) {@logger.info(msg, pos, pid)}
       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 debug(msg, pos=caller(1).first, pid=Process.pid)
+        send_message(msg, pos, pid) {@logger.debug(msg, pos, pid)}
+      end
 
       def terminate
-        # ignore
+        @logger = nil
       end
 
-      def queued?
-        false
+      private
+
+      def send_message(msg, pos, pid, &block)
+        block.call
+      rescue Exception
+        # print stdout directly if the logger fails
+        $stdout.puts("%s (%s) #%s" % [msg, pos, pid])
       end
     end
 
@@ -210,8 +133,6 @@ module Pione
     # register loggers
     #
 
-    SystemLogger.register(:pione, PioneSystemLogger)
-    SystemLogger.register(:ruby, RubyStandardSystemLogger)
-    SystemLogger.register(:syslog, SyslogSystemLogger)
+    Rootage::Logger.register(:pione, PioneSystemLogger)
   end
 end