openc3 5.12.0 → 5.13.0

data/lib/openc3/interfaces/mqtt_stream_interface.rb

@@ -0,0 +1,78 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/interfaces/stream_interface'
+require 'openc3/streams/mqtt_stream'
+
+module OpenC3
+  class MqttStreamInterface < StreamInterface
+    # @param hostname [String] MQTT server to connect to
+    # @param port [Integer] MQTT port
+    # @param ssl [Boolean] Use SSL true/false
+    def initialize(hostname, port = 1883, ssl = false, write_topic = nil, read_topic = nil, protocol_type = nil, *protocol_args)
+      super(protocol_type, protocol_args)
+      @hostname = hostname
+      @port = Integer(port)
+      @ssl = ConfigParser.handle_true_false(ssl)
+      @write_topic = ConfigParser.handle_nil(write_topic)
+      @read_topic = ConfigParser.handle_nil(read_topic)
+      @username = nil
+      @password = nil
+      @cert = nil
+      @key = nil
+      @ca_file = nil
+    end
+
+    # Creates a new {SerialStream} using the parameters passed in the constructor
+    def connect
+      @stream = MqttStream.new(@hostname, @port, @ssl, @write_topic, @read_topic)
+      @stream.username = @username if @username
+      @stream.password = @password if @password
+      @stream.cert = @cert if @cert
+      @stream.key = @key if @key
+      @stream.ca_file = @ca_file if @ca_file
+      super()
+    end
+
+    # Supported Options
+    # USERNAME - Username for Mqtt Server
+    # PASSWORD - Password for Mqtt Server
+    # CERT - Public Key for Client Cert Auth
+    # KEY - Private Key for Client Cert Auth
+    # CA_FILE - Certificate Authority for Client Cert Auth
+    # (see Interface#set_option)
+    def set_option(option_name, option_values)
+      super(option_name, option_values)
+      case option_name.upcase
+      when 'USERNAME'
+        @username = option_values[0]
+      when 'PASSWORD'
+        @password = option_values[0]
+      when 'CERT'
+        @cert = option_values[0]
+      when 'KEY'
+        @key = option_values[0]
+      when 'CA_FILE'
+        # CA_FILE must be given as a file
+        @ca_file = Tempfile.new('ca_file')
+        @ca_file.write(option_values[0])
+        @ca_file.close
+      end
+    end
+  end
+end

data/lib/openc3/logs/packet_log_reader.rb

@@ -298,12 +298,12 @@ module OpenC3
       next_offset = 12
       received_time_nsec_since_epoch = time_nsec_since_epoch
       if includes_received_time
-        received_time_nsec_since_epoch = entry[next_offset..(next_offset + OPENC3_RECEIVED_TIME_FIXED_SIZE - 1)].unpack(OPENC3_RECEIVED_TIME_PACK_DIRECTIVE)
+        received_time_nsec_since_epoch = entry[next_offset..(next_offset + OPENC3_RECEIVED_TIME_FIXED_SIZE - 1)].unpack(OPENC3_RECEIVED_TIME_PACK_DIRECTIVE)[0]
         next_offset += OPENC3_RECEIVED_TIME_FIXED_SIZE
       end
       extra = nil
       if includes_extra
-        extra_length = entry[next_offset..(next_offset + OPENC3_EXTRA_LENGTH_FIXED_SIZE - 1)].unpack(OPENC3_EXTRA_LENGTH_PACK_DIRECTIVE)
+        extra_length = entry[next_offset..(next_offset + OPENC3_EXTRA_LENGTH_FIXED_SIZE - 1)].unpack(OPENC3_EXTRA_LENGTH_PACK_DIRECTIVE)[0]
         next_offset += OPENC3_EXTRA_LENGTH_FIXED_SIZE
         extra_encoded = entry[next_offset..(next_offset + extra_length - 1)]
         next_offset += extra_length

data/lib/openc3/logs/text_log_writer.rb

@@ -78,8 +78,9 @@ module OpenC3
       begin
         # Need to write the OFFSET_MARKER for each packet
         @last_offsets.each do |redis_topic, last_offset|
-          time = Time.now
-          data = { time: time.to_nsec_from_epoch, '@timestamp' => time.xmlschema(3), severity: 'INFO', "microservice_name" => Logger.microservice_name, "container_name" => @container_name, "last_offset" => last_offset, "redis_topic" => redis_topic, "type" => "offset" }
+          time = Time.now.utc
+          # timestamp iso8601 with 6 decimal places to match the python output format
+          data = { time: time.to_nsec_from_epoch, '@timestamp' => time.iso8601(6), level: 'INFO', "microservice_name" => Logger.microservice_name, "container_name" => @container_name, "last_offset" => last_offset, "redis_topic" => redis_topic, "type" => "offset" }
           write_entry(time.to_nsec_from_epoch, data.as_json(allow_nan: true).to_json(allow_nan: true)) if @file
         end
 

data/lib/openc3/microservices/trigger_group_microservice.rb

@@ -333,7 +333,8 @@ module OpenC3
       )
       return nil if packet.nil?
       _, limit = packet.read_with_limits_state(operand[ITEM_TYPE], operand[ITEM_VALUE_TYPE].intern)
-      return limit
+      # Convert limit symbol to string since we'll be comparing with strings
+      return limit.to_s
     end
 
     # extract the value outlined in the operand to get the packet item value

data/lib/openc3/models/plugin_model.rb

@@ -296,10 +296,15 @@ module OpenC3
 
     # Undeploy all models associated with this plugin
     def undeploy
+      errors = []
       microservice_count = 0
       microservices = MicroserviceModel.find_all_by_plugin(plugin: @name, scope: @scope)
       microservices.each do |name, model_instance|
-        model_instance.destroy
+        begin
+          model_instance.destroy
+        rescue Exception => error
+          errors << error
+        end
         microservice_count += 1
       end
       # Wait for the operator to wake up and remove the microservice processes
@@ -308,15 +313,44 @@ module OpenC3
       # Save TargetModel for last as it has the most to cleanup
       [InterfaceModel, RouterModel, ToolModel, WidgetModel, TargetModel].each do |model|
         model.find_all_by_plugin(plugin: @name, scope: @scope).each do |name, model_instance|
-          model_instance.destroy
+          begin
+            model_instance.destroy
+          rescue Exception => error
+            errors << error
+          end
         end
       end
       # Cleanup Redis stuff that might have been left by microservices
       microservices.each do |name, model_instance|
-        model_instance.cleanup
+        begin
+          model_instance.cleanup
+        rescue Exception => error
+          errors << error
+        end
+      end
+      # Raise all the errors at once
+      if errors.length > 0
+        message = ''
+        errors.each do |error|
+          message += "\n#{error.formatted}\n"
+        end
+        raise message
       end
     rescue Exception => error
-      Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to #{error}")
+      Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to: #{error}")
+    ensure
+      # Double check everything is gone
+      found = []
+      [MicroserviceModel, InterfaceModel, RouterModel, ToolModel, WidgetModel, TargetModel].each do |model|
+        model.find_all_by_plugin(plugin: @name, scope: @scope).each do |name, model_instance|
+          found << model_instance
+        end
+      end
+      if found.length > 0
+        # If undeploy failed we need to not move forward with anything else
+        Logger.error("Error undeploying plugin model #{@name} in scope #{@scope} due to: Plugin submodels still exist after undeploy = #{found.length}")
+        raise "Plugin #{@name} submodels still exist after undeploy = #{found.length}"
+      end
     end
 
     # Reinstall

data/lib/openc3/packets/json_packet.rb

@@ -65,66 +65,97 @@ module OpenC3
     # @param name [String] Name of the item to read - Should already by upcase
     # @param value_type (see #read_item)
     def read(name, value_type = :CONVERTED, reduced_type = nil)
+      value = nil
+      array_index = nil
+      if name[-1] == ']'
+        open_bracket_index = name.index('[')
+        if open_bracket_index
+          array_index = name[(open_bracket_index + 1)..-2].to_i
+          name = name[0..(open_bracket_index - 1)]
+        end
+      end
       if reduced_type
         raise "Reduced types only support RAW or CONVERTED value types: #{value_type} unsupported" if value_type == :WITH_UNITS or value_type == :FORMATTED
         if value_type == :CONVERTED
           case reduced_type
           when :AVG
             value = @json_hash["#{name}__CA"]
-            return value if value
           when :STDDEV
             value = @json_hash["#{name}__CS"]
-            return value if value
           when :MIN
             value = @json_hash["#{name}__CN"]
-            return value if value
           when :MAX
             value = @json_hash["#{name}__CX"]
-            return value if value
+          end
+          if value
+            value = value[array_index] if array_index
+            return value
           end
         end
         case reduced_type
         when :AVG
           value = @json_hash["#{name}__A"]
-          return value if value
         when :STDDEV
           value = @json_hash["#{name}__S"]
-          return value if value
         when :MIN
           value = @json_hash["#{name}__N"]
-          return value if value
         when :MAX
           value = @json_hash["#{name}__X"]
-          return value if value
+        end
+        if value
+          value = value[array_index] if array_index
+          return value
         end
       end
       if value_type == :WITH_UNITS
         value = @json_hash["#{name}__U"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
       end
       if value_type == :WITH_UNITS or value_type == :FORMATTED
         value = @json_hash["#{name}__F"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
 
         value = @json_hash["#{name}__C"]
-        return value.to_s if value
+        if value
+          value = value[array_index] if array_index
+          return value.to_s
+        end
 
         value = @json_hash[name]
-        return value.to_s if value
+        if value
+          value = value[array_index] if array_index
+          return value.to_s
+        end
 
         return nil
       end
       if value_type == :CONVERTED
         value = @json_hash["#{name}__C"]
-        return value if value
+        if value
+          value = value[array_index] if array_index
+          return value
+        end
       end
-      return @json_hash[name]
+      value = @json_hash[name]
+      if value
+        value = value[array_index] if array_index
+        return value
+      end
+      return nil
     end
 
     def read_with_limits_state(name, value_type = :CONVERTED, reduced_type = nil)
       value = read(name, value_type, reduced_type)
       limits_state = @json_hash["#{name}__L"]
-      limits_state.intern if limits_state
+      if limits_state
+        limits_state = limits_state.intern
+      end
       return [value, limits_state]
     end
 

data/lib/openc3/packets/packet_config.rb

@@ -119,7 +119,8 @@ module OpenC3
     #   an xtce file to automatically determine the target name.
     def process_file(filename, process_target_name)
       # Handle .xtce files
-      if File.extname(filename).to_s.downcase == ".xtce"
+      extension = File.extname(filename).to_s.downcase
+      if extension == ".xtce" or extension == ".xml"
         XtceParser.process(@commands, @telemetry, @warnings, filename, process_target_name)
         return
       end

data/lib/openc3/packets/parsers/xtce_parser.rb

@@ -181,7 +181,8 @@ module OpenC3
       when 'ParameterTypeSet', 'EnumerationList', 'ParameterSet', 'ContainerSet',
         'EntryList', 'DefaultCalibrator', 'DefaultAlarm', 'RestrictionCriteria',
         'ComparisonList', 'MetaCommandSet', 'ArgumentTypeSet', 'ArgumentList',
-        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime'
+        'ArgumentAssignmentList', 'LocationInContainerInBits', 'ReferenceTime',
+        'AncillaryDataSet', 'AncillaryData'
         # Do Nothing
 
       when 'ErrorDetectCorrect'
@@ -446,6 +447,9 @@ module OpenC3
         process_ref_entry(element)
         return false # Already recursed
 
+      when 'ContainerRefEntry'
+        xtce_handle_base_container('ContainerRefEntry', element)
+
       when 'BaseContainer'
         # Handled in SequenceContainer/CommandContainer
 

data/lib/openc3/script/api_shared.rb

@@ -69,7 +69,7 @@ module OpenC3
       method += ", #{orig_kwargs}" unless orig_kwargs.empty?
       method += ")"
     rescue Exception => error
-      Logger.info "CHECK: #{method} raised #{error.class}:#{error.message}"
+      puts "CHECK: #{method} raised #{error.class}:#{error.message}"
     else
       raise(CheckError, "#{method} should have raised an exception but did not.")
     end
@@ -107,10 +107,10 @@ module OpenC3
         end
 
         if all_checks_ok
-          Logger.info message
+          puts message
         else
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -120,11 +120,11 @@ module OpenC3
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value}"
         if range.include?(value)
-          Logger.info "#{check_str} was within #{range_str}"
+          puts "#{check_str} was within #{range_str}"
         else
           message = "#{check_str} failed to be within #{range_str}"
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -142,11 +142,11 @@ module OpenC3
     def check_expression(exp_to_eval, context = nil, scope: $openc3_scope, token: $openc3_token)
       success = _openc3_script_wait_implementation_expression(exp_to_eval, 0, DEFAULT_TLM_POLLING_RATE, context, scope: scope, token: token)
       if success
-        Logger.info "CHECK: #{exp_to_eval} is TRUE"
+        puts "CHECK: #{exp_to_eval} is TRUE"
       else
         message = "CHECK: #{exp_to_eval} is FALSE"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -171,7 +171,7 @@ module OpenC3
         start_time = Time.now.sys
         openc3_script_sleep()
         time_diff = Time.now.sys - start_time
-        Logger.info("WAIT: Indefinite for actual time of #{time_diff} seconds") unless quiet
+        puts "WAIT: Indefinite for actual time of #{time_diff} seconds" unless quiet
 
       # wait(5) # absolute wait time
       when 1
@@ -179,7 +179,7 @@ module OpenC3
           start_time = Time.now.sys
           openc3_script_sleep(args[0])
           time_diff = Time.now.sys - start_time
-          Logger.info("WAIT: #{args[0]} seconds with actual time of #{time_diff} seconds") unless quiet
+          puts "WAIT: #{args[0]} seconds with actual time of #{time_diff} seconds" unless quiet
         else
           raise "Non-numeric wait time specified"
         end
@@ -254,9 +254,9 @@ module OpenC3
         end
 
         if success
-          Logger.info message unless quiet
+          puts message unless quiet
         else
-          Logger.warn message unless quiet
+          puts "WARN: #{message}" unless quiet
         end
       else
         success, value = _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
@@ -265,9 +265,9 @@ module OpenC3
         wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time} seconds"
         if success
-          Logger.info "#{wait_str} was within #{range_str}" unless quiet
+          puts "#{wait_str} was within #{range_str}" unless quiet
         else
-          Logger.warn "#{wait_str} failed to be within #{range_str}" unless quiet
+          puts "WARN: #{wait_str} failed to be within #{range_str}" unless quiet
         end
       end
       time
@@ -284,9 +284,9 @@ module OpenC3
       success = _openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
+        puts "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
       else
-        Logger.warn "WAIT: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds" unless quiet
+        puts "WARN: WAIT: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds" unless quiet
       end
       time_diff
     end
@@ -312,11 +312,11 @@ module OpenC3
       end
       with_value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
-        Logger.info "#{check_str} success #{with_value_str}"
+        puts "#{check_str} success #{with_value_str}"
       else
         message = "#{check_str} failed #{with_value_str}"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -363,10 +363,10 @@ module OpenC3
         end
 
         if success
-          Logger.info message
+          puts message
         else
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -378,11 +378,11 @@ module OpenC3
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
         range_str = "range #{range.first} to #{range.last} with value == #{value} after waiting #{time_diff} seconds"
         if success
-          Logger.info "#{check_str} was within #{range_str}"
+          puts "#{check_str} was within #{range_str}"
         else
           message = "#{check_str} failed to be within #{range_str}"
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
@@ -409,11 +409,11 @@ module OpenC3
                                                              context, scope: scope, token: token, &block)
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds"
+        puts "CHECK: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds"
       else
         message = "CHECK: #{exp_to_eval} is FALSE after waiting #{time_diff} seconds"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end
@@ -540,7 +540,7 @@ module OpenC3
       if comparison_to_eval
         _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
       else
-        Logger.info "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
+        puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value}"
       end
     end
 
@@ -621,17 +621,17 @@ module OpenC3
       value = 0 unless value
       time_diff = Time.now.sys - start_time
       if success
-        Logger.info "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time_diff} seconds" unless quiet
+        puts "#{type}: #{target_name.upcase} #{packet_name.upcase} received #{value - initial_count} times after waiting #{time_diff} seconds" unless quiet
       else
         message = "#{type}: #{target_name.upcase} #{packet_name.upcase} expected to be received #{num_packets} times but only received #{value - initial_count} times after waiting #{time_diff} seconds"
         if check
           if $disconnect
-            Logger.error message
+            puts "ERROR: #{message}"
           else
             raise CheckError, message
           end
         else
-          Logger.warn message unless quiet
+          puts "WARN: #{message}" unless quiet
         end
       end
       time_diff
@@ -645,9 +645,9 @@ module OpenC3
       wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
-        Logger.info "#{wait_str} success #{value_str}" unless quiet
+        puts "#{wait_str} success #{value_str}" unless quiet
       else
-        Logger.warn "#{wait_str} failed #{value_str}" unless quiet
+        puts "WARN: #{wait_str} failed #{value_str}" unless quiet
       end
     end
 
@@ -873,11 +873,11 @@ module OpenC3
       value_str = value.is_a?(String) ? "'#{value}'" : value
       with_value = "with value == #{value_str}"
       if eval(string)
-        Logger.info "#{check_str} success #{with_value}"
+        puts "#{check_str} success #{with_value}"
       else
         message = "#{check_str} failed #{with_value}"
         if $disconnect
-          Logger.error message
+          puts "ERROR: #{message}"
         else
           raise CheckError, message
         end

data/lib/openc3/script/commands.rb

@@ -69,12 +69,12 @@ module OpenC3
     # NOTE: This is a helper method and should not be called directly
     def _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
       if no_range
-        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring range checks"
+        puts "WARN: Command #{target_name} #{cmd_name} being sent ignoring range checks"
       end
       if no_hazardous
-        Logger.warn "Command #{target_name} #{cmd_name} being sent ignoring hazardous warnings"
+        puts "WARN: Command #{target_name} #{cmd_name} being sent ignoring hazardous warnings"
       end
-      Logger.info _cmd_string(target_name, cmd_name, cmd_params, raw)
+      puts _cmd_string(target_name, cmd_name, cmd_params, raw)
     end
 
     def _cmd_disconnect(cmd, raw, no_range, no_hazardous, *args, scope: $openc3_scope)
@@ -95,7 +95,7 @@ module OpenC3
       end
 
       # Get the command and validate the parameters
-      command = $api_server.get_command(target_name, cmd_name, scope: scope)
+      command = $api_server.get_cmd(target_name, cmd_name, scope: scope)
       cmd_params.each do |param_name, param_value|
         param = command['items'].find { |item| item['name'] == param_name }
         unless param
@@ -108,7 +108,7 @@ module OpenC3
     # Send the command and log the results
     # This method signature has to include the keyword params present in cmd_api.rb cmd_implementation()
     # NOTE: This is a helper method and should not be called directly
-    def _cmd(cmd, cmd_no_hazardous, *args, scope: $openc3_scope, token: $openc3_token, timeout: nil, **kwargs)
+    def _cmd(cmd, cmd_no_hazardous, *args, timeout: nil, log_message: nil, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       raw = cmd.include?('raw')
       no_range = cmd.include?('no_range') || cmd.include?('no_checks')
@@ -118,14 +118,18 @@ module OpenC3
         _cmd_disconnect(cmd, raw, no_range, no_hazardous, *args, scope: scope)
       else
         begin
-          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args, scope: scope, token: token, timeout: timeout)
-          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args, timeout: timeout, log_message: log_message, scope: scope, token: token)
+          if log_message.nil? or log_message
+            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          end
         rescue HazardousError => e
           # This opens a prompt at which point they can cancel and stop the script
           # or say Yes and send the command. Thus we don't care about the return value.
           prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args, scope: scope, token: token, timeout: timeout)
-          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args, timeout: timeout, log_message: log_message, scope: scope, token: token)
+          if log_message.nil? or log_message
+            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
+          end
         end
       end
     end
@@ -171,12 +175,14 @@ module OpenC3
     # Builds a command binary
     #
     # Accepts two different calling styles:
-    #   build_command("TGT CMD with PARAM1 val, PARAM2 val")
-    #   build_command('TGT','CMD',{'PARAM1'=>val,'PARAM2'=>val})
-    def build_command(*args, range_check: true, raw: false, scope: $openc3_scope, **kwargs)
+    #   build_cmd("TGT CMD with PARAM1 val, PARAM2 val")
+    #   build_cmd('TGT','CMD',{'PARAM1'=>val,'PARAM2'=>val})
+    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       $api_server.build_command(*args)
     end
+    # build_command is DEPRECATED
+    alias build_command build_cmd
 
     # Returns whether the specified command is hazardous
     #

data/lib/openc3/script/limits.rb

@@ -29,7 +29,7 @@ module OpenC3
       define_method(method_name) do |*args, **kw_args, &block|
         kw_args[:scope] = $openc3_scope unless kw_args[:scope]
         if $disconnect
-          Logger.info "DISCONNECT: #{method_name}(#{args}) ignored"
+          puts "DISCONNECT: #{method_name}(#{args}) ignored"
         else
           $api_server.public_send(method_name, *args, **kw_args, &block)
         end

data/lib/openc3/script/storage.rb

@@ -37,7 +37,7 @@ module OpenC3
         # Only delete from the targets_modified
         delete_path = "#{scope}/targets_modified/#{path}"
         endpoint = "/openc3-api/storage/delete/#{delete_path}"
-        OpenC3::Logger.info "Deleting #{delete_path}"
+        puts "Deleting #{delete_path}"
         # Pass the name of the ENV variable name where we pull the actual bucket name
         response = $api_server.request('delete', endpoint, query: { bucket: 'OPENC3_CONFIG_BUCKET' }, scope: scope)
         if response.nil? || response.status != 200
@@ -65,7 +65,7 @@ module OpenC3
 
       endpoint = "/openc3-api/storage/upload/#{upload_path}"
       result = _get_presigned_request(endpoint, scope: scope)
-      OpenC3::Logger.info "Writing #{upload_path}"
+      puts "Writing #{upload_path}"
 
       # Try to put the file
       begin
@@ -104,7 +104,7 @@ module OpenC3
           if part == "targets_modified" and ENV['OPENC3_LOCAL_MODE']
             local_file = OpenC3::LocalMode.open_local_file(path, scope: scope)
             if local_file
-              OpenC3::Logger.info "Reading local #{scope}/#{part}/#{path}"
+              puts "Reading local #{scope}/#{part}/#{path}"
               file = Tempfile.new('target', binmode: true)
               file.filename = path
               file.write(local_file.read)
@@ -138,7 +138,7 @@ module OpenC3
 
       endpoint = "/openc3-api/storage/download/#{scope}/#{path}"
       result = _get_presigned_request(endpoint, scope: scope)
-      OpenC3::Logger.info "Reading #{scope}/#{path}"
+      puts "Reading #{scope}/#{path}"
 
       # Try to get the file
       uri = _get_uri(result['url'])