openc3 5.9.0 → 5.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35a757bea46ad5b21ac348aa90b6163595d04c702b752b728f628d7dd82f6132
-  data.tar.gz: 149be2f48cdb7864a3665bf46982a1e16fb37541f68203387297c14d0d55e7d8
+  metadata.gz: 9c37c79f2062a5921e13c3370ce281c443b9abba929ca36f152df7cd1bcea92e
+  data.tar.gz: 643d74e05f61eb9016eaefbe5dca61316939e3d4e063fcf4150423cee4d95474
 SHA512:
-  metadata.gz: 1595ea101a9473b1aa5a1894d08bcd5704943fae771f9e58c4506b905cae9cb5957ab0fc961349ec9ecc4466a3ae34b6987a2a9d21ed8b9d2b0d31592c16908b
-  data.tar.gz: afbf06dfc4d4dbbfd7916146b6ee2b3005959bae650735127710b257a675487591adb5739744e603ef5eb20cc545b4dc79962021aaef00127c9aa76017a4ba3e
+  metadata.gz: 25285376d600c16a3d0b6d485a359998fda7226fc3781f639cdde992370291fa7d23b0ce6ca89e02ddcf4e6386dd596839ed4d8c704003b893e37e726ed1a7e4
+  data.tar.gz: 3ae81b7ea67047a8e23cfb161aeb77b4e7224e44b2c9c1dc4fa2dd78cb06eae50710b0a5c882cfcaf8da9e0214b6b96e517ec2a6af0b7671f5b8e8a0dc1448fe

data/lib/openc3/accessors/binary_accessor.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 # This file contains the implementation of the BinaryAccessor class.
@@ -280,7 +280,10 @@ module OpenC3
 
             if upper_bound > lower_bound
               # Combine bytes into a FixNum
-              temp_data[1..temp_upper].each_byte { |temp_value| temp = temp << 8; temp = temp + temp_value }
+              temp_data[1..temp_upper].each_byte do |temp_value|
+                temp = temp << 8
+                temp = temp + temp_value
+              end
             end
 
             # Shift off unwanted bits at end

data/lib/openc3/api/limits_api.rb

@@ -172,7 +172,7 @@ module OpenC3
 
       TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
 
-      message = "Disabling Limits For '#{target_name} #{packet_name} #{item_name}'"
+      message = "Disabling Limits for '#{target_name} #{packet_name} #{item_name}'"
       Logger.info(message, scope: scope)
 
       event = { type: :LIMITS_ENABLE_STATE, target_name: target_name, packet_name: packet_name,
@@ -344,11 +344,11 @@ module OpenC3
             if action == :enable
               enabled = true
               item['limits']['enabled'] = true
-              message = "Enabling Limits For '#{target_name} #{packet_name} #{item_name}'"
+              message = "Enabling Limits for '#{target_name} #{packet_name} #{item_name}'"
             elsif action == :disable
               enabled = false
               item['limits'].delete('enabled')
-              message = "Disabling Limits For '#{target_name} #{packet_name} #{item_name}'"
+              message = "Disabling Limits for '#{target_name} #{packet_name} #{item_name}'"
             end
             Logger.info(message, scope: scope)
 
@@ -373,26 +373,10 @@ module OpenC3
     # @param item_name [String] item name
     # @param scope [String] scope
     # @return Hash The requested item based on the packet name
-    def _get_item(target_name, packet_name, item_name, scope:)
-      requested_item = nil
-      if packet_name == 'LATEST'
-        latest = -1
-        TargetModel.packets(target_name, scope: scope).each do |packet|
-          item = packet['items'].find { |item| item['name'] == item_name }
-          if item
-            hash = CvtModel.get(target_name: target_name, packet_name: packet['packet_name'], scope: scope)
-            if hash['PACKET_TIMESECONDS'] && hash['PACKET_TIMESECONDS'] > latest
-              latest = hash['PACKET_TIMESECONDS']
-              requested_item = item
-            end
-          end
-        end
-        raise "Item '#{target_name} LATEST #{item_name}' does not exist" if latest == -1
-      else
-        # Determine if this item exists, it will raise appropriate errors if not
-        requested_item = TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
-      end
-      return requested_item
+    def _get_item(target_name, packet_name, item_name, cache_timeout: 0.1, scope:)
+      # Determine if this item exists, it will raise appropriate errors if not
+      packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: $openc3_scope) if packet_name == 'LATEST'
+      return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
     end
   end
 end

data/lib/openc3/api/target_api.rb

@@ -26,19 +26,22 @@ module OpenC3
   module Api
     WHITELIST ||= []
     WHITELIST.concat([
-                       'get_target_list',
-                       'get_target',
-                       'get_target_interfaces',
-                       'get_all_target_info', # DEPRECATED
-                     ])
+      'get_target_names',
+      'get_target_list', # DEPRECATED
+      'get_target',
+      'get_target_interfaces',
+      'get_all_target_info', # DEPRECATED
+    ])
 
     # Returns the list of all target names
     #
     # @return [Array<String>] All target names
-    def get_target_list(scope: $openc3_scope, token: $openc3_token)
+    def get_target_names(scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm', scope: scope, token: token)
       TargetModel.names(scope: scope)
     end
+    # get_target_list is DEPRECATED
+    alias get_target_list get_target_names
 
     # Gets the full target hash
     #
@@ -57,7 +60,7 @@ module OpenC3
       authorize(permission: 'system', scope: scope, token: token)
       info = []
       interfaces = InterfaceModel.all(scope: scope)
-      get_target_list(scope: scope, token: token).each do |target_name|
+      get_target_names(scope: scope, token: token).each do |target_name|
         interface_names = []
         interfaces.each do |name, interface|
           if interface['target_names'].include? target_name
@@ -76,7 +79,7 @@ module OpenC3
     def get_all_target_info(scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system', scope: scope, token: token)
       info = []
-      get_target_list(scope: scope, token: token).each do |target_name|
+      get_target_names(scope: scope, token: token).each do |target_name|
         cmd_cnt = 0
         packets = TargetModel.packets(target_name, type: :CMD, scope: scope)
         packets.each do |packet|

data/lib/openc3/api/tlm_api.rb

@@ -66,30 +66,30 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
     # @return [Object] The telemetry value formatted as requested
-    def tlm(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name = tlm_process_args(args, 'tlm', scope: scope)
+    def tlm(*args, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+      target_name, packet_name, item_name = tlm_process_args(args, 'tlm', cache_timeout: cache_timeout, scope: scope)
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
-      CvtModel.get_item(target_name, packet_name, item_name, type: type.intern, scope: scope)
+      CvtModel.get_item(target_name, packet_name, item_name, type: type.intern, cache_timeout: cache_timeout, scope: scope)
     end
 
     # @deprecated Use tlm with type: :RAW
-    def tlm_raw(*args, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :RAW, scope: scope, token: token)
+    def tlm_raw(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :RAW, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type: :FORMATTED
-    def tlm_formatted(*args, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :FORMATTED, scope: scope, token: token)
+    def tlm_formatted(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :FORMATTED, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type: :WITH_UNITS
-    def tlm_with_units(*args, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args, type: :WITH_UNITS, scope: scope, token: token)
+    def tlm_with_units(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args, type: :WITH_UNITS, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # @deprecated Use tlm with type:
-    def tlm_variable(*args, scope: $openc3_scope, token: $openc3_token)
-      tlm(*args[0..-2], type: args[-1].intern, scope: scope, token: token)
+    def tlm_variable(*args, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
+      tlm(*args[0..-2], type: args[-1].intern, cache_timeout: cache_timeout, scope: scope, token: token)
     end
 
     # Set a telemetry item in the current value table.
@@ -227,7 +227,7 @@ module OpenC3
     # @return [Array<String, Object, Symbol|nil>] Returns an Array consisting
     #   of [item name, item value, item limits state] where the item limits
     #   state can be one of {OpenC3::Limits::LIMITS_STATES}
-    def get_tlm_packet(target_name, packet_name, stale_time: 30, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_packet(target_name, packet_name, stale_time: 30, type: :CONVERTED, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       packet_name = packet_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
@@ -235,8 +235,8 @@ module OpenC3
       t = _validate_tlm_type(type)
       raise ArgumentError, "Unknown type '#{type}' for #{target_name} #{packet_name}" if t.nil?
       items = packet['items'].map { | item | item['name'].upcase }
-      cvt_items = items.map { | item | "#{target_name}__#{packet_name}__#{item}__#{type}" }
-      current_values = CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, scope: scope)
+      cvt_items = items.map { | item | [target_name, packet_name, item, type] }
+      current_values = CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, cache_timeout: cache_timeout, scope: scope)
       items.zip(current_values).map { | item , values | [item, values[0], values[1]]}
     end
 
@@ -250,25 +250,26 @@ module OpenC3
     # @return [Array<Object, Symbol>]
     #   Array consisting of the item value and limits state
     #   given as symbols such as :RED, :YELLOW, :STALE
-    def get_tlm_values(items, stale_time: 30, scope: $openc3_scope, token: $openc3_token)
+    def get_tlm_values(items, stale_time: 30, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
+      packets = []
+      cvt_items = []
       items.each_with_index do |item, index|
-        target_name, packet_name, item_name, value_type = item.split('__')
+        item_upcase = item.to_s.upcase
+        target_name, packet_name, item_name, value_type = item_upcase.split('__')
         raise ArgumentError, "items must be formatted as TGT__PKT__ITEM__TYPE" if target_name.nil? || packet_name.nil? || item_name.nil? || value_type.nil?
-        target_name = target_name.upcase
-        packet_name = packet_name.upcase
-        item_name = item_name.upcase
-        value_type = value_type.upcase
-        if packet_name == 'LATEST'
-          _, packet_name, _ = tlm_process_args([target_name, packet_name, item_name], 'get_tlm_values', scope: scope) # Figure out which packet is LATEST
-        end
+        packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: scope) if packet_name == 'LATEST'
         # Change packet_name in case of LATEST and ensure upcase
-        items[index] = "#{target_name}__#{packet_name}__#{item_name}__#{value_type}"
+        cvt_items[index] = [target_name, packet_name, item_name, value_type]
+        packets << [target_name, packet_name]
+      end
+      packets.uniq!
+      packets.each do |target_name, packet_name|
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       end
-      CvtModel.get_tlm_values(items, stale_time: stale_time, scope: scope)
+      CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, cache_timeout: cache_timeout, scope: scope)
     end
 
     # Returns an array of all the telemetry packet hashes
@@ -429,7 +430,7 @@ module OpenC3
       return nil
     end
 
-    def tlm_process_args(args, method_name, scope: $openc3_scope, token: $openc3_token)
+    def tlm_process_args(args, method_name, cache_timeout: 0.1, scope: $openc3_scope, token: $openc3_token)
       case args.length
       when 1
         target_name, packet_name, item_name = extract_fields_from_tlm_text(args[0])
@@ -444,19 +445,9 @@ module OpenC3
       target_name = target_name.upcase
       packet_name = packet_name.upcase
       item_name = item_name.upcase
+
       if packet_name == 'LATEST'
-        latest = -1
-        TargetModel.packets(target_name, scope: scope).each do |packet|
-          item = packet['items'].find { |item| item['name'] == item_name }
-          if item
-            hash = CvtModel.get(target_name: target_name, packet_name: packet['packet_name'], scope: scope)
-            if hash['PACKET_TIMESECONDS'] && hash['PACKET_TIMESECONDS'] > latest
-              latest = hash['PACKET_TIMESECONDS']
-              packet_name = packet['packet_name']
-            end
-          end
-        end
-        raise "Item '#{target_name} LATEST #{item_name}' does not exist" if latest == -1
+        packet_name = CvtModel.determine_latest_packet_for_item(target_name, item_name, cache_timeout: cache_timeout, scope: scope)
       else
         # Determine if this item exists, it will raise appropriate errors if not
         TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)

data/lib/openc3/microservices/decom_microservice.rb

@@ -115,7 +115,11 @@ module OpenC3
     def limits_change_callback(packet, item, old_limits_state, value, log_change)
       return if @cancel_thread
       packet_time = packet.packet_time
-      message = "#{packet.target_name} #{packet.packet_name} #{item.name} = #{value} is #{item.limits.state}"
+      if value
+        message = "#{packet.target_name} #{packet.packet_name} #{item.name} = #{value} is #{item.limits.state}"
+      else
+        message = "#{packet.target_name} #{packet.packet_name} #{item.name} is disabled"
+      end
       message << " (#{packet.packet_time.sys.formatted})" if packet_time
 
       time_nsec = packet_time ? packet_time.to_nsec_from_epoch : Time.now.to_nsec_from_epoch

data/lib/openc3/models/auth_model.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'digest'
@@ -28,6 +28,12 @@ module OpenC3
     PRIMARY_KEY = 'OPENC3__TOKEN'
     SERVICE_KEY = 'OPENC3__SERVICE__TOKEN'
 
+    TOKEN_CACHE_TIMEOUT = 5
+    @@token_cache = nil
+    @@token_cache_time = nil
+    @@service_token_cache = nil
+    @@service_token_cache_time = nil
+
     def self.is_set?(key = PRIMARY_KEY)
       Store.exists(key) == 1
     end
@@ -36,15 +42,21 @@ module OpenC3
       return false if token.nil? or token.empty?
 
       token_hash = hash(token)
-      return true if Store.get(PRIMARY_KEY) == token_hash
+      return true if @@token_cache and (Time.now - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+      return true if @@service_token_cache and (Time.now - @@service_token_cache_time) < TOKEN_CACHE_TIMEOUT and @@service_token_cache == token_hash and permission != 'admin'
+
+      @@token_cache = Store.get(PRIMARY_KEY)
+      @@token_cache_time = Time.now
+      return true if @@token_cache == token_hash
 
-      service_hash = Store.get(SERVICE_KEY)
-      if ENV['OPENC3_SERVICE_PASSWORD'] and hash(ENV['OPENC3_SERVICE_PASSWORD']) != service_hash
+      @@service_token_cache = Store.get(SERVICE_KEY)
+      @@service_token_cache_time = @@token_cache_time
+      if ENV['OPENC3_SERVICE_PASSWORD'] and hash(ENV['OPENC3_SERVICE_PASSWORD']) != @@service_token_cache
         set_hash = hash(ENV['OPENC3_SERVICE_PASSWORD'])
         OpenC3::Store.set(SERVICE_KEY, set_hash)
-        service_hash = set_hash
+        @@service_token_cache = set_hash
       end
-      return true if service_hash == token_hash and permission != 'admin'
+      return true if @@service_token_cache == token_hash and permission != 'admin'
       return false
     end
 

data/lib/openc3/models/cvt_model.rb

@@ -25,6 +25,9 @@ require 'openc3/models/target_model'
 
 module OpenC3
   class CvtModel
+    @@packet_cache = {}
+    @@override_cache = {}
+
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
     def self.build_json_from_packet(packet)
       packet.decom
@@ -32,24 +35,39 @@ module OpenC3
 
     # Delete the current value table for a target
     def self.del(target_name:, packet_name:, scope: $openc3_scope)
-      Store.hdel("#{scope}__tlm__#{target_name}", packet_name)
+      key = "#{scope}__tlm__#{target_name}"
+      tgt_pkt_key = key + "__#{packet_name}"
+      @@packet_cache[tgt_pkt_key] = nil
+      Store.hdel(key, packet_name)
     end
 
     # Set the current value table for a target, packet
     def self.set(hash, target_name:, packet_name:, scope: $openc3_scope)
-      Store.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
+      packet_json = JSON.generate(hash.as_json(:allow_nan => true))
+      key = "#{scope}__tlm__#{target_name}"
+      tgt_pkt_key = key + "__#{packet_name}"
+      @@packet_cache[tgt_pkt_key] = [Time.now, hash]
+      Store.hset(key, packet_name, packet_json)
     end
 
     # Get the hash for packet in the CVT
-    def self.get(target_name:, packet_name:, scope: $openc3_scope)
-      packet = Store.hget("#{scope}__tlm__#{target_name}", packet_name)
+    # Note: Does not apply overrides
+    def self.get(target_name:, packet_name:, cache_timeout: 0.1, scope: $openc3_scope)
+      key = "#{scope}__tlm__#{target_name}"
+      tgt_pkt_key = key + "__#{packet_name}"
+      cache_time, hash = @@packet_cache[tgt_pkt_key]
+      now = Time.now
+      return hash if hash and (now - cache_time) < cache_timeout
+      packet = Store.hget(key, packet_name)
       raise "Packet '#{target_name} #{packet_name}' does not exist" unless packet
-      JSON.parse(packet, :allow_nan => true, :create_additions => true)
+      hash = JSON.parse(packet, :allow_nan => true, :create_additions => true)
+      @@packet_cache[tgt_pkt_key] = [now, hash]
+      hash
     end
 
     # Set an item in the current value table
     def self.set_item(target_name, packet_name, item_name, value, type:, scope: $openc3_scope)
-      hash = get(target_name: target_name, packet_name: packet_name, scope: scope)
+      hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: 0.0, scope: scope)
       case type
       when :WITH_UNITS
         hash["#{item_name}__U"] = value.to_s # WITH_UNITS should always be a string
@@ -67,33 +85,13 @@ module OpenC3
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
-      Store.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
+      set(hash, target_name: target_name, packet_name: packet_name, scope: scope)
     end
 
     # Get an item from the current value table
-    def self.get_item(target_name, packet_name, item_name, type:, scope: $openc3_scope)
-      override_key = item_name
-      types = []
-      case type
-      when :WITH_UNITS
-        types = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
-        override_key = "#{item_name}__U"
-      when :FORMATTED
-        types = ["#{item_name}__F", "#{item_name}__C", item_name]
-        override_key = "#{item_name}__F"
-      when :CONVERTED
-        types = ["#{item_name}__C", item_name]
-        override_key = "#{item_name}__C"
-      when :RAW
-        types = [item_name]
-      else
-        raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
-      end
-      overrides = Store.hget("#{scope}__override__#{target_name}", packet_name)
-      if overrides
-        result = JSON.parse(overrides, :allow_nan => true, :create_additions => true)[override_key]
-        return result if result
-      end
+    def self.get_item(target_name, packet_name, item_name, type:, cache_timeout: 0.1, scope: $openc3_scope)
+      result, types = self._handle_item_override(target_name, packet_name, item_name, type: type, cache_timeout: cache_timeout, scope: scope)
+      return result if result
       hash = get(target_name: target_name, packet_name: packet_name, scope: scope)
       hash.values_at(*types).each do |result|
         if result
@@ -111,18 +109,19 @@ module OpenC3
     # @param items [Array<String>] Items to return. Must be formatted as TGT__PKT__ITEM__TYPE
     # @param stale_time [Integer] Time in seconds from Time.now that value will be marked stale
     # @return [Array] Array of values
-    def self.get_tlm_values(items, stale_time: 30, scope: $openc3_scope)
-      now = Time.now.sys.to_f
+    def self.get_tlm_values(items, stale_time: 30, cache_timeout: 0.1, scope: $openc3_scope)
+      now = Time.now
       results = []
       lookups = []
       packet_lookup = {}
       overrides = {}
       # First generate a lookup hash of all the items represented so we can query the CVT
-      items.each { |item| _parse_item(lookups, overrides, item, scope: scope) }
+      items.each { |item| _parse_item(now, lookups, overrides, item, cache_timeout: cache_timeout, scope: scope) }
 
+      now = now.to_f
       lookups.each do |target_packet_key, target_name, packet_name, value_keys|
         unless packet_lookup[target_packet_key]
-          packet_lookup[target_packet_key] = get(target_name: target_name, packet_name: packet_name, scope: scope)
+          packet_lookup[target_packet_key] = get(target_name: target_name, packet_name: packet_name, cache_timeout: cache_timeout, scope: scope)
         end
         hash = packet_lookup[target_packet_key]
         item_result = []
@@ -153,6 +152,7 @@ module OpenC3
     end
 
     # Return all the overrides
+    # Note: Does not use cache to benefit from hgetall
     def self.overrides(scope: $openc3_scope)
       overrides = []
       TargetModel.names(scope: scope).each do |target_name|
@@ -207,6 +207,9 @@ module OpenC3
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
+
+      tgt_pkt_key = "#{scope}__tlm__#{target_name}__#{packet_name}"
+      @@override_cache[tgt_pkt_key] = [Time.now, hash]
       Store.hset("#{scope}__override__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
     end
 
@@ -232,6 +235,9 @@ module OpenC3
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
+
+      tgt_pkt_key = "#{scope}__tlm__#{target_name}__#{packet_name}"
+      @@override_cache[tgt_pkt_key] = [Time.now, hash]
       if hash.empty?
         Store.hdel("#{scope}__override__#{target_name}", packet_name)
       else
@@ -239,16 +245,78 @@ module OpenC3
       end
     end
 
+    def self.determine_latest_packet_for_item(target_name, item_name, cache_timeout: 0.1, scope: $openc3_scope)
+      item_map = TargetModel.get_item_to_packet_map(target_name, scope: scope)
+      packet_names = item_map[item_name]
+      raise "Item '#{target_name} LATEST #{item_name}' does not exist for scope: #{scope}" unless packet_names
+
+      latest = -1
+      latest_packet_name = nil
+      packet_names.each do |packet_name|
+        hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: cache_timeout, scope: scope)
+        if hash['PACKET_TIMESECONDS'] && hash['PACKET_TIMESECONDS'] > latest
+          latest = hash['PACKET_TIMESECONDS']
+          latest_packet_name = packet_name
+        end
+      end
+      raise "Item '#{target_name} LATEST #{item_name}' does not exist for scope: #{scope}" if latest == -1
+      return latest_packet_name
+    end
+
     # PRIVATE METHODS
 
+    def self._handle_item_override(target_name, packet_name, item_name, type:, cache_timeout:, scope: $openc3_scope)
+      override_key = item_name
+      types = []
+      case type
+      when :WITH_UNITS
+        types = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
+        override_key = "#{item_name}__U"
+      when :FORMATTED
+        types = ["#{item_name}__F", "#{item_name}__C", item_name]
+        override_key = "#{item_name}__F"
+      when :CONVERTED
+        types = ["#{item_name}__C", item_name]
+        override_key = "#{item_name}__C"
+      when :RAW
+        types = [item_name]
+      else
+        raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
+      end
+
+      tgt_pkt_key = "#{scope}__tlm__#{target_name}__#{packet_name}"
+      overrides = _get_overrides(Time.now, tgt_pkt_key, {}, target_name, packet_name, cache_timeout: cache_timeout, scope: scope)
+      result = overrides[override_key]
+      return result, types if result
+      return nil, types
+    end
+
+    def self._get_overrides(now, tgt_pkt_key, overrides, target_name, packet_name, cache_timeout:, scope:)
+      cache_time, hash = @@override_cache[tgt_pkt_key]
+      if hash and (now - cache_time) < cache_timeout
+        overrides[tgt_pkt_key] = hash
+        return hash
+      end
+      override_data = Store.hget("#{scope}__override__#{target_name}", packet_name)
+      if override_data
+        hash = JSON.parse(override_data, :allow_nan => true, :create_additions => true)
+        overrides[tgt_pkt_key] = hash
+      else
+        hash = {}
+        overrides[tgt_pkt_key] = {}
+      end
+      @@override_cache[tgt_pkt_key] = [now, hash] # always update
+      return hash
+    end
+
     # parse item and update lookups with packet_name and target_name and keys
     # return an ordered array of hash with keys
-    def self._parse_item(lookups, overrides, item, scope:)
-      target_name, packet_name, item_name, value_type = item.split('__')
+    def self._parse_item(now, lookups, overrides, item, cache_timeout:, scope:)
+      target_name, packet_name, item_name, value_type = item
 
       # We build lookup keys by including all the less formatted types to gracefully degrade lookups
       # This allows the user to specify WITH_UNITS and if there is no conversions it will simply return the RAW value
-      case value_type
+      case value_type.to_s
       when 'RAW'
         keys = [item_name]
       when 'CONVERTED'
@@ -260,20 +328,15 @@ module OpenC3
       else
         raise "Unknown value type '#{value_type}'"
       end
-      tgt_pkt_key = "#{target_name}__#{packet_name}"
+
       # Check the overrides cache for this target / packet
-      unless overrides[tgt_pkt_key]
-        override_data = Store.hget("#{scope}__override__#{target_name}", packet_name)
-        if override_data
-          overrides[tgt_pkt_key] = JSON.parse(override_data, :allow_nan => true, :create_additions => true)
-        else
-          overrides[tgt_pkt_key] = {}
-        end
-      end
-      if overrides[tgt_pkt_key][keys[0]]
-        # Set the result as a Hash to distingish it from the key array and from an overridden Array value
-        keys = {'value' => overrides[tgt_pkt_key][keys[0]]}
-      end
+      tgt_pkt_key = "#{scope}__tlm__#{target_name}__#{packet_name}"
+      _get_overrides(now, tgt_pkt_key, overrides, target_name, packet_name, cache_timeout: cache_timeout, scope: scope) unless overrides[tgt_pkt_key]
+
+      # Set the result as a Hash to distinguish it from the key array and from an overridden Array value
+      value = overrides[tgt_pkt_key][keys[0]]
+      keys = {'value' => value} if value
+
       lookups << [tgt_pkt_key, target_name, packet_name, keys]
     end
   end

data/lib/openc3/models/interface_model.rb

@@ -389,6 +389,8 @@ module OpenC3
         status_model = RouterStatusModel.get_model(name: @name, scope: @scope)
       end
       status_model.destroy if status_model
+    rescue Exception => error
+      Logger.error("Error undeploying interface/router model #{@name} in scope #{@scope} due to #{error}")
     end
 
     def unmap_target(target_name, cmd_only: false, tlm_only: false)

data/lib/openc3/models/microservice_status_model.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/model'

data/lib/openc3/models/plugin_model.rb

@@ -297,6 +297,8 @@ module OpenC3
       microservices.each do |name, model_instance|
         model_instance.cleanup
       end
+    rescue Exception => error
+      Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to #{error}")
     end
 
     # Reinstall