openc3 5.8.1 → 5.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6639b1c8a8f8b4902a85d6bdf1f23800aefd25b61b333c661c25236058e9595
-  data.tar.gz: e2b037827217d57a34a126189895afc3ff2c62e9758cc326f1cf24be08e1b791
+  metadata.gz: c24a28732bfd8c275b65639cd566b4823d78b70b43781bf14a82e114397e7677
+  data.tar.gz: a8567e57ec8008d505e7f6a30cd3462e435988a46729908fbc17775f2b92e976
 SHA512:
-  metadata.gz: 6d2b3412ed3db8cdee1772416419737fc895d54145f58c087168c8b8c17649ab155cc36c4563a6bb826852c02ae0f89ac0972f101e28db04fa2cdc9163799732
-  data.tar.gz: 39eacdb1118b721017fb84359426576ced5f08be342972a46429797b22e2f6ad46db4999171a03dc310dbb8c41e09d3bbbc8dc86145f807dfa50bfa0ffbacaf3
+  metadata.gz: dc287a9895e3ae60c6332389d0b7926bb84aa04d7d65e51c936ba65f66640b179b0baefdcec232d7775a70f2e95d88557faf5e960663c4c28840428e7cb52904
+  data.tar.gz: 578c1f1fe45512344390492e9aa15d7af851bb81e608fbc874189dcc73bc998c472e62d449c114fb300fc58bb0d9cc269cc3dfbcbb31aaaf76c9003abd63c8e7

data/ext/openc3/ext/crc/crc.c

@@ -410,7 +410,7 @@ static VALUE crc64_calculate(int argc, VALUE *argv, VALUE self)
 /*
  * Initialize methods for Crc
  */
-void Init_crc()
+void Init_crc(void)
 {
   id_ivar_seed = rb_intern("@seed");
   id_ivar_xor = rb_intern("@xor");

data/lib/openc3/api/cmd_api.rb

@@ -393,7 +393,7 @@ module OpenC3
         # Check if any of the parameters have DISABLE_MESSAGES
         cmd_params.each do |key, value|
           item = packet['items'].find { |item| item['name'] == key.to_s }
-          if item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
+          if item && item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
             log_message = false
           end
         end

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/microservices/decom_microservice.rb

@@ -124,14 +124,22 @@ module OpenC3
         when :BLUE, :GREEN, :GREEN_LOW, :GREEN_HIGH
           @logger.info message
         when :YELLOW, :YELLOW_LOW, :YELLOW_HIGH
+          notification = NotificationModel.new(
+            time: time_nsec,
+            severity: "caution",
+            url: "/tools/limitsmonitor",
+            title: "#{packet.target_name} #{packet.packet_name} #{item.name} #{item.limits.state}",
+            body: "#{item.name} is #{item.limits.state}"
+          )
+          NotificationsTopic.write_notification(notification.as_json(:allow_nan => true), scope: @scope)
           @logger.warn message
         when :RED, :RED_LOW, :RED_HIGH
           notification = NotificationModel.new(
             time: time_nsec,
             severity: "critical",
             url: "/tools/limitsmonitor",
-            title: "#{packet.target_name} #{packet.packet_name} #{item.name} out of limits",
-            body: "Item went into #{item.limits.state} limit status."
+            title: "#{packet.target_name} #{packet.packet_name} #{item.name} #{item.limits.state}",
+            body: "#{item.name} is #{item.limits.state}"
           )
           NotificationsTopic.write_notification(notification.as_json(:allow_nan => true), scope: @scope)
           @logger.error message