morpheus-cli 4.2.12 → 4.2.17

data/lib/morpheus/cli/backups_command.rb

@@ -0,0 +1,271 @@
+require 'morpheus/cli/cli_command'
+
+class Morpheus::Cli::BackupsCommand
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::BackupsHelper
+  include Morpheus::Cli::ProvisioningHelper
+  include Morpheus::Cli::OptionSourceHelper
+
+  set_command_hidden # hide until ready
+  
+  set_command_name :'backups'
+
+  register_subcommands :list, :get, :add, :update, :remove, :run, :restore
+  
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @backups_interface = @api_client.backups
+    @backup_jobs_interface = @api_client.backup_jobs
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def list(args)
+    options = {}
+    params = {}
+    ref_ids = []
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[search]")
+      build_standard_list_options(opts, options)
+      opts.footer = "List backups."
+    end
+    optparse.parse!(args)
+    connect(options)
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    @backups_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @backups_interface.dry.list(params)
+      return
+    end
+    json_response = @backups_interface.list(params)
+    backups = json_response['backups']
+    render_response(json_response, options, 'backups') do
+      print_h1 "Morpheus Backups", parse_list_subtitles(options), options
+      if backups.empty?
+        print cyan,"No backups found.",reset,"\n"
+      else
+        print as_pretty_table(backups, backup_column_definitions.upcase_keys!, options)
+        print_results_pagination(json_response)
+      end
+      print reset,"\n"
+    end
+    if backups.empty?
+      return 1, "no backups found"
+    else
+      return 0, nil
+    end
+  end
+  
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[backup]")
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a specific backup.
+[backup] is required. This is the name or id of a backup.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    id_list = parse_id_list(args)
+    return run_command_for_each_arg(id_list) do |arg|
+      _get(arg, params, options)
+    end
+  end
+
+  def _get(id, options)
+    params = {}
+    @backups_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @backups_interface.dry.get(id, params)
+      return
+    end
+    json_response = @backups_interface.get(id, params)
+    backup = json_response['backup']
+    render_response(json_response, options, 'backup') do
+      print_h1 "Backup Details", [], options
+      print cyan
+      print_description_list(backup_column_definitions, backup)
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def add(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name] [options]")
+      build_option_type_options(opts, options, add_backup_option_types)
+      build_option_type_options(opts, options, add_backup_advanced_option_types)
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new backup.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:0, max:1)
+    options[:options]['name'] = args[0] if args[0]
+    connect(options)
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'backup' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'backup' => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_backup_option_types(), options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(add_backup_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload['backup'].deep_merge!(params)
+    end
+    @backups_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @backups_interface.dry.create(payload)
+      return 0, nil
+    end
+    json_response = @backups_interface.create(payload)
+    backup = json_response['backup']
+    render_response(json_response, options, 'backup') do
+      print_green_success "Added backup #{backup['name']}"
+      return _get(backup["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+  def update(args)
+    options = {}
+    params = {}
+    payload = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[backup] [options]")
+      build_option_type_options(opts, options, update_backup_option_types)
+      build_option_type_options(opts, options, update_backup_advanced_option_types)
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Update a backup.
+[backup] is required. This is the name or id of a backup.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    backup = find_backup_by_name_or_id(args[0])
+    return 1 if backup.nil?
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'backup' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'backup' => parse_passed_options(options)})
+      # do not prompt on update
+      v_prompt = Morpheus::Cli::OptionTypes.no_prompt(update_backup_option_types, options[:options], @api_client, options[:params])
+      v_prompt.deep_compact!
+      params.deep_merge!(v_prompt)
+      advanced_config = Morpheus::Cli::OptionTypes.no_prompt(update_backup_advanced_option_types, options[:options], @api_client, options[:params])
+      advanced_config.deep_compact!
+      params.deep_merge!(advanced_config)
+      payload.deep_merge!({'backup' => params})
+      if payload['backup'].empty? # || options[:no_prompt]
+        raise_command_error "Specify at least one option to update.\n#{optparse}"
+      end
+    end
+    @backups_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @backups_interface.dry.update(backup['id'], payload)
+      return
+    end
+    json_response = @backups_interface.update(backup['id'], payload)
+    backup = json_response['backup']
+    render_response(json_response, options, 'backup') do
+      print_green_success "Updated backup #{backup['name']}"
+      return _get(backup["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+  def remove(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[backup] [options]")
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete a backup.
+[backup] is required. This is the name or id of a backup.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    backup = find_backup_by_name_or_id(args[0])
+    return 1 if backup.nil?
+    @backups_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @backups_interface.dry.destroy(backup['id'], params)
+      return
+    end
+    json_response = @backups_interface.destroy(backup['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed backup #{backup['name']}"
+    end
+    return 0, nil
+  end
+
+  private
+
+  def backup_column_definitions()
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Schedule" => lambda {|it| it['schedule']['name'] rescue '' },
+      "Backup Job" => lambda {|it| it['job']['name'] rescue '' },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  # this is not so simple, need to first choose select instance, host or provider
+  def add_backup_option_types
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
+      {'fieldName' => 'jobId', 'fieldLabel' => 'Backup Job', 'type' => 'select', 'optionSource' => lambda { |api_client, api_params| 
+        # @options_interface.options_for_source("licenseTypes", {})['data']
+        @backup_jobs_interface.list({max:10000})['backupJobs'].collect {|backup_job|
+          {'name' => backup_job['name'], 'value' => backup_job['id'], 'id' => backup_job['id']}
+        }
+      }, 'required' => true, 'displayOrder' => 3},
+    ]
+  end
+
+  def add_backup_advanced_option_types
+    []
+  end
+
+  def update_backup_option_types
+    add_backup_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+  def update_backup_advanced_option_types
+    add_backup_advanced_option_types.collect {|it|
+      it.delete('required')
+      it.delete('defaultValue')
+      it
+    }
+  end
+
+end

data/lib/morpheus/cli/boot_scripts_command.rb

@@ -279,7 +279,7 @@ class Morpheus::Cli::BootScriptsCommand
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[boot-script]")
-      build_common_options(opts, options, [:account, :auto_confirm, :json, :dry_run, :remote])
+      build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :remote])
     end
     optparse.parse!(args)
 

data/lib/morpheus/cli/cli_command.rb

@@ -1,5 +1,6 @@
 require 'yaml'
 require 'json'
+require 'fileutils'
 require 'morpheus/logging'
 require 'morpheus/benchmarking'
 require 'morpheus/cli/option_parser'
@@ -169,14 +170,18 @@ module Morpheus
             full_field_name = "#{field_namespace.join('.')}.#{field_name}"
           end
 
-          description = "#{option_type['fieldLabel']}#{option_type['fieldAddOn'] ? ('(' + option_type['fieldAddOn'] + ') ') : '' }#{!option_type['required'] ? ' (optional)' : ''}#{option_type['defaultValue'] ? ' Default: '+option_type['defaultValue'].to_s : ''}"
+          description = "#{option_type['fieldLabel']}#{option_type['fieldAddOn'] ? ('(' + option_type['fieldAddOn'] + ') ') : '' }#{!option_type['required'] ? ' (optional)' : ''}"
           if option_type['description']
             # description << "\n                                     #{option_type['description']}"
             description << " - #{option_type['description']}"
           end
+          if option_type['defaultValue']
+            description << ". Default: #{option_type['defaultValue']}"
+          end
           if option_type['helpBlock']
             description << "\n                                     #{option_type['helpBlock']}"
           end
+
           # description = option_type['description'].to_s
           # if option_type['defaultValue']
           #   description = "#{description} Default: #{option_type['defaultValue']}"
@@ -228,11 +233,11 @@ module Morpheus
       ## the standard options for a command that makes api requests (most of them)
 
       def build_standard_get_options(opts, options, includes=[], excludes=[])
-        build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :quiet, :dry_run, :remote] + includes, excludes)
+        build_common_options(opts, options, includes + [:query, :json, :yaml, :csv, :fields, :quiet, :dry_run, :remote], excludes)
       end
 
       def build_standard_post_options(opts, options, includes=[], excludes=[])
-        build_common_options(opts, options, [:options, :payload, :json, :quiet, :dry_run, :remote] + includes, excludes)
+        build_common_options(opts, options, includes + [:options, :payload, :json, :quiet, :dry_run, :remote], excludes)
       end
 
       def build_standard_put_options(opts, options, includes=[], excludes=[])
@@ -240,7 +245,7 @@ module Morpheus
       end
 
       def build_standard_delete_options(opts, options, includes=[], excludes=[])
-        build_common_options(opts, options, [:auto_confirm, :query, :json, :quiet, :dry_run, :remote] + includes, excludes)
+        build_common_options(opts, options, includes + [:auto_confirm, :query, :json, :quiet, :dry_run, :remote], excludes)
       end
 
       # list is GET that supports phrase,max,offset,sort,direction
@@ -281,13 +286,24 @@ module Morpheus
         while (option_key = option_keys.shift) do
           case option_key.to_sym
 
-          when :account
-            opts.on('-a','--account ACCOUNT', "Account Name or ID") do |val|
+          when :tenant, :account
+            # todo: let's deprecate this in favor of :tenant --tenant to keep -a reserved for --all perhaps?
+            opts.on('--tenant TENANT', String, "Tenant (Account) Name or ID") do |val|
+              options[:account] = val
+            end
+            opts.on('--tenant-id ID', String, "Tenant (Account) ID") do |val|
+              options[:account_id] = val
+            end
+            # todo: let's deprecate this in favor of :tenant --tenant to keep -a reserved for --all perhaps?
+            opts.on('-a','--account ACCOUNT', "Alias for --tenant") do |val|
               options[:account] = val
             end
-            opts.on('-A','--account-id ID', "Account ID") do |val|
+            opts.on('-A','--account-id ID', "Tenant (Account) ID") do |val|
               options[:account_id] = val
             end
+            opts.add_hidden_option('--tenant-id') if opts.is_a?(Morpheus::Cli::OptionParser)
+            opts.add_hidden_option('-a, --account') if opts.is_a?(Morpheus::Cli::OptionParser)
+            opts.add_hidden_option('-A, --account-id') if opts.is_a?(Morpheus::Cli::OptionParser)
 
           when :options
             options[:options] ||= {}
@@ -455,7 +471,7 @@ module Morpheus
             end
 
             # arbitrary query parameters in the format -Q "category=web&phrase=nginx"
-            # opts.on( '-Q', '--query PARAMS', "Query parameters. PARAMS format is 'phrase=foobar&category=web'" ) do |val|
+            # opts.on( '-Q', '--query PARAMS', "Query parameters. PARAMS format is 'foo=bar&category=web'" ) do |val|
             #   options[:query_filters_raw] = val
             #   options[:query_filters] = {}
             #   # todo: smarter parsing
@@ -473,7 +489,7 @@ module Morpheus
 
           when :query, :query_filters
             # arbitrary query parameters in the format -Q "category=web&phrase=nginx"
-            opts.on( '-Q', '--query PARAMS', "Query parameters. PARAMS format is 'phrase=foobar&category=web'" ) do |val|
+            opts.on( '-Q', '--query PARAMS', "Query parameters. PARAMS format is 'foo=bar&category=web'" ) do |val|
               options[:query_filters_raw] = val
               options[:query_filters] = {}
               # todo: smarter parsing
@@ -599,9 +615,17 @@ module Morpheus
             opts.add_hidden_option('json-raw') if opts.is_a?(Morpheus::Cli::OptionParser)
 
           when :yaml
-            opts.on(nil, '--yaml', "YAML Output") do
-              options[:yaml] = true
-              options[:format] = :yaml
+            # -y for --yes and for --yaml
+            if includes.include?(:auto_confirm)
+              opts.on(nil, '--yaml', "YAML Output") do
+                options[:yaml] = true
+                options[:format] = :yaml
+              end
+            else
+              opts.on('-y', '--yaml', "YAML Output") do
+                options[:yaml] = true
+                options[:format] = :yaml
+              end
             end
             opts.on(nil, '--yml', "alias for --yaml") do
               options[:yaml] = true
@@ -779,7 +803,11 @@ module Morpheus
         end
         opts.add_hidden_option('--no-debug') if opts.is_a?(Morpheus::Cli::OptionParser)
 
-
+        opts.on('--hidden-help', "Print help that includes all the hidden options, like this one." ) do
+          puts opts.full_help_message({show_hidden_options:true})
+          exit # return 0 maybe?
+        end
+        opts.add_hidden_option('--hidden-help') if opts.is_a?(Morpheus::Cli::OptionParser)
         opts.on('-h', '--help', "Print this help" ) do
           puts opts
           exit # return 0 maybe?
@@ -804,6 +832,20 @@ module Morpheus
         self.class.subcommand_aliases
       end
 
+      # def subcommand_descriptions
+      #   self.class.subcommand_descriptions
+      # end
+
+      def get_subcommand_description(subcmd)
+        self.class.get_subcommand_description(subcmd)
+      end
+
+      def subcommand_description()
+        calling_method = caller[0][/`([^']*)'/, 1].to_s.sub('block in ', '')
+        subcommand_name = subcommands.key(calling_method)
+        subcommand_name ? get_subcommand_description(subcommand_name) : nil
+      end
+
       def default_subcommand
         self.class.default_subcommand
       end
@@ -845,8 +887,11 @@ module Morpheus
         if !subcommands.empty?
           out << "Commands:"
           out << "\n"
-          subcommands.sort.each {|cmd, method|
-            out << "\t#{cmd.to_s}\n"
+          subcommands.sort.each {|subcmd, method|
+            desc = get_subcommand_description(subcmd)
+            out << "\t#{subcmd.to_s}"
+            out << "\t#{desc}" if desc
+            out << "\n"
           }
         end
         # out << "\n"
@@ -990,7 +1035,7 @@ module Morpheus
         #   raise_command_error "Please specify a remote appliance with -r or see the command `remote use`"
         # end
 
-        Morpheus::Logging::DarkPrinter.puts "establishing connection to remote #{display_appliance(@appliance_name, @appliance_url)}" if Morpheus::Logging.debug?
+        Morpheus::Logging::DarkPrinter.puts "establishing connection to remote #{display_appliance(@appliance_name, @appliance_url)}" if Morpheus::Logging.debug? # && !options[:quiet]
 
         if options[:no_authorization]
           # maybe handle this here..
@@ -1061,7 +1106,7 @@ module Morpheus
         else
           if opts[:min]
             if args.count < opts[:min]
-              raise_args_error("not many arguments, expected #{opts[:min] || '0'}-#{opts[:max] || 'N'} and got #{args.count == 0 ? '0' : args.count.to_s + ': '}#{args.join(', ')}", args, opts[:optparse])
+              raise_args_error("not enough arguments, expected #{opts[:min] || '0'}-#{opts[:max] || 'N'} and got #{args.count == 0 ? '0' : args.count.to_s + ': '}#{args.join(', ')}", args, opts[:optparse])
             end
           end
           if opts[:max]
@@ -1152,22 +1197,32 @@ module Morpheus
         payload
       end
 
-      def render_response(json_response, options, object_key=nil, &block)
-        render_result = render_with_format(json_response, options, object_key)
-        if render_result
-          return  0, nil
-        else
-          if block_given?
-            return yield
+      def validate_outfile(outfile, options)
+        full_filename = File.expand_path(outfile)
+        outdir = File.dirname(full_filename)
+        if Dir.exists?(full_filename)
+          print_red_alert "[local-file] is invalid. It is the name of an existing directory: #{outfile}"
+          return false
+        end
+        if !Dir.exists?(outdir)
+          if options[:mkdir]
+            print cyan,"Creating local directory #{outdir}",reset,"\n"
+            FileUtils.mkdir_p(outdir)
           else
-            return 0, nil
+            print_red_alert "[local-file] is invalid. Directory not found: #{outdir}"
+            return false
           end
         end
+        if File.exists?(full_filename) && !options[:overwrite]
+          print_red_alert "[local-file] is invalid. File already exists: #{outfile}\nUse -f to overwrite the existing file."
+          return false
+        end
+        return true
       end
 
       # basic rendering for options :json, :yml, :csv, :quiet, and :outfile
       # returns the string rendered, or nil if nothing was rendered.
-      def render_with_format(json_response, options, object_key=nil, &block)
+      def render_response(json_response, options, object_key=nil, &block)
         output = nil
         if options[:json]
           output = as_json(json_response, options, object_key)
@@ -1180,32 +1235,49 @@ module Morpheus
           else
             output = records_as_csv([row], options)
           end
-        elsif options[:quiet]
-          # note: returning non nil means the calling function knows to return rght away.. kinda weird..
-          # but means we need less if options[:quiet] blocks in every action.
-          return ""
         end
-        if output
-          if options[:outfile]
+        if options[:outfile]
+          if output
             print_to_file(output, options[:outfile], options[:overwrite])
+            print "#{cyan}Wrote output to file #{options[:outfile]} (#{File.size(options[:outfile])} B)\n" unless options[:quiet]
           else
-            puts output
+            # uhhh ok lets try this
+            Morpheus::Logging::DarkPrinter.puts "using experimental feature: --outfile without a common format like json, yml or csv" if Morpheus::Logging.debug?
+            result = with_stdout_to_file(options[:outfile], options[:overwrite], 'w+', &block)
+            print "#{cyan}Wrote output to file #{options[:outfile]} (#{File.size(options[:outfile])} B)\n" unless options[:quiet]
+            if result
+              return result
+            end
+            return 0, nil
           end
         else
-          if block_given?
-            # invoke the user given block to render (print output)
-            # hope it returned something well formed, there's a parse method for that..
-            cmd_render_result = yield
-            # could try to support writing output to options[:outfile] here too.. 
-            # output is already printed inside block though
-            # if cmd_render_result
-            #   return output
-            # end
-          end 
+          # --quiet means do not render, still want to print to outfile though
+          if options[:quiet]
+            return 0, nil
+          end
+          # render ouput generated above
+          if output
+            puts output
+            return 0, nil
+          else
+            # no render happened, so calling the block if given
+            if block_given?
+              result = yield
+              if result
+                return result
+              else
+                return 0, nil
+              end
+            else
+              # nil means nothing was rendered, some methods still using render_with_format() are relying on this
+              return nil
+            end
+          end
         end
-        return output
       end
 
+      alias :render_with_format :render_response
+
       module ClassMethods
 
         def set_command_name(cmd_name)
@@ -1277,12 +1349,46 @@ module Morpheus
               v = cmd.to_s.gsub('-', '_')
               register_subcommands({(k) => v})
             else
-              raise "Unable to register command of type: #{cmd.class} #{cmd}"
+              raise Morpheus::Cli::CliRegistry::BadCommandDefinition.new("Unable to register command of type: #{cmd.class} #{cmd}")
             end
           }
           return
         end
 
+        # this might be the new hotness
+        # register_subcommand(:show) # do not do this, always define a description!
+        # register_subcommand(:list, "List things")
+        # register_subcommand("update-all", "update_all", "Update all things")
+        # If the command name =~ method, no need to pass both
+        # command names will have "-" swapped in for "_" and vice versa for method names.
+        def register_subcommand(*args)
+          args = args.flatten
+          cmd_name = args[0]
+          cmd_method = nil
+          cmd_desc = nil
+          if args.count == 1
+            cmd_method = cmd_name
+          elsif args.count == 2
+            if args[1].is_a?(Symbol)
+              cmd_method = args[1]
+            else
+              cmd_method = cmd_name
+              cmd_desc = args[1]
+            end
+          elsif args.count == 3
+            cmd_method = args[1]
+            cmd_desc = args[2]
+          else
+            raise Morpheus::Cli::CliRegistry::BadCommandDefinition.new("register_subcommand expects 1-3 arguments, got #{args.size} #{args.inspect}")
+          end
+          cmd_name = cmd_name.to_s.gsub("_", "-").to_sym
+          cmd_method = (cmd_method || cmd_name).to_s.gsub("-", "_").to_sym
+          cmd_definition = {(cmd_name) => cmd_method}
+          register_subcommands(cmd_definition)
+          add_subcommand_description(cmd_name, cmd_desc)
+          return
+        end
+
         def set_default_subcommand(cmd)
           @default_subcommand = cmd
         end
@@ -1341,6 +1447,31 @@ module Morpheus
           @subcommand_aliases.delete(alias_cmd_name.to_s)
         end
 
+        def subcommand_descriptions
+          @subcommand_descriptions ||= {}
+        end
+
+        def add_subcommand_description(cmd_name, description)
+          @subcommand_descriptions ||= {}
+          @subcommand_descriptions[cmd_name.to_s.gsub('_', '-')] = description
+        end
+
+        def get_subcommand_description(cmd_name)
+          desc = subcommand_descriptions[cmd_name.to_s.gsub('_', '-')]
+          if desc
+            return desc
+          else
+            cmd_method = subcommands.key(cmd_name)
+            return cmd_method ? subcommand_descriptions[cmd_method.to_s.gsub('_', '-')] : nil
+          end
+        end
+
+        def set_subcommand_descriptions(cmd_map)
+          cmd_map.each do |cmd_name, description|
+            add_subcommand_description(cmd_name, description)
+          end
+        end
+
       end
     end
   end