openc3 7.3.0 → 7.4.1

data/lib/openc3/interfaces/interface.rb

@@ -15,6 +15,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/packets/packet'
 require 'openc3/api/api'
 require 'openc3/logs/stream_log_pair'
 require 'openc3/utilities/secrets'
@@ -433,8 +434,8 @@ module OpenC3
       config['name'] = @name
       config['state'] = @state
       config['clients'] = self.num_clients
-      config['txsize'] = @write_queue_size
-      config['rxsize'] = @read_queue_size
+      config['txsize'] = self.write_queue_size
+      config['rxsize'] = self.read_queue_size
       config['txbytes'] = @bytes_written
       config['rxbytes'] = @bytes_read
       config['txcnt'] = @write_count
@@ -677,12 +678,12 @@ module OpenC3
       result['read_raw_data'] = @read_raw_data
       result['written_raw_data'] = @written_raw_data
       if @read_raw_data_time
-        result['read_raw_data_time'] = @read_raw_data_time.iso8601
+        result['read_raw_data_time'] = @read_raw_data_time.getutc.iso8601(6)
       else
         result['read_raw_data_time'] = nil
       end
       if @written_raw_data_time
-        result['written_raw_data_time'] = @written_raw_data_time.iso8601
+        result['written_raw_data_time'] = @written_raw_data_time.getutc.iso8601(6)
       else
         result['written_raw_data_time'] = nil
       end

data/lib/openc3/interfaces/mqtt_stream_interface.rb

@@ -49,6 +49,8 @@ module OpenC3
 
     # Creates a new {SerialStream} using the parameters passed in the constructor
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = MqttStream.new(@hostname, @port, @ssl, @write_topic, @read_topic, @ack_timeout)
       @stream.username = @username if @username
       @stream.password = @password if @password

data/lib/openc3/interfaces/protocols/burst_protocol.rb

@@ -23,6 +23,14 @@ module OpenC3
   # Reads all data available on the interface and creates a packet
   # with that data.
   class BurstProtocol < Protocol
+    # Maximum number of bytes which will be buffered while waiting for a
+    # complete packet. This bounds the memory a peer can cause the interface
+    # to allocate by declaring an enormous packet length (LENGTH, PREIDENTIFIED)
+    # or by never sending a terminator (TERMINATED). Deliberately much larger
+    # than any realistic packet so it does not affect existing configurations.
+    # Override with the OPENC3_PROTOCOL_MAX_BUFFER_SIZE environment variable.
+    DEFAULT_MAX_BUFFER_SIZE = 100_000_000
+
     # @param discard_leading_bytes [Integer] The number of bytes to discard
     #   from the binary data after reading. Note that this is often
     #   used to remove a sync pattern from the final packet data.
@@ -37,6 +45,7 @@ module OpenC3
       @sync_pattern = ConfigParser.handle_nil(sync_pattern)
       @sync_pattern = @sync_pattern.hex_to_byte_string if @sync_pattern
       @fill_fields = ConfigParser.handle_true_false(fill_fields)
+      @max_buffer_size = Integer(ENV.fetch('OPENC3_PROTOCOL_MAX_BUFFER_SIZE', DEFAULT_MAX_BUFFER_SIZE))
     end
 
     def reset
@@ -60,6 +69,7 @@ module OpenC3
       # @return [String|nil] Data for a packet consisting of the bytes read
       def read_data(data, extra = nil)
         @data << data
+        check_buffer_size()
         @extra = extra unless (data.length == 0 and extra.nil?) # Maintain extra from last read read_data
 
         while true
@@ -192,6 +202,21 @@ module OpenC3
       return super(data, extra)
     end
 
+    # Raises if the accumulation buffer has grown past @max_buffer_size. Called
+    # from read_data by both the Ruby and the C implementations. Raising causes
+    # Interface#read to log the error and disconnect, which drops the offending
+    # peer and resets this protocol.
+    def check_buffer_size
+      length = @data.length
+      return if length <= @max_buffer_size
+
+      # Release the buffer and clear any partially reduced state now rather than
+      # waiting for the interface to disconnect and reset() us
+      reset()
+      raise "#{@interface ? @interface.name : ""}: Protocol buffer of #{length} bytes exceeds maximum of #{@max_buffer_size} bytes. " \
+            "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+    end
+
     def log_discard(length, found)
       Logger.error("#{@interface ? @interface.name : ""}: Sync #{'not ' unless found}found. Discarding #{length} bytes of data.")
       if @data.length >= 0
@@ -210,6 +235,7 @@ module OpenC3
       result['discard_leading_bytes'] = @discard_leading_bytes
       result['sync_pattern'] = @sync_pattern.inspect
       result['fill_fields'] = @fill_fields
+      result['max_buffer_size'] = @max_buffer_size
       return result
     end
 
@@ -218,6 +244,7 @@ module OpenC3
       result['discard_leading_bytes'] = @discard_leading_bytes
       result['sync_pattern'] = @sync_pattern.inspect
       result['fill_fields'] = @fill_fields
+      result['max_buffer_size'] = @max_buffer_size
       return result
     end
   end

data/lib/openc3/interfaces/protocols/length_protocol.rb

@@ -168,6 +168,13 @@ module OpenC3
       raise "Length value received larger than max_length: #{length} > #{@max_length}" if @max_length and length > @max_length
 
       packet_length = (length * @length_bytes_per_count) + @length_value_offset
+      # Reject up front rather than buffering the declared number of bytes first
+      if packet_length > @max_buffer_size
+        reset() # Drop the partial frame rather than holding it until disconnect
+        raise "Calculated packet length of #{packet_length} bytes exceeds maximum buffer size of #{@max_buffer_size} bytes. " \
+              "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+      end
+
       # Ensure the calculated packet length is long enough to support the location of the length field
       # without overlap into the next packet
       if (packet_length * 8) < (@length_bit_offset + @length_bit_size)

data/lib/openc3/interfaces/protocols/preidentified_protocol.rb

@@ -106,6 +106,13 @@ module OpenC3
       when 4
         string_length = string_length.unpack('N')[0] # UINT32
         raise "Length value received larger than max_length: #{string_length} > #{@max_length}" if @max_length and string_length > @max_length
+
+        # Reject up front rather than buffering the declared number of bytes first
+        if string_length > @max_buffer_size
+          reset() # Drop the partial frame rather than holding it until disconnect
+          raise "Length value received of #{string_length} bytes exceeds maximum buffer size of #{@max_buffer_size} bytes. " \
+                "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+        end
       else
         raise "Unsupported length given to read_length_field_followed_by_string: #{length_num_bytes}"
       end

data/lib/openc3/interfaces/protocols/protocol.rb

@@ -36,6 +36,14 @@ module OpenC3
     end
 
     def reset
+      @read_data_input_time = nil
+      @read_data_input = ''
+      @read_data_output_time = nil
+      @read_data_output = ''
+      @write_data_input_time = nil
+      @write_data_input = ''
+      @write_data_output_time = nil
+      @write_data_output = ''
       @extra = nil
     end
 
@@ -131,13 +139,13 @@ module OpenC3
     def write_details
       result = {'name' => self.class.name.to_s.split("::")[-1]}
       if @write_data_input_time
-        result['write_data_input_time'] = @write_data_input_time.iso8601
+        result['write_data_input_time'] = @write_data_input_time.getutc.iso8601(6)
       else
         result['write_data_input_time'] = nil
       end
       result['write_data_input'] = @write_data_input
       if @write_data_output_time
-        result['write_data_output_time'] = @write_data_output_time.iso8601
+        result['write_data_output_time'] = @write_data_output_time.getutc.iso8601(6)
       else
         result['write_data_output_time'] = nil
       end
@@ -148,13 +156,13 @@ module OpenC3
     def read_details
       result = {'name' => self.class.name.to_s.split("::")[-1]}
       if @read_data_input_time
-        result['read_data_input_time'] = @read_data_input_time.iso8601
+        result['read_data_input_time'] = @read_data_input_time.getutc.iso8601(6)
       else
         result['read_data_input_time'] = nil
       end
       result['read_data_input'] = @read_data_input
       if @read_data_output_time
-        result['read_data_output_time'] = @read_data_output_time.iso8601
+        result['read_data_output_time'] = @read_data_output_time.getutc.iso8601(6)
       else
         result['read_data_output_time'] = nil
       end

data/lib/openc3/interfaces/protocols/template_protocol.rb

@@ -266,7 +266,7 @@ module OpenC3
       result['response_timeout'] = @response_timeout
       result['response_polling_period'] = @response_polling_period
       if @connect_complete_time
-        result['connect_complete_time'] = @connect_complete_time.iso8601
+        result['connect_complete_time'] = @connect_complete_time.getutc.iso8601(6)
       else
         result['connect_complete_time'] = nil
       end
@@ -285,7 +285,7 @@ module OpenC3
       result['response_timeout'] = @response_timeout
       result['response_polling_period'] = @response_polling_period
       if @connect_complete_time
-        result['connect_complete_time'] = @connect_complete_time.iso8601
+        result['connect_complete_time'] = @connect_complete_time.getutc.iso8601(6)
       else
         result['connect_complete_time'] = nil
       end

data/lib/openc3/interfaces/serial_interface.rb

@@ -77,6 +77,8 @@ module OpenC3
 
     # Creates a new {SerialStream} using the parameters passed in the constructor
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = SerialStream.new(
         @write_port_name,
         @read_port_name,

data/lib/openc3/interfaces/tcpip_client_interface.rb

@@ -76,6 +76,8 @@ module OpenC3
     # Connects the {TcpipClientStream} by passing the
     # initialization parameters to the {TcpipClientStream}.
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = TcpipClientStream.new(
         @hostname,
         @write_port,

data/lib/openc3/interfaces/udp_interface.rb

@@ -23,6 +23,7 @@ module OpenC3
   # Base class for interfaces that send and receive messages over UDP
   class UdpInterface < Interface
     HOST_127_0_0_1 = '127.0.0.1'
+    HOST_0_0_0_0 = '0.0.0.0'
 
     # @param hostname [String] Machine to connect to
     # @param write_dest_port [Integer] Port to write commands to
@@ -77,8 +78,11 @@ module OpenC3
       @read_timeout = ConfigParser.handle_nil(read_timeout)
       @read_timeout = @read_timeout.to_f if @read_timeout
       @bind_address = ConfigParser.handle_nil(bind_address)
-      if @bind_address && @bind_address.casecmp('LOCALHOST').zero?
-        @bind_address = HOST_127_0_0_1
+      if @bind_address
+        @bind_address = HOST_127_0_0_1 if @bind_address.casecmp('LOCALHOST').zero?
+      else
+        # nil means all local addresses which is what 0.0.0.0 means
+        @bind_address = HOST_0_0_0_0
       end
       @write_socket = nil
       @read_socket = nil
@@ -91,9 +95,9 @@ module OpenC3
       result = ''
       result += " #{@hostname}:#{@write_dest_port} (write dest port)" if @write_dest_port
       result += " #{@write_src_port} (write src port)" if @write_src_port
-      result += " #{@hostname}:#{@read_port} (read)" if @read_port
+      result += " #{@bind_address}:#{@read_port} (read)" if @read_port
       result += " #{@interface_address} (interface addr)" if @interface_address
-      result += " #{@bind_address} (bind addr)" if @bind_address != '0.0.0.0'
+      result += " #{@bind_address} (bind addr)" if @bind_address != HOST_0_0_0_0
       return result.strip
     end
 
@@ -102,13 +106,20 @@ module OpenC3
     # the constructor.
     def connect
       if @read_port and @write_dest_port and @write_src_port and (@read_port == @write_src_port)
+        # read_multicast is false because this socket is not connected and thus
+        # doesn't filter by peer address. Joining the multicast group we write to
+        # would deliver our own commands back to us as telemetry (multicast
+        # loopback is enabled by default).
         @read_socket = UdpReadWriteSocket.new(
           @read_port,
           @bind_address,
           @write_dest_port,
           @hostname,
           @interface_address,
-          @ttl
+          @ttl,
+          false, # read_multicast
+          true,  # write_multicast
+          false  # connect_socket
         )
         @write_socket = @read_socket
       else

data/lib/openc3/io/json_api.rb

@@ -35,8 +35,9 @@ module OpenC3
     # pull openc3-cosmos-script-runner-api url from environment variables
     def _generate_url(microservice_name:, prefix:, schema: 'http', hostname: nil, port:, scope: $openc3_scope)
       prefix = '/' + prefix unless prefix[0] == '/'
-      if ENV['OPENC3_OPERATOR_HOSTNAME']
-        hostname = ENV['OPENC3_OPERATOR_HOSTNAME'] unless hostname
+      operator_hostname = ENV.fetch('OPENC3_OPERATOR_HOSTNAME', nil)
+      if operator_hostname
+        hostname = operator_hostname unless hostname
         return "#{schema}://#{hostname}:#{port.to_i}#{prefix}"
       else
         if ENV['KUBERNETES_SERVICE_HOST']

data/lib/openc3/io/json_api_object.rb

@@ -53,10 +53,19 @@ module OpenC3
 
     USER_AGENT = 'OpenC3 / v7 (ruby/openc3/lib/io/json_api_object)'.freeze
 
+    # Time limit for the first response byte from the server. This must be an
+    # explicit number rather than nil, see connect() for why. Requests can
+    # legitimately block for a long time, e.g. cmd() with a large timeout waiting
+    # on an interface ack, so this is effectively "wait forever" while still
+    # bounded so a wedged connection eventually releases the thread.
+    DEFAULT_READ_TIMEOUT_S = 86400
+
     # @param url [String] The url of openc3-cosmos-cmd-tlm-api http://openc3-cosmos-cmd-tlm-api:2901
     # @param timeout [Float] The time to wait before disconnecting 1.0
     # @param authentication [OpenC3Authentication] The authentication object if nill initialize will generate
-    def initialize(url:, timeout: 1.0, authentication: nil)
+    # @param read_timeout [Float] The time to wait for the first response byte from the server.
+    #   Defaults to the OPENC3_API_READ_TIMEOUT environment variable or DEFAULT_READ_TIMEOUT_S.
+    def initialize(url:, timeout: 1.0, authentication: nil, read_timeout: nil)
       @http = nil
       @mutex = Mutex.new
       @request_data = ""
@@ -65,6 +74,7 @@ module OpenC3
       @log = [nil, nil, nil]
       @authentication = authentication.nil? ? generate_auth() : authentication
       @timeout = timeout
+      @read_timeout = (read_timeout || ENV.fetch('OPENC3_API_READ_TIMEOUT', DEFAULT_READ_TIMEOUT_S)).to_f
       @shutdown = false
       # JsonDRb.debug = true # Enable for debugging
     end
@@ -120,7 +130,11 @@ module OpenC3
         # :open_timeout  - time limit for just the connection phase (e.g. handshake) (Integer in seconds)
         # :read_timeout  - time limit for the first response byte received from the server (Integer in seconds)
         # :write_timeout - time limit for the client to send the request to the server (Integer in seconds)
-        @http = Faraday.new(request: { open_timeout: @timeout.to_i, read_timeout: nil }) do |f|
+        # NOTE: read_timeout must be an explicit number. Faraday only assigns it to Net::HTTP
+        # when the value is truthy (see Faraday::Adapter::NetHttp#configure_request), so passing
+        # nil does NOT mean "wait forever", it silently leaves Net::HTTP's 60s default in place.
+        # That 60s then caps every request regardless of any longer application level timeout.
+        @http = Faraday.new(request: { open_timeout: @timeout.to_i, read_timeout: @read_timeout }) do |f|
           f.adapter :net_http # adds the adapter to the connection, defaults to `Faraday.default_adapter`
         end
       rescue => e
@@ -212,7 +226,9 @@ module OpenC3
           @response_data = resp.body
           return resp
         rescue Faraday::ConnectionFailed, Errno::ECONNRESET, Errno::EPIPE, IOError => e
-          # Connection errors are retryable - reconnect and try again
+          # Retryable. Nothing was successfully sent, so replaying is safe. This includes
+          # Net::OpenTimeout, which Faraday maps to ConnectionFailed and which covers a
+          # service that is still starting up.
           retry_count += 1
           @log[2] = "#{method} Exception: #{e.class}, #{e.message}, #{e.backtrace}"
           if retry_count <= RETRY_COUNT
@@ -225,6 +241,11 @@ module OpenC3
             raise error
           end
         rescue StandardError => e
+          # Everything else, including Faraday::TimeoutError from a read timeout, is NOT
+          # retryable. A read timeout means the request was fully sent and the server may
+          # have already acted on it. Many endpoints are not idempotent (create_activity,
+          # script_run, cmd), so a retry risks duplicating the operation. It would also blow
+          # past the caller's deadline by RETRY_COUNT times.
           @log[2] = "#{method} Exception: #{e.class}, #{e.message}, #{e.backtrace}"
           disconnect()
           error = "Api Exception: #{@log[0]} ::: #{@log[1]} ::: #{@log[2]}"

data/lib/openc3/io/json_drb.rb

@@ -282,10 +282,26 @@ module OpenC3
               response = JsonRpcSuccessResponse.new(result, request.id)
             end
           rescue Exception => e
-            # Filter out the framework stack trace (rails, rack, puma etc)
-            lines = e.formatted.split("\n")
-            i = lines.find_index { |row| row.include?('actionpack') || row.include?('activesupport') }
-            Logger.error lines[0...i].join("\n")
+            error_name = e.class.name.split('::')[-1]
+            method_name = request.method.downcase()
+            case e
+            when AuthError, ForbiddenError
+              # Auth failures are expected (e.g. browser requests before login or with an
+              # expired session token) so log a single line without the stack trace
+              Logger.warn "#{error_name} : #{e.message} calling #{method_name}"
+            when HazardousError, CriticalCmdError
+              # Not errors at all: these are the signal that the UI should raise an
+              # operator confirmation dialog, and the user retries with the hazardous
+              # or critical flag set. A stack trace per prompt is pure noise, and
+              # HazardousError#to_s embeds the formatted command with a newline,
+              # so log just the error name and the method that raised it.
+              Logger.info "#{error_name} calling #{method_name}"
+            else
+              # Filter out the framework stack trace (rails, rack, puma etc)
+              lines = e.formatted.split("\n")
+              i = lines.find_index { |row| row.include?('actionpack') || row.include?('activesupport') }
+              Logger.error lines[0...(i || lines.length)].join("\n")
+            end
 
             if request.id
               if NoMethodError === e

data/lib/openc3/io/json_drb_object.rb

@@ -38,8 +38,9 @@ module OpenC3
     # @param url [String] The url of openc3-cosmos-cmd-tlm-api http://openc3-cosmos-cmd-tlm-api:2901
     # @param timeout [Float] The time to wait before disconnecting 1.0
     # @param authentication [OpenC3Authentication] The authentication object if nill initialize will generate
-    def initialize(url:, timeout: 1.0, authentication: nil)
-      super(url: url, timeout: timeout, authentication: authentication)
+    # @param read_timeout [Float] The time to wait for the first response byte from the server
+    def initialize(url:, timeout: 1.0, authentication: nil, read_timeout: nil)
+      super(url: url, timeout: timeout, authentication: authentication, read_timeout: read_timeout)
       @uri = URI("#{url}/openc3-api/api")
     end