Class: FMCache::Engine

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

Constant Summary collapse

DEFAULT_TTL =

7 days

7 * 24 * 3600

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client:, fm_parser:, ttl: DEFAULT_TTL, notifier: nil, json_serializer: nil, id_key_prefix: nil) ⇒ Engine

Returns a new instance of Engine.

Parameters:

  • client (Redis | MockRRedis)
  • fm_parser (Proc)
  • ttl (Integer) (defaults to: DEFAULT_TTL)
  • notifier (Proc, nil) (defaults to: nil)
  • json_serializer (#dump#load, nil) (defaults to: nil)
  • id_key_prefix (String, nil) (defaults to: nil) 


11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/fmcache/engine.rb', line 11

def initialize(
  client:,
  fm_parser:,
  ttl:             DEFAULT_TTL,
  notifier:        nil,
  json_serializer: nil,
  id_key_prefix:   nil
)
  @client     = Client.new(client, notifier)
  @fm_parser  = wrap(fm_parser)
  @ttl        = ttl
  @id_key_gen = IdKeyGen.new(id_key_prefix)
  @encoder    = Encoder.new(@id_key_gen)
  @decoder    = Decoder.new(@fm_parser)
  @jsonizer   = Jsonizer.new(json_serializer)
end

Instance Attribute Details

#client ⇒ Object (readonly)

Returns the value of attribute client.



28
29
30
 
# File 'lib/fmcache/engine.rb', line 28

def client
  @client
end

#decoder ⇒ Object (readonly)

Returns the value of attribute decoder.



28
29
30
 
# File 'lib/fmcache/engine.rb', line 28

def decoder
  @decoder
end

#encoder ⇒ Object (readonly)

Returns the value of attribute encoder.



28
29
30
 
# File 'lib/fmcache/engine.rb', line 28

def encoder
  @encoder
end

#fm_parser ⇒ Object (readonly)

Returns the value of attribute fm_parser.



28
29
30
 
# File 'lib/fmcache/engine.rb', line 28

def fm_parser
  @fm_parser
end

Instance Method Details

#delete(ids:) ⇒ Object

Parameters:

  • ids (<Integer | String>) 


91
92
93
94
 
# File 'lib/fmcache/engine.rb', line 91

def delete(ids:)
  ids = ids.map(&:to_i)
  client.del(keys: @id_key_gen.to_keys(ids))
end

#fetch(ids:, field_mask:) {|ids,| ... } ⇒ <Hash>

Parameters:

  • ids (<Integer | String>)
  • field_mask (FieldMaskParser::Node)

Yield Parameters:

  • ids, (<Integer>, FieldMaskParser::Node) —

    field_mask

Yield Returns:

  • (<Hash>)

Returns:

  • (<Hash>) 


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/fmcache/engine.rb', line 62

def fetch(ids:, field_mask:, &block)
  ids = ids.map(&:to_i)
  normalize!(field_mask)

  values, incomplete_values, incomplete_info = read(ids: ids, field_mask: field_mask)
  return values if incomplete_info.ids.size == 0

  # NOTE: get new data
  d = block.call(incomplete_info.ids, incomplete_info.field_mask)
  write(values: d, field_mask: incomplete_info.field_mask)

  older = encode(incomplete_values, field_mask)
  newer = encode(d,                 incomplete_info.field_mask)

  v, i_v, i_i = decode(older.deep_merge(newer), field_mask)

  if i_i.ids.size == 0
    r = values + v + i_v
  else
    # NOTE: Fallback to block.call with full field_mask
    d2 = block.call(i_i.ids, field_mask)
    write(values: d2, field_mask: field_mask)
    r = values + d2
  end

  Helper.sort(r, ids)
end

#read(ids:, field_mask:) ⇒ <Hash>, IncompleteInfo

Parameters:

  • ids (<Integer | String>)
  • field_mask (FieldMaskParser::Node)

Returns:



42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/fmcache/engine.rb', line 42

def read(ids:, field_mask:)
  ids = ids.map(&:to_i)
  normalize!(field_mask)

  keys   = @id_key_gen.to_keys(ids)
  fields = Helper.to_fields(field_mask)
  h = client.get(keys: keys, fields: fields)

  with_id, with_no_id = split(h)
  v, i_v, i_i = decode(@jsonizer.dejsonize(with_id), field_mask)
  with_no_id_list = @id_key_gen.to_ids(with_no_id.keys)

  return v, i_v, merge(i_i, with_no_id_list, field_mask)
end

#write(values:, field_mask:) ⇒ Boolean

Parameters:

  • values (<Hash>)
  • field_mask (FieldMaskParser::Node)

Returns:

  • (Boolean) 


33
34
35
36
37
 
# File 'lib/fmcache/engine.rb', line 33

def write(values:, field_mask:)
  normalize!(field_mask)
  h = encode(values, field_mask)
  client.set(values: @jsonizer.jsonize(h), ttl: @ttl)
end