Class: SBSM::SessionStore

Inherits:
Object
  • Object
show all
Defined in:
lib/sbsm/session_store.rb

Overview

SessionStore manages session, which are kept in memory Sessions are limited and expire after some time The maximal amount of concurrent session is given via CAP_MAX_THRESHOLD

Constant Summary collapse

CLEANING_INTERVAL = 
30
CAP_MAX_THRESHOLD = 
120
MAX_SESSIONS = 
100
RUN_CLEANER = 
true
SESSION = 
Session
UNKNOWN_USER = 
UnknownUser
VALIDATOR = 
nil
@@mutex = 
Mutex.new
@@sessions = 
{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app:, persistence_layer: nil, trans_handler: nil, session_class: nil, validator: nil, cookie_name: nil, unknown_user: UNKNOWN_USER.new, multi_threaded: nil) ⇒ SessionStore

Returns a new instance of SessionStore.



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/sbsm/session_store.rb', line 55

def initialize(app:,
               persistence_layer: nil,
               trans_handler: nil,
               session_class: nil,
               validator: nil,
               cookie_name: nil,
               unknown_user: UNKNOWN_USER.new,
               multi_threaded: nil)
  fail "You must specify an app!" unless app
  @cleaner = run_cleaner if(self.class.const_get(:RUN_CLEANER))
  @app = app
  @system = persistence_layer
  @persistence_layer = persistence_layer
  @cookie_name = cookie_name
  @trans_handler = trans_handler
  @trans_handler ||= TransHandler.instance
  @session_class = session_class
  @session_class ||= SBSM::Session
  @unknown_user = unknown_user.is_a?(Class) ? unknown_user.new : unknown_user
  @unknown_user ||= UnknownUser.new
  @validator = validator
end

Instance Attribute Details

#cleaner ⇒ Object (readonly)

Returns the value of attribute cleaner.



52
53
54
 
# File 'lib/sbsm/session_store.rb', line 52

def cleaner
  @cleaner
end

#persistence_layer ⇒ Object (readonly)

Returns the value of attribute persistence_layer.



52
53
54
 
# File 'lib/sbsm/session_store.rb', line 52

def persistence_layer
  @persistence_layer
end

#updater ⇒ Object (readonly)

Returns the value of attribute updater.



52
53
54
 
# File 'lib/sbsm/session_store.rb', line 52

def updater
  @updater
end

Class Method Details

.clear ⇒ Object 



117
118
119
120
121
122
 
# File 'lib/sbsm/session_store.rb', line 117

def SessionStore.clear
  @@mutex.synchronize do
    @@sessions.each_value { |sess| sess.__checkout }
    @@sessions.clear
  end
end

.sessions ⇒ Object

cap_max_sessions(now)



113
114
115
 
# File 'lib/sbsm/session_store.rb', line 113

def SessionStore.sessions
  @@sessions
end

Instance Method Details

#[](key) ⇒ Object 



146
147
148
149
150
151
152
153
154
155
 
# File 'lib/sbsm/session_store.rb', line 146

def [](key)
  @@mutex.synchronize do
    unless((s = @@sessions[key]) && !s.expired?)
      s = @@sessions[key] = @session_class.new(app: @app, cookie_name: @cookie_name, trans_handler: @trans_handler, validator: @validator, unknown_user: @unknown_user)
    end
    s.reset()
    s.touch()
    s
  end
end

#cap_max_sessions(now = Time.now) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/sbsm/session_store.rb', line 77

def cap_max_sessions(now = Time.now)
  if(@@sessions.size > self::class::CAP_MAX_THRESHOLD)
    SBSM.info "too many sessions! Keeping only #{self::class::MAX_SESSIONS}"
    sess = nil
    sorted = @@sessions.values.sort
    sorted[0...(-self::class::MAX_SESSIONS)].each { |sess|
      sess.__checkout
      @@sessions.delete(sess.key)
    }
    if(sess)
      age = sess.age(now)
      SBSM.info sprintf("deleted all sessions that had not been accessed for more than %im %is", age / 60, age % 60)
    end
  end
end

#clean ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/sbsm/session_store.rb', line 92

def clean
  now = Time.now
  @@sessions.delete_if { |key, s|
    begin
      if s.respond_to?(:expired?)
        if s.expired?(now)
          s.__checkout
          true
        else
          s.cap_max_states
          false
        end
      else
        true
      end
    rescue
      true
    end
  }
  #cap_max_sessions(now)
end

#delete_session(key) ⇒ Object 



123
124
125
126
127
 
# File 'lib/sbsm/session_store.rb', line 123

def delete_session(key)
  if(sess = @@sessions.delete(key))
    sess.__checkout
  end
end

#reset ⇒ Object 



128
129
130
131
132
 
# File 'lib/sbsm/session_store.rb', line 128

def reset
  @@mutex.synchronize {
    @@sessions.clear
  }
end

#run_cleaner ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/sbsm/session_store.rb', line 133

def run_cleaner
  # puts "running cleaner thread"
  Thread.new do
    Thread.current.abort_on_exception = true
    #Thread.current.priority = 1
    loop do
      sleep self::class::CLEANING_INTERVAL
      @@mutex.synchronize do
        clean()
      end
    end
  end
end