cosmos 3.0.1 → 3.1.0

data/lib/cosmos/interfaces/interface.rb

@@ -1,213 +1,213 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/tools/cmd_tlm_server/api'
-require 'cosmos/io/raw_logger_pair'
-
-module Cosmos
-
-  # Defines all the attributes and methods common to all interface classes
-  # used by COSMOS.
-  class Interface
-
-    include Api
-
-    # @return [String] Name of the interface
-    attr_reader :name
-
-    # @return [Array<String>] Array of target names associated with this interface
-    attr_accessor :target_names
-
-    # @return [Thread] Thread reading from the interface
-    attr_accessor :thread
-
-    # @return [Boolean] Flag indicating if the interface should be connected
-    #   to on startup
-    attr_accessor :connect_on_startup
-
-    # @return [Boolean] Flag indicating if the interface should automatically
-    #   reconnect after losing connection
-    attr_accessor :auto_reconnect
-
-    # @return [Integer[ Delay between reconnect attempts
-    attr_accessor :reconnect_delay
-
-    # @return [Boolean] Flag indicating if the user is allowed to disconnect
-    #   this interface
-    attr_accessor :disable_disconnect
-
-    # @return [Array] Array of packet logger classes for this interface
-    attr_accessor :packet_log_writer_pairs
-
-    # @return [RawLoggerPair] RawLoggerPair instance or nil
-    attr_accessor :raw_logger_pair
-
-    # @return [Array<Routers>] Array of routers that receive packets
-    #   read from the interface
-    attr_accessor :routers
-
-    # @return [Integer] The number of packets read from this interface
-    attr_accessor :read_count
-
-    # @return [Integer] The number of packets written to this interface
-    attr_accessor :write_count
-
-    # @return [Integer] The number of bytes read from this interface
-    attr_accessor :bytes_read
-
-    # @return [Integer] The number of bytes written to this interface
-    attr_accessor :bytes_written
-
-    # @return [Integer] The number of active clients
-    #   (when used as a Router)
-    attr_accessor :num_clients
-
-    # @return [Integer] The number of packets in the read queue
-    #   (when used as a Router)
-    attr_accessor :read_queue_size
-
-    # @return [Integer] The number of packets in the write queue
-    #   (when used as a Router)
-    attr_accessor :write_queue_size
-
-    # @return [Array<Interface>] Array of interfaces to route packets to
-    #   (when used as a Router)
-    attr_accessor :interfaces
-
-    # Initialize default attribute values
-    def initialize
-      @name = self.class.to_s
-      @target_names = []
-      @thread = nil
-      @connect_on_startup = true
-      @auto_reconnect = true
-      @reconnect_delay = 5.0
-      @disable_disconnect = false
-      @packet_log_writer_pairs = []
-      @raw_logger_pair = RawLoggerPair.new(@name)
-      @routers = []
-      @read_count = 0
-      @write_count = 0
-      @bytes_read = 0
-      @bytes_written = 0
-      @num_clients = 0
-      @read_queue_size = 0
-      @write_queue_size = 0
-      @interfaces = []
-      @read_allowed = true
-      @write_allowed = true
-      @write_raw_allowed = true
-    end
-
-    # Connects the interface to its target(s). Must be implemented by a
-    # subclass.
-    def connect
-      raise "Interface connect method not implemented"
-    end
-
-    # Indicates if the interface is connected to its target(s) or not. Must be
-    # implemented by a subclass.
-    def connected?
-      raise "Interface connected? method not implemented"
-    end
-
-    # Disconnects the interface from its target(s). Must be implemented by a
-    # subclass.
-    def disconnect
-      raise "Interface disconnect method not implemented"
-    end
-
-    # Retrieves the next packet from the interface. Must be implemented by a
-    # subclass.
-    def read
-      raise "Interface read method not implemented"
-    end
-
-    # Method to send a packet on the interface. Must be implemented by a
-    # subclass.
-    def write(packet)
-      raise "Interface write method not implemented"
-    end
-
-    # Writes preformatted data onto the interface. Malformed data may cause
-    # problems. Must be implemented by a subclass.
-    def write_raw(data)
-      raise "Interface write_raw method not implemented"
-    end
-
-    # @return [Boolean] Whether reading is allowed
-    def read_allowed?
-      @read_allowed
-    end
-
-    # @return [Boolean] Whether writing is allowed
-    def write_allowed?
-      @write_allowed
-    end
-
-    # @return [Boolean] Whether writing raw data over the interface is allowed
-    def write_raw_allowed?
-      @write_raw_allowed
-    end
-
-    # Start raw logging for this interface
-    def start_raw_logging
-      @raw_logger_pair.start if @raw_logger_pair
-    end
-
-    # Stop raw logging for this interface
-    def stop_raw_logging
-      @raw_logger_pair.stop if @raw_logger_pair
-    end
-
-    # Set the interface name
-    def name=(name)
-      @name = name.to_s.clone
-      @raw_logger_pair.name = name if @raw_logger_pair
-    end
-
-    # Copy settings from this interface to another interface. All instance
-    # variables are copied except for thread, num_clients, read_queue_size,
-    # and write_queue_size since these are all specific to the operation of the
-    # interface rather than its instantiation.
-    #
-    # @param other_interface [Interface] The other interface to copy to
-    def copy_to(other_interface)
-      other_interface.name = self.name.clone
-      other_interface.target_names = self.target_names.clone
-      # The other interface has its own Thread
-      other_interface.connect_on_startup = self.connect_on_startup
-      other_interface.auto_reconnect = self.auto_reconnect
-      other_interface.reconnect_delay = self.reconnect_delay
-      other_interface.disable_disconnect = self.disable_disconnect
-      other_interface.packet_log_writer_pairs = self.packet_log_writer_pairs.clone
-      other_interface.routers = self.routers.clone
-      other_interface.read_count = self.read_count
-      other_interface.write_count = self.write_count
-      other_interface.bytes_read = self.bytes_read
-      other_interface.bytes_written = self.bytes_written
-      other_interface.raw_logger_pair = self.raw_logger_pair.clone if self.raw_logger_pair
-      # num_clients is per interface so don't copy
-      # read_queue_size is the number of packets in the queue so don't copy
-      # write_queue_size is the number of packets in the queue so don't copy
-      other_interface.interfaces = self.interfaces.clone
-    end
-
-    # This method is called by the CmdTlmServer after each read packet is
-    # identified. It can be used to perform custom processing/monitoring as
-    # each packet is received by the CmdTlmServer.
-    #
-    # @param packet [Packet] The identified packet read from the interface
-    def post_identify_packet(packet)
-    end
-
-  end # class Interface
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/tools/cmd_tlm_server/api'
+require 'cosmos/io/raw_logger_pair'
+
+module Cosmos
+
+  # Defines all the attributes and methods common to all interface classes
+  # used by COSMOS.
+  class Interface
+
+    include Api
+
+    # @return [String] Name of the interface
+    attr_reader :name
+
+    # @return [Array<String>] Array of target names associated with this interface
+    attr_accessor :target_names
+
+    # @return [Thread] Thread reading from the interface
+    attr_accessor :thread
+
+    # @return [Boolean] Flag indicating if the interface should be connected
+    #   to on startup
+    attr_accessor :connect_on_startup
+
+    # @return [Boolean] Flag indicating if the interface should automatically
+    #   reconnect after losing connection
+    attr_accessor :auto_reconnect
+
+    # @return [Integer[ Delay between reconnect attempts
+    attr_accessor :reconnect_delay
+
+    # @return [Boolean] Flag indicating if the user is allowed to disconnect
+    #   this interface
+    attr_accessor :disable_disconnect
+
+    # @return [Array] Array of packet logger classes for this interface
+    attr_accessor :packet_log_writer_pairs
+
+    # @return [RawLoggerPair] RawLoggerPair instance or nil
+    attr_accessor :raw_logger_pair
+
+    # @return [Array<Routers>] Array of routers that receive packets
+    #   read from the interface
+    attr_accessor :routers
+
+    # @return [Integer] The number of packets read from this interface
+    attr_accessor :read_count
+
+    # @return [Integer] The number of packets written to this interface
+    attr_accessor :write_count
+
+    # @return [Integer] The number of bytes read from this interface
+    attr_accessor :bytes_read
+
+    # @return [Integer] The number of bytes written to this interface
+    attr_accessor :bytes_written
+
+    # @return [Integer] The number of active clients
+    #   (when used as a Router)
+    attr_accessor :num_clients
+
+    # @return [Integer] The number of packets in the read queue
+    #   (when used as a Router)
+    attr_accessor :read_queue_size
+
+    # @return [Integer] The number of packets in the write queue
+    #   (when used as a Router)
+    attr_accessor :write_queue_size
+
+    # @return [Array<Interface>] Array of interfaces to route packets to
+    #   (when used as a Router)
+    attr_accessor :interfaces
+
+    # Initialize default attribute values
+    def initialize
+      @name = self.class.to_s
+      @target_names = []
+      @thread = nil
+      @connect_on_startup = true
+      @auto_reconnect = true
+      @reconnect_delay = 5.0
+      @disable_disconnect = false
+      @packet_log_writer_pairs = []
+      @raw_logger_pair = RawLoggerPair.new(@name)
+      @routers = []
+      @read_count = 0
+      @write_count = 0
+      @bytes_read = 0
+      @bytes_written = 0
+      @num_clients = 0
+      @read_queue_size = 0
+      @write_queue_size = 0
+      @interfaces = []
+      @read_allowed = true
+      @write_allowed = true
+      @write_raw_allowed = true
+    end
+
+    # Connects the interface to its target(s). Must be implemented by a
+    # subclass.
+    def connect
+      raise "Interface connect method not implemented"
+    end
+
+    # Indicates if the interface is connected to its target(s) or not. Must be
+    # implemented by a subclass.
+    def connected?
+      raise "Interface connected? method not implemented"
+    end
+
+    # Disconnects the interface from its target(s). Must be implemented by a
+    # subclass.
+    def disconnect
+      raise "Interface disconnect method not implemented"
+    end
+
+    # Retrieves the next packet from the interface. Must be implemented by a
+    # subclass.
+    def read
+      raise "Interface read method not implemented"
+    end
+
+    # Method to send a packet on the interface. Must be implemented by a
+    # subclass.
+    def write(packet)
+      raise "Interface write method not implemented"
+    end
+
+    # Writes preformatted data onto the interface. Malformed data may cause
+    # problems. Must be implemented by a subclass.
+    def write_raw(data)
+      raise "Interface write_raw method not implemented"
+    end
+
+    # @return [Boolean] Whether reading is allowed
+    def read_allowed?
+      @read_allowed
+    end
+
+    # @return [Boolean] Whether writing is allowed
+    def write_allowed?
+      @write_allowed
+    end
+
+    # @return [Boolean] Whether writing raw data over the interface is allowed
+    def write_raw_allowed?
+      @write_raw_allowed
+    end
+
+    # Start raw logging for this interface
+    def start_raw_logging
+      @raw_logger_pair.start if @raw_logger_pair
+    end
+
+    # Stop raw logging for this interface
+    def stop_raw_logging
+      @raw_logger_pair.stop if @raw_logger_pair
+    end
+
+    # Set the interface name
+    def name=(name)
+      @name = name.to_s.clone
+      @raw_logger_pair.name = name if @raw_logger_pair
+    end
+
+    # Copy settings from this interface to another interface. All instance
+    # variables are copied except for thread, num_clients, read_queue_size,
+    # and write_queue_size since these are all specific to the operation of the
+    # interface rather than its instantiation.
+    #
+    # @param other_interface [Interface] The other interface to copy to
+    def copy_to(other_interface)
+      other_interface.name = self.name.clone
+      other_interface.target_names = self.target_names.clone
+      # The other interface has its own Thread
+      other_interface.connect_on_startup = self.connect_on_startup
+      other_interface.auto_reconnect = self.auto_reconnect
+      other_interface.reconnect_delay = self.reconnect_delay
+      other_interface.disable_disconnect = self.disable_disconnect
+      other_interface.packet_log_writer_pairs = self.packet_log_writer_pairs.clone
+      other_interface.routers = self.routers.clone
+      other_interface.read_count = self.read_count
+      other_interface.write_count = self.write_count
+      other_interface.bytes_read = self.bytes_read
+      other_interface.bytes_written = self.bytes_written
+      other_interface.raw_logger_pair = self.raw_logger_pair.clone if self.raw_logger_pair
+      # num_clients is per interface so don't copy
+      # read_queue_size is the number of packets in the queue so don't copy
+      # write_queue_size is the number of packets in the queue so don't copy
+      other_interface.interfaces = self.interfaces.clone
+    end
+
+    # This method is called by the CmdTlmServer after each read packet is
+    # identified. It can be used to perform custom processing/monitoring as
+    # each packet is received by the CmdTlmServer.
+    #
+    # @param packet [Packet] The identified packet read from the interface
+    def post_identify_packet(packet)
+    end
+
+  end # class Interface
+
+end # module Cosmos

data/lib/cosmos/interfaces/linc_interface.rb

@@ -1,360 +1,360 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/interfaces/tcpip_client_interface'
-require 'uuidtools'
-
-module Cosmos
-
-  # Interface for connecting to Ball Aerospace LINC Labview targets
-  class LincInterface < TcpipClientInterface
-    # The maximum number of handshake responses 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 = 100
-
-    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)
-      @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 = []
-      @handshakes = []
-      @handshakes_mutex = Mutex.new
-      @handshakes_resource = ConditionVariable.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
-      @handshake_packet = System.telemetry.packet(@target_names[0], 'HANDSHAKE')
-      @error_packet = System.telemetry.packet(@target_names[0], 'ERROR')
-
-      # Handle not defining the interface configuration commands (May not want to support this functionality)
-      begin
-        @error_ignore_command = nil
-        @error_ignore_command = System.commands.packet(@target_names[0], 'COSMOS_ERROR_IGNORE')
-      rescue
-      end
-      begin
-        @error_handle_command = nil
-        @error_handle_command = System.commands.packet(@target_names[0], 'COSMOS_ERROR_HANDLE')
-      rescue
-      end
-      begin
-        @handshake_enable_command = nil
-        @handshake_enable_command = System.commands.packet(@target_names[0], 'COSMOS_HANDSHAKE_EN')
-      rescue
-      end
-      begin
-        @handshake_disable_command = nil
-        @handshake_disable_command = System.commands.packet(@target_names[0], 'COSMOS_HANDSHAKE_DS')
-      rescue
-      end
-
-      @handshakes_mutex.synchronize do
-        @handshakes = []
-      end
-
-      # Actually connect
-      super()
-    end
-
-    def write(packet)
-      ######################################
-      # Commands handled in the COSMOS interface not the LINC target
-      ######################################
-
-      if @error_ignore_command and @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 << code unless @ignored_error_codes.include? code
-        return
-      end
-
-      if @error_handle_command and @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.delete(code) if @ignored_error_codes.include? code
-        return
-      end
-
-      if @handshake_enable_command and @handshake_enable_command.identify?(packet.buffer(false))
-        @handshake_enabled = true
-        return
-      end
-
-      if @handshake_disable_command and @handshake_disable_command.identify?(packet.buffer(false))
-        @handshake_enabled = false
-        return
-      end
-
-      # Verify we are connected to the LINC target
-      if connected?()
-        # Add a GUID to the GUID field if its defined
-        if @fieldname_guid
-          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.
-            my_guid = UUIDTools::UUID.random_create.raw
-            packet.write(@fieldname_guid, my_guid, :RAW)
-          else
-            my_guid = packet.read(@fieldname_guid)
-          end
-        end
-
-        # Fix the length field to handle the cases where a variable length packet
-        # is defined. COSMOS does not do this automatically.
-        if @fieldname_cmd_length
-          my_length = packet.length - @length_value_offset
-          packet.write(@fieldname_cmd_length, my_length, :RAW)
-        end
-
-        # Always take the mutex (even if we aren't handshaking)
-        @handshakes_mutex.synchronize do
-
-          # Send the command
-          super(packet)
-
-          # Wait for the response if handshaking
-          if @handshake_enabled
-            begin
-              my_handshake = nil
-
-              # The time after which we will give up waiting for a response
-              deadline = Time.now + @response_timeout
-
-              # Loop until we find our response
-              while my_handshake.nil?
-                # How long should we wait in this loop. We could get notified
-                # multiple times for handshakes that aren't ours so we need to
-                # recalculate the wait time each time.
-                to_wait = deadline - Time.now
-
-                # If there is no more time to wait then this is a timeout so we break
-                # out of the loop looking for handshakes
-                if to_wait <= 0
-                  raise "Timeout waiting for handshake from #{System.commands.format(packet, System.targets[@target_names[0]].ignored_parameters)}"
-                end
-
-                # Wait until the telemetry side signals that there is a new handshake to check or timeout.
-                # This releases the mutex until the telemetry side signals us
-                @handshakes_resource.wait(@handshakes_mutex, to_wait)
-                # We now have the mutex again
-
-                # Loop if we have timed out so we can handle the timeout with common code
-                next if (deadline - Time.now) <= 0
-
-                if @fieldname_guid
-                  # A GUID means it's an asychronous 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!
-                  my_handshake_index = @handshakes.index {|hs| hs.get_cmd_guid(@fieldname_guid) == my_guid}
-                  my_handshake = @handshakes.slice!(my_handshake_index) if my_handshake_index
-                else
-                  # This is the synchronous version
-                  my_handshake = @handshakes.pop
-                end
-              end # while my_handshake.nil?
-
-              # Handle handshake warnings and errors
-              if my_handshake.handshake.read('STATUS') == "OK" and my_handshake.handshake.read('CODE') != 0
-                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
-                  Logger.warn "Warning sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
-                end
-              elsif my_handshake.handshake.read('STATUS') == "ERROR"
-                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
-                  raise "Error sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
-                end
-              end
-            rescue Exception => err
-              # 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.
-              # COSMOS 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 err
-            end
-          end # if @handshake_enabled
-        end # @handshakes_mutex.synchronize
-      else
-        raise "Interface not connected"
-      end # if connected
-
-    end # def write
-
-    def read
-      packet = super()
-      if packet
-        if @handshake_packet.identify?(packet.buffer(false))
-          handshake_packet = @handshake_packet.clone
-          handshake_packet.buffer = packet.buffer
-          my_handshake = LincHandshake.new(handshake_packet, @target_names[0])
-
-          if handshake_packet.read('origin') == "LCL"
-            # Update the current value table for this command
-            command = System.commands.packet(my_handshake.identified_command.target_name, my_handshake.identified_command.packet_name)
-            command.received_time = my_handshake.identified_command.received_time
-            command.buffer = my_handshake.identified_command.buffer
-            command.received_count += 1
-
-            # Put a log of the command onto the server for the user to see
-            Logger.info("External Command: " + System.commands.format(my_handshake.identified_command, System.targets[@target_names[0]].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(my_handshake.identified_command)
-            end
-          else
-            # This is a remote packet (sent from here).
-            # Add to the array of handshake packet responses (only if handshakes are enabled).
-            # The mutex is required by the command task due to the way it
-            # first looks up the handshake before removing it.
-            if @handshake_enabled
-              @handshakes_mutex.synchronize do
-                @handshakes.push(my_handshake)
-                if @handshakes.length > MAX_CONCURRENT_HANDSHAKES
-                  len = @handshakes.length
-                  @handshakes = []
-                  raise "The handshakes response array has grown to #{len}. Clearing all handshakes!"
-                end
-                # Tell all waiting commands to take a look
-                @handshakes_resource.broadcast
-              end # @handshakes_mutex.synchronize
-            end # if @handshake_enabled
-
-          end # if handshake_packet.read('origin') == "LCL"
-        end # @handshake_packet.identify?(packet.buffer(false))
-      end # if packet
-
-      return packet
-    end
-
-  end # class LincInterface
-
-  # 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'))
-    end
-
-    def get_cmd_guid(fieldname_guid)
-      return @identified_command.read(fieldname_guid)
-    end
-
-  end  # class LincHandshake
-
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/interfaces/tcpip_client_interface'
+require 'uuidtools'
+
+module Cosmos
+
+  # Interface for connecting to Ball Aerospace LINC Labview targets
+  class LincInterface < TcpipClientInterface
+    # The maximum number of handshake responses 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 = 100
+
+    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)
+      @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 = []
+      @handshakes = []
+      @handshakes_mutex = Mutex.new
+      @handshakes_resource = ConditionVariable.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
+      @handshake_packet = System.telemetry.packet(@target_names[0], 'HANDSHAKE')
+      @error_packet = System.telemetry.packet(@target_names[0], 'ERROR')
+
+      # Handle not defining the interface configuration commands (May not want to support this functionality)
+      begin
+        @error_ignore_command = nil
+        @error_ignore_command = System.commands.packet(@target_names[0], 'COSMOS_ERROR_IGNORE')
+      rescue
+      end
+      begin
+        @error_handle_command = nil
+        @error_handle_command = System.commands.packet(@target_names[0], 'COSMOS_ERROR_HANDLE')
+      rescue
+      end
+      begin
+        @handshake_enable_command = nil
+        @handshake_enable_command = System.commands.packet(@target_names[0], 'COSMOS_HANDSHAKE_EN')
+      rescue
+      end
+      begin
+        @handshake_disable_command = nil
+        @handshake_disable_command = System.commands.packet(@target_names[0], 'COSMOS_HANDSHAKE_DS')
+      rescue
+      end
+
+      @handshakes_mutex.synchronize do
+        @handshakes = []
+      end
+
+      # Actually connect
+      super()
+    end
+
+    def write(packet)
+      ######################################
+      # Commands handled in the COSMOS interface not the LINC target
+      ######################################
+
+      if @error_ignore_command and @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 << code unless @ignored_error_codes.include? code
+        return
+      end
+
+      if @error_handle_command and @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.delete(code) if @ignored_error_codes.include? code
+        return
+      end
+
+      if @handshake_enable_command and @handshake_enable_command.identify?(packet.buffer(false))
+        @handshake_enabled = true
+        return
+      end
+
+      if @handshake_disable_command and @handshake_disable_command.identify?(packet.buffer(false))
+        @handshake_enabled = false
+        return
+      end
+
+      # Verify we are connected to the LINC target
+      if connected?()
+        # Add a GUID to the GUID field if its defined
+        if @fieldname_guid
+          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.
+            my_guid = UUIDTools::UUID.random_create.raw
+            packet.write(@fieldname_guid, my_guid, :RAW)
+          else
+            my_guid = packet.read(@fieldname_guid)
+          end
+        end
+
+        # Fix the length field to handle the cases where a variable length packet
+        # is defined. COSMOS does not do this automatically.
+        if @fieldname_cmd_length
+          my_length = packet.length - @length_value_offset
+          packet.write(@fieldname_cmd_length, my_length, :RAW)
+        end
+
+        # Always take the mutex (even if we aren't handshaking)
+        @handshakes_mutex.synchronize do
+
+          # Send the command
+          super(packet)
+
+          # Wait for the response if handshaking
+          if @handshake_enabled
+            begin
+              my_handshake = nil
+
+              # The time after which we will give up waiting for a response
+              deadline = Time.now + @response_timeout
+
+              # Loop until we find our response
+              while my_handshake.nil?
+                # How long should we wait in this loop. We could get notified
+                # multiple times for handshakes that aren't ours so we need to
+                # recalculate the wait time each time.
+                to_wait = deadline - Time.now
+
+                # If there is no more time to wait then this is a timeout so we break
+                # out of the loop looking for handshakes
+                if to_wait <= 0
+                  raise "Timeout waiting for handshake from #{System.commands.format(packet, System.targets[@target_names[0]].ignored_parameters)}"
+                end
+
+                # Wait until the telemetry side signals that there is a new handshake to check or timeout.
+                # This releases the mutex until the telemetry side signals us
+                @handshakes_resource.wait(@handshakes_mutex, to_wait)
+                # We now have the mutex again
+
+                # Loop if we have timed out so we can handle the timeout with common code
+                next if (deadline - Time.now) <= 0
+
+                if @fieldname_guid
+                  # A GUID means it's an asychronous 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!
+                  my_handshake_index = @handshakes.index {|hs| hs.get_cmd_guid(@fieldname_guid) == my_guid}
+                  my_handshake = @handshakes.slice!(my_handshake_index) if my_handshake_index
+                else
+                  # This is the synchronous version
+                  my_handshake = @handshakes.pop
+                end
+              end # while my_handshake.nil?
+
+              # Handle handshake warnings and errors
+              if my_handshake.handshake.read('STATUS') == "OK" and my_handshake.handshake.read('CODE') != 0
+                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
+                  Logger.warn "Warning sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
+                end
+              elsif my_handshake.handshake.read('STATUS') == "ERROR"
+                unless @ignored_error_codes.include? my_handshake.handshake.read('CODE')
+                  raise "Error sending command (#{my_handshake.handshake.read('CODE')}): #{my_handshake.error_source}"
+                end
+              end
+            rescue Exception => err
+              # 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.
+              # COSMOS 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 err
+            end
+          end # if @handshake_enabled
+        end # @handshakes_mutex.synchronize
+      else
+        raise "Interface not connected"
+      end # if connected
+
+    end # def write
+
+    def read
+      packet = super()
+      if packet
+        if @handshake_packet.identify?(packet.buffer(false))
+          handshake_packet = @handshake_packet.clone
+          handshake_packet.buffer = packet.buffer
+          my_handshake = LincHandshake.new(handshake_packet, @target_names[0])
+
+          if handshake_packet.read('origin') == "LCL"
+            # Update the current value table for this command
+            command = System.commands.packet(my_handshake.identified_command.target_name, my_handshake.identified_command.packet_name)
+            command.received_time = my_handshake.identified_command.received_time
+            command.buffer = my_handshake.identified_command.buffer
+            command.received_count += 1
+
+            # Put a log of the command onto the server for the user to see
+            Logger.info("External Command: " + System.commands.format(my_handshake.identified_command, System.targets[@target_names[0]].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(my_handshake.identified_command)
+            end
+          else
+            # This is a remote packet (sent from here).
+            # Add to the array of handshake packet responses (only if handshakes are enabled).
+            # The mutex is required by the command task due to the way it
+            # first looks up the handshake before removing it.
+            if @handshake_enabled
+              @handshakes_mutex.synchronize do
+                @handshakes.push(my_handshake)
+                if @handshakes.length > MAX_CONCURRENT_HANDSHAKES
+                  len = @handshakes.length
+                  @handshakes = []
+                  raise "The handshakes response array has grown to #{len}. Clearing all handshakes!"
+                end
+                # Tell all waiting commands to take a look
+                @handshakes_resource.broadcast
+              end # @handshakes_mutex.synchronize
+            end # if @handshake_enabled
+
+          end # if handshake_packet.read('origin') == "LCL"
+        end # @handshake_packet.identify?(packet.buffer(false))
+      end # if packet
+
+      return packet
+    end
+
+  end # class LincInterface
+
+  # 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'))
+    end
+
+    def get_cmd_guid(fieldname_guid)
+      return @identified_command.read(fieldname_guid)
+    end
+
+  end  # class LincHandshake
+
+end # module Cosmos