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.



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

def initialize(opts = {})
  @options = opts
  
  if INFINISPAN_AVAILABLE
    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?
  end

  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 



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

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

Instance Method Details

#add_listener(listener) ⇒ Object 



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

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

#all ⇒ Object Also known as: values 



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

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.



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

def clear
  cache.clear
end

#clustered? ⇒ Boolean 



95
96
97
 
# File 'lib/torquebox/cache.rb', line 95

def clustered?
  INFINISPAN_AVAILABLE && service.clustered? 
end

#clustering_mode ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/torquebox/cache.rb', line 99

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 



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

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



208
209
210
 
# File 'lib/torquebox/cache.rb', line 208

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

#distributed? ⇒ Boolean 



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

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

#evict(key) ⇒ Object 



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

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

#eviction_strategy ⇒ Object 



129
130
131
132
133
134
135
 
# File 'lib/torquebox/cache.rb', line 129

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



166
167
168
 
# File 'lib/torquebox/cache.rb', line 166

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

#increment(sequence_name, amount = 1) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/torquebox/cache.rb', line 194

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 



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

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

#keys ⇒ Object

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



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

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

#locking_mode ⇒ Object 



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

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

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



257
258
259
 
# File 'lib/torquebox/cache.rb', line 257

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

#max_entries ⇒ Object 



137
138
139
 
# File 'lib/torquebox/cache.rb', line 137

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

#name ⇒ Object 



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

def name
  options[:name] || TORQUEBOX_APP_NAME
end

#persisted? ⇒ Boolean 



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

def persisted?
  !!options[:persist]
end

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

Write an entry to the cache



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

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

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



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

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



190
191
192
 
# File 'lib/torquebox/cache.rb', line 190

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

#replace(key, original_value, new_value) ⇒ Object 



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

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

#replicated? ⇒ Boolean 



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

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

#size ⇒ Object 



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

def size
  cache.size
end

#stop ⇒ Object 



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

def stop
  cache.stop
end

#transaction(&block) ⇒ Object 



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
240
241
242
243
 
# File 'lib/torquebox/cache.rb', line 212

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 



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

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

#transactional? ⇒ Boolean 



125
126
127
 
# File 'lib/torquebox/cache.rb', line 125

def transactional?
  transaction_mode == TransactionMode::TRANSACTIONAL
end