openc3 5.9.0 → 5.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35a757bea46ad5b21ac348aa90b6163595d04c702b752b728f628d7dd82f6132
-  data.tar.gz: 149be2f48cdb7864a3665bf46982a1e16fb37541f68203387297c14d0d55e7d8
+  metadata.gz: c24a28732bfd8c275b65639cd566b4823d78b70b43781bf14a82e114397e7677
+  data.tar.gz: a8567e57ec8008d505e7f6a30cd3462e435988a46729908fbc17775f2b92e976
 SHA512:
-  metadata.gz: 1595ea101a9473b1aa5a1894d08bcd5704943fae771f9e58c4506b905cae9cb5957ab0fc961349ec9ecc4466a3ae34b6987a2a9d21ed8b9d2b0d31592c16908b
-  data.tar.gz: afbf06dfc4d4dbbfd7916146b6ee2b3005959bae650735127710b257a675487591adb5739744e603ef5eb20cc545b4dc79962021aaef00127c9aa76017a4ba3e
+  metadata.gz: dc287a9895e3ae60c6332389d0b7926bb84aa04d7d65e51c936ba65f66640b179b0baefdcec232d7775a70f2e95d88557faf5e960663c4c28840428e7cb52904
+  data.tar.gz: 578c1f1fe45512344390492e9aa15d7af851bb81e608fbc874189dcc73bc998c472e62d449c114fb300fc58bb0d9cc269cc3dfbcbb31aaaf76c9003abd63c8e7

data/lib/openc3/api/limits_api.rb

@@ -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/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/target_model.rb

@@ -44,6 +44,8 @@ module OpenC3
   class TargetModel < Model
     PRIMARY_KEY = 'openc3_targets'
     VALID_TYPES = %i(CMD TLM)
+    ITEM_MAP_CACHE_TIMEOUT = 10.0
+    @@item_map_cache = {}
 
     attr_accessor :folder_name
     attr_accessor :requires
@@ -208,7 +210,7 @@ module OpenC3
     # @return [Array>Hash>] All packet hashes under the target_name
     def self.packets(target_name, type: :TLM, scope:)
       raise "Unknown type #{type} for #{target_name}" unless VALID_TYPES.include?(type)
-      raise "Target '#{target_name}' does not exist" unless get(name: target_name, scope: scope)
+      raise "Target '#{target_name}' does not exist for scope: #{scope}" unless get(name: target_name, scope: scope)
 
       result = []
       packets = Store.hgetall("#{scope}__openc3#{type.to_s.downcase}__#{target_name}")
@@ -268,6 +270,36 @@ module OpenC3
       end
     end
 
+    def self.get_item_to_packet_map(target_name, scope:)
+      cache_time, item_map = @@item_map_cache[target_name]
+      return item_map if item_map and (Time.now - cache_time) < ITEM_MAP_CACHE_TIMEOUT
+      item_map_key = "#{scope}__#{target_name}__item_to_packet_map"
+      target_name = target_name.upcase
+      json_data = Store.get(item_map_key)
+      if json_data
+        item_map = JSON.parse(json_data, :allow_nan => true, :create_additions => true)
+      else
+        item_map = build_item_to_packet_map(target_name, scope: scope)
+        Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
+      end
+      @@item_map_cache[target_name] = [Time.now, item_map]
+      return item_map
+    end
+
+    def self.build_item_to_packet_map(target_name, scope:)
+      item_map = {}
+      packets = packets(target_name, scope: scope)
+      packets.each do |packet|
+        items = packet['items']
+        items.each do |item|
+          item_name = item['name']
+          item_map[item_name] ||= []
+          item_map[item_name] << packet['packet_name']
+        end
+      end
+      return item_map
+    end
+
     # Called by the PluginModel to allow this class to validate it's top-level keyword: "TARGET"
     def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
       case keyword
@@ -601,6 +633,10 @@ module OpenC3
           model.destroy if model
         end
       end
+      # Delete item_map
+      item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
+      Store.del(item_map_key)
+      @@item_map_cache[@name] = nil
 
       ConfigTopic.write({ kind: 'deleted', type: 'target', name: @name, plugin: @plugin }, scope: @scope)
     end
@@ -731,6 +767,12 @@ module OpenC3
       end
       Store.hmset("#{@scope}__limits_sets", *sets)
 
+      # Create item_map
+      item_map_key = "#{@scope}__#{@name}__item_to_packet_map"
+      item_map = self.class.build_item_to_packet_map(@name, scope: @scope)
+      Store.set(item_map_key, JSON.generate(item_map, :allow_nan => true))
+      @@item_map_cache[@name] = [Time.now, item_map]
+
       return system
     end
 

data/lib/openc3/utilities/local_mode.rb

@@ -431,7 +431,7 @@ module OpenC3
             # Parse just to ensure we have valid JSON
             JSON.parse(data, :allow_nan => true, :create_additions => true)
             # Only save if the parse was successful
-            ToolConfigModel.save_config(parts[-2], File.basename(config), data, scope: scope, local_mode: false)
+            ToolConfigModel.save_config(parts[-2], File.basename(config, '.json'), data, scope: scope, local_mode: false)
           rescue JSON::ParserError => error
             puts "Unable to initialize tool config due to #{error.message}"
           end

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '5.9.0'
+OPENC3_VERSION = '5.9.1'
 module OpenC3
   module Version
     MAJOR = '5'
     MINOR = '9'
-    PATCH = '0'
+    PATCH = '1'
     OTHER = ''
-    BUILD = '7ad48e4189eb35c8a08051cc9856d0bd8be27f60'
+    BUILD = 'e60c6e1f7e80f87eae7bc623986940da5449d6ad'
   end
-  VERSION = '5.9.0'
-  GEM_VERSION = '5.9.0'
+  VERSION = '5.9.1'
+  GEM_VERSION = '5.9.1'
 end

data/templates/tool_angular/package.json

@@ -1,6 +1,6 @@
 {
   "name": "<%= tool_name %>",
-  "version": "5.9.0",
+  "version": "5.9.1",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",
@@ -22,7 +22,7 @@
     "@angular/platform-browser": "^16.1.3",
     "@angular/platform-browser-dynamic": "^16.1.3",
     "@angular/router": "^16.1.3",
-    "@openc3/tool-common": "5.9.0",
+    "@openc3/tool-common": "5.9.1",
     "rxjs": "~7.8.0",
     "single-spa": ">=5.9.5",
     "single-spa-angular": "^8.1.0",

data/templates/tool_react/package.json

@@ -45,7 +45,7 @@
     "@emotion/react": "^11.11.1",
     "@emotion/styled": "^11.11.0",
     "@mui/material": "^5.13.6",
-    "@openc3/tool-common": "5.9.0",
+    "@openc3/tool-common": "5.9.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "single-spa-react": "^5.1.1"