cosmos 3.1.1 → 3.1.2

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

@@ -0,0 +1,189 @@
+# 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 interfaces and routers tabs in the Command and Telemetry Server GUI
+  class InterfacesTab
+    INTERFACES = 'Interfaces'
+    ROUTERS = 'Routers'
+
+    def initialize
+      @interfaces_table = {}
+    end
+
+    # Create the interfaces tab and add it to the tab_widget
+    #
+    # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
+    def populate_interfaces(tab_widget)
+      populate(INTERFACES, CmdTlmServer.interfaces, tab_widget)
+    end
+
+    # Create the routers tab and add it to the tab_widget
+    #
+    # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
+    def populate_routers(tab_widget)
+      populate(ROUTERS, CmdTlmServer.routers, tab_widget)
+    end
+
+    # Update the interfaces or routers tab
+    #
+    # @param name [String] Must be Interfaces or Routers
+    def update(name)
+      if name == ROUTERS
+        interfaces = CmdTlmServer.routers
+      else
+        interfaces = CmdTlmServer.interfaces
+      end
+      row = 0
+      interfaces.all.each do |interface_name, interface|
+        button = @interfaces_table[name].cellWidget(row,1)
+        state = @interfaces_table[name].item(row,2)
+        if interface.connected?
+          button.setText('Disconnect')
+          button.setDisabled(true) if interface.disable_disconnect
+          state.setText('true')
+          state.textColor = Cosmos::GREEN
+        elsif interface.thread
+          button.text = 'Cancel Connect'
+          button.setDisabled(false)
+          state.text = 'attempting'
+          state.textColor = Cosmos::RED
+        else
+          button.setText('Connect')
+          button.setDisabled(false)
+          state.setText('false')
+          state.textColor = Cosmos::BLACK
+        end
+        @interfaces_table[name].item(row,3).setText(interface.num_clients.to_s)
+        @interfaces_table[name].item(row,4).setText(interface.write_queue_size.to_s)
+        @interfaces_table[name].item(row,5).setText(interface.read_queue_size.to_s)
+        @interfaces_table[name].item(row,6).setText(interface.bytes_written.to_s)
+        @interfaces_table[name].item(row,7).setText(interface.bytes_read.to_s)
+        if name == ROUTERS
+          @interfaces_table[name].item(row,8).setText(interface.read_count.to_s)
+          @interfaces_table[name].item(row,9).setText(interface.write_count.to_s)
+        else
+          @interfaces_table[name].item(row,8).setText(interface.write_count.to_s)
+          @interfaces_table[name].item(row,9).setText(interface.read_count.to_s)
+        end
+        row += 1
+      end
+    end
+
+    private
+
+    def populate(name, interfaces, tab_widget)
+      return if interfaces.all.empty?
+
+      scroll = Qt::ScrollArea.new
+      scroll.setMinimumSize(800, 150)
+      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)
+
+      interfaces_table = Qt::TableWidget.new()
+      interfaces_table.verticalHeader.hide()
+      interfaces_table.setRowCount(interfaces.all.length)
+      interfaces_table.setColumnCount(10)
+      if name == ROUTERS
+        interfaces_table.setHorizontalHeaderLabels(["Router", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts  "])
+      else
+        interfaces_table.setHorizontalHeaderLabels(["Interface", "Connect/Disconnect", "Connected?", "Clients", "Tx Q Size", "Rx Q Size", "   Bytes Tx   ", "   Bytes Rx   ", "  Cmd Pkts  ", "  Tlm Pkts  "])
+      end
+
+      populate_interface_table(name, interfaces, interfaces_table)
+      interfaces_table.displayFullSize
+
+      layout.addWidget(interfaces_table)
+      scroll.setWidget(widget)
+      @interfaces_table[name] = interfaces_table
+      tab_widget.addTab(scroll, name)
+    end
+
+    def populate_interface_table(name, interfaces, interfaces_table)
+      row = 0
+      interfaces.all.each do |interface_name, interface|
+        item = Qt::TableWidgetItem.new(Qt::Object.tr(interface_name))
+        item.setTextAlignment(Qt::AlignCenter)
+        interfaces_table.setItem(row, 0, item)
+        interfaces_table.setCellWidget(row, 1, create_button(name, interface, interface_name))
+        interfaces_table.setItem(row, 2, create_state(interface))
+
+        index = 3
+        [interface.num_clients, interface.write_queue_size, interface.read_queue_size,
+          interface.bytes_written, interface.bytes_read,
+          interface.write_count, interface.read_count].each do |val|
+
+          item = Qt::TableWidgetItem.new(Qt::Object.tr(val.to_s))
+          item.setTextAlignment(Qt::AlignCenter)
+          interfaces_table.setItem(row, index, item)
+          index += 1
+        end
+        row += 1
+      end
+    end
+
+    def create_button(name, interface, interface_name)
+      if interface.connected?
+        button_text = 'Disconnect'
+      elsif interface.thread.nil?
+        button_text = 'Connect'
+      else
+        button_text = 'Cancel Connect'
+      end
+      button = Qt::PushButton.new(button_text)
+      if name == ROUTERS
+        button.connect(SIGNAL('clicked()')) do
+          if interface.thread
+            Logger.info "User disconnecting router #{interface_name}"
+            CmdTlmServer.instance.disconnect_router(interface_name)
+          else
+            Logger.info "User connecting router #{interface_name}"
+            CmdTlmServer.instance.connect_router(interface_name)
+          end
+        end
+      else
+        button.connect(SIGNAL('clicked()')) do
+          if interface.thread
+            Logger.info "User disconnecting interface #{interface_name}"
+            CmdTlmServer.instance.disconnect_interface(interface_name)
+          else
+            Logger.info "User connecting interface #{interface_name}"
+            CmdTlmServer.instance.connect_interface(interface_name)
+          end
+        end
+      end
+      button.setDisabled(true) if interface.disable_disconnect
+      button
+    end
+
+    def create_state(interface)
+      state = Qt::TableWidgetItem.new
+      if interface.connected?
+        state.setText('true')
+        state.textColor = Cosmos::GREEN
+      elsif interface.thread
+        state.setText('attempting')
+        state.textColor = Cosmos::YELLOW
+      else
+        state.setText('false')
+        state.textColor = Cosmos::BLACK
+      end
+      state.setTextAlignment(Qt::AlignCenter)
+      state
+    end
+
+  end
+end # module Cosmos

data/lib/cosmos/tools/cmd_tlm_server/gui/logging_tab.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'
+require 'cosmos/gui/qt'
+
+module Cosmos
+
+  # Implements the logging tab in the Command and Telemetry Server GUI
+  class LoggingTab
+
+    def initialize(production)
+      @production = production
+      @logging_layouts = {}
+    end
+
+    # Create the logging tab and add it to the tab_widget
+    #
+    # @param tab_widget [Qt::TabWidget] The tab widget to add the tab to
+    def populate(tab_widget)
+      scroll = Qt::ScrollArea.new
+      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)
+
+      populate_logging_actions(layout)
+
+      # Add the cmd/tlm log files information
+      populate_log_file_info(layout)
+
+      # Set the scroll area widget last now that all the items have been layed out
+      scroll.setWidget(widget)
+      tab_widget.addTab(scroll, "Logging")
+    end
+
+    def update
+      CmdTlmServer.packet_logging.all.each do |packet_log_writer_pair_name, packet_log_writer_pair|
+        @logging_layouts[packet_log_writer_pair_name].itemAt(1, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.logging_enabled.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(2, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.queue.size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(3, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.cmd_log_writer.filename)
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.cmd_log_writer.filename) if packet_log_writer_pair.cmd_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        @logging_layouts[packet_log_writer_pair_name].itemAt(4, Qt::FormLayout::FieldRole).widget.setText(file_size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(5, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.logging_enabled.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(6, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.queue.size.to_s)
+        @logging_layouts[packet_log_writer_pair_name].itemAt(7, Qt::FormLayout::FieldRole).widget.setText(packet_log_writer_pair.tlm_log_writer.filename)
+        file_size = 0
+        begin
+          file_size = File.size(packet_log_writer_pair.tlm_log_writer.filename) if packet_log_writer_pair.tlm_log_writer.filename
+        rescue Exception
+          # Do nothing on error
+        end
+        @logging_layouts[packet_log_writer_pair_name].itemAt(8, Qt::FormLayout::FieldRole).widget.setText(file_size.to_s)
+      end
+    end
+
+    private
+
+    def populate_logging_actions(layout)
+      # Add all the action buttons
+      actions = Qt::GroupBox.new(Qt::Object.tr("Actions"))
+      actions_layout = Qt::VBoxLayout.new(actions)
+      button_layout = Qt::GridLayout.new
+
+      log_buttons = [
+        ["Start Logging on All", [0,0], :start_logging],
+        ["Stop Logging on All", [0,1], :stop_logging],
+        ["Start Telemetry Logging on All", [1,0], :start_tlm_log],
+        ["Stop Telemetry Logging on All", [1,1], :stop_tlm_log],
+        ["Start Command Logging on All", [2,0], :start_cmd_log],
+        ["Stop Command Logging on All", [2,1], :stop_cmd_log]
+      ]
+
+      log_buttons.each do |text, location, method|
+        next if text =~ /Stop/ and @production
+        button = Qt::PushButton.new(Qt::Object.tr(text))
+        button_layout.addWidget(button, location[0], location[1])
+        button.connect(SIGNAL('clicked()')) do
+          begin
+            CmdTlmServer.instance.send(method, 'ALL')
+          rescue Exception => error
+            statusBar.showMessage(Qt::Object.tr(error.message))
+          end
+        end
+      end
+
+      actions_layout.addLayout(button_layout)
+
+      layout.addWidget(actions)
+    end
+
+    def create_log_layout(form_layout, log_writer, label_prefix)
+      label = Qt::Label.new(Qt::Object.tr(log_writer.logging_enabled.to_s))
+      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
+      form_layout.addRow("#{label_prefix} Logging:", label)
+      label = Qt::Label.new(Qt::Object.tr(log_writer.queue.size.to_s))
+      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
+      form_layout.addRow("#{label_prefix} Queue Size:", label)
+      label = Qt::Label.new(Qt::Object.tr(log_writer.filename))
+      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
+      form_layout.addRow("#{label_prefix} Filename:", label)
+      file_size = 0
+      begin
+        file_size = File.size(log_writer.filename) if log_writer.filename
+      rescue Exception
+        # Do nothing on error
+      end
+      label = Qt::Label.new(Qt::Object.tr(file_size.to_s))
+      label.setTextInteractionFlags(Qt::TextSelectableByMouse)
+      form_layout.addRow("#{label_prefix} File Size:", label)
+    end
+
+    def populate_log_file_info(layout)
+      CmdTlmServer.packet_logging.all.sort.each do |packet_log_writer_pair_name, packet_log_writer_pair|
+        log = Qt::GroupBox.new("#{packet_log_writer_pair_name} Packet Log Writer")
+        log_layout = Qt::VBoxLayout.new(log)
+        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
+
+        form_layout = Qt::FormLayout.new
+        @logging_layouts[packet_log_writer_pair_name] = form_layout
+        label = Qt::Label.new(Qt::Object.tr(interfaces.join(", ")))
+        label.setTextInteractionFlags(Qt::TextSelectableByMouse)
+        form_layout.addRow("Interfaces:", label)
+        create_log_layout(form_layout, packet_log_writer_pair.cmd_log_writer, 'Cmd')
+        create_log_layout(form_layout, packet_log_writer_pair.tlm_log_writer, 'Tlm')
+
+        button_layout = Qt::HBoxLayout.new
+        start_button = Qt::PushButton.new(Qt::Object.tr('Start Cmd Logging'))
+        button_layout.addWidget(start_button)
+        start_button.connect(SIGNAL('clicked()')) do
+          CmdTlmServer.instance.start_cmd_log(packet_log_writer_pair_name)
+        end
+        start_button = Qt::PushButton.new(Qt::Object.tr('Start Tlm Logging'))
+        button_layout.addWidget(start_button)
+        start_button.connect(SIGNAL('clicked()')) do
+          CmdTlmServer.instance.start_tlm_log(packet_log_writer_pair_name)
+        end
+        if @production == false
+          stop_button = Qt::PushButton.new(Qt::Object.tr('Stop Cmd Logging'))
+          button_layout.addWidget(stop_button)
+          stop_button.connect(SIGNAL('clicked()')) do
+            CmdTlmServer.instance.stop_cmd_log(packet_log_writer_pair_name)
+          end
+          stop_button = Qt::PushButton.new(Qt::Object.tr('Stop Tlm Logging'))
+          button_layout.addWidget(stop_button)
+          stop_button.connect(SIGNAL('clicked()')) do
+            CmdTlmServer.instance.stop_tlm_log(packet_log_writer_pair_name)
+          end
+        end
+        form_layout.addRow("Actions:", button_layout)
+        log_layout.addLayout(form_layout)
+        layout.addWidget(log)
+      end
+      layout.addWidget(Qt::Label.new(Qt::Object.tr("Note: Buffered IO operations cause file size to not reflect total logged data size until the log file is closed.")))
+    end
+
+  end
+end # module Cosmos

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

@@ -0,0 +1,144 @@
+# 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'
+require 'cosmos/gui/dialogs/cmd_tlm_raw_dialog'
+
+module Cosmos
+
+  # Implements the packets tab in the Command and Telemetry Server GUI
+  class PacketsTab
+    COMMANDS = "Commands"
+    TELEMETRY = "Telemetry"
+
+    def initialize(server_gui)
+      @server_gui = server_gui
+      @packets_table = {}
+    end
+
+    def populate_commands(tab_widget)
+      populate(COMMANDS, System.commands, tab_widget)
+    end
+
+    def populate_telemetry(tab_widget)
+      populate(TELEMETRY, System.telemetry, tab_widget)
+    end
+
+    def update(name)
+      cmd_tlm = nil
+      cmd_tlm = System.commands if name == COMMANDS
+      cmd_tlm = System.telemetry if name == TELEMETRY
+      return if cmd_tlm.nil? || cmd_tlm.target_names.empty?
+
+      row = 0
+      cmd_tlm.target_names.sort.each do |target_name|
+        packets = cmd_tlm.packets(target_name)
+        packets.sort.each do |packet_name, packet|
+          next if packet.hidden
+          @packets_table[name].item(row, 2).setText(packet.received_count.to_s)
+          row += 1
+        end
+      end
+    end
+
+    private
+
+    def populate(name, cmd_tlm, tab_widget)
+      return if cmd_tlm.target_names.empty?
+
+      count = 0
+      cmd_tlm.target_names.sort.each do |target_name|
+        packets = cmd_tlm.packets(target_name)
+        packets.each do |packet_name, packet|
+          count += 1 unless packet.hidden
+        end
+      end
+
+      scroll = Qt::ScrollArea.new
+      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)
+
+      table = Qt::TableWidget.new()
+      table.verticalHeader.hide()
+      table.setRowCount(count)
+      column_cnt = 4
+      column_cnt += 1 if name == TELEMETRY
+      table.setColumnCount(column_cnt)
+      # Force the last section to fill all available space in the frame
+      #~ table.horizontalHeader.setStretchLastSection(true)
+      headers = ["Target Name", "Packet Name", "Packet Count", "View Raw"]
+      headers << "View in Packet Viewer" if name == TELEMETRY
+      table.setHorizontalHeaderLabels(headers)
+
+      populate_packets_table(name, cmd_tlm, table)
+      table.displayFullSize
+
+      layout.addWidget(table)
+      scroll.setWidget(widget)
+      tab_name = "Cmd Packets" if name == COMMANDS
+      tab_name = "Tlm Packets" if name == TELEMETRY
+      tab_widget.addTab(scroll, tab_name)
+
+      @packets_table[name] = table
+    end
+
+    def populate_packets_table(name, cmd_tlm, table)
+      row = 0
+      cmd_tlm.target_names.sort.each do |target_name|
+        packets = cmd_tlm.packets(target_name)
+        packets.sort.each do |packet_name, packet|
+          packet.received_count ||= 0
+          next if packet.hidden
+          target_name_widget = Qt::TableWidgetItem.new(Qt::Object.tr(target_name))
+          target_name_widget.setTextAlignment(Qt::AlignRight | Qt::AlignVCenter)
+          table.setItem(row, 0, target_name_widget)
+          table.setItem(row, 1, Qt::TableWidgetItem.new(Qt::Object.tr(packet_name)))
+          packet_count = Qt::TableWidgetItem.new(Qt::Object.tr(packet.received_count.to_s))
+          packet_count.setTextAlignment(Qt::AlignCenter)
+          table.setItem(row, 2, packet_count)
+          view_raw = Qt::PushButton.new("View Raw")
+          view_raw.connect(SIGNAL('clicked()')) do
+            @raw_dialogs ||= []
+            @raw_dialogs << CmdRawDialog.new(@server_gui, target_name, packet_name) if name == COMMANDS
+            @raw_dialogs << TlmRawDialog.new(@server_gui, target_name, packet_name) if name == TELEMETRY
+          end
+          table.setCellWidget(row, 3, view_raw)
+
+          if name == TELEMETRY
+            if target_name != 'UNKNOWN' and packet_name != 'UNKNOWN'
+              view_pv = Qt::PushButton.new("View in Packet Viewer")
+              view_pv.connect(SIGNAL('clicked()')) do
+                if Kernel.is_windows?
+                  Cosmos.run_process("rubyw tools/PacketViewer -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                elsif Kernel.is_mac? and File.exist?("tools/mac/PacketViewer.app")
+                  Cosmos.run_process("open tools/mac/PacketViewer.app --args -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                else
+                  Cosmos.run_process("ruby tools/PacketViewer -p \"#{target_name} #{packet_name}\" --system #{File.basename(System.initial_filename)}")
+                end
+              end
+              table.setCellWidget(row, 4, view_pv)
+            else
+              table_widget = Qt::TableWidgetItem.new(Qt::Object.tr('N/A'))
+              table_widget.setTextAlignment(Qt::AlignCenter)
+              table.setItem(row, 4, table_widget)
+            end
+          end
+
+          row += 1
+        end
+      end
+    end
+
+  end
+end # module Cosmos