technomancy-rack 0.3.0

data/lib/rack/response.rb

@@ -0,0 +1,166 @@
+require 'rack/request'
+require 'rack/utils'
+
+module Rack
+  # Rack::Response provides a convenient interface to create a Rack
+  # response.
+  #
+  # It allows setting of headers and cookies, and provides useful
+  # defaults (a OK response containing HTML).
+  #
+  # You can use Response#write to iteratively generate your response,
+  # but note that this is buffered by Rack::Response until you call
+  # +finish+.  +finish+ however can take a block inside which calls to
+  # +write+ are syncronous with the Rack response.
+  #
+  # Your application's +call+ should end returning Response#finish.
+
+  class Response
+    def initialize(body=[], status=200, header={}, &block)
+      @status = status
+      @header = Utils::HeaderHash.new({"Content-Type" => "text/html"}.
+                                      merge(header))
+
+      @writer = lambda { |x| @body << x }
+      @block = nil
+
+      @body = []
+
+      if body.respond_to? :to_str
+        write body.to_str
+      elsif body.respond_to?(:each)
+        body.each { |part|
+          write part.to_s
+        }
+      else
+        raise TypeError, "stringable or iterable required"
+      end
+
+      yield self  if block_given?
+    end
+
+    attr_reader :header
+    attr_accessor :status, :body
+
+    def [](key)
+      header[key]
+    end
+
+    def []=(key, value)
+      header[key] = value
+    end
+
+    def set_cookie(key, value)
+      case value
+      when Hash
+        domain  = "; domain="  + value[:domain]    if value[:domain]
+        path    = "; path="    + value[:path]      if value[:path]
+        # According to RFC 2109, we need dashes here.
+        # N.B.: cgi.rb uses spaces...
+        expires = "; expires=" + value[:expires].clone.gmtime.
+          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
+        value = value[:value]
+      end
+      value = [value]  unless Array === value
+      cookie = Utils.escape(key) + "=" +
+        value.map { |v| Utils.escape v }.join("&") +
+        "#{domain}#{path}#{expires}"
+
+      case self["Set-Cookie"]
+      when Array
+        self["Set-Cookie"] << cookie
+      when String
+        self["Set-Cookie"] = [self["Set-Cookie"], cookie]
+      when nil
+        self["Set-Cookie"] = cookie
+      end
+    end
+
+    def delete_cookie(key, value={})
+      unless Array === self["Set-Cookie"]
+        self["Set-Cookie"] = [self["Set-Cookie"]].compact
+      end
+
+      self["Set-Cookie"].reject! { |cookie|
+        cookie =~ /\A#{Utils.escape(key)}=/
+      }
+
+      set_cookie(key,
+                 {:value => '', :path => nil, :domain => nil,
+                   :expires => Time.at(0) }.merge(value))
+    end
+
+
+    def finish(&block)
+      @block = block
+
+      if [204, 304].include?(status.to_i)
+        header.delete "Content-Type"
+        [status.to_i, header.to_hash, []]
+      else
+        [status.to_i, header.to_hash, self]
+      end
+    end
+    alias to_a finish           # For *response
+
+    def each(&callback)
+      @body.each(&callback)
+      @writer = callback
+      @block.call(self)  if @block
+    end
+
+    def write(str)
+      @writer.call str.to_s
+      str
+    end
+
+    def close
+      body.close if body.respond_to?(:close)
+    end
+
+    def empty?
+      @block == nil && @body.empty?
+    end
+
+    alias headers header
+
+    module Helpers
+      def invalid?;       @status < 100 || @status >= 600;       end
+
+      def informational?; @status >= 100 && @status < 200;       end
+      def successful?;    @status >= 200 && @status < 300;       end
+      def redirection?;   @status >= 300 && @status < 400;       end
+      def client_error?;  @status >= 400 && @status < 500;       end
+      def server_error?;  @status >= 500 && @status < 600;       end
+
+      def ok?;            @status == 200;                        end
+      def forbidden?;     @status == 403;                        end
+      def not_found?;     @status == 404;                        end
+
+      def redirect?;      [301, 302, 303, 307].include? @status; end
+      def empty?;         [201, 204, 304].include?      @status; end
+
+      # Headers
+      attr_reader :headers, :original_headers
+
+      def include?(header)
+        !!headers[header]
+      end
+
+      def content_type
+        headers["Content-Type"]
+      end
+
+      def content_length
+        cl = headers["Content-Length"]
+        cl ? cl.to_i : cl
+      end
+
+      def location
+        headers["Location"]
+      end
+    end
+
+    include Helpers
+  end
+end

data/lib/rack/session/abstract/id.rb

@@ -0,0 +1,126 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+require 'rack/utils'
+
+module Rack
+  module Session
+    module Abstract
+      # ID sets up a basic framework for implementing an id based sessioning
+      # service. Cookies sent to the client for maintaining sessions will only
+      # contain an id reference. Only #get_session and #set_session should
+      # need to be overwritten.
+      #
+      # All parameters are optional.
+      # * :key determines the name of the cookie, by default it is
+      #   'rack.session'
+      # * :domain and :path set the related cookie values, by default
+      #   domain is nil, and the path is '/'.
+      # * :expire_after is the number of seconds in which the session
+      #   cookie will expire. By default it is set not to provide any
+      #   expiry time.
+      class ID
+        attr_reader :key
+        DEFAULT_OPTIONS = {
+          :key =>           'rack.session',
+          :path =>          '/',
+          :domain =>        nil,
+          :expire_after =>  nil
+        }
+
+        def initialize(app, options={})
+          @default_options = self.class::DEFAULT_OPTIONS.merge(options)
+          @key = @default_options[:key]
+          @default_context = context app
+        end
+
+        def call(env)
+          @default_context.call(env)
+        end
+
+        def context(app)
+          Rack::Utils::Context.new self, app do |env|
+            load_session env
+            response = app.call(env)
+            commit_session env, response
+            response
+          end
+        end
+
+        private
+
+        # Extracts the session id from provided cookies and passes it and the
+        # environment to #get_session. It then sets the resulting session into
+        # 'rack.session', and places options and session metadata into
+        # 'rack.session.options'.
+        def load_session(env)
+          sid           = env.fetch('HTTP_COOKIE','')[/#{@key}=([^,;]+)/,1]
+          sid, session  = get_session(env, sid)
+          unless session.is_a?(Hash)
+            puts 'Session: '+sid.inspect+"\n"+session.inspect if $DEBUG
+            raise TypeError, 'Session not a Hash'
+          end
+          options = @default_options.
+            merge({ :id => sid, :by => self, :at => Time.now })
+
+          env['rack.session'] = session
+          env['rack.session.options'] = options
+        end
+
+        # Acquires the session from the environment and the session id from
+        # the session options and passes them to #set_session. It then
+        # proceeds to set a cookie up in the response with the session's id.
+        def commit_session(env, response)
+          unless response.is_a?(Array)
+            puts 'Response: '+response.inspect if $DEBUG
+            raise ArgumentError, 'Response is not an array.'
+          end
+
+          options = env['rack.session.options']
+          unless options.is_a?(Hash)
+            puts 'Options: '+options.inspect if $DEBUG
+            raise TypeError, 'Options not a Hash'
+          end
+
+          sid, time, z = options.values_at(:id, :at, :by)
+          unless self == z
+            warn "#{self} not managing this session."
+            return
+          end
+
+          unless env['rack.session'].is_a?(Hash)
+            puts 'Session: '+sid.inspect+"\n"+session.inspect if $DEBUG
+            raise TypeError, 'Session not a Hash'
+          end
+          set_session(env, sid)
+
+          expiry = options[:expire_after] && time+options[:expire_after]
+          cookie = Utils.escape(@key)+'='+Utils.escape(sid)
+          cookie<< "; domain=#{options[:domain]}" if options[:domain]
+          cookie<< "; path=#{options[:path]}" if options[:path]
+          cookie<< "; expires=#{expiry}" if expiry
+
+          puts "Cookie: "+cookie.inspect if $DEBUG
+
+          case a = (h = response[1])['Set-Cookie']
+          when Array then  a << cookie
+          when String then h['Set-Cookie'] = [a, cookie]
+          when nil then    h['Set-Cookie'] = cookie
+          end
+        end
+
+        # Should return [session_id, session]. All thread safety and session
+        # retrival proceedures should occur here.
+        # If nil is provided as the session id, generation of a new valid id
+        # should occur within.
+        def get_session(env, sid)
+          raise '#get_session needs to be implemented.'
+        end
+
+        # All thread safety and session storage proceedures should occur here.
+        def set_session(env, sid)
+          raise '#set_session needs to be implemented.'
+        end
+      end
+    end
+  end
+end

data/lib/rack/session/cookie.rb

@@ -0,0 +1,71 @@
+module Rack
+
+  module Session
+
+    # Rack::Session::Cookie provides simple cookie based session management.
+    # The session is a Ruby Hash stored as base64 encoded marshalled data
+    # set to :key (default: rack.session).
+    #
+    # Example:
+    #
+    #     use Rack::Session::Cookie, :key => 'rack.session',
+    #                                :domain => 'foo.com',
+    #                                :path => '/',
+    #                                :expire_after => 2592000
+    #
+    #     All parameters are optional.
+
+    class Cookie
+
+      def initialize(app, options={})
+        @app = app
+        @key = options[:key] || "rack.session"
+        @default_options = {:domain => nil,
+          :path => "/",
+          :expire_after => nil}.merge(options)
+      end
+
+      def call(env)
+        load_session(env)
+        status, headers, body = @app.call(env)
+        commit_session(env, status, headers, body)
+      end
+
+      private
+
+      def load_session(env)
+        request = Rack::Request.new(env)
+        session_data = request.cookies[@key]
+
+        begin
+          session_data = session_data.unpack("m*").first
+          session_data = Marshal.load(session_data)
+          env["rack.session"] = session_data
+        rescue
+          env["rack.session"] = Hash.new
+        end
+
+        env["rack.session.options"] = @default_options.dup
+      end
+
+      def commit_session(env, status, headers, body)
+        session_data = Marshal.dump(env["rack.session"])
+        session_data = [session_data].pack("m*")
+
+        if session_data.size > (4096 - @key.size)
+          env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K. Content dropped.")
+          [status, headers, body]
+        else
+          options = env["rack.session.options"]
+          cookie = Hash.new
+          cookie[:value] = session_data
+          cookie[:expires] = Time.now + options[:expire_after] unless options[:expire_after].nil?
+          response = Rack::Response.new(body, status, headers)
+          response.set_cookie(@key, cookie.merge(options))
+          response.to_a
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/session/memcache.rb

@@ -0,0 +1,83 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+require 'rack/session/abstract/id'
+require 'memcache'
+
+module Rack
+  module Session
+    # Rack::Session::Memcache provides simple cookie based session management.
+    # Session data is stored in memcached. The corresponding session key is
+    # maintained in the cookie.
+    # You may treat Session::Memcache as you would Session::Pool with the
+    # following differences.
+    #
+    # * Setting :expire_after to 0 would note to the Memcache server to hang
+    #   onto the session data until it would drop it according to it's own
+    #   specifications.
+    #
+    # Note that memcache does drop data before it may be listed to expire. For
+    # a full description of behaviour, please see memcache's documentation.
+
+    class Memcache < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge({
+        :namespace => 'rack:session',
+        :memcache_server => 'localhost:11211'
+      })
+
+      def initialize(app, options={})
+        super
+        @pool = MemCache.new @default_options[:memcache_server], @default_options
+        @mutex = Mutex.new
+      end
+
+      private
+
+      def get_session(env, sid)
+        session = sid && @pool.get(sid)
+        unless session and session.is_a?(Hash)
+          session = {}
+          lc = 0
+          @mutex.synchronize do
+            begin
+              raise RuntimeError, 'Unique id finding looping excessively' if (lc+=1) > 1000
+              sid = "%08x" % rand(0xffffffff)
+              ret = @pool.add(sid, session)
+            end until /^STORED/ =~ ret
+          end
+        end
+        class << session
+          @deleted = []
+          def delete key
+            (@deleted||=[]) << key
+            super
+          end
+        end
+        [sid, session]
+      end
+
+      def set_session(env, sid)
+        session = env['rack.session']
+        options = env['rack.session.options']
+        expiry  = options[:expire_after] || 0
+        o, s = @mutex.synchronize do
+          old_session = @pool.get(sid)
+          unless old_session.is_a?(Hash)
+            warn 'Session not properly initialized.' if $DEBUG
+            old_session = {}
+            @pool.add sid, old_session, expiry
+          end
+          session.instance_eval do
+            @deleted.each{|k| old_session.delete(k) } if defined? @deleted
+          end
+          @pool.set sid, old_session.merge(session), expiry
+          [old_session, session]
+        end
+        s.each do |k,v|
+          next unless o.has_key?(k) and v != o[k]
+          warn "session value assignment collision at #{k}: #{o[k]} <- #{v}"
+        end if $DEBUG and env['rack.multithread']
+      end
+    end
+  end
+end

data/lib/rack/session/pool.rb

@@ -0,0 +1,67 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+# THANKS:
+#   apeiros, for session id generation, expiry setup, and threadiness
+#   sergio, threadiness and bugreps
+
+require 'rack/session/abstract/id'
+require 'thread'
+
+module Rack
+  module Session
+    # Rack::Session::Pool provides simple cookie based session management.
+    # Session data is stored in a hash held by @pool.
+    # In the context of a multithreaded environment, sessions being
+    # committed to the pool is done in a merging manner.
+    #
+    # Example:
+    #   myapp = MyRackApp.new
+    #   sessioned = Rack::Session::Pool.new(myapp,
+    #     :key => 'rack.session',
+    #     :domain => 'foo.com',
+    #     :path => '/',
+    #     :expire_after => 2592000
+    #   )
+    #   Rack::Handler::WEBrick.run sessioned
+
+    class Pool < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.dup
+
+      def initialize(app, options={})
+        super
+        @pool = Hash.new
+        @mutex = Mutex.new
+      end
+
+      private
+
+      def get_session(env, sid)
+        session = @mutex.synchronize do
+          unless sess = @pool[sid] and ((expires = sess[:expire_at]).nil? or expires > Time.now)
+            @pool.delete_if{|k,v| expiry = v[:expire_at] and expiry < Time.now }
+            begin
+              sid = "%08x" % rand(0xffffffff)
+            end while @pool.has_key?(sid)
+          end
+          @pool[sid] ||= {}
+        end
+        [sid, session]
+      end
+
+      def set_session(env, sid)
+        options = env['rack.session.options']
+        expiry = options[:expire_after] && options[:at]+options[:expire_after]
+        @mutex.synchronize do
+          old_session = @pool[sid]
+          old_session[:expire_at] = expiry if expiry
+          session = old_session.merge(env['rack.session'])
+          @pool[sid] = session
+          session.each do |k,v|
+            next unless old_session.has_key?(k) and v != old_session[k]
+            warn "session value assignment collision at #{k}: #{old_session[k]} <- #{v}"
+          end if $DEBUG and env['rack.multithread']
+        end
+      end
+    end
+  end
+end