merb-core 0.9.2

data/lib/merb-core/dispatch/session/memcached.rb

@@ -0,0 +1,161 @@
+require 'memcache_util'
+module Merb
+
+  module SessionMixin #:nodoc:
+
+    # Adds a before and after dispatch hook for setting up the memcached
+    # session store.
+    #
+    # ==== Parameters
+    # base<Class>:: The class to which the SessionMixin is mixed into.
+    def setup_session
+      before = cookies[_session_id_key]
+      request.session, cookies[_session_id_key] = Merb::MemCacheSession.persist(cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(request.session.data).hash
+      @_new_cookie = cookies[_session_id_key] != before
+    end
+
+    # Finalizes the session by storing the session ID in a cookie, if the
+    # session has changed.
+    def finalize_session 
+      if @_fingerprint != Marshal.dump(request.session.data).hash
+        ::Cache.put("session:#{request.session.session_id}", request.session.data)
+      end
+      set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
+    end
+
+    # ==== Returns
+    # String:: The session store type, i.e. "memcache".
+    def session_store_type
+      "memcache"
+    end
+  end
+
+  ##
+  # Sessions stored in memcached.
+  #
+  # Requires setup in your +init.rb+:
+  #
+  #   require 'memcache'
+  #   CACHE = MemCache.new('127.0.0.1:11211', { :namespace => 'my_app' })
+  #
+  # And a setting in +init.rb+:
+  #
+  #   c[:session_store] = 'memcache'
+  class MemCacheSession
+
+    attr_accessor :session_id
+    attr_accessor :data
+    attr_accessor :needs_new_cookie
+
+    # ==== Parameters
+    # session_id<String>:: A unique identifier for this session.
+    def initialize(session_id)
+      @session_id = session_id
+      @data = {}
+    end
+
+    class << self
+
+      # Generates a new session ID and creates a new session.
+      #
+      # ==== Returns
+      # MemCacheSession:: The new session.
+      def generate
+        sid = Merb::SessionMixin::rand_uuid
+        new(sid)
+      end
+
+      # ==== Parameters
+      # session_id<String:: The ID of the session to retrieve.
+      #
+      # ==== Returns
+      # Array::
+      #   A pair consisting of a MemCacheSession and the session's ID. If no
+      #   sessions matched session_id, a new MemCacheSession will be generated.
+      def persist(session_id)
+        unless session_id.blank?
+          session = ::Cache.get("session:#{session_id}")
+          if session.nil?
+            # Not in memcached, but assume that cookie exists
+            session = new(session_id)
+          end
+        else
+          # No cookie...make a new session_id
+          session = generate
+        end
+        if session.is_a?(MemCacheSession)
+          [session, session.session_id]
+        else
+          # recreate using the rails session as the data
+          session_object = MemCacheSession.new(session_id)
+          session_object.data = session
+          [session_object, session_object.session_id]
+        end
+
+      end
+
+      # Don't try to reload in dev mode.
+      def reloadable? #:nodoc:
+        false
+      end
+
+    end
+
+    # Regenerate the session ID.
+    def regenerate 
+      @session_id = Merb::SessionMixin::rand_uuid 
+      self.needs_new_cookie=true 
+    end 
+      
+    # Recreates the cookie with the default expiration time. Useful during log
+    # in for pushing back the expiration date.
+    def refresh_expiration 
+      self.needs_new_cookie=true 
+    end 
+     
+    # Deletes the session by emptying stored data.
+    def delete  
+      @data = {} 
+    end
+
+    # ==== Returns
+    # Boolean:: True if session has been loaded already.
+    def loaded?
+      !! @data
+    end
+    
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to set.
+    # v<~to_s>:: The value of the session parameter to set.
+    def []=(k, v) 
+      @data[k] = v
+    end
+
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to retrieve.
+    #
+    # ==== Returns
+    # String:: The value of the session parameter.
+    def [](k) 
+      @data[k] 
+    end
+
+    # Yields the session data to an each block.
+    #
+    # ==== Parameter
+    # &b:: The block to pass to each.
+    def each(&b) 
+      @data.each(&b) 
+    end
+    
+    private
+
+    # Attempts to redirect any messages to the data object.
+    def method_missing(name, *args, &block)
+      @data.send(name, *args, &block)
+    end
+
+  end
+
+end

data/lib/merb-core/dispatch/session/memory.rb

@@ -0,0 +1,234 @@
+module Merb
+
+  module SessionMixin #:nodoc:
+
+    # Adds a before and after dispatch hook for setting up the memory session
+    # store.
+    #
+    # ==== Parameters
+    # base<Class>:: The class to which the SessionMixin is mixed into.
+    def setup_session
+      before = cookies[_session_id_key]
+      request.session , cookies[_session_id_key] = Merb::MemorySession.persist(cookies[_session_id_key])
+      @_new_cookie = cookies[_session_id_key] != before
+    end
+
+    # Finalizes the session by storing the session ID in a cookie, if the
+    # session has changed.
+    def finalize_session
+      set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
+    end
+
+    # ==== Returns
+    # String:: The session store type, i.e. "memory".
+    def session_store_type
+      "memory"
+    end
+  end
+  
+  ##
+  # Sessions stored in memory.
+  #
+  # And a setting in +merb.yml+:
+  #
+  #   :session_store: memory
+  #   :memory_session_ttl: 3600 (in seconds, one hour)
+  #
+  # Sessions will remain in memory until the server is stopped or the time
+  # as set in :memory_session_ttl expires.
+  class MemorySession
+
+    attr_accessor :session_id
+    attr_accessor :data
+    attr_accessor :needs_new_cookie
+
+    # ==== Parameters
+    # session_id<String>:: A unique identifier for this session.
+    def initialize(session_id)
+      @session_id = session_id
+      @data = {}
+    end
+
+    class << self
+
+      # Generates a new session ID and creates a new session.
+      #
+      # ==== Returns
+      # MemorySession:: The new session.
+      def generate
+        sid = Merb::SessionMixin::rand_uuid
+        MemorySessionContainer[sid] = new(sid)
+      end
+
+      # ==== Parameters
+      # session_id<String:: The ID of the session to retrieve.
+      #
+      # ==== Returns
+      # Array::
+      #   A pair consisting of a MemorySession and the session's ID. If no
+      #   sessions matched session_id, a new MemorySession will be generated.
+      def persist(session_id)
+        if session_id
+          session = MemorySessionContainer[session_id]
+        end
+        unless session
+          session = generate
+        end
+        [session, session.session_id]
+      end
+
+    end
+
+    # Regenerate the Session ID
+    def regenerate
+      new_sid = Merb::SessionMixin::rand_uuid 
+      old_sid = @session_id
+      MemorySessionContainer[new_sid] = MemorySessionContainer[old_sid]
+      @session_id = new_sid
+      MemorySessionContainer.delete(old_sid)
+      self.needs_new_cookie=true 
+    end 
+      
+    # Recreates the cookie with the default expiration time. Useful during log
+    # in for pushing back the expiration date.
+    def refresh_expiration 
+      self.needs_new_cookie=true 
+    end 
+     
+    # Deletes the session by emptying stored data.
+    def delete
+      @data = {} 
+    end
+     
+    # ==== Returns
+    # Boolean:: True if session has been loaded already.
+    def loaded?
+      !! @data
+    end
+    
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to set.
+    # v<~to_s>:: The value of the session parameter to set.
+    def []=(k, v) 
+      @data[k] = v
+    end
+
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to retrieve.
+    #
+    # ==== Returns
+    # String:: The value of the session parameter.
+    def [](k) 
+      @data[k] 
+    end
+
+    # Yields the session data to an each block.
+    #
+    # ==== Parameter
+    # &b:: The block to pass to each.
+    def each(&b) 
+      @data.each(&b) 
+    end
+    
+    private
+
+    # Attempts to redirect any messages to the data object.
+    def method_missing(name, *args, &block)
+      @data.send(name, *args, &block)
+    end
+
+  end
+
+  # Used for handling multiple sessions stored in memory.
+  class MemorySessionContainer
+    class << self
+
+      # ==== Parameters
+      # ttl<Fixnum>:: Session validity time in seconds. Defaults to 1 hour.
+      #
+      # ==== Returns
+      # MemorySessionContainer:: The new session container.
+      def setup(ttl=nil)
+        @sessions = Hash.new
+        @timestamps = Hash.new
+        @mutex = Mutex.new
+        @session_ttl = ttl || 60*60 # default 1 hour
+        start_timer
+        self
+      end
+
+      # Creates a new session based on the options.
+      #
+      # ==== Parameters
+      # opts<Hash>:: The session options (see below).
+      #
+      # ==== Options (opts)
+      # :session_id<String>:: ID of the session to create in the container.
+      # :data<MemorySession>:: The session to create in the container.
+      def create(opts={})
+        self[opts[:session_id]] = opts[:data]
+      end
+
+      # ==== Parameters
+      # key<String>:: ID of the session to retrieve.
+      #
+      # ==== Returns
+      # MemorySession:: The session corresponding to the ID.
+      def [](key)
+        @mutex.synchronize {
+          @timestamps[key] = Time.now
+          @sessions[key]
+        }
+      end
+
+      # ==== Parameters
+      # key<String>:: ID of the session to set.
+      # val<MemorySession>:: The session to set.
+      def []=(key, val) 
+        @mutex.synchronize {
+          @timestamps[key] = Time.now
+          @sessions[key] = val
+        } 
+      end
+
+      # ==== Parameters
+      # key<String>:: ID of the session to delete.
+      def delete(key)
+        @mutex.synchronize {
+          @sessions.delete(key)
+          @timestamps.delete(key)
+        }
+      end
+
+      # Deletes any sessions that have reached their maximum validity.
+      def reap_old_sessions
+        @timestamps.each do |key,stamp|
+          if stamp + @session_ttl < Time.now
+            delete(key)
+          end  
+        end
+        GC.start
+      end
+
+      # Starts the timer that will eventually reap outdated sessions.
+      def start_timer
+        Thread.new do
+          loop {
+            sleep @session_ttl
+            reap_old_sessions
+          } 
+        end  
+      end
+
+      # ==== Returns
+      # Array:: The sessions stored in this container.
+      def sessions
+        @sessions
+      end  
+      
+    end # end singleton class
+
+  end # end MemorySessionContainer
+end
+
+Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl])

data/lib/merb-core/gem_ext/erubis.rb

@@ -0,0 +1,19 @@
+require 'erubis'
+module Erubis
+  
+  class MEruby < Erubis::Eruby
+    include PercentLineEnhancer
+    include StringBufferEnhancer
+  end
+
+  # Loads a file, runs it through Erubis and parses it as YAML.
+  #
+  # ===== Parameters
+  # file<String>:: The name of the file to load.
+  # binding<Binding>::
+  #   The binding to use when evaluating the ERB tags. Defaults to the current
+  #   binding.
+  def self.load_yaml_file(file, binding = binding)
+    YAML::load(Erubis::MEruby.new(IO.read(File.expand_path(file))).result(binding))
+  end
+end

data/lib/merb-core/logger.rb

@@ -0,0 +1,230 @@
+require "time" # httpdate
+# ==== Public Merb Logger API
+#
+# To replace an existing logger with a new one:
+#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Merb.logger.fatal(message<String>,&block)
+#   Merb.logger.error(message<String>,&block)
+#   Merb.logger.warn(message<String>,&block)
+#   Merb.logger.info(message<String>,&block)
+#   Merb.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Merb.logger.fatal!(message<String>,&block)
+#   Merb.logger.error!(message<String>,&block)
+#   Merb.logger.warn!(message<String>,&block)
+#   Merb.logger.info!(message<String>,&block)
+#   Merb.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to 
+#   Merb.logger.flush
+#
+# Remove the current log object
+#   Merb.logger.close
+# 
+# ==== Private Merb Logger API
+# 
+# To initialize the logger you create a new object, proxies to set_log.
+#   Merb::Logger.new(log{String, IO},level{Symbol, String})
+module Merb
+
+  class << self #:nodoc:
+    attr_accessor :logger
+  end
+
+  class Logger
+
+    attr_accessor :aio
+    attr_accessor :level
+    attr_accessor :delimiter
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels = 
+    {
+      :fatal => 7, 
+      :error => 6, 
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }
+
+    private
+
+    # Define the write method based on if asynchronous IO an be used.
+    #
+    # ==== Notes
+    # The idea here is that instead of performing an 'if' conditional check on
+    # each logging we do it once when the log object is setup.
+    def set_write_method
+      @log.instance_eval do
+
+        # ==== Returns
+        # Boolean:: True if asynchronous IO can be used.
+        def aio?
+          @aio = !Merb.environment.to_s.match(/development|test/) && 
+          !RUBY_PLATFORM.match(/java|mswin/) &&
+          !(@log == STDOUT) &&
+          @log.respond_to?(:write_nonblock)
+        end
+
+        undef write_method if defined? write_method #:nodoc:
+        if aio?
+          alias :write_method :write_nonblock
+        else
+          alias :write_method :write
+        end
+      end
+    end
+
+    # Readies a log for writing.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    def initialize_log(log)
+      close if @log # be sure that we don't leave open files laying around.
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
+      end
+      set_write_method
+    end
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Parameters
+    # *args:: Arguments to create the log from. See set_logs for specifics.
+    def initialize(*args)
+      @init_args = args
+      set_log(*args)
+    end
+
+    # Replaces an existing logger with a new one.
+    # 
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    # log_level<~to_sym>::
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+    #   production environment and :debug otherwise.
+    # delimiter<String>::
+    #   Delimiter to use between message sections. Defaults to " ~ ".
+    # auto_flush<Boolean>::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to false.
+    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
+      if log_level && Levels[log_level.to_sym]
+        @level = Levels[log_level.to_sym]
+      elsif Merb.environment == "production"
+        @level = Levels[:warn]
+      else
+        @level = Levels[:debug]
+      end
+      @buffer     = []
+      @delimiter  = delimiter
+      @auto_flush = auto_flush
+
+      initialize_log(log)
+
+      Merb.logger = self
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @log.write_method(@buffer.slice!(0..-1).to_s)
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close)
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # string<String>:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # String:: The resulting message added to the log file.
+    def <<(string = nil)
+      message = ""
+      message << delimiter
+      message << string if string
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+
+      message
+    end
+    alias :push :<<
+
+    # Generate the logging methods for Merb.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        self << message if #{number} >= level
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        self << message if #{number} >= level
+        flush if #{number} >= level
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+  end
+  
+end