openc3 5.11.3 → 5.13.0

data/lib/openc3/api/cmd_api.rb

@@ -39,12 +39,17 @@ module OpenC3
                        'cmd_raw_no_range_check',
                        'cmd_raw_no_hazardous_check',
                        'cmd_raw_no_checks',
-                       'build_command',
+                       'build_cmd',
+                       'build_command', # DEPRECATED
                        'send_raw',
-                       'get_all_commands',
-                       'get_all_command_names',
-                       'get_command',
-                       'get_parameter',
+                       'get_all_cmds',
+                       'get_all_commands', # DEPRECATED
+                       'get_all_cmd_names',
+                       'get_all_command_names', # DEPRECATED
+                       'get_cmd',
+                       'get_command', # DEPRECATED
+                       'get_param',
+                       'get_parameter', # DEPRECATED
                        'get_cmd_buffer',
                        'get_cmd_hazardous',
                        'get_cmd_value',
@@ -62,45 +67,45 @@ module OpenC3
     #
     # Favor the first syntax where possible as it is more succinct.
     def cmd(*args, **kwargs)
-      cmd_implementation('cmd', *args, range_check: true, hazardous_check: true, raw: false, **kwargs)
+      _cmd_implementation('cmd', *args, range_check: true, hazardous_check: true, raw: false, **kwargs)
     end
     def cmd_raw(*args, **kwargs)
-      cmd_implementation('cmd_raw', *args, range_check: true, hazardous_check: true, raw: true, **kwargs)
+      _cmd_implementation('cmd_raw', *args, range_check: true, hazardous_check: true, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any value range
     # checks on the parameters. Useful for testing to allow sending command
     # parameters outside the allowable range as defined in the configuration.
     def cmd_no_range_check(*args, **kwargs)
-      cmd_implementation('cmd_no_range_check', *args, range_check: false, hazardous_check: true, raw: false, **kwargs)
+      _cmd_implementation('cmd_no_range_check', *args, range_check: false, hazardous_check: true, raw: false, **kwargs)
     end
     def cmd_raw_no_range_check(*args, **kwargs)
-      cmd_implementation('cmd_raw_no_range_check', *args, range_check: false, hazardous_check: true, raw: true, **kwargs)
+      _cmd_implementation('cmd_raw_no_range_check', *args, range_check: false, hazardous_check: true, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any hazardous checks
     # both on the command itself and its parameters. Useful in scripts to
     # prevent popping up warnings to the user.
     def cmd_no_hazardous_check(*args, **kwargs)
-      cmd_implementation('cmd_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: false, **kwargs)
+      _cmd_implementation('cmd_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: false, **kwargs)
     end
     def cmd_raw_no_hazardous_check(*args, **kwargs)
-      cmd_implementation('cmd_raw_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: true, **kwargs)
+      _cmd_implementation('cmd_raw_no_hazardous_check', *args, range_check: true, hazardous_check: false, raw: true, **kwargs)
     end
 
     # Send a command packet to a target without performing any value range
     # checks or hazardous checks both on the command itself and its parameters.
     def cmd_no_checks(*args, **kwargs)
-      cmd_implementation('cmd_no_checks', *args, range_check: false, hazardous_check: false, raw: false, **kwargs)
+      _cmd_implementation('cmd_no_checks', *args, range_check: false, hazardous_check: false, raw: false, **kwargs)
     end
     def cmd_raw_no_checks(*args, **kwargs)
-      cmd_implementation('cmd_raw_no_checks', *args, range_check: false, hazardous_check: false, raw: true, **kwargs)
+      _cmd_implementation('cmd_raw_no_checks', *args, range_check: false, hazardous_check: false, raw: true, **kwargs)
     end
 
     # Build a command binary
     #
     # @since 5.8.0
-    def build_command(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -123,6 +128,8 @@ module OpenC3
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       DecomInterfaceTopic.build_cmd(target_name, cmd_name, cmd_params, range_check, raw, scope: scope)
     end
+    # build_command is DEPRECATED
+    alias build_command build_cmd
 
     # Send a raw binary string to the specified interface.
     #
@@ -140,9 +147,8 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Hash] command hash with last command buffer
-    def get_cmd_buffer(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd_buffer(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd_buffer', *args)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
@@ -159,35 +165,38 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all commands as a hash
-    def get_all_commands(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmds(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packets(target_name, type: :CMD, scope: scope)
     end
+    # get_all_commands is DEPRECATED
+    alias get_all_commands get_all_cmds
 
     # Returns an array of all the command packet names
     #
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all command packet names
-    def get_all_command_names(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmd_names(target_name, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet_names(target_name, type: :CMD, scope: scope)
     end
+    # get_all_command_names is DEPRECATED
+    alias get_all_command_names get_all_cmd_names
 
     # Returns a hash of the given command
     #
     # @since 5.0.0
-    # @param target_name [String] Name of the target
-    # @param command_name [String] Name of the packet
     # @return [Hash] Command as a hash
-    def get_command(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd', *args)
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
+    # get_command is DEPRECATED
+    alias get_command get_cmd
 
     # Returns a hash of the given command parameter
     #
@@ -196,13 +205,13 @@ module OpenC3
     # @param command_name [String] Name of the packet
     # @param parameter_name [String] Name of the parameter
     # @return [Hash] Command parameter as a hash
-    def get_parameter(target_name, command_name, parameter_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
-      parameter_name = parameter_name.upcase
+    def get_param(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name, parameter_name = _extract_target_command_parameter_names('get_param', *args)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet_item(target_name, command_name, parameter_name, type: :CMD, scope: scope)
     end
+    # get_parameter is DEPRECATED
+    alias get_parameter get_param
 
     # Returns whether the specified command is hazardous
     #
@@ -257,19 +266,35 @@ module OpenC3
     end
 
     # Returns a value from the specified command
-    #
-    # @param target_name [String] Target name of the command
-    # @param command_name [String] Packet name of the command
-    # @param parameter_name [String] Parameter name in the command
-    # @param value_type [Symbol] How the values should be converted. Must be
-    #   one of {Packet::VALUE_TYPES}
-    # @return [Varies] value
-    def get_cmd_value(target_name, command_name, parameter_name, value_type = :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
-      parameter_name = parameter_name.upcase
+    # Supports the following call syntax:
+    #   get_cmd_value("TGT PKT ITEM", type: :RAW)
+    #   get_cmd_value("TGT", "PKT", "ITEM", type: :RAW)
+    #   get_cmd_value("TGT", "PKT", "ITEM", :RAW) # DEPRECATED
+    def get_cmd_value(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+      target_name = nil
+      command_name = nil
+      parameter_name = nil
+      case args.length
+      when 1
+        target_name, command_name, parameter_name = args[0].upcase.split
+      when 3
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+      when 4
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+        type = args[3].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to get_cmd_value()"
+      end
+      if target_name.nil? or command_name.nil? or parameter_name.nil?
+        raise "ERROR: Target name, command name and parameter name required. Usage: get_cmd_value(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
+      end
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
-      CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: value_type, scope: scope)
+      CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: type, scope: scope)
     end
 
     # Returns the time the most recent command was sent
@@ -285,7 +310,7 @@ module OpenC3
         target_name = target_name.upcase
         command_name = command_name.upcase
         time = CommandDecomTopic.get_cmd_item(target_name, command_name, 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
-        [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
+        return [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
       else
         if target_name.nil?
           targets = TargetModel.names(scope: scope)
@@ -293,21 +318,22 @@ module OpenC3
           target_name = target_name.upcase
           targets = [target_name]
         end
-        targets.each do |target_name|
-          time = 0
-          command_name = nil
-          TargetModel.packets(target_name, type: :CMD, scope: scope).each do |packet|
-            cur_time = CommandDecomTopic.get_cmd_item(target_name, packet["packet_name"], 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
+        time = 0
+        command_name = nil
+        targets.each do |cur_target|
+          TargetModel.packets(cur_target, type: :CMD, scope: scope).each do |packet|
+            cur_time = CommandDecomTopic.get_cmd_item(cur_target, packet["packet_name"], 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
             next unless cur_time
 
             if cur_time > time
               time = cur_time
               command_name = packet["packet_name"]
+              target_name = cur_target
             end
           end
-          target_name = nil unless command_name
-          return [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
         end
+        target_name = nil unless command_name
+        return [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
       end
     end
 
@@ -316,9 +342,8 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnt(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
-      target_name = target_name.upcase
-      command_name = command_name.upcase
+    def get_cmd_cnt(*args, scope: $openc3_scope, token: $openc3_token)
+      target_name, command_name = _extract_target_command_names('get_cmd_cnt', *args)
       authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
@@ -330,6 +355,9 @@ module OpenC3
     # @return [Numeric] Transmit count for the command
     def get_cmd_cnts(target_commands, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system', scope: scope, token: token)
+      unless target_commands.is_a?(Array) and target_commands[0].is_a?(Array)
+        raise "get_cmd_cnts takes an array of arrays containing target, packet_name, e.g. [['INST', 'COLLECT'], ['INST', 'ABORT']]"
+      end
       counts = []
       target_commands.each do |target_name, command_name|
         target_name = target_name.upcase
@@ -343,7 +371,47 @@ module OpenC3
     # PRIVATE implementation details
     ###########################################################################
 
-    def cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil,
+    def _extract_target_command_names(method_name, *args)
+      target_name = nil
+      command_name = nil
+      case args.length
+      when 1
+        target_name, command_name = args[0].upcase.split
+      when 2
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or command_name.nil?
+        raise "ERROR: Target name and command name required. Usage: #{method_name}(\"TGT CMD\") or #{method_name}(\"TGT\", \"CMD\")"
+      end
+      return [target_name, command_name]
+    end
+
+    def _extract_target_command_parameter_names(method_name, *args)
+      target_name = nil
+      command_name = nil
+      parameter_name = nil
+      case args.length
+      when 1
+        target_name, command_name, parameter_name = args[0].upcase.split
+      when 3
+        target_name = args[0].upcase
+        command_name = args[1].upcase
+        parameter_name = args[2].upcase
+      else
+        # Invalid number of arguments
+        raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
+      end
+      if target_name.nil? or command_name.nil? or parameter_name.nil?
+        raise "ERROR: Target name, command name and parameter name required. Usage: #{method_name}(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
+      end
+      return [target_name, command_name, parameter_name]
+    end
+
+    def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil,
                            scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       unless [nil, true, false].include?(log_message)
@@ -399,17 +467,13 @@ module OpenC3
         end
       end
       if log_message
-        Logger.info(build_cmd_output_string(target_name, cmd_name, cmd_params, packet, raw), scope: scope)
+        Logger.info(_build_cmd_output_string(method_name, target_name, cmd_name, cmd_params, packet), scope: scope)
       end
       CommandTopic.send_command(command, timeout: timeout, scope: scope)
     end
 
-    def build_cmd_output_string(target_name, cmd_name, cmd_params, packet, raw)
-      if raw
-        output_string = 'cmd_raw("'
-      else
-        output_string = 'cmd("'
-      end
+    def _build_cmd_output_string(method_name, target_name, cmd_name, cmd_params, packet)
+      output_string = "#{method_name}(\""
       output_string << target_name + ' ' + cmd_name
       if cmd_params.nil? or cmd_params.empty?
         output_string << '")'

data/lib/openc3/api/config_api.rb

@@ -14,10 +14,10 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, 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/tool_config_model'
@@ -26,16 +26,16 @@ module OpenC3
   module Api
     WHITELIST ||= []
     WHITELIST.concat([
-                       'get_saved_config',
-                       'list_configs',
-                       'load_config',
-                       'save_config',
-                       'delete_config'
-                     ])
-
-    # Get a saved configuration zip file
-    def get_saved_config(configuration_name = nil, scope: $openc3_scope, token: $openc3_token)
-      raise "Not supported by OpenC3 5"
+      'config_tool_names',
+      'list_configs',
+      'load_config',
+      'save_config',
+      'delete_config'
+    ])
+
+    def config_tool_names(scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', scope: scope, token: token)
+      ToolConfigModel.config_tool_names(scope: scope)
     end
 
     def list_configs(tool, scope: $openc3_scope, token: $openc3_token)

data/lib/openc3/api/limits_api.rb

@@ -109,10 +109,11 @@ 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)
-      target_name, packet_name, item_name = tlm_process_args(args, 'limits_enabled?', scope: scope)
+      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)
       return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)['limits']['enabled'] ? true : false
     end
+    alias limits_enabled limits_enabled?
 
     # Enable limits checking for a telemetry item
     #
@@ -124,7 +125,7 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     def enable_limits(*args, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name = tlm_process_args(args, 'enable_limits', scope: scope)
+      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)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
@@ -157,7 +158,7 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     def disable_limits(*args, scope: $openc3_scope, token: $openc3_token)
-      target_name, packet_name, item_name = tlm_process_args(args, 'disable_limits', scope: scope)
+      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)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil

data/lib/openc3/api/settings_api.rb

@@ -30,7 +30,8 @@ module OpenC3
                        'get_all_settings',
                        'get_setting',
                        'get_settings',
-                       'save_setting'
+                       'set_setting',
+                       'save_setting' # DEPRECATED
                      ])
 
     def list_settings(scope: $openc3_scope, token: $openc3_token)
@@ -60,10 +61,12 @@ module OpenC3
       result
     end
 
-    def save_setting(name, data, scope: $openc3_scope, token: $openc3_token)
+    def set_setting(name, data, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'admin', scope: scope, token: token)
       SettingModel.set({ name: name, data: data }, scope: scope)
       LocalMode.save_setting(scope, name, data)
     end
+    # save_setting is DEPRECATED
+    alias save_setting set_setting
   end
 end