cosmos 5.0.2 → 5.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f94954d88cfda8c83f25e5f9a073360d2cf2f7ca9ec359212d3aa6c1bce5a909
-  data.tar.gz: ab1f28afba922389b69d3c5527944d9e53d8ceca45ebe25746ef1517a44b54b8
+  metadata.gz: 520339a0daade42a51611f9e17fe6e5a2c1343d9bab3ad6b36dbb03f11f55f28
+  data.tar.gz: 59a4d41cc6ef453ea1f375c5e9671aa0b14b390da42d8413bd080ab7bdb18ff4
 SHA512:
-  metadata.gz: 3b5ed0b4186b705cd0360caabbed8f04daac8eaedf9872b8e22fb147c43a0a748fe98afc1b88a8fc99d15d6bd4b3bb9208c1497bb7732f4ef031b856735c6ea7
-  data.tar.gz: 9353b73975d3d6c0f84560b388e2d175a70c2cd4d6c03dbe2f92a650368007c6c0b44cb8b114292180284bb1b8cd465e8e680fd4d6da85c125fc6fe853bf7156
+  metadata.gz: 700274a130767236a08e76ce223a09fa0229e659153c8a5f50896447796d3ca0e4487423704ece2d655511a642c6dfed0a8fc9482f8ee7ef9681f1726c23a2ce
+  data.tar.gz: 20773c2fd54d95674f66252edbd51faee8107cca83c05bace69a4607fd5563dc543d10f670513b4fb2df25d6ca6c18d0e58923f517e66f7f186fe7bc0e1eecbb

data/bin/cosmos

@@ -24,6 +24,7 @@ require 'cosmos'
 require 'cosmos/utilities/s3'
 require 'cosmos/models/scope_model'
 require 'cosmos/models/plugin_model'
+require 'cosmos/packets/packet_config'
 require 'cosmos/bridge/bridge'
 require 'ostruct'
 require 'optparse'
@@ -32,6 +33,7 @@ require 'fileutils'
 require 'find'
 require 'json'
 require 'redis'
+require 'psych'
 require 'erb'
 
 $redis_url = "redis://#{ENV['COSMOS_REDIS_HOSTNAME']}:#{ENV['COSMOS_REDIS_PORT']}"
@@ -40,25 +42,27 @@ $redis_url = "redis://#{ENV['COSMOS_REDIS_HOSTNAME']}:#{ENV['COSMOS_REDIS_PORT']
 MIGRATE_OPTIONS = OpenStruct.new
 MIGRATE_OPTIONS.all = false
 MIGRATE_PARSER = OptionParser.new do |op|
-  op.banner = "cosmos migrate PLUGIN [TGT1...]  # Create a COSMOS 5 plugin from existing COSMOS 4 targets"
-  op.on("-a", "--all", "Move all COSMOS 4 targets into a single COSMOS 5 plugin") do
+  op.banner = "cosmos migrate PLUGIN [TGT1...]      # Create a COSMOS 5 plugin from existing COSMOS 4 targets"
+  op.on("-a", "--all", "    Move all COSMOS 4 targets into a single COSMOS 5 plugin") do
     MIGRATE_OPTIONS.all = true
   end
 end
+ERROR_CODE = 67 # ASCII 'C' for COSMOS
 
 # Prints the usage text for the cosmos executable
 def print_usage
   puts "Usage:"
   puts "  cosmos help                          # Displays this information"
   puts "  cosmos rake                          # Runs rake in the local directory"
-  puts "  cosmos load /PATH/FILENAME.gem       # Loads a COSMOS plugin gem file"
+  puts "  cosmos validate /PATH/FILENAME.gem SCOPE variables.txt # Validate a COSMOS plugin gem file"
+  puts "  cosmos load /PATH/FILENAME.gem SCOPE variables.txt     # Loads a COSMOS plugin gem file"
   puts "  cosmos generate plugin PLUGIN_NAME   # Generate a COSMOS plugin"
   puts "  #{MIGRATE_PARSER}"
   puts "  cosmos bridge CONFIG_FILENAME        # Run COSMOS host bridge"
   puts "  cosmos bridgesetup CONFIG_FILENAME   # Create a default config file"
   puts "  cosmos geminstall GEMFILENAME        # Install loaded gem to /gems"
   puts "  cosmos rubysloc                      # Counts Ruby SLOC recursively. Run with --help for more info."
-  # puts "  cosmos xtce_converter                # Convert to and from the XTCE format. Run with --help for more info."
+  puts "  cosmos xtce_converter                # Convert to and from the XTCE format. Run with --help for more info."
   puts "  cosmos cstol_converter               # Converts CSTOL files (.prc) to COSMOS. Run with --help for more info."
   puts ""
 end
@@ -99,7 +103,7 @@ def generate(args)
       end
       base_name.sub!("target.rb", target_lib_filename)
       base_name.sub!("plugin.gemspec", "#{plugin_name}.gemspec")
-      output = ERB.new(File.read(file)).result(b)
+      output = ERB.new(File.read(file), trim_mode: "-").result(b)
       File.open(base_name, 'w') do |file|
         file.write output
       end
@@ -185,6 +189,76 @@ def migrate(args)
   puts "Plugin complete: #{File.expand_path('.')}" # Remember we're inside the plugin dir
 end
 
+def xtce_converter(args)
+  options = {}
+  option_parser = OptionParser.new do |option_parser|
+    option_parser.banner = "Usage: xtce_converter [options] --import input_xtce_filename --output output_dir\n"+
+      "       xtce_converter [options] --plugin /PATH/FILENAME.gem --output output_dir --variables variables.txt"
+    option_parser.separator("")
+    option_parser.on("-h", "--help", "Show this message") do
+      puts option_parser
+      exit
+    end
+    option_parser.on("-i VALUE", "--import VALUE", "Import the specified .xtce file") do |arg|
+      options[:import] = arg
+    end
+    option_parser.on("-o", "--output DIRECTORY", "Create files in the directory") do |arg|
+      options[:output] = arg
+    end
+    option_parser.on("-p", "--plugin PLUGIN", "Export .xtce file(s) from the plugin") do |arg|
+      options[:plugin] = arg
+    end
+    option_parser.on("-v", "--variables", "Optional variables file to pass to the plugin") do |arg|
+      options[:variables] = arg
+    end
+  end
+
+  begin
+    option_parser.parse!(args)
+  rescue => err
+    abort(option_parser.to_s)
+  end
+
+  if options[:import] && options[:plugin]
+    puts "xtce_converter options --import and --plugin are mutually exclusive"
+    abort(option_parser.to_s)
+  end
+
+  ENV['COSMOS_NO_STORE'] = '1' # it can be anything
+  Cosmos::Logger.stdout = false
+  Cosmos::Logger.level = Cosmos::Logger::DEBUG
+
+  if options[:import] && options[:output]
+    packet_config = Cosmos::PacketConfig.new
+    puts "Processing #{options[:import]}..."
+    packet_config.process_file(options[:import], nil)
+    puts "Writing COSMOS config files to #{options[:output]}/"
+    packet_config.to_config(options[:output])
+    exit(0)
+  elsif options[:plugin] && options[:output]
+    begin
+      variables = nil
+      variables = JSON.parse(File.read(options[:variables])) if options[:variables]
+      puts "Installing #{File.basename(options[:plugin])}"
+      plugin_hash = Cosmos::PluginModel.install_phase1(options[:plugin], variables, scope: 'DEFAULT', validate_only: true)
+      plugin_hash['variables']['xtce_output'] = options[:output]
+      Cosmos::PluginModel.install_phase2(plugin_hash['name'], plugin_hash['variables'], scope: 'DEFAULT', validate_only: true,
+        gem_file_path: options[:plugin])
+      result = 0 # bash and Windows consider 0 success
+    rescue => e
+      puts "Error: #{e.message}"
+      result = ERROR_CODE
+    ensure
+      name = Psych.safe_load(`gem spec #{options[:plugin]} name`).to_s
+      version = Psych.safe_load(`gem spec #{options[:plugin]} version`, permitted_classes: [Gem::Version]).to_s
+      Gem::Uninstaller.new(name, {:version => version, :force => true}).uninstall
+      exit(result)
+    end
+  else
+    abort(option_parser.to_s)
+  end
+end
+
 # A helper method to make the zip writing recursion work
 def write_zip_entries(base_dir, entries, zip_path, io)
   io.add(zip_path, base_dir) # Add the directory whether it has entries or not
@@ -212,7 +286,66 @@ def put_into_archive(disk_file_path, io, zip_file_path)
   end
 end
 
-def load_plugin(plugin_file_path, scope:, variables_file: nil)
+def validate_plugin(plugin_file_path, scope:, variables_file: nil)
+  ENV['COSMOS_NO_STORE'] = '1' # it can be anything
+  Cosmos::Logger.stdout = false
+  Cosmos::Logger.level = Cosmos::Logger::DEBUG
+  scope ||= 'DEFAULT'
+  variables = nil
+  variables = JSON.parse(File.read(variables_file)) if variables_file
+  puts "Installing #{File.basename(plugin_file_path)}"
+  plugin_hash = Cosmos::PluginModel.install_phase1(plugin_file_path, variables, scope: scope, validate_only: true)
+  Cosmos::PluginModel.install_phase2(plugin_hash['name'], plugin_hash['variables'], scope: scope, validate_only: true,
+    gem_file_path: plugin_file_path)
+  puts "Successfully validated #{File.basename(plugin_file_path)}"
+  result = 0 # bash and Windows consider 0 success
+rescue => e
+  puts "Error: #{e.message}"
+  result = ERROR_CODE
+ensure
+  name = Psych.safe_load(`gem spec #{plugin_file_path} name`).to_s
+  version = Psych.safe_load(`gem spec #{plugin_file_path} version`, permitted_classes: [Gem::Version]).to_s
+  Gem::Uninstaller.new(name, {:version => version, :force => true}).uninstall
+  exit(result)
+end
+
+def update_plugin(plugin_file_path, plugin_name, variables: nil, plugin_txt_lines: nil, scope:)
+  new_gem = File.basename(plugin_file_path)
+  old_gem = plugin_name.split("__")[0]
+  puts "Updating existing plugin: #{plugin_name} with #{File.basename(plugin_file_path)}"
+  plugin_model = Cosmos::PluginModel.get_model(name: plugin_name, scope: scope)
+  begin
+    # Only update if something has changed
+    if (new_gem != old_gem) or (variables != plugin_model.variables) or (plugin_txt_lines != plugin_model.plugin_txt_lines)
+      variables = plugin_model.variables unless variables
+      plugin_model.destroy
+      plugin_hash = Cosmos::PluginModel.install_phase1(plugin_file_path, existing_variables: variables, existing_plugin_txt_lines: plugin_txt_lines, process_existing: true, scope: scope)
+      Cosmos::PluginModel.install_phase2(plugin_hash, scope: scope)
+    else
+      puts "No changes detected - Exiting without change"
+    end
+  rescue => error
+    puts error.formatted
+    plugin_model.restore if plugin_model.destroyed?
+    raise error
+  end
+end
+
+# Loads a plugin into the COSMOS system
+# This code is used from the command line and is the same code that gets called if you
+# edit/upgrade or install a new plugin from the Admin interface
+#
+# Usage: cosmos load gemfile_path [scope] [plugin_hash_file_path]
+#
+# With just gemfile_path and/or scope: Will do nothing if any plugin
+# with the same gem file already exists
+#
+# Otherwise will do what the plugin_hash_file says to do
+# Plugin hash file must have the exact name of an existing plugin for upgrades and edits
+# Otherwise, it will be assumed that the plugin is intentionally being installed for a second
+# time
+#
+def load_plugin(plugin_file_path, scope:, plugin_hash_file: nil)
   scope ||= 'DEFAULT'
   # Only create the scope if it doesn't already exist
   unless Cosmos::ScopeModel.names.include?(scope)
@@ -226,41 +359,47 @@ def load_plugin(plugin_file_path, scope:, variables_file: nil)
   end
 
   begin
-    # Try to find an existing plugin with this file to upgrade
-    gem_filename = File.basename(plugin_file_path, ".gem")
-    gem_filename = gem_filename.split('-')[0..-2].join('-')
-    plugin_names = Cosmos::PluginModel.names(scope: scope)
-    found = false
-    plugin_names.each do |plugin_name|
-      gem_name = plugin_name.split("__")[0]
-      gem_name = File.basename(plugin_name, ".gem")
-      gem_name = gem_name.split('-')[0..-2].join('-')
-      if gem_filename == gem_name
-        puts "Upgrading existing plugin: #{plugin_name} with #{plugin_file_path}"
-        plugin_model = Cosmos::PluginModel.get_model(name: plugin_name, scope: scope)
-        variables = plugin_model.variables
-        plugin_model.destroy
-        if variables_file
-          # Assume phase1 is already done
-          variables = JSON.parse(File.read(variables_file))
-          plugin_hash = Cosmos::PluginModel.new(name: File.basename(plugin_file_path), variables: variables, scope: scope).as_json
-        else
-          plugin_hash = Cosmos::PluginModel.install_phase1(plugin_file_path, variables, scope: scope)
+    if plugin_hash_file
+      # Admin Create / Edit / or Upgrade Plugin
+      Cosmos::PluginModel.install_phase1(plugin_file_path, scope: scope)
+      plugin_hash = JSON.parse(File.read(plugin_hash_file))
+    else
+      # Init or Command Line cosmos load with no plugin_hash_file
+      file_full_name = File.basename(plugin_file_path, ".gem")
+      file_gem_name = file_full_name.split('-')[0..-2].join('-')
+      found = false
+      plugin_names = Cosmos::PluginModel.names(scope: scope)
+      plugin_names.each do |plugin_name|
+        gem_name = plugin_name.split("__")[0]
+        full_name = File.basename(gem_name, ".gem")
+        gem_name = full_name.split('-')[0..-2].join('-')
+        if file_gem_name == gem_name
+          found = true
+          # Upgrade if version changed else do nothing
+          if file_full_name != full_name
+            update_plugin(plugin_file_path, plugin_name, scope: scope)
+          end
         end
-        Cosmos::PluginModel.install_phase2(plugin_hash['name'], plugin_hash['variables'], scope: scope)
-        found = true
       end
+      return if found
+
+      plugin_hash = Cosmos::PluginModel.install_phase1(plugin_file_path, scope: scope)
     end
-    unless found
-      puts "Loading new plugin: #{plugin_file_path}"
-      if variables_file
-        # Assume phase1 is already done
-        variables = JSON.parse(File.read(variables_file))
-        plugin_hash = Cosmos::PluginModel.new(name: File.basename(plugin_file_path), variables: variables, scope: scope).as_json
-      else
-        plugin_hash = Cosmos::PluginModel.install_phase1(plugin_file_path, scope: scope)
-      end
-      Cosmos::PluginModel.install_phase2(plugin_hash['name'], plugin_hash['variables'], scope: scope)
+
+    # Determine if plugin named in plugin_hash exists
+    existing_plugin_hash = Cosmos::PluginModel.get(name: plugin_hash['name'], scope: scope)
+
+    # Existing plugin hash will be present if plugin is being edited or upgraded
+    # If editing, gem name will match existing hash name
+    # If upgrading, gem name will not match the existing hash name
+
+    if existing_plugin_hash
+      # Upgrade or Edit
+      update_plugin(plugin_file_path, plugin_hash['name'], variables: plugin_hash['variables'], plugin_txt_lines: plugin_hash['plugin_txt_lines'], scope: scope)
+    else
+      # New Install
+      puts "Loading new plugin: #{plugin_file_path}\n#{plugin_hash}"
+      Cosmos::PluginModel.install_phase2(plugin_hash, scope: scope)
     end
   rescue => err
     abort("Error installing plugin: #{scope}: #{plugin_file_path}: #{err.formatted}")
@@ -305,8 +444,11 @@ if not ARGV[0].nil? # argument(s) given
   when 'rake'
     puts `rake #{ARGV[1..-1].join(' ')}`
 
+  when 'validate'
+    validate_plugin(ARGV[1], scope: ARGV[2], variables_file: ARGV[3])
+
   when 'load'
-    load_plugin(ARGV[1], scope: ARGV[2], variables_file: ARGV[3])
+    load_plugin(ARGV[1], scope: ARGV[2], plugin_hash_file: ARGV[3])
 
   when 'geminstall'
     gem_install(ARGV[1])
@@ -333,9 +475,8 @@ if not ARGV[0].nil? # argument(s) given
   when 'cstol_converter'
     puts `ruby /cosmos/bin/cstol_converter #{ARGV[1..-1].join(' ')}`
 
-  # TODO: This still needs work in COSMOS 5
-  # when 'xtce_converter'
-  #   puts `ruby /cosmos/bin/xtce_converter #{ARGV[1..-1].join(' ')}`
+  when 'xtce_converter'
+    xtce_converter(ARGV[1..-1])
 
   when 'bridge'
     ENV['COSMOS_NO_STORE'] = '1'

data/data/config/microservice.yaml

@@ -2,65 +2,77 @@
 MICROSERVICE:
   summary: Defines a new microservice
   example: MICROSERVICE EXAMPLE example-microservice
+  description: Defines a microservice that the plugin adds to the COSMOS system. Microservices are background software processes that perform persistent processing.
   parameters:
-    - name: Folder Name
+    - name: Microservice Folder Name
+      description: The exact name of the microservice folder in the plugin. ie. microservices/<Microservice Folder Name>
       required: true
-      description: The target folder where the microservice is located
-      values: .*
-    - name: Name
+      values: .+
+    - name: Microservice Name
+      description: The specific name of this instance of the microservice in the COSMOS system
       required: true
-      description: The microservice name
-      values: .*
+      values: .+
   modifiers:
     ENV:
-      summary: Environment variable
+      summary: Sets an environment variable in the microservice.
       parameters:
-        - name: Name
+        - name: Key
           required: true
           description: Environment variable name
-          values: .*
+          values: .+
         - name: Value
           required: true
           description: Environment variable value
-          values: .*
+          values: .+
     WORK_DIR:
-      summary: Directory to start the microservice in (CWD)
+      summary: Set the working directory
+      description: Working directory to run the microservice CMD in.  Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
       parameters:
-        - name: Path
+        - name: Directory
           required: true
-          description: Relative path from the target directory
-          values: .*
+          description: Working directory to run the microservice CMD in. Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
+          values: .+
     TOPIC:
-      summary: Topic the microservice should process data from
+      summary: Associate a Redis topic
+      description: Redis topic to associate with this microservice. Standard COSMOS microservices such as decom_microservice use this information to know what packet streams to subscribe to. The TOPIC keyword can be used as many times as necessary to associate all needed topics.
       parameters:
-        - name: Name
+        - name: Topic Name
           required: true
-          description: Topic name
-          values: .*
+          description: Redis Topic to associate with the microservice
+          values: .+
     TARGET_NAME:
-      summary: Target which this microservice processes
+      summary: Associate a COSMOS target
+      description: COSMOS target to associate with the microservice. For standard COSMOS microservices such as decom_microservice this causes the target configuration to get loaded into the container for the microservice.
       parameters:
-        - name: Name
+        - name: Target Name
           required: true
-          description: Target name
-          values: .*
+          description: COSMOS target to associate with the microservice
+          values: .+
     CMD:
-      summary: Command to run which starts the microservice
+      summary: Command line to execute to run the microservice.
+      description: Command line to execute to run the microservice.
       parameters:
-        - name: Executable
+        - name: Args
           required: true
-          description: Executable to call
-          values: .*
-        - name: Command parameters
-          required: false
-          description: Additional parameters used by the command
+          description: One or more arguments to exec to run the microservice.
+          values: .+
     OPTION:
-      summary: Options to pass to the underlying microservice (used by InterfaceMicroservice, etc.)
+      summary: Pass an option to the microservice
+      description: Generic key/value(s) options to pass to the microservice. These take the form of KEYWORD/PARAMS like a line in a COSMOS configuration file. Multiple OPTION keywords can be used to pass multiple options to the microservice.
       parameters:
-        - name: Name
+        - name: Option Name
+          required: true
+          description: Name of the option
+          values: .+
+        - name: Option Value(s)
           required: true
-          description: Option name
-          values: .*
-        - name: Values
+          description: One or more values to associate with the option
+          values: .+
+    CONTAINER:
+      summary: Docker Container.
+      description: Container to execute and run the microservice in.
+      parameters:
+        - name: Args
           required: false
-          description: Option values
+          description: Name of the container
+          values: .+

data/data/config/plugins.yaml

@@ -65,153 +65,16 @@ ROUTER:
         <%= MetaConfigParser.load('_interfaces.yaml').to_meta_config_yaml(8) %>
       documentation: Additional parameters are required. Please see the [Interfaces](/docs/v5/interfaces)
         documentation for more details.
-TARGET:
-  summary: Define a target
-  description: Defines a target that the plugin adds to the COSMOS system.  Targets are entities that COSMOS can send commands to and receive telemetry from.
+<%= MetaConfigParser.load('target.yaml').to_meta_config_yaml() %>
+<%= MetaConfigParser.load('microservice.yaml').to_meta_config_yaml() %>
+<%= MetaConfigParser.load('tool.yaml').to_meta_config_yaml() %>
+WIDGET:
+  summary: Define a custom widget
+  example: WIDGET HELLOWORLD
+  description: Defines a custom widget that can be used in Telemetry Viewer screens.
   parameters:
-    - name: Target Folder Name
-      description: The exact name of the target folder in the plugin. ie. targets/<Target Folder Name>
+    - name: Widget Name
+      description: The name of the widget wil be used to build a path to the widget implementation. For example, `WIDGET HELLOWORLD` will find the as-built file tools/widgets/HelloworldWidget/HelloworldWidget.umd.min.js. See the [Custom Widgets](/docs/v5/custom-widgets)
+        guide for more details.
       required: true
       values: .+
-    - name: Target Name
-      description: The specific name of this instance of the target in the COSMOS system
-      required: true
-      values: .+
-MICROSERVICE:
-  summary: Define a microservice
-  description: Defines a microservice that the plugin adds to the COSMOS system.  Microservices are background software processes that perform persistent processing.
-  parameters:
-    - name: Microservice Folder Name
-      description: The exact name of the microservice folder in the plugin. ie. microservices/<Microservice Folder Name>
-      required: true
-      values: .+
-    - name: Microservice Name
-      description: The specific name of this instance of the microservice in the COSMOS system
-      required: true
-      values: .+
-  modifiers:
-    ENV:
-      summary: Sets an environment variable in the microservice.
-      description: Sets an environment variable in the microservice.
-      parameters:
-        - name: Key
-          required: true
-          description: Name of the environment variable
-          values: .+
-        - name: Value
-          required: true
-          description: Value of the environment variable
-          values: .+
-    WORK_DIR:
-      summary: Set the working directory
-      description: Working directory to run the microservice CMD in.  Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
-      parameters:
-        - name: Directory
-          required: true
-          description: Working directory to run the microservice CMD in.  Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
-          values: .+
-    TOPIC:
-      summary: Associate a Redis topic
-      description: Redis topic to associate with this microservice.  Standard COSMOS microservices such as decom_microservice use this information to know what packet streams to subscribe to.  The TOPIC keyword can be used as many times as necessary to associate all needed topics.
-      parameters:
-        - name: Topic Name
-          required: true
-          description: Redis Topic to associate with the microservice
-          values: .+
-    TARGET_NAME:
-      summary: Associate a COSMOS target
-      description: COSMOS target to associate with the microservice.   For standard COSMOS microservices such as decom_microservice this causes the target configuration to get loaded into the container for the microservice.
-      parameters:
-        - name: Target Name
-          required: true
-          description: COSMOS target to associate with the microservice
-          values: .+
-    CMD:
-      summary: Command line to execute to run the microservice.
-      description: Command line to execute to run the microservice.
-      parameters:
-        - name: Args
-          required: true
-          description: One or more arguments to exec to run the microservice.
-          values: .+
-    CONTAINER:
-      summary: Docker Container.
-      description: Container to execute and run the microservice in.
-      parameters:
-        - name: Args
-          required: false
-          description: Name of the container
-          values: .+
-    OPTION:
-      summary: Pass an option to the microservice
-      description: Generic key/value(s) options to pass to the microservice.  These take the form of KEYWORD/PARAMS like a line in a COSMOS configuration file.  Multiple OPTION keywords can be used to pass multiple options to the microservice.
-      parameters:
-        - name: Option Name
-          required: true
-          description: Name of the option
-          values: .+
-        - name: Option Value(s)
-          required: true
-          description: One or more values to associate with the option
-          values: .+
-TOOL:
-  summary: Define a tool
-  description: Defines a tool that the plugin adds to the COSMOS system.  Tools are web based applications that make use of the Single-SPA javascript library that allows them to by dynamically added to the running system as independent frontend microservices.
-  parameters:
-    - name: Tool Folder Name
-      description: The exact name of the tool folder in the plugin. ie. tools/<Tool Folder Name>
-      required: true
-      values: .+
-    - name: Tool Name
-      description: Name of the tool that is displayed in the COSMOS Navigation menu
-      required: true
-      values: .+
-  modifiers:
-    URL:
-      summary: Url used to access the tool
-      description: The relative url used to access the tool.  Defaults to "/tools/<Tool Folder Name>".
-      parameters:
-        - name: Url
-          required: true
-          description: The url.  If not given defaults to tools/<Tool Folder Name>.  Generally should not be given unless linking to external tools.
-          values: .+
-    INLINE_URL:
-      summary: Internal url to load a tool
-      description: The url of the javascript file used to load the tool into single-SPA.  Defaults to "js/app.js".
-      parameters:
-        - name: Url
-          required: true
-          description: The inline url.  If not given defaults to js/app.js.  Generally should not be given unless using a non-standard filename.
-          values: .+
-    WINDOW:
-      summary: How to display the tool when navigated to
-      description: The window mode used to display the tool.  Currently supported modes are INLINE which opens the tool internally without refreshing the page using the Single-SPA framework, and NEW which opens the tool in a new TAB.   A future release will support IFRAME to open external tools in an Iframe within COSMOS.
-      parameters:
-        - name: Window Mode
-          required: true
-          description: INLINE, NEW, or IFRAME
-          values: .+
-    ICON:
-      summary: Set tool icon
-      description: Icon shown next to the tool name in the COSMOS navigation menu.
-      parameters:
-        - name: Icon Name
-          required: true
-          description: Icon to display next to the tool name.   Icons come from Font Awesome, Material Design, and Astro.  See https://vuetifyjs.com/en/components/icons/
-          values: .+
-    CATEGORY:
-      summary: Category for the tool
-      description: Associates the tool with a category.  In a future release this will be able to organize tools into submenus in the Navigation menu.
-      parameters:
-        - name: Category Name
-          required: true
-          description: Category to associate the tool with
-          values: .+
-    SHOWN:
-      summary: Show the tool or not
-      description: Whether or not the tool is shown in the Navigation menu.   Should generally be true, except for the cosmos base tool.
-      parameters:
-        - name: Shown
-          required: true
-          description: Whether or not the tool is shown.  TRUE or FALSE
-          values: .+