openc3 5.0.6

data/lib/openc3/system.rb

@@ -0,0 +1,24 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# 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.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  autoload(:Target, "openc3/system/target.rb")
+  autoload(:System, "openc3/system/system.rb")
+  autoload(:SystemConfig, "openc3/system/system_config.rb")
+end

data/lib/openc3/tools/cmd_tlm_server/api.rb

@@ -0,0 +1,20 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# 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.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/api/api'

data/lib/openc3/tools/cmd_tlm_server/cmd_tlm_server_config.rb

@@ -0,0 +1,320 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# 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.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/config/config_parser'
+
+module OpenC3
+  # Reads an ascii file that defines the configuration settings used to
+  # configure the Command/Telemetry Server.
+  class CmdTlmServerConfig
+    # @return [Hash<String, Interface>] Interfaces hash
+    attr_accessor :interfaces
+    # @return [Hash<String, Interface>] Routers hash
+    attr_accessor :routers
+    # @return [Hash<String, PacketLogWriterPair>] Packet log writer hash. Each
+    #   pair encapsulates a command and telemetry log writer.
+    attr_accessor :packet_log_writer_pairs
+    # @return [Array<BackgroundTask>] Array of background tasks
+    attr_accessor :background_tasks
+    # @return [String] Command and Telemetry Server title
+    attr_accessor :title
+    # @return [Boolean] Flag indicating if meta data should be collected
+    attr_accessor :metadata
+
+    # Create a default pair of packet log writers and parses the
+    # configuration file.
+    #
+    # @param filename [String] The name of the configuration file to parse
+    def initialize(filename, system_config)
+      @system_config = system_config
+      @interfaces = {}
+      @routers = {}
+      @packet_log_writer_pairs = {}
+      # cmd_log_writer = System.default_packet_log_writer.new(:CMD, *System.default_packet_log_writer_params)
+      # tlm_log_writer = System.default_packet_log_writer.new(:TLM, *System.default_packet_log_writer_params)
+      # @packet_log_writer_pairs['DEFAULT'] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+      @background_tasks = []
+      @title = nil
+      @metadata = false
+      process_file(filename)
+    end
+
+    protected
+
+    def get_target_interface_name(target_name)
+      @interfaces.each do |interface_name, interface|
+        return interface_name if interface.target_names.include?(target_name)
+      end
+      nil
+    end
+
+    def setup_interface_or_router
+      current_interface_or_router = OpenStruct.new
+      current_interface_or_router.interfaces = []
+      current_interface_or_router.routers = []
+      current_interface_or_router.target_names = []
+      current_interface_or_router
+    end
+
+    # Processes a file and adds in the configuration defined in the file
+    #
+    # @param filename [String] The name of the configuration file to parse
+    # @param recursive [Boolean] Whether process_file is being called
+    #   recursively
+    def process_file(filename, recursive = false)
+      current_interface_or_router = nil
+      current_type = nil
+      current_interface_log_added = false
+
+      Logger.info "Processing CmdTlmServer configuration in file: #{File.expand_path(filename)}"
+
+      parser = ConfigParser.new("https://openc3.com/docs/v5")
+      parser.parse_file(filename) do |keyword, params|
+        case keyword
+        when 'TITLE'
+          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+
+          parser.verify_num_parameters(1, 1, "#{keyword} <Title Text>")
+          @title = params[0]
+
+        when 'PACKET_LOG_WRITER'
+          # usage = "PACKET_LOG_WRITER <Name> <Filename> <Specific Parameters>"
+          # parser.verify_num_parameters(2, nil, usage)
+          # packet_log_writer_name = params[0].upcase
+          # packet_log_writer_class = OpenC3.require_class(params[1])
+
+          # # Verify not overridding a packet log writer that is already associated with an interface
+          # packet_log_writer_pair = @packet_log_writer_pairs[packet_log_writer_name]
+          # if packet_log_writer_pair
+          #   @interfaces.each do |interface_name, interface|
+          #     if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+          #       raise parser.error("Redefining Packet Log Writer #{packet_log_writer_name} not allowed after it is associated with an interface")
+          #     end
+          #   end
+          # end
+
+          # if params[2]
+          #   cmd_log_writer = packet_log_writer_class.new(:CMD, *params[2..-1])
+          #   tlm_log_writer = packet_log_writer_class.new(:TLM, *params[2..-1])
+          #   @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+          # else
+          #   cmd_log_writer = packet_log_writer_class.new(:CMD)
+          #   tlm_log_writer = packet_log_writer_class.new(:TLM)
+          #   @packet_log_writer_pairs[packet_log_writer_name] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
+          # end
+
+        when 'AUTO_INTERFACE_TARGETS'
+          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+
+          usage = "#{keyword}"
+          parser.verify_num_parameters(0, 0, usage)
+          @system_config.targets.each do |target_name, target|
+            target_filename = File.join(target.dir, 'cmd_tlm_server.txt')
+            if File.exist?(target_filename)
+              # Skip this target if it's already been assigned an interface
+              next if get_target_interface_name(target.name)
+              raise parser.error("Cannot use #{keyword} with target name substitutions: #{target.name} != #{target.original_name}") if target.name != target.original_name
+
+              process_file(target_filename, true)
+            end
+          end
+
+        when 'INTERFACE_TARGET'
+          raise parser.error("#{keyword} not allowed in target #{filename}") if recursive
+
+          usage = "#{keyword} <Target Name> <Config File (defaults to cmd_tlm_server.txt)>"
+          parser.verify_num_parameters(1, 2, usage)
+          target = @system_config.targets[params[0].upcase]
+          raise parser.error("Unknown target: #{params[0].upcase}") unless target
+
+          interface_name = get_target_interface_name(target.name)
+          raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
+
+          target_filename = params[1]
+          target_filename = 'cmd_tlm_server.txt' unless target_filename
+          target_filename = File.join(target.dir, target_filename)
+          if File.exist?(target_filename)
+            process_file(target_filename, true)
+          else
+            raise parser.error("#{target_filename} does not exist")
+          end
+
+        when 'INTERFACE'
+          usage = "INTERFACE <Name> <Filename> <Specific Parameters>"
+          parser.verify_num_parameters(2, nil, usage)
+          interface_name = params[0].upcase
+          raise parser.error("Interface '#{interface_name}' defined twice") if @interfaces[interface_name]
+
+          # interface_class = OpenC3.require_class(params[1])
+          # if params[2]
+          #   current_interface_or_router = interface_class.new(*params[2..-1])
+          # else
+          #   current_interface_or_router = interface_class.new
+          # end
+          current_interface_or_router = setup_interface_or_router()
+          current_type = :INTERFACE
+          current_interface_log_added = false
+          # current_interface_or_router.packet_log_writer_pairs << @packet_log_writer_pairs['DEFAULT']
+          current_interface_or_router.name = interface_name
+          current_interface_or_router.config_params = params[1..-1]
+          @interfaces[interface_name] = current_interface_or_router
+
+        when 'LOG', 'LOG_STORED', 'DONT_LOG', 'TARGET'
+          raise parser.error("No current interface for #{keyword}") unless current_interface_or_router and current_type == :INTERFACE
+
+          case keyword
+
+          when 'LOG'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
+            # packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
+            # raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
+            # current_interface_or_router.packet_log_writer_pairs.delete(@packet_log_writer_pairs['DEFAULT']) unless current_interface_log_added
+            current_interface_log_added = true
+            # current_interface_or_router.packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.packet_log_writer_pairs.include?(packet_log_writer_pair)
+
+          when 'LOG_STORED'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Packet Log Writer Name>")
+            # packet_log_writer_pair = @packet_log_writer_pairs[params[0].upcase]
+            # raise parser.error("Unknown packet log writer: #{params[0].upcase}") unless packet_log_writer_pair
+            # current_interface_or_router.stored_packet_log_writer_pairs << packet_log_writer_pair unless current_interface_or_router.stored_packet_log_writer_pairs.include?(packet_log_writer_pair)
+
+          when 'DONT_LOG'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            # current_interface_or_router.packet_log_writer_pairs = []
+
+          when 'TARGET'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Target Name>")
+            target_name = params[0].upcase
+            target = @system_config.targets[target_name]
+            if target
+              interface_name = get_target_interface_name(target.name)
+              raise parser.error("Target #{target.name} already mapped to interface #{interface_name}") if interface_name
+
+              target.interface = current_interface_or_router
+              current_interface_or_router.target_names << target_name
+            else
+              raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface_or_router.name}")
+            end
+
+          end # end case keyword for all keywords that require a current interface
+
+        when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG_RAW', 'OPTION', 'PROTOCOL'
+          raise parser.error("No current interface or router for #{keyword}") unless current_interface_or_router
+
+          case keyword
+
+          when 'DONT_CONNECT'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            current_interface_or_router.connect_on_startup = false
+
+          when 'DONT_RECONNECT'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            current_interface_or_router.auto_reconnect = false
+
+          when 'RECONNECT_DELAY'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Delay in Seconds>")
+            current_interface_or_router.reconnect_delay = Float(params[0])
+
+          when 'DISABLE_DISCONNECT'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            current_interface_or_router.disable_disconnect = true
+
+          when 'LOG_RAW',
+            parser.verify_num_parameters(0, nil, "#{keyword} <Raw Logger Class File (optional)> <Raw Logger Parameters (optional)>")
+            # current_interface_or_router.raw_logger_pair = RawLoggerPair.new(current_interface_or_router.name, params)
+            # current_interface_or_router.start_raw_logging
+
+          when 'OPTION'
+            parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+            # current_interface_or_router.set_option(params[0], params[1..-1])
+
+          when 'PROTOCOL'
+            usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+            parser.verify_num_parameters(2, nil, usage)
+            unless %w(READ WRITE READ_WRITE).include? params[0].upcase
+              raise parser.error("Invalid protocol type: #{params[0]}", usage)
+            end
+
+            begin
+              # klass = OpenC3.require_class(params[1])
+              # current_interface_or_router.add_protocol(klass, params[2..-1], params[0].upcase.intern)
+            rescue LoadError, StandardError => error
+              raise parser.error(error.message, usage)
+            end
+
+          end # end case keyword for all keywords that require a current interface or router
+
+        when 'ROUTER'
+          usage = "ROUTER <Name> <Filename> <Specific Parameters>"
+          parser.verify_num_parameters(2, nil, usage)
+          router_name = params[0].upcase
+          raise parser.error("Router '#{router_name}' defined twice") if @routers[router_name]
+
+          # router_class = OpenC3.require_class(params[1])
+          # if params[2]
+          #  current_interface_or_router = router_class.new(*params[2..-1])
+          # else
+          #  current_interface_or_router = router_class.new
+          # end
+          current_interface_or_router = setup_interface_or_router()
+          current_type = :ROUTER
+          current_interface_or_router.name = router_name
+          @routers[router_name] = current_interface_or_router
+
+        when 'ROUTE'
+          raise parser.error("No current router for #{keyword}") unless current_interface_or_router and current_type == :ROUTER
+
+          usage = "ROUTE <Interface Name>"
+          parser.verify_num_parameters(1, 1, usage)
+          interface_name = params[0].upcase
+          interface = @interfaces[interface_name]
+          raise parser.error("Unknown interface #{interface_name} mapped to router #{current_interface_or_router.name}") unless interface
+
+          unless current_interface_or_router.interfaces.include? interface
+            current_interface_or_router.interfaces << interface
+            interface.routers << current_interface_or_router
+          end
+
+        when 'BACKGROUND_TASK'
+          usage = "#{keyword} <Filename> <Specific Parameters>"
+          parser.verify_num_parameters(1, nil, usage)
+          # background_task = OpenC3.require_class(params[0])
+          if params[1]
+            @background_tasks << params
+          else
+            @background_tasks << params
+          end
+
+        when 'STOPPED'
+          parser.verify_num_parameters(0, 0, "#{keyword}")
+          raise parser.error("No BACKGROUND_TASK defined") if @background_tasks.empty?
+          # @background_tasks[-1].stopped = true
+
+        when 'COLLECT_METADATA'
+          parser.verify_num_parameters(0, 0, "#{keyword}")
+          @metadata = true
+
+        else
+          # blank lines will have a nil keyword and should not raise an exception
+          raise parser.error("Unknown keyword: #{keyword}") unless keyword.nil?
+        end # case
+      end  # loop
+    end
+  end
+end

data/lib/openc3/tools/cmd_tlm_server/interface_thread.rb

@@ -0,0 +1,294 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# 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.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  # Encapsulates an {Interface} in a Ruby thread. When the thread is started by
+  # the {#start} method, it loops trying to connect. It then continously reads
+  # from the interface while handling the packets it receives.
+  class InterfaceThread
+    # The number of bytes to print when an UNKNOWN packet is received
+    UNKNOWN_BYTES_TO_PRINT = 36
+
+    # @return [#call()] Callback which is called if the #{Interface#connect}
+    #   method succeeds
+    attr_accessor :connection_success_callback
+    # @return [#call(Exception)] Callback which is called if the
+    #   {Interface#connect} method throws an exception.
+    attr_accessor :connection_failed_callback
+    # @return [#call(Exception|nil)] Callback which is called if the
+    #   interface connection is lost.
+    attr_accessor :connection_lost_callback
+    # @return [#call(Packet)] Callback which is called when a packet has been
+    #   received from the interface and identified.
+    attr_accessor :identified_packet_callback
+    # @return [#call(Exception)] Callback which is called if the
+    #   InterfaceThread dies for any reason.
+    attr_accessor :fatal_exception_callback
+
+    # @param interface [Interface] The interface to create a thread for
+    def initialize(interface)
+      @interface = interface
+      @connection_success_callback = nil
+      @connection_failed_callback = nil
+      @connection_lost_callback = nil
+      @identified_packet_callback = nil
+      @fatal_exception_callback = nil
+      @thread = nil
+      @thread_sleeper = Sleeper.new
+      @connection_failed_messages = []
+      @connection_lost_messages = []
+      @mutex = Mutex.new
+    end
+
+    # Create and start the Ruby thread that will encapsulate the interface.
+    # Creates a while loop that waits for {Interface#connect} to succeed. Then
+    # calls {Interface#read} and handles all the incoming packets.
+    def start
+      @thread_sleeper = Sleeper.new
+      @thread = Thread.new do
+        @cancel_thread = false
+        begin
+          if @interface.read_allowed?
+            Logger.info "Starting packet reading for #{@interface.name}"
+          else
+            Logger.info "Starting connection maintenance for #{@interface.name}"
+          end
+          while true
+            break if @cancel_thread
+
+            unless @interface.connected?
+              begin
+                @mutex.synchronize do
+                  # We need to make sure connect is not called after stop() has been called
+                  connect() unless @cancel_thread
+                end
+                break if @cancel_thread
+              rescue Exception => connect_error
+                handle_connection_failed(connect_error)
+                if @cancel_thread
+                  break
+                else
+                  next
+                end
+              end
+            end
+
+            if @interface.read_allowed?
+              begin
+                packet = @interface.read
+                unless packet
+                  Logger.info "Clean disconnect from #{@interface.name} (returned nil)"
+                  handle_connection_lost(nil)
+                  if @cancel_thread
+                    break
+                  else
+                    next
+                  end
+                end
+                packet.received_time = Time.now.sys unless packet.received_time
+              rescue Exception => err
+                handle_connection_lost(err)
+                if @cancel_thread
+                  break
+                else
+                  next
+                end
+              end
+
+              handle_packet(packet)
+            else
+              @thread_sleeper.sleep(1)
+              handle_connection_lost(nil) if !@interface.connected?
+            end
+          end # loop
+        rescue Exception => error
+          if @fatal_exception_callback
+            @fatal_exception_callback.call(error)
+          else
+            Logger.error "Packet reading thread unexpectedly died for #{@interface.name}"
+            OpenC3.handle_fatal_exception(error)
+          end
+        end
+        Logger.info "Stopped packet reading for #{@interface.name}"
+      end # Thread.new
+    end # def start
+
+    # Disconnect from the interface and stop the thread
+    def stop
+      @mutex.synchronize do
+        # Need to make sure that @cancel_thread is set and the interface disconnected within
+        # mutex to ensure that connect() is not called when we want to stop()
+        @cancel_thread = true
+        @thread_sleeper.cancel
+        @interface.disconnect
+      end
+      OpenC3.kill_thread(self, @thread) if @thread and @thread != Thread.current
+    end
+
+    def graceful_kill
+      # Just to avoid warning
+    end
+
+    protected
+
+    def handle_packet(packet)
+      if packet.stored
+        # Stored telemetry does not update the current value table
+        identified_packet = System.telemetry.identify_and_define_packet(packet, @interface.target_names)
+      else
+        # Identify and update packet
+        if packet.identified?
+          begin
+            # Preidentifed packet - place it into the current value table
+            identified_packet = System.telemetry.update!(packet.target_name,
+                                                         packet.packet_name,
+                                                         packet.buffer)
+          rescue RuntimeError
+            # Packet identified but we don't know about it
+            # Clear packet_name and target_name and try to identify
+            Logger.warn "Received unknown identified telemetry: #{packet.target_name} #{packet.packet_name}"
+            packet.target_name = nil
+            packet.packet_name = nil
+            identified_packet = System.telemetry.identify!(packet.buffer,
+                                                           @interface.target_names)
+          end
+        else
+          # Packet needs to be identified
+          identified_packet = System.telemetry.identify!(packet.buffer,
+                                                         @interface.target_names)
+        end
+      end
+
+      if identified_packet
+        identified_packet.received_time = packet.received_time
+        identified_packet.stored = packet.stored
+        identified_packet.extra = packet.extra
+        packet = identified_packet
+      else
+        unknown_packet = System.telemetry.update!('UNKNOWN', 'UNKNOWN', packet.buffer)
+        unknown_packet.received_time = packet.received_time
+        unknown_packet.stored = packet.stored
+        unknown_packet.extra = packet.extra
+        packet = unknown_packet
+        data_length = packet.length
+        string = "#{@interface.name} - Unknown #{data_length} byte packet starting: "
+        num_bytes_to_print = [UNKNOWN_BYTES_TO_PRINT, data_length].min
+        data_to_print = packet.buffer(false)[0..(num_bytes_to_print - 1)]
+        data_to_print.each_byte do |byte|
+          string << sprintf("%02X", byte)
+        end
+        Logger.error string
+      end
+
+      target = System.targets[packet.target_name]
+      target.tlm_cnt += 1 if target
+      packet.received_count += 1
+      @identified_packet_callback.call(packet) if @identified_packet_callback
+
+      # Write to routers
+      @interface.routers.each do |router|
+        router.write(packet) if router.write_allowed? and router.connected?
+      rescue => err
+        Logger.error "Problem writing to router #{router.name} - #{err.class}:#{err.message}"
+      end
+
+      # Write to packet log writers
+      if packet.stored and !@interface.stored_packet_log_writer_pairs.empty?
+        @interface.stored_packet_log_writer_pairs.each do |packet_log_writer_pair|
+          packet_log_writer_pair.tlm_log_writer.write(packet)
+        end
+      else
+        @interface.packet_log_writer_pairs.each do |packet_log_writer_pair|
+          # Write errors are handled by the log writer
+          packet_log_writer_pair.tlm_log_writer.write(packet)
+        end
+      end
+    end
+
+    def handle_connection_failed(connect_error)
+      if @connection_failed_callback
+        @connection_failed_callback.call(connect_error)
+      else
+        Logger.error "#{@interface.name} Connection Failed: #{connect_error.formatted(false, false)}"
+        case connect_error
+        when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::ENOTSOCK, Errno::EHOSTUNREACH, IOError
+          # Do not write an exception file for these extremely common cases
+        else
+          if RuntimeError === connect_error and (connect_error.message =~ /canceled/ or connect_error.message =~ /timeout/)
+            # Do not write an exception file for these extremely common cases
+          else
+            Logger.error connect_error.formatted
+            unless @connection_failed_messages.include?(connect_error.message)
+              OpenC3.write_exception_file(connect_error)
+              @connection_failed_messages << connect_error.message
+            end
+          end
+        end
+      end
+      disconnect()
+    end
+
+    def handle_connection_lost(err)
+      if @connection_lost_callback
+        @connection_lost_callback.call(err)
+      else
+        if err
+          Logger.info "Connection Lost for #{@interface.name}: #{err.formatted(false, false)}"
+          case err
+          when Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EBADF, Errno::ENOTSOCK, IOError
+            # Do not write an exception file for these extremely common cases
+          else
+            Logger.error err.formatted
+            unless @connection_lost_messages.include?(err.message)
+              OpenC3.write_exception_file(err)
+              @connection_lost_messages << err.message
+            end
+          end
+        else
+          Logger.info "Connection Lost for #{@interface.name}"
+        end
+      end
+      disconnect()
+    end
+
+    def connect
+      Logger.info "Connecting to #{@interface.name}..."
+      @interface.connect
+      if @connection_success_callback
+        @connection_success_callback.call
+      else
+        Logger.info "#{@interface.name} Connection Success"
+      end
+    end
+
+    def disconnect
+      @interface.disconnect
+
+      # 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.
+      if @interface.auto_reconnect
+        if !@cancel_thread
+          @thread_sleeper.sleep(@interface.reconnect_delay)
+        end
+      else
+        stop()
+      end
+    end
+  end # class InterfaceThread
+end