Class: Rack::Session::Redis

Inherits:
Abstract::ID
  • Object
show all
Defined in:
lib/rack/session/redis.rb

Constant Summary collapse

DEFAULT_OPTIONS = 
Abstract::ID::DEFAULT_OPTIONS.merge \
:redis_server => 'redis://127.0.0.1:6379/0/rack:session'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app, options = {}) ⇒ Redis

Returns a new instance of Redis.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/rack/session/redis.rb', line 13

def initialize(app, options = {})
  super

  @mutex = Mutex.new
  @pool = if @default_options[:pool]
           raise "pool must be an instance of ConnectionPool" unless @default_options[:pool].is_a?(ConnectionPool)
            @pooled = true
            @default_options[:pool]
          elsif [:pool_size, :pool_timeout].any? { |key| @default_options.has_key?(key) }
            pool_options           = {}
            pool_options[:size]    = options[:pool_size] if options[:pool_size]
            pool_options[:timeout] = options[:pool_timeout] if options[:pool_timeout]
            @pooled = true
            ::ConnectionPool.new(pool_options) { ::Redis::Store::Factory.create(@default_options[:redis_server]) }
          else
            @default_options.has_key?(:redis_store) ?
              @default_options[:redis_store] :
              ::Redis::Store::Factory.create(@default_options[:redis_server])

          end
end

Instance Attribute Details

#mutex ⇒ Object (readonly)

Returns the value of attribute mutex.



8
9
10
 
# File 'lib/rack/session/redis.rb', line 8

def mutex
  @mutex
end

#pool ⇒ Object (readonly)

Returns the value of attribute pool.



8
9
10
 
# File 'lib/rack/session/redis.rb', line 8

def pool
  @pool
end

Instance Method Details

#destroy_session(env, session_id, options) ⇒ Object 



66
67
68
69
70
71
 
# File 'lib/rack/session/redis.rb', line 66

def destroy_session(env, session_id, options)
  with_lock(env) do
    with { |c| c.del(session_id) }
    generate_sid unless options[:drop]
  end
end

#generate_unique_sid(session) ⇒ Object 



35
36
37
38
39
40
41
42
43
 
# File 'lib/rack/session/redis.rb', line 35

def generate_unique_sid(session)
  loop do
    sid = generate_sid
    first = with do |c|
      [*c.setnx(sid, session, @default_options)].first
    end
    break sid if [1, true].include?(first)
  end
end

#get_session(env, sid) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/rack/session/redis.rb', line 45

def get_session(env, sid)
  if env['rack.session.options'][:skip]
    [generate_sid, {}]
  else
    with_lock(env, [nil, {}]) do
      unless sid and session = with { |c| c.get(sid) }
        session = {}
        sid = generate_unique_sid(session)
      end
      [sid, session]
    end
  end
end

#set_session(env, session_id, new_session, options) ⇒ Object 



59
60
61
62
63
64
 
# File 'lib/rack/session/redis.rb', line 59

def set_session(env, session_id, new_session, options)
  with_lock(env, false) do
    with { |c| c.set session_id, new_session, options }
    session_id
  end
end

#threadsafe? ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/rack/session/redis.rb', line 73

def threadsafe?
  @default_options.fetch(:threadsafe, true)
end

#with(&block) ⇒ Object 



90
91
92
93
94
95
96
 
# File 'lib/rack/session/redis.rb', line 90

def with(&block)
  if @pooled
    @pool.with(&block)
  else
    block.call(@pool)
  end
end

#with_lock(env, default = nil) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/rack/session/redis.rb', line 77

def with_lock(env, default=nil)
  @mutex.lock if env['rack.multithread'] && threadsafe?
  yield
rescue Errno::ECONNREFUSED
  if $VERBOSE
    warn "#{self} is unable to find Redis server."
    warn $!.inspect
  end
  default
ensure
  @mutex.unlock if @mutex.locked?
end