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
77
 
# 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
  @@sessions = {}
  @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 



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

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

.sessions ⇒ Object

SBSM.warn sprintf(“Cleaned #- @@sessions.size sessions. Took %d seconds”, seconds)



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

def SessionStore.sessions
  @@sessions
end

Instance Method Details

#[](key) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/sbsm/session_store.rb', line 150

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.key=key
    s.reset()
    s.touch()
    s
  end
end

#cap_max_sessions(now = Time.now) ⇒ Object 



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

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
      @@sessions.values.sort[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
  seconds = (Time.now.to_i - now.to_i)
  SBSM.warn sprintf("cap_max_sessions to #{self::class::CAP_MAX_THRESHOLD}. took %d seconds", seconds)
end

#clean ⇒ Object 



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

def clean
  now = Time.now
  old_size = @@sessions.size
  @@sessions.delete_if do |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
  end
  seconds = (Time.now.to_i - now.to_i)
  # SBSM.warn sprintf("Cleaned #{old_size - @@sessions.size} sessions. Took %d seconds", seconds)
end

#delete_session(key) ⇒ Object 



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

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

#reset ⇒ Object 



132
133
134
135
136
 
# File 'lib/sbsm/session_store.rb', line 132

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

#run_cleaner ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/sbsm/session_store.rb', line 137

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