rjspotter-ramaze 2009.06.29

data/lib/ramaze/log/rotatinginformer.rb

@@ -0,0 +1,168 @@
+module Ramaze
+
+  module Logger
+
+    # A customized logger (based on Informer) that creates multiple log files based on time
+
+    class RotatingInformer
+      include Innate::Traited
+      include Logging
+
+      attr_accessor :time_format, :log_levels
+      attr_reader :base_dir
+
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Create a new instance of RotatingInformer.
+      #
+      # base_dir is the directory where all log files will be stored
+      #
+      # time_format is the time format used to name the log files.
+      # Possible formats are identical to those
+      # accepted by Time.strftime
+      #
+      # log_levelse is an array describing what kind of messages
+      # that the log receives. The array may contain
+      # any or all of the symbols :debug, :error, :info and/or :warn
+      #
+      # Examples:
+      #   RotatingInformer.new('logs')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM-DD.log
+      #   RotatingInformer.new('logs', '%Y-%m.txt')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt
+      #   RotatingInformer.new('logs', '%Y-%m.txt', [:error])
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt. Only errors will be
+      #                                       logged to the files.
+
+      def initialize(base_dir, time_format = '%Y-%m-%d.log', log_levels = [:debug, :error, :info, :warn])
+        # Verify and set base directory
+        send :base_dir=, base_dir, true
+
+        @time_format = time_format
+        @log_levels = log_levels
+
+        # Keep track of log shutdown (to prevent StackErrors due to recursion)
+        @in_shutdown = false
+      end
+
+      # Set the base directory for log files
+      #
+      # If this method is called with the raise_exception
+      # parameter set to true the method will raise an exception
+      # if the specified directory does not exist or is unwritable.
+      #
+      # If raise_exception is set to false, the method will just
+      # silently fail if the specified directory does not exist
+      # or is unwritable
+
+      def base_dir=(directory, raise_exception = false)
+        # Expand directory path
+        base_dir = File.expand_path(directory)
+        # Verify that directory path exists
+        if File.exist?(base_dir)
+          # Verify that directory path is a directory
+          if File.directory?(base_dir)
+            # Verify that directory path is writable
+            if File.writable?(base_dir)
+              @base_dir = base_dir
+            else
+              raise Exception.new("#{base_dir} is not writable") if raise_exception
+            end
+          else
+            raise Exception.new("#{base_dir} is not a directory") if raise_exception
+          end
+        else
+          raise Exception.new("#{base_dir} does not exist.") if raise_exception
+        end
+      end
+
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          unless @in_shutdown
+            @in_shutdown = true
+            Log.debug("close, #{@out.inspect}")
+            @in_shutdown = false
+          end
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+
+        return unless @log_levels.include?(tag)
+
+        # Update current log
+        update_current_log
+
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
+
+        @out.flush if @out.respond_to?(:flush)
+      end
+
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
+
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
+
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
+
+        message
+      end
+
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
+
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+      end
+
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) && @out.closed?
+      end
+
+      private
+
+      # Checks whether current filename is still valid.
+      # If not, update the current log to point at the new
+      # filename
+
+      def update_current_log
+        out = File.join(@base_dir, Time.now.strftime(@time_format))
+        if @out.nil? || @out.path != out
+          # Close old log if necessary
+          shutdown unless @out.nil? || closed?
+
+          # Start new log
+          @out = File.open(out, 'ab+')
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/syslog.rb

@@ -0,0 +1,51 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'syslog'
+
+# Add aliases for the levelnames used by Ramaze logging
+module Syslog
+    alias dev debug
+    alias warn warning
+    alias error err
+    module_function :dev, :warn, :error 
+end
+
+module Ramaze
+    module Logger
+        # Logger class for writing to syslog. It is a *very* thin wrapper
+        # around the Syslog library.
+        class Syslog
+		    include Logging
+
+            # Open the syslog library, if it is allready open, we reopen it using the
+            # new argument list.  The argument list is passed on to the Syslog library
+            # so please check that, and man syslog for detailed information.  
+            # There are 3 parameters:
+            #
+            #   ident:  The identification used in the log file, defaults to $0
+            #   options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
+            #   facility: defaults to Syslog::LOG_USER
+            #
+            def initialize( *args )
+	    	    ::Syslog.close if ::Syslog.opened?
+	    	    ::Syslog.open( *args )
+            end
+
+            # just sends all messages received to ::Syslog
+            # We simply return if the log was closed for some reason, this behavior
+            # was copied from Informer.  We do not handle levels here. This will
+            # be done by te syslog daemon based on it's configuration.
+            def log(tag, *messages)
+			    return if !::Syslog.opened?
+              	::Syslog.send(tag, *messages)
+            end
+
+            # Has to call the modules singleton-method.
+            def inspect
+              ::Syslog.inspect
+            end
+        end
+    end
+end

data/lib/ramaze/log/xosd.rb

@@ -0,0 +1,92 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Ramaze::Log.log( :warn, "Both xosd gems are currently known to be broken" )
+require 'xosd'
+require 'thread'
+
+module Ramaze
+  module Logger
+
+    # Informer for the XOSD notification system for X11.
+    #
+    # You can install the ruby-bindings with:
+    #   gem install xosd.
+
+    class Xosd < ::Xosd
+      attr_accessor :options
+
+      include Logging
+
+      DEFAULT = {
+        :font_size       => 20,
+        :font            => "-*-*-*-*-*-*-%d-*-*-*-*-*-*-*",
+        :align           => 'center',
+        :color           => '#FFFFFF',
+        :lines           => 3,
+        :valign          => 'top',
+        :timeout         => 3,
+        :outline_color   => "#000000",
+        :outline_width   => 1,
+        :vertical_offset => 20,
+        :colors => {
+        :error => "#FF0000",
+        :info => "#00FF00",
+        :warn => "#EAA61E",
+        :debug => "#FFFF00"
+        },
+      }
+
+      # keys to ignore when setting the options to the instance.
+      IGNORE = [:colors, :font_size, :lines]
+
+      # Here new messages are pushed to eventually displaying them.
+      QUEUE = Queue.new
+
+      # Create a new instance, valid options are in DEFAULT.
+      # In the background a new thread will be running that checks the QUEUE
+      # and processes all messages that are being sent to it.
+      # This is done to make output nicer and readable.
+
+      def initialize(options = {})
+        @options = DEFAULT.merge(options)
+
+        super(@options[:lines])
+
+        @options.each do |key, value|
+          next if IGNORE.include?(key)
+          value %= @options[:font_size] if key == :font
+          send("#{key}=", value)
+        end
+
+        Thread.new(self) do |xosd|
+          loop do
+            items = []
+            lines = xosd.options[:lines]
+            items << QUEUE.shift until QUEUE.empty? or items.size >= lines
+
+            unless items.empty?
+              # pad up with empty lines to avoid dragging around old messages.
+              items << [:info, ' '] until items.size >= lines
+
+              items.each_with_index do |(tag, message), i|
+              xosd.color = xosd.options[:colors][tag.to_sym]
+              xosd.display(message, i)
+              end
+            end
+            sleep xosd.options[:timeout]
+          end
+        end
+      end
+
+      # pushes all messages it gets on the QUEUE for further processing.
+
+      def log(tag, *messages)
+        messages.each do |message|
+          QUEUE << [tag, message]
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/middleware_compiler.rb

@@ -0,0 +1,13 @@
+module Ramaze
+  class MiddlewareCompiler < Innate::MiddlewareCompiler
+    def static(path)
+      require 'rack/contrib'
+      Rack::ETag.new(Rack::ConditionalGet.new(Rack::File.new(path)))
+    end
+
+    def directory(path)
+      require 'rack/contrib'
+      Rack::ETag.new(Rack::ConditionalGet.new(Rack::Directory.new(path)))
+    end
+  end
+end

data/lib/ramaze/plugin.rb

@@ -0,0 +1,69 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  def self.plugin(name, options = {})
+    Plugin.load(name, options)
+  end
+
+  module Plugin
+    PLUGIN_LIST = Set.new
+    EXTS = %w[rb so bundle]
+    PATH = []
+    POOL = []
+
+    module_function
+
+    Ramaze.options.setup << self
+
+    def setup
+      PLUGIN_LIST.each do |name, const, options|
+        const.setup(options) if const.respond_to?(:setup)
+      end
+    end
+
+    def teardown
+      PLUGIN_LIST.each do |name, const, options|
+        const.teardown if const.respond_to?(:teardown)
+      end
+    end
+
+    def add_pool(pool)
+      POOL.unshift(pool)
+      POOL.uniq!
+    end
+
+    add_pool(self)
+
+    def add_path(path)
+      PATH.unshift(File.expand_path(path))
+      PATH.uniq!
+    end
+
+    add_path(__DIR__)
+    add_path('')
+
+    def load(name, options)
+      name = name.to_s
+      try_require(name.snake_case)
+      PLUGIN_LIST << [name, const_get(name.camel_case), options]
+    rescue Exception => exception
+      Log.error(exception)
+      raise LoadError, "Plugin #{name} not found"
+    end
+
+    def try_require(name)
+      found = Dir[glob(name)].first
+      require(File.expand_path(found)) if found
+    rescue LoadError
+    end
+
+    def glob(name = '*')
+      "{#{paths.join(',')}}/plugin/#{name}.{#{EXTS.join(',')}}"
+    end
+
+    def paths
+      PATH
+    end
+  end
+end

data/lib/ramaze/reloader.rb

@@ -0,0 +1,172 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # It does not depend on Ramaze itself, but you might have to adjust the
+  # Reloader::Hooks module or include your own module to override the hooks.
+  # You also might have to set the Log constant.
+  #
+  # Currently, it uses RInotify if available and falls back to using File.stat.
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called
+  # In case of Ramaze it is performing a check/reload cycle at the start of
+  # every request, but also respects a cool down time, during which nothing will
+  # be done.
+  #
+  # After every reload the OPTIONS hash will be checked for changed options and
+  # assigned to the instance, so you may change options during the lifetime of
+  # your application.
+  #
+  # A number of hooks will be executed during the reload cycle, see
+  # Ramaze::ReloaderHooks for more information.
+
+  class Reloader
+    OPTIONS = {
+      # At most check every n seconds
+      # nil/false will never trigger the reload cycle
+      # 0 will cycle on every call
+      :cooldown => 2,
+
+      # Compiled files cannot be reloaded during runtime
+      :ignore => /\.so$/,
+
+      # Run cycle in a Thread.exclusive, by default no threads are used.
+      :thread => false,
+
+      # If you assign a block here it will be instance_evaled instead of
+      # calling cycle. This allows you to use for example EventMachine for
+      # well performing asynchronous cycling.
+      :control => nil, # lambda{ cycle },
+    }
+
+    begin
+      begin
+        gem('RInotify', '>=0.9') # is older version ok?
+      rescue NoMethodError # Kernel::gem might simply be not available
+      end
+
+      require 'rinotify'
+      require 'ramaze/reloader/watch_inotify'
+      Watcher = WatchInotify
+    rescue LoadError
+      # stat always available
+      require 'ramaze/reloader/watch_stat'
+      Watcher = WatchStat
+    end
+
+    def initialize(app)
+      @app = app
+      @files = {}
+      @watcher = Watcher.new
+      options_reload
+    end
+
+    def options_reload
+      @cooldown, @ignore, @control, @thread =
+        OPTIONS.values_at(:cooldown, :ignore, :control, :thread)
+    end
+
+    def call(env)
+      options_reload
+
+      @watcher.call(@cooldown) do
+        if @control
+          instance_eval(&@control)
+        elsif @thread
+          Thread.exclusive{ cycle }
+        else
+          cycle
+        end
+      end
+
+      @app.call(env)
+    end
+
+    def cycle
+      before_cycle
+
+      rotation{|file| @watcher.watch(file) }
+      @watcher.changed_files{|f| safe_load(f) }
+
+      after_cycle
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file)
+      before_safe_load(file)
+      load(file)
+      after_safe_load_succeed(file)
+    rescue Object => ex
+      Log.error(ex)
+      after_safe_load_failed(file, ex)
+    end
+
+    def rotation
+      files = [$0, __FILE__, *$LOADED_FEATURES].uniq
+      paths = ['./', *$LOAD_PATH].uniq
+
+      files.each do |file|
+        next if file =~ @ignore
+        if not @files.has_key?(file) and path = figure_path(file, paths)
+          @files[file] = path
+          yield path
+        end
+      end
+    end
+
+    def figure_path(file, paths)
+      if Pathname.new(file).absolute?
+        return File.exist?(file) ? file : nil
+      end
+
+      paths.each do |possible_path|
+        full_path = File.join(possible_path, file)
+        return full_path if File.exist?(full_path)
+      end
+      nil
+    end
+
+
+    # Holds hooks that are called before and after #cycle and #safe_load
+    module Hooks
+      # Overwrite to add actions before the reload rotation is started.
+      def before_cycle
+      end
+
+      # Overwrite to add actions after the reload rotation has ended.
+      def after_cycle
+      end
+
+      # Overwrite to add actions before a file is Kernel::load-ed
+      def before_safe_load(file)
+        Log.debug("reload #{file}")
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed successfully,
+      # by default we clean the Cache for compiled templates and resolved actions.
+      def after_safe_load_succeed(file)
+        Cache.clear_after_reload
+        after_safe_load(file)
+      end
+
+      # Overwrite to add custom hook in addition to default Cache cleaning
+      def after_safe_load(file)
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed unsuccessfully,
+      # by default we output an error-message with the exception.
+      def after_safe_load_failed(file, error)
+        Log.error(error)
+      end
+    end
+
+    include Hooks
+
+  end
+end