ptomato-ramaze 2009.02

data/lib/ramaze/option.rb

@@ -0,0 +1,156 @@
+require 'ramaze/option/dsl'
+require 'ramaze/option/holder'
+
+module Ramaze
+  Global = Option::Holder.new
+
+  Option::DSL.new Global do
+    o "List of aliases for adapters",
+      :adapter_aliases, {
+        "mongrel"             => "Mongrel",
+        "evented_mongrel"     => "Mongrel",
+        "fcgi"                => "Fcgi",
+        "thin"                => "Thin",
+        "ebb"                 => "Ebb",
+        "cgi"                 => "Cgi",
+        "lsws"                => "LSWS",
+        "scgi"                => "SCGI",
+        "webrick"             => "WEBrick",
+        "swiftiplied_mongrel" => "Mongrel",
+      }
+
+    o "Hash of aliases for caches",
+      :cache_aliases, {
+        "memory"    => "MemoryCache",
+        "yaml"      => "YAMLStoreCache",
+        "memcache"  => "MemcachedCache",
+        "memcached" => "MemcachedCache",
+      }
+
+    o "Disable templates without actions",
+      :actionless_templates, true, :cli => true
+
+    o "Set adapter Ramaze will run on.",
+      :adapter, :webrick, :cli => @config[:adapter_aliases][1].keys, :short => :a
+
+    o "Set the size of Backtrace shown.",
+      :backtrace_size, 10, :cli => 10
+
+    o "Turn benchmarking every request on.",
+      :benchmarking, false, :short => :b, :cli => false
+
+    o "Do not log about these requests to static files, values as in Global.ignore",
+      :boring, ["/favicon.ico"]
+
+    o "Use this for general caching and as base for Cache.new.",
+      :cache, :memory, :cli => [:memory, :memcached, :yaml]
+
+    o "Turn on naive caching of all requests.",
+      :cache_all, false, :cli => false
+
+    o "Alternative caches",
+      :cache_alternative, {}
+
+    o "Don't cache action if session flash data is present for a request.",
+      :no_cache_flash, true, :cli => true
+
+    o "Compile Templates",
+      :compile, false, :cli => false
+
+    o "Start Ramaze within an IRB session",
+      :console, false, :short => :c
+
+    o "Active contribs",
+      :contribs, Set.new
+
+    o "Set default Content-Type for responses",
+      :content_type, "text/html"
+
+    o "Set default Accept-Charset for responses. No header set if nil.",
+      :accept_charset, nil
+
+    o "All subclasses of Controller are collected here.",
+      :controllers, Set.new
+
+    o "Instruction for daemonize, only works with bin/ramaze for now",
+      :daemonize, '', :cli => [:start, :stop]
+
+    o "Turn on customized error pages. Use Rack::ShowException otherwise.",
+      :error_page, true, :cli => true
+
+    o "Cache actions to filesystem, uses String as directory name or Global.public_root if other truism",
+      :file_cache, false, :cli => false
+
+    o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",
+      :host, "0.0.0.0", :cli => "0.0.0.0"
+
+    o "Ignore requests to these paths if no file in public_root exists, absolute path or regex",
+      :ignore, ["/favicon.ico"]
+
+    o "Body set on ignored paths",
+      :ignore_body, "File not found"
+
+    o "Status set on ignored paths",
+      :ignore_status, 404
+
+    o "Enable directory listing",
+      :list_directories, false
+
+    o "Templating engines to load on startup",
+      :load_engines, nil
+
+    o "All paths to controllers are mapped here.",
+      :mapping, {}
+
+    o "Activate middleware",
+      :middleware, true
+
+    o "For your own modes to decide on",
+      :mode, :live, :cli => [:live, :dev, :spec]
+
+    o "The place ramaze was started from, useful mostly for debugging",
+      :origin, :main
+
+    o "Specify port",
+      :port, 7000, :short => :p, :cli => 7000
+
+    o "Specify directory to serve static files",
+      :public_root, "public", :cli => "public"
+
+    o "Prefix for incoming and outgoing links",
+      :prefix, '/'
+
+    o "Record all Request objects by assigning a filtering Proc to me.",
+      :record, false
+
+    o "root directory of your application (former APPDIR)",
+      :root, File.dirname(File.expand_path($0))
+
+    o "Don't wait until all adapter-threads are finished or killed.",
+      :run_loose, false, :cli => false
+
+    o "The runner of your application (start.rb)",
+      :runner, "/home/manveru/c/ramaze/examples/hello.rb"
+
+    o "The running server will be put here from Adapter.",
+      :server, nil
+
+    o "Turn on session for all requests.",
+      :sessions, true, :cli => true
+
+    o "Turn on BF/DoS protection for error-responses",
+      :shield, false, :cli => false
+
+    o "What signal to trap to call Ramaze::shutdown",
+      :shutdown_trap, "SIGINT"
+
+    o "Interval in seconds of the Reloader",
+      :sourcereload, 3, :cli => 3
+
+    o "Test before start if adapters will be able to connect",
+      :test_connections, true, :cli => true
+
+    o "Specify directory to serve dynamic files",
+      :view_root, "view", :cli => "view"
+  end
+end

data/lib/ramaze/reloader/watch_inotify.rb

@@ -0,0 +1,85 @@
+module Ramaze
+  class Reloader
+    # TODO:
+    #   * There seems to be a problem somewhere that I couldn't identify yet, a
+    #     file has to be modified twice initially to make it show up as
+    #     modified here, subsequent changes work just fine.
+    #     The only workaround I could find right now would be to read/write
+    #     every single file, but that would be unexpected, irresponsible, and
+    #     error-prone.
+    #
+    # NOTE:
+    #   * I have changed from using a Mutex to using a Queue, which uses a
+    #     Mutex internally.
+
+    class WatchInotify
+      POLL_INTERVAL = 2 # seconds
+      NOTIFY_MASK = RInotify::MODIFY | RInotify::IN_ONESHOT
+
+      def initialize
+        @watcher = RInotify.new
+        @changed = Queue.new
+        @watcher_thread = start_watcher
+      end
+
+      def call(cooldown)
+        yield
+      end
+
+      # TODO: define a finalizer to cleanup? -- reloader never calls #close
+
+      def start_watcher
+        Thread.new{ loop{ watcher_cycle }}
+      end
+
+      # Not much work here, we just have to empty the event queue and push the
+      # descriptors for reloading on next request.
+      def watcher_cycle
+        return unless @watcher.wait_for_events(POLL_INTERVAL)
+
+        @watcher.each_event do |event|
+          @changed.push(event.watch_descriptor)
+        end
+      end
+
+      def watch(file)
+        return if @watcher.watch_descriptors.has_value?(file)
+        return unless File.exist?(file)
+
+        @watcher.add_watch(file, NOTIFY_MASK)
+      rescue Errno::ENOENT
+        retry
+      end
+
+      # FIXME:
+      #   Seems like this won't work due to some bug in the rinotify library.
+      #   Would be cool if someone could make a FFI version.
+
+      def remove_watch(file)
+        @watcher.rm_watch(file)
+      end
+
+      def close
+        @watcher_thread.terminate
+        @watcher.close
+        true
+      end
+
+      # NOTE:
+      #   We have to add the changed file again after we got a notification, I
+      #   have no idea why, but using IN_ONESHOT should make sure that there is
+      #   no memory leak in the C level even if we add a file again.
+      #   There is a memory leak however in the watch_descriptors hash, since
+      #   rinotify won't synchronize the contents properly and will only add to
+      #   the hash, so we have to clean up ourselves.
+      def changed_files
+        until @changed.empty?
+          descriptor = @changed.shift
+          file = @watcher.watch_descriptors.delete(descriptor)
+          watch(file)
+          yield(file)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/reloader/watch_stat.rb

@@ -0,0 +1,58 @@
+module Ramaze
+  class Reloader
+    class WatchStat
+      def initialize
+        # @files[file_path] = stat
+        @files = {}
+        @last = Time.now
+      end
+
+      def call(cooldown)
+        if cooldown and Time.now > @last + cooldown
+          yield
+          @last = Time.now
+        end
+      end
+
+      # start watching a file for changes
+      # true if succeeded, false if failure
+      def watch(file)
+        return true if watching?(file) # if already watching
+        if stat = safe_stat(file)
+          @files[file] = stat
+        end
+      end
+
+      def watching?(file)
+        @files.has_key?(file)
+      end
+
+      # stop watching a file for changes
+      def remove_watch(file)
+        @files.delete(file)
+      end
+
+      # no need for cleanup
+      def close
+      end
+
+      # return files changed since last call
+      def changed_files
+        @files.each do |file, stat|
+          if new_stat = safe_stat(file)
+            if new_stat.mtime > stat.mtime
+              @files[file] = new_stat
+              yield(file)
+            end
+          end
+        end
+      end
+
+      def safe_stat(file)
+        File.stat(file)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end
+  end
+end

data/lib/ramaze/reloader.rb

@@ -0,0 +1,170 @@
+#          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
+      gem 'RInotify', '>=0.9' # is older version ok?
+      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 = nil)
+      @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) if @app
+    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)
+        Ramaze::Cache.compiled.clear
+        Ramaze::Cache.resolved.clear
+        Ramaze::Cache.action_methods.clear
+        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