cosmos 3.0.0

data/lib/cosmos/script.rb

@@ -0,0 +1,9 @@
+# encoding: ascii-8bit
+
+# Enforce not allowing this file to be included within CmdTlmServer
+if $0 =~ /CmdTlmServer/ or $0 =~ /Replay/
+  raise "cosmos/script must not be required by any code used in the CmdTlmServer or Replay applications"
+end
+
+require 'cosmos/script/script'
+include Cosmos::Script

data/lib/cosmos/streams/burst_stream_protocol.rb

@@ -0,0 +1,25 @@
+# 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/streams/stream_protocol'
+
+module Cosmos
+
+  # Reads all data available in the stream and creates a packet
+  # with that data.
+  class BurstStreamProtocol < StreamProtocol
+    # This class is currently empty because StreamProtocol performs all
+    # the necessary functionality. It exists because of the way
+    # {StreamInterface} creates the stream protocol by appending
+    # 'StreamProtocol' to the name of the protocol. Thus we need a
+    # BurstStreamProtocol so 'burst' can be used by the {StreamInterface}.
+  end
+
+end # module Cosmos

data/lib/cosmos/streams/fixed_stream_protocol.rb

@@ -0,0 +1,111 @@
+# 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/config/config_parser'
+require 'cosmos/streams/stream_protocol'
+
+module Cosmos
+
+  # This StreamProtocol delineates packets by identifying them and then
+  # reading out their entire fixed length. Packets lengths can vary but
+  # they must all be fixed.
+  class FixedStreamProtocol < StreamProtocol
+
+    # @param min_id_size [Integer] The minimum amount of data needed to
+    #   identify a packet.
+    # @param discard_leading_bytes (see StreamProtocol#initialize)
+    # @param sync_pattern (see StreamProtocol#initialize)
+    # @param telemetry_stream [Boolean] Whether the stream is returning
+    #   telemetry (true) or commands (false)
+    # @param fill_sync_pattern (see StreamProtocol#initialize)
+    def initialize(min_id_size,
+                   discard_leading_bytes = 0,
+                   sync_pattern = nil,
+                   telemetry_stream = true,
+                   fill_sync_pattern = false)
+      super(discard_leading_bytes, sync_pattern, fill_sync_pattern)
+      @min_id_size = Integer(min_id_size)
+      @telemetry_stream = telemetry_stream
+    end
+
+    # Set the received_time, target_name and packet_name which we recorded when
+    # we identified this packet. The server will also do this but since we know
+    # the information here, we perform this optimization.
+    # See StreamProtocol#post_read_packet
+    def post_read_packet(packet)
+      packet.received_time = @received_time
+      packet.target_name = @target_name
+      packet.packet_name = @packet_name
+      packet
+    end
+
+    protected
+
+    # Identifies an unknown buffer of data as a Packet. The raw data is
+    # returned but the packet that matched is recorded so it can be set in the
+    # post_read_packet callback.
+    #
+    # @return [String|nil] The identified packet data or nil if the stream was
+    #   closed
+    def identify_and_finish_packet
+      packet_data = nil
+
+      raise "Interface required for FixedStreamProtocol" unless @interface
+      @interface.target_names.each do |target_name|
+        target_packets = nil
+        begin
+          if @telemetry_stream
+            target_packets = System.telemetry.packets(target_name)
+          else
+            target_packets = System.commands.packets(target_name)
+          end
+        rescue RuntimeError
+          # No telemetry for this target
+          next
+        end
+
+        identified_packet = nil
+        target_packets.each do |packet_name, packet|
+          if (packet.identify?(@data))
+            identified_packet = packet
+            if identified_packet.defined_length > @data.length
+              # Need more data to finish packet
+              read_minimum_size(identified_packet.defined_length)
+              return nil if @data.length <= 0
+            end
+            # Set some variables so we can update the packet in
+            # post_read_packet
+            @received_time = Time.now
+            @target_name = identified_packet.target_name
+            @packet_name = identified_packet.packet_name
+
+            # Get the data from this packet
+            packet_data = @data[0..(identified_packet.defined_length - 1)]
+            @data.replace(@data[identified_packet.defined_length..-1])
+            break
+          end
+        end
+
+        break if identified_packet
+      end
+
+      packet_data
+    end
+
+    def reduce_to_single_packet
+      read_minimum_size(@min_id_size)
+      return nil if @data.length <= 0
+
+      identify_and_finish_packet()
+    end
+
+  end # class FixedStreamProtocol
+
+end # module Cosmos

data/lib/cosmos/streams/length_stream_protocol.rb

@@ -0,0 +1,140 @@
+# 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/packets/binary_accessor'
+require 'cosmos/streams/stream_protocol'
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # This StreamProtocol delineates packets using a length field at a fixed
+  # location in each packet.
+  class LengthStreamProtocol < StreamProtocol
+
+    # @param length_bit_offset [Integer] The bit offset of the length field
+    # @param length_bit_size [Integer] The size in bits of the length field
+    # @param length_value_offset [Integer] The offset to apply to the length
+    #   value once it has been read from the packet. The value in the length
+    #   field itself plus the length value offset MUST equal the total bytes in
+    #   the stream including any discarded bytes.
+    #   For example: if your length field really means "length - 1" this value should be 1.
+    # @param length_bytes_per_count [Integer] The number of bytes per each
+    #   length field 'count'. This is used if the units of the length field is
+    #   something other than bytes, for example words.
+    # @param length_endianness [String] The endianness of the length field.
+    #   Must be either BIG_ENDIAN or LITTLE_ENDIAN.
+    # @param discard_leading_bytes (see StreamProtocol#initialize)
+    # @param sync_pattern (see StreamProtocol#initialize)
+    # @param max_length [Integer] The maximum allowed value of the length field
+    # @param fill_length_and_sync_pattern [Boolean] Fill the length field and sync
+    #    pattern when writing packets
+    def initialize(
+      length_bit_offset = 0,
+      length_bit_size = 16,
+      length_value_offset = 0,
+      length_bytes_per_count = 1,
+      length_endianness = 'BIG_ENDIAN',
+      discard_leading_bytes = 0,
+      sync_pattern = nil,
+      max_length = nil,
+      fill_length_and_sync_pattern = false
+    )
+      super(discard_leading_bytes, sync_pattern, fill_length_and_sync_pattern)
+
+      # Save length field attributes
+      @length_bit_offset = Integer(length_bit_offset)
+      @length_bit_size = Integer(length_bit_size)
+      @length_value_offset = Integer(length_value_offset)
+      @length_bytes_per_count = Integer(length_bytes_per_count)
+
+      # Save endianness
+      if length_endianness.to_s.upcase == 'LITTLE_ENDIAN'
+        @length_endianness = :LITTLE_ENDIAN
+      else
+        @length_endianness = :BIG_ENDIAN
+      end
+
+      # Derive number of bytes required to contain entire length field
+      if @length_endianness == :BIG_ENDIAN or ((@length_bit_offset % 8) == 0)
+        length_bits_needed = @length_bit_offset + @length_bit_size
+        length_bits_needed += 8 if (length_bits_needed % 8) != 0
+        @length_bytes_needed = ((length_bits_needed - 1)/ 8) + 1
+      else
+        @length_bytes_needed = (length_bit_offset / 8) + 1
+      end
+
+      # Save max length setting
+      @max_length = ConfigParser.handle_nil(max_length)
+      @max_length = Integer(@max_length) if @max_length
+    end
+
+    # See StreamProtocol#pre_write_packet
+    def pre_write_packet(packet)
+      data = super(packet)
+      if @fill_sync_pattern # and length
+        # Fill the length field
+        length = (data.length - @length_value_offset) / @length_bytes_per_count
+        BinaryAccessor.write(length,
+          @length_bit_offset,
+          @length_bit_size,
+          :UINT,
+          data,
+          @length_endianness,
+          :ERROR)
+
+        # Also write the new length field into the packet that will be logged if it exists in the packet
+        if @discard_leading_bytes > 0
+          # The write above did not write into the original packet
+          original_length_bit_offset = @length_bit_offset - (@discard_leading_bytes * 8)
+          if original_length_bit_offset >= 0
+            original_data = packet.buffer(false)
+            BinaryAccessor.write(length,
+              original_length_bit_offset,
+              @length_bit_size,
+              :UINT,
+              original_data,
+              @length_endianness,
+              :ERROR)
+          end
+        end
+      end
+      data
+    end
+
+    protected
+
+    def reduce_to_single_packet
+      # Make sure we have at least enough data to reach the length field
+      read_minimum_size(@length_bytes_needed)
+      return nil if @data.length <= 0
+
+      # Determine the packet's length
+      length = BinaryAccessor.read(@length_bit_offset,
+                                   @length_bit_size,
+                                   :UINT,
+                                   @data,
+                                   @length_endianness)
+      raise "Length value received larger than max_length: #{length} > #{@max_length}" if @max_length and length > @max_length
+      packet_length = (length * @length_bytes_per_count) + @length_value_offset
+
+      # Make sure we have enough data for the packet
+      read_minimum_size(packet_length)
+      return nil if @data.length <= 0
+
+      # Reduce to packet data and setup current_data for next packet
+      packet_data = @data[0..(packet_length - 1)]
+      @data.replace(@data[packet_length..-1])
+
+      packet_data
+    end
+
+  end # class LengthStreamProtocol
+
+end # module Cosmos

data/lib/cosmos/streams/preidentified_stream_protocol.rb

@@ -0,0 +1,118 @@
+# 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/streams/stream_protocol'
+
+module Cosmos
+
+  # This StreamProtocol delineates packets using the COSMOS
+  # preidentification system
+  class PreidentifiedStreamProtocol < StreamProtocol
+
+    # @param sync_pattern (see StreamProtocol#initialize)
+    # @param max_length [Integer] The maximum allowed value of the length field
+    def initialize(sync_pattern = nil, max_length = nil)
+      super(0, sync_pattern)
+      @max_length = ConfigParser.handle_nil(max_length)
+      @max_length = Integer(@max_length) if @max_length
+    end
+
+    # See StreamProtocol#post_read_packet
+    def post_read_packet(packet)
+      packet.received_time = @received_time
+      packet.target_name = @target_name
+      packet.packet_name = @packet_name
+      packet
+    end
+
+    # See StreamProtocol#pre_write_packet
+    def pre_write_packet(packet)
+      received_time = packet.received_time
+      received_time = Time.now unless received_time
+      time_seconds = [received_time.tv_sec].pack('N') # UINT32
+      time_microseconds = [received_time.tv_usec].pack('N') # UINT32
+      target_name = packet.target_name
+      target_name = 'UNKNOWN' unless target_name
+      packet_name = packet.packet_name
+      packet_name = 'UNKNOWN' unless packet_name
+      data = packet.buffer
+      data_length = [data.length].pack('N') # UINT32
+      data_to_send = ''
+      data_to_send << @sync_pattern if @sync_pattern
+      data_to_send << time_seconds
+      data_to_send << time_microseconds
+      data_to_send << target_name.length
+      data_to_send << target_name
+      data_to_send << packet_name.length
+      data_to_send << packet_name
+      data_to_send << data_length
+      data_to_send << data
+      data_to_send
+    end
+
+    protected
+
+    def read_length_field_followed_by_string(length_num_bytes)
+      # Read bytes for string length
+      read_minimum_size(length_num_bytes)
+      return nil if @data.length <= 0
+      string_length = @data[0..(length_num_bytes - 1)]
+
+      case length_num_bytes
+      when 1
+        string_length = string_length.unpack('C')[0] # UINT8
+      when 2
+        string_length = string_length.unpack('n')[0] # UINT16
+      when 4
+        string_length = string_length.unpack('N')[0] # UINT32
+        raise "Length value received larger than max_length: #{string_length} > #{@max_length}" if @max_length and string_length > @max_length
+      else
+        return nil
+      end
+
+      # Read String
+      read_minimum_size(string_length + length_num_bytes)
+      return nil if @data.length <= 0
+      next_index = string_length + length_num_bytes
+      string = @data[length_num_bytes..(next_index - 1)]
+
+      # Remove data from current_data
+      @data.replace(@data[next_index..-1])
+
+      string
+    end
+
+    def reduce_to_single_packet
+      # Discard sync pattern if present
+      @data.replace(@data[(@sync_pattern.length)..-1]) if @sync_pattern
+
+      # Read and remove packet received time
+      read_minimum_size(8)
+      return nil if @data.length <= 0
+      time_seconds = @data[0..3].unpack('N')[0] # UINT32
+      time_microseconds = @data[4..7].unpack('N')[0] # UINT32
+      @received_time = Time.at(time_seconds, time_microseconds)
+      @data.replace(@data[8..-1])
+
+      # Read and remove the target name
+      @target_name = read_length_field_followed_by_string(1)
+      return nil unless @target_name
+
+      # Read and remove the packet name
+      @packet_name = read_length_field_followed_by_string(1)
+      return nil unless @packet_name
+
+      # Read packet data and return
+      read_length_field_followed_by_string(4)
+    end
+
+  end # class PreidentifiedStreamProtocol
+
+end # module Cosmos

data/lib/cosmos/streams/serial_stream.rb

@@ -0,0 +1,143 @@
+# 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 'thread' # For Mutex
+require 'timeout' # For Timeout::Error
+require 'cosmos/streams/stream'
+require 'cosmos/config/config_parser'
+require 'cosmos/io/serial_driver'
+
+module Cosmos
+
+  # Stream that reads and writes to serial ports by using {SerialDriver}.
+  class SerialStream < Stream
+
+    # @param write_port_name [String] The name of the serial port to write.
+    #   Pass nil if the stream is to be read only. On Windows the port name
+    #   is typically 'COMX' where X can be any port number. On UNIX the port
+    #   name is typically a device such as '/dev/ttyS0'.
+    # @param read_port_name [String] The name of the serial port to read.
+    #   Pass nil if the stream is to be read only. On Windows the port name
+    #   is typically 'COMX' where X can be any port number. On UNIX the port
+    #   name is typically a device such as '/dev/ttyS0'.
+    # @param baud_rate [Integer] The serial port baud rate
+    # @param parity [Symbol] Must be :NONE, :EVEN, or :ODD
+    # @param stop_bits [Integer] Number of stop bits. Must be 1 or 2.
+    # @param write_timeout [Integer] Number of seconds to wait for the write to
+    #   complete. Pass nil to create no timeout. The {SerialDriver} will
+    #   continously try to send the data until it has been sent or an error
+    #   occurs.
+    # @param read_timeout [Integer] Number of seconds to wait for the read to
+    #   complete. Pass nil to create no timeout. The {SerialDriver} will
+    #   continously try to read data until it has received data or an error
+    #   occurs.
+    def initialize(write_port_name,
+                   read_port_name,
+                   baud_rate,
+                   parity,
+                   stop_bits,
+                   write_timeout,
+                   read_timeout)
+      super()
+
+      # The SerialDriver class will validate the parameters
+      @write_port_name = ConfigParser.handle_nil(write_port_name)
+      @read_port_name  = ConfigParser.handle_nil(read_port_name)
+      @baud_rate       = Integer(baud_rate)
+      @parity          = parity
+      @stop_bits       = stop_bits.to_i
+      @write_timeout   = ConfigParser.handle_nil(write_timeout)
+      @write_timeout   = @write_timeout.to_f if @write_timeout
+      @read_timeout    = ConfigParser.handle_nil(read_timeout)
+      @read_timeout    = @read_timeout.to_f if @read_timeout
+
+      if @write_port_name
+        @write_serial_port = SerialDriver.new(@write_port_name,
+                                              @baud_rate,
+                                              @parity,
+                                              @stop_bits,
+                                              @write_timeout,
+                                              @read_timeout)
+      else
+        @write_serial_port = nil
+      end
+      if @read_port_name
+        if @read_port_name == @write_port_name
+          @read_serial_port = @write_serial_port
+        else
+          @read_serial_port = SerialDriver.new(@read_port_name,
+                                               @baud_rate,
+                                               @parity,
+                                               @stop_bits,
+                                               @write_timeout,
+                                               @read_timeout)
+        end
+      else
+        @read_serial_port = nil
+      end
+      if @read_serial_port.nil? && @write_serial_port.nil?
+        raise "Either a write port or read port must be given"
+      end
+
+      # We 'connect' when we create the stream
+      @connected = true
+
+      # Mutex on write is needed to protect from commands coming in from more
+      # than one tool
+      @write_mutex = Mutex.new
+    end
+
+    # @return [String] Returns a binary string of data from the serial port
+    def read
+      raise "Attempt to read from write only stream" unless @read_serial_port
+      # No read mutex is needed because there is only one stream procesor
+      # reading
+      data = @read_serial_port.read
+      @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
+      data
+    end
+
+    # @return [String] Returns a binary string of data from the serial port without blocking
+    def read_nonblock
+      raise "Attempt to read from write only stream" unless @read_serial_port
+      # No read mutex is needed because there is only one stream procesor
+      # reading
+      data = @read_serial_port.read_nonblock
+      @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
+      data
+    end
+
+    # @param data [String] A binary string of data to write to the serial port
+    def write(data)
+      raise "Attempt to write to read only stream" unless @write_serial_port
+      @write_mutex.synchronize do
+        @write_serial_port.write(data)
+        @raw_logger_pair.write_logger.write(data) if @raw_logger_pair
+      end
+    end
+
+    # @return [Boolean] Whether the serial stream is connected to the serial
+    #   port
+    def connected?
+      @connected
+    end
+
+    # Disconnect by closing the serial ports
+    def disconnect
+      if @connected
+        @write_serial_port.close if @write_serial_port && !@write_serial_port.closed?
+        @read_serial_port.close if @read_serial_port && !@read_serial_port.closed?
+        @connected = false
+      end
+    end
+
+  end # class SerialStream
+
+end # module Cosmos

data/lib/cosmos/streams/stream.rb

@@ -0,0 +1,57 @@
+# 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 'timeout' # For Timeout::Error
+
+module Cosmos
+
+  # Interface that implments the following methods: read, write(data),
+  # connected? and disconnect. Streams are simply data sources which
+  # {StreamProtocol} classes read and write to. This separation of concerns
+  # allows Streams to simply focus on getting and sending raw data while the
+  # higher level processing occurs in {StreamProtocol}.
+  class Stream
+
+    # @return [RawLoggerPair] Raw logger pair associated with this stream
+    attr_accessor :raw_logger_pair
+
+    # Expected to return any amount of data on success, or a blank string on
+    # closed/EOF, and may raise Timeout::Error, or other errors
+    def read
+      raise "read not defined by Stream"
+    end
+
+    # Expected to always return immediately with data if available or an empty string.
+    # Should not raise errors
+    def read_nonblock
+      raise "read_nonblock not defined by Stream"
+    end
+
+    # Expected to write complete set of data.  May raise Timeout::Error
+    # or other errors.
+    #
+    # @param data [String] Binary data to write to the stream
+    def write(data)
+      raise "write not defined by Stream"
+    end
+
+    # @return [Boolean] true if connected or false otherwise
+    def connected?
+      raise "connected? not defined by Stream"
+    end
+
+    # Disconnects the stream
+    def disconnect
+      raise "disconnect not defined by Stream"
+    end
+
+  end # class Stream
+
+end # module Cosmos