cosmos 4.5.2 → 5.0.3

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

@@ -1,270 +0,0 @@
-# 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/gui/qt'
-
-module Cosmos
-  # Implements the status tab in the Command and Telemetry Server GUI
-  class StatusTab
-    def initialize(tab_widget)
-      @widget = nil
-      reset()
-      @scroll = Qt::ScrollArea.new
-      tab_widget.addTab(@scroll, "Status")
-    end
-
-    def reset
-      Qt.execute_in_main_thread(true) do
-        @widget.destroy if @widget
-        @widget = nil
-      end
-    end
-
-    # Create the status tab and add it to the tab_widget
-    def populate
-      reset()
-      @widget = Qt::Widget.new
-      layout = Qt::VBoxLayout.new(@widget)
-
-      populate_limits_status(layout)
-      populate_api_status(layout)
-      populate_system_status(layout)
-      populate_background_status(layout)
-
-      @scroll.setWidget(@widget)
-    end
-
-    # Update the status tab in the GUI
-    def update
-      update_limits_set()
-      update_api_status()
-      update_system_status()
-      update_background_task_status()
-    end
-
-    private
-
-    def populate_limits_status(layout)
-      limits = Qt::GroupBox.new("Limits Status")
-      limits_layout = Qt::FormLayout.new(limits)
-      current_limits_set = System.limits_set.to_s
-
-      known_limits_sets = System.limits.sets
-      known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
-      current_index = known_limits_sets.index(current_limits_set.to_s)
-
-      @limits_set_combo = Qt::ComboBox.new
-      limits_layout.addRow("Limits Set:", @limits_set_combo)
-      layout.addWidget(limits)
-
-      known_limits_sets.sort.each do |limits_set|
-        @limits_set_combo.addItem(limits_set.to_s)
-      end
-      @limits_set_combo.setMaxVisibleItems(6)
-      @limits_set_combo.setCurrentIndex(current_index)
-      # Only connect to the signal that is sent when the user chooses an item.
-      # If the limits set is changed programatically the code in
-      # handle_status_tab will pick up the change.
-      @limits_set_combo.connect(SIGNAL('activated(int)')) do
-        selected_limits_set = @limits_set_combo.currentText
-        if selected_limits_set
-          System.limits_set = selected_limits_set.intern if System.limits_set != selected_limits_set.intern
-        end
-      end
-    end
-
-    def populate_api_status(layout)
-      if CmdTlmServer.json_drb
-        @previous_request_count = CmdTlmServer.json_drb.request_count
-      else
-        @previous_request_count = 0
-      end
-
-      api = Qt::GroupBox.new("API Status")
-      api_layout = Qt::VBoxLayout.new(api)
-      @api_table = Qt::TableWidget.new()
-      @api_table.verticalHeader.hide()
-      @api_table.setRowCount(1)
-      @api_table.setColumnCount(6)
-      @api_table.setHorizontalHeaderLabels(["Port", "Num Clients", "Requests", "Requests/Sec", "Avg Request Time", "Estimated Utilization"])
-
-      if CmdTlmServer.mode == :CMD_TLM_SERVER
-        @api_table.setItem(0, 0, Qt::TableWidgetItem.new(System.ports['CTS_API'].to_s))
-      else
-        @api_table.setItem(0, 0, Qt::TableWidgetItem.new(System.ports['REPLAY_API'].to_s))
-      end
-      item0 = Qt::TableWidgetItem.new(CmdTlmServer.json_drb.num_clients.to_s)
-      item0.setTextAlignment(Qt::AlignCenter)
-      @api_table.setItem(0, 1, item0)
-      item = Qt::TableWidgetItem.new(@previous_request_count.to_s)
-      item.setTextAlignment(Qt::AlignCenter)
-      @api_table.setItem(0, 2, item)
-      item2 = Qt::TableWidgetItem.new("0.0")
-      item2.setTextAlignment(Qt::AlignCenter)
-      @api_table.setItem(0, 3, item2)
-      item3 = Qt::TableWidgetItem.new("0.0")
-      item3.setTextAlignment(Qt::AlignCenter)
-      @api_table.setItem(0, 4, item3)
-      item4 = Qt::TableWidgetItem.new("0.0")
-      item4.setTextAlignment(Qt::AlignCenter)
-      @api_table.setItem(0, 5, item4)
-      @api_table.displayFullSize
-      api_layout.addWidget(@api_table)
-      layout.addWidget(api)
-    end
-
-    def populate_system_status(layout)
-      system = Qt::GroupBox.new("System Status")
-      system_layout = Qt::VBoxLayout.new(system)
-      @system_table = Qt::TableWidget.new()
-      @system_table.verticalHeader.hide()
-      @system_table.setRowCount(1)
-      @system_table.setColumnCount(4)
-      @system_table.setHorizontalHeaderLabels(["Threads", "Total Objs", "Free Objs", "Allocated Objs"])
-
-      item0 = Qt::TableWidgetItem.new("0")
-      item0.setTextAlignment(Qt::AlignCenter)
-      @system_table.setItem(0, 0, item0)
-      item1 = Qt::TableWidgetItem.new("0.0")
-      item1.setTextAlignment(Qt::AlignCenter)
-      @system_table.setItem(0, 1, item1)
-      item2 = Qt::TableWidgetItem.new("0.0")
-      item2.setTextAlignment(Qt::AlignCenter)
-      @system_table.setItem(0, 2, item2)
-      item3 = Qt::TableWidgetItem.new("0.0")
-      item3.setTextAlignment(Qt::AlignCenter)
-      @system_table.setItem(0, 3, item3)
-      @system_table.displayFullSize
-      system_layout.addWidget(@system_table)
-      layout.addWidget(system)
-    end
-
-    def populate_background_status(layout)
-      background_tasks_groupbox = Qt::GroupBox.new("Background Tasks")
-      background_tasks_layout = Qt::VBoxLayout.new(background_tasks_groupbox)
-      @background_tasks_table = Qt::TableWidget.new()
-      @background_tasks_table.verticalHeader.hide()
-      @background_tasks_table.setRowCount(CmdTlmServer.background_tasks.all.length)
-      @background_tasks_table.setColumnCount(4)
-      @background_tasks_table.setHorizontalHeaderLabels(["Name", "State", "Status", "Control"])
-
-      background_tasks = CmdTlmServer.background_tasks.all
-      if background_tasks.length > 0
-        row = 0
-        background_tasks.each_with_index do |background_task, index|
-          background_task_name_widget = Qt::TableWidgetItem.new(background_task.name)
-          background_task_name_widget.setTextAlignment(Qt::AlignCenter)
-          @background_tasks_table.setItem(row, 0, background_task_name_widget)
-          button_text = 'START'
-          if background_task.thread
-            status = background_task.thread.status
-            status = 'complete' if status == false
-            background_task_state_widget = Qt::TableWidgetItem.new(status.to_s)
-            button_text = background_task.thread.alive? ? 'STOP' : 'START'
-          else
-            background_task_state_widget = Qt::TableWidgetItem.new('no thread')
-          end
-          background_task_state_widget.setTextAlignment(Qt::AlignCenter)
-          background_task_state_widget.setSizeHint(Qt::Size.new(80, 30))
-          @background_tasks_table.setItem(row, 1, background_task_state_widget)
-          background_task_status_widget = Qt::TableWidgetItem.new(background_task.status.to_s)
-          background_task_status_widget.setTextAlignment(Qt::AlignCenter)
-          background_task_status_widget.setSizeHint(Qt::Size.new(400, 30))
-          @background_tasks_table.setItem(row, 2, background_task_status_widget)
-
-          background_task_button = Qt::PushButton.new(button_text)
-          background_task_button.connect(SIGNAL('clicked()')) { start_stop_task(background_task_button) }
-          @background_tasks_table.setCellWidget(row, 3, background_task_button)
-          row += 1
-        end
-      end
-      @background_tasks_table.displayFullSize
-      background_tasks_layout.addWidget(@background_tasks_table)
-      layout.addWidget(background_tasks_groupbox)
-    end
-
-    # Update the current limits set in the GUI
-    def update_limits_set
-      current_limits_set = System.limits_set.to_s
-      if @limits_set_combo.currentText != current_limits_set
-        known_limits_sets = System.limits.sets
-        known_limits_sets = known_limits_sets.map {|x| x.to_s}.sort
-        current_index = known_limits_sets.index(current_limits_set.to_s)
-        @limits_set_combo.clear
-        known_limits_sets.sort.each do |limits_set|
-          @limits_set_combo.addItem(limits_set.to_s)
-        end
-        @limits_set_combo.setCurrentIndex(current_index)
-      end
-    end
-
-    # Update the API statistics in the GUI
-    def update_api_status
-      if CmdTlmServer.json_drb
-        @api_table.item(0,1).setText(CmdTlmServer.json_drb.num_clients.to_s)
-        @api_table.item(0,2).setText(CmdTlmServer.json_drb.request_count.to_s)
-        request_count = CmdTlmServer.json_drb.request_count
-        requests_per_second = request_count - @previous_request_count
-        @api_table.item(0,3).setText(requests_per_second.to_s)
-        @previous_request_count = request_count
-        average_request_time = CmdTlmServer.json_drb.average_request_time
-        @api_table.item(0,4).setText(sprintf("%0.6f s", average_request_time))
-        estimated_utilization = requests_per_second * average_request_time * 100.0
-        @api_table.item(0,5).setText(sprintf("%0.2f %%", estimated_utilization))
-      end
-    end
-
-    # Update the Ruby system statistics in the GUI
-    def update_system_status
-      @system_table.item(0,0).setText(Thread.list.length.to_s)
-      objs = ObjectSpace.count_objects
-      @system_table.item(0,1).setText(objs[:TOTAL].to_s)
-      @system_table.item(0,2).setText(objs[:FREE].to_s)
-      total = 0
-      objs.each do |key, val|
-        next if key == :TOTAL || key == :FREE
-        total += val
-      end
-      @system_table.item(0,3).setText(total.to_s)
-    end
-
-    # Update the background task status in the GUI
-    def update_background_task_status
-      background_tasks = CmdTlmServer.background_tasks.all
-      if background_tasks.length > 0
-        row = 0
-        background_tasks.each_with_index do |background_task, index|
-          if background_task.thread
-            status = background_task.thread.status
-            status = 'complete' if status == false
-            @background_tasks_table.item(row, 1).setText(status.to_s)
-            text = background_task.thread.alive? ? 'STOP' : 'START'
-            @background_tasks_table.cellWidget(row, 3).setText(text)
-          else
-            @background_tasks_table.item(row, 1).setText('no thread')
-          end
-          @background_tasks_table.item(row, 2).setText(background_task.status.to_s)
-          row += 1
-        end
-      end
-    end
-
-    # Start or stop the background task
-    def start_stop_task(button)
-      row = @background_tasks_table.indexAt(button.pos()).row
-      if button.text == 'STOP'
-        CmdTlmServer.background_tasks.stop(row)
-      else
-        CmdTlmServer.background_tasks.start(row)
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-# 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/gui/qt'
-
-module Cosmos
-  # Implements the targets tab in the Command and Telemetry Server GUI
-  class TargetsTab
-    def initialize(tab_widget)
-      @widget = nil
-      reset()
-      @scroll = Qt::ScrollArea.new
-      tab_widget.addTab(@scroll, "Targets")
-    end
-
-    def reset
-      Qt.execute_in_main_thread(true) do
-        @widget.destroy if @widget
-        @widget = nil
-      end
-    end
-
-    # Create the targets tab and add it to the tab_widget
-    def populate
-      reset()
-      num_targets = System.targets.length
-      if num_targets > 0
-        @widget = Qt::Widget.new
-        layout = Qt::VBoxLayout.new(@widget)
-        # Since the layout will be inside a scroll area make sure it respects the sizes we set
-        layout.setSizeConstraint(Qt::Layout::SetMinAndMaxSize)
-
-        @targets_table = Qt::TableWidget.new()
-        @targets_table.verticalHeader.hide()
-        @targets_table.setRowCount(num_targets)
-        @targets_table.setColumnCount(4)
-        @targets_table.setHorizontalHeaderLabels(["Target Name", "Interface", "Command Count", "Telemetry Count"])
-
-        populate_targets_table()
-
-        @targets_table.displayFullSize
-
-        layout.addWidget(@targets_table)
-        @scroll.setWidget(@widget)
-      end
-    end
-
-    # Update the targets tab gui
-    def update
-      row = 0
-      System.targets.sort.each do |target_name, target|
-        @targets_table.item(row,2).setText(target.cmd_cnt.to_s)
-        @targets_table.item(row,3).setText(target.tlm_cnt.to_s)
-        row += 1
-      end
-    end
-
-    private
-
-    def populate_targets_table
-      row = 0
-      System.targets.sort.each do |target_name, target|
-        target_name_widget = Qt::TableWidgetItem.new(target_name)
-        target_name_widget.setTextAlignment(Qt::AlignCenter)
-        @targets_table.setItem(row, 0, target_name_widget)
-        if target.interface
-          interface_name_widget = Qt::TableWidgetItem.new(target.interface.name.to_s)
-        else
-          interface_name_widget = Qt::TableWidgetItem.new('')
-        end
-        interface_name_widget.setTextAlignment(Qt::AlignCenter)
-        @targets_table.setItem(row, 1, interface_name_widget)
-        cmd_cnt = Qt::TableWidgetItem.new(target.cmd_cnt.to_s)
-        cmd_cnt.setTextAlignment(Qt::AlignCenter)
-        @targets_table.setItem(row, 2, cmd_cnt)
-
-        tlm_cnt = Qt::TableWidgetItem.new(target.tlm_cnt.to_s)
-        tlm_cnt.setTextAlignment(Qt::AlignCenter)
-        @targets_table.setItem(row, 3, tlm_cnt)
-
-        row += 1
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# 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
-
-    # Get the targets of an interface
-    #
-    # @param interface_name [String] Interface to return target list
-    # @return [Array<String>] All the targets mapped to this interface
-    def targets(interface_name)
-      interface = @config.interfaces[interface_name.upcase]
-      raise "Unknown interface: #{interface_name}" unless interface
-      interface.target_names
-    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
-
-    # 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,
-    #   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,
-              interface.write_queue_size, interface.read_queue_size,
-              interface.bytes_written,    interface.bytes_read,
-              interface.write_count,      interface.read_count]
-    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

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

@@ -1,124 +0,0 @@
-# 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, task_delay = 0.5)
-      super()
-      @initial_delay = Float(initial_delay)
-      @task_delay = Float(task_delay)
-      @name = "Limits Groups"
-      @groups = get_limits_groups()
-      @sleeper = Sleeper.new
-      # 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"
-      @sleeper = Sleeper.new
-      check_methods = find_check_methods()
-      return if @sleeper.sleep(@initial_delay)
-      loop do
-        start = Time.now
-        check_methods.each {|method| self.public_send(method.intern) }
-        now = Time.now
-        @status = "#{now.formatted}: Checking groups took #{now - start}s"
-        sleep_time = @task_delay - (now - start)
-        sleep_time = 0 if sleep_time < 0
-        return if @sleeper.sleep(sleep_time)
-      end
-    end
-
-    def stop
-      @sleeper.cancel
-      @status = "Stopped at #{Time.now.sys.formatted}"
-    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
-            Logger.warn "Inside class #{self.class}, method #{method_name} doesn't match a group name.\n"\
-              "Methods must begin with 'check_' and end with a valid group name.\n"\
-              "You need to declare 'LIMITS_GROUP #{method_name.to_s[6..-1].upcase}' for #{method_name} to work.\n"\
-              "Currently defined groups: #{@groups.join(', ')}\n"\
-          end
-        end
-      end
-      check_methods.sort # Sort by name
-    end
-  end
-end