Class: AvroTurf::DiskCache

Inherits:
Object
  • Object
show all
Defined in:
lib/avro_turf/disk_cache.rb

Overview

A cache for the CachedConfluentSchemaRegistry. Extends the InMemoryCache to provide a write-thru to disk for persistent cache.

Instance Method Summary collapse

Constructor Details

#initialize(disk_path, logger: Logger.new($stdout)) ⇒ DiskCache

Returns a new instance of DiskCache.



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/avro_turf/disk_cache.rb', line 6

def initialize(disk_path, logger: Logger.new($stdout))
  @logger = logger

  # load the write-thru cache on startup, if it exists
  @schemas_by_id_path = File.join(disk_path, "schemas_by_id.json")
  hash = read_from_disk_cache(@schemas_by_id_path)
  @schemas_by_id = hash || {}

  @ids_by_schema_path = File.join(disk_path, "ids_by_schema.json")
  hash = read_from_disk_cache(@ids_by_schema_path)
  @ids_by_schema = hash || {}

  @schemas_by_subject_version_path = File.join(disk_path, "schemas_by_subject_version.json")
  @schemas_by_subject_version = {}

  @data_by_schema_path = File.join(disk_path, "data_by_schema.json")
  hash = read_from_disk_cache(@data_by_schema_path)
  @data_by_schema = hash || {}
end

Instance Method Details

#lookup_by_id(id) ⇒ Object

override the write-thru cache (json) does not store keys in numeric format so, convert id to a string for caching purposes



29
30
31
 
# File 'lib/avro_turf/disk_cache.rb', line 29

def lookup_by_id(id)
  @schemas_by_id[id.to_s]
end

#lookup_by_schema(subject, schema) ⇒ Object

override to use a json serializable cache key



43
44
45
46
 
# File 'lib/avro_turf/disk_cache.rb', line 43

def lookup_by_schema(subject, schema)
  key = "#{subject}#{schema}"
  @ids_by_schema[key]
end

#lookup_by_version(subject, version) ⇒ Object

checks instance var (in-memory cache) for schema checks disk cache if in-memory cache doesn’t exists if file exists but no in-memory cache, read from file and sync in-memory cache finally, if file doesn’t exist return nil



76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/avro_turf/disk_cache.rb', line 76

def lookup_by_version(subject, version)
  key = "#{subject}#{version}"
  schema = @schemas_by_subject_version[key]

  return schema unless schema.nil?

  hash = read_from_disk_cache(@schemas_by_subject_version_path)
  if hash
    @schemas_by_subject_version = hash
    @schemas_by_subject_version[key]
  end
end

#lookup_data_by_schema(subject, schema) ⇒ Object

override to use a json serializable cache key



49
50
51
52
 
# File 'lib/avro_turf/disk_cache.rb', line 49

def lookup_data_by_schema(subject, schema)
  key = "#{subject}#{schema}"
  @data_by_schema[key]
end

#store_by_id(id, schema) ⇒ Object

override to include write-thru cache after storing result from upstream



34
35
36
37
38
39
40
 
# File 'lib/avro_turf/disk_cache.rb', line 34

def store_by_id(id, schema)
  # must return the value from storing the result (i.e. do not return result from file write)
  @schemas_by_id[id.to_s] = schema
  write_to_disk_cache(@schemas_by_id_path, @schemas_by_id)

  schema
end

#store_by_schema(subject, schema, id) ⇒ Object

override to use a json serializable cache key and update the file cache



55
56
57
58
59
60
61
 
# File 'lib/avro_turf/disk_cache.rb', line 55

def store_by_schema(subject, schema, id)
  key = "#{subject}#{schema}"
  @ids_by_schema[key] = id

  write_to_disk_cache(@ids_by_schema_path, @ids_by_schema)
  id
end

#store_by_version(subject, version, schema) ⇒ Object

check if file exists and parse json into a hash if file exists take json and overwite/insert schema at key if file doesn’t exist create new hash write the new/updated hash to file update instance var (in memory-cache) to match



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

def store_by_version(subject, version, schema)
  key = "#{subject}#{version}"
  hash = read_from_disk_cache(@schemas_by_subject_version_path)
  hash = if hash
    hash[key] = schema
    hash
  else
    {key => schema}
  end

  write_to_disk_cache(@schemas_by_subject_version_path, hash)

  @schemas_by_subject_version = hash
  @schemas_by_subject_version[key]
end

#store_data_by_schema(subject, schema, data) ⇒ Object 



63
64
65
66
67
68
69
70
 
# File 'lib/avro_turf/disk_cache.rb', line 63

def store_data_by_schema(subject, schema, data)
  return unless data

  key = "#{subject}#{schema}"
  @data_by_schema[key] = data
  write_to_disk_cache(@data_by_schema_path, @data_by_schema)
  data
end