Class: SBSM::Session

Inherits:
SimpleDelegator
  • Object
show all
Includes:
DRbUndumped
Defined in:
lib/sbsm/session.rb

Constant Summary collapse 

"sbsm-persistent-cookie"
DEFAULT_FLAVOR = 
'sbsm'
DEFAULT_LANGUAGE = 
'en'
DEFAULT_STATE = 
State
DEFAULT_ZONE = 
nil
DRB_LOAD_LIMIT = 
255 * 102400
EXPIRES = 
60 * 60
LF_FACTORY = 
nil
LOOKANDFEEL = 
Lookandfeel
CAP_MAX_THRESHOLD = 
8
MAX_STATES = 
4
SERVER_NAME = 
nil
@@stats_ptrn = 
/./
@@msie_ptrn = 
/MSIE/
@@win_ptrn = 
/Win/i
@@nt5_ptrn = 
/Windows\s*NT\s*(\d+\.\d+)/i
@@hash_ptrn = 
/([^\[]+)((\[[^\]]+\])+)/
@@index_ptrn = 
/[^\[\]]+/
@@input_ptrn = 
/([^\[]+)\[([^\]]+)\]/

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(key, app, validator = nil) ⇒ Session

Returns a new instance of Session.



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/sbsm/session.rb', line 91

def initialize(key, app, validator=nil)
			touch()
  reset_input()
			reset_cookie()
  raise "Must pass key and app and validator to session" unless key && app # && validator
  @app = app
  @key = key
			@validator = validator
			@attended_states = {}
			@persistent_user_input = {}
			logout()
			@unknown_user_class = @user.class
			@variables = {}
  @mutex = Mutex.new
  @cgi = CGI.initialize_without_offline_prompt('html4')
  SBSM.debug "session initialized #{self} key #{key} app #{app.class}  #{validator.class} with @cgi #{@cgi}"
			super(app)
end

Instance Attribute Details

#active_thread ⇒ Object (readonly)

Returns the value of attribute active_thread.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def active_thread
  @active_thread
end

#app=(value) ⇒ Object (writeonly)

Sets the attribute app

Parameters:

  • value —

    the value to set the attribute app to.



41
42
43
 
# File 'lib/sbsm/session.rb', line 41

def app=(value)
  @app = value
end

#cgi ⇒ Object (readonly)

Returns the value of attribute cgi.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def cgi
  @cgi
end

#cookie_input ⇒ Object (readonly)

Returns the value of attribute cookie_input.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def cookie_input
  @cookie_input
end

#key ⇒ Object (readonly)

Returns the value of attribute key.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def key
  @key
end

#request_path ⇒ Object (readonly)

Returns the value of attribute request_path.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def request_path
  @request_path
end

#trans_handler=(value) ⇒ Object (writeonly)

Sets the attribute trans_handler

Parameters:

  • value —

    the value to set the attribute trans_handler to.



41
42
43
 
# File 'lib/sbsm/session.rb', line 41

def trans_handler=(value)
  @trans_handler = value
end

#unsafe_input ⇒ Object (readonly)

Returns the value of attribute unsafe_input.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def unsafe_input
  @unsafe_input
end

#user ⇒ Object (readonly)

Returns the value of attribute user.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def user
  @user
end

#valid_input ⇒ Object (readonly)

Returns the value of attribute valid_input.



39
40
41
 
# File 'lib/sbsm/session.rb', line 39

def valid_input
  @valid_input
end

#validator=(value) ⇒ Object (writeonly)

Sets the attribute validator

Parameters:

  • value —

    the value to set the attribute validator to.



41
42
43
 
# File 'lib/sbsm/session.rb', line 41

def validator=(value)
  @validator = value
end

Class Method Details

.reset_stats ⇒ Object 



55
56
57
 
# File 'lib/sbsm/session.rb', line 55

def Session.reset_stats
  @@stats = {}
end

.show_stats(ptrn = @@stats_ptrn) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/sbsm/session.rb', line 60

def Session.show_stats ptrn=@@stats_ptrn
  if ptrn.is_a?(String)
    ptrn = /#{ptrn}/i
  end
  puts sprintf("%8s %8s %8s %6s %10s Request-Path",
               "Min", "Max", "Avg", "Num", "Total")
  grand_total = requests = all_max = all_min = 0
  @@stats.collect do |path, times|
    total = times.inject do |a, b| a + b end
    grand_total += total
    size = times.size
    requests += size
    max = times.max
    all_max = max > all_max ? max : all_max
    min = times.min
    all_min = min < all_min ? min : all_min
    [min, max, total / size, size, total, path]
  end.sort.each do |data|
    line = sprintf("%8.2f %8.2f %8.2f %6i %10.2f %s", *data)
    if ptrn.match(line)
      puts line
    end
  end
  puts sprintf("%8s %8s %8s %6s %10s Request-Path",
               "Min", "Max", "Avg", "Num", "Total")
  puts sprintf("%8.2f %8.2f %8.2f %6i %10.2f",
               all_min, all_max,
               requests > 0 ? grand_total / requests : 0,
               requests, grand_total)
  ''
end

Instance Method Details

#<=>(other) ⇒ Object 



515
516
517
 
# File 'lib/sbsm/session.rb', line 515

def <=>(other)
	self.weighted_mtime <=> other.weighted_mtime
end

#==(other) ⇒ Object 



512
513
514
 
# File 'lib/sbsm/session.rb', line 512

def ==(other)
	super
end

#[](key) ⇒ Object 



518
519
520
 
# File 'lib/sbsm/session.rb', line 518

def [](key)
	@variables[key]
end

#[]=(key, val) ⇒ Object 



521
522
523
 
# File 'lib/sbsm/session.rb', line 521

def []=(key, val)
	@variables[key] = val
end

#__checkout ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/sbsm/session.rb', line 123

def __checkout
	@attended_states.each_value { |state| state.__checkout }
	@attended_states.clear
	flavor = @persistent_user_input[:flavor]
	lang = @persistent_user_input[:language]
	@persistent_user_input.clear
	@persistent_user_input.store(:flavor, flavor)
	@persistent_user_input.store(:language, lang)
	@valid_input.clear
	@unsafe_input.clear
	@active_thread = nil
	true
end

#age(now = Time.now) ⇒ Object 



109
110
111
 
# File 'lib/sbsm/session.rb', line 109

def age(now=Time.now)
  now - @mtime
end

#cap_max_states ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/sbsm/session.rb', line 112

def cap_max_states
	if(@attended_states.size > self::class::CAP_MAX_THRESHOLD)
		SBSM.info "too many states in session! Keeping only #{self::class::MAX_STATES}"
		sorted = @attended_states.values.sort
		sorted[0...(-self::class::MAX_STATES)].each { |state|
			state.__checkout
			@attended_states.delete(state.object_id)
		}
      @attended_states.size
	end
end

#client_activex? ⇒ Boolean

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/sbsm/session.rb', line 138

def client_activex?
    (ua = user_agent) && @@msie_ptrn.match(ua) && @@win_ptrn.match(ua)
end

#client_nt5? ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
145
146
 
# File 'lib/sbsm/session.rb', line 142

def client_nt5?
    (ua = user_agent) \
      && (match = @@nt5_ptrn.match(user_agent)) \
      && (match[1].to_f >= 5)
end

#close ⇒ Object

nothing



496
497
498
499
 
# File 'lib/sbsm/session.rb', line 496

def close
			#@unix_socket.stop_service
  # nothing
end

#cookie_name ⇒ Object 



157
158
159
160
 
# File 'lib/sbsm/session.rb', line 157

def cookie_name
	# self::class::PERSISTENT_COOKIE_NAME
    nil
end

#cookie_set_or_get(key) ⇒ Object 



147
148
149
150
151
152
153
 
# File 'lib/sbsm/session.rb', line 147

def cookie_set_or_get(key)
	if(value = @valid_input[key])
		set_cookie_input(key, value)
	else
		@cookie_input[key]
	end
end

#default_language ⇒ Object 



161
162
163
 
# File 'lib/sbsm/session.rb', line 161

def default_language
	self::class::DEFAULT_LANGUAGE
end

#delete ⇒ Object

nothing



500
501
502
 
# File 'lib/sbsm/session.rb', line 500

def delete
  @app.delete_session @key
end

#direct_event ⇒ Object 



164
165
166
167
 
# File 'lib/sbsm/session.rb', line 164

def direct_event
    # used when
	@state.direct_event
end

#drb_process(app, rack_request) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/sbsm/session.rb', line 168

def drb_process(app, rack_request)
  start = Time.now
  @request_path ||= rack_request.path
  SBSM.debug("rack_request #{rack_request.class} #{@request_path} #{rack_request.request_method} #{@cgi}")
  rack_request.params.each { |key, val| @cgi.params.store(key, val) }
  @trans_handler.translate_uri(rack_request)
  html = @mutex.synchronize do
    process(rack_request)
    to_html
  end
  (@@stats[@request_path] ||= []).push(Time.now - start)
  html
rescue  => err
    SBSM.info "Error in drb_process #{err.backtrace[0..5].join("\n")}"
    raise err
end

#error(key) ⇒ Object 



184
185
186
 
# File 'lib/sbsm/session.rb', line 184

def error(key)
	@state.error(key) if @state.respond_to?(:error)
end

#error? ⇒ Boolean

Returns:

  • (Boolean) 


190
191
192
 
# File 'lib/sbsm/session.rb', line 190

def error?
	@state.error? if @state.respond_to?(:error?)
end

#errors ⇒ Object 



187
188
189
 
# File 'lib/sbsm/session.rb', line 187

def errors
	@state.errors.values if @state.respond_to?(:errors)
end

#event ⇒ Object 



193
194
195
 
# File 'lib/sbsm/session.rb', line 193

def event
	@valid_input[:event]
end

#event_bound_user_input(key) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
 
# File 'lib/sbsm/session.rb', line 196

def event_bound_user_input(key)
  @event_user_input ||= {}
  evt = state.direct_event
  @event_user_input[evt] ||= {}
  if(val = user_input(key))
    @event_user_input[evt][key] = val
  else
    @event_user_input[evt][key]
  end
end

#expired?(now = Time.now) ⇒ Boolean

Returns:

  • (Boolean) 


206
207
208
 
# File 'lib/sbsm/session.rb', line 206

def expired?(now=Time.now)
    age(now) > EXPIRES
end

#flavor ⇒ Object 



320
321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/sbsm/session.rb', line 320

def flavor
	@flavor ||= begin
		user_input = persistent_user_input(:flavor)
		user_input ||= @valid_input[:default_flavor]
		lf_factory = self::class::LF_FACTORY
		if(lf_factory && lf_factory.include?(user_input))
			user_input
		else
			self::class::DEFAULT_FLAVOR
		end
	end
end

#force_login(user) ⇒ Object 



209
210
211
 
# File 'lib/sbsm/session.rb', line 209

def (user)
	@user = user
end

#get_cookie_input(key) ⇒ Object 



154
155
156
 
# File 'lib/sbsm/session.rb', line 154

def get_cookie_input(key)
	@cookie_input[key]
end

#http_headers ⇒ Object 



332
333
334
335
336
337
338
339
 
# File 'lib/sbsm/session.rb', line 332

def http_headers
	@state.http_headers
  rescue DRb::DRbConnError
    raise
rescue NameError, StandardError => err
    SBSM.info "NameError, StandardError: #@request_path"
	{'Content-Type' => 'text/plain'}
end

#http_protocol ⇒ Object 



340
341
342
343
344
345
346
347
 
# File 'lib/sbsm/session.rb', line 340

def http_protocol
	@http_protocol ||=	if(@request.respond_to?(:server_port) \
												&& @request.server_port == 443)
												'https'
											else
												'http'
											end
end

#import_cookies(request) ⇒ Object 



212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/sbsm/session.rb', line 212

def import_cookies(request)
	reset_cookie()
    return if request.cookies.is_a?(DRb::DRbUnknown)
    if(cuki_str = request.cookies[self::class::PERSISTENT_COOKIE_NAME])
      CGI.parse(CGI.unescape(cuki_str)).each { |key, val|
        key = key.intern
        valid = @validator.validate(key, val.compact.last)
        @cookie_input.store(key, valid)
      }
    end
end

#import_user_input(rack_req) ⇒ Object 



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'lib/sbsm/session.rb', line 225

def import_user_input(rack_req)
			# attempting to read the cgi-params more than once results in a
			# DRbConnectionRefused Exception. Therefore, do it only once...
			return if(@user_input_imported)
  hash = rack_req.env.merge rack_req.params
  hash.each do |key, value|
    next if /^rack\./.match(key)
index = nil
@unsafe_input.push([key.to_s.dup, value.to_s.dup])
unless(key.nil? || key.empty?)
	if match = @@hash_ptrn.match(key)
		key = match[1]
		index = match[2]
        #puts key, index
	end
	key = key.intern
	if(key == :confirm_pass)
		pass = rack_req.params["pass"]
		# puts "pass:#{pass} - confirm:#{value}"
		@valid_input[key] = @valid_input[:set_pass] \
			= @validator.set_pass(pass, value)
	else
		valid = @validator.validate(key, value)
        # puts "Checking #{key} -> #{value}  valid #{valid.inspect} index #{index.inspect}"
		if(index)
          target = (@valid_input[key] ||= {})
          indices = []
          index.scan(@@index_ptrn) { |idx|
            indices.push idx
          }
          last = indices.pop
          indices.each { |idx|
            target = (target[idx] ||= {})
          }
          target.store(last, valid)
		else
			@valid_input[key] = valid
          # puts "@valid_input #{key} -> #{value}  valid #{valid.inspect} index #{index.inspect}"
          "dummy" # Some statement is necessary here to avoid Date data loading error on Ruby 1.9.3
		end
	end
end
#puts "imported #{key} -> #{value} => #{@valid_input[key].inspect}"
  end
			@user_input_imported = true
  @valid_input
			#puts @unsafe_input.inspect
			#puts @valid_input.inspect
			#$stdout.flush
end

#info? ⇒ Boolean

Returns:

  • (Boolean) 


278
279
280
 
# File 'lib/sbsm/session.rb', line 278

def info?
	@state.info? if @state.respond_to?(:info?)
end

#infos ⇒ Object

puts @unsafe_input.inspect puts @valid_input.inspect $stdout.flush



275
276
277
 
# File 'lib/sbsm/session.rb', line 275

def infos
	@state.infos if @state.respond_to?(:infos)
end

#input_keys ⇒ Object 



348
349
350
 
# File 'lib/sbsm/session.rb', line 348

def input_keys
	@valid_input.keys
end

#is_crawler? ⇒ Boolean

Returns:

  • (Boolean) 


281
282
283
284
285
 
# File 'lib/sbsm/session.rb', line 281

def is_crawler?
	@is_crawler ||= if @request.respond_to?(:is_crawler?)
                      @request.is_crawler?
                    end
end

#language ⇒ Object 



286
287
288
 
# File 'lib/sbsm/session.rb', line 286

def language
	cookie_set_or_get(:language) || default_language
end

#logged_in? ⇒ Boolean

Returns:

  • (Boolean) 


289
290
291
 
# File 'lib/sbsm/session.rb', line 289

def logged_in?
	!@user.is_a?(@unknown_user_class)
end

#login ⇒ Object 



292
293
294
295
296
297
298
299
 
# File 'lib/sbsm/session.rb', line 292

def 
	if(user = @app.(self))
        SBSM.debug "user is #{user}  #{request_path.inspect}"
		@user = user
    else
      SBSM.debug "login no user #{request_path.inspect}"
	end
end

#logout ⇒ Object 



300
301
302
303
304
305
306
307
 
# File 'lib/sbsm/session.rb', line 300

def logout
    SBSM.debug "logout #{request_path.inspect} setting @state #{self::class::DEFAULT_STATE.new(self, @user)}"
	__checkout
	@user = @app.unknown_user()
	@active_state = @state = self::class::DEFAULT_STATE.new(self, @user)
    @state.init
	@attended_states.store(@state.object_id, @state)
end

#lookandfeel ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'lib/sbsm/session.rb', line 308

def lookandfeel
	if(@lookandfeel.nil? \
		|| (@lookandfeel.flavor != flavor) \
		|| (@lookandfeel.language != persistent_user_input(:language)))
		@lookandfeel = if self::class::LF_FACTORY
			self::class::LF_FACTORY.create(self)
		else
			self::class::LOOKANDFEEL.new(self)
		end
	end
	@lookandfeel
end

#navigation ⇒ Object 



351
352
353
 
# File 'lib/sbsm/session.rb', line 351

def navigation
	@user.navigation
end

#passthru(*args) ⇒ Object 



354
355
356
 
# File 'lib/sbsm/session.rb', line 354

def passthru(*args)
	@request.passthru(*args)
end

#persistent_user_input(key) ⇒ Object 



357
358
359
360
361
362
363
 
# File 'lib/sbsm/session.rb', line 357

def persistent_user_input(key)
	if(value = user_input(key))
		@persistent_user_input.store(key, value)
	else
		@persistent_user_input[key]
	end
end

#process(rack_request) ⇒ Object 



364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/sbsm/session.rb', line 364

def process(rack_request)
    begin
      @request_method =rack_request.request_method
      @request = rack_request
      @request_method ||= @request.request_method
      @request_path = @request.path
      @validator.reset_errors() if @validator && @validator.respond_to?(:reset_errors)
      import_user_input(rack_request)
      import_cookies(rack_request)
      @state = active_state.trigger(event())
      #FIXME: is there a better way to distinguish returning states?
      #       ... we could simply refuse to init if event == :sort, but that
      #       would not solve the problem cleanly, I think.
      unless(@state.request_path)
        @state.request_path = @request_path
        @state.init
      end
      unless @state.volatile?
        SBSM.debug "Changing to #{@state.class}"
        @active_state = @state
        @attended_states.store(@state.object_id, @state)
      end
      @zone = @active_state.zone
      @active_state.touch
      cap_max_states
    rescue DRb::DRbConnError
      raise
	ensure
		@user_input_imported = false
	end
	''
end

#remote_addr ⇒ Object 



413
414
415
416
417
 
# File 'lib/sbsm/session.rb', line 413

def remote_addr
	@remote_addr ||= if @request.respond_to?(:remote_addr)
		@request.remote_addr
	end
end

#remote_ip ⇒ Object 



418
419
420
421
422
 
# File 'lib/sbsm/session.rb', line 418

def remote_ip
	@remote_ip ||= if(@request.respond_to?(:remote_host))
		@request.remote_host
	end
end

#reset ⇒ Object 



396
397
398
399
400
401
402
 
# File 'lib/sbsm/session.rb', line 396

def reset
    if @redirected
      @redirected = false
    else
      reset_input()
    end
end

#reset_cookie ⇒ Object 



403
404
405
 
# File 'lib/sbsm/session.rb', line 403

def reset_cookie
	@cookie_input = {}
end

#reset_input ⇒ Object 



406
407
408
409
410
411
412
 
# File 'lib/sbsm/session.rb', line 406

def reset_input
  @valid_input = {}
			@processing_errors = {}
			@http_protocol = nil
			@flavor = nil
			@unsafe_input = []
end

#restore ⇒ Object

CGI::SessionHandler compatibility



487
488
489
490
491
492
 
# File 'lib/sbsm/session.rb', line 487

def restore
  hash = {
    :proxy	=>	self,
  }
  hash
end

#server_name ⇒ Object 



426
427
428
429
430
431
432
433
434
 
# File 'lib/sbsm/session.rb', line 426

def server_name
	@server_name ||= if @request.respond_to?(:server_name)
		@request.server_name
	else
		self::class::SERVER_NAME
	end
rescue DRb::DRbConnError
	@server_name = self::class::SERVER_NAME
end

#set_cookie_input(key, val) ⇒ Object 



423
424
425
 
# File 'lib/sbsm/session.rb', line 423

def set_cookie_input(key, val)
	@cookie_input.store(key, val)
end

#state(event = nil) ⇒ Object 



435
436
437
 
# File 'lib/sbsm/session.rb', line 435

def state(event=nil)
	@active_state
end

#to_html ⇒ Object 



442
443
444
445
446
447
448
449
 
# File 'lib/sbsm/session.rb', line 442

def to_html
	@state.to_html(cgi)
  rescue DRb::DRbConnError
    raise
rescue StandardError => err
    SBSM.info "StandardError: #@request_path"
	[ err.class, err.message ].join("\n")
end

#touch ⇒ Object 



438
439
440
441
 
# File 'lib/sbsm/session.rb', line 438

def touch
  @mtime = Time.now
  self
end

#update ⇒ Object 



493
494
495
 
# File 'lib/sbsm/session.rb', line 493

def update
  # nothing
end

#user_agent ⇒ Object 



450
451
452
 
# File 'lib/sbsm/session.rb', line 450

def user_agent
  @user_agent ||= (@request.user_agent if @request.respond_to?(:user_agent))
end

#user_input(*keys) ⇒ Object 



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
 
# File 'lib/sbsm/session.rb', line 454

def user_input(*keys)
			if(keys.size == 1)
index = nil
key = keys.first.to_s
if match = @@input_ptrn.match(key)
	key = match[1]
	index = match[2]
end
key_sym = key.to_sym
valid = @valid_input[key_sym]
if(index && valid.respond_to?(:[]))
	valid[index]
else
	valid
end
			else
keys.inject({}) { |inj, key|
	inj.store(key, user_input(key))
	inj
}
			end
end

#valid_values(key) ⇒ Object 



476
477
478
479
 
# File 'lib/sbsm/session.rb', line 476

def valid_values(key)
	vals = @validator.valid_values(key) unless @validator.nil?
	vals || []
end

#warning? ⇒ Boolean

Returns:

  • (Boolean) 


483
484
485
 
# File 'lib/sbsm/session.rb', line 483

def warning?
	@state.warning? if @state.respond_to?(:warning?)
end

#warnings ⇒ Object 



480
481
482
 
# File 'lib/sbsm/session.rb', line 480

def warnings
	@state.warnings if @state.respond_to?(:warnings)
end

#zone ⇒ Object 



503
504
505
 
# File 'lib/sbsm/session.rb', line 503

def zone
	@valid_input[:zone] || @state.zone || self::class::DEFAULT_ZONE
end

#zone_navigation ⇒ Object 



509
510
511
 
# File 'lib/sbsm/session.rb', line 509

def zone_navigation
	@state.zone_navigation
end

#zones ⇒ Object 



506
507
508
 
# File 'lib/sbsm/session.rb', line 506

def zones
	@active_state.zones
end