openc3 5.12.0 → 5.14.0

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
@@ -525,6 +525,17 @@ module OpenC3
     # Private implementation details
     ###########################################################################
 
+    # This must be here for custom microservices that might block.
+    # Overriden by running_script.rb for script sleep
+    def openc3_script_sleep(sleep_time = nil)
+      if sleep_time
+        sleep(sleep_time)
+      else
+        prompt("Press any key to continue...")
+      end
+      return false
+    end
+
     # Creates a string with the parameters upcased
     def _upcase(target_name, packet_name, item_name)
       "#{target_name.upcase} #{packet_name.upcase} #{item_name.upcase}"
@@ -540,7 +551,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 +632,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 +656,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 +884,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/script.rb

@@ -93,17 +93,8 @@ module OpenC3
       $script_runner_api_server = nil
     end
 
-    # This isn't part of the public API because users should use wait()
-    def openc3_script_sleep(sleep_time = nil)
-      if sleep_time
-        sleep(sleep_time)
-      else
-        prompt("Press any key to continue...")
-      end
-      return false
-    end
-
     # Internal method used in scripts when encountering a hazardous command
+    # Not part of public APIs but must be implemented here
     def prompt_for_hazardous(target_name, cmd_name, hazardous_description)
       loop do
         message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
@@ -140,6 +131,7 @@ module OpenC3
       default = ''
       if blank_or_default != true && blank_or_default != false
         question << " (default = #{blank_or_default})"
+        default = blank_or_default.to_s
         allow_blank = true
       else
         allow_blank = blank_or_default
@@ -150,7 +142,9 @@ module OpenC3
         answer.chomp!
         break if allow_blank
       end
-      answer = default if answer.empty? and !default.empty?
+      if answer.empty? and !default.empty?
+        answer = default
+      end
       return answer
     end
 
@@ -162,7 +156,7 @@ module OpenC3
 
     def message_box(string, *buttons, **options)
       print "#{string} (#{buttons.join(", ")}): "
-      print "Details: #{details}\n" if details
+      print "Details: #{details}\n" if options['details']
       gets.chomp
     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'])

data/lib/openc3/script/web_socket_api.rb

@@ -217,14 +217,14 @@ module OpenC3
 
   # Log Messages WebSocket
   class MessagesWebSocketApi < CmdTlmWebSocketApi
-    def initialize(history_count: 0, start_time: nil, end_time: nil, severity: nil, types: nil, url: nil, write_timeout: 10.0, read_timeout: 10.0, connect_timeout: 5.0, authentication: nil, scope: $openc3_scope)
+    def initialize(history_count: 0, start_time: nil, end_time: nil, level: nil, types: nil, url: nil, write_timeout: 10.0, read_timeout: 10.0, connect_timeout: 5.0, authentication: nil, scope: $openc3_scope)
       @identifier = {
         channel: "MessagesChannel",
         history_count: history_count
       }
       @identifier['start_time'] = start_time if start_time
       @identifier['end_time'] = end_time if end_time
-      @identifier['severity'] = severity if severity
+      @identifier['level'] = level if level
       @identifier['types'] = types if types
       super(url: url, write_timeout: write_timeout, read_timeout: read_timeout, connect_timeout: connect_timeout, authentication: authentication, scope: scope)
     end

data/lib/openc3/streams/mqtt_stream.rb

@@ -0,0 +1,109 @@
+# 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/mqtt_interface' # For MQTT patches
+require 'openc3/streams/stream'
+require 'openc3/config/config_parser'
+
+module OpenC3
+  class MqttStream < Stream
+    attr_reader :hostname
+    attr_reader :port
+    attr_reader :ssl
+    attr_reader :write_topic
+    attr_reader :read_topic
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :cert
+    attr_accessor :key
+    attr_accessor :ca_file
+
+    def initialize(hostname, port = 1883, ssl = false, write_topic = nil, read_topic = nil)
+      super()
+
+      @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)
+      @connected = false
+
+      @username = nil
+      @password = nil
+      @cert = nil
+      @key = nil
+      @ca_file = nil
+
+      # Mutex on write is needed to protect from commands coming in from more
+      # than one tool
+      @write_mutex = Mutex.new
+    end
+
+    # @return [String] Returns a binary string of data from the read_topic
+    def read
+      raise "Attempt to read from write only stream" unless @read_topic
+
+      # No read mutex is needed because reads happen serially
+      _, data = @client.get
+      if data.nil? or data.length <= 0
+        Logger.info "MqttStream: read returned nil" if data.nil?
+        Logger.info "MqttStream: read returned 0 bytes" if not data.nil? and data.length <= 0
+        return nil
+      end
+
+      return data
+    end
+
+    # @param data [String] A binary string of data to write to the write_topic
+    def write(data)
+      raise "Attempt to write to read only stream" unless @write_topic
+
+      @write_mutex.synchronize do
+        @client.publish(@write_topic, data)
+      end
+    end
+
+    # Connect the stream
+    def connect
+      @client = MQTT::Client.new
+      @client.host = @hostname
+      @client.port = @port
+      @client.ssl = @ssl
+      @client.username = @username if @username
+      @client.password = @password if @password
+      @client.cert = @cert if @cert
+      @client.key = @key if @key
+      @client.ca_file = @ca_file.path if @ca_file
+      @client.connect
+      @client.subscribe(@read_topic) if @read_topic
+      @connected = true
+    end
+
+    def connected?
+      @connected
+    end
+
+    def disconnect
+      if @connected
+        @client.disconnect
+        @client = nil
+        @connected = false
+      end
+    end
+  end
+end

data/lib/openc3/streams/tcpip_socket_stream.rb

@@ -160,5 +160,24 @@ module OpenC3
       @pipe_writer.write('.')
       @connected = false
     end
+
+    def set_option(option_name, option_values)
+      option_name_upcase = option_name.upcase
+
+      case option_name_upcase
+      when 'KEEPALIVE'
+        @write_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        @read_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      when 'KEEPCNT'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, Integer(option_values[0]))
+      when 'KEEPIDLE'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, Integer(option_values[0]))
+      when 'KEEPINTVL'
+        @write_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, Integer(option_values[0]))
+        @read_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, Integer(option_values[0]))
+      end
+    end
   end
 end

data/lib/openc3/system/system.rb

@@ -92,6 +92,18 @@ module OpenC3
               zip_file.extract(entry, path) unless File.exist?(path)
             end
           end
+
+          # Now add any modifications in targets_modified/TARGET/cmd_tlm
+          # This adds support for remembering dynamically created packets
+          # target.txt must be configured to either use all files in cmd_tlm folder (default)
+          # or have a predetermined empty file like dynamic_tlm.txt
+          bucket_path = "#{scope}/targets_modified/#{target_name}/cmd_tlm"
+          dirs, files = bucket.list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: bucket_path)
+          files.each do |file|
+            bucket_key = File.join(bucket_path, file['name'])
+            local_path = "#{base_dir}/targets/#{target_name}/cmd_tlm/#{file['name']}"
+            bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: bucket_key, path: local_path)
+          end
         end
 
         # Build System from targets
@@ -119,7 +131,7 @@ module OpenC3
     # @param target_names [Array of target names]
     # @param target_config_dir Directory where target config folders are
     def initialize(target_names, target_config_dir)
-      OpenC3.add_to_search_path(target_config_dir, true)
+      OpenC3.add_to_search_path(target_config_dir, true) if target_config_dir
       @targets = {}
       @packet_config = PacketConfig.new
       @commands = Commands.new(@packet_config)