merb 0.5.3 → 0.9.2

data/lib/merb/server.rb

@@ -1,169 +0,0 @@
-require 'rubygems'
-
-# Make the app's "gems" directory a place where gems are loaded from
-# This needs to go here for using in a shared envirionment where Erubis may not
-# be available
-if File.exists?(File.join(Dir.pwd,  "gems")) && File.directory?(File.join(Dir.pwd,"gems"))
-  Gem.clear_paths
-  Gem.path.unshift(File.join(Dir.pwd,"gems"))
-end
-
-
-require 'optparse'
-require 'ostruct'
-require 'fileutils'
-require 'yaml'
-
-# this is so we can test for HAML features for HAML partial inlining
-unless Gem.cache.search("haml").empty?
-  gem "haml"
-  require "haml"
-end
-
-require File.join(File.dirname(__FILE__), 'config')
-
-module Merb
-
-  class Server
-    
-    class << self
-      
-      def run
-        ::Merb::Config.parse_args
-                
-        if Merb::Config[:cluster]
-          Merb::Config[:port].to_i.upto(Merb::Config[:port].to_i+Merb::Config[:cluster].to_i-1) do |port|
-            unless alive?(port)
-              delete_pidfiles(port)
-              puts "Starting merb server on port: #{port}"
-              start(port)
-            else
-              raise "Merb is already running on port: #{port}"
-            end
-          end   
-        elsif Merb::Config[:daemonize]
-          unless alive?(Merb::Config[:port])  
-            delete_pidfiles(Merb::Config[:port])
-            start(Merb::Config[:port])
-          else
-            raise "Merb is already running on port: #{port}"
-          end
-        else
-          trap('TERM') { exit }
-          mongrel_start(Merb::Config[:port])
-        end     
-        
-      end
-      
-      def store_pid(pid,port)
-        File.open("#{Merb::Config[:merb_root]}/log/merb.#{port}.pid", 'w'){|f| f.write("#{Process.pid}\n")}
-      end
-      
-      def alive?(port)
-        f = Merb::Config[:merb_root] + "/log/merb.#{port}.pid"
-        pid = IO.read(f).chomp.to_i
-        Process.kill(0, pid)
-        true
-      rescue
-        false
-      end
-      
-      def kill(ports, sig=9)
-        begin
-          Dir[Merb::Config[:merb_root] + "/log/merb.#{ports == 'all' ? '*' : ports }.pid"].each do |f|
-            pid = IO.read(f).chomp.to_i
-            Process.kill(sig, pid)
-            FileUtils.rm f
-            puts "killed PID #{pid} with signal #{sig}"
-          end
-        rescue
-          puts "Failed to kill! #{k}"
-        ensure  
-          exit
-        end
-      end
-      
-      def start(port,what=:mongrel_start)
-        fork do
-          Process.setsid
-          exit if fork
-          File.umask 0000
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen "/dev/null", "a"
-          STDERR.reopen STDOUT
-          trap("TERM") { exit }
-          Dir.chdir Merb::Config[:merb_root]
-          send(what, port)
-        end
-      end
-      
-      def webrick_start(port)
-        Merb::BootLoader.initialize_merb
-        store_pid(Process.pid, port)
-        require 'rack'
-        require 'merb/rack_adapter'
-        ::Rack::Handler::WEBrick.run Merb::Rack::Adapter.new,
-          :Port => port
-      end
-
-      def fastcgi_start
-        Merb::BootLoader.initialize_merb
-        require 'rack'
-        require 'merb/rack_adapter'
-        ::Rack::Handler::FastCGI.run Merb::Rack::Adapter.new
-      end
-      
-      def delete_pidfiles(portor_star='*')
-        Dir["#{Merb::Config[:merb_root]}/log/merb.#{portor_star}.pid"].each do |pid|
-          FileUtils.rm(pid)  rescue nil
-        end
-      end  
-      
-      def drbserver_start(port)
-        puts "Starting merb drb server on port: #{port}"
-        require 'merb/drb_server'
-        Merb::BootLoader.initialize_merb
-        store_pid(Process.pid, "drb.#{port}")
-        drb_init = File.join(Merb.root, "/config/drb_init")
-        require drb_init if File.exist?(drb_init)
-        DRb.start_service("druby://#{Merb::Config[:host]}:#{port}", Merb::DrbServiceProvider)
-        DRb.thread.join
-      end  
-      
-      def mongrel_start(port)
-        store_pid(Process.pid, port)
-        Merb::Config[:port] = port
-        unless  Merb::Config[:generate] ||  Merb::Config[:console] ||  Merb::Config[:only_drb] ||  Merb::Config[:kill]
-          puts %{Merb started with these options:}
-          puts Merb::Config.to_yaml; puts
-        end
-        Merb::BootLoader.initialize_merb
-      
-        mconf_hash = {:host => (Merb::Config[:host]||"0.0.0.0"), :port => (port ||4000)}
-        if Merb::Config[:user] and Merb::Config[:group]
-          mconf_hash[:user]   = Merb::Config[:user]
-          mconf_hash[:group]  = Merb::Config[:group]
-        end
-        mconfig = Mongrel::Configurator.new(mconf_hash) do
-          listener do
-            uri( "/", :handler => MerbUploadHandler.new(Merb::Config), :in_front => true) if Merb::Config[:upload_path_match]
-            uri "/", :handler => MerbHandler.new(Merb.root+'/public', Merb::Config[:mongrel_x_sendfile])
-            uri "/favicon.ico", :handler => Mongrel::Error404Handler.new("") 
-          end
-          MerbHandler.path_prefix = Merb::Config[:path_prefix]
-      
-          trap("INT") { stop }
-          run
-        end
-        mconfig.join
-      end
-      
-      def config
-        Merb::Config
-      end
-      
-    end # class << self
-    
-  end # Server
-
-end # Merb

data/lib/merb/session.rb

@@ -1,23 +0,0 @@
-module Merb
-  module SessionMixin
-    
-    def rand_uuid
-      values = [
-        rand(0x0010000),
-        rand(0x0010000),
-        rand(0x0010000),
-        rand(0x0010000),
-        rand(0x0010000),
-        rand(0x1000000),
-        rand(0x1000000),
-      ]
-      "%04x%04x%04x%04x%04x%06x%06x" % values
-    end
-    
-    def needs_new_cookie!
-      @_new_cookie = true
-    end
-    
-    module_function :rand_uuid, :needs_new_cookie!
-  end
-end  

data/lib/merb/session/cookie_store.rb

@@ -1,118 +0,0 @@
-require 'base64'        # to convert Marshal.dump to ASCII
-require 'openssl'       # to generate the HMAC message digest
-
-# Most of this code is taken from bitsweat's implementation in rails
-
-module Merb
-  
-  module SessionMixin #:nodoc:
-    def setup_session
-      Merb.logger.info("Setting Up Cookie Store Sessions")
-      request.session = Merb::CookieStore.new(cookies[_session_id_key], session_secret_key)
-      @original_session = request.session.read_cookie
-    end
-    
-    def finalize_session
-      Merb.logger.info("Finalize Cookie Store Session")
-      new_session = request.session.read_cookie
-
-      if @original_session != new_session
-        set_cookie(_session_id_key, new_session, _session_expiry) 
-      end
-    end
-    
-    def session_store_type
-      "cookie"
-    end
-  end
-  
-  # If you have more than 4K of session data or don't want your data to be
-  # visible to the user, pick another session store.
-  #
-  # CookieOverflow is raised if you attempt to store more than 4K of data.
-  # TamperedWithCookie is raised if the data integrity check fails.
-  #
-  # A message digest is included with the cookie to ensure data integrity:
-  # a user cannot alter session data without knowing the secret key included
-  # in the hash. 
-  # 
-  # To use Cookie Sessions, set in config/merb.yml
-  #  :session_secret_key - your secret digest key
-  #  :session_store: cookie
-  class CookieStore
-    # TODO (maybe):
-    # include request ip address
-    # AES encrypt marshaled data
-    
-    # Raised when storing more than 4K of session data.
-    class CookieOverflow < StandardError; end
-    
-    # Raised when the cookie fails its integrity check.
-    class TamperedWithCookie < StandardError; end
-    
-    # Cookies can typically store 4096 bytes.
-    MAX = 4096
-    DIGEST = OpenSSL::Digest::Digest.new('SHA1') # or MD5, RIPEMD160, SHA256?
-    
-    attr_reader :data
-    
-    def initialize(cookie, secret)
-      if secret.nil? or secret.blank?
-        raise ArgumentError, 'A secret is required to generate an integrity hash for cookie session data.'
-      end
-      @secret = secret
-      @data = unmarshal(cookie) || Hash.new
-    end
-    
-    # return a cookie value. raises CookieOverflow if session contains too
-    # much information
-    def read_cookie
-      unless @data.nil? or @data.empty? 
-        updated = marshal(@data)
-        raise CookieOverflow if updated.size > MAX
-        updated
-      end
-    end
-    
-    # assigns a key value pair 
-    def []=(k, v) 
-      @data[k] = v
-    end
-    
-    def [](k) 
-      @data[k] 
-    end 
-     
-    def each(&b) 
-      @data.each(&b) 
-    end
-    
-    private
-    
-    def method_missing(name, *args, &block)
-      @data.send(name, *args, &block)
-    end
-    
-    # Generate the HMAC keyed message digest. Uses SHA1.
-    def generate_digest(data)
-      OpenSSL::HMAC.hexdigest(DIGEST, @secret, data)
-    end
-    
-    # Marshal a session hash into safe cookie data. Include an integrity hash.
-    def marshal(session)
-      data = Base64.encode64(Marshal.dump(session)).chop
-      Mongrel::HttpRequest.escape "#{data}--#{generate_digest(data)}"
-    end
-    
-    # Unmarshal cookie data to a hash and verify its integrity.
-    def unmarshal(cookie)
-      if cookie
-        data, digest = Mongrel::HttpRequest.unescape(cookie).split('--')
-        unless digest == generate_digest(data)
-          raise TamperedWithCookie, "Maybe the site's session_secret_key has changed?"
-        end
-        Marshal.load(Base64.decode64(data))
-      end
-    end
-  end
-end

data/lib/merb/session/mem_cache_session.rb

@@ -1,131 +0,0 @@
-require 'memcache_util'
-
-module Merb
-
-  module SessionMixin #:nodoc:
-
-    def setup_session
-      Merb.logger.info("Setting up 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
-
-    def finalize_session
-      Merb.logger.info("Finalize session")
-      if @_fingerprint != Marshal.dump(request.session.data).hash
-        ::Cache.put("session:#{@_session.session_id}", request.session.data)
-      end
-      set_cookie(_session_id_key, request.session.session_id, _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
-    end
-
-    def session_store_type
-      "memcache"
-    end
-  end
-
-  ##
-  # Sessions stored in memcached.
-  #
-  # Requires setup in your +merb_init.rb+:
-  #
-  #   require 'memcache'
-  #   CACHE = MemCache.new('127.0.0.1:11211', { :namespace => 'my_app' })
-  #
-  # And a setting in +merb.yml+:
-  #
-  #   :session_store: mem_cache
-
-  class MemCacheSession
-
-    attr_accessor :session_id
-    attr_accessor :data
-    attr_accessor :needs_new_cookie
-    
-    def initialize(session_id)
-      @session_id = session_id
-      @data = {}
-    end
-
-    class << self
-      # Generates a new session ID and creates a row for the new session in the database.
-      def generate
-        sid = Merb::SessionMixin::rand_uuid
-        new(sid)
-      end
-
-      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
-      # If none is found, generates a new session.
-      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 
-   	
-   	# Lazy-delete of session data 
-   	def delete  
-   	  @data = {} 
-   	end
-
-    # Has the session been loaded yet?
-    def loaded?
-      !! @data
-    end
-    
-    # assigns a key value pair 
-    def []=(k, v) 
-      @data[k] = v
-    end
-    
-    def [](k) 
-      @data[k] 
-    end 
-     
-    def each(&b) 
-      @data.each(&b) 
-    end
-    
-    private
-    def method_missing(name, *args, &block)
-      @data.send(name, *args, &block)
-    end
-
-  end
-
-end

data/lib/merb/session/memory_session.rb

@@ -1,176 +0,0 @@
-module Merb
-  
-  module SessionMixin #:nodoc:
-
-    def setup_session
-      Merb.logger.info("Setting up 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
-
-    def finalize_session
-      Merb.logger.info("Finalize session")
-      set_cookie(_session_id_key, request.session.session_id, _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
-    end
-     
-    def session_store_type
-      "memory"
-    end
-  end
-  
-  ##
-  # Sessions stored in memory.
-  #
-  # And a setting in +merb.yml+:
-  #
-  #   :session_store: mem_cache
-  #   :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
-    
-    def initialize(session_id)
-      @session_id = session_id
-      @data = {}
-    end
-
-    class << self
-      # Generates a new session ID and creates a row for the new session in the database.
-      def generate
-        sid = Merb::SessionMixin::rand_uuid
-        MemorySessionContainer[sid] = new(sid)
-      end
-
-      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
-      # If none is found, generates a new session.
-      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 
-   	
-   	# Lazy-delete of session data 
-   	def delete
-   	  @data = {} 
-   	end
-   	
-    # Has the session been loaded yet?
-    def loaded?
-      !! @data
-    end
-    
-    # assigns a key value pair 
-    def []=(k, v) 
-      @data[k] = v
-    end
-    
-    def [](k) 
-      @data[k] 
-    end 
-     
-    def each(&b) 
-      @data.each(&b) 
-    end
-    
-    private
-    def method_missing(name, *args, &block)
-      @data.send(name, *args, &block)
-    end
-
-  end
-  
-  class MemorySessionContainer
-    class << self
-      
-      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
-      
-      def create(opts={})
-        self[opts[:session_id]] = opts[:data]
-      end  
-
-      
-      def [](key)
-        @mutex.synchronize {
-          @timestamps[key] = Time.now
-          @sessions[key]
-        }
-      end  
-      
-      def []=(key, val) 
-        @mutex.synchronize {
-          @timestamps[key] = Time.now
-          @sessions[key] = val
-        } 
-      end
-      
-      def delete(key)
-        @mutex.synchronize {
-          @sessions.delete(key)
-          @timestamps.delete(key)
-        }
-      end
-      
-      def reap_old_sessions
-        @timestamps.each do |key,stamp|
-          if stamp + @session_ttl < Time.now
-            delete(key)
-          end  
-        end
-        GC.start
-      end  
-      
-      def start_timer
-        Thread.new do
-          loop {
-            sleep @session_ttl
-            reap_old_sessions
-          } 
-        end  
-      end  
-      
-      def sessions
-        @sessions
-      end  
-      
-    end # end singleton class
-
-  end # end MemorySessionContainer
-end
-
-Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl])