Class: Rack::Session::Dalli

Inherits:
Abstract::PersistedSecure
  • Object
show all
Defined in:
lib/rack/session/dalli.rb

Overview

Rack::Session::Dalli provides memcached based session management.

Constant Summary collapse

DEFAULT_DALLI_OPTIONS =

Don’t freeze this until we fix the specs/implementation rubocop:disable Style/MutableConstant

{
  namespace: 'rack:session'
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

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

Brings in a new Rack::Session::Dalli middleware with the given ‘:memcache_server`. The server is either a hostname, or a host-with-port string in the form of “host_name:port”, or an array of such strings. For example:

use Rack::Session::Dalli,
  :memcache_server => "mc.example.com:1234"

If no ‘:memcache_server` option is specified, Rack::Session::Dalli will connect to localhost, port 11211 (the default memcached port). If `:memcache_server` is set to nil, Dalli::Client will look for ENV and use that value if it is available, or fall back to the same default behavior described above.

Rack::Session::Dalli accepts the same options as Dalli::Client, so it’s worth reviewing its documentation. Perhaps most importantly, if you don’t specify a ‘:namespace` option, Rack::Session::Dalli will default to using ’rack:session’.

It is not recommended to set ‘:expires_in`. Instead, use `:expire_after`, which will control both the expiration of the client cookie as well as the expiration of the corresponding entry in memcached.

Rack::Session::Dalli also accepts a host of options that control how the sessions and session cookies are managed, including the aforementioned ‘:expire_after` option. Please see the documentation for Rack::Session::Abstract::Persisted for a detailed explanation of these options and their default values.

Finally, if your web application is multithreaded, the Rack::Session::Dalli middleware can become a source of contention. You can use a connection pool of Dalli clients by passing in the ‘:pool_size` and/or `:pool_timeout` options. For example:

use Rack::Session::Dalli,
  :memcache_server => "mc.example.com:1234",
  :pool_size => 10

You must include the ‘connection_pool` gem in your project if you wish to use pool support. Please see the documentation for ConnectionPool for more information about it and its default options (which would only be applicable if you supplied one of the two options, but not both).



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

def initialize(app, options = {})
  # Parent uses DEFAULT_OPTIONS to build @default_options for Rack::Session
  super

  # Determine the default TTL for newly-created sessions
  @default_ttl = ttl(@default_options[:expire_after])
  @data = build_data_source(options)
end

Instance Attribute Details

#data ⇒ Object (readonly)

Returns the value of attribute data.



12
13
14
 
# File 'lib/rack/session/dalli.rb', line 12

def data
  @data
end

Instance Method Details

#delete_session(_req, sid, options) ⇒ Object 



94
95
96
97
98
99
100
 
# File 'lib/rack/session/dalli.rb', line 94

def delete_session(_req, sid, options)
  with_dalli_client do |dc|
    key = memcached_key_from_sid(sid)
    dc.delete(key) if key
    generate_sid_with(dc) unless options[:drop]
  end
end

#find_session(_req, sid) ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'lib/rack/session/dalli.rb', line 73

def find_session(_req, sid)
  with_dalli_client([nil, {}]) do |dc|
    existing_session = existing_session_for_sid(dc, sid)
    return [sid, existing_session] unless existing_session.nil?

    [create_sid_with_empty_session(dc), {}]
  end
end

#write_session(_req, sid, session, options) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/rack/session/dalli.rb', line 82

def write_session(_req, sid, session, options)
  return false unless sid

  key = memcached_key_from_sid(sid)
  return false unless key

  with_dalli_client(false) do |dc|
    dc.set(memcached_key_from_sid(sid), session, ttl(options[:expire_after]))
    sid
  end
end