cosmos 3.0.0

data/lib/cosmos/tools/cmd_tlm_server/commanding.rb

@@ -0,0 +1,112 @@
+# 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
+
+module Cosmos
+
+  # Sends command packets to targets or interfaces. Utilizes the System
+  # knowledge of targets and commands to correctly identify interfaces and
+  # commands before sending. Also provides {#send_raw} to directly send raw
+  # binary data to an interface.
+  class Commanding
+    # @param cmd_tlm_server_config [CmdTlmServerConfig] The configuration which
+    #   defines the interfaces
+    def initialize(cmd_tlm_server_config)
+      @config = cmd_tlm_server_config
+    end
+
+    # Sends a command to the interface associated with the given target
+    # and logs the command using its log writer
+    #
+    # Commands should be identified before this method is called.
+    #
+    # @param target_name [String] Name of the target to send to
+    # @param packet [Packet] Packet to send
+    def send_command_to_target(target_name, packet)
+      # Create guaranteed uppercase target name
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+      raise "Target not mapped to an interface: #{target_name}" unless target.interface
+
+      # Send the command
+      send_command_to_interface(target.interface, packet)
+    end
+
+    # Sends the packet to the given interface and performs other common command
+    # sending tasks.
+    #
+    # @param interface [Interface] The interface to send the packet to
+    # @param packet [Packet] Packet to send
+    def send_command_to_interface(interface, packet)
+      # Make sure packet received time is set
+      packet.received_time ||= Time.now
+
+      unless packet.identified?
+        identified_command = System.commands.identify(packet.buffer, interface.target_names)
+        if identified_command
+          identified_command.received_time = packet.received_time
+          identified_command.raw = packet.raw
+          packet = identified_command
+        end
+      end
+
+      # Log to messages command being sent, update counters, and initially update current value table
+      target = nil
+      if packet.identified?
+        command = System.commands.packet(packet.target_name, packet.packet_name)
+        raise "Cannot send DISABLED command #{packet.target_name} #{packet.packet_name}" if packet.disabled
+        target = System.targets[packet.target_name]
+        target.cmd_cnt += 1
+      else
+        command = System.commands.packet('UNKNOWN', 'UNKNOWN')
+        Logger.warn "Unidentified packet of #{packet.length} bytes being sent to interface #{interface.name}"
+      end
+      command.received_time = packet.received_time
+      command.raw = packet.raw
+      command.buffer = packet.buffer
+      command.received_count += 1
+      Logger.info System.commands.format(command, target.ignored_parameters) if !command.messages_disabled and command.target_name != 'UNKNOWN'
+
+      if packet.identified?
+        # Write the identified and defined packet to the interface
+        interface.write(command)
+      else
+        # Write the unidentified and undefined packet to the interface
+        # We do not want to give interfaces packets identified and defined as UNKNOWN UNKNOWN
+        interface.write(packet)
+
+        # Note: packet may have been modified by the interface to fill in a CRC, length, etc.
+        # The following actions are done after a successful write to incorporate these possible
+        # changes.
+
+        # Update current value table again after successful write
+        command.buffer = packet.buffer
+      end
+
+      # Write to command packet logs
+      interface.packet_log_writer_pairs.each do |packet_log_writer_pair|
+        packet_log_writer_pair.cmd_log_writer.write(command)
+      end
+    end
+
+    # Sends raw data to the specified interface. Note: Raw data is not logged
+    # to the command packet log, because packet boundaries are not known.
+    #
+    # @param interface_name [String] Name of the interface to send to
+    # @param data [String] Binary string of data
+    def send_raw(interface_name, data)
+      interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless interface
+      Logger.warn "Unlogged raw data of #{data.length} bytes being sent to interface #{interface_name}"
+      interface.write_raw(data)
+    end
+
+  end # class Commanding
+
+end # module Cosmos

data/lib/cosmos/tools/cmd_tlm_server/connections.rb

@@ -0,0 +1,176 @@
+# 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_server_interface'
+
+module Cosmos
+
+  # Abstract base class for {Routers} and {Interfaces}. Since Routers are just
+  # Interfaces they share a lot of responsibilies which are captured here.
+  class Connections
+    # @param cmd_tlm_server_config [CmdTlmServerConfig] The configuration which
+    #   defines all the connections
+    def initialize(type, cmd_tlm_server_config)
+      @config = cmd_tlm_server_config
+      if type == :INTERFACES
+        @connections = @config.interfaces
+        @keyword = "interface"
+      elsif type == :ROUTERS
+        @connections = @config.routers
+        @keyword = "router"
+      else
+        raise "Unknown type: #{type}. Must be :INTERFACES or :ROUTERS."
+      end
+    end
+
+    # Creates a thread for each connection which sends all commands received out on
+    # the connection interfaces
+    def start
+      @connections.each do |connection_name, connection|
+        connect(connection_name) if connection.connect_on_startup
+      end
+    end
+
+    # Stop connections by disconnecting the interface and killing the thread
+    def stop
+      @connections.each do |connection_name, connection|
+        disconnect(connection_name)
+        stop_raw_logging(connection_name)
+      end
+    end
+
+    # Connect a connection by name
+    #
+    # @param connection_name [String] Name of the connection
+    # @param params [Array] Array of parameters to be passed to the {#recreate}
+    #   method. Pass nothing to start the connection for the first time.
+    def connect(connection_name, *params)
+      connection = @connections[connection_name.upcase]
+      raise "Unknown #{@keyword}: #{connection_name}" unless connection
+
+      if params.empty?
+        start_thread(connection) unless connection.thread
+      else
+        disconnect(connection_name)
+        connection = recreate(connection_name, *params)
+        start_thread(connection)
+      end
+    end
+
+    # Recreate an interface with new initialization parameters. Must be
+    # implemented by a subclass.
+    #
+    # @param connection_name [String] Name of the connection
+    # @param params [Array] Array of parameters to pass to the connection
+    #   constructor
+    def recreate(connection_name, *params)
+      raise "Connections recreate method not implemented"
+    end
+
+    # Disconnect a connection by name
+    #
+    # @param connection_name [String] Name of the connection
+    def disconnect(connection_name)
+      connection = @connections[connection_name.upcase]
+      raise "Unknown #{@keyword}: #{connection_name}" unless connection
+
+      connection.disconnect
+      stop_thread(connection)
+      Logger.info "Disconnected from #{@keyword} #{connection_name.upcase}"
+    end
+
+    # Get the state of a connection by name
+    #
+    # @return [String] Either 'CONNECTED', 'ATTEMPTING', or 'DISCONNECTED'.
+    def state(connection_name)
+      connection = @connections[connection_name.upcase]
+      raise "Unknown #{@keyword}: #{connection_name}" unless connection
+
+      if connection.connected?
+        return 'CONNECTED'
+      elsif connection.thread
+        return 'ATTEMPTING'
+      else
+        return 'DISCONNECTED'
+      end
+    end
+
+    # @return [Array<String>] The names of all the connections
+    def names
+      names = []
+      @connections.each do |connection_name, connection|
+        names << connection_name
+      end
+      return names.sort
+    end
+
+    # Clears the bytes written, bytes read, write count, and read count from
+    # each of the connections.
+    def clear_counters
+      @connections.each do |connection_name, connection|
+        connection.bytes_written = 0
+        connection.bytes_read = 0
+        connection.write_count = 0
+        connection.read_count = 0
+      end
+    end
+
+    # @return [Hash<String, Interface>] All the connections
+    def all
+      @connections
+    end
+
+    # Start raw logging on a connection by name
+    #
+    # @param connection_name [String] Name of the connection
+    def start_raw_logging(connection_name = 'ALL')
+      connection_name_upcase = connection_name.upcase
+      if connection_name == 'ALL'
+        @connections.each do |_, connection|
+          connection.start_raw_logging
+        end
+      else
+        connection = @connections[connection_name_upcase]
+        raise "Unknown #{@keyword}: #{connection_name}" unless connection
+        connection.start_raw_logging
+      end
+    end
+
+    # Stop raw logging on a connection by name
+    #
+    # @param connection_name [String] Name of the connection
+    def stop_raw_logging(connection_name = 'ALL')
+      connection_name_upcase = connection_name.upcase
+      if connection_name == 'ALL'
+        @connections.each do |_, connection|
+          connection.stop_raw_logging
+        end
+      else
+        connection = @connections[connection_name_upcase]
+        raise "Unknown #{@keyword}: #{connection_name}" unless connection
+        connection.stop_raw_logging
+      end
+    end
+
+    protected
+
+    # Start an connection's packet reading thread
+    def start_thread(connection)
+      raise "Connections start_thread method not implemented"
+    end
+
+    # Stop an connection's packet reading thread
+    def stop_thread(connection)
+      raise "Connections stop_thread method not implemented"
+    end
+
+  end # class Connections
+
+end # module Cosmos

data/lib/cosmos/tools/cmd_tlm_server/interface_thread.rb

@@ -0,0 +1,221 @@
+# 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
+
+module Cosmos
+
+  # Encapsulates an {Interface} in a Ruby thread. When the thread is started by
+  # the {#start} method, it loops trying to connect. It then continously reads
+  # from the interface while handling the packets it receives.
+  class InterfaceThread
+    # The number of bytes to print when an UNKNOWN packet is received
+    UNKNOWN_BYTES_TO_PRINT = 36
+
+    # @return [#call()] Callback which is called if the #{Interface#connect}
+    #   method succeeds
+    attr_accessor :connection_success_callback
+    # @return [#call(Exception)] Callback which is called if the
+    #   {Interface#connect} method throws an exception.
+    attr_accessor :connection_failed_callback
+    # @return [#call(Exception|nil)] Callback which is called if the
+    #   interface connection is lost.
+    attr_accessor :connection_lost_callback
+    # @return [#call(Packet)] Callback which is called when a packet has been
+    #   received from the interface and identified.
+    attr_accessor :identified_packet_callback
+    # @return [#call(Exception)] Callback which is called if the
+    #   InterfaceThread dies for any reason.
+    attr_accessor :fatal_exception_callback
+
+    # @param interface [Interface] The interface to create a thread for
+    def initialize(interface)
+      @interface = interface
+      @interface.thread = self
+      @connection_success_callback = nil
+      @connection_failed_callback = nil
+      @connection_lost_callback = nil
+      @identified_packet_callback = nil
+      @fatal_exception_callback = nil
+      @thread = nil
+    end
+
+    # Create and start the Ruby thread that will encapsulate the interface.
+    # Creates a while loop that waits for {Interface#connect} to succeed. Then
+    # calls {Interface#read} and handles all the incoming packets.
+    def start
+      @thread = Thread.new do
+        begin
+          Logger.info "Starting packet reading for #{@interface.name}"
+          while true
+            unless @interface.connected?
+              begin
+                connect()
+              rescue Exception => connect_error
+                handle_connection_failed(connect_error)
+                next
+              end
+            end
+
+            begin
+              packet = @interface.read
+              unless packet
+                handle_connection_lost(nil)
+                next
+              end
+              packet.received_time = Time.now unless packet.received_time
+            rescue Exception => err
+              handle_connection_lost(err)
+              next
+            end
+
+            handle_packet(packet)
+          end  # loop
+        rescue Exception => error
+          if @fatal_exception_callback
+            @fatal_exception_callback.call(error)
+          else
+            Logger.error "Packet reading thread unexpectedly died for #{@interface.name}"
+            Cosmos.handle_fatal_exception(error)
+          end
+        end
+      end  # Thread.new
+    end # def start
+
+    # Disconnect from the interface and stop the thread
+    def stop
+      @interface.disconnect
+
+      if @thread
+        Logger.info "Stopping packet reading for #{@interface.name}"
+        @thread.kill
+      end
+    end
+
+    protected
+
+    def handle_packet(packet)
+      # Identify and update packet
+      if packet.identified?
+        begin
+          # Preidentifed packet - place it into the current value table
+          identified_packet = System.telemetry.update!(packet.target_name,
+                                                       packet.packet_name,
+                                                       packet.buffer)
+        rescue RuntimeError
+          # Packet identified but we don't know about it
+          # Clear packet_name and target_name and try to identify
+          Logger.warn "Received unknown identified telemetry: #{packet.target_name} #{packet.packet_name}"
+          packet.target_name = nil
+          packet.packet_name = nil
+          identified_packet = System.telemetry.identify!(packet.buffer,
+                                                         @interface.target_names)
+        end
+      else
+        # Packet needs to be identified
+        identified_packet = System.telemetry.identify!(packet.buffer,
+                                                       @interface.target_names)
+      end
+
+      if identified_packet
+        identified_packet.received_time = packet.received_time
+        packet = identified_packet
+      else
+        unknown_packet = System.telemetry.update!('UNKNOWN', 'UNKNOWN', packet.buffer)
+        unknown_packet.received_time = packet.received_time
+        packet = unknown_packet
+        data_length = packet.length
+        string = "#{@interface.name} - Unknown #{data_length} byte packet starting: "
+        num_bytes_to_print = [UNKNOWN_BYTES_TO_PRINT, data_length].min
+        data_to_print = packet.buffer(false)[0..(num_bytes_to_print - 1)]
+        data_to_print.each_byte do |byte|
+          string << sprintf("%02X", byte)
+        end
+        Logger.error string
+      end
+
+      @interface.post_identify_packet(packet)
+      target = System.targets[packet.target_name]
+      target.tlm_cnt += 1 if target
+      packet.received_count += 1
+      @identified_packet_callback.call(packet) if @identified_packet_callback
+
+      # Write to routers
+      @interface.routers.each do |router|
+        begin
+          router.write(packet) if router.write_allowed? and router.connected?
+        rescue => err
+          Logger.error "Problem writing to router #{router.name} - #{err.class}:#{err.message}"
+        end
+      end
+
+      # Write to packet log writers
+      @interface.packet_log_writer_pairs.each do |packet_log_writer_pair|
+        # Write errors are handled by the log writer
+        packet_log_writer_pair.tlm_log_writer.write(packet)
+      end
+    end
+
+    def handle_connection_failed(connect_error)
+      if @connection_failed_callback
+        @connection_failed_callback.call(connect_error)
+      else
+        Logger.error "#{@interface.name} Connection Failed: #{connect_error.to_s}"
+        case connect_error
+        when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT
+          # Do not write an exception file for these extremely common cases
+        else
+          Cosmos.write_exception_file(connect_error)
+        end
+      end
+      disconnect()
+    end
+
+    def handle_connection_lost(err)
+      if @connection_lost_callback
+        @connection_lost_callback.call(err)
+      else
+        Logger.error "Connection Lost for #{@interface.name}"
+        if err
+          case err
+          when Errno::ECONNABORTED, Errno::ECONNRESET, Errno::ETIMEDOUT
+            # Do not write an exception file for these extremely common cases
+            Logger.error err.formatted(false, false)
+          else
+            Cosmos.write_exception_file(err)
+            Logger.error err.formatted
+          end
+        end
+      end
+      disconnect()
+    end
+
+    def connect
+      Logger.info "Connecting to #{@interface.name}..."
+      @interface.connect
+      if @connection_success_callback
+        @connection_success_callback.call
+      else
+        Logger.info "#{@interface.name} Connection Success"
+      end
+    end
+
+    def disconnect
+      @interface.disconnect
+
+      # If the interface is set to auto_reconnect then delay so the thread
+      # can come back around and allow the interface a chance to reconnect.
+      if @interface.auto_reconnect
+        sleep @interface.reconnect_delay
+      else
+        stop()
+      end
+    end
+  end # class InterfaceThread
+
+end # module Cosmos

data/lib/cosmos/tools/cmd_tlm_server/interfaces.rb

@@ -0,0 +1,127 @@
+# 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/connections'
+
+module Cosmos
+
+  # Controls the interfaces as defined in the Command/Telemetry configuration
+  # file. Interfaces provide the connection between the Command and Telemetry
+  # Server and targets. They send command packets to and receive telemetry
+  # packets from targets.
+  class Interfaces < Connections
+
+    # @param cmd_tlm_server_config [CmdTlmServerConfig] The configuration which
+    #   defines all the routers
+    # @param identified_packet_callback [#call(Packet)] Callback which is called
+    #   when a packet has been  received from the interface and identified.
+    def initialize(cmd_tlm_server_config, identified_packet_callback = nil)
+      super(:INTERFACES, cmd_tlm_server_config)
+      @identified_packet_callback = identified_packet_callback
+    end
+
+    # Determines all targets in the system and maps them to the given interface
+    #
+    # @param interface_name [String] The interface to map all targets to
+    def map_all_targets(interface_name)
+      interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless interface
+      System.targets.each do |target_name, target|
+        target.interface = interface
+        interface.target_names << target_name
+      end
+    end
+
+    # Maps a target to an interface and unmaps the target from its existing
+    # interface if present.
+    #
+    # @param target_name [String] The name of the target to map
+    # @param interface_name [String] The name of the interface to map the
+    #   target to
+    def map_target(target_name, interface_name)
+      # Find the new interface
+      new_interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless new_interface
+
+      # Find the target
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+
+      # Find the old interface
+      old_interface = System.targets[target_name.upcase].interface
+
+      # Remove target from old interface
+      old_interface.target_names.delete(target_name.upcase) if old_interface
+
+      # Add target to new interface
+      new_interface.target_names << target_name.upcase unless new_interface.target_names.include? target_name.upcase
+
+      # Update targets
+      System.targets[target_name.upcase].interface = new_interface
+    end
+
+    # Recreate an interface with new initialization parameters
+    #
+    # @param interface_name [String] Name of the interface
+    # @param params [Array] Array of parameters to pass to the interface
+    #   constructor
+    def recreate(interface_name, *params)
+      interface = @config.interfaces[interface_name.upcase]
+      raise "Unknown interface: #{interface_name}" unless interface
+
+      # Build New Interface
+      new_interface = interface.class.new(*params)
+      interface.copy_to(new_interface)
+
+      # Replace interface for targets
+      System.targets.each do |target_name, target|
+        target.interface = new_interface if target.interface == interface
+      end
+
+      # Replace interface for routers
+      @config.routers.each do |router_name, router|
+        if router.interfaces.include?(interface)
+          router.interfaces.delete(interface)
+          router.interfaces << new_interface
+        end
+      end
+
+      # Replace interface in @interfaces array
+      @config.interfaces[interface_name.upcase] = new_interface
+
+      # Make sure there is no thread
+      stop_thread(interface)
+
+      return new_interface
+    end
+
+    protected
+
+    # Start an interface's packet reading thread
+    def start_thread(interface)
+      Logger.info "Creating thread for interface #{interface.name}"
+      interface_thread = InterfaceThread.new(interface)
+      interface_thread.identified_packet_callback = @identified_packet_callback
+      interface_thread.start
+    end
+
+    # Stop an interface's packet reading thread
+    def stop_thread(interface)
+      if interface.thread
+        Logger.info "Killing thread for interface #{interface.name}"
+        to_stop = interface.thread
+        interface.thread = nil
+        to_stop.stop
+      end
+    end
+
+  end # class Interfaces
+
+end # module Cosmos