cosmos 3.9.1 → 3.9.2

data/lib/cosmos/gui/utilities/analyze_log.rb

@@ -0,0 +1,153 @@
+# 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
+
+  # Class to analyze log files and report packet counts.
+  class AnalyzeLog
+
+    def initialize(parent, packet_log_frame)
+      @parent = parent
+      @packet_log_frame = packet_log_frame
+      @input_filenames = []
+      @packet_log_reader = System.default_packet_log_reader.new
+      @time_start = nil
+      @time_end = nil
+      @cancel = false
+    end
+
+    def analyze_log_files
+      @cancel = false
+      pkt_counts = {}
+      begin
+        @packet_log_reader = @packet_log_frame.packet_log_reader
+        @input_filenames = @packet_log_frame.filenames.sort
+        @time_start = @packet_log_frame.time_start
+        @time_end = @packet_log_frame.time_end
+        unless @input_filenames and @input_filenames[0]
+          Qt::MessageBox.critical(@parent, 'Error', 'Please select at least 1 input file')
+          return
+        end
+
+        ProgressDialog.execute(@parent, # parent
+                               'Log File Progress', # title
+                               600, # width, height
+                               300) do |progress_dialog|
+          progress_dialog.cancel_callback = method(:cancel_callback)
+          progress_dialog.enable_cancel_button
+
+          begin
+            Cosmos.set_working_dir do
+              pkt_counts = analyze_files(progress_dialog)
+            end
+          ensure
+            progress_dialog.complete
+          end
+        end
+
+        if !@cancel
+          results = "Log Analysis Complete.\n"
+          results << "Log Reader: #{@packet_log_reader.class.to_s}\n"
+          if @time_start
+            results << "Start time: #{@time_start.formatted}\n"
+          else
+            results << "Start time: not specified\n"
+          end
+          if @time_end
+            results << "End time:   #{@time_end.formatted}\n"
+          else
+            results << "End time:   not specified\n"
+          end
+          results << "\n"
+
+          if pkt_counts.empty?
+            results << "No files analyzed"
+          else
+            if pkt_counts.keys.size > 1
+              pkt_counts_total = {}
+              pkt_counts.each do |file, counts|
+                counts.each do |pkt, count|
+                  pkt_counts_total[pkt] ||= 0
+                  pkt_counts_total[pkt] += count
+                end
+              end
+              results << "Total count of packets found in all files:\n"
+              pkt_counts_total.keys.sort.each do |pkt|
+                results << "#{pkt}: #{pkt_counts_total[pkt]}\n"
+              end
+              results << "\n"
+            end
+
+            pkt_counts.each do |file, counts|
+              results << "Packets found in file: #{file}\n"
+              if counts.empty?
+                results << "  No packets found\n"
+              else
+                counts.keys.sort.each do |pkt|
+                  results << "#{pkt}: #{counts[pkt]}\n"
+                end
+              end
+              results << "\n"
+            end
+          end
+          ScrollTextDialog.new(@parent, 'Packet Counts', results)
+        end
+
+      rescue => error
+        Qt::MessageBox.critical(@parent, 'Error!', "Error Analyzing Log File(s)\n#{error.formatted}")
+      end
+    end
+
+    def analyze_files(progress_dialog)
+      log_file_count = 1
+      pkt_counts = {}
+      @input_filenames.each do |log_file|
+        break if @cancel
+        begin
+          Cosmos.check_log_configuration(@packet_log_reader, log_file)
+          file_size = File.size(log_file).to_f
+          progress_dialog.append_text("Analyzing File #{log_file_count}/#{@input_filenames.length}: #{log_file}")
+          progress_dialog.set_step_progress(0.0)
+          @packet_log_reader.each(
+            log_file, # log filename
+            true,     # identify and define packet
+            @time_start,
+            @time_end) do |packet|
+
+            break if @cancel
+            progress_dialog.set_step_progress(@packet_log_reader.bytes_read / file_size)
+            pkt_counts[log_file] ||= {}
+            pkt_counts[log_file]["#{packet.target_name} #{packet.packet_name}"] ||= 0
+            pkt_counts[log_file]["#{packet.target_name} #{packet.packet_name}"] += 1       
+          end
+          progress_dialog.set_step_progress(1.0) if !@cancel
+          progress_dialog.set_overall_progress(log_file_count.to_f / @input_filenames.length.to_f) if !@cancel
+        rescue Exception => error
+          progress_dialog.append_text("Error analyzing: #{error.formatted}\n")
+        end
+        log_file_count += 1
+      end
+      return pkt_counts
+    end
+
+    def cancel_callback(progress_dialog = nil)
+      @cancel = true
+      return true, false
+    end
+
+    def self.execute(parent, packet_log_frame)
+      log_analyzer = AnalyzeLog.new(parent, packet_log_frame)
+      log_analyzer.analyze_log_files()
+    end
+
+
+  end # class AnalyzeLog
+
+end # module Cosmos

data/lib/cosmos/interfaces/interface.rb

@@ -53,6 +53,10 @@ module Cosmos
     #   read from the interface
     attr_accessor :routers
 
+    # @return [Array<Routers>] Array of cmd routers that mirror packets
+    #   sent from the interface
+    attr_accessor :cmd_routers
+
     # @return [Integer] The number of packets read from this interface
     attr_accessor :read_count
 
@@ -96,6 +100,7 @@ module Cosmos
       @packet_log_writer_pairs = []
       @raw_logger_pair = RawLoggerPair.new(@name)
       @routers = []
+      @cmd_routers = []
       @read_count = 0
       @write_count = 0
       @bytes_read = 0
@@ -193,6 +198,7 @@ module Cosmos
       other_interface.disable_disconnect = self.disable_disconnect
       other_interface.packet_log_writer_pairs = self.packet_log_writer_pairs.clone
       other_interface.routers = self.routers.clone
+      other_interface.cmd_routers = self.cmd_routers.clone
       other_interface.read_count = self.read_count
       other_interface.write_count = self.write_count
       other_interface.bytes_read = self.bytes_read

data/lib/cosmos/packets/packet_item_limits.rb

@@ -91,12 +91,24 @@ module Cosmos
     end
 
     def persistence_setting=(persistence_setting)
-      raise ArgumentError, "persistence_setting must be a Fixnum but is a #{persistence_setting.class}" unless Fixnum === persistence_setting
+      if 0.class == Integer
+        # Ruby version >= 2.4.0
+        raise ArgumentError, "persistence_setting must be an Integer but is a #{persistence_setting.class}" unless Integer === persistence_setting
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "persistence_setting must be a Fixnum but is a #{persistence_setting.class}" unless Fixnum === persistence_setting
+      end
       @persistence_setting = persistence_setting
     end
 
     def persistence_count=(persistence_count)
-      raise ArgumentError, "persistence_count must be a Fixnum but is a #{persistence_count.class}" unless Fixnum === persistence_count
+      if 0.class == Integer
+        # Ruby version >= 2.4.0
+        raise ArgumentError, "persistence_count must be an Integer but is a #{persistence_count.class}" unless Integer === persistence_count
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "persistence_count must be a Fixnum but is a #{persistence_count.class}" unless Fixnum === persistence_count
+      end
       @persistence_count = persistence_count
     end
 

data/lib/cosmos/packets/structure_item.rb

@@ -104,7 +104,14 @@ module Cosmos
     end
 
     def bit_offset=(bit_offset)
-      raise ArgumentError, "#{@name}: bit_offset must be a Fixnum" unless Fixnum === bit_offset
+      if 0.class == Integer
+        # Ruby version >= 2.4.0
+        raise ArgumentError, "#{@name}: bit_offset must be an Integer" unless Integer === bit_offset
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "#{@name}: bit_offset must be a Fixnum" unless Fixnum === bit_offset
+      end
+
       byte_aligned = ((bit_offset % 8) == 0)
       if (@data_type == :FLOAT or @data_type == :STRING or @data_type == :BLOCK) and !byte_aligned
         raise ArgumentError, "#{@name}: bit_offset for :FLOAT, :STRING, and :BLOCK items must be byte aligned"
@@ -118,7 +125,13 @@ module Cosmos
     end
 
     def bit_size=(bit_size)
-      raise ArgumentError, "#{name}: bit_size must be a Fixnum" unless Fixnum === bit_size
+      if 0.class == Integer
+        # Ruby version >=  2.4.0
+        raise ArgumentError, "#{name}: bit_size must be an Integer" unless Integer === bit_size
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "#{name}: bit_size must be a Fixnum" unless Fixnum === bit_size
+      end
       byte_multiple = ((bit_size % 8) == 0)
       if bit_size <= 0 and (@data_type == :INT or @data_type == :UINT or @data_type == :FLOAT)
         raise ArgumentError, "#{@name}: bit_size cannot be negative or zero for :INT, :UINT, and :FLOAT items: #{bit_size}"
@@ -150,7 +163,13 @@ module Cosmos
 
     def array_size=(array_size)
       if array_size
-        raise ArgumentError, "#{@name}: array_size must be a Fixnum" unless Fixnum === array_size
+        if 0.class == Integer
+          # Ruby version >=  2.4.0
+          raise ArgumentError, "#{@name}: array_size must be an Integer" unless Integer === array_size
+        else
+          # Ruby version < 2.4.0
+          raise ArgumentError, "#{@name}: array_size must be a Fixnum" unless Fixnum === array_size
+        end
         raise ArgumentError, "#{@name}: array_size must be a multiple of bit_size" unless (@bit_size == 0 or (array_size % @bit_size == 0) or array_size < 0)
         raise ArgumentError, "#{@name}: bit_size cannot be negative or zero for array items" if @bit_size <= 0
       end

data/lib/cosmos/script/cmd_tlm_server.rb

@@ -13,6 +13,10 @@ module Cosmos
   module Script
     private
 
+    def get_interface_targets(interface_name)
+      return $cmd_tlm_server.get_interface_targets(interface_name)
+    end
+
     def get_interface_names
       return $cmd_tlm_server.get_interface_names
     end
@@ -49,6 +53,30 @@ module Cosmos
       return $cmd_tlm_server.router_state(router_name)
     end
 
+    def get_target_info(target_name)
+      return $cmd_tlm_server.get_target_info(target_name)
+    end
+
+    def get_interface_info(interface_name)
+      return $cmd_tlm_server.get_interface_info(interface_name)
+    end
+
+    def get_router_info(router_name)
+      return $cmd_tlm_server.get_router_info(router_name)
+    end
+
+    def get_cmd_cnt(target_name, command_name)
+      return $cmd_tlm_server.get_cmd_cnt(target_name, command_name)
+    end
+
+    def get_tlm_cnt(target_name, packet_name)
+      return $cmd_tlm_server.get_tlm_cnt(target_name, packet_name)
+    end
+
+    def get_packet_logger_info(packet_logger_name)
+      return $cmd_tlm_server.get_packet_logger_info(packet_logger_name)
+    end
+
     def get_cmd_log_filename(packet_log_writer_name = 'DEFAULT')
       return $cmd_tlm_server.get_cmd_log_filename(packet_log_writer_name)
     end

data/lib/cosmos/script/extract.rb

@@ -11,7 +11,7 @@
 module Cosmos
 
   module Extract
-    SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[.*\]) | \S+ }x #"
+    SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.)*\]) | \S+ }x #"
 
     private
 
@@ -26,22 +26,23 @@ module Cosmos
 
     def extract_fields_from_cmd_text(text)
       split_string = text.split(/\s+with\s+/i, 2)
-      raise "ERROR: 'with' must be followed by parameters : #{text}" if split_string.length == 1 and text =~ /\s*with\s*/i
+      raise "ERROR: text must not be empty" if split_string.length == 0
+      raise "ERROR: 'with' must be followed by parameters : #{text}" if (split_string.length == 1 and text =~ /\s*with\s*/i) or (split_string.length == 2 and split_string[1].empty?)
 
       # Extract target_name and cmd_name
       first_half = split_string[0].split
       raise "ERROR: Both Target Name and Command Name must be given : #{text}" if first_half.length < 2
       raise "ERROR: Only Target Name and Command Name must be given before 'with' : #{text}" if first_half.length > 2
       target_name = first_half[0]
-      cmd_name    = first_half[1]
-      cmd_params  = {}
+      cmd_name = first_half[1]
+      cmd_params = {}
 
       if split_string.length == 2
         # Extract Command Parameters
         second_half = split_string[1].scan(SCANNING_REGULAR_EXPRESSION)
-        keyword  = nil
-        value    = nil
-        comma    = nil
+        keyword = nil
+        value = nil
+        comma = nil
         second_half.each do |item|
           unless keyword
             keyword = item
@@ -61,8 +62,8 @@ module Cosmos
           end
           add_cmd_parameter(keyword, value, cmd_params)
           keyword = nil
-          value   = nil
-          comma   = nil
+          value = nil
+          comma = nil
         end
         if keyword
           if value

data/lib/cosmos/script/tools.rb

@@ -18,18 +18,24 @@ module Cosmos
     #######################################
 
     def display(display_name, x_pos = nil, y_pos = nil)
-      run_tlm_viewer(display_name, "displayed") do |tlm_viewer|
+      run_tlm_viewer("display", display_name) do |tlm_viewer|
         tlm_viewer.display(display_name, x_pos, y_pos)
       end
     end
 
     def clear(display_name)
-      run_tlm_viewer(display_name, "cleared") do |tlm_viewer|
+      run_tlm_viewer("clear", display_name) do |tlm_viewer|
         tlm_viewer.clear(display_name)
       end
     end
 
-    def run_tlm_viewer(display_name, action)
+    def clear_all(target = nil)
+      run_tlm_viewer("clear_all") do |tlm_viewer|
+        tlm_viewer.clear_all(target)
+      end
+    end
+
+    def run_tlm_viewer(action, display_name = '')
       tlm_viewer = JsonDRbObject.new "localhost", System.ports['TLMVIEWER_API']
       begin
         yield tlm_viewer
@@ -48,7 +54,7 @@ module Cosmos
             canceled = cosmos_script_sleep(1)
             retry unless canceled
           end
-          raise "Unable to Successfully Start Listening Telemetry Viewer: #{display_name} could not be #{action}"
+          raise "Unable to Successfully Start Listening Telemetry Viewer: Could not #{action} #{display_name}"
         rescue Errno::ENOENT
           raise "Display Screen File: #{display_name}.txt does not exist"
         end

data/lib/cosmos/system/system.rb

@@ -60,7 +60,7 @@ module Cosmos
     instance_attr_reader :limits_set
 
     # Known COSMOS ports
-    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED']
+    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER']
     # Known COSMOS paths
     KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES']
 
@@ -94,6 +94,7 @@ module Cosmos
       @ports['CTS_API'] = 7777
       @ports['TLMVIEWER_API'] = 7778
       @ports['CTS_PREIDENTIFIED'] = 7779
+      @ports['CTS_CMD_ROUTER'] = 7780
 
       @paths = {}
       @paths['LOGS'] = File.join(USERPATH, 'outputs', 'logs')

data/lib/cosmos/tools/cmd_extractor/cmd_extractor.rb

@@ -14,6 +14,7 @@ Cosmos.catch_fatal_exception do
   require 'cosmos/gui/dialogs/packet_log_dialog'
   require 'cosmos/gui/dialogs/splash'
   require 'cosmos/gui/dialogs/progress_dialog'
+  require 'cosmos/gui/utilities/analyze_log'
 end
 
 module Cosmos
@@ -52,6 +53,11 @@ module Cosmos
     def initialize_actions
       super()
 
+      # File Menu Actions
+      @analyze_log = Qt::Action.new(tr('&Analyze Logs'), self)
+      @analyze_log.statusTip = tr('Analyze log file packet counts')
+      @analyze_log.connect(SIGNAL('triggered()')) { analyze_log_files() }
+
       # Mode Menu Actions
       @include_raw = Qt::Action.new(tr('Include &Raw Data'), self)
       @include_raw_keyseq = Qt::KeySequence.new(tr('Ctrl+R'))
@@ -63,6 +69,8 @@ module Cosmos
     def initialize_menus
       # File Menu
       @file_menu = menuBar.addMenu(tr('&File'))
+      @file_menu.addAction(@analyze_log)
+      @file_menu.addSeparator()
       @file_menu.addAction(@exit_action)
 
       # Mode Menu
@@ -121,6 +129,10 @@ module Cosmos
     # File Menu Handlers
     ###############################################################################
 
+    def analyze_log_files
+      AnalyzeLog.execute(self, @packet_log_frame)
+    end
+
     def process_log_files
       @cancel = false
       begin

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

@@ -68,6 +68,7 @@ module Cosmos
         'subscribe_packet_data',
         'unsubscribe_packet_data',
         'get_packet_data',
+        'get_interface_targets',
         'get_interface_names',
         'connect_interface',
         'disconnect_interface',
@@ -77,6 +78,12 @@ module Cosmos
         'connect_router',
         'disconnect_router',
         'router_state',
+        'get_target_info',
+        'get_interface_info',
+        'get_router_info',
+        'get_cmd_cnt',
+        'get_tlm_cnt',
+        'get_packet_logger_info',
         'get_cmd_log_filename',
         'get_tlm_log_filename',
         'start_logging',
@@ -768,6 +775,11 @@ module Cosmos
     # Methods for scripting
     #
 
+    # @return [Array<String>] All the targets mapped to the given interface
+    def get_interface_targets(interface_name)
+      CmdTlmServer.interfaces.targets(interface_name)
+    end
+
     # @return [Array<String>] All the interface names
     def get_interface_names
       CmdTlmServer.interfaces.names
@@ -841,6 +853,78 @@ module Cosmos
       CmdTlmServer.routers.state(router_name)
     end
 
+    # Get information about a target
+    #
+    # @param target_name [String] Target name
+    # @return [Array<Numeric, Numeric>] Array of \[cmd_cnt, tlm_cnt]
+    def get_target_info(target_name)
+      target = System.targets[target_name.upcase]
+      raise "Unknown target: #{target_name}" unless target
+      return [target.cmd_cnt, target.tlm_cnt]
+    end
+
+    # 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, 
+    #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
+    #   Telemetry count] for the interface
+    def get_interface_info(interface_name)
+      CmdTlmServer.interfaces.get_info(interface_name)
+    end
+
+    # 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, 
+    #   TX queue size, RX queue size, TX bytes, RX bytes, Pkts received,
+    #   Pkts sent] for the router
+    def get_router_info(router_name)
+      CmdTlmServer.routers.get_info(router_name)
+    end
+
+    # Get the transmit count for a command packet
+    #
+    # @param target_name [String] Target name of the command
+    # @param command_name [String] Packet name of the command
+    # @return [Numeric] Transmit count for the command
+    def get_cmd_cnt(target_name, command_name)
+      packet = System.commands.packet(target_name, command_name)
+      return packet.received_count
+    end
+
+    # Get the receive count for a telemetry packet
+    #
+    # @param target_name [String] Name of the target
+    # @param packet_name [String] Name of the packet
+    # @return [Numeric] Receive count for the telemetry packet
+    def get_tlm_cnt(target_name, packet_name)
+      packet = System.telemetry.packet(target_name, packet_name)
+      return packet.received_count
+    end
+
+    # Get information about a packet logger.
+    #
+    # @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, 
+    #   tlm logging enabled, tlm queue size, tlm filename, tlm file size]
+    #   for the packet logger
+    def get_packet_logger_info(packet_logger_name = 'DEFAULT')
+      logger_info = CmdTlmServer.packet_logging.get_info(packet_logger_name)
+      packet_log_writer_pair = CmdTlmServer.packet_logging.all[packet_logger_name.upcase]
+      interfaces = []
+      CmdTlmServer.interfaces.all.each do |interface_name, interface|
+        if interface.packet_log_writer_pairs.include?(packet_log_writer_pair)
+          interfaces << interface.name
+        end
+      end
+      return [interfaces] + logger_info
+    end
+
     # @param packet_log_writer_name [String] The name of the packet log writer which
     #   is writing the command packet log
     # @return [String] The command packet log filename