cosmos 3.9.2 → 4.0.0

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

@@ -29,10 +29,8 @@ module Cosmos
     attr_accessor :background_tasks
     # @return [String] Command and Telemetry Server title
     attr_accessor :title
-    # @return [String or nil] Meta Target Name
-    attr_accessor :meta_target_name
-    # @return [String or nil] Meta Packet Name
-    attr_accessor :meta_packet_name
+    # @return [Boolean] Flag indicating if meta data should be collected
+    attr_accessor :metadata
 
     # Create a default pair of packet log writers and parses the
     # configuration file.
@@ -42,13 +40,12 @@ module Cosmos
       @interfaces = {}
       @routers = {}
       @packet_log_writer_pairs = {}
-      cmd_log_writer = System.default_packet_log_writer.new(:CMD)
-      tlm_log_writer = System.default_packet_log_writer.new(:TLM)
+      cmd_log_writer = System.default_packet_log_writer.new(:CMD, *System.default_packet_log_writer_params)
+      tlm_log_writer = System.default_packet_log_writer.new(:TLM, *System.default_packet_log_writer_params)
       @packet_log_writer_pairs['DEFAULT'] = PacketLogWriterPair.new(cmd_log_writer, tlm_log_writer)
       @background_tasks = []
       @title = nil
-      @meta_target_name = nil
-      @meta_packet_name = nil
+      @metadata = false
       process_file(filename)
     end
 
@@ -67,7 +64,7 @@ module Cosmos
       Logger.info "Processing CmdTlmServer configuration in file: #{File.expand_path(filename)}"
 
       Cosmos.set_working_dir do
-      parser = ConfigParser.new
+        parser = ConfigParser.new("http://cosmosrb.com/docs/system/#command-and-telemetry-server-configuration")
         parser.parse_file(filename) do |keyword, params|
           case keyword
           when 'TITLE'
@@ -145,7 +142,7 @@ module Cosmos
             current_interface_or_router.name = interface_name
             @interfaces[interface_name] = current_interface_or_router
 
-          when 'LOG', 'DONT_LOG', 'TARGET'
+          when 'LOG', 'DONT_LOG', 'TARGET', 'PROTOCOL'
             raise parser.error("No current interface for #{keyword}") unless current_interface_or_router and current_type == :INTERFACE
 
             case keyword
@@ -173,6 +170,19 @@ module Cosmos
                 raise parser.error("Unknown target #{target_name} mapped to interface #{current_interface_or_router.name}")
               end
 
+            when 'PROTOCOL'
+              usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+              parser.verify_num_parameters(2, nil, usage)
+              unless %w(READ WRITE READ_WRITE).include? params[0].upcase
+                raise parser.error("Invalid protocol type: #{params[0]}", usage)
+              end
+              begin
+                klass = Cosmos.require_class(params[1])
+                current_interface_or_router.add_protocol(klass, params[2..-1], params[0].upcase.intern)
+              rescue LoadError, StandardError => error
+                raise parser.error(error.message, usage)
+              end
+
             end # end case keyword for all keywords that require a current interface
 
           when 'DONT_CONNECT', 'DONT_RECONNECT', 'RECONNECT_DELAY', 'DISABLE_DISCONNECT', 'LOG_RAW', 'ROUTER_LOG_RAW', 'OPTION'
@@ -249,12 +259,9 @@ module Cosmos
             raise parser.error("No BACKGROUND_TASK defined") if @background_tasks.empty?
             @background_tasks[-1].stopped = true
 
-          # TODO: Deprecate COLLECT_META_DATA
-          when 'COLLECT_METADATA', 'COLLECT_META_DATA'
-            parser.verify_num_parameters(2, 2, "#{keyword} <Metadata Target Name> <Metadata Packet Name>")
-            System.telemetry.packet(params[0], params[1])
-            @meta_target_name = params[0]
-            @meta_packet_name = params[1]
+          when 'COLLECT_METADATA'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            @metadata = true
 
           else
             # blank lines will have a nil keyword and should not raise an exception

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

@@ -10,15 +10,68 @@
 
 require 'cosmos'
 require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
-require 'cosmos/tools/cmd_tlm_server/gui/interfaces_tab'
-require 'cosmos/tools/cmd_tlm_server/gui/targets_tab'
-require 'cosmos/tools/cmd_tlm_server/gui/packets_tab'
-require 'cosmos/tools/cmd_tlm_server/gui/logging_tab'
-require 'cosmos/tools/cmd_tlm_server/gui/status_tab'
-require 'cosmos/gui/qt_tool'
-require 'cosmos/gui/dialogs/splash'
-require 'cosmos/gui/dialogs/exception_dialog'
-require 'cosmos/gui/dialogs/set_tlm_dialog'
+if RUBY_ENGINE == 'ruby'
+  require 'cosmos/tools/cmd_tlm_server/gui/interfaces_tab'
+  require 'cosmos/tools/cmd_tlm_server/gui/targets_tab'
+  require 'cosmos/tools/cmd_tlm_server/gui/packets_tab'
+  require 'cosmos/tools/cmd_tlm_server/gui/logging_tab'
+  require 'cosmos/tools/cmd_tlm_server/gui/status_tab'
+  require 'cosmos/gui/qt_tool'
+  require 'cosmos/gui/dialogs/splash'
+  require 'cosmos/gui/dialogs/exception_dialog'
+  require 'cosmos/gui/dialogs/set_tlm_dialog'
+else
+  # The following stubs allow the CmdTlmServer to run under JRuby with no gui
+  require 'ostruct'
+  require 'optparse'
+
+  class QtTool
+    def self.slots(*args)
+      # Do nothing
+    end
+
+    def self.create_default_options
+      options = OpenStruct.new
+      options.redirect_io = true
+      options.title = "COSMOS Tool"
+      parser = OptionParser.new do |option_parser|
+        option_parser.banner = "Usage: ruby #{option_parser.program_name} [options]"
+        option_parser.separator("")
+
+        # Create the help option
+        option_parser.on("-h", "--help", "Show this message") do
+          puts option_parser
+          exit
+        end
+
+        # Create the version option
+        option_parser.on("-v", "--version", "Show version") do
+          puts "COSMOS Version: #{COSMOS_VERSION}"
+          puts "User Version: #{USER_VERSION}" if defined? USER_VERSION
+          exit
+        end
+
+        # Create the system option
+        option_parser.on("--system FILE", "Use an alternative system.txt file") do |arg|
+          System.instance(File.join(USERPATH, 'config', 'system', arg))
+        end
+        option_parser.on("-c", "--config FILE", "Use the specified configuration file") do |arg|
+          options.config_file = arg
+        end
+      end
+
+      return parser, options
+    end
+
+    def self.run(option_parser = nil, options = nil)
+      Cosmos.set_working_dir do
+        option_parser, options = create_default_options() unless option_parser and options
+        option_parser.parse!(ARGV)
+        post_options_parsed_hook(options)
+      end
+    end
+  end
+end
 
 module Cosmos
 
@@ -34,18 +87,22 @@ module Cosmos
 
     TOOL_NAME = "Command and Telemetry Server"
 
-    # For the CTS we display all the tables as full size
-    # Thus we don't want the table to absorb the scroll wheel events but
-    # instead pass them up to the container so the entire window will scroll.
-    class Qt::TableWidget
-      def wheelEvent(event)
-        event.ignore()
+    attr_writer :no_prompt
+
+    if RUBY_ENGINE == 'ruby'
+      # For the CTS we display all the tables as full size
+      # Thus we don't want the table to absorb the scroll wheel events but
+      # instead pass them up to the container so the entire window will scroll.
+      class Qt::TableWidget
+        def wheelEvent(event)
+          event.ignore()
+        end
       end
     end
 
-    def meta_callback(meta_target_name, meta_packet_name)
+    def meta_callback
       Qt.execute_in_main_thread(true) do
-        result = SetTlmDialog.execute(self, 'Enter Metadata', 'Set Metadata', 'Cancel', meta_target_name, meta_packet_name)
+        result = SetTlmDialog.execute(self, 'Enter Metadata', 'Set Metadata', 'Cancel', 'SYSTEM', 'META')
         exit(1) unless result
       end
     end
@@ -59,7 +116,7 @@ module Cosmos
       @message_log = nil
       @output_sleeper = Sleeper.new
       @first_output = 0
-      @interfaces_tab = InterfacesTab.new
+      @interfaces_tab = InterfacesTab.new(self)
       @targets_tab = TargetsTab.new
       @packets_tab = PacketsTab.new(self)
       @logging_tab = LoggingTab.new(@production)
@@ -223,9 +280,9 @@ module Cosmos
       @tab_thread = Thread.new do
         begin
           while true
-            start_time = Time.now
+            start_time = Time.now.sys
             Qt.execute_in_main_thread(true) { @status_tab.update }
-            total_time = Time.now - start_time
+            total_time = Time.now.sys - start_time
             if total_time > 0.0 and total_time < 1.0
               break if @tab_sleeper.sleep(1.0 - total_time)
             end
@@ -344,6 +401,8 @@ module Cosmos
 
     def self.post_options_parsed_hook(options)
       if options.no_gui
+        ["TERM", "INT"].each {|sig| Signal.trap(sig) {exit}}
+
         begin
           @output_sleeper = Sleeper.new
           @string_output = StringIO.new("", "r+")
@@ -367,6 +426,19 @@ module Cosmos
         end
         return false
       else
+        ["TERM", "INT"].each do |sig|
+          Signal.trap(sig) do
+            # No synchronization is allowed in trap context, so we have
+            # to spawn a thread here to send the close event.
+            Thread.new do
+              Qt.execute_in_main_thread(true) do
+                @@window.no_prompt = true
+                @@window.closeEvent(Qt::CloseEvent.new())
+                exit
+              end
+            end
+          end
+        end
         return true
       end
     end

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

@@ -45,7 +45,7 @@ module Cosmos
     # @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
+      packet.received_time ||= Time.now.sys
 
       unless packet.identified?
         identified_command = System.commands.identify(packet.buffer, interface.target_names)

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

@@ -10,6 +10,7 @@
 
 require 'cosmos'
 require 'cosmos/gui/qt'
+require 'cosmos/gui/dialogs/interface_raw_dialog'
 
 module Cosmos
 
@@ -19,7 +20,8 @@ module Cosmos
     ROUTERS = 'Routers'
     ALIGN_CENTER = Qt::AlignCenter
 
-    def initialize
+    def initialize(server_gui)
+      @server_gui = server_gui
       @interfaces_table = {}
     end
 
@@ -102,11 +104,11 @@ module Cosmos
       interfaces_table = Qt::TableWidget.new()
       interfaces_table.verticalHeader.hide()
       interfaces_table.setRowCount(interfaces.all.length)
-      interfaces_table.setColumnCount(10)
+      interfaces_table.setColumnCount(11)
       if name == ROUTERS
-        interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Pkts Rcvd  ", "  Pkts Sent  "])
+        interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Pkts Rcvd  ", "  Pkts Sent  ", "View Raw"])
       else
-        interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts "])
+        interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts ", "View Raw"])
       end
 
       populate_interface_table(name, interfaces, interfaces_table)
@@ -137,6 +139,17 @@ module Cosmos
           interfaces_table.setItem(row, index, item)
           index += 1
         end
+        view_raw = Qt::PushButton.new("View Raw")
+        view_raw.connect(SIGNAL('clicked()')) do
+          @raw_dialogs ||= []
+          if name == ROUTERS
+            current_interface = CmdTlmServer.routers.all[interface_name]
+          else
+            current_interface = CmdTlmServer.interfaces.all[interface_name]
+          end
+          @raw_dialogs << InterfaceRawDialog.new(@server_gui, current_interface)
+        end
+        interfaces_table.setCellWidget(row, index, view_raw)
         row += 1
       end
     end

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

@@ -22,9 +22,6 @@ module Cosmos
     def populate(tab_widget)
       num_targets = System.targets.length
       if num_targets > 0
-        return if num_targets == 1 and System.targets['SYSTEM']
-        num_targets -= 1 if System.targets['SYSTEM']
-
         scroll = Qt::ScrollArea.new
         widget = Qt::Widget.new
         layout = Qt::VBoxLayout.new(widget)
@@ -51,7 +48,6 @@ module Cosmos
     def update
       row = 0
       System.targets.sort.each do |target_name, target|
-        next if target_name == 'SYSTEM'
         @targets_table.item(row,2).setText(target.cmd_cnt.to_s)
         @targets_table.item(row,3).setText(target.tlm_cnt.to_s)
         row += 1
@@ -63,7 +59,6 @@ module Cosmos
     def populate_targets_table
       row = 0
       System.targets.sort.each do |target_name, target|
-        next if target_name == 'SYSTEM'
         target_name_widget = Qt::TableWidgetItem.new(Qt::Object.tr(target_name))
         target_name_widget.setTextAlignment(Qt::AlignCenter)
         @targets_table.setItem(row, 0, target_name_widget)

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

@@ -93,7 +93,7 @@ module Cosmos
                     next
                   end
                 end
-                packet.received_time = Time.now unless packet.received_time
+                packet.received_time = Time.now.sys unless packet.received_time
               rescue Exception => err
                 handle_connection_lost(err)
                 if @cancel_thread
@@ -179,7 +179,6 @@ module Cosmos
         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

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

@@ -114,15 +114,15 @@ module Cosmos
 
     # Get info about an interface by name
     #
-    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric, 
-    #   Numeric, Numeric>] Array containing \[state, num_clients, 
-    #   write_queue_size, read_queue_size, bytes_written, bytes_read, 
+    # @return [Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>] Array containing \[state, num_clients,
+    #   write_queue_size, read_queue_size, bytes_written, bytes_read,
     #   write_count, read_count] for the interface
     def get_info(interface_name)
       interface = @config.interfaces[interface_name.upcase]
       raise "Unknown interface: #{interface_name}" unless interface
 
-      return [state(interface_name),      interface.num_clients, 
+      return [state(interface_name),      interface.num_clients,
               interface.write_queue_size, interface.read_queue_size,
               interface.bytes_written,    interface.bytes_read,
               interface.write_count,      interface.read_count]

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

@@ -0,0 +1,121 @@
+# 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/background_task'
+
+module Cosmos
+  # Monitors telemetry and enables and disables limits groups
+  class LimitsGroupsBackgroundTask < BackgroundTask
+    attr_reader :groups
+    # Time in the future that we will never hit to allow the logic to work
+    FUTURE_TIME = Time.new("3000")
+    PAST_TIME = Time.new("1900")
+
+    def initialize(initial_delay = 0)
+      super()
+      @initial_delay = Float(initial_delay)
+      @name = "Limits Groups"
+      @groups = get_limits_groups()
+      # Initialize all the group names as instance variables
+      @groups.each {|group| self.instance_variable_set("@#{group.downcase}", nil) }
+    end
+
+    # Enables and disables COSMOS limits groups. The group named after the
+    # passed group variable is automatically enabled and disabled when the
+    # yielded to block returns true and false respectively. In addition, any
+    # groups with the same name and a _PRI or _RED extension are also enabled
+    # or disabled with the base group.
+    #
+    # @param delay [Integer] The amount of time to wait after detecting the group
+    #   power on condition before actually enabling the group. A delay
+    #   allows time for telemetry to stability to avoid false positives.
+    # @param enable_code [Proc] Code to execute when the group is enabled
+    # @param disable_code [Proc] Code to execute when the group is disabled
+    def process_group(delay = 0, enable_code = nil, disable_code = nil)
+      group = calling_method.to_s[6..-1]
+
+      # Grab the instance variable based on the group name
+      var_name = "@#{group}"
+      var = self.instance_variable_get(var_name)
+      # Yield to the block to perform the telemetry check
+      if yield
+        # If the instance variable is not set or set in the past
+        # (by the disable logic) it means the group isn't enabled
+        # so store the current time to allow for an enable delay
+        if !var || var == PAST_TIME
+          self.instance_variable_set(var_name, Time.now)
+          # After setting the variable we need to get it again
+          var = self.instance_variable_get(var_name)
+        end
+        # After the requested delay after power on we enable the group
+        if Time.now > (var + delay)
+          # Reset the instance variable to a distance future time
+          # so it won't satisfy any of the other checks and enable the group
+          self.instance_variable_set(var_name, FUTURE_TIME)
+          enable_limits_group(group)
+          # Call any additional enable code passed to the method
+          enable_code.call if enable_code
+        end
+      else
+        # If the instance variable is not set or set in the future
+        # (by the enable logic) it means the group isn't disabled
+        # Reset the instance variable to a distance past time so it
+        # won't satisfy any of the other checks and disable the group
+        if !var || var == FUTURE_TIME
+          self.instance_variable_set(var_name, PAST_TIME)
+          disable_limits_group(group)
+          # Call any additional disable code passed to the method
+          disable_code.call if disable_code
+        end
+      end
+    end
+
+    def call
+      @status = "Starting the LimitsGroupsBackgroundTask"
+      check_methods = find_check_methods()
+      sleep @initial_delay
+      @sleeper = Sleeper.new
+      loop do
+        start = Time.now
+        check_methods.each {|method| self.send(method.intern) }
+        now = Time.now
+        @status = "#{now.formatted}: Checking groups took #{now - start}s"
+        sleep_time = 1 - (now - start)
+        sleep_time = 0 if sleep_time < 0
+        broken = @sleeper.sleep(sleep_time) # Run the checks at 1Hz
+        break if broken
+      end
+    end
+
+    def stop
+      @sleeper.cancel
+    end
+
+    protected
+
+    def find_check_methods
+      # Find all the check methods (begins with 'check_')
+      check_methods = []
+      self.class.instance_methods.each do |method_name|
+        if method_name.to_s =~ /^check_/
+          # The second part of the method must correspond to a group name
+          if @groups.include?(method_name.to_s[6..-1].upcase)
+            check_methods << method_name.to_s
+          else
+            raise "Method #{method_name} doesn't match a group name.\n"\
+              "Methods must begin with 'check_' and end with a valid group name.\n"\
+              "Groups are #{@groups.join(', ')}."
+          end
+        end
+      end
+      check_methods.sort # Sort by name
+    end
+  end
+end