# File lib/rack/session/memcache.rb, line 29
def initialize(app, options={})
  super

  @mutex = Mutex.new
  mserv = @default_options[:memcache_server]
  mopts = @default_options.reject{|k,v| !MemCache::DEFAULT_OPTIONS.include? k }

  @pool = options[:cache] || MemCache.new(mserv, mopts)
  unless @pool.active? and @pool.servers.any?{|c| c.alive? }
    raise 'No memcache servers'
  end
end

# File lib/rack/session/memcache.rb, line 71
def destroy_session(env, session_id, options)
  with_lock(env) do
    @pool.delete(session_id)
    generate_sid unless options[:drop]
  end
end

# File lib/rack/session/memcache.rb, line 42
def generate_sid
  loop do
    sid = super
    break sid unless @pool.get(sid, true)
  end
end

# File lib/rack/session/memcache.rb, line 49
def get_session(env, sid)
  with_lock(env) do
    unless sid and session = @pool.get(sid)
      sid, session = generate_sid, {}
      unless /^STORED/ =~ @pool.add(sid, session)
        raise "Session collision on '#{sid.inspect}'"
      end
    end
    [sid, session]
  end
end

# File lib/rack/session/memcache.rb, line 61
def set_session(env, session_id, new_session, options)
  expiry = options[:expire_after]
  expiry = expiry.nil? ? 0 : expiry + 1

  with_lock(env) do
    @pool.set session_id, new_session, expiry
    session_id
  end
end

# File lib/rack/session/memcache.rb, line 78
def with_lock(env)
  @mutex.lock if env['rack.multithread']
  yield
rescue MemCache::MemCacheError, Errno::ECONNREFUSED
  if $VERBOSE
    warn "#{self} is unable to find memcached server."
    warn $!.inspect
  end
  raise
ensure
  @mutex.unlock if @mutex.locked?
end

# File lib/rack/session/pool.rb, line 31
def initialize(app, options={})
  super
  @pool = Hash.new
  @mutex = Mutex.new
end

# File lib/rack/session/pool.rb, line 61
def destroy_session(env, session_id, options)
  with_lock(env) do
    @pool.delete(session_id)
    generate_sid unless options[:drop]
  end
end

# File lib/rack/session/pool.rb, line 37
def generate_sid
  loop do
    sid = super
    break sid unless @pool.key? sid
  end
end

# File lib/rack/session/pool.rb, line 44
def get_session(env, sid)
  with_lock(env) do
    unless sid and session = @pool[sid]
      sid, session = generate_sid, {}
      @pool.store sid, session
    end
    [sid, session]
  end
end

# File lib/rack/session/pool.rb, line 54
def set_session(env, session_id, new_session, options)
  with_lock(env) do
    @pool.store session_id, new_session
    session_id
  end
end

# File lib/rack/session/pool.rb, line 68
def with_lock(env)
  @mutex.lock if env['rack.multithread']
  yield
ensure
  @mutex.unlock if @mutex.locked?
end

# File lib/rack/session/cookie.rb, line 64
def decode(str)
  return unless str
  ::Marshal.load(super(str)) rescue nil
end

# File lib/rack/session/cookie.rb, line 60
def encode(str)
  super(::Marshal.dump(str))
end

# File lib/rack/session/cookie.rb, line 77
def decode(str)
  return unless str
  ::Rack::Utils::OkJson.decode(super(str)) rescue nil
end

# File lib/rack/session/cookie.rb, line 73
def encode(obj)
  super(::Rack::Utils::OkJson.encode(obj))
end

# File lib/rack/session/cookie.rb, line 88
def decode(str)
  return unless str
  ::Rack::Utils::OkJson.decode(Zlib::Inflate.inflate(super(str)))
rescue
  nil
end

# File lib/rack/session/cookie.rb, line 84
def encode(obj)
  super(Zlib::Deflate.deflate(::Rack::Utils::OkJson.encode(obj)))
end

# File lib/rack/session/cookie.rb, line 54
def decode(str)
  str.unpack('m').first
end

# File lib/rack/session/cookie.rb, line 50
def encode(str)
  [str].pack('m')
end

# File lib/rack/session/cookie.rb, line 100
def decode(str); str; end

# File lib/rack/session/cookie.rb, line 99
def encode(str); str; end

# File lib/rack/session/cookie.rb, line 105
def initialize(app, options={})
  @secrets = options.values_at(:secret, :old_secret).compact
  warn         SECURITY WARNING: No secret option provided to Rack::Session::Cookie.        This poses a security threat. It is strongly recommended that you        provide a secret to prevent exploits that may be possible from crafted        cookies. This will not be supported in future versions of Rack, and        future versions will even invalidate your existing user cookies.        Called from: #{caller[0]}. unless @secrets.size >= 1
  @coder  = options[:coder] ||= Base64::Marshal.new
  super(app, options.merge!(:cookie_only => true))
end

# File lib/rack/session/abstract/id.rb, line 211
def initialize(app, options={})
  @app = app
  @default_options = self.class::DEFAULT_OPTIONS.merge(options)
  @key = @default_options.delete(:key)
  @cookie_only = @default_options.delete(:cookie_only)
  initialize_sid
end

# File lib/rack/session/abstract/id.rb, line 219
def call(env)
  context(env)
end

# File lib/rack/session/abstract/id.rb, line 223
def context(env, app=@app)
  prepare_session(env)
  status, headers, body = app.call(env)
  commit_session(env, status, headers, body)
end

# File lib/rack/session/abstract/id.rb, line 27
def self.find(env)
  env[ENV_SESSION_KEY]
end

# File lib/rack/session/abstract/id.rb, line 39
def initialize(store, env)
  @store = store
  @env = env
  @loaded = false
end

# File lib/rack/session/abstract/id.rb, line 31
def self.set(env, session)
  env[ENV_SESSION_KEY] = session
end

# File lib/rack/session/abstract/id.rb, line 35
def self.set_options(env, options)
  env[ENV_SESSION_OPTIONS_KEY] = options.dup
end

# File lib/rack/session/abstract/id.rb, line 59
def [](key)
  load_for_read!
  @data[key.to_s]
end

# File lib/rack/session/abstract/id.rb, line 72
def []=(key, value)
  load_for_write!
  @data[key.to_s] = value
end

# File lib/rack/session/abstract/id.rb, line 78
def clear
  load_for_write!
  @data.clear
end

# File lib/rack/session/abstract/id.rb, line 104
def delete(key)
  load_for_write!
  @data.delete(key.to_s)
end

# File lib/rack/session/abstract/id.rb, line 83
def destroy
  clear
  @id = @store.send(:destroy_session, @env, id, options)
end

# File lib/rack/session/abstract/id.rb, line 54
def each(&block)
  load_for_read!
  @data.each(&block)
end

# File lib/rack/session/abstract/id.rb, line 127
def empty?
  load_for_read!
  @data.empty?
end

# File lib/rack/session/abstract/id.rb, line 117
def exists?
  return @exists if instance_variable_defined?(:@exists)
  @data = {}
  @exists = @store.send(:session_exists?, @env)
end

# File lib/rack/session/abstract/id.rb, line 65
def has_key?(key)
  load_for_read!
  @data.has_key?(key.to_s)
end

# File lib/rack/session/abstract/id.rb, line 45
def id
  return @id if @loaded or instance_variable_defined?(:@id)
  @id = @store.send(:extract_session_id, @env)
end

# File lib/rack/session/abstract/id.rb, line 109
def inspect
  if loaded?
    @data.inspect
  else
    "#<#{self.class}:0x#{self.object_id.to_s(16)} not yet loaded>"
  end
end

# File lib/rack/session/abstract/id.rb, line 132
def keys
  @data.keys
end

# File lib/rack/session/abstract/id.rb, line 123
def loaded?
  @loaded
end

# File lib/rack/session/abstract/id.rb, line 50
def options
  @env[ENV_SESSION_OPTIONS_KEY]
end

# File lib/rack/session/abstract/id.rb, line 99
def replace(hash)
  load_for_write!
  @data.replace(stringify_keys(hash))
end

# File lib/rack/session/abstract/id.rb, line 88
def to_hash
  load_for_read!
  @data.dup
end

# File lib/rack/session/abstract/id.rb, line 93
def update(hash)
  load_for_write!
  @data.update(stringify_keys(hash))
end

# File lib/rack/session/abstract/id.rb, line 136
def values
  @data.values
end