Class: SadieSession

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(params) ⇒ SadieSession

Returns a new instance of SadieSession.



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/sadie_session.rb', line 12

def initialize( params )
  
  # init lock manager
  @lockmgr = LockManager.new
  
  # init expiry and refresh threads
  @expiry_lock = @lockmgr.create( :systype => :session,
                                  :locktype => :expiry  )
  @refresh_lock = @lockmgr.create( :systype => :session,
                                   :locktype => :refresh  )

  @expiry_queue,@refresh_queue = TimestampQueue.new,TimestampQueue.new
  
  _initialize_expiry_thread
  _initialize_refresh_thread
  
  
  # init registered key hash
  @registered_key = {}
  
  # init session operating parameters
  @default_storage_mechanism = :memory
  @file_storage_mechanism_dirpath = nil
  unless params.nil?
    if params.is_a? Hash
      
      if params.has_key?( :primers_dirpath )
        self.primers_dirpath = params[:primers_dirpath]
        _register_primers
      end
      
      if params.has_key?( :default_storage_mechanism )
        @default_storage_mechanism = params[:default_storage_mechanism]
      end
      
      if params.has_key?( :file_storage_mechanism_dirpath )
        @file_storage_mechanism_dirpath = params[:file_storage_mechanism_dirpath]
      end
      
    end
  end
  
  # init storage manager
  @storagemgr_lock = @lockmgr.create( :systype => :session,
                                      :locktype => :expiry  )
  @storage_manager = SadieStorageManager.new
  @lockmgr.critical_section_insist( @storagemgr_lock ) do
    @storage_manager.register_storage_mechanism :memory, SadieStorageMechanismMemory.new
    @storage_manager.register_storage_mechanism :file, SadieStorageMechanismFile.new(:key_storage_dirpath => @file_storage_mechanism_dirpath)
  end
  
end

Instance Attribute Details

#primers_dirpath ⇒ Object

Returns the value of attribute primers_dirpath.



10
11
12
 
# File 'lib/sadie_session.rb', line 10

def primers_dirpath
  @primers_dirpath
end

Instance Method Details

#get(key) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/sadie_session.rb', line 116

def get( key )
  ret = nil
  if @storage_manager.has_key?( key )
    ret = @storage_manager.get( key )
  elsif primer_registered?( key )
    
    @primer_lock = @lockmgr.create( :systype => :session,
                                    :locktype => :primer,
                                    :key => key )
    p = nil
    
    @lockmgr.critical_section_try( @primer_lock ) do
      p = _get_primed_primer( key )
      ret = @storage_manager.get( key )
      if p.expire == :on_get
        @storage_manager.unset( key )
      end
    end
    if ! p.nil?
      _manage_refresh( key, p.refresh_rate ) if ( p.refreshes? )
    else 
      @lockmgr.critical_section_insist( @primer_lock ) do
        if @storage_manager.has_key?( key )
          ret = @storage_manager.get( key )
        else
          ret = get( key )  # recurse should only happen if primer set to expire on get
        end
      end
    end
    
  end
  ret
end

#has_key?(key, params) ⇒ Boolean

Returns:

  • (Boolean) 


65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/sadie_session.rb', line 65

def has_key?( key, params )
  ret = @storage_manager.has_key?( key )
  include_primers = true
  
  if ( params.is_a?( Hash ) ) && ( params.has_key?( :include_primers ) )
    include_primers = params[:include_primers]
  end      
  
  if ( ! ret ) && ( include_primers )
    ret = primer_registered?( key )
  end
  
  ret
end

#has_metadata?(key) ⇒ Boolean

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/sadie_session.rb', line 90

def has_metadata?( key )
  @storage_manager.has_metadata?( key )
end

#metadata(key) ⇒ Object 



94
95
96
 
# File 'lib/sadie_session.rb', line 94

def metadata( key )
  @storage_manager.metadata( key )
end

#primer_registered?(key) ⇒ Boolean

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/sadie_session.rb', line 80

def primer_registered?( key )
  @registered_key.has_key? key
end

#set(keys, value, params = nil) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/sadie_session.rb', line 98

def set( keys, value, params=nil )
  expires, mechanism, metadata = :never, @default_storage_mechanism, nil
  unless params.nil?
    if params.is_a? Hash
      expires = params[:expire] if params.has_key?( :expire )
      mechanism = params[:mechanism] if params.has_key?( :mechanism )
      metadata = params[:metadata] if params.has_key?( :metadata )
    end
  end
  @lockmgr.critical_section_insist( @storagemgr_lock ) do
    @storage_manager.set( :keys => Array( keys ),
                          :value => value,
                          :mechanism => mechanism,
                          :metadata => metadata )
  end
  _manage_expiry( keys, expires ) unless expires == :never || expires == :on_get
end

#unset(key) ⇒ Object 



84
85
86
87
88
 
# File 'lib/sadie_session.rb', line 84

def unset( key )
  @lockmgr.critical_section_insist( @storagemgr_lock ) do
    @storage_manager.unset( key )
  end
end