cosmos 3.0.0

data/lib/cosmos/interfaces/interface.rb

@@ -0,0 +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

data/lib/cosmos/interfaces/linc_interface.rb

@@ -0,0 +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

data/lib/cosmos/interfaces/serial_interface.rb

@@ -0,0 +1,76 @@
+# 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/stream_interface'
+require 'cosmos/streams/serial_stream'
+
+module Cosmos
+
+  # Provides a base class for interfaces that use serial ports
+  class SerialInterface < StreamInterface
+
+    # Creates a serial interface which uses the specified stream protocol.
+    #
+    # @param write_port_name [String] The name of the serial port to write
+    # @param read_port_name [String] The name of the serial port to read
+    # @param baud_rate [Integer] The serial port baud rate
+    # @param parity [Symbol] The parity which is normally :NONE.
+    #   Must be one of :NONE, :EVEN, or :ODD.
+    # @param stop_bits [Integer] The number of stop bits which is normally 1.
+    # @param write_timeout [Integer] The number of seconds to attempt the write
+    #   before aborting
+    # @param read_timeout [Integer] The number of seconds to attempt to read
+    #   data from the serial port before aborting
+    # @param stream_protocol_type [String] Combined with 'StreamProtocol'
+    #   this should resolve to a COSMOS stream protocol class
+    # @param stream_protocol_args [Array] Arguments to pass to the stream
+    #   protocol class constructor
+    def initialize(write_port_name,
+                   read_port_name,
+                   baud_rate,
+                   parity,
+                   stop_bits,
+                   write_timeout,
+                   read_timeout,
+                   stream_protocol_type,
+                   *stream_protocol_args)
+      super(stream_protocol_type, *stream_protocol_args)
+
+      @write_port_name = ConfigParser.handle_nil(write_port_name)
+      @read_port_name  = ConfigParser.handle_nil(read_port_name)
+      @baud_rate = baud_rate
+      @parity = parity.to_s.intern
+      @stop_bits = stop_bits
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+
+      @write_allowed     = false unless @write_port_name
+      @write_raw_allowed = false unless @write_port_name
+      @read_allowed      = false unless @read_port_name
+    end
+
+    # Connects the stream protocol to a new {SerialStream} using the
+    # parameters passed in the constructor.
+    def connect
+      stream = SerialStream.new(
+        @write_port_name,
+        @read_port_name,
+        @baud_rate,
+        @parity,
+        @stop_bits,
+        @write_timeout,
+        @read_timeout)
+      stream.raw_logger_pair = @raw_logger_pair
+      @stream_protocol.connect(stream)
+    end
+
+  end # class SerialInterface
+
+end # module Cosmos