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.



15
16
17
18
19
20
 
# File 'lib/rack/session/redis.rb', line 15

def initialize(app, options = {})
  super

  @mutex = Mutex.new
  @conn = ::Redis::Rack::Connection.new(@default_options)
end

Instance Attribute Details

#mutex ⇒ Object (readonly)

Returns the value of attribute mutex.



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

def mutex
  @mutex
end

Instance Method Details

#destroy_session(env, session_id, options) ⇒ Object 



54
55
56
57
58
59
 
# File 'lib/rack/session/redis.rb', line 54

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 



22
23
24
25
26
27
28
29
30
31
 
# File 'lib/rack/session/redis.rb', line 22

def generate_unique_sid(session)
  return generate_sid if session.empty?
  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 



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

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 



47
48
49
50
51
52
 
# File 'lib/rack/session/redis.rb', line 47

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) 


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

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

#with(&block) ⇒ Object 



78
79
80
 
# File 'lib/rack/session/redis.rb', line 78

def with(&block)
  @conn.with(&block)
end

#with_lock(env, default = nil) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/rack/session/redis.rb', line 65

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