cosmos 5.0.3 → 5.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cc294c0ebdd3984fd89fc3a21d4c269c47c6bc4bd7851f0f3ef5ae5393ad365
-  data.tar.gz: 89168bfb640bb201cc62f1060b83285326ca7497feeea878c4ec81b6a0c8b40c
+  metadata.gz: 5a561fd5492c1b282759d45170da4e687b4e53eea086804bde1c549a75a8bdd5
+  data.tar.gz: c88407b16125e7ef2fb9764dd14338f6508e2fbde1567ff3b7d23b24f1b7dd2a
 SHA512:
-  metadata.gz: 4f3524b98078bf0568a703d2622f81865fe1133a34434c203b03d2a29ff7dd55510a762fe06b75584fc35f90ebe06a31b4ee3882cdf2553628368f908912173f
-  data.tar.gz: 6caeb0cefd049620051a44ffbe0d398e6e43a466bbd7c6cc5edb499652cb5c242c769afb91e560b310700059764ec4ecf64a1bc109ed7654af4ecc568c379e88
+  metadata.gz: f80a81b27f8c00611a730ef329b4c4afc01e572419ee03d1c7621295e2670a1e829d41511ee4a82af5874d43d32f7b51280281c26310ee8f1e79e767e987c542
+  data.tar.gz: 14f36f225ac641ca74dac4eca580ffad8e6ffea7d69bed1c685d387db0ff6d3977c6ad8b148b8a8117914bd7752914423d2691aa899b0ec902fde5c25f4e931a

data/bin/cosmos

@@ -99,7 +99,7 @@ def generate(args)
       end
       base_name.sub!("target.rb", target_lib_filename)
       base_name.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
-      output = ERB.new(File.read(file)).result(b)
+      output = ERB.new(File.read(file), trim_mode: "-").result(b)
       File.open(base_name, 'w') do |file|
         file.write output
       end

data/lib/cosmos/api/api.rb

@@ -28,36 +28,12 @@ require 'cosmos/api/settings_api'
 require 'cosmos/api/target_api'
 require 'cosmos/api/tlm_api'
 require 'cosmos/utilities/authorization'
+require 'cosmos/topics/topic'
 
 module Cosmos
   module Api
     include Extract
     include Authorization
     include ApiShared
-
-    # PRIVATE - Shared by cmd_api and tlm_api
-
-    def _get_cnt(topic)
-      _, packet = Store.instance.read_topic_last(topic)
-      packet ? packet["received_count"].to_i : 0
-    end
-
-    def get_all_cmd_tlm_info(type, scope:, token:)
-      authorize(permission: 'system', scope: scope, token: token)
-      result = []
-      keys = []
-      count = 0
-      loop do
-        count, part = Store.scan(0, :match => "#{scope}__#{type}__*", :count => 1000)
-        keys.concat(part)
-        break if count.to_i == 0
-      end
-      keys.each do |key|
-        _, _, target, packet = key.gsub(/{|}/, '').split('__') # split off scope and type
-        result << [target, packet, _get_cnt(key)]
-      end
-      # Return the results sorted by target, packet
-      result.sort_by { |a| [a[0], a[1]] }
-    end
   end
 end

data/lib/cosmos/api/cmd_api.rb

@@ -195,7 +195,7 @@ module Cosmos
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
-      msg_id, msg_hash = Store.instance.read_topic_last(topic)
+      msg_id, msg_hash = Topic.get_newest_message(topic)
       if msg_id
         msg_hash['buffer'] = msg_hash['buffer'].b
         return msg_hash
@@ -302,7 +302,7 @@ module Cosmos
     # @return [Varies] value
     def get_cmd_value(target_name, command_name, parameter_name, value_type = :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
-      Store.instance.get_cmd_item(target_name, command_name, parameter_name, type: value_type, scope: scope)
+      CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: value_type, scope: scope)
     end
 
     # Returns the time the most recent command was sent
@@ -315,7 +315,7 @@ module Cosmos
     def get_cmd_time(target_name = nil, command_name = nil, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       if target_name and command_name
-        time = Store.instance.get_cmd_item(target_name, command_name, 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
+        time = CommandDecomTopic.get_cmd_item(target_name, command_name, 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
         [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
       else
         if target_name.nil?
@@ -327,7 +327,7 @@ module Cosmos
           time = 0
           command_name = nil
           TargetModel.packets(target_name, type: :CMD, scope: scope).each do |packet|
-            cur_time = Store.instance.get_cmd_item(target_name, packet["packet_name"], 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
+            cur_time = CommandDecomTopic.get_cmd_item(target_name, packet["packet_name"], 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
             next unless cur_time
 
             if cur_time > time
@@ -349,7 +349,7 @@ module Cosmos
     def get_cmd_cnt(target_name, command_name, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
-      _get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
+      Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
     end
 
     # Get information on all command packets
@@ -362,7 +362,7 @@ module Cosmos
         TargetModel.packets(target_name, type: :CMD, scope: scope).each do | packet |
           command_name = packet['packet_name']
           key = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
-          result << [target_name, command_name, _get_cnt(key)]
+          result << [target_name, command_name, Topic.get_cnt(key)]
         end
       end
       # Return the results sorted by target, packet

data/lib/cosmos/api/config_api.rb

@@ -17,6 +17,8 @@
 # enterprise edition license of COSMOS if purchased from the
 # copyright holder
 
+require 'cosmos/models/tool_config_model'
+
 module Cosmos
   module Api
     WHITELIST ||= []
@@ -34,19 +36,23 @@ module Cosmos
     end
 
     def list_configs(tool, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hkeys("#{scope}__config__#{tool}")
+      authorize(permission: 'system', scope: scope, token: token)
+      ToolConfigModel.list_configs(tool, scope: scope)
     end
 
     def load_config(tool, name, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hget("#{scope}__config__#{tool}", name)
+      authorize(permission: 'system', scope: scope, token: token)
+      ToolConfigModel.load_config(tool, name, scope: scope)
     end
 
     def save_config(tool, name, data, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hset("#{scope}__config__#{tool}", name, data)
+      authorize(permission: 'system_set', scope: scope, token: token)
+      ToolConfigModel.save_config(tool, name, data, scope: scope)
     end
 
     def delete_config(tool, name, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hdel("#{scope}__config__#{tool}", name)
+      authorize(permission: 'system_set', scope: scope, token: token)
+      ToolConfigModel.delete_config(tool, name, scope: scope)
     end
   end
 end

data/lib/cosmos/api/limits_api.rb

@@ -64,7 +64,7 @@ module Cosmos
       targets.each do |target_name|
         get_all_telemetry(target_name, scope: scope).each do |packet|
           topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}"
-          _, msg_hash = Store.get_newest_message(topic)
+          _, msg_hash = Topic.get_newest_message(topic)
           unless msg_hash && msg_hash['time'].to_i > stale_time
             next if with_limits_only && packet['items'].find { |item| item['limits'] }.nil?
 

data/lib/cosmos/api/settings_api.rb

@@ -19,8 +19,6 @@
 
 module Cosmos
   module Api
-    SETTINGS_KEY = "cosmos__settings"
-
     WHITELIST ||= []
     WHITELIST.concat([
                        'list_settings',
@@ -31,28 +29,42 @@ module Cosmos
                      ])
 
     def list_settings(scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hkeys(SETTINGS_KEY)
+      authorize(permission: 'system', scope: scope, token: token)
+      SettingsModel.names(scope: scope)
     end
 
     def get_all_settings(scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hgetall(SETTINGS_KEY)
+      authorize(permission: 'system', scope: scope, token: token)
+      SettingsModel.all(scope: scope)
     end
 
     def get_setting(name, scope: $cosmos_scope, token: $cosmos_token)
-      Store.instance.hget(SETTINGS_KEY, name)
+      authorize(permission: 'system', scope: scope, token: token)
+      setting = SettingsModel.get(name: name, scope: scope)
+      if setting
+        return setting["data"]
+      else
+        return nil
+      end
     end
 
     def get_settings(*args, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', scope: scope, token: token)
       ret = []
       args.each do |name|
-        ret << Store.instance.hget(SETTINGS_KEY, name)
+        setting = SettingsModel.get(name: name, scope: scope)
+        if setting
+          ret << setting["data"]
+        else
+          ret << nil
+        end
       end
       return ret
     end
 
     def save_setting(name, data, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'admin', scope: scope, token: token)
-      Store.instance.hset(SETTINGS_KEY, name, data)
+      SettingsModel.set({ name: name,  data: data }, scope: scope)
     end
   end
 end

data/lib/cosmos/api/target_api.rb

@@ -56,12 +56,12 @@ module Cosmos
         cmd_cnt = 0
         packets = TargetModel.packets(target_name, type: :CMD, scope: scope)
         packets.each do |packet|
-          cmd_cnt += _get_cnt("#{scope}__COMMAND__{#{target_name}}__#{packet['packet_name']}")
+          cmd_cnt += Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{packet['packet_name']}")
         end
         tlm_cnt = 0
         packets = TargetModel.packets(target_name, type: :TLM, scope: scope)
         packets.each do |packet|
-          tlm_cnt += _get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
+          tlm_cnt += Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
         end
         interface_name = ''
         InterfaceModel.all(scope: scope).each do |name, interface|

data/lib/cosmos/api/tlm_api.rb

@@ -190,7 +190,7 @@ module Cosmos
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
       topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-      msg_id, msg_hash = Store.instance.read_topic_last(topic)
+      msg_id, msg_hash = Topic.get_newest_message(topic)
       if msg_id
         msg_hash['buffer'] = msg_hash['buffer'].b
         return msg_hash
@@ -300,7 +300,7 @@ module Cosmos
       packets.each do |target_name, packet_name|
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
         topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
-        id, _ = Store.read_topic_last(topic)
+        id, _ = Topic.get_newest_message(topic)
         result[topic] = id ? id : '0-0'
       end
       result.to_a.join(SUBSCRIPTION_DELIMITER)
@@ -317,13 +317,13 @@ module Cosmos
       authorize(permission: 'tlm', scope: scope, token: token)
       # Split the list of topic, ID values and turn it into a hash for easy updates
       lookup = Hash[*id.split(SUBSCRIPTION_DELIMITER)]
-      xread = Store.xread(lookup.keys, lookup.values, block: block, count: count)
+      xread = Topic.read_topics(lookup.keys, lookup.values, block, count)
       # Return the original ID and nil if we didn't get anything
       return [id, nil] if xread.empty?
       packets = []
       xread.each do |topic, data|
         data.each do |id, msg_hash|
-          lookup[topic] = id # Store the new ID
+          lookup[topic] = id # save the new ID
           json_hash = JSON.parse(msg_hash['json_data'])
           msg_hash.delete('json_data')
           packets << msg_hash.merge(json_hash)
@@ -340,7 +340,7 @@ module Cosmos
     def get_tlm_cnt(target_name, packet_name, scope: $cosmos_scope, token: $cosmos_token)
       authorize(permission: 'system', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
-      _get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
+      Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
     end
 
     # Get information on all telemetry packets
@@ -353,12 +353,12 @@ module Cosmos
         TargetModel.packets(target_name, scope: scope).each do | packet |
           packet_name = packet['packet_name']
           key = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
-          result << [target_name, packet_name, _get_cnt(key)]
+          result << [target_name, packet_name, Topic.get_cnt(key)]
         end
       end
       ['UNKNOWN'].each do | x |
         key = "#{scope}__TELEMETRY__{#{x}}__#{x}"
-        result << [x, x, _get_cnt(key)]
+        result << [x, x, Topic.get_cnt(key)]
       end
       # Return the result sorted by target, packet
       result.sort_by { |a| [a[0], a[1]] }
@@ -425,7 +425,7 @@ module Cosmos
         TargetModel.packets(target_name, scope: scope).each do |packet|
           item = packet['items'].find { |item| item['name'] == item_name }
           if item
-            _, msg_hash = Store.instance.get_oldest_message("#{scope}__DECOM__{#{target_name}}__#{packet['packet_name']}")
+            _, msg_hash = Topic.get_oldest_message("#{scope}__DECOM__{#{target_name}}__#{packet['packet_name']}")
             if msg_hash && msg_hash['time'] && msg_hash['time'].to_i > latest
               packet_name = packet['packet_name']
               latest = msg_hash['time'].to_i

data/lib/cosmos/config/config_parser.rb

@@ -168,7 +168,7 @@ module Cosmos
         path = File.join(File.dirname(@filename), template_name)
       end
       Cosmos.set_working_dir(File.dirname(path)) do
-        return ERB.new(File.read(path)).result(b)
+        return ERB.new(File.read(path), trim_mode: "-").result(b)
       end
     end
 
@@ -377,7 +377,7 @@ module Cosmos
         output = nil
         if run_erb
           Cosmos.set_working_dir(File.dirname(filename)) do
-            output = ERB.new(File.read(filename)).result(binding.set_variables(variables))
+            output = ERB.new(File.read(filename), trim_mode: "-").result(binding.set_variables(variables))
           end
         else
           output = File.read(filename)

data/lib/cosmos/config/meta_config_parser.rb

@@ -50,7 +50,7 @@ module Cosmos
 
       output = nil
       Cosmos.set_working_dir(File.dirname(path)) do
-        output = ERB.new(File.read(path)).result(binding)
+        output = ERB.new(File.read(path), trim_mode: "-").result(binding)
       end
       tf.write(output)
       tf.close

data/lib/cosmos/logs/log_writer.rb

@@ -19,7 +19,7 @@
 
 require 'thread'
 require 'cosmos/config/config_parser'
-require 'cosmos/utilities/store'
+require 'cosmos/topics/topic'
 require 'cosmos/utilities/s3'
 
 module Cosmos
@@ -211,7 +211,7 @@ module Cosmos
             S3Utilities.move_log_file_to_s3(@filename, s3_key)
             # Now that the file is in S3, trim the Redis stream up until the previous file.
             # This keeps one file worth of data in Redis as a safety buffer
-            Cosmos::Store.trim_topic(@redis_topic, @previous_file_redis_offset) if @redis_topic and @previous_file_redis_offset
+            Topic.trim_topic(@redis_topic, @previous_file_redis_offset) if @redis_topic and @previous_file_redis_offset
             @previous_file_redis_offset = @last_offset
           rescue Exception => err
             Logger.instance.error "Error closing #{@filename} : #{err.formatted}"

data/lib/cosmos/microservices/decom_microservice.rb

@@ -31,7 +31,7 @@ module Cosmos
 
     def initialize(*args)
       super(*args)
-      Store.update_topic_offsets(@topics)
+      Topic.update_topic_offsets(@topics)
       System.telemetry.limits_change_callback = method(:limits_change_callback)
     end
 

data/lib/cosmos/microservices/interface_microservice.rb

@@ -143,7 +143,6 @@ module Cosmos
             hazardous, hazardous_description = System.commands.cmd_pkt_hazardous?(command)
             # Return back the error, description, and the formatted command
             # This allows the error handler to simply re-send the command
-            # TODO: Should we set target_name, cmd_name, and cmd_params instead?
             next "HazardousError\n#{hazardous_description}\n#{System.commands.format(command)}" if hazardous
           end
 

data/lib/cosmos/microservices/microservice.rb

@@ -40,7 +40,7 @@ module Cosmos
     attr_accessor :scope
 
     def self.run
-      microservice = self.new(ARGV[0])
+      microservice = self.new(ENV['COSMOS_MICROSERVICE_NAME'])
       begin
         MicroserviceStatusModel.set(microservice.as_json, scope: microservice.scope)
         microservice.state = 'RUNNING'
@@ -52,7 +52,7 @@ module Cosmos
         else
           microservice.error = err
           microservice.state = 'DIED_ERROR'
-          Logger.fatal("Microservice #{ARGV[0]} dying from exception\n#{err.formatted}")
+          Logger.fatal("Microservice #{ENV['COSMOS_MICROSERVICE_NAME']} dying from exception\n#{err.formatted}")
         end
       ensure
         MicroserviceStatusModel.set(microservice.as_json, scope: microservice.scope)

data/lib/cosmos/microservices/reducer_microservice.rb

@@ -96,9 +96,8 @@ module Cosmos
         ReducerModel
           .all_files(type: :DECOM, target: @target_name, scope: @scope)
           .each do |file|
-            if process_file(file, 'minute', MINUTE_ENTRY_SECS, MINUTE_FILE_SECS)
-              ReducerModel.rm_file(file)
-            end
+            process_file(file, 'minute', MINUTE_ENTRY_SECS, MINUTE_FILE_SECS)
+            ReducerModel.rm_file(file)
           end
       end
     end
@@ -108,9 +107,8 @@ module Cosmos
         ReducerModel
           .all_files(type: :MINUTE, target: @target_name, scope: @scope)
           .each do |file|
-            if process_file(file, 'hour', HOUR_ENTRY_SECS, HOUR_FILE_SECS)
-              ReducerModel.rm_file(file)
-            end
+            process_file(file, 'hour', HOUR_ENTRY_SECS, HOUR_FILE_SECS)
+            ReducerModel.rm_file(file)
           end
       end
     end
@@ -120,9 +118,8 @@ module Cosmos
         ReducerModel
           .all_files(type: :HOUR, target: @target_name, scope: @scope)
           .each do |file|
-            if process_file(file, 'day', DAY_ENTRY_SECS, DAY_FILE_SECS)
-              ReducerModel.rm_file(file)
-            end
+            process_file(file, 'day', DAY_ENTRY_SECS, DAY_FILE_SECS)
+            ReducerModel.rm_file(file)
           end
       end
     end
@@ -250,7 +247,12 @@ module Cosmos
       )
       true
     rescue => e
-      Logger.error("Reducer Error #{e}\n#{e.backtrace}")
+      if file.local_path and File.exist?(file.local_path)
+        Logger.error("Reducer Error: #{filename}:#{File.size(file.local_path)} bytes: \n#{e.formatted}")
+      else
+        Logger.error("Reducer Error: #{filename}:(Not Retrieved): \n#{e.formatted}")
+      end
+      false
     end
 
     def reduce(type, data_keys, reduced)

data/lib/cosmos/models/cvt_model.rb

@@ -40,12 +40,12 @@ module Cosmos
 
     # Delete the current value table for a target
     def self.del(target_name:, packet_name:, scope:)
-      Store.hdel("#{scope}__tlm__#{target_name}", packet_name)
+      EphemeralStore.hdel("#{scope}__tlm__#{target_name}", packet_name)
     end
 
     # Set the current value table for a target, packet
     def self.set(hash, target_name:, packet_name:, scope:)
-      Store.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json))
+      EphemeralStore.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json))
     end
 
     # Set an item in the current value table
@@ -62,9 +62,9 @@ module Cosmos
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
-      hash = JSON.parse(Store.hget("#{scope}__tlm__#{target_name}", packet_name))
+      hash = JSON.parse(EphemeralStore.hget("#{scope}__tlm__#{target_name}", packet_name))
       hash[field] = value
-      Store.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json))
+      EphemeralStore.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json))
     end
 
     # Get an item from the current value table
@@ -86,7 +86,7 @@ module Cosmos
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
-      hash = JSON.parse(Store.hget("#{scope}__tlm__#{target_name}", packet_name))
+      hash = JSON.parse(EphemeralStore.hget("#{scope}__tlm__#{target_name}", packet_name))
       hash.values_at(*types).each do |result|
         return result if result
       end
@@ -106,7 +106,7 @@ module Cosmos
 
       lookups.each do |target_packet_key, target_name, packet_name, packet_values|
         unless packet_lookup[target_packet_key]
-          packet = Store.hget("#{scope}__tlm__#{target_name}", packet_name)
+          packet = EphemeralStore.hget("#{scope}__tlm__#{target_name}", packet_name)
           raise "Packet '#{target_name} #{packet_name}' does not exist" unless packet
           packet_lookup[target_packet_key] = JSON.parse(packet)
         end

data/lib/cosmos/models/gem_model.rb

@@ -73,7 +73,7 @@ module Cosmos
       return nil
     end
 
-    def self.install(name_or_path)
+    def self.install(name_or_path, scope:)
       temp_dir = Dir.mktmpdir
       begin
         if File.exist?(name_or_path)
@@ -81,7 +81,7 @@ module Cosmos
         else
           gem_file_path = get(temp_dir, name_or_path)
         end
-        rubygems_url = get_setting('rubygems_url')
+        rubygems_url = get_setting('rubygems_url', scope: scope)
         Gem.sources = [rubygems_url] if rubygems_url
         Gem.done_installing_hooks.clear
         Gem.install(gem_file_path, "> 0.pre", :build_args => ['--no-document'], :prerelease => true)

data/lib/cosmos/models/info_model.rb

@@ -24,7 +24,7 @@ module Cosmos
 
     # @return Hash information and statistics about the redis server
     def self.get()
-      return Store.info()
+      return [Store.info(), EphemeralStore.info]
     end
 
   end

data/lib/cosmos/models/interface_status_model.rb

@@ -23,7 +23,7 @@ module Cosmos
   # Stores the status about an interface. This class also implements logic
   # to handle status for a router since the functionality is identical
   # (only difference is the Redis key used).
-  class InterfaceStatusModel < Model
+  class InterfaceStatusModel < EphemeralModel
     INTERFACES_PRIMARY_KEY = 'cosmos_interface_status'
     ROUTERS_PRIMARY_KEY = 'cosmos_router_status'