Class: Lutaml::Store::Adapter::Memory

Inherits:
Base
  • Object
show all
Defined in:
lib/lutaml/store/adapter/memory.rb

Instance Method Summary collapse

Constructor Details

#initialize(config = {}) ⇒ Memory

Returns a new instance of Memory.



7
8
9
10
11
12
13
14
 
# File 'lib/lutaml/store/adapter/memory.rb', line 7

def initialize(config = {})
  super
  @data = {}
  @mutex = Mutex.new
  @ttl_enabled = @config.fetch(:ttl_enabled, false)
  @ttl_data = {} if @ttl_enabled
  @default_ttl = @config[:default_ttl] || 3600
end

Instance Method Details

#all ⇒ Object 



66
67
68
69
70
71
 
# File 'lib/lutaml/store/adapter/memory.rb', line 66

def all
  @mutex.synchronize do
    cleanup_expired if @ttl_enabled
    @data.dup
  end
end

#bulk_delete(keys) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/lutaml/store/adapter/memory.rb', line 193

def bulk_delete(keys)
  @mutex.synchronize do
    result = {}
    keys.each do |key|
      result[key] = @data.delete(key)
      @ttl_data.delete(key) if @ttl_enabled
    end
    result
  end
end

#bulk_get(keys) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/lutaml/store/adapter/memory.rb', line 173

def bulk_get(keys)
  @mutex.synchronize do
    result = {}
    keys.each do |key|
      if @data.key?(key)
        if @ttl_enabled && expired?(key)
          @data.delete(key)
          @ttl_data.delete(key)
          result[key] = nil
        else
          result[key] = @data[key]
        end
      else
        result[key] = nil
      end
    end
    result
  end
end

#bulk_set(key_value_pairs, ttl: nil) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/lutaml/store/adapter/memory.rb', line 160

def bulk_set(key_value_pairs, ttl: nil)
  @mutex.synchronize do
    key_value_pairs.each do |key, value|
      @data[key] = value

      if @ttl_enabled
        ttl_value = ttl || @default_ttl
        @ttl_data[key] = Time.now + ttl_value if ttl_value
      end
    end
  end
end

#cleanup_expired ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/lutaml/store/adapter/memory.rb', line 114

def cleanup_expired
  return unless @ttl_enabled

  @mutex.synchronize do
    expired_keys = []
    @ttl_data.each do |key, expiry_time|
      expired_keys << key if Time.now > expiry_time
    end

    expired_keys.each do |key|
      @data.delete(key)
      @ttl_data.delete(key)
    end

    expired_keys.size
  end
end

#clear ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'lib/lutaml/store/adapter/memory.rb', line 73

def clear
  @mutex.synchronize do
    count = @data.size
    @data.clear
    @ttl_data.clear if @ttl_enabled
    count
  end
end

#close ⇒ Object 



96
97
98
99
100
101
 
# File 'lib/lutaml/store/adapter/memory.rb', line 96

def close
  @mutex.synchronize do
    @data.clear
    @ttl_data.clear if @ttl_enabled
  end
end

#delete(key) ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/lutaml/store/adapter/memory.rb', line 43

def delete(key)
  @mutex.synchronize do
    existed = @data.key?(key)
    @data.delete(key)
    @ttl_data.delete(key) if @ttl_enabled
    existed
  end
end

#exists?(key) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/lutaml/store/adapter/memory.rb', line 52

def exists?(key)
  @mutex.synchronize do
    return false unless @data.key?(key)

    if @ttl_enabled && expired?(key)
      @data.delete(key)
      @ttl_data.delete(key)
      return false
    end

    true
  end
end

#get(key) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/lutaml/store/adapter/memory.rb', line 16

def get(key)
  @mutex.synchronize do
    return nil unless @data.key?(key)

    if @ttl_enabled && expired?(key)
      @data.delete(key)
      @ttl_data.delete(key)
      return nil
    end

    @data[key]
  end
end

#get_ttl(key) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/lutaml/store/adapter/memory.rb', line 148

def get_ttl(key)
  return nil unless @ttl_enabled

  @mutex.synchronize do
    return nil unless @ttl_data.key?(key)

    expiry_time = @ttl_data[key]
    remaining = expiry_time - Time.now
    remaining.positive? ? remaining : nil
  end
end

#keys ⇒ Object 



89
90
91
92
93
94
 
# File 'lib/lutaml/store/adapter/memory.rb', line 89

def keys
  @mutex.synchronize do
    cleanup_expired if @ttl_enabled
    @data.keys
  end
end

#set(key, value, metadata = {}) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/lutaml/store/adapter/memory.rb', line 30

def set(key, value, metadata = {})
  @mutex.synchronize do
    @data[key] = value

    if @ttl_enabled
      ttl_value = metadata[:ttl] || @default_ttl
      @ttl_data[key] = Time.now + ttl_value if ttl_value
    end

    value
  end
end

#set_ttl(key, ttl) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/lutaml/store/adapter/memory.rb', line 132

def set_ttl(key, ttl)
  return false unless @ttl_enabled

  @mutex.synchronize do
    return false unless @data.key?(key)

    if ttl
      @ttl_data[key] = Time.now + ttl
    else
      @ttl_data.delete(key)
    end

    true
  end
end

#size ⇒ Object 



82
83
84
85
86
87
 
# File 'lib/lutaml/store/adapter/memory.rb', line 82

def size
  @mutex.synchronize do
    cleanup_expired if @ttl_enabled
    @data.size
  end
end

#stats ⇒ Object 



103
104
105
106
107
108
109
110
111
112
 
# File 'lib/lutaml/store/adapter/memory.rb', line 103

def stats
  @mutex.synchronize do
    cleanup_expired if @ttl_enabled
    super.merge(
      size: @data.size,
      ttl_enabled: @ttl_enabled,
      expired_keys: @ttl_enabled ? count_expired_keys : 0
    )
  end
end