Class: Rack::Session::Redic

Inherits:
Abstract::Persisted
  • Object
show all
Defined in:
lib/rack/session/redic.rb

Overview

Rack::Session::Redic provides simple cookie based session management. Session data is stored in Redis via the Redic gem. The corresponding session key is maintained in the cookie.

Options include:

  • :marshaller - You may optionally supply the class/module you would like to use when marshalling objects in and out of Redis. All that is required is that this class respond to the ‘load` and `dump` methods, returning the session hash and a string respectively.

  • :url - Addtionally, you may pass in the URL for your Redis server. The default URL is fetched from the ENV as ‘REDIS_URL’ in keeping with Heroku and others’ practices.

  • :expire_after - Finally, expiration will be passed to the Redis server via the ‘EX’ option on ‘SET’. Expiration should be in seconds, just like Rack’s default handling of the :expire_after option. This option will refresh the expiration set in Redis with each request.

Any other options will get passed to Rack::Session::Abstract::Persisted.

Constant Summary collapse

HASH = 
{}.freeze
DELETE =

Redis commands.

'DEL'
EX = 
'EX'
EXISTS = 
'EXISTS'
GET = 
'GET'
SET = 
'SET'
REDIS_URL =

Assorted.

'REDIS_URL'
ZERO = 
0

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app, options = HASH) ⇒ Redic

Returns a new instance of Redic.



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

def initialize(app, options = HASH)
  super(app, options)

  @expires = options[:expire_after]
  @marshaller = options.fetch(:marshaller) { Marshal }
  @storage = ::Redic.new(options.fetch(:url) { ENV.fetch(REDIS_URL) })
end

Instance Attribute Details

#storage ⇒ Redic (readonly)

Access the storage interface directly. Needed for testing.

Returns:



44
45
46
 
# File 'lib/rack/session/redic.rb', line 44

def storage
  @storage
end

Instance Method Details

#delete_session(_req, session_id, options) ⇒ Object

Kill the session.



88
89
90
91
92
 
# File 'lib/rack/session/redic.rb', line 88

def delete_session(_req, session_id, options)
  @storage.call(DELETE, session_id)

  generate_sid unless options[:drop]
end

#find_session(_req, session_id) ⇒ Object

Find the session (or generate a blank one).



69
70
71
72
73
74
75
 
# File 'lib/rack/session/redic.rb', line 69

def find_session(_req, session_id)
  unless session_id && (session = deserialize(@storage.call(GET, session_id)))
    session_id, session = generate_sid, {} # rubocop:disable Style/ParallelAssignment
  end

  [session_id, session]
end

#generate_sid ⇒ String

Generate a session ID that doesn’t already exist.

Based on Rack::Session::Abstract::Persisted#generate_sid and Rack::Session::Memcache#generate_sid but without the conditional check. We always generate the session ID from SecureRandom#hex.

Returns:

  • (String) 


61
62
63
64
65
66
 
# File 'lib/rack/session/redic.rb', line 61

def generate_sid
  loop do
    session_id = SecureRandom.hex(@sid_length)
    break session_id unless @storage.call(EXISTS, session_id) != ZERO
  end
end

#write_session(_req, session_id, session_data, _options) ⇒ Object

Write the session.



78
79
80
81
82
83
84
85
 
# File 'lib/rack/session/redic.rb', line 78

def write_session(_req, session_id, session_data, _options)
  arguments = [SET, session_id, serialize(session_data)]
  arguments.push(EX, @expires) if @expires

  @storage.call(*arguments)

  session_id
end