Class: Magick::Adapters::Memory

Inherits:
Base
  • Object
show all
Defined in:
lib/magick/adapters/memory.rb

Constant Summary collapse

CLEANUP_INTERVAL =

seconds between cleanup sweeps

30

Instance Method Summary collapse

Methods inherited from Base

#load_features_data_with_prefix, #load_features_data_without_prefixes

Constructor Details

#initialize ⇒ Memory

Returns a new instance of Memory.



10
11
12
13
14
15
16
 
# File 'lib/magick/adapters/memory.rb', line 10

def initialize
  @store = {}
  @mutex = Mutex.new
  @ttl = {}
  @default_ttl = 3600 # 1 hour default TTL
  @last_cleanup = Time.now.to_i
end

Instance Method Details

#all_features ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/magick/adapters/memory.rb', line 57

def all_features
  mutex.synchronize do
    cleanup_expired_if_needed
    store.keys
  end
end

#clear ⇒ Object 



131
132
133
134
135
136
 
# File 'lib/magick/adapters/memory.rb', line 131

def clear
  mutex.synchronize do
    @store = {}
    @ttl = {}
  end
end

#delete(feature_name) ⇒ Object 



42
43
44
45
46
47
48
 
# File 'lib/magick/adapters/memory.rb', line 42

def delete(feature_name)
  mutex.synchronize do
    feature_name_str = feature_name.to_s
    store.delete(feature_name_str)
    ttl.delete(feature_name_str)
  end
end

#delete_key(feature_name, key) ⇒ Object

Remove one key without touching the rest of the feature's data.



106
107
108
109
110
111
112
113
 
# File 'lib/magick/adapters/memory.rb', line 106

def delete_key(feature_name, key)
  mutex.synchronize do
    feature_data = store[feature_name.to_s]
    next false unless feature_data

    !feature_data.delete(key.to_s).nil?
  end
end

#exists?(feature_name) ⇒ Boolean

Returns:

  • (Boolean) 


50
51
52
53
54
55
 
# File 'lib/magick/adapters/memory.rb', line 50

def exists?(feature_name)
  mutex.synchronize do
    cleanup_expired_if_needed
    store.key?(feature_name.to_s)
  end
end

#get(feature_name, key) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/magick/adapters/memory.rb', line 18

def get(feature_name, key)
  feature_name_str = feature_name.is_a?(String) ? feature_name : feature_name.to_s
  key_str = key.is_a?(String) ? key : key.to_s

  mutex.synchronize do
    cleanup_expired_if_needed
    feature_data = store[feature_name_str]
    return nil unless feature_data

    value = feature_data[key_str]
    deserialize_value(value)
  end
end

#get_all_data(feature_name) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/magick/adapters/memory.rb', line 64

def get_all_data(feature_name)
  feature_name_str = feature_name.to_s
  mutex.synchronize do
    cleanup_expired_if_needed
    feature_data = store[feature_name_str]
    return {} unless feature_data

    feature_data.each_with_object({}) do |(k, v), result|
      result[k] = deserialize_value(v)
    end
  end
end

#load_all_features_data ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/magick/adapters/memory.rb', line 77

def load_all_features_data
  mutex.synchronize do
    cleanup_expired_if_needed
    result = {}
    store.each do |feature_name, feature_data|
      deserialized = {}
      feature_data.each do |k, v|
        deserialized[k] = deserialize_value(v)
      end
      result[feature_name] = deserialized
    end
    result
  end
end

#next_sequence(feature_name, key, floor: 0) ⇒ Object

Atomic within this process: the counter is read, bumped and written under the same lock, so concurrent threads never share a number. Across processes each memory adapter is its own store, which is why Versioning only allocates here when no shared backend is configured.



119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/magick/adapters/memory.rb', line 119

def next_sequence(feature_name, key, floor: 0)
  mutex.synchronize do
    cleanup_expired_if_needed
    feature_name_str = feature_name.to_s
    counters = (store[feature_name_str] ||= {})
    value = [counters[key.to_s].to_i, floor.to_i].max + 1
    counters[key.to_s] = value
    update_ttl(feature_name_str)
    value
  end
end

#set(feature_name, key, value) ⇒ Object 



32
33
34
35
36
37
38
39
40
 
# File 'lib/magick/adapters/memory.rb', line 32

def set(feature_name, key, value)
  mutex.synchronize do
    cleanup_expired_if_needed
    feature_name_str = feature_name.to_s
    store[feature_name_str] ||= {}
    store[feature_name_str][key.to_s] = serialize_value(value)
    update_ttl(feature_name_str)
  end
end

#set_all_data(feature_name, data_hash) ⇒ Object

Bulk set all data for a feature (used by preloading)



93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/magick/adapters/memory.rb', line 93

def set_all_data(feature_name, data_hash)
  mutex.synchronize do
    cleanup_expired_if_needed
    feature_name_str = feature_name.to_s
    store[feature_name_str] ||= {}
    data_hash.each do |key, value|
      store[feature_name_str][key.to_s] = serialize_value(value)
    end
    update_ttl(feature_name_str)
  end
end

#set_ttl(feature_name, seconds) ⇒ Object 



138
139
140
141
142
 
# File 'lib/magick/adapters/memory.rb', line 138

def set_ttl(feature_name, seconds)
  mutex.synchronize do
    ttl[feature_name.to_s] = Time.now.to_i + seconds
  end
end