openc3 5.19.0 → 6.0.0

data/lib/openc3/interfaces/linc_interface.rb

@@ -1,480 +0,0 @@
-# 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
-#
-# This file may also be used under the terms of a commercial license
-# if purchased from OpenC3, Inc.
-
-require 'openc3/interfaces/tcpip_client_interface'
-require 'uuidtools'
-
-module OpenC3
-  # TODO: Deprecated ... Will remove in next major version of COSMOS (COSMOS 6)
-
-  # Interface for connecting to Ball Aerospace LINC Labview targets
-  class LincInterface < TcpipClientInterface
-    # The maximum number of asynchronous commands we can wait for at a time.
-    # We don't ever expect to get close to this but we need to limit it
-    # to ensure the Array doesn't grow out of control.
-    MAX_CONCURRENT_HANDSHAKES = 1000
-
-    def initialize(
-      hostname,
-      port,
-      handshake_enabled = true,
-      response_timeout = 5.0,
-      read_timeout = nil,
-      write_timeout = 5.0,
-      length_bitoffset = 0,
-      length_bitsize = 16,
-      length_value_offset = 4,
-      fieldname_guid = 'HDR_GUID',
-      endianness = 'BIG_ENDIAN',
-      fieldname_cmd_length = 'HDR_LENGTH'
-    )
-      # Initialize Super Class
-      super(hostname, port, port, write_timeout, read_timeout, 'LENGTH',
-        length_bitoffset, length_bitsize, length_value_offset, 1, endianness, 0, nil, nil)
-
-      # Configuration Settings
-      @handshake_enabled = ConfigParser.handle_true_false(handshake_enabled)
-      @handshake_enableds = nil
-      @response_timeout = response_timeout.to_f
-      @length_value_offset = Integer(length_value_offset)
-      @fieldname_guid = ConfigParser.handle_nil(fieldname_guid)
-      @fieldname_cmd_length = ConfigParser.handle_nil(fieldname_cmd_length)
-
-      # Other instance variables
-      @ignored_error_codes = {}
-      @handshake_cmds = []
-      @handshakes_mutex = Mutex.new
-
-      # Call this once now because the first time is slow
-      UUIDTools::UUID.random_create.raw
-    end # def initialize
-
-    def connect
-      # Packet definitions need to be retrieved here because @target_names is not filled in until after initialize
-      unless @handshake_enableds
-        @handshake_enableds = {}
-        @target_names.each do |target_name|
-          @handshake_enableds[target_name] = @handshake_enabled
-          @ignored_error_codes[target_name] = []
-        end
-      end
-      @handshake_packets = []
-      @error_packets = []
-      @error_ignore_commands = nil
-      @error_handle_commands = nil
-      @handshake_enable_commands = nil
-      @handshake_disable_commands = nil
-
-      @target_names.each do |target_name|
-        @handshake_packets << System.telemetry.packet(target_name, 'HANDSHAKE')
-        @error_packets << System.telemetry.packet(target_name, 'ERROR')
-
-        # Handle not defining the interface configuration commands (Targets may not want to support this functionality)
-        begin
-          command = System.commands.packet(target_name, 'OPENC3_ERROR_IGNORE')
-          @error_ignore_commands ||= []
-          @error_ignore_commands << command
-        rescue
-        end
-        begin
-          command = System.commands.packet(target_name, 'OPENC3_ERROR_HANDLE')
-          @error_handle_commands ||= []
-          @error_handle_commands << command
-        rescue
-        end
-        begin
-          command = System.commands.packet(target_name, 'OPENC3_HANDSHAKE_EN')
-          @handshake_enable_commands ||= []
-          @handshake_enable_commands << command
-        rescue
-        end
-        begin
-          command = System.commands.packet(target_name, 'OPENC3_HANDSHAKE_DS')
-          @handshake_disable_commands ||= []
-          @handshake_disable_commands << command
-        rescue
-        end
-      end
-
-      @handshakes_mutex.synchronize do
-        @handshake_cmds = []
-      end
-
-      # Actually connect
-      super()
-    end
-
-    def write(packet)
-      return if linc_interface_command(packet)
-      raise "Interface not connected" unless connected?()
-
-      # Add a GUID to the GUID field if its defined
-      # A GUID means it's an asynchronous packet type.
-      if @fieldname_guid
-        guid = get_guid(packet)
-      else
-        # If @fieldname_guid is not defined (synchronous) we don't care what the
-        # GUID is because we're not trying to match it up with anything.
-        # As soon as we get a response we free the command.
-        guid = 0
-      end
-
-      # Fix the length field to handle the cases where a variable length packet
-      # is defined. OpenC3 does not do this automatically.
-      update_length_field(packet) if @fieldname_cmd_length
-
-      # Always take the mutex (even if we aren't handshaking)
-      # We do not want any incoming telemetry to be missed because
-      # it could be the handshake to this command.
-      @handshakes_mutex.synchronize do
-        super(packet) # Send the command
-        wait_for_response(packet, guid) if @handshake_enableds[packet.target_name]
-      end
-    end
-
-    def linc_interface_command(packet)
-      if @error_ignore_commands
-        @error_ignore_commands.each do |error_ignore_command|
-          if error_ignore_command.identify?(packet.buffer(false))
-            linc_cmd = error_ignore_command.clone
-            linc_cmd.buffer = packet.buffer
-            code = linc_cmd.read('CODE')
-            @ignored_error_codes[error_ignore_command.target_name] << code unless @ignored_error_codes[error_ignore_command.target_name].include? code
-            return true
-          end
-        end
-      end
-
-      if @error_handle_commands
-        @error_handle_commands.each do |error_handle_command|
-          if error_handle_command.identify?(packet.buffer(false))
-            linc_cmd = error_handle_command.clone
-            linc_cmd.buffer = packet.buffer
-            code = linc_cmd.read('CODE')
-            @ignored_error_codes[error_handle_command.target_name].delete(code) if @ignored_error_codes[error_handle_command.target_name].include? code
-            return true
-          end
-        end
-      end
-
-      if @handshake_enable_commands
-        @handshake_enable_commands.each do |handshake_enable_command|
-          if handshake_enable_command.identify?(packet.buffer(false))
-            @handshake_enabled = true
-            @handshake_enableds[handshake_enable_command.target_name] = true
-            return true
-          end
-        end
-      end
-
-      if @handshake_disable_commands
-        @handshake_disable_commands.each do |handshake_disable_command|
-          if handshake_disable_command.identify?(packet.buffer(false))
-            @handshake_enabled = false
-            @handshake_enableds[handshake_disable_command.target_name] = false
-            return true
-          end
-        end
-      end
-
-      return false
-    end
-
-    def get_guid(packet)
-      if not packet.read(@fieldname_guid) =~ /[\x01-\xFF]/
-        # The GUID has not been set already (it has all \x00 values), so make a new one.
-        # This enables a router GUI to make the GUIDs so it can process handshakes too.
-        guid = UUIDTools::UUID.random_create.raw
-        packet.write(@fieldname_guid, guid, :RAW)
-      else
-        guid = packet.read(@fieldname_guid)
-      end
-      return guid
-    end
-
-    def update_length_field(packet)
-      length = packet.length - @length_value_offset
-      packet.write(@fieldname_cmd_length, length, :RAW)
-    end
-
-    def wait_for_response(packet, guid)
-      # Check the number of commands waiting for handshakes.  This is just for sanity
-      # If the number of commands waiting for handshakes is very large then it can't be real
-      # So raise an error.  Something has gone horribly wrong.
-      if @handshake_cmds.length > MAX_CONCURRENT_HANDSHAKES
-        len = @handshake_cmds.length
-        @handshake_cmds = []
-        raise "The number of commands waiting for handshakes to #{len}. Clearing all commands!"
-      end
-
-      # Create a handshake command object and add it to the list of commands waiting
-      handshake_cmd = LincHandshakeCommand.new(@handshakes_mutex, guid)
-      @handshake_cmds.push(handshake_cmd)
-
-      # wait for that handshake. This releases the mutex so that the telemetry and other commands can start running again.
-      timed_out = handshake_cmd.wait_for_handshake(@response_timeout)
-      # We now have the mutex again.  This interface is blocked for the rest of the command handling,
-      # which should be quick because it's just checking variables and logging.
-      # We want to hold the mutex during that so that the commands get logged in order of handshake from here.
-
-      if timed_out
-        # Clean this command out of the array of items that require handshakes.
-        @handshake_cmds.delete_if { |hsc| hsc == handshake_cmd }
-        raise "Timeout waiting for handshake from #{System.commands.format(packet, System.targets[packet.target_name].ignored_parameters)}"
-      end
-
-      process_handshake_results(handshake_cmd)
-    rescue Exception => e
-      # If anything goes wrong after successfully writing the packet to the LINC target
-      # ensure that the packet gets updated in the CVT and logged to the packet log writer.
-      # OpenC3 normally only does this if write returns successfully
-      if packet.identified?
-        command = System.commands.packet(packet.target_name, packet.packet_name)
-      else
-        command = System.commands.packet('UNKNOWN', 'UNKNOWN')
-      end
-      command.buffer = packet.buffer
-
-      @packet_log_writer_pairs.each do |packet_log_writer_pair|
-        packet_log_writer_pair.cmd_log_writer.write(packet)
-      end
-
-      raise e
-    end
-
-    def process_handshake_results(handshake_cmd)
-      status = handshake_cmd.handshake.handshake.read('STATUS')
-      code = handshake_cmd.handshake.handshake.read('CODE')
-      source = handshake_cmd.handshake.error_source
-
-      # Handle handshake warnings and errors
-      if status == "OK" and code != 0
-        unless @ignored_error_codes[handshake_cmd.handshake.handshake.target_name].include? code
-          Logger.warn "#{@name}: Warning sending command (#{code}): #{source}"
-        end
-      elsif status == "ERROR"
-        unless @ignored_error_codes[handshake_cmd.handshake.handshake.target_name].include? code
-          raise "Error sending command (#{code}): #{source}"
-        end
-      end
-    end
-
-    def read
-      packet = super()
-      if packet
-        @handshake_packets.each do |handshake_packet|
-          if handshake_packet.identify?(packet.buffer(false))
-            handshake_packet = handshake_packet.clone
-            handshake_packet.buffer = packet.buffer
-            linc_handshake = LincHandshake.new(handshake_packet, handshake_packet.target_name)
-
-            # Check for a local handshake
-            if handshake_packet.read('origin') == "LCL"
-              handle_local_handshake(linc_handshake)
-            else
-              handle_remote_handshake(linc_handshake) if @handshake_enableds[handshake_packet.target_name]
-            end # if handshake_packet.read('origin') == "LCL"
-          end # @handshake_packet.identify?(packet.buffer(false))
-        end
-      end # if packet
-
-      return packet
-    end
-
-    def handle_local_handshake(linc_handshake)
-      # Update the current value table for this command
-      command = System.commands.packet(linc_handshake.identified_command.target_name, linc_handshake.identified_command.packet_name)
-      command.received_time = linc_handshake.identified_command.received_time
-      command.buffer = linc_handshake.identified_command.buffer
-      command.received_count += 1
-
-      # Put a log of the command onto the server for the user to see
-      Logger.info("#{@name}: External Command: " + System.commands.format(linc_handshake.identified_command, System.targets[linc_handshake.identified_command.target_name].ignored_parameters))
-
-      # Log the command to the command log(s)
-      @packet_log_writer_pairs.each do |packet_log_writer_pair|
-        packet_log_writer_pair.cmd_log_writer.write(linc_handshake.identified_command)
-      end
-    end
-
-    def handle_remote_handshake(linc_handshake)
-      # This is a remote packet (sent from here).
-      # Add to the array of handshake packet responses
-      # The mutex is required by the command task due to the way it
-      # first looks up the handshake before removing it.
-      @handshakes_mutex.synchronize do
-        if @fieldname_guid
-          # A GUID means it's an asynchronous packet type.
-          # So look at the list of incoming handshakes and pick off (deleting)
-          # the handshake from the list if it's for this command.
-          #
-          # The mutex is required because the telemetry task
-          # could enqueue a response between the index lookup and the slice
-          # function which would remove the wrong response. FAIL!
-
-          # Loop through all waiting commands to see if this handshake belongs to them
-          this_handshake_guid = linc_handshake.get_cmd_guid(@fieldname_guid)
-          handshake_cmd_index = @handshake_cmds.index { |hsc| hsc.get_cmd_guid == this_handshake_guid }
-
-          # If command was waiting (ie the loop above found one), then remove it from waiters and signal it
-          if handshake_cmd_index
-            handshake_cmd = @handshake_cmds.slice!(handshake_cmd_index)
-            handshake_cmd.got_your_handshake(linc_handshake)
-          else
-            # No command match found!  Either it gave up and timed out or this wasn't originated from here.
-            # Ignore this typically.  This case here for clarity.
-          end
-
-        else
-          # Synchronous version: just pop the array (pull the command off) and send it the handshake
-          handshake_cmd = @handshakes_cmds.pop
-          handshake_cmd.got_your_handshake(linc_handshake)
-        end # of handshaking type check
-      end
-    end
-  end # class LincInterface
-
-  # The LincHandshakeCommand class is used only by the LincInterface.
-  # It is the command with other required items that is passed to the telemetry
-  # thread so it can match it with the handshake.
-  class LincHandshakeCommand
-    attr_accessor :handshake
-
-    def initialize(handshakes_mutex, cmd_guid)
-      @cmd_guid = cmd_guid
-      @handshakes_mutex = handshakes_mutex
-      @resource = ConditionVariable.new
-      @handshake = nil
-    end
-
-    def wait_for_handshake(response_timeout)
-      timed_out = false
-
-      @resource.wait(@handshakes_mutex, response_timeout)
-      if @handshake
-        timed_out = false
-      else
-        Logger.warn "#{@name}: No handshake - must be timeout."
-        timed_out = true
-      end
-
-      return timed_out
-    end
-
-    def got_your_handshake(handshake)
-      @handshake = handshake
-      @resource.signal
-    end
-
-    def get_cmd_guid
-      return @cmd_guid
-    end
-  end # class LincHandshakeCommand
-
-  # The LincHandshake class is used only by the LincInterface. It processes the handshake and
-  # helps with finding the information regarding the internal command.
-  class LincHandshake
-    attr_accessor :handshake
-    attr_accessor :identified_command
-    attr_accessor :error_source
-
-    def initialize(handshake, interface_target_name)
-      @handshake = handshake
-
-      # Interpret the command field of the handshake packet
-      # Where DATA is defined as:
-      # 1 byte target name length
-      # X byte target name
-      # 1 byte packet name length
-      # X byte packet name
-      # 4 byte packet data length
-      # X byte packet data
-      # 4 byte error source length
-      # X byte error source
-      data = handshake.read('DATA')
-      raise "Data field too short for target name length" if data.length == 0
-
-      # Get target name length
-      target_name_length = data[0..0].unpack('C')[0]
-      raise "Invalid target name length" if target_name_length == 0
-
-      data = data[1..-1]
-
-      # get target name
-      raise "Data field too short for target name" if data.length < target_name_length
-
-      # target_name = data[0..(target_name_length - 1)] # Unused
-      data = data[target_name_length..-1]
-
-      # get packet name length
-      raise "Data field too short for packet name length" if data.length == 0
-
-      packet_name_length = data[0..0].unpack('C')[0]
-      raise "Invalid packet name length" if packet_name_length == 0
-
-      data = data[1..-1]
-
-      # get packet name
-      raise "Data field too short for packet name" if data.length < packet_name_length
-
-      packet_name = data[0..(packet_name_length - 1)]
-      data = data[packet_name_length..-1]
-
-      # get packet data length
-      raise "Data field too short for packet data length" if data.length < 4
-
-      packet_data_length = data[0..3].unpack('N')[0]
-      raise "Invalid data length" if packet_data_length == 0
-
-      data = data[4..-1]
-
-      # get packet data
-      raise "Data field too short for packet data" if data.length < packet_data_length
-
-      packet_data = data[0..(packet_data_length - 1)]
-      data = data[packet_data_length..-1]
-
-      # get error source length
-      raise "Data field too short for error source length" if data.length < 4
-
-      error_source_length = data[0..3].unpack('N')[0]
-      # note it is OK to have a 0 source length
-      data = data[4..-1]
-
-      # get error source - store on object
-      if error_source_length > 0
-        @error_source = data[0..(error_source_length - 1)]
-      else
-        @error_source = ''
-      end
-
-      # make packet - store on object as a defined packet of type command that this handshakes
-      @identified_command = System.commands.packet(interface_target_name, packet_name).clone
-      @identified_command.buffer = packet_data
-      @identified_command.received_time = Time.at(handshake.read('TIME_SECONDS'), handshake.read('TIME_MICROSECONDS')).sys
-    end
-
-    def get_cmd_guid(fieldname_guid)
-      return @identified_command.read(fieldname_guid)
-    end
-  end
-end

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

@@ -1,4 +0,0 @@
-# encoding: ascii-8bit
-
-# This class is deprecated and this file exists only to satisfy existing code requiring it
-# TODO: Remove this in a future release