openc3 5.17.0 → 5.18.0

data/lib/openc3/api/limits_api.rb

@@ -47,8 +47,8 @@ module OpenC3
     #   [[target name, packet name, item name, item limits state], ...]
     #
     # @return [Array<Array<String, String, String, String>>]
-    def get_out_of_limits(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_out_of_limits(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.out_of_limits(scope: scope)
     end
 
@@ -59,7 +59,7 @@ module OpenC3
     # @param ignored_items [Array<Array<String, String, String|nil>>] Array of [TGT, PKT, ITEM] strings
     #   to ignore when determining overall state. Note, ITEM can be nil to indicate to ignore entire packet.
     # @return [String] The overall limits state for the system, one of 'GREEN', 'YELLOW', 'RED'
-    def get_overall_limits_state(ignored_items = nil, scope: $openc3_scope, token: $openc3_token)
+    def get_overall_limits_state(ignored_items = nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       # We only need to check out of limits items so call get_out_of_limits() which authorizes
       out_of_limits = get_out_of_limits(scope: scope, token: token)
       overall = 'GREEN'
@@ -108,9 +108,9 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     # @return [Boolean] Whether limits are enable for the itme
-    def limits_enabled?(*args, scope: $openc3_scope, token: $openc3_token)
+    def limits_enabled?(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'limits_enabled?', scope: scope)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)['limits']['enabled'] ? true : false
     end
     alias limits_enabled limits_enabled?
@@ -124,9 +124,9 @@ module OpenC3
     # Favor the first syntax where possible as it is more succinct.
     #
     # @param args [String|Array<String>] See the description for calling style
-    def enable_limits(*args, scope: $openc3_scope, token: $openc3_token)
+    def enable_limits(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'enable_limits', scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
       packet['items'].each do |item|
@@ -157,9 +157,9 @@ module OpenC3
     # Favor the first syntax where possible as it is more succinct.
     #
     # @param args [String|Array<String>] See the description for calling style
-    def disable_limits(*args, scope: $openc3_scope, token: $openc3_token)
+    def disable_limits(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name = _tlm_process_args(args, 'disable_limits', scope: scope)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
       packet['items'].each do |item|
@@ -190,8 +190,8 @@ module OpenC3
     #               'TVAC' => [-25, -10, 50, 55] }
     #
     # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
-    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+    def get_limits(target_name, packet_name, item_name, cache_timeout: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       limits = {}
       item = _get_item(target_name, packet_name, item_name, cache_timeout: cache_timeout, scope: scope)
       item['limits'].each do |key, vals|
@@ -207,8 +207,8 @@ module OpenC3
     # is created to avoid overriding existing limits.
     def set_limits(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high,
                    green_low = nil, green_high = nil, limits_set = 'CUSTOM', persistence = nil, enabled = true,
-                   scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+                   manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       if (red_low > yellow_low) || (yellow_low >= yellow_high) || (yellow_high > red_high)
         raise "Invalid limits specified. Ensure yellow limits are within red limits."
       end
@@ -259,38 +259,38 @@ module OpenC3
     # Returns all limits_groups and their members
     # @since 5.0.0 Returns hash with values
     # @return [Hash{String => Array<Array<String, String, String>>]
-    def get_limits_groups(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_groups(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       TargetModel.limits_groups(scope: scope)
     end
 
     # Enables limits for all the items in the group
     #
     # @param group_name [String] Name of the group to enable
-    def enable_limits_group(group_name, scope: $openc3_scope, token: $openc3_token)
-      _limits_group(group_name, action: :enable, scope: scope, token: token)
+    def enable_limits_group(group_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _limits_group(group_name, action: :enable, manual: manual, scope: scope, token: token)
     end
 
     # Disables limits for all the items in the group
     #
     # @param group_name [String] Name of the group to disable
-    def disable_limits_group(group_name, scope: $openc3_scope, token: $openc3_token)
-      _limits_group(group_name, action: :disable, scope: scope, token: token)
+    def disable_limits_group(group_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _limits_group(group_name, action: :disable, manual: manual, scope: scope, token: token)
     end
 
     # Returns all defined limits sets
     #
     # @return [Array<String>] All defined limits sets
-    def get_limits_sets(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_sets(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.sets(scope: scope).keys
     end
 
     # Changes the active limits set that applies to all telemetry
     #
     # @param limits_set [String] The name of the limits set
-    def set_limits_set(limits_set, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm_set', scope: scope, token: token)
+    def set_limits_set(limits_set, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
       message = "Setting Limits Set: #{limits_set}"
       Logger.info(message, scope: scope)
       LimitsEventTopic.write({ type: :LIMITS_SET, set: limits_set.to_s,
@@ -300,8 +300,8 @@ module OpenC3
     # Returns the active limits set that applies to all telemetry
     #
     # @return [String] The current limits set
-    def get_limits_set(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_set(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.current_set(scope: scope)
     end
 
@@ -313,8 +313,8 @@ module OpenC3
     # @param count [Integer] The total number of events returned. Default is 100.
     # @return [Hash, Integer] Event hash followed by the offset. The offset can
     #   be used in subsequent calls to return events from where the last call left off.
-    def get_limits_events(offset = nil, count: 100, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_limits_events(offset = nil, count: 100, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'tlm', manual: manual, scope: scope, token: token)
       LimitsEventTopic.read(offset, count: count, scope: scope)
     end
 
@@ -323,8 +323,8 @@ module OpenC3
     ###########################################################################
 
     # Enables or disables a limits group
-    def _limits_group(group_name, action:, scope:, token:)
-      authorize(permission: 'tlm_set', scope: scope, token: token)
+    def _limits_group(group_name, action:, manual:, scope:, token:)
+      authorize(permission: 'tlm_set', manual: manual, scope: scope, token: token)
       group_name.upcase!
       group = get_limits_groups(scope: scope, token: token)[group_name]
       raise "LIMITS_GROUP #{group_name} undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP #{group_name}" unless group

data/lib/openc3/api/metrics_api.rb

@@ -66,15 +66,15 @@ module OpenC3
     SUM_METRICS['text_log_total'] = 0
     SUM_METRICS['text_log_error_total'] = 0
 
-    def get_metrics(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_metrics(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
 
       sum_metrics = SUM_METRICS.dup
       duration_metrics = DURATION_METRICS.dup
       delay_metrics = DELAY_METRICS.dup
 
       metrics = MetricModel.all(scope: scope)
-      metrics.each do |microservice_name, metrics|
+      metrics.each do |_microservice_name, metrics|
         next unless metrics and metrics['values']
         metrics['values'].each do |metric_name, data|
           value = data['value']

data/lib/openc3/api/offline_access_api.rb

@@ -27,10 +27,10 @@ module OpenC3
                        'set_offline_access'
                      ])
 
-    def offline_access_needed(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def offline_access_needed(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       begin
-        authorize(permission: 'script_run', scope: scope, token: token)
+        authorize(permission: 'script_view', manual: manual, scope: scope, token: token)
       rescue
         # Not needed if can't run scripts
         return false
@@ -60,8 +60,8 @@ module OpenC3
       end
     end
 
-    def set_offline_access(offline_access_token, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_run', scope: scope, token: token)
+    def set_offline_access(offline_access_token, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', manual: manual, scope: scope, token: token)
       info = user_info(token)
       username = info['username']
       raise "Invalid username" if not username or username == ''

data/lib/openc3/api/router_api.rb

@@ -43,8 +43,8 @@ module OpenC3
     #
     # @param router_name [String] Router name
     # @return [Hash] Hash of all the router information
-    def get_router(router_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', router_name: router_name, scope: scope, token: token)
+    def get_router(router_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', router_name: router_name, manual: manual, scope: scope, token: token)
       router = RouterModel.get(name: router_name, scope: scope)
       raise "Router '#{router_name}' does not exist" unless router
 
@@ -52,8 +52,8 @@ module OpenC3
     end
 
     # @return [Array<String>] All the router names
-    def get_router_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_router_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       RouterModel.names(scope: scope)
     end
 
@@ -61,24 +61,27 @@ module OpenC3
     #
     # @param router_name [String] Name of router
     # @param router_params [Array] Optional parameters to pass to the router
-    def connect_router(router_name, *router_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def connect_router(router_name, *router_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       RouterTopic.connect_router(router_name, *router_params, scope: scope)
     end
 
     # Disconnects a router and kills its command gathering thread
     #
     # @param router_name [String] Name of router
-    def disconnect_router(router_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def disconnect_router(router_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       RouterTopic.disconnect_router(router_name, scope: scope)
     end
 
     # Starts raw logging for a router
     #
     # @param router_name [String] The name of the router
-    def start_raw_logging_router(router_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def start_raw_logging_router(router_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       if router_name == 'ALL'
         get_router_names().each do |router_name|
           RouterTopic.start_raw_logging(router_name, scope: scope)
@@ -91,8 +94,9 @@ module OpenC3
     # Stop raw logging for a router
     #
     # @param router_name [String] The name of the router
-    def stop_raw_logging_router(router_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def stop_raw_logging_router(router_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       if router_name == 'ALL'
         get_router_names().each do |router_name|
           RouterTopic.stop_raw_logging(router_name, scope: scope)
@@ -108,10 +112,10 @@ module OpenC3
     #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
     #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
     #   Telemetry count] for all routers
-    def get_all_router_info(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_all_router_info(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       info = []
-      RouterStatusModel.all(scope: scope).each do |router_name, router|
+      RouterStatusModel.all(scope: scope).each do |_router_name, router|
         info << [router['name'], router['state'], router['clients'], router['txsize'], router['rxsize'],\
                  router['txbytes'], router['rxbytes'], router['rxcnt'], router['txcnt']]
       end
@@ -119,13 +123,15 @@ module OpenC3
       info
     end
 
-    def router_cmd(router_name, cmd_name, *cmd_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def router_cmd(router_name, cmd_name, *cmd_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       RouterTopic.router_cmd(router_name, cmd_name, *cmd_params, scope: scope)
     end
 
-    def router_protocol_cmd(router_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+    def router_protocol_cmd(router_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       RouterTopic.protocol_cmd(router_name, cmd_name, *cmd_params, read_write: read_write, index: index, scope: scope)
     end
   end

data/lib/openc3/api/settings_api.rb

@@ -34,18 +34,18 @@ module OpenC3
                        'save_setting' # DEPRECATED
                      ])
 
-    def list_settings(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def list_settings(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       SettingModel.names(scope: scope)
     end
 
-    def get_all_settings(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_all_settings(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       SettingModel.all(scope: scope)
     end
 
-    def get_setting(name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_setting(name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       setting = SettingModel.get(name: name, scope: scope)
       if setting
         setting['data']
@@ -54,15 +54,15 @@ module OpenC3
       end
     end
 
-    def get_settings(*settings, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_settings(*settings, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       result = []
       settings.each { |name| result << get_setting(name, scope: scope, token: token) }
       result
     end
 
-    def set_setting(name, data, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'admin', scope: scope, token: token)
+    def set_setting(name, data, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'admin', manual: manual, scope: scope, token: token)
       SettingModel.set({ name: name, data: data }, scope: scope)
       LocalMode.save_setting(scope, name, data)
     end

data/lib/openc3/api/stash_api.rb

@@ -29,13 +29,13 @@ module OpenC3
                        'stash_delete'
                      ])
 
-    def stash_set(key, value, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_run', scope: scope, token: token)
+    def stash_set(key, value, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_run', manual: manual, scope: scope, token: token)
       StashModel.set( {name: key, value: JSON.generate(value.as_json(:allow_nan => true)) }, scope: scope)
     end
 
-    def stash_get(key, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_view', scope: scope, token: token)
+    def stash_get(key, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', manual: manual, scope: scope, token: token)
       result = StashModel.get(name: key, scope: scope)
       if result
         JSON.parse(result['value'], :allow_nan => true, :create_additions => true)
@@ -44,18 +44,18 @@ module OpenC3
       end
     end
 
-    def stash_all(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_view', scope: scope, token: token)
+    def stash_all(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', manual: manual, scope: scope, token: token)
       StashModel.all(scope: scope).transform_values { |hash| JSON.parse(hash["value"], :allow_nan => true, :create_additions => true) }
     end
 
-    def stash_keys(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_view', scope: scope, token: token)
+    def stash_keys(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_view', manual: manual, scope: scope, token: token)
       StashModel.names(scope: scope)
     end
 
-    def stash_delete(key, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'script_run', scope: scope, token: token)
+    def stash_delete(key, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'script_run', manual: manual, scope: scope, token: token)
       model = StashModel.get_model(name: key, scope: scope)
       model.destroy if model
     end

data/lib/openc3/api/target_api.rb

@@ -36,8 +36,8 @@ module OpenC3
     # Returns the list of all target names
     #
     # @return [Array<String>] All target names
-    def get_target_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'tlm', scope: scope, token: token)
+    def get_target_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       TargetModel.names(scope: scope)
     end
     # get_target_list is DEPRECATED
@@ -48,21 +48,21 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Target name
     # @return [Hash] Hash of all the target properties
-    def get_target(target_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', target_name: target_name, scope: scope, token: token)
+    def get_target(target_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.get(name: target_name, scope: scope)
     end
 
     # Get all targets and their interfaces
     #
     # @return [Array<Array<String, String] Array of Arrays \[name, interfaces]
-    def get_target_interfaces(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_target_interfaces(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       info = []
       interfaces = InterfaceModel.all(scope: scope)
       get_target_names(scope: scope, token: token).each do |target_name|
         interface_names = []
-        interfaces.each do |name, interface|
+        interfaces.each do |_name, interface|
           if interface['target_names'].include? target_name
             interface_names << interface['name']
           end
@@ -76,8 +76,8 @@ module OpenC3
     # Warning this call can take a long time with many defined packets
     #
     # @return [Array<Array<String, String, Numeric, Numeric>] Array of Arrays \[name, interface, cmd_cnt, tlm_cnt]
-    def get_all_target_info(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_all_target_info(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       info = []
       get_target_names(scope: scope, token: token).each do |target_name|
         cmd_cnt = 0
@@ -91,7 +91,7 @@ module OpenC3
           tlm_cnt += Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
         end
         interface_names = []
-        InterfaceModel.all(scope: scope).each do |name, interface|
+        InterfaceModel.all(scope: scope).each do |_name, interface|
           if interface['target_names'].include? target_name
             interface_names << interface['name']
           end