cosmos 3.9.2 → 4.0.0

data/lib/cosmos/tools/cmd_sequence/sequence_list.rb

@@ -0,0 +1,194 @@
+# 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'
+require 'cosmos/tools/cmd_sequence/sequence_item'
+
+module Cosmos
+  # Widget which displays a list of SequenceItems
+  class SequenceList < Qt::Widget
+    include Enumerable
+    # Emit modified whenever any of the underlying SequenceItems change
+    signals 'modified()'
+
+    # Create the SequenceList
+    def initialize
+      super()
+      @modified = false
+      layout = Qt::VBoxLayout.new()
+      layout.setContentsMargins(0, 0, 0, 0)
+      layout.setSpacing(0)
+      setLayout(layout)
+      setSizePolicy(1, 0)
+      layout.addWidget(create_header())
+    end
+
+    # Opens a sequence definition file and populates the sequence.
+    # Exceptions are re-raised with filename and line number information
+    # and must be handled by the higher level application.
+    #
+    # @param filename [String] File containing a sequence definition
+    def open(filename)
+      clear()
+
+      parser = ConfigParser.new("http://cosmosrb.com/docs/tools/#command-sequence-configuration")
+      parser.parse_file(filename) do |keyword, params|
+        case keyword
+        when 'COMMAND'
+          usage = "#{keyword} <Delay Time> <Command>"
+          parser.verify_num_parameters(2, 2, usage)
+          begin
+            item = SequenceItem.parse(params[0], params[1])
+            # Connect the SequenceItems modified signal to propagate it
+            # forward by emitting our own modified signal
+            item.connect(SIGNAL("modified()")) do
+              @modified = true
+              emit modified()
+            end
+            layout.addWidget(item)
+          rescue => error
+            Kernel.raise parser.error("#{usage} passed '#{params[0]} #{params[1]}'\n#{error.message}")
+          end
+        else
+          Kernel.raise parser.error("Unknown keyword '#{keyword}'.") if keyword
+        end
+      end
+      @modified = false # Initially we're not modified
+    end
+
+    # Add a new SequenceItem to the list.
+    # @param command [Packet] Command packet to base the SequenceItem on
+    # @return [SequenceItem] The item added
+    def add(command)
+      @modified = true
+      item = SequenceItem.new(command)
+      # Connect the SequenceItems modified signal to propagate it
+      # forward by emitting our own modified signal
+      item.connect(SIGNAL("modified()")) do
+        @modified = true
+        emit modified()
+      end
+      layout.addWidget(item)
+      emit modified()
+      item
+    end
+
+    # Clear the list by removing all SequenceItems and disposing them
+    def clear
+      @modified = false
+      (1...layout.count).each do |index|
+        item = layout.takeAt(1)
+        item.widget.dispose
+      end
+      emit modified()
+    end
+
+    # @return [Boolean] Whether the list is modified
+    def modified?
+      @modified
+    end
+
+    # Yield each SequenceItem to enable the included Enumerable module
+    def each
+      total_items = 1
+      Qt.execute_in_main_thread { total_items = layout.count }
+      (1...total_items).each do |index|
+        item = nil
+        Qt.execute_in_main_thread { item = layout.itemAt(index).widget }
+        yield item
+      end
+    end
+
+    # Calls save on all individual SequenceItems and writes out the result
+    # to the given filename. Exceptions must be handled by the higher level
+    # application.
+    # @param filename [String] Filename to open and write the sequence
+    def save(filename)
+      @modified = false
+      File.open(filename, "w") do |file|
+        # Each SequenceItem's save method returns the save string
+        file.write(collect {|item| item.save }.join("\n"))
+        file.write("\n") # final newline
+      end
+    end
+
+    protected
+
+    # Create a header item in the SequenceList to describe the SequenceItems
+    def create_header
+      header = Qt::Widget.new
+      header_layout = Qt::HBoxLayout.new
+      header_layout.setContentsMargins(5, 5, 5, 5)
+      header.setLayout(header_layout)
+      time = Qt::Label.new("Time (Delay or Absolute)")
+      time.setFixedWidth(130)
+      header_layout.addWidget(time)
+      command = Qt::Label.new("Command")
+      header_layout.addWidget(command)
+      header_layout.addStretch()
+      header
+    end
+
+    # TODO: The following are various methods that could be used in future
+    # drag and drop support.
+    #
+    # def swap(index1, index2)
+    #   STDOUT.puts "swap:#{index1}, #{index2} count:#{layout.count}"
+    #  widget1 = layout.takeAt(index1).widget
+    #  index1 = widget1.index
+    #  widget2 = layout.takeAt(index2).widget
+    #  index2 = widget2.index
+    #  widget2.index = index1
+    #  widget1.index = index2
+    #  layout.insertWidget(index1, widget2)
+    #  layout.insertWidget(index2, widget1)
+    # end
+    #
+    # def mousePressEvent(event)
+    #   super(event)
+    #   if event.button == Qt::LeftButton
+    #     @dragStartPosition = event.pos
+    #   end
+    #   @expanded = !@expanded
+    #   if @expanded
+    #     @parameters.show
+    #   else
+    #     @parameters.hide
+    #   end
+    # end
+    #
+    # def mouseMoveEvent(event)
+    #  super(event)
+    #  return unless (event.buttons & Qt::LeftButton)
+    #  return if (event.pos - @dragStartPosition).manhattanLength() < Qt::Application::startDragDistance()
+    #
+    #  mime = Qt::MimeData.new()
+    #  mime.setText(@index.to_s)
+    #  drag = Qt::Drag.new(self)
+    #  drag.setMimeData(mime)
+    #  drop = drag.exec(Qt::MoveAction)
+    # end
+    #
+    # def dragEnterEvent(event)
+    #  if event.mimeData.text != @text.to_s
+    #    event.acceptProposedAction
+    #    setStyleSheet("background-color:grey")
+    #  end
+    # end
+    #
+    # def dragLeaveEvent(event)
+    #  setStyleSheet("background-color:")
+    # end
+    #
+    # def dropEvent(event)
+    #  setStyleSheet("background-color:white")
+    # end
+  end
+end

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

@@ -9,11 +9,13 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/script/extract'
+require 'cosmos/script/api_shared'
 
 module Cosmos
 
   module Api
     include Extract
+    include ApiShared
 
     # Sets api_requests to 0 and initializes the whitelist of allowable API
     # method calls
@@ -41,6 +43,10 @@ module Cosmos
         'tlm_variable',
         'set_tlm',
         'set_tlm_raw',
+        'inject_tlm',
+        'override_tlm',
+        'override_tlm_raw',
+        'normalize_tlm',
         'get_tlm_buffer',
         'get_tlm_packet',
         'get_tlm_values',
@@ -470,7 +476,15 @@ module Cosmos
     #   description).
     def set_tlm(*args)
       target_name, packet_name, item_name, value = set_tlm_process_args(args, 'set_tlm')
+      if target_name == 'SYSTEM'.freeze and packet_name == 'META'.freeze
+        raise "set_tlm not allowed on #{target_name} #{packet_name} #{item_name}" if ['PKTID', 'CONFIG'].include?(item_name)
+      end
       System.telemetry.set_value(target_name, packet_name, item_name, value, :CONVERTED)
+      if target_name == 'SYSTEM'.freeze and packet_name == 'META'.freeze
+        tlm_packet = System.telemetry.packet('SYSTEM', 'META')
+        cmd_packet = System.commands.packet('SYSTEM', 'META')
+        cmd_packet.buffer = tlm_packet.buffer
+      end
       System.telemetry.packet(target_name, packet_name).check_limits(System.limits_set, true)
       nil
     end
@@ -499,6 +513,164 @@ module Cosmos
       nil
     end
 
+    # Injects a packet into the system as if it was received from an interface
+    #
+    # @param target_name[String] Target name of the packet
+    # @param packet_name[String] Packet name of the packet
+    # @param item_hash[Hash] Hash of item_name and value for each item you want to change from the current value table
+    # @param value_type[Symbol/String] Type of the values in the item_hash (RAW or CONVERTED)
+    # @param send_routers[Boolean] Whether or not to send to routers for the target's interface
+    # @param send_packet_log_writers[Boolean] Whether or not to send to the packet log writers for the target's interface
+    # @param create_new_logs[Boolean] Whether or not to create new log files before writing this packet to logs
+    def inject_tlm(target_name, packet_name, item_hash = nil, value_type = :CONVERTED, send_routers = true, send_packet_log_writers = true, create_new_logs = false)
+      received_time = Time.now
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+
+      # Find and clone the telemetry packet
+      cvt_packet = System.telemetry.packet(target_name, packet_name)
+      packet = cvt_packet.clone
+      packet.received_time = received_time
+
+      # Update the packet with item_hash
+      value_type = value_type.to_s.intern
+      item_hash.each do |item_name, item_value|
+        packet.write(item_name, item_value, value_type)
+      end
+
+      # Update current value table
+      cvt_packet.buffer = packet.buffer(false)
+      cvt_packet.received_time = received_time
+
+      # The interface does the following line, but I don't think inject_tlm should because it could confuse the interface
+      target.tlm_cnt += 1
+      packet.received_count += 1
+      cvt_packet.received_count += 1
+      CmdTlmServer.instance.identified_packet_callback(packet)
+
+      # Find the interface for this target
+      interface = target.interface
+
+      if interface
+        # Write to routers
+        if send_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
+        end
+
+        # Write to packet log writers
+        if create_new_logs or send_packet_log_writers
+          interface.packet_log_writer_pairs.each do |packet_log_writer_pair|
+            # Optionally create new log files
+            packet_log_writer_pair.tlm_log_writer.start if create_new_logs
+
+            # Optionally write to packet logs - Write errors are handled by the log writer
+            packet_log_writer_pair.tlm_log_writer.write(packet) if send_packet_log_writers
+          end
+        end
+      else
+        # Some packets don't have an interface - Can still write to standard routers and packet logs
+
+        # Write to routers
+        if send_routers
+          router = CmdTlmServer.instance.routers.all['PREIDENTIFIED_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
+
+        if create_new_logs or send_packet_log_writers
+          # Handle packet logging
+          packet_log_writer_pair = CmdTlmServer.instance.packet_logging.all['DEFAULT']
+
+          # Optionally create new logs
+          packet_log_writer_pair.tlm_log_writer.start if create_new_logs
+
+          # Optionally write to packet logs - Write errors are handled by the log writer
+          packet_log_writer_pair.tlm_log_writer.write(packet) if send_packet_log_writers
+        end
+      end
+
+      nil
+    end
+
+    # Override a telemetry item in a packet to a particular value such that it
+    # is always returned even when new telemetry packets are received from the
+    # target.
+    #
+    # Accepts two different calling styles:
+    #   override_tlm("TGT PKT ITEM = 1.0")
+    #   override_tlm('TGT','PKT','ITEM', 10.0)
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args The args must either be a string followed by a value or
+    #   three strings followed by a value (see the calling style in the
+    #   description).
+    def override_tlm(*args)
+      _override(__method__, set_tlm_process_args(args, __method__))
+    end
+
+    # Override a telemetry item in a packet to a particular value such that it
+    # is always returned even when new telemetry packets are received from the
+    # target. This only accepts RAW data items and any conversions are applied
+    # to the raw data when the packet is read.
+    #
+    # Accepts two different calling styles:
+    #   override_tlm_raw("TGT PKT ITEM = 1.0")
+    #   override_tlm_raw('TGT','PKT','ITEM', 10.0)
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args The args must either be a string followed by a value or
+    #   three strings followed by a value (see the calling style in the
+    #   description).
+    def override_tlm_raw(*args)
+      _override(__method__, set_tlm_process_args(args, __method__))
+    end
+
+    # Normalize a telemetry item in a packet to its default behavior. Called
+    # after override_tlm and override_tlm_raw to restore standard processing.
+    #
+    # Accepts two different calling styles:
+    #   normalize_tlm("TGT PKT ITEM")
+    #   normalize_tlm('TGT','PKT','ITEM')
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args The args must either be a string or three strings
+    #   (see the calling style in the description).
+    def normalize_tlm(*args)
+      _override(__method__, tlm_process_args(args, __method__))
+    end
+
+    private
+
+    def _override(method, tgt_pkt_item)
+      interface = System.targets[tgt_pkt_item[0]].interface
+      found = false
+      interface.read_protocols.each do |protocol|
+        found = true if protocol.kind_of? OverrideProtocol
+      end
+      if found
+        # Test to see if this telemetry item exists
+        System.telemetry.value(tgt_pkt_item[0], tgt_pkt_item[1], tgt_pkt_item[2], :RAW)
+        interface.public_send("_#{method}", *tgt_pkt_item)
+      else
+        raise "Interface #{interface.name} does not have override ability. Is 'PROTOCOL OverrideProtocol' under the interface definition?"
+      end
+      nil
+    end
+
+    public
+
     # Returns the raw buffer for a telemetry packet.
     #
     # @param target_name [String] Name of the target
@@ -696,12 +868,14 @@ module Cosmos
 
     # (see Cosmos::Limits#enable_group)
     def enable_limits_group(group_name)
+      Logger.info("Enabling Limits Group: #{group_name.upcase}")
       System.limits.enable_group(group_name)
       nil
     end
 
     # (see Cosmos::Limits#disable_group)
     def disable_limits_group(group_name)
+      Logger.info("Disabling Limits Group: #{group_name.upcase}")
       System.limits.disable_group(group_name)
       nil
     end
@@ -866,8 +1040,8 @@ module Cosmos
     # Get information about an interface
     #
     # @param interface_name [String] Interface name
-    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric, 
-    #   Numeric, Numeric>] Array containing \[state, num clients, 
+    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>] Array containing \[state, num clients,
     #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
     #   Telemetry count] for the interface
     def get_interface_info(interface_name)
@@ -877,8 +1051,8 @@ module Cosmos
     # Get information about a router
     #
     # @param router_name [String] Router name
-    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric, 
-    #   Numeric, Numeric>] Array containing \[state, num clients, 
+    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>] Array containing \[state, num clients,
     #   TX queue size, RX queue size, TX bytes, RX bytes, Pkts received,
     #   Pkts sent] for the router
     def get_router_info(router_name)
@@ -910,7 +1084,7 @@ module Cosmos
     # @param packet_logger_name [String] Name of the packet logger
     # @return [Array<<Array<String>, Boolean, Numeric, String, Numeric,
     #   Boolean, Numeric, String, Numeric>] Array containing \[interfaces,
-    #   cmd logging enabled, cmd queue size, cmd filename, cmd file size, 
+    #   cmd logging enabled, cmd queue size, cmd filename, cmd file size,
     #   tlm logging enabled, tlm queue size, tlm filename, tlm file size]
     #   for the packet logger
     def get_packet_logger_info(packet_logger_name = 'DEFAULT')

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

@@ -1,3 +1,4 @@
+
 # encoding: ascii-8bit
 
 # Copyright 2014 Ball Aerospace & Technologies Corp.
@@ -70,8 +71,6 @@ module Cosmos
     #   packet_data_queues hash to access the queue.
     attr_accessor :next_packet_data_queue_id
 
-    # The default host
-    DEFAULT_HOST = 'localhost'
     # The default configuration file name
     DEFAULT_CONFIG_FILE = File.join(Cosmos::USERPATH, 'config', 'tools', 'cmd_tlm_server', 'cmd_tlm_server.txt')
     # The maximum number of limits events that are queued. Used when
@@ -156,7 +155,7 @@ module Cosmos
       System.telemetry # Make sure definitions are loaded by starting anything
       return unless @json_drb.nil?
 
-      @@meta_callback.call(@config.meta_target_name, @config.meta_packet_name) if @@meta_callback if @config.meta_target_name and @config.meta_packet_name
+      @@meta_callback.call() if @@meta_callback if @config.metadata
 
       # Start DRb with access control
       @json_drb = JsonDRb.new
@@ -178,7 +177,7 @@ module Cosmos
       end
       @json_drb.method_whitelist = @api_whitelist
       begin
-        @json_drb.start_service("localhost", System.ports['CTS_API'], self)
+        @json_drb.start_service(System.listen_hosts['CTS_API'], System.ports['CTS_API'], self)
       rescue Exception
         # Call packet_logging shutdown here to explicitly kill the logging
         # threads since this CTS is not going to launch
@@ -197,11 +196,31 @@ module Cosmos
       @sleeper = Sleeper.new
       @staleness_monitor_thread = Thread.new do
         begin
+          stale = []
+          prev_stale = []
           while true
-            stale = System.telemetry.check_stale
-            stale.each do |packet|
-              post_limits_event(:STALE_PACKET, [packet.target_name, packet.packet_name])
+            # The check_stale method drives System.telemetry to iterate through
+            # the packets and mark them stale as necessary.
+            System.telemetry.check_stale
+
+            # Get all stale packets that include limits items.
+            stale_pkts = System.telemetry.stale(true)
+
+            # Send :STALE_PACKET events for all newly stale packets.
+            stale = []
+            stale_pkts.each do |packet|
+              pkt_name = [packet.target_name, packet.packet_name]
+              stale << pkt_name
+              post_limits_event(:STALE_PACKET, pkt_name) unless prev_stale.include?(pkt_name)
+            end
+
+            # Send :STALE_PACKET_RCVD events for all packets that were stale
+            # but are no longer stale.
+            prev_stale.each do |pkt_name|
+              post_limits_event(:STALE_PACKET_RCVD, pkt_name) unless stale.include?(pkt_name)
             end
+            prev_stale = stale.dup
+
             broken = @sleeper.sleep(10)
             break if broken
           end
@@ -288,6 +307,8 @@ module Cosmos
     #   :LIMITS_CHANGE which means an individual item has changed limits state,
     #   :LIMITS_SETTINGS which means an individual item has new settings, or
     #   :STALE_PACKET which means a packet with limits has gone stale
+    #   :STALE_PACKET_RCVD which means a packet with limits that had previously
+    #   been stale is no longer stale.
     # @param event_data [Symbol|Array<String,String,String,Symbol,Symbol>]
     #   Returns the current limits set name for event_type == :LIMITS_SET.
     #   Returns an array containing the target name, packet name, item name,
@@ -396,7 +417,7 @@ module Cosmos
             packets.each do |target_name, packet_name|
               if packet.target_name == target_name and packet.packet_name == packet_name
                 received_time = packet.received_time
-                received_time ||= Time.now
+                received_time ||= Time.now.sys
                 queue << [packet.buffer, target_name, packet_name,
                   received_time.tv_sec, received_time.tv_usec, packet.received_count]
                 if queue.length > queue_size
@@ -503,8 +524,6 @@ module Cosmos
       self.instance.json_drb.request_count = 0
     end
 
-    protected
-
     # Method called by all interfaces when a packet has been identified. It
     # checks the limits of the packet and then posts the packet to any
     # registered subscribers.
@@ -514,7 +533,5 @@ module Cosmos
       packet.check_limits(System.limits_set)
       post_packet(packet)
     end
-
-  end # class CmdTlmServer
-
-end # module Cosmos
+  end
+end