cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/api/limits_api.rb

@@ -0,0 +1,375 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'cosmos/api/target_api'
+
+module Cosmos
+  module Api
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'get_stale',
+                       'get_out_of_limits',
+                       'get_overall_limits_state',
+                       'limits_enabled?',
+                       'enable_limits',
+                       'disable_limits',
+                       'get_limits',
+                       'set_limits',
+                       'get_limits_groups',
+                       'enable_limits_group',
+                       'disable_limits_group',
+                       'get_limits_sets',
+                       'set_limits_set',
+                       'get_limits_set',
+                       'get_limits_events',
+                     ])
+
+    # Get the list of stale packets for a specific target or pass nil to list
+    # all stale packets
+    #
+    # @param with_limits_only [Boolean] Return only the stale packets
+    #   that have limits items and thus affect the overall limits
+    #   state of the system
+    # @param target_name [String] The target to find stale packets for or nil to list
+    #   all stale packets in the system
+    # @param staleness_sec [Integer] The amount of time to pass before a packet is marked stale
+    # @return [Array<Array<String, String>>] Array of arrays listing the target
+    #   name and packet name
+    def get_stale(with_limits_only: false, target_name: nil, staleness_sec: 30, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
+      stale_time = Time.now.sys.to_nsec_from_epoch - (staleness_sec * Time::NSEC_PER_SECOND)
+      stale = []
+      targets = []
+      if target_name
+        targets = [target_name]
+      else
+        targets = get_target_list()
+      end
+      targets.each do |target_name|
+        get_all_telemetry(target_name, scope: scope).each do |packet|
+          topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}"
+          _, msg_hash = Store.get_newest_message(topic)
+          unless msg_hash && msg_hash['time'].to_i > stale_time
+            next if with_limits_only && packet['items'].find { |item| item['limits'] }.nil?
+
+            stale << [packet['target_name'], packet['packet_name']]
+          end
+        end
+      end
+      stale
+    end
+
+    # Return an array of arrays indicating all items in the packet that are out of limits
+    #   [[target name, packet name, item name, item limits state], ...]
+    #
+    # @return [Array<Array<String, String, String, String>>]
+    def get_out_of_limits(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      LimitsEventTopic.out_of_limits(scope: scope)
+    end
+
+    # Get the overall limits state which is the worse case of all limits items.
+    # For example if any limits are YELLOW_LOW or YELLOW_HIGH then the overall limits state is YELLOW.
+    # If a single limit item then turns RED_HIGH the overall limits state is RED.
+    #
+    # @param ignored_items [Array<Array<String, String, String|nil>>] Array of [TGT, PKT, ITEM] strings
+    #   to ignore when determining overall state. Note, ITEM can be nil to indicate to ignore entire packet.
+    # @return [String] The overall limits state for the system, one of 'GREEN', 'YELLOW', 'RED'
+    def get_overall_limits_state(ignored_items = nil, scope: $cosmos_scope, token: $cosmos_token)
+      # We only need to check out of limits items so call get_out_of_limits() which authorizes
+      out_of_limits = get_out_of_limits(scope: scope, token: token)
+      overall = 'GREEN'
+      limits_packet_stale = false # TODO: Calculate stale
+
+      # Build easily matchable ignore list
+      if ignored_items
+        ignored_items.map! do |item|
+          raise "Invalid ignored item: #{item}. Must be [TGT, PKT, ITEM] where ITEM can be nil." if item.length != 3
+
+          item.join('__')
+        end
+      else
+        ignored_items = []
+      end
+
+      out_of_limits.each do |target_name, packet_name, item_name, limits_state|
+        # Ignore this item if we match one of the ignored items. Checking against /^#{item}/
+        # allows us to detect matches against a TGT__PKT__ with no item defined.
+        next if ignored_items.detect { |item| "#{target_name}__#{packet_name}__#{item_name}" =~ /^#{item}/ }
+
+        case overall
+          # If our overall state is currently blue or green we can go to any state
+        when 'BLUE', 'GREEN', 'GREEN_HIGH', 'GREEN_LOW'
+          overall = limits_state
+        # If our overal state is yellow we can only go higher to red
+        when 'YELLOW', 'YELLOW_HIGH', 'YELLOW_LOW'
+          if limits_state == 'RED' || limits_state == 'RED_HIGH' || limits_state == 'RED_LOW'
+            overall = limits_state
+            break # Red is as high as we go so no need to look for more
+          end
+        end
+      end
+      overall = 'GREEN' if overall == 'GREEN_HIGH' || overall == 'GREEN_LOW' || overall == 'BLUE'
+      overall = 'YELLOW' if overall == 'YELLOW_HIGH' || overall == 'YELLOW_LOW'
+      overall = 'RED' if overall == 'RED_HIGH' || overall == 'RED_LOW'
+      overall = 'STALE' if (overall == 'GREEN' || overall == 'BLUE') && limits_packet_stale
+      return overall
+    end
+
+    # Whether the limits are enabled for the given item
+    #
+    # Accepts two different calling styles:
+    #   limits_enabled?("TGT PKT ITEM")
+    #   limits_enabled?('TGT','PKT','ITEM')
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args [String|Array<String>] See the description for calling style
+    # @return [Boolean] Whether limits are enable for the itme
+    def limits_enabled?(*args, scope: $cosmos_scope, token: $cosmos_token)
+      target_name, packet_name, item_name = tlm_process_args(args, 'limits_enabled?', scope: scope)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      return TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)['limits']['enabled'] ? true : false
+    end
+
+    # Enable limits checking for a telemetry item
+    #
+    # Accepts two different calling styles:
+    #   enable_limits("TGT PKT ITEM")
+    #   enable_limits('TGT','PKT','ITEM')
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args [String|Array<String>] See the description for calling style
+    def enable_limits(*args, scope: $cosmos_scope, token: $cosmos_token)
+      target_name, packet_name, item_name = tlm_process_args(args, 'enable_limits', scope: scope)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      packet = TargetModel.packet(target_name, packet_name, scope: scope)
+      found_item = nil
+      packet['items'].each do |item|
+        if item['name'] == item_name
+          item['limits']['enabled'] = true
+          found_item = item
+          break
+        end
+      end
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+
+      TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
+    end
+
+    # Disable limit checking for a telemetry item
+    #
+    # Accepts two different calling styles:
+    #   disable_limits("TGT PKT ITEM")
+    #   disable_limits('TGT','PKT','ITEM')
+    #
+    # Favor the first syntax where possible as it is more succinct.
+    #
+    # @param args [String|Array<String>] See the description for calling style
+    def disable_limits(*args, scope: $cosmos_scope, token: $cosmos_token)
+      target_name, packet_name, item_name = tlm_process_args(args, 'disable_limits', scope: scope)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      packet = TargetModel.packet(target_name, packet_name, scope: scope)
+      found_item = nil
+      packet['items'].each do |item|
+        if item['name'] == item_name
+          item['limits'].delete('enabled')
+          found_item = item
+          break
+        end
+      end
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+
+      TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
+    end
+
+    # Get a Hash of all the limits sets defined for an item. Hash keys are the limit
+    # set name in uppercase (note there is always a DEFAULT) and the value is an array
+    # of limit values: red low, yellow low, yellow high, red high, <green low, green high>.
+    # Green low and green high are optional.
+    #
+    # For example: {'DEFAULT' => [-80, -70, 60, 80, -20, 20],
+    #               'TVAC' => [-25, -10, 50, 55] }
+    #
+    # @return [Hash{String => Array<Number, Number, Number, Number, Number, Number>}]
+    def get_limits(target_name, packet_name, item_name, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      limits = {}
+      item = TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
+      item['limits'].each do |key, vals|
+        next unless vals.is_a?(Hash)
+
+        limits[key] = [vals['red_low'], vals['yellow_low'], vals['yellow_high'], vals['red_high']]
+        limits[key].concat([vals['green_low'], vals['green_high']]) if vals['green_low']
+      end
+      return limits
+    end
+
+    # Change the limits settings for a given item. By default, a new limits set called 'CUSTOM'
+    # is created to avoid overriding existing limits.
+    def set_limits(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high,
+                   green_low = nil, green_high = nil, limits_set = :CUSTOM, persistence = nil, enabled = true,
+                   scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
+      if (red_low > yellow_low) || (yellow_low >= yellow_high) || (yellow_high > red_high)
+        raise "Invalid limits specified. Ensure yellow limits are within red limits."
+      end
+      if (green_low && green_high) && ((yellow_low > green_low) || (green_low >= green_high) || (green_high > yellow_high))
+        raise "Invalid limits specified. Ensure green limits are within yellow limits."
+      end
+      packet = TargetModel.packet(target_name, packet_name, scope: scope)
+      found_item = nil
+      packet['items'].each do |item|
+        if item['name'] == item_name
+          item['limits']['persistence_setting'] = persistence
+          if enabled
+            item['limits']['enabled'] = true
+          else
+            item['limits'].delete('enabled')
+          end
+          limits = {}
+          limits['red_low'] = red_low
+          limits['yellow_low'] = yellow_low
+          limits['yellow_high'] = yellow_high
+          limits['red_high'] = red_high
+          limits['green_low'] = green_low if green_low && green_high
+          limits['green_high'] = green_high if green_low && green_high
+          item['limits'][limits_set] = limits
+          found_item = item
+          break
+        end
+      end
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      message = "Setting '#{target_name} #{packet_name} #{item_name}' limits to #{red_low} #{yellow_low} #{yellow_high} #{red_high}"
+      message << " #{green_low} #{green_high}" if green_low && green_high
+      message << " in set #{limits_set} with persistence #{persistence} as enabled #{enabled}"
+      Logger.info(message)
+
+      TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
+
+      event = { type: :LIMITS_SETTINGS, target_name: target_name, packet_name: packet_name,
+                item_name: item_name, red_low: red_low, yellow_low: yellow_low, yellow_high: yellow_high, red_high: red_high,
+                green_low: green_low, green_high: green_high, limits_set: limits_set, persistence: persistence, enabled: enabled,
+                time_nsec: Time.now.to_nsec_from_epoch, message: message }
+      LimitsEventTopic.write(event, scope: scope)
+    end
+
+    # Returns all limits_groups and their members
+    # @since 5.0.0 Returns hash with values
+    # @return [Hash{String => Array<Array<String, String, String>>]
+    def get_limits_groups(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      TargetModel.limits_groups(scope: scope)
+    end
+
+    # Enables limits for all the items in the group
+    #
+    # @param group_name [String] Name of the group to enable
+    def enable_limits_group(group_name, scope: $cosmos_scope, token: $cosmos_token)
+      _limits_group(group_name, action: :enable, scope: scope, token: token)
+    end
+
+    # Disables limits for all the items in the group
+    #
+    # @param group_name [String] Name of the group to disable
+    def disable_limits_group(group_name, scope: $cosmos_scope, token: $cosmos_token)
+      _limits_group(group_name, action: :disable, scope: scope, token: token)
+    end
+
+    # Returns all defined limits sets
+    #
+    # @return [Array<String>] All defined limits sets
+    def get_limits_sets(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      LimitsEventTopic.sets(scope: scope).keys
+    end
+
+    # Changes the active limits set that applies to all telemetry
+    #
+    # @param limits_set [String] The name of the limits set
+    def set_limits_set(limits_set, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm_set', scope: scope, token: token)
+      message = "Setting Limits Set: #{limits_set}"
+      Logger.info(message)
+      LimitsEventTopic.write({ type: :LIMITS_SET, set: limits_set.to_s,
+        time_nsec: Time.now.to_nsec_from_epoch, message: message }, scope: scope)
+    end
+
+    # Returns the active limits set that applies to all telemetry
+    #
+    # @return [String] The current limits set
+    def get_limits_set(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      LimitsEventTopic.current_set(scope: scope)
+    end
+
+    # Returns limits events starting at the provided offset. Passing nil for an
+    # offset will return the last received limits event and associated offset.
+    #
+    # @param offset [Integer] Offset to start reading limits events. Nil to return
+    #   the last received limits event (if any).
+    # @param count [Integer] The total number of events returned. Default is 100.
+    # @return [Hash, Integer] Event hash followed by the offset. The offset can
+    #   be used in subsequent calls to return events from where the last call left off.
+    def get_limits_events(offset = nil, count: 100, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      LimitsEventTopic.read(offset, count: count, scope: scope)
+    end
+
+    ###########################################################################
+    # PRIVATE implementation details
+    ###########################################################################
+
+    def _limits_group(group_name, action:, scope:, token:)
+      authorize(permission: 'tlm_set', scope: scope, token: token)
+      group_name.upcase!
+      group = get_limits_groups()[group_name]
+      raise "LIMITS_GROUP #{group_name} undefined. Ensure your telemetry definition contains the line: LIMITS_GROUP #{group_name}" unless group
+
+      Logger.info("Disabling Limits Group: #{group_name}")
+      last_target_name = nil
+      last_packet_name = nil
+      packet = nil
+      group.sort.each do |target_name, packet_name, item_name|
+        if last_target_name != target_name || last_packet_name != packet_name
+          if last_target_name && last_packet_name
+            TargetModel.set_packet(last_target_name, last_packet_name, packet, scope: scope)
+          end
+          packet = TargetModel.packet(target_name, packet_name, scope: scope)
+        end
+        packet['items'].each do |item|
+          if item['name'] == item_name
+            if action == :enable
+              item['limits']['enabled'] = true
+            elsif action == :disable
+              item['limits'].delete('enabled')
+            end
+            break
+          end
+        end
+        last_target_name = target_name
+        last_packet_name = packet_name
+      end
+      if last_target_name && last_packet_name
+        TargetModel.set_packet(last_target_name, last_packet_name, packet, scope: scope)
+      end
+    end
+  end
+end

data/lib/cosmos/api/router_api.rb

@@ -0,0 +1,117 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'cosmos/models/router_model'
+require 'cosmos/models/router_status_model'
+require 'cosmos/topics/router_topic'
+
+module Cosmos
+  module Api
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'get_router',
+                       'get_router_names',
+                       'connect_router',
+                       'disconnect_router',
+                       'start_raw_logging_router',
+                       'stop_raw_logging_router',
+                       'get_all_router_info',
+                     ])
+
+    # Get information about a router
+    #
+    # @param router_name [String] Router name
+    # @return [Hash] Hash of all the router information
+    def get_router(router_name, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', router_name: router_name, scope: scope, token: token)
+      router = RouterModel.get(name: router_name, scope: scope)
+      raise "Router '#{router_name}' does not exist" unless router
+
+      router.merge(RouterStatusModel.get(name: router_name, scope: scope))
+    end
+
+    # @return [Array<String>] All the router names
+    def get_router_names(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', scope: scope, token: token)
+      RouterModel.names(scope: scope)
+    end
+
+    # Connects a router and starts its command gathering thread
+    #
+    # @param router_name [String] Name of router
+    # @param params [Array] Parameters to pass to the router.
+    def connect_router(router_name, *params, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+      RouterTopic.connect_router(router_name, scope: scope)
+    end
+
+    # Disconnects a router and kills its command gathering thread
+    #
+    # @param router_name [String] Name of router
+    def disconnect_router(router_name, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+      RouterTopic.disconnect_router(router_name, scope: scope)
+    end
+
+    # Starts raw logging for a router
+    #
+    # @param router_name [String] The name of the interface
+    def start_raw_logging_router(router_name = 'ALL', scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+      if router_name == 'ALL'
+        get_router_names().each do |router_name|
+          RouterTopic.start_raw_logging(router_name, scope: scope)
+        end
+      else
+        RouterTopic.start_raw_logging(router_name, scope: scope)
+      end
+    end
+
+    # Stop raw logging for a router
+    #
+    # @param router_name [String] The name of the interface
+    def stop_raw_logging_router(router_name = 'ALL', scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system_set', router_name: router_name, scope: scope, token: token)
+      if router_name == 'ALL'
+        get_router_names().each do |router_name|
+          RouterTopic.stop_raw_logging(router_name, scope: scope)
+        end
+      else
+        RouterTopic.stop_raw_logging(router_name, scope: scope)
+      end
+    end
+
+    # Consolidate all router info into a single API call
+    #
+    # @return [Array<Array<String, Numeric, Numeric, Numeric, Numeric, Numeric,
+    #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
+    #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
+    #   Telemetry count] for all routers
+    def get_all_router_info(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', scope: scope, token: token)
+      info = []
+      RouterStatusModel.all(scope: scope).each do |router_name, router|
+        info << [router['name'], router['state'], router['clients'], router['txsize'], router['rxsize'],\
+                 router['txbytes'], router['rxbytes'], router['rxcnt'], router['txcnt']]
+      end
+      info.sort! { |a, b| a[0] <=> b[0] }
+      info
+    end
+  end
+end

data/lib/cosmos/api/settings_api.rb

@@ -0,0 +1,58 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+module Cosmos
+  module Api
+    SETTINGS_KEY = "cosmos__settings"
+
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'list_settings',
+                       'get_all_settings',
+                       'get_setting',
+                       'get_settings',
+                       'save_setting'
+                     ])
+
+    def list_settings(scope: $cosmos_scope, token: $cosmos_token)
+      Store.instance.hkeys(SETTINGS_KEY)
+    end
+
+    def get_all_settings(scope: $cosmos_scope, token: $cosmos_token)
+      Store.instance.hgetall(SETTINGS_KEY)
+    end
+
+    def get_setting(name, scope: $cosmos_scope, token: $cosmos_token)
+      Store.instance.hget(SETTINGS_KEY, name)
+    end
+
+    def get_settings(*args, scope: $cosmos_scope, token: $cosmos_token)
+      ret = []
+      args.each do |name|
+        ret << Store.instance.hget(SETTINGS_KEY, name)
+      end
+      return ret
+    end
+
+    def save_setting(name, data, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'admin', scope: scope, token: token)
+      Store.instance.hset(SETTINGS_KEY, name, data)
+    end
+  end
+end

data/lib/cosmos/api/target_api.rb

@@ -0,0 +1,78 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'cosmos/models/target_model'
+
+module Cosmos
+  module Api
+    WHITELIST ||= []
+    WHITELIST.concat([
+                       'get_target_list',
+                       'get_target',
+                       'get_all_target_info',
+                     ])
+
+    # Returns the list of all target names
+    #
+    # @return [Array<String>] All target names
+    def get_target_list(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'tlm', scope: scope, token: token)
+      TargetModel.names(scope: scope)
+    end
+
+    # Gets the full target hash
+    #
+    # @since 5.0.0
+    # @param target_name [String] Target name
+    # @return [Hash] Hash of all the target properties
+    def get_target(target_name, scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', target_name: target_name, scope: scope, token: token)
+      TargetModel.get(name: target_name, scope: scope)
+    end
+
+    # Get information about all targets
+    #
+    # @return [Array<Array<String, Numeric, Numeric>] Array of Arrays \[name, interface, cmd_cnt, tlm_cnt]
+    def get_all_target_info(scope: $cosmos_scope, token: $cosmos_token)
+      authorize(permission: 'system', scope: scope, token: token)
+      info = []
+      get_target_list(scope: scope, token: token).each do |target_name|
+        cmd_cnt = 0
+        packets = TargetModel.packets(target_name, type: :CMD, scope: scope)
+        packets.each do |packet|
+          cmd_cnt += _get_cnt("#{scope}__COMMAND__{#{target_name}}__#{packet['packet_name']}")
+        end
+        tlm_cnt = 0
+        packets = TargetModel.packets(target_name, type: :TLM, scope: scope)
+        packets.each do |packet|
+          tlm_cnt += _get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet['packet_name']}")
+        end
+        interface_name = ''
+        InterfaceModel.all(scope: scope).each do |name, interface|
+          if interface['target_names'].include? target_name
+            interface_name = interface['name']
+            break
+          end
+        end
+        info << [target_name, interface_name, cmd_cnt, tlm_cnt]
+      end
+      info
+    end
+  end
+end