openc3 7.3.0 → 7.4.1

data/lib/openc3/io/udp_sockets.rb

@@ -27,6 +27,9 @@ module OpenC3
   class UdpReadWriteSocket
     HOST_0_0_0_0 = '0.0.0.0'
 
+    # MSG_DONTWAIT is not defined on Windows where sends are left blocking
+    WRITE_FLAGS = Socket.const_defined?('MSG_DONTWAIT') ? Socket::MSG_DONTWAIT : 0
+
     # @param bind_port [Integer[ Port to write data out from and receive data on (0 = randomly assigned)
     # @param bind_address [String] Local address to bind to (0.0.0.0 = All local addresses)
     # @param external_port [Integer] External port to write to
@@ -35,6 +38,8 @@ module OpenC3
     # @param ttl [Integer] Time To Live for outgoing multicast packets
     # @param read_multicast [Boolean] Whether or not to try to read from the external address as multicast
     # @param write_multicast [Boolean] Whether or not to write to the external address as multicast
+    # @param connect_socket [Boolean] Whether to connect the socket to the external address. If false,
+    #   writes explicitly address each datagram so reads can accept datagrams from any source.
     def initialize(
       bind_port = 0,
       bind_address = HOST_0_0_0_0,
@@ -43,10 +48,23 @@ module OpenC3
       multicast_interface_address = nil,
       ttl = 1,
       read_multicast = true,
-      write_multicast = true
+      write_multicast = true,
+      connect_socket = true
     )
 
       @socket = UDPSocket.new
+      @external_address = external_address
+      @external_port = external_port
+      @connect_socket = connect_socket
+      # Resolve the destination once at creation time so writes don't pay for a
+      # (potentially blocking) name lookup on every datagram
+      @external_sockaddr = nil
+      if !connect_socket and external_address and external_port
+        # Explicitly resolve IPv4 because UDPSocket is an AF_INET socket and
+        # sockaddr_in would otherwise hand back an IPv6 address for names like localhost
+        ip_address = Socket.getaddrinfo(external_address, nil, Socket::AF_INET, Socket::SOCK_DGRAM)[0][3]
+        @external_sockaddr = Socket.sockaddr_in(external_port, ip_address)
+      end
 
       # Basic setup to reuse address
       @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
@@ -55,10 +73,10 @@ module OpenC3
       @socket.bind(bind_address, bind_port) if bind_address and bind_port
 
       # Default send to the specified address and port
-      @socket.connect(external_address, external_port) if external_address and external_port
+      @socket.connect(external_address, external_port) if connect_socket and external_address and external_port
 
       # Handle multicast
-      if UdpReadWriteSocket.multicast?(external_address, external_port)
+      if UdpReadWriteSocket.multicast?(external_address)
         if write_multicast
           # Basic setup set time to live
           @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl.to_i)
@@ -90,7 +108,13 @@ module OpenC3
 
       loop do
         begin
-          bytes_sent = @socket.write_nonblock(data_to_send)
+          if @external_sockaddr
+            # send is used rather than sendmsg_nonblock because sendmsg is not
+            # implemented on Windows
+            bytes_sent = @socket.send(data_to_send, WRITE_FLAGS, @external_sockaddr)
+          else
+            bytes_sent = @socket.write_nonblock(data_to_send)
+          end
         rescue Errno::EAGAIN, Errno::EWOULDBLOCK
           result = IO.fast_select(nil, [@socket], nil, write_timeout)
           if result
@@ -129,12 +153,18 @@ module OpenC3
     end
 
     # @param host [String] Machine name or IP address
-    # @param port [String] Port
+    # @param port [String] Port (unused, kept for backwards compatibility)
     # @return [Boolean] Whether the hostname is multicast
-    def self.multicast?(host, port)
-      return false if host.nil? || port.nil?
+    def self.multicast?(host, port = nil)
+      return false if host.nil?
 
-      Addrinfo.udp(host, port).ipv4_multicast?
+      begin
+        Addrinfo.udp(host, 0).ipv4_multicast?
+      rescue SocketError, ArgumentError
+        # Hostname isn't resolvable so it can't be a multicast address we handle.
+        # Reads don't need the hostname at all so don't fail creating the socket.
+        false
+      end
     end
   end
 

data/lib/openc3/io/win32_serial_driver.rb

@@ -16,6 +16,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/win32/win32'
+require 'openc3/io/serial_driver'
 require 'timeout' # For Timeout::Error
 
 module OpenC3

data/lib/openc3/logs/packet_log_reader.rb

@@ -142,7 +142,7 @@ module OpenC3
         end
       elsif flags & OPENC3_ENTRY_TYPE_MASK == OPENC3_RAW_PACKET_ENTRY_TYPE_MASK
         packet_index, time_nsec_since_epoch = entry[2..11].unpack('nQ>')
-        received_time_nsec_since_epoch, _extra, packet_data = handle_received_time_extra_and_data(entry, time_nsec_since_epoch, includes_received_time, includes_extra, cbor)
+        received_time_nsec_since_epoch, extra, packet_data = handle_received_time_extra_and_data(entry, time_nsec_since_epoch, includes_received_time, includes_extra, cbor)
         lookup_cmd_or_tlm, target_name, packet_name, _id = @packets[packet_index]
         if cmd_or_tlm != lookup_cmd_or_tlm
           raise "Packet type mismatch, packet:#{cmd_or_tlm}, lookup:#{lookup_cmd_or_tlm}"
@@ -159,6 +159,10 @@ module OpenC3
         packet.set_received_time_fast(received_time)
         packet.cmd_or_tlm = cmd_or_tlm
         packet.stored = stored
+        # Assigned unconditionally because identify_and_define_packet_data
+        # returns the shared System packet, so a nil extra here must clear
+        # the extra left over from a previous read of the same packet
+        packet.extra = extra
         packet.received_count += 1
         return packet
       elsif flags & OPENC3_ENTRY_TYPE_MASK == OPENC3_TARGET_DECLARATION_ENTRY_TYPE_MASK
@@ -304,7 +308,24 @@ module OpenC3
         if cbor
           extra = CBOR.decode(extra_encoded)
         else
-          extra = JSON.parse(extra_encoded, allow_nan: true, create_additions: true)
+          begin
+            extra = JSON.parse(extra_encoded, allow_nan: true, create_additions: true)
+          rescue JSON::ParserError => e
+            # PacketLogWriter up to version 7.3.0 CBOR encoded the extra on
+            # RAW_PACKET entries without setting OPENC3_CBOR_FLAG_MASK, so the
+            # flag claims JSON while the bytes are CBOR. Retry as CBOR so those
+            # existing files can still be read. extra is always a Hash, so a
+            # decode to anything else means these bytes aren't the legacy
+            # encoding either and the original JSON error is the useful one.
+            decoded = begin
+              CBOR.decode(extra_encoded)
+            rescue StandardError
+              raise e
+            end
+            raise e unless Hash === decoded
+
+            extra = decoded
+          end
         end
       end
       data = entry[next_offset..-1]

data/lib/openc3/logs/packet_log_writer.rb

@@ -311,6 +311,11 @@ module OpenC3
           extra = JSON.parse(extra, allow_nan: true, create_additions: true) if String === extra
           length += OPENC3_EXTRA_LENGTH_FIXED_SIZE
           if @data_format == :CBOR
+            # The reader uses this same flag to pick the extra decoder, so it
+            # must be set here as well as in the JSON_PACKET data branch above.
+            # RAW_PACKET entries never reach that branch and would otherwise
+            # write CBOR extra that the reader tries to JSON.parse.
+            flags |= OPENC3_CBOR_FLAG_MASK
             extra_encoded = extra.as_json.to_cbor
           else
             extra_encoded = JSON.generate(extra.as_json, allow_nan: true)

data/lib/openc3/logs/stream_log.rb

@@ -47,7 +47,7 @@ module OpenC3
       raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
 
       super(
-        "#{ENV['OPENC3_SCOPE']}/stream_logs/",
+        "#{ENV.fetch('OPENC3_SCOPE', 'DEFAULT')}/stream_logs/",
         true, # Start with logging enabled
         cycle_time,
         cycle_size,

data/lib/openc3/microservices/interface_decom_common.rb

@@ -33,7 +33,8 @@ module OpenC3
       end
       stored = inject_tlm_hash.fetch('stored', false)
       packet.stored = stored.to_s.downcase == 'true'
-      packet.received_time = Time.now.sys
+      received_time = inject_tlm_hash['received_time']
+      packet.received_time = received_time.nil? ? Time.now.sys : Time.from_nsec_from_epoch(received_time).sys
       packet.received_count = TargetModel.increment_telemetry_count(packet.target_name, packet.packet_name, 1, scope: @scope)
       TelemetryTopic.write_packet(packet, scope: @scope)
     end

data/lib/openc3/microservices/interface_microservice.rb

@@ -221,7 +221,12 @@ module OpenC3
               next 'SUCCESS'
             end
             if msg_hash.key?('interface_details')
-              next @interface.details.as_json.to_json(allow_nan: true)
+              begin
+                next @interface.details.as_json.to_json(allow_nan: true)
+              rescue => e
+                @logger.error "#{@interface.name}: interface_details: #{e.formatted}"
+                next e.message
+              end
             end
           end
 
@@ -508,7 +513,12 @@ module OpenC3
             next 'SUCCESS'
           end
           if msg_hash.key?('router_details')
-            next @router.details.as_json.to_json(allow_nan: true)
+            begin
+              next @router.details.as_json.to_json(allow_nan: true)
+            rescue => e
+              @logger.error "#{@router.name}: router_details: #{e.formatted}"
+              next e.message
+            end
           end
           next 'SUCCESS'
         end
@@ -610,7 +620,26 @@ module OpenC3
     # Called to connect the interface/router. It takes optional parameters to
     # rebuilt the interface/router. Once we set the state to 'ATTEMPTING' the
     # run method handles the actual connection.
+    # Connecting an interface/router which is already CONNECTED is a no-op.
+    # Without this the existing (working) connection would be torn down and
+    # rebuilt which can take up to the read_timeout to detect. Callers who want
+    # to force a reconnect should disconnect first or pass new parameters.
     def attempting(*params)
+      if params.empty? and @interface.state == 'CONNECTED' and @interface.connected?
+        @logger.info "#{@interface.name}: Connect ignored, already connected"
+        return @interface
+      end
+
+      attempt_connection(*params)
+    end
+
+    # Sets the state to 'ATTEMPTING', first rebuilding the interface/router if
+    # parameters are given, so the run method performs the actual connection.
+    # Unlike attempting() this always transitions. The reconnect path in
+    # disconnect() requires that, since @interface.disconnect may have raised or
+    # left connected? true, which would make attempting() ignore the request and
+    # leave the interface stuck in 'CONNECTED' with no way back to a connection.
+    def attempt_connection(*params)
       unless params.empty?
         @interface.disconnect()
         # Build New Interface, this can fail if passed bad parameters
@@ -828,6 +857,13 @@ module OpenC3
 
     def connect
       @logger.info "#{@interface.name}: Connect #{@interface.connection_string}"
+      # Interface connect implementations typically overwrite their stream / socket
+      # so cleanly close any existing connection rather than leaking it
+      begin
+        @interface.disconnect if @interface.connected?
+      rescue => e
+        @logger.error "Disconnect: #{@interface.name}: #{e.formatted}"
+      end
       begin
         @interface.connect
         @interface.post_connect
@@ -849,38 +885,49 @@ module OpenC3
     end
 
     def disconnect(allow_reconnect = true)
-      return if @interface.state == 'DISCONNECTED' && !@interface.connected?
-
-      # Synchronize the calls to @interface.disconnect since it takes an unknown
-      # amount of time. If two calls to disconnect stack up, the if statement
-      # should avoid multiple calls to disconnect.
+      reconnect = false
+
+      # Two threads reach here for a single connection loss: the cmd handler
+      # thread servicing a disconnect directive, and the run thread coming back
+      # out of read (or out of the connection maintenance sleep). The redundant
+      # check below and the state change that records the disconnect must be in
+      # the same critical section, otherwise the second thread reads the state
+      # before the first has updated it and disconnects the interface twice.
       @mutex.synchronize do
+        # A disconnect has already been performed so there is nothing left to do
+        return if @interface.state == 'DISCONNECTED' && !@interface.connected?
+
+        # Call disconnect without consulting connected? so any resources the
+        # interface is still holding are cleaned up. It takes an unknown amount
+        # of time which is the other reason for the mutex.
         begin
-          @interface.disconnect if @interface.connected?
+          @interface.disconnect
         rescue => e
           @logger.error "Disconnect: #{@interface.name}: #{e.formatted}"
         end
-      end
 
-      # If the interface is set to auto_reconnect then delay so the thread
-      # can come back around and allow the interface a chance to reconnect.
-      # Skip reconnect if stop() has been called to avoid re-creating the status model
-      if allow_reconnect and @interface.auto_reconnect and @interface.state != 'DISCONNECTED' and !@cancel_thread
-        attempting()
-        if !@cancel_thread
-          # @logger.debug "reconnect delay: #{@interface.reconnect_delay}"
-          @interface_thread_sleeper.sleep(@interface.reconnect_delay)
-        end
-      else
-        @interface.state = 'DISCONNECTED'
-        unless @cancel_thread
-          if @interface_or_router == 'INTERFACE'
-            InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
-          else
-            RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+        # If the interface is set to auto_reconnect then delay so the thread
+        # can come back around and allow the interface a chance to reconnect.
+        # Skip reconnect if stop() has been called to avoid re-creating the status model
+        reconnect = allow_reconnect && @interface.auto_reconnect && @interface.state != 'DISCONNECTED' && !@cancel_thread
+        if reconnect
+          attempt_connection()
+        else
+          @interface.state = 'DISCONNECTED'
+          unless @cancel_thread
+            if @interface_or_router == 'INTERFACE'
+              InterfaceStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+            else
+              RouterStatusModel.set(@interface.as_json(), queued: true, scope: @scope)
+            end
           end
         end
       end
+
+      # Sleep outside the mutex so stop() and connect() are not blocked for the
+      # whole reconnect delay
+      # @logger.debug "reconnect delay: #{@interface.reconnect_delay}"
+      @interface_thread_sleeper.sleep(@interface.reconnect_delay) if reconnect && !@cancel_thread
     end
 
     # Disconnect from the interface and stop the thread

data/lib/openc3/microservices/microservice.rb

@@ -43,7 +43,7 @@ module OpenC3
     attr_accessor :secrets
 
     def self.run(name = nil)
-      name = ENV['OPENC3_MICROSERVICE_NAME'] unless name
+      name = ENV.fetch('OPENC3_MICROSERVICE_NAME', nil) unless name
       microservice = self.new(name)
       thread = Thread.new do
         begin
@@ -150,7 +150,7 @@ module OpenC3
         cmd_array = @config["cmd"]
 
         # Get Microservice files from bucket storage
-        bucket = ENV['OPENC3_CONFIG_BUCKET']
+        bucket = ENV.fetch('OPENC3_CONFIG_BUCKET') { raise 'OPENC3_CONFIG_BUCKET environment variable is required' }
         client = Bucket.getClient()
 
         prefix = "#{@scope}/microservices/#{@name}/"
@@ -160,7 +160,7 @@ module OpenC3
         # unreachable while many microservices start at once. Rather than crash
         # and CrashLoopBackOff (which can outlast deploy timeouts), retry for a
         # bounded time before giving up.
-        startup_timeout = (ENV['OPENC3_MICROSERVICE_STARTUP_BUCKET_TIMEOUT'] || 60).to_f
+        startup_timeout = (ENV.fetch('OPENC3_MICROSERVICE_STARTUP_BUCKET_TIMEOUT', 60)).to_f
         startup_deadline = Time.now + startup_timeout
         begin
           file_count = 0

data/lib/openc3/microservices/multi_microservice.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2024 OpenC3 Inc.
+# Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
 #
 # This program is distributed in the hope that it will be useful,

data/lib/openc3/microservices/periodic_microservice.rb

@@ -46,8 +46,8 @@ module OpenC3
           NewsModel.news_error("Error contacting OpenC3 news feed (status: #{response.status})")
         end
       end
-    rescue Exception => e
-      NewsModel.news_error("Error contacting OpenC3 news feed. #{e.message})")
+    rescue StandardError => e
+      NewsModel.news_error("Error contacting OpenC3 news feed. #{e.message}")
     end
 
     def run

data/lib/openc3/migrations/20260704000000_default_bridge.rb

@@ -0,0 +1,38 @@
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# 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 LICENSE.md for more details.
+
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/utilities/migration'
+require 'openc3/models/scope_model'
+require 'openc3/models/microservice_model'
+require 'openc3/models/bridge_model'
+
+module OpenC3
+  # Ensure every existing scope has a DEFAULT bridge_microservice (the Iroh hub
+  # that lets openc3-app run COSMOS interfaces on the host). New scopes get one
+  # via ScopeModel#deploy; this backfills any scope created before that.
+  class DefaultBridge < Migration
+    def self.run
+      ScopeModel.get_all_models(scope: nil).each do |scope, scope_model|
+        name = "#{scope}__BRIDGE__DEFAULT"
+        next if MicroserviceModel.get_model(name: name, scope: scope)
+
+        microservice = BridgeModel.build_microservice(bridge_name: "DEFAULT", scope: scope, shard: scope_model.shard)
+        microservice.create
+        microservice.deploy
+        Logger.info("Added DEFAULT bridge_microservice to scope #{scope}")
+      end
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::DefaultBridge.run
+end

data/lib/openc3/migrations/20260731000000_system_health_json.rb

@@ -1,3 +1,14 @@
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# 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 LICENSE.md for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
 require 'json'
 require 'openc3/utilities/local_mode'
 require 'openc3/utilities/migration'

data/lib/openc3/models/auth_model.rb

@@ -27,7 +27,7 @@ module OpenC3
     PRIMARY_KEY = 'OPENC3__TOKEN' # for argon2 password hash
     SESSIONS_KEY = 'OPENC3__SESSIONS' # for hash containing session tokens
 
-    # The length of time in minutes to keep redis values in memory
+    # The length of time in seconds to keep redis values in memory
     PW_HASH_CACHE_TIMEOUT = 5
     SESSION_CACHE_TIMEOUT = 5
 
@@ -44,6 +44,21 @@ module OpenC3
     SESSION_PREFIX = "ses_"
     OTP_PREFIX = "otp_"
 
+    # A session token is SESSION_PREFIX followed by the unpadded urlsafe base64
+    # encoding of 16 random bytes, i.e. exactly 22 characters of [A-Za-z0-9_-].
+    # Keep this in sync with generate_session.
+    SESSION_TOKEN_REGEX = /\A#{SESSION_PREFIX}[A-Za-z0-9_-]{22}\z/
+
+    # Whether the given value could have been produced by generate_session.
+    # Callers handling a token from an unauthenticated request use this to
+    # reject garbage before doing any Redis work. Checking only the prefix is
+    # not enough: something like "ses_AAA" would pass and still cost us a read.
+    # @param token [String] the value to check
+    # @return [Boolean] whether the value is shaped like a session token
+    def self.session_token?(token)
+      SESSION_TOKEN_REGEX.match?(token.to_s)
+    end
+
     def self.set?(key = PRIMARY_KEY)
       Store.exists(key) == 1
     end
@@ -56,7 +71,7 @@ module OpenC3
     def self.verify(token, no_password: true, service_only: false)
       # Handle a service password - Generally only used by ScriptRunner
       # TODO: Replace this with temporary service tokens
-      service_password = ENV['OPENC3_SERVICE_PASSWORD']
+      service_password = ENV.fetch('OPENC3_SERVICE_PASSWORD', nil)
       return true if service_password and service_password == token
 
       return false if service_only
@@ -78,15 +93,28 @@ module OpenC3
       # Check cached session tokens and password hash
       time = Time.now
       unless mode == :password
-        if @@session_cache and (time - @@session_cache_time) < SESSION_CACHE_TIMEOUT and @@session_cache[token]
+        # Drop the whole cache once it ages out rather than tracking per token
+        # times. This bounds how long a terminated token keeps working to
+        # SESSION_CACHE_TIMEOUT, same as before.
+        if @@session_cache.nil? or (time - @@session_cache_time) >= SESSION_CACHE_TIMEOUT
+          @@session_cache = {}
+          @@session_cache_time = time
+        end
+
+        if @@session_cache[token]
           terminate_otp(token)
           return true
         end
 
-        # Check stored session tokens
-        @@session_cache = Store.hgetall(SESSIONS_KEY)
-        @@session_cache_time = time
-        if @@session_cache[token]
+        # Check the stored session tokens for just this token. Deliberately not
+        # HGETALL: verify_token is unauthenticated, so reading the entire
+        # session hash here lets any caller make us pull every session ever
+        # created on every request, and that hash only grows. HGET is O(1) and
+        # can't be amplified. The cache then fills with the tokens actually in
+        # use instead of all of them.
+        stored = Store.hget(SESSIONS_KEY, token)
+        if stored
+          @@session_cache[token] = stored
           terminate_otp(token)
           return true
         end