Class: TorqueBox::Infinispan::Cache

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

Constant Summary collapse

SECONDS = 
java.util.concurrent.TimeUnit::SECONDS

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Cache

Returns a new instance of Cache.



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/torquebox/cache.rb', line 55

def initialize(opts = {})
  return nothing unless INFINISPAN_AVAILABLE
  @options = opts
  options[:transaction_mode] = :transactional unless options.has_key?( :transaction_mode )
  options[:locking_mode] ||= :optimistic if (transactional? && !options.has_key?( :locking_mode ))
  options[:sync] = true if options[:sync].nil?
  if options[:encoding] == :marshal
    log( "Encoding of :marshal cannot be used with " +
         "TorqueBox::Infinispan::Cache - using :marshal_base64 instead",
         'WARN')
    options[:encoding] = :marshal_base64
  end
  @codec = TorqueBox::Codecs[ options[:encoding] || :marshal_smart ]
  cache
end

Class Method Details

.log(message, status = 'INFO') ⇒ Object 



249
250
251
 
# File 'lib/torquebox/cache.rb', line 249

def self.log( message, status = 'INFO' )
  $stdout.puts( "#{status}: #{message}" )
end

Instance Method Details

#add_listener(listener) ⇒ Object 



241
242
243
 
# File 'lib/torquebox/cache.rb', line 241

def add_listener( listener )
  cache.add_listener( listener )
end

#all ⇒ Object Also known as: values 



152
153
154
 
# File 'lib/torquebox/cache.rb', line 152

def all
  keys.map{|k| get(k)}
end

#clear ⇒ Object

Clear the entire cache. Be careful with this method since it could affect other processes if shared cache is being used.



139
140
141
 
# File 'lib/torquebox/cache.rb', line 139

def clear
  cache.clear
end

#clustered? ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/torquebox/cache.rb', line 91

def clustered?
  INFINISPAN_AVAILABLE && service.clustered? 
end

#clustering_mode ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/torquebox/cache.rb', line 95

def clustering_mode
  return CacheMode::LOCAL unless clustered?
  sync = options[:sync]
  case
  when replicated?
    sync ? CacheMode::REPL_SYNC : CacheMode::REPL_ASYNC
  when distributed?
    sync ? CacheMode::DIST_SYNC : CacheMode::DIST_ASYNC
  when invalidated?
    sync ? CacheMode::INVALIDATION_SYNC : CacheMode::INVALIDATION_ASYNC
  else
    sync ? CacheMode::DIST_SYNC : CacheMode::DIST_ASYNC
  end
end

#contains_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


157
158
159
 
# File 'lib/torquebox/cache.rb', line 157

def contains_key?( key )
  cache.contains_key( encode(key) )
end

#decrement(name, amount = 1) ⇒ Object

Decrement an integer value in the cache; return new value



204
205
206
 
# File 'lib/torquebox/cache.rb', line 204

def decrement(name, amount = 1)
  increment( name, -amount )
end

#distributed? ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/torquebox/cache.rb', line 83

def distributed?
  [:d, :dist, :distributed, :distribution].include? options[:mode]
end

#evict(key) ⇒ Object 



177
178
179
 
# File 'lib/torquebox/cache.rb', line 177

def evict( key )
  cache.evict( encode(key) )
end

#eviction_strategy ⇒ Object 



125
126
127
128
129
130
131
 
# File 'lib/torquebox/cache.rb', line 125

def eviction_strategy
  case options[:eviction]
  when :lirs then EvictionStrategy::LIRS
  when :lru then EvictionStrategy::LRU
  when :unordered then EvictionStrategy::UNORDERED
  end
end

#get(key) ⇒ Object Also known as: []

Get an entry from the cache



162
163
164
 
# File 'lib/torquebox/cache.rb', line 162

def get(key)
  decode(cache.get(encode(key)))
end

#increment(sequence_name, amount = 1) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/torquebox/cache.rb', line 190

def increment(sequence_name, amount = 1)
  result, current = amount, get(sequence_name)
  if current.nil?
    put(sequence_name, result)
  else
    result = current + amount
    unless replace(sequence_name, current, result)
      raise "Concurrent modification, old value was #{current} new value #{result}"
    end
  end
  result
end

#invalidated? ⇒ Boolean

Returns:

  • (Boolean) 


87
88
89
 
# File 'lib/torquebox/cache.rb', line 87

def invalidated?
  [:i, :inv, :invalidated, :invalidation].include? options[:mode] 
end

#keys ⇒ Object

Return the keys in the cache; potentially very expensive depending on configuration



144
145
146
 
# File 'lib/torquebox/cache.rb', line 144

def keys
  cache.key_set.map{|k| decode(k)}
end

#locking_mode ⇒ Object 



110
111
112
113
114
115
 
# File 'lib/torquebox/cache.rb', line 110

def locking_mode
  case options[:locking_mode]
  when :optimistic then LockingMode::OPTIMISTIC
  when :pessimistic then LockingMode::PESSIMISTIC
  end
end

#log(message, status = 'INFO') ⇒ Object 



253
254
255
 
# File 'lib/torquebox/cache.rb', line 253

def log( message, status = 'INFO' )
  TorqueBox::Infinispan::Cache.log( message, status )
end

#max_entries ⇒ Object 



133
134
135
 
# File 'lib/torquebox/cache.rb', line 133

def max_entries
  options[:max_entries] || -1
end

#name ⇒ Object 



71
72
73
 
# File 'lib/torquebox/cache.rb', line 71

def name
  options[:name] || TORQUEBOX_APP_NAME
end

#persisted? ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
 
# File 'lib/torquebox/cache.rb', line 75

def persisted?
  !!options[:persist]
end

#put(key, value, expires = 0) ⇒ Object Also known as: []=

Write an entry to the cache



168
169
170
 
# File 'lib/torquebox/cache.rb', line 168

def put(key, value, expires = 0)
  __put(key, value, expires, :put)
end

#put_if_absent(key, value, expires = 0) ⇒ Object 



173
174
175
 
# File 'lib/torquebox/cache.rb', line 173

def put_if_absent(key, value, expires = 0)
  __put(key, value, expires, :put_if_absent)
end

#remove(key) ⇒ Object

Delete an entry from the cache



186
187
188
 
# File 'lib/torquebox/cache.rb', line 186

def remove(key)
  decode(cache.remove(encode(key)))
end

#replace(key, original_value, new_value) ⇒ Object 



181
182
183
 
# File 'lib/torquebox/cache.rb', line 181

def replace(key, original_value, new_value)
  cache.replace(encode(key), encode(original_value), encode(new_value))
end

#replicated? ⇒ Boolean

Returns:

  • (Boolean) 


79
80
81
 
# File 'lib/torquebox/cache.rb', line 79

def replicated?
  [:r, :repl, :replicated, :replication].include? options[:mode]
end

#size ⇒ Object 



148
149
150
 
# File 'lib/torquebox/cache.rb', line 148

def size
  cache.size
end

#stop ⇒ Object 



245
246
247
 
# File 'lib/torquebox/cache.rb', line 245

def stop
  cache.stop
end

#transaction(&block) ⇒ Object 



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/torquebox/cache.rb', line 208

def transaction(&block)
  if !transactional?
    yield self
  elsif TorqueBox.fetch('transaction-manager').nil?
    tm = cache.getAdvancedCache.getTransactionManager
    begin
      tm.begin if tm
      yield self
      tm.commit if tm
    rescue Exception => e
      if tm.nil?
        log( "Transaction is nil", "ERROR" )
        log( e.message, 'ERROR' )
        log( e.backtrace, 'ERROR' )
      elsif tm.status == javax.transaction.Status.STATUS_NO_TRANSACTION
        log( "No transaction was started", "ERROR" )
        log( e.message, 'ERROR' )
        log( e.backtrace, 'ERROR' )
      else
        tm.rollback 
        log( "Rolling back.", 'ERROR' )
        log( e.message, 'ERROR' )
        log( e.backtrace, 'ERROR' )
      end
      raise e
    end
  else
    TorqueBox.transaction do 
      yield self 
    end
  end
end

#transaction_mode ⇒ Object 



117
118
119
 
# File 'lib/torquebox/cache.rb', line 117

def transaction_mode
  options[:transaction_mode] == :transactional ? TransactionMode::TRANSACTIONAL : TransactionMode::NON_TRANSACTIONAL
end

#transactional? ⇒ Boolean

Returns:

  • (Boolean) 


121
122
123
 
# File 'lib/torquebox/cache.rb', line 121

def transactional?
  transaction_mode == TransactionMode::TRANSACTIONAL
end