cosmos 3.0.0

data/lib/cosmos/interfaces/simulated_target_interface.rb

@@ -0,0 +1,128 @@
+# 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/interface'
+
+module Cosmos
+
+  # An interface class that provides simulated telemetry and command responses
+  class SimulatedTargetInterface < Interface
+
+    # @param sim_target_file [String] Filename of the simulator target class
+    def initialize(sim_target_file)
+      super()
+
+      @connected = false
+      @initialized = false
+      @count_100hz = 0
+      @next_tick_time = nil
+      @pending_packets = []
+
+      @sim_target_class = Cosmos.require_class sim_target_file
+      @sim_target = nil
+      @write_raw_allowed = false
+      @raw_logger_pair = nil
+    end
+
+    # Initialize the simulated target object and "connect" to the target
+    def connect
+      unless @initialized
+        # Save the current time + 10 ms as the next expected tick time
+        @next_tick_time = Time.now + 0.01
+
+        # Create Simulated Target Object
+        @sim_target = @sim_target_class.new(@target_names[0])
+
+        # Set telemetry rates
+        @sim_target.set_rates
+
+        @initialized = true
+      end
+
+      @connected = true
+    end
+
+    # @return [Boolean] Whether the simulated target is connected (initialized)
+    def connected?
+      @connected
+    end
+
+    # @return [Packet] Returns a simulated target packet from the simulator
+    def read
+      if @connected
+        packet = first_pending_packet()
+        return packet if packet
+
+        while true
+          # Calculate time to sleep to make ticks 10ms apart
+          now = Time.now
+          delta = @next_tick_time - now
+          if delta > 0.0
+            sleep(delta) # Sleep up to 10 ms
+          elsif delta < -1.0
+            # Fell way behind - jump next tick time
+            @next_tick_time = Time.now
+          end
+
+          @pending_packets = @sim_target.read(@count_100hz, @next_tick_time)
+          @next_tick_time += 0.01
+          @count_100hz += 1
+
+          packet = first_pending_packet()
+          return packet if packet
+        end
+      else
+        raise "Interface not connected"
+      end
+    end
+
+    # @param packet [Packet] Command packet to send to the simulator
+    def write(packet)
+      if @connected
+        # Update count of commands sent through this interface
+        @write_count += 1
+        @bytes_written += packet.buffer.length
+
+        # Have simulated target handle the packet
+        @sim_target.write(packet)
+      else
+        raise "Interface not connected"
+      end
+    end
+
+    # write_raw is not implemented and will raise a RuntimeError
+    def write_raw(data)
+      raise "write_raw not implemented for SimulatedTargetInterface"
+    end
+
+    # Raise an error because raw logging is not supported for this interface
+    def raw_logger_pair=(raw_logger_pair)
+      raise "Raw logging not supported for SimulatedTargetInterface"
+    end
+
+    # Disconnect from the simulator
+    def disconnect
+      @connected = false
+    end
+
+    protected
+
+    def first_pending_packet
+      packet = nil
+      unless @pending_packets.empty?
+        @read_count += 1
+        packet = @pending_packets.pop.clone
+        @bytes_read += packet.buffer.length
+      end
+      packet
+    end
+  end
+
+end # module Cosmos

data/lib/cosmos/interfaces/stream_interface.rb

@@ -0,0 +1,156 @@
+# 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/interface'
+# Require all the stream protocols. Additional general purpose stream
+# protocols should be added to the require list.
+require 'cosmos/streams/burst_stream_protocol'
+require 'cosmos/streams/fixed_stream_protocol'
+require 'cosmos/streams/length_stream_protocol'
+require 'cosmos/streams/preidentified_stream_protocol'
+require 'cosmos/streams/template_stream_protocol'
+require 'cosmos/streams/terminated_stream_protocol'
+
+module Cosmos
+
+  # Stream interfaces use stream protocols to interface with the target. This
+  # class simply passes through each method to identically named methods in the
+  # stream protocol class. This class is an abstract class and should not be
+  # used directly. It should be subclassed and the connect method implemented.
+  class StreamInterface < Interface
+
+    # @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(stream_protocol_type, *stream_protocol_args)
+      super()
+
+      stream_protocol_class = stream_protocol_type.to_s.capitalize << 'StreamProtocol'
+      klass = stream_protocol_class.to_class
+      unless klass
+        begin
+          require stream_protocol_class.class_name_to_filename
+        # If the stream protocol doesn't exist require will throw a LoadError
+        rescue LoadError => err
+          msg = "Unable to require " \
+            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}. " \
+            "Ensure #{stream_protocol_class.class_name_to_filename} "\
+            "is in the COSMOS lib directory."
+          Logger.instance.error msg
+          raise msg
+        # If the stream protocol exists but has problems we rescue those here
+        rescue => err
+          msg = "Unable to require " \
+            "#{stream_protocol_class.class_name_to_filename} due to #{err.message}."
+          Logger.instance.error msg
+          raise msg
+        end
+      end
+
+      @stream_protocol = klass.new(*stream_protocol_args)
+      @stream_protocol.interface = self
+    end
+
+    # Connect is left undefined as it must be defined by a subclass.
+
+    # @return [Boolean] Whether the stream protocol is connected to the target
+    def connected?
+      @stream_protocol.connected?
+    end
+
+    # Disconnect the stream protocol from the target
+    def disconnect
+      @stream_protocol.disconnect
+    end
+
+    # Read a packet from the stream protocol
+    def read
+      packet = @stream_protocol.read
+      @read_count += 1 if packet
+      packet
+    end
+
+    # Write a packet to the stream protocol
+    #
+    # @param packet [Packet]
+    def write(packet)
+      if connected?()
+        begin
+          @stream_protocol.write(packet)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write : #{@name}"
+      end
+    end
+
+    # Write a raw binary string to the stream protocol
+    #
+    # @param data [String] Raw binary string
+    def write_raw(data)
+      if connected?()
+        begin
+          @stream_protocol.write_raw(data)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing raw data to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write_raw : #{@name}"
+      end
+    end
+
+    # @return [Integer] The number of bytes read by the stream protocol
+    def bytes_read
+      @stream_protocol.bytes_read
+    end
+
+    # @return [Integer] Sets the number of bytes read by the stream protocol
+    def bytes_read=(bytes_read)
+      @stream_protocol.bytes_read = bytes_read
+    end
+
+    # @return [Integer] The number of bytes written to the stream protocol
+    def bytes_written
+      @stream_protocol.bytes_written
+    end
+
+    # @return [Integer] Sets the number of bytes written to the stream protocol
+    def bytes_written=(bytes_written)
+      @stream_protocol.bytes_written = bytes_written
+    end
+
+    # These methods do not exist in StreamInterface but can be implemented by
+    # subclasses and will be called by the {StreamProtocol} when processing
+    # the data in the {Stream}.
+    #
+    # Subclasses of {StreamProtocol} can implement the same method. However,
+    # if the callback method is implemented in the interface then the
+    # subclass method is not called.
+    #
+    # Thus if you are implementing an Interface that uses a {StreamProtocol}
+    # and choose to implement this method, you must be aware of any
+    # processing that the {StreamProtocol} does in the same method
+    # and re-implement it (or call @stream_protocol.post_read_data(packet_data), etc) in yours.
+    #
+    # @!method post_read_data(packet_data)
+    # @!method post_read_packet(packet)
+    # @!method pre_write_packet(packet)
+
+  end # class StreamInterface
+
+end # module Cosmos

data/lib/cosmos/interfaces/tcpip_client_interface.rb

@@ -0,0 +1,60 @@
+# 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/tcpip_client_stream'
+
+module Cosmos
+
+  # Base class for interfaces that act as a TCP/IP client
+  class TcpipClientInterface < StreamInterface
+
+    # @param hostname [String] Machine to connect to
+    # @param write_port [Integer] Port to write commands to
+    # @param read_port [Integer] Port to read telemetry from
+    # @param write_timeout [Integer] Seconds to wait before aborting writes
+    # @param read_timeout [Integer] Seconds to wait before aborting reads
+    # @param stream_protocol_type (see StreamInterface#initialize)
+    # @param stream_protocol_args (see StreamInterface#initialize)
+    def initialize(hostname,
+                   write_port,
+                   read_port,
+                   write_timeout,
+                   read_timeout,
+                   stream_protocol_type,
+                   *stream_protocol_args)
+      super(stream_protocol_type, *stream_protocol_args)
+
+      @hostname = hostname
+      @write_port = ConfigParser.handle_nil(write_port)
+      @read_port = ConfigParser.handle_nil(read_port)
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+      @read_allowed = false unless @read_port
+      @write_allowed = false unless @write_port
+      @write_raw_allowed = false unless @write_port
+    end
+
+    # Connects the {StreamProtocol} to a {TcpipClientStream} by passing the
+    # initialization parameters to the {TcpipClientStream}.
+    def connect
+      stream = TcpipClientStream.new(
+        @hostname,
+        @write_port,
+        @read_port,
+        @write_timeout,
+        @read_timeout)
+      stream.raw_logger_pair = @raw_logger_pair
+      @stream_protocol.connect(stream)
+    end
+
+  end # class TcpipClientInterface
+
+end # module Cosmos

data/lib/cosmos/interfaces/tcpip_server_interface.rb

@@ -0,0 +1,154 @@
+# 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/interface'
+require 'cosmos/io/tcpip_server'
+
+module Cosmos
+
+  # Base class for interfaces that act as a TCP/IP server
+  class TcpipServerInterface < Interface
+
+    # @param write_port [Integer] Port that clients should write commands to
+    # @param read_port [Integer] Port that clients should read telemetry from
+    # @param write_timeout [Integer] Seconds to wait before aborting writes
+    # @param read_timeout [Integer] Seconds to wait before aborting reads
+    # @param stream_protocol_type (see StreamInterface#initialize)
+    # @param stream_protocol_args (see StreamInterface#initialize)
+    def initialize(write_port,
+                   read_port,
+                   write_timeout,
+                   read_timeout,
+                   stream_protocol_type,
+                   *stream_protocol_args)
+      super()
+
+      @tcpip_server = TcpipServer.new(write_port,
+                                      read_port,
+                                      write_timeout,
+                                      read_timeout,
+                                      stream_protocol_type,
+                                      *stream_protocol_args)
+      @tcpip_server.interface = self
+      @read_allowed = false unless ConfigParser.handle_nil(read_port)
+      @write_allowed = false unless ConfigParser.handle_nil(write_port)
+      @write_raw_allowed = false unless ConfigParser.handle_nil(write_port)
+    end
+
+    # (see TcpipServer#connect)
+    def connect
+      @tcpip_server.raw_logger_pair = @raw_logger_pair
+      @tcpip_server.connect
+    end
+
+    # (see TcpipServer#connected?)
+    def connected?
+      @tcpip_server.connected?
+    end
+
+    # (see TcpipServer#disconnect)
+    def disconnect
+      @tcpip_server.disconnect
+    end
+
+    # (see TcpipServer#read)
+    def read
+      # Normal case will not be trying to read if not connected so don't bother checking
+      packet = @tcpip_server.read
+      @read_count += 1 if packet
+      packet
+    end
+
+    # If the server has connections, the packet is written to all the connected
+    # clients.
+    #
+    # @param packet [Packet]
+    def write(packet)
+      if connected?()
+        begin
+          @tcpip_server.write(packet)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write : #{@name}"
+      end
+    end
+
+    # If the server has connections, the data is written to all the connected
+    # clients.
+    #
+    # @param data [String] Raw binary data
+    def write_raw(data)
+      if connected?()
+        begin
+          @tcpip_server.write_raw(data)
+          @write_count += 1
+        rescue Exception => err
+          Logger.instance.error("Error writing raw data to interface : #{@name}")
+          disconnect()
+          raise err
+        end
+      else
+        raise "Interface not connected for write_raw : #{@name}"
+      end
+    end
+
+    # (see TcpipServer#bytes_read)
+    def bytes_read
+      @tcpip_server.bytes_read
+    end
+
+    # (see TcpipServer#bytes_read)
+    def bytes_read=(bytes_read)
+      @tcpip_server.bytes_read = bytes_read
+    end
+
+    # (see TcpipServer#bytes_written)
+    def bytes_written
+      @tcpip_server.bytes_written
+    end
+
+    # (see TcpipServer#bytes_written)
+    def bytes_written=(bytes_written)
+      @tcpip_server.bytes_written = bytes_written
+    end
+
+    # Number of clients connected to the TCP/IP server
+    def num_clients
+      @tcpip_server.num_clients
+    end
+
+    # Number of packets buffered in the read queue
+    def read_queue_size
+      @tcpip_server.read_queue_size
+    end
+
+    # Number of packets buffered in the write queue
+    def write_queue_size
+      @tcpip_server.write_queue_size
+    end
+
+    # Start raw logging for this interface
+    def start_raw_logging
+      @tcpip_server.start_raw_logging
+    end
+
+    # Stop raw logging for this interface
+    def stop_raw_logging
+      @tcpip_server.stop_raw_logging
+    end
+
+  end # class TcpipServerInterface
+
+end # module Cosmos

data/lib/cosmos/interfaces/udp_interface.rb

@@ -0,0 +1,173 @@
+# 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/interface'
+require 'cosmos/io/udp_sockets'
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # Base class for interfaces that send and receive messages over UDP
+  class UdpInterface < Interface
+
+    # @param hostname [String] Machine to connect to
+    # @param write_dest_port [Integer] Port to write commands to
+    # @param read_port [Integer] Port to read telemetry from
+    # @param write_src_port [Integer] Port to allow replies if needed
+    # @param interface_address [String] If the destination machine represented
+    #   by hostname supports multicast, then interface_address is used to
+    #   configure the outgoing multicast address.
+    # @param ttl [Integer] Time To Live value. The number of intermediate
+    #   routers allowed before dropping the packet.
+    # @param write_timeout [Integer] Seconds to wait before aborting writes
+    # @param read_timeout [Integer] Seconds to wait before aborting reads
+    def initialize(hostname,
+                   write_dest_port,
+                   read_port,
+                   write_src_port = nil,
+                   interface_address = nil,
+                   ttl = 128, # default for Windows
+                   write_timeout = 10.0,
+                   read_timeout = nil)
+      super()
+
+      @hostname = ConfigParser.handle_nil(hostname)
+      if @hostname
+        @hostname = @hostname.to_s
+        @hostname = '127.0.0.1' if @hostname.upcase == 'LOCALHOST'
+      end
+      @write_dest_port = ConfigParser.handle_nil(write_dest_port)
+      @write_dest_port = write_dest_port.to_i if @write_dest_port
+      @read_port = ConfigParser.handle_nil(read_port)
+      @read_port = read_port.to_i if @read_port
+      @write_src_port = ConfigParser.handle_nil(write_src_port)
+      @write_src_port = @write_src_port.to_i if @write_src_port
+      @interface_address = ConfigParser.handle_nil(interface_address)
+      @interface_address = '127.0.0.1' if @interface_address and @interface_address.upcase == 'LOCALHOST'
+      @ttl = ttl.to_i
+      @ttl = 1 if @ttl < 1
+      @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
+      @write_socket = nil
+      @read_socket = nil
+      @read_allowed = false unless @read_port
+      @write_allowed = false unless @write_dest_port
+      @write_raw_allowed = false unless @write_dest_port
+    end
+
+    # Creates a new {UdpWriteSocket} if the the write_dest_port was given in
+    # the constructor and a new {UdpReadSocket} if the read_port was given in
+    # the constructor.
+    def connect
+      @write_socket = UdpWriteSocket.new(@hostname,
+                                         @write_dest_port,
+                                         @write_src_port,
+                                         @interface_address,
+                                         @ttl) if @write_dest_port
+      @read_socket = UdpReadSocket.new(@read_port,@hostname,@interface_address) if @read_port
+    end
+
+    # @return [Boolean] Whether the active ports (read and/or write) have
+    #   created sockets. Since UDP is connectionless, creation of the sockets
+    #   is used to determine connection.
+    def connected?
+      if @write_dest_port && @read_port
+        (@write_socket && @read_socket) ? true : false
+      elsif @write_dest_port
+        @write_socket ? true : false
+      else
+        @read_socket ? true : false
+      end
+    end
+
+    # Close the active ports (read and/or write) and set the sockets to nil.
+    def disconnect
+      begin
+        if @write_socket
+          @write_socket.close unless @write_socket.closed?
+          @write_socket = nil
+        end
+      rescue IOError
+        @write_socket = nil
+      end
+      begin
+        if @read_socket
+          @read_socket.close unless @read_socket.closed?
+          @read_socket = nil
+        end
+      rescue IOError
+        @read_socket = nil
+      end
+    end
+
+    # If the read port was given, the read_socket is read and the data returned
+    # in a {Packet}. bytes_read and read_count are updated.
+    #
+    # @return [Packet]
+    def read
+      if @read_port
+        begin
+          data = @read_socket.read(@read_timeout)
+          @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
+        rescue IOError
+          # Disconnected
+          Thread.stop
+        end
+
+        @bytes_read += data.length
+        @read_count += 1
+
+        return Packet.new(nil, nil, :BIG_ENDIAN, nil, data)
+      else
+        # Write only interface so stop the thread which calls read
+        Thread.stop
+      end
+    end
+
+    # If the write_dest_port was given, the write_socket is written with the
+    # packet data. bytes_written and write_count are updated.
+    #
+    # @param packet [Packet] Packet buffer to write
+    def write(packet)
+      if @write_dest_port
+        if connected?()
+          write_raw(packet.buffer)
+        else
+          raise "Interface not connected"
+        end
+      else
+        raise "Attempt to write to read only interface"
+      end
+    end
+
+    # If the write_dest_port was given, the write_socket is written with the
+    # data. bytes_written and write_count are updated.
+    #
+    # @param data [String] Raw binary data to write
+    def write_raw(data)
+      if @write_dest_port
+        if connected?()
+          @write_socket.write(data, @write_timeout)
+          @bytes_written += data.length
+          @write_count += 1
+          @raw_logger_pair.write_logger.write(data) if @raw_logger_pair
+        else
+          raise "Interface not connected"
+        end
+      else
+        raise "Attempt to write to read only interface"
+      end
+    end
+
+  end # class UdpInterface
+
+end # module Cosmos

data/lib/cosmos/interfaces.rb

@@ -0,0 +1,11 @@
+# encoding: ascii-8bit
+
+require 'cosmos/interfaces/interface'
+require 'cosmos/interfaces/stream_interface'
+require 'cosmos/interfaces/cmd_tlm_server_interface'
+require 'cosmos/interfaces/serial_interface'
+require 'cosmos/interfaces/simulated_target_interface'
+require 'cosmos/interfaces/tcpip_client_interface'
+require 'cosmos/interfaces/tcpip_server_interface'
+require 'cosmos/interfaces/udp_interface'
+require 'cosmos/interfaces/linc_interface'

data/lib/cosmos/io/buffered_file.rb

@@ -0,0 +1,11 @@
+# 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/ext/buffered_file'