Module: Morpheus::Cli::CliCommand

Included in:: AccessTokenCommand, AccountGroupsCommand, AliasCommand, ApplianceSettingsCommand, ApprovalsCommand, Apps, ArchivesCommand, AuthCommand, BackupSettingsCommand, BenchmarkCommand, BlueprintsCommand, BootScriptsCommand, BudgetsCommand, CatCommand, ChangePasswordCommand, CloudDatastoresCommand, CloudFoldersCommand, CloudResourcePoolsCommand, Clouds, Clusters, ColoringCommand, ContainersCommand, CurlCommand, CypherCommand, DashboardCommand, DebugCommand, Deployments, Deploys, Echo, EditProfileCommand, EditRcCommand, EnvironmentsCommand, ExecuteSchedulesCommand, ExecutionRequestCommand, ExitCommand, FileCopyRequestCommand, GetPromptCommand, Groups, GuidanceCommand, HealthCommand, HistoryCommand, Hosts, ImageBuilderCommand, InstanceTypes, Instances, IntegrationsCommand, InvoicesCommand, JobsCommand, KeyPairs, LibraryClusterLayoutsCommand, LibraryContainerScriptsCommand, LibraryContainerTemplatesCommand, LibraryContainerTypesCommand, LibraryInstanceTypesCommand, LibraryLayoutsCommand, LibraryOptionListsCommand, LibraryOptionTypesCommand, LibrarySpecTemplatesCommand, LibraryUpgradesCommand, License, LoadBalancers, LogLevelCommand, LogSettingsCommand, Login, Logout, LogsCommand, ManCommand, MonitoringAlertsCommand, MonitoringAppsCommand, MonitoringChecksCommand, MonitoringContactsCommand, MonitoringGroupsCommand, MonitoringIncidentsCommand, NetworkGroupsCommand, NetworkPoolServersCommand, NetworkPoolsCommand, NetworkProxiesCommand, NetworkRoutersCommand, NetworkServicesCommand, NetworksCommand, PackagesCommand, PoliciesCommand, PowerSchedulesCommand, PreseedScriptsCommand, PriceSetsCommand, PricesCommand, Processes, ProvisioningLicensesCommand, ProvisioningSettingsCommand, RecentActivityCommand, Remote, RemoveFileCommand, ReportsCommand, Roles, SecurityGroupRules, SecurityGroups, ServicePlanCommand, SetPromptCommand, Shell, Sleep, SourceCommand, SslVerificationCommand, StorageProvidersCommand, SubnetsCommand, Tasks, TeeCommand, TenantsCommand, UserGroupsCommand, UserSettingsCommand, UserSourcesCommand, Users, VersionCommand, VirtualImages, WhitelabelSettingsCommand, Whoami, WikiCommand, Workflows

Defined in:: lib/morpheus/cli/cli_command.rb

Overview

Module to be included by every CLI command so that commands get registered This mixin defines a print and puts method, and delegates todo: use delegate

Defined Under Namespace

Modules: ClassMethods

Instance Attribute Summary collapse

#no_prompt ⇒ Object readonly

this setting makes it easy for the called to disable prompting.

Class Method Summary collapse

.included(klass) ⇒ Object

Instance Method Summary collapse

#apply_options(payload, options, object_key = nil) ⇒ Object

support -O OPTION switch.
#build_common_options(opts, options, includes = [], excludes = []) ⇒ Object

appends to the passed OptionParser all the generic options.
#build_option_type_options(opts, options, option_types = []) ⇒ Object

Appends Array of OptionType definitions to an OptionParser instance This adds an option like –fieldContext.fieldName=“VALUE”.
#build_standard_add_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_get_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_list_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_remove_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_update_options(opts, options, includes = [], excludes = []) ⇒ Object
#command_name ⇒ Object
#default_refresh_interval ⇒ Object
#default_subcommand ⇒ Object
#establish_remote_appliance_connection(options) ⇒ Object

This supports the simple remote option eg.
#full_command_usage ⇒ Object

a string to describe the usage of your command this is what the –help option feel free to override this in your commands.
#handle(args) ⇒ Object
#handle_subcommand(args) ⇒ Object

a default handler.
#interactive? ⇒ Boolean

whether to prompt or not, this is true by default.
#my_help_command ⇒ Object
#my_terminal ⇒ Morpheus::Terminal

The terminal this command is being executed inside of.
#my_terminal=(term) ⇒ Object

set the terminal running this command.
#parse_bytes_param(bytes_param, option, assumed_unit = nil) ⇒ Object
#parse_id_list(id_list, delim = /\s*\,\s*/) ⇒ Object

parse_id_list splits returns the given id_list with its values split on a comma your id values cannot contain a comma, atm…
#parse_list_options(options = {}) ⇒ Object

parse the parameters provided by the common :list options this includes the :query options too via parse_query_options().
#parse_list_subtitles(options = {}) ⇒ Object

parse the subtitles provided by the common :list options returns Array of subtitles as strings in the format [“Phrase: blah”, “Max: 100”].
#parse_payload(options = {}, object_key = nil) ⇒ Object
#parse_query_options(options = {}) ⇒ Object

parse the parameters provided by the common :query (:query_filters) options returns Hash of params the format => “foobar”, “max”: 100.
#print(*msgs) ⇒ Object

delegate :print, to: :my_terminal delegate :puts, to: :my_terminal or .
#print_error(*msgs) ⇒ Object
#println(*msgs) ⇒ Object
#puts(*msgs) ⇒ Object
#puts_error(*msgs) ⇒ Object
#raise_command_error(msg) ⇒ Object
#render_with_format(json_response, options, object_key = nil) ⇒ Object

basic rendering for options :json, :yaml, :csv, :fields, and :outfile returns the string rendered, or nil if nothing was rendered.
#run_command_for_each_arg(args, &block) ⇒ 0|1

executes block with each argument in the list.
#subcommand_aliases ⇒ Object
#subcommand_usage(*extra) ⇒ Object
#subcommands ⇒ Object
#usage ⇒ Object
#verify_access_token! ⇒ Object

Instance Attribute Details

#no_prompt ⇒ `Object` (readonly)

this setting makes it easy for the called to disable prompting



30
31
32

# File 'lib/morpheus/cli/cli_command.rb', line 30

def no_prompt
  @no_prompt
end

Class Method Details

.included(klass) ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 20

def self.included(klass)
  klass.send :include, Morpheus::Cli::PrintHelper
  klass.send :include, Morpheus::Benchmarking::HasBenchmarking
  klass.extend ClassMethods
  Morpheus::Cli::CliRegistry.add(klass, klass.command_name)
end

Instance Method Details

#apply_options(payload, options, object_key = nil) ⇒ `Object`

support -O OPTION switch

# File 'lib/morpheus/cli/cli_command.rb', line 1033

def apply_options(payload, options, object_key=nil)
  payload ||= {}
  if options[:options]
    if object_key
      payload.deep_merge!({object_key => options[:options].reject {|k,v| k.is_a?(Symbol)}})
    else
      payload.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol)})
    end
  end
  payload
end

#build_common_options(opts, options, includes = [], excludes = []) ⇒ `Object`

appends to the passed OptionParser all the generic options

Parameters:

opts (OptionParser) —

the option parser object being constructed
options (Hash) —

the output Hash that is to being modified
includes (Array) (defaults to: []) —

which options to include eg. :options, :json, :remote

Returns:

opts

# File 'lib/morpheus/cli/cli_command.rb', line 244

def build_common_options(opts, options, includes=[], excludes=[])
  #opts.separator ""
  # opts.separator "Common options:"
  option_keys = includes.clone
  # todo: support --quiet everywhere
  # turn on some options all the time..
  # unless command_name == "shell"
  #   option_keys << :quiet unless option_keys.include?(:quiet)
  # end

  # ensure commands can always access options[:options], until we can deprecate it...
  options[:options] ||= {}

  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|
        options[:account] = val
      end
      opts.on('-A','--account-id ID', "Account ID") do |val|
        options[:account_id] = val
      end

    when :options
      options[:options] ||= {}
      opts.on( '-O', '--option OPTION', "Option in the format -O field=\"value\"" ) do |option|
        # todo: look ahead and parse ALL the option=value args after -O switch
        #custom_option_args = option.split('=')
        custom_option_args = option.sub(/\s?\=\s?/, '__OPTION_DELIM__').split('__OPTION_DELIM__')
        custom_options = options[:options]
        option_name_args = custom_option_args[0].split('.')
        if option_name_args.count > 1
          nested_options = custom_options
          option_name_args.each_with_index do |name_element,index|
            if index < option_name_args.count - 1
              nested_options[name_element] = nested_options[name_element] || {}
              nested_options = nested_options[name_element]
            else
              val = custom_option_args[1]
              if (val.to_s[0] == '{' && val.to_s[-1] == '}') || (val.to_s[0] == '[' && val.to_s[-1] == ']')
                begin
                  val = JSON.parse(val)
                rescue
                  Morpheus::Logging::DarkPrinter.puts "Failed to parse option value '#{val}' as JSON" if Morpheus::Logging.debug?
                end
              end
              nested_options[name_element] = val
            end
          end
        else
          val = custom_option_args[1]
          if (val.to_s[0] == '{' && val.to_s[-1] == '}') || (val.to_s[0] == '[' && val.to_s[-1] == ']')
            begin
              val = JSON.parse(val)
            rescue
              Morpheus::Logging::DarkPrinter.puts "Failed to parse option value '#{val}' as JSON" if Morpheus::Logging.debug?
            end
          end
          custom_options[custom_option_args[0]] = val
        end
        # convert "true","on" and "false","off" to true and false
        unless options[:skip_booleanize]
          custom_options.booleanize!
        end
        options[:options] = custom_options
      end
      opts.on('-P','--prompt', "Always prompts. Use passed options as the default value.") do |val|
        options[:always_prompt] = true
        options[:options] ||= {}
        options[:options][:always_prompt] = true
      end
      opts.on('-N','--no-prompt', "Skip prompts. Use default values for all optional fields.") do |val|
        options[:no_prompt] = true
        options[:options] ||= {}
        options[:options][:no_prompt] = true
      end

    when :prompt
      opts.on('-P','--prompt', "Always prompts. Use passed options as the default value.") do |val|
        options[:always_prompt] = true
        options[:options] ||= {}
        options[:options][:always_prompt] = true
      end
      opts.on('-N','--no-prompt', "Skip prompts. Use default values for all optional fields.") do |val|
        options[:no_prompt] = true
        options[:options] ||= {}
        options[:options][:no_prompt] = true
      end

    when :payload
      opts.on('--payload FILE', String, "Payload from a local JSON or YAML file, skip all prompting") do |val|
        options[:payload_file] = val.to_s
        begin
          payload_file = File.expand_path(options[:payload_file])
          if !File.exists?(payload_file) || !File.file?(payload_file)
            raise ::OptionParser::InvalidOption.new("File not found: #{payload_file}")
            #return false
          end
          if payload_file =~ /\.ya?ml\Z/
            options[:payload] = YAML.load_file(payload_file)
          else
            options[:payload] = JSON.parse(File.read(payload_file))
          end
        rescue => ex
          raise ::OptionParser::InvalidOption.new("Failed to parse payload file: #{payload_file} Error: #{ex.message}")
        end
      end
      opts.on('--payload-dir DIRECTORY', String, "Payload from a local directory containing 1-N JSON or YAML files, skip all prompting") do |val|
        options[:payload_dir] = val.to_s
        payload_dir = File.expand_path(options[:payload_dir])
        if !Dir.exists?(payload_dir) || !File.directory?(payload_dir)
          raise ::OptionParser::InvalidOption.new("Directory not found: #{payload_dir}")
        end
        payload = {}
        begin
          merged_payload = {}
          payload_files = []
          payload_files += Dir["#{payload_dir}/*.json"]
          payload_files += Dir["#{payload_dir}/*.yml"]
          payload_files += Dir["#{payload_dir}/*.yaml"]
          if payload_files.empty?
            raise ::OptionParser::InvalidOption.new("No .json/yaml files found in config directory: #{payload_dir}")
          end
          payload_files.each do |payload_file|
            Morpheus::Logging::DarkPrinter.puts "parsing payload file: #{payload_file}" if Morpheus::Logging.debug?
            config_payload = {}
            if payload_file =~ /\.ya?ml\Z/
              config_payload = YAML.load_file(payload_file)
            else
              config_payload = JSON.parse(File.read(payload_file))
            end
            merged_payload.deep_merge!(config_payload)
          end
          options[:payload] = merged_payload
        rescue => ex
          raise ::OptionParser::InvalidOption.new("Failed to parse payload file: #{payload_file} Error: #{ex.message}")
        end
      end
      opts.on('--payload-json JSON', String, "Payload JSON, skip all prompting") do |val|
        begin
          options[:payload] = JSON.parse(val.to_s)
        rescue => ex
          raise ::OptionParser::InvalidOption.new("Failed to parse payload as JSON. Error: #{ex.message}")
        end
      end
      opts.on('--payload-yaml YAML', String, "Payload YAML, skip all prompting") do |val|
        begin
          options[:payload] = YAML.load(val.to_s)
        rescue => ex
          raise ::OptionParser::InvalidOption.new("Failed to parse payload as YAML. Error: #{ex.message}")
        end
      end

    when :list
      opts.on( '-m', '--max MAX', "Max Results" ) do |val|
        max = val.to_i
        if max <= 0
          raise ::OptionParser::InvalidArgument.new("must be a positive integer")
        end
        options[:max] = max
      end

      opts.on( '-o', '--offset OFFSET', "Offset Results" ) do |val|
        offset = val.to_i
        if offset <= 0
          raise ::OptionParser::InvalidArgument.new("must be a positive integer")
        end
        options[:offset] = offset
      end

      opts.on( '-s', '--search PHRASE', "Search Phrase" ) do |phrase|
        options[:phrase] = phrase
      end

      opts.on( '-S', '--sort ORDER', "Sort Order. DIRECTION may be included as \"ORDER [asc|desc]\"." ) do |v|
        v_parts = v.to_s.split(" ")
        if v_parts.size > 1
          options[:sort] = v_parts[0]
          options[:direction] = (v_parts[1].strip == "desc") ? "desc" : "asc"
        else
          options[:sort] = v
        end
      end

      opts.on( '-D', '--desc', "Reverse Sort Order" ) do |v|
        options[:direction] = "desc"
      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|
      #   options[:query_filters_raw] = val
      #   options[:query_filters] = {}
      #   # todo: smarter parsing
      #   val.split('&').each do |filter| 
      #     k, v = filter.split('=')
      #     # allow "woot:true instead of woot=true"
      #     if (k.include?(":") && v == nil)
      #       k, v = k.split(":")
      #     end
      #     if (!k.to_s.empty?)
      #       options[:query_filters][k.to_s.strip] = v.to_s.strip
      #     end
      #   end
      # end

    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|
        options[:query_filters_raw] = val
        options[:query_filters] = {}
        # todo: smarter parsing
        val.split('&').each do |filter| 
          k, v = filter.split('=')
          # allow "woot:true instead of woot=true"
          if (k.include?(":") && v == nil)
            k, v = k.split(":")
          end
          if (!k.to_s.empty?)
            if options[:query_filters].key?(k.to_s.strip)
              cur_val = options[:query_filters][k.to_s.strip]
              if cur_val.instance_of?(Array)
                options[:query_filters][k.to_s.strip] << v.to_s.strip
              else
                options[:query_filters][k.to_s.strip] = [cur_val, v.to_s.strip]
              end
            else
              options[:query_filters][k.to_s.strip] = v.to_s.strip
            end
          end
        end
      end

    when :last_updated
      # opts.on("--last-updated TIME", Time, "Filter by gte last updated") do |time|
      opts.on("--last-updated TIME", String, "Filter by Last Updated (gte)") do |time|
        begin
          options[:lastUpdated] = parse_time(time)
        rescue => e
          raise OptionParser::InvalidArgument.new "Failed to parse time '#{time}'. Error: #{e}"
        end
      end

    when :remote
      opts.on( '-r', '--remote REMOTE', "Remote name. The current remote is used by default." ) do |val|
        options[:remote] = val
      end
      opts.on( '--remote-url URL', '--remote-url URL', "Remote url. This allows adhoc requests instead of using a configured remote." ) do |val|
        options[:remote_url] = val
      end
      opts.on( '-T', '--token TOKEN', "Access token for authentication with --remote. Saved credentials are used by default." ) do |val|
        options[:remote_token] = val
      end unless excludes.include?(:remote_token)
      opts.on( '-U', '--username USERNAME', "Username for authentication." ) do |val|
        options[:remote_username] = val
      end unless excludes.include?(:remote_username)
      opts.on( '-P', '--password PASSWORD', "Password for authentication." ) do |val|
        options[:remote_password] = val
      end unless excludes.include?(:remote_password)

      # todo: also require this for talking to plain old HTTP
      opts.on('-I','--insecure', "Allow insecure HTTPS communication.  i.e. bad SSL certificate.") do |val|
        options[:insecure] = true
        Morpheus::RestClient.enable_ssl_verification = false
      end
    
    #when :header, :headers
      opts.on( '-H', '--header HEADER', "Additional HTTP header to include with requests." ) do |val|
        options[:headers] ||= {}
        # header_list = val.to_s.split(',')
        header_list = [val.to_s]
        header_list.each do |h|
          header_parts = val.to_s.split(":")
          header_key, header_value = header_parts[0], header_parts[1..-1].join(":").strip
          if header_parts.size() < 2
            header_parts = val.to_s.split("=")
            header_key, header_value = header_parts[0], header_parts[1..-1].join("=").strip
          end
          if header_parts.size() < 2
            raise_command_error "Invalid HEADER value '#{val}'. HEADER should contain a key and a value. eg. -H 'X-Morpheus-Lease: $MORPHEUS_LEASE_TOKEN'"
          end
          options[:headers][header_key] = header_value
        end
      end
      # opts.add_hidden_option('-H') if opts.is_a?(Morpheus::Cli::OptionParser)
      # opts.add_hidden_option('--header') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.add_hidden_option('--headers') if opts.is_a?(Morpheus::Cli::OptionParser)

    #when :timeout
      opts.on( '--timeout SECONDS', "Timeout for api requests. Default is typically 30 seconds." ) do |val|
        options[:timeout] = val ? val.to_f : nil
      end
      # opts.add_hidden_option('--timeout') if opts.is_a?(Morpheus::Cli::OptionParser)

    when :auto_confirm
      opts.on( '-y', '--yes', "Auto Confirm" ) do
        options[:yes] = true
      end

    when :json
      opts.on('-j','--json', "JSON Output") do
        options[:json] = true
        options[:format] = :json
      end

      opts.on('--json-raw', String, "JSON Output that is not so pretty.") do |val|
        options[:json] = true
        options[:format] = :json
        options[:pretty_json] = false
      end
      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
      end
      opts.on(nil, '--yml', "alias for --yaml") do
        options[:yaml] = true
        options[:format] = :yaml
      end
      opts.add_hidden_option('yml') if opts.is_a?(Morpheus::Cli::OptionParser)

    when :csv
      opts.on(nil, '--csv', "CSV Output") do
        options[:csv] = true
        options[:format] = :csv
        #options[:csv_delim] = options[:csv_delim] || ","
      end

      opts.on('--csv-delim CHAR', String, "Delimiter for CSV Output values. Default: ','") do |val|
        options[:csv] = true
        options[:format] = :csv
        val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
        options[:csv_delim] = val
      end

      opts.on('--csv-newline [CHAR]', String, "Delimiter for CSV Output rows. Default: '\\n'") do |val|
        options[:csv] = true
        options[:format] = :csv
        if val == "no" || val == "none"
          options[:csv_newline] = ""
        else
          val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
          options[:csv_newline] = val
        end
      end

      opts.on(nil, '--csv-quotes', "Wrap CSV values with \". Default: false") do
        options[:csv] = true
        options[:format] = :csv
        options[:csv_quotes] = true
      end

      opts.on(nil, '--csv-no-header', "Exclude header for CSV Output.") do
        options[:csv] = true
        options[:format] = :csv
        options[:csv_no_header] = true
      end

    when :fields
      opts.on('-f', '--fields x,y,z', Array, "Filter Output to a limited set of fields. Default is all fields for json,csv,yaml.") do |val|
        if val.size == 1 && val[0].downcase == 'all'
          options[:all_fields] = true
        else
          options[:include_fields] = val
        end
      end
      opts.on('-F', '--old-fields x,y,z', Array, "alias for -f, --fields") do |val|
        if val.size == 1 && val[0].downcase == 'all'
          options[:all_fields] = true
        else
          options[:include_fields] = val
        end
      end
      opts.add_hidden_option('-F,') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on(nil, '--all-fields', "Show all fields present in the data.") do
        options[:all_fields] = true
      end
      #opts.add_hidden_option('--all-fields') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on(nil, '--wrap', "Wrap table columns instead hiding them when terminal is not wide enough.") do
        options[:responsive_table] = false
      end
    when :thin
      opts.on( '--thin', '--thin', "Format headers and columns with thin borders." ) do |val|
        options[:border_style] = :thin
      end
      
    

    when :dry_run
      opts.on('-d','--dry-run', "Dry Run, print the API request instead of executing it") do
        # todo: this should print after parsing obv..
        # need a hook after parse! or a standard_handle(options) { ... } paradigm
        # either that or hook it up in every command somehow, maybe a hook on connect()
        #puts "#{cyan}#{dark} #=> DRY RUN#{reset}"
        # don't print this for --json combined with -d
        # print once and dont munge json
        if !options[:curl] && !options[:json]
          puts "#{cyan}#{bold}#{dark}DRY RUN#{reset}"
        end
        options[:dry_run] = true
      end
      opts.on(nil,'--curl', "Dry Run to output API request as a curl command.") do
        # print once and dont munge json
        if !options[:dry_run] && !options[:json]
          puts "#{cyan}#{bold}#{dark}DRY RUN#{reset}"
        end
        options[:dry_run] = true
        options[:curl] = true
      end
      opts.on(nil,'--scrub', "Mask secrets in output, such as the Authorization header. For use with --curl and --dry-run.") do
        options[:scrub] = true
      end
      # dry run comes with hidden outfile options
      #opts.add_hidden_option('--scrub') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on('--out FILE', String, "Write standard output to a file instead of the terminal.") do |val|
        # could validate directory is writable..
        options[:outfile] = val
      end
      opts.add_hidden_option('--out') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on('--overwrite', '--overwrite', "Overwrite output file if it already exists.") do
        options[:overwrite] = true
      end
      opts.add_hidden_option('--overwrite') if opts.is_a?(Morpheus::Cli::OptionParser)

    when :outfile
      opts.on('--out FILE', String, "Write standard output to a file instead of the terminal.") do |val|
        options[:outfile] = val
      end
      opts.on('--overwrite', '--overwrite', "Overwrite output file if it already exists.") do |val|
        options[:overwrite] = true
      end
    when :quiet
      opts.on('-q','--quiet', "No Output, do not print to stdout") do
        options[:quiet] = true
      end

    else
      raise "Unknown common_option key: #{option_key}"
    end
  end

  # options that are always included

  # always support thin, but hidden because mostly not hooked up at the moment...
  unless includes.include?(:thin)
    opts.on( '--thin', '--thin', "Format headers and columns with thin borders." ) do |val|
      options[:border_style] = :thin
    end
    opts.add_hidden_option('--thin') if opts.is_a?(Morpheus::Cli::OptionParser)
  end

  # disable ANSI coloring
  opts.on('-C','--nocolor', "Disable ANSI coloring") do
    Term::ANSIColor::coloring = false
  end


  # Benchmark this command?
  opts.on('-B','--benchmark', "Print benchmark time after the command is finished.") do
    options[:benchmark] = true
    # this is hacky, but working!  
    # shell handles returning to false
    #Morpheus::Benchmarking.enabled = true
    #my_terminal.benchmarking = true
    #start_benchmark(args.join(' '))
    # ok it happens outside of handle() alltogether..
    # wow, simplify me plz
  end

  opts.on('-V','--debug', "Print extra output for debugging.") do
    options[:debug] = true
    Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
    ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
    # perhaps...
    # create a new logger instance just for this command instance
    # this way we don't elevate the global level for subsequent commands in a shell
    # @logger = Morpheus::Logging::Logger.new(STDOUT)
    # if [email protected]?
    #   @logger.log_level = Morpheus::Logging::Logger::DEBUG
    # end
  end

  opts.on('-h', '--help', "Print this help" ) do
    puts opts
    exit # return 0 maybe?
  end

  opts
end

#build_option_type_options(opts, options, option_types = []) ⇒ `Object`

Appends Array of OptionType definitions to an OptionParser instance This adds an option like –fieldContext.fieldName=“VALUE”

Parameters:

opts (OptionParser)
options (Hash) —

output map that is being constructed
option_types (Array) (defaults to: []) —

list of OptionType definitions to add

Returns:

void, this modifies the opts in place.

# File 'lib/morpheus/cli/cli_command.rb', line 137

def build_option_type_options(opts, options, option_types=[])
  #opts.separator ""
  #opts.separator "Options:"
  options[:options] ||= {} # this is where these go..for now
  custom_options = options[:options]
  
  # add each one to the OptionParser
  option_types.each do |option_type|
    field_namespace = []
    field_name = option_type['fieldName'].to_s
    if field_name.empty?
      puts "Missing fieldName for option type: #{option_type}" if Morpheus::Logging.debug?
      next
    end
    
    if !option_type['fieldContext'].to_s.empty?
      option_type['fieldContext'].split(".").each do |ns|
        field_namespace << ns
      end
    end
    
    full_field_name = field_name
    if !field_namespace.empty?
      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 : ''}"
    if option_type['description']
      # description << "\n                                     #{option_type['description']}"
      description << " - #{option_type['description']}"
    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']}"
    # end
    # if option_type['required'] == true
    #   description = "(Required) #{description}"
    # end
    
    value_label = "VALUE"
    if option_type['placeHolder']
      value_label = option_type['placeHolder']
    elsif option_type['type'] == 'checkbox'
      value_label = 'on|off' # or.. true|false
    elsif option_type['type'] == 'number'
      value_label = 'NUMBER'
    elsif option_type['type'] == 'multiSelect'
      value_label = 'LIST'
    # elsif option_type['type'] == 'select'
    #   value_label = 'SELECT'
    # elsif option['type'] == 'select'
    end
    opts.on("--#{full_field_name} #{value_label}", String, description) do |val|
      # attempt to parse JSON, this allows blank arrays for multiSelect like --tenants []
      if (val.to_s[0] == '{' && val.to_s[-1] == '}') || (val.to_s[0] == '[' && val.to_s[-1] == ']')
        begin
          val = JSON.parse(val)
        rescue
          Morpheus::Logging::DarkPrinter.puts "Failed to parse option value '#{val}' as JSON" if Morpheus::Logging.debug?
        end
      end
      cur_namespace = custom_options
      field_namespace.each do |ns|
        next if ns.empty?
        cur_namespace[ns.to_s] ||= {}
        cur_namespace = cur_namespace[ns.to_s]
      end
      cur_namespace[field_name] = val
    end

    # todo: all the various types
    # number 
    # checkbox [on|off]
    # select for optionSource and selectOptions

  end
  opts
end

#build_standard_add_options(opts, options, includes = [], excludes = []) ⇒ `Object`



227
228
229

# File 'lib/morpheus/cli/cli_command.rb', line 227

def build_standard_add_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote] + includes, excludes)
end

#build_standard_get_options(opts, options, includes = [], excludes = []) ⇒ `Object`



223
224
225

# File 'lib/morpheus/cli/cli_command.rb', line 223

def build_standard_get_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :dry_run, :remote] + includes, excludes)
end

#build_standard_list_options(opts, options, includes = [], excludes = []) ⇒ `Object`



219
220
221

# File 'lib/morpheus/cli/cli_command.rb', line 219

def build_standard_list_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote] + includes, excludes)
end

#build_standard_remove_options(opts, options, includes = [], excludes = []) ⇒ `Object`



235
236
237

# File 'lib/morpheus/cli/cli_command.rb', line 235

def build_standard_remove_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote] + includes, excludes)
end

#build_standard_update_options(opts, options, includes = [], excludes = []) ⇒ `Object`



231
232
233

# File 'lib/morpheus/cli/cli_command.rb', line 231

def build_standard_update_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, [:options, :payload, :json, :dry_run, :remote] + includes, excludes)
end

#command_name ⇒ `Object`



736
737
738

# File 'lib/morpheus/cli/cli_command.rb', line 736

def command_name
  self.class.command_name
end

#default_refresh_interval ⇒ `Object`



752
753
754

# File 'lib/morpheus/cli/cli_command.rb', line 752

def default_refresh_interval
  self.class.default_refresh_interval
end

#default_subcommand ⇒ `Object`



748
749
750

# File 'lib/morpheus/cli/cli_command.rb', line 748

def default_subcommand
  self.class.default_subcommand
end

#establish_remote_appliance_connection(options) ⇒ `Object`

This supports the simple remote option eg. ‘instances add –remote “qa”` It will establish a connection to the pre-configured appliance named “qa” The calling command can populate @appliances and/or @appliance_name Otherwise, the current active appliance is used… This returns a new instance of Morpheus::APIClient (and sets @access_token, and @appliance) Your command should be ready to make api requests after this.

# File 'lib/morpheus/cli/cli_command.rb', line 866

def establish_remote_appliance_connection(options)
  # todo: probably refactor and don't rely on this method to set these instance vars
  @appliance_name, @appliance_url, @access_token = nil, nil, nil
  @api_client = nil

  appliance = nil # @appliance..why not? laff
  if options[:remote]
    appliance = ::Morpheus::Cli::Remote.load_remote(options[:remote])
    if !appliance
      if ::Morpheus::Cli::Remote.appliances.empty?
        raise_command_error "You have no appliances configured. See the `remote add` command."
      else
        raise_command_error "Remote appliance not found by the name '#{options[:remote]}'"
      end
    end
  else
    appliance = ::Morpheus::Cli::Remote.load_active_remote()
    if !appliance
      if ::Morpheus::Cli::Remote.appliances.empty?
        raise_command_error "You have no appliances configured. See the `remote add` command."
      else
        raise_command_error "No current appliance, see `remote use`."
      end
    end
  end
  @appliance_name = appliance[:name]
  @appliance_url = appliance[:host] || appliance[:url] # it's :host in the YAML..heh

  # instead of toggling this global value
  # this should just be an attribute of the api client
  # for now, this fixes the issue where passing --insecure or --remote
  # would then apply to all subsequent commands...
  if !Morpheus::Cli::Shell.insecure
    if options[:insecure]
      Morpheus::RestClient.enable_ssl_verification = false
    else
      if appliance[:insecure] && Morpheus::RestClient.ssl_verification_enabled?
        Morpheus::RestClient.enable_ssl_verification = false
      elsif !appliance[:insecure] && !Morpheus::RestClient.ssl_verification_enabled?
        Morpheus::RestClient.enable_ssl_verification = true
      end
    end
  end

  # todo: support old way of accepting --username and --password on the command line
  # it's probably better not to do that tho, just so it stays out of history files
  

  # if !@appliance_name && !@appliance_url
  #   raise_command_error "Please specify a remote appliance with -r or see the command `remote use`"
  # end

  Morpheus::Logging::DarkPrinter.puts "establishing connection to [#{@appliance_name}] #{@appliance_url}" if options[:debug]
  #puts "#{dark} #=> establishing connection to [#{@appliance_name}] #{@appliance_url}#{reset}\n" if options[:debug]


  # ok, get some credentials.
  # this prompts for username, password  without options[:no_prompt]
  # uses saved credentials by default.
  # passing --remote-url or --token or --username will skip loading saved credentials and trigger prompting
  if options[:remote_token]
    @access_token = options[:remote_token]
  else
    credentials = Morpheus::Cli::Credentials.new(@appliance_name, @appliance_url)
    # @wallet = credentials.load_saved_credentials()
    # @wallet = credentials.request_credentials(options)
    if options[:remote_token]
      @wallet = credentials.request_credentials(options, false)
    elsif options[:remote_url] || options[:remote_username]
      @wallet = credentials.request_credentials(options, false)
    else
      #@wallet = credentials.request_credentials(options)
      @wallet = credentials.load_saved_credentials()
    end
    @access_token = @wallet ? @wallet['access_token'] : nil
    # if @access_token.to_s.empty?
    #   unless options[:no_prompt]
    #     @wallet = credentials.request_credentials(options)
    #     @access_token = @wallet ? @wallet['access_token'] : nil
    #   end
    # end
    # bail if we got nothing still
    unless options[:skip_verify_access_token]
      verify_access_token!
    end
  end

  # ok, connect to the appliance.. actually this just instantiates an ApiClient
  api_client = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url)
  @api_client = api_client # meh, just return w/o setting instance attrs
  return api_client
end

#full_command_usage ⇒ `Object`

a string to describe the usage of your command this is what the –help option feel free to override this in your commands

# File 'lib/morpheus/cli/cli_command.rb', line 782

def full_command_usage
  out = ""
  out << usage.to_s.strip if usage
  out << "\n"
  if !subcommands.empty?
    out << "Commands:"
    out << "\n"
    subcommands.sort.each {|cmd, method|
      out << "\t#{cmd.to_s}\n"
    }
  end
  # out << "\n"
  out
end

#handle(args) ⇒ `Object`



832
833
834

# File 'lib/morpheus/cli/cli_command.rb', line 832

def handle(args)
  raise "#{self} has not defined handle()!"
end

#handle_subcommand(args) ⇒ `Object`

a default handler

# File 'lib/morpheus/cli/cli_command.rb', line 798

def handle_subcommand(args)
  commands = subcommands
  if subcommands.empty?
    raise "#{self.class} has no available subcommands"
  end
  # meh, could deprecate and make subcommand define handle() itself
  # if args.count == 0 && default_subcommand
  #   # p "using default subcommand #{default_subcommand}"
  #   return self.send(default_subcommand, args || [])
  # end
  subcommand_name = args[0]
  if args.empty?
    print_error Morpheus::Terminal.angry_prompt
    puts_error "[command] argument is required"
    puts full_command_usage
    exit 127
  end
  if args[0] == "-h" || args[0] == "--help" || args[0] == "help"
    puts full_command_usage
    return 0
  end
  if subcommand_aliases[subcommand_name]
    subcommand_name = subcommand_aliases[subcommand_name]
  end
  cmd_method = subcommands[subcommand_name]
  if !cmd_method
    print_error Morpheus::Terminal.angry_prompt
    #puts_error "'#{subcommand_name}' is not recognized. See '#{my_help_command}'"
    puts_error "'#{subcommand_name}' is not recognized.\n#{full_command_usage}"
    return 127
  end
  self.send(cmd_method, args[1..-1])
end

#interactive? ⇒ `Boolean`

whether to prompt or not, this is true by default.

Returns:

(Boolean)



96
97
98

# File 'lib/morpheus/cli/cli_command.rb', line 96

def interactive?
  @no_prompt != true
end

#my_help_command ⇒ `Object`



764
765
766

# File 'lib/morpheus/cli/cli_command.rb', line 764

def my_help_command
  "morpheus #{command_name} --help"
end

#my_terminal ⇒ `Morpheus::Terminal`

Returns the terminal this command is being executed inside of.

Returns:

(Morpheus::Terminal) —

the terminal this command is being executed inside of



33
34
35

# File 'lib/morpheus/cli/cli_command.rb', line 33

def my_terminal
  @my_terminal ||= Morpheus::Terminal.instance
end

#my_terminal=(term) ⇒ `Object`

set the terminal running this command.

Parameters:

term (MorpheusTerminal) —

the terminal this command is assigned to

Returns:

the Terminal this command is being executed inside of

# File 'lib/morpheus/cli/cli_command.rb', line 40

def my_terminal=(term)
  if !term.is_a?(Morpheus::Terminal)
    raise "CliCommand (#{self.class}) my_terminal= expects object of type Terminal and instead got a #{term.class}"
  end
  @my_terminal = term
end

#parse_bytes_param(bytes_param, option, assumed_unit = nil) ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 113

def parse_bytes_param(bytes_param, option, assumed_unit = nil)
  if bytes_param && bytes_param.to_f > 0
    bytes_param.upcase!
    multiplier = 1
    unit = nil
    number = (bytes_param.to_f == bytes_param.to_i ? bytes_param.to_i : bytes_param.to_f)
    if (bytes_param.end_with? 'GB') || ((!bytes_param.end_with? 'MB') && assumed_unit == 'GB')
      unit = 'GB'
      multiplier = 1024 * 1024 * 1024
    elsif (bytes_param.end_with? 'MB') || assumed_unit == 'MB'
      unit = 'MB'
      multiplier = 1024 * 1024
    end
    return {:bytes_param => bytes_param, :bytes => number * multiplier, :number => number, :multiplier => multiplier, :unit => unit}
  end
  raise_command_error "Invalid value for #{option} option"
end

#parse_id_list(id_list, delim = /\s\,\s/) ⇒ `Object`

parse_id_list splits returns the given id_list with its values split on a comma

your id values cannot contain a comma, atm...

Parameters:

id_list (String or Array of Strings)
delim (String) (defaults to: /\s*\,\s*/) —

Default is a comma and any surrounding white space.

Returns:

array of values



109
110
111

# File 'lib/morpheus/cli/cli_command.rb', line 109

def parse_id_list(id_list, delim=/\s*\,\s*/)
  [id_list].flatten.collect {|it| it ? it.to_s.split(delim) : nil }.flatten.compact
end

#parse_list_options(options = {}) ⇒ `Object`

parse the parameters provided by the common :list options this includes the :query options too via parse_query_options(). returns Hash of params the format => “foobar”, “max”: 100

# File 'lib/morpheus/cli/cli_command.rb', line 969

def parse_list_options(options={})
  list_params = {}
  [:phrase, :offset, :max, :sort, :direction, :lastUpdated].each do |k|
    if options.key?(k)
      list_params[k.to_s] = options[k]
    elsif options.key?(k.to_s)
      list_params[k.to_s] = options[k.to_s]
    end
  end
  # arbitrary filters
  list_params.merge!(parse_query_options(options))
  
  return list_params
end

#parse_list_subtitles(options = {}) ⇒ `Object`

parse the subtitles provided by the common :list options returns Array of subtitles as strings in the format [“Phrase: blah”, “Max: 100”]

# File 'lib/morpheus/cli/cli_command.rb', line 1001

def parse_list_subtitles(options={})
  subtitles = []
  list_params = {}
  [:phrase, :offset, :max, :sort, :direction, :lastUpdated].each do |k|
    if options.key?(k)
      subtitles << "#{k.to_s}: #{options[k]}"
    elsif options.key?(k.to_s)
      subtitles << "#{k.to_s}: #{options[k.to_s]}"
    end
  end
  # arbitrary filters
  if options[:query_filters]
    formatted_filters = options[:query_filters].collect {|k,v| "#{k.to_s}=#{v}" }.join('&')
    subtitles << "Query: #{formatted_filters}"
    # options[:query_filters].each do |k, v|
    #   subtitles << "#{k.to_s}: #{v}"
    # end
  end
  return subtitles
end

#parse_payload(options = {}, object_key = nil) ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 1022

def parse_payload(options={}, object_key=nil)
  payload = nil
  if options[:payload]
    payload = options[:payload]
    # support -O OPTION switch on top of --payload
    apply_options(payload, options, object_key)
  end
  payload
end

#parse_query_options(options = {}) ⇒ `Object`

parse the parameters provided by the common :query (:query_filters) options returns Hash of params the format => “foobar”, “max”: 100

# File 'lib/morpheus/cli/cli_command.rb', line 986

def parse_query_options(options={})
  list_params = {}
  # arbitrary filters
  if options[:query_filters]
    options[:query_filters].each do |k, v|
      if k
        list_params[k] = v
      end
    end
  end
  return list_params
end

#print(*msgs) ⇒ `Object`

delegate :print, to: :my_terminal delegate :puts, to: :my_terminal or . . . bum bum bummm a paradigm shift away from include and use module functions instead. module_function :print, puts delegate :puts, to: :my_terminal



55
56
57

# File 'lib/morpheus/cli/cli_command.rb', line 55

def print(*msgs)
  my_terminal.stdout.print(*msgs)
end

#print_error(*msgs) ⇒ `Object`



68
69
70

# File 'lib/morpheus/cli/cli_command.rb', line 68

def print_error(*msgs)
  my_terminal.stderr.print(*msgs)
end

#println(*msgs) ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 59

def println(*msgs)
  print(*msgs)
  print "\n"
end

#puts(*msgs) ⇒ `Object`



64
65
66

# File 'lib/morpheus/cli/cli_command.rb', line 64

def puts(*msgs)
  my_terminal.stdout.puts(*msgs)
end

#puts_error(*msgs) ⇒ `Object`



72
73
74

# File 'lib/morpheus/cli/cli_command.rb', line 72

def puts_error(*msgs)
  my_terminal.stderr.puts(*msgs)
end

#raise_command_error(msg) ⇒ `Object`

Raises:

(Morpheus::Cli::CommandError)



100
101
102

# File 'lib/morpheus/cli/cli_command.rb', line 100

def raise_command_error(msg)
  raise Morpheus::Cli::CommandError.new(msg)
end

#render_with_format(json_response, options, object_key = nil) ⇒ `Object`

basic rendering for options :json, :yaml, :csv, :fields, and :outfile returns the string rendered, or nil if nothing was rendered.

# File 'lib/morpheus/cli/cli_command.rb', line 1047

def render_with_format(json_response, options, object_key=nil)
  output = nil
  if options[:json]
    output = as_json(json_response, options, object_key)
  elsif options[:yaml]
    output = as_yaml(json_response, options, object_key)
  elsif options[:csv]
    row = object_key ? json_response[object_key] : json_response
    if row.is_a?(Array)
      output = records_as_csv(row, options)
    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.
    output = ""
  end
  if output
    if options[:outfile]
      print_to_file(output, options[:outfile], options[:overwrite])
    else
      puts output
    end
  end
  return output
end

#run_command_for_each_arg(args, &block) ⇒ `0|1`

executes block with each argument in the list

Returns:

(0|1) —

0 if they were all successful, else 1

# File 'lib/morpheus/cli/cli_command.rb', line 838

def run_command_for_each_arg(args, &block)
  cmd_results = []
  args.each do |arg|
    begin
      cur_result = yield arg
    rescue SystemExit => err
      cur_result = err.success? ? 0 : 1
    end
    cmd_results << cur_result
  end
  # find a bad result and return it
  cmd_results = cmd_results.collect do |cmd_result| 
    if cmd_result.is_a?(Array)
      cmd_result
    else
      [cmd_result, nil]
    end
  end
  failed_result = cmd_results.find {|cmd_result| cmd_result[0] == false || (cmd_result[0].is_a?(Integer) && cmd_result[0] != 0) }
  return failed_result ? failed_result : cmd_results.last
end

#subcommand_aliases ⇒ `Object`



744
745
746

# File 'lib/morpheus/cli/cli_command.rb', line 744

def subcommand_aliases
  self.class.subcommand_aliases
end

#subcommand_usage(*extra) ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 768

def subcommand_usage(*extra)
  calling_method = caller[0][/`([^']*)'/, 1].to_s.sub('block in ', '')
  subcommand_name = subcommands.key(calling_method)
  extra = extra.flatten
  if !subcommand_name.empty? && extra.first == subcommand_name
    extra.shift
  end
  #extra = ["[options]"] if extra.empty?
  "Usage: morpheus #{command_name} #{subcommand_name} #{extra.join(' ')}".squeeze(' ').strip
end

#subcommands ⇒ `Object`



740
741
742

# File 'lib/morpheus/cli/cli_command.rb', line 740

def subcommands
  self.class.subcommands
end

#usage ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 756

def usage
  if !subcommands.empty?
    "Usage: morpheus #{command_name} [command] [options]"
  else
    "Usage: morpheus #{command_name} [options]"
  end
end

#verify_access_token! ⇒ `Object`

# File 'lib/morpheus/cli/cli_command.rb', line 959

def verify_access_token!
  if @access_token.empty?
    raise_command_error "Unable to acquire access token. Please verify your credentials and try again."
  end
  true
end

Module: Morpheus::Cli::CliCommand

Overview

Defined Under Namespace

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#no_prompt ⇒ Object (readonly)

Class Method Details

.included(klass) ⇒ Object

Instance Method Details

#apply_options(payload, options, object_key = nil) ⇒ Object

#build_common_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_option_type_options(opts, options, option_types = []) ⇒ Object

#build_standard_add_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_standard_get_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_standard_list_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_standard_remove_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_standard_update_options(opts, options, includes = [], excludes = []) ⇒ Object

#command_name ⇒ Object

#default_refresh_interval ⇒ Object

#default_subcommand ⇒ Object

#establish_remote_appliance_connection(options) ⇒ Object

#full_command_usage ⇒ Object

#handle(args) ⇒ Object

#handle_subcommand(args) ⇒ Object

#interactive? ⇒ Boolean

#my_help_command ⇒ Object

#my_terminal ⇒ Morpheus::Terminal

#my_terminal=(term) ⇒ Object

#parse_bytes_param(bytes_param, option, assumed_unit = nil) ⇒ Object

#parse_id_list(id_list, delim = /\s*\,\s*/) ⇒ Object

#parse_list_options(options = {}) ⇒ Object

#parse_list_subtitles(options = {}) ⇒ Object

#parse_payload(options = {}, object_key = nil) ⇒ Object

#parse_query_options(options = {}) ⇒ Object

#print(*msgs) ⇒ Object

#print_error(*msgs) ⇒ Object

#println(*msgs) ⇒ Object

#puts(*msgs) ⇒ Object

#puts_error(*msgs) ⇒ Object

#raise_command_error(msg) ⇒ Object

#render_with_format(json_response, options, object_key = nil) ⇒ Object

#run_command_for_each_arg(args, &block) ⇒ 0|1

#subcommand_aliases ⇒ Object

#subcommand_usage(*extra) ⇒ Object

#subcommands ⇒ Object

#usage ⇒ Object

#verify_access_token! ⇒ Object

#no_prompt ⇒ `Object` (readonly)

.included(klass) ⇒ `Object`

#apply_options(payload, options, object_key = nil) ⇒ `Object`

#build_common_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_option_type_options(opts, options, option_types = []) ⇒ `Object`

#build_standard_add_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_standard_get_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_standard_list_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_standard_remove_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_standard_update_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#command_name ⇒ `Object`

#default_refresh_interval ⇒ `Object`

#default_subcommand ⇒ `Object`

#establish_remote_appliance_connection(options) ⇒ `Object`

#full_command_usage ⇒ `Object`

#handle(args) ⇒ `Object`

#handle_subcommand(args) ⇒ `Object`

#interactive? ⇒ `Boolean`

#my_help_command ⇒ `Object`

#my_terminal ⇒ `Morpheus::Terminal`

#my_terminal=(term) ⇒ `Object`

#parse_bytes_param(bytes_param, option, assumed_unit = nil) ⇒ `Object`

#parse_id_list(id_list, delim = /\s\,\s/) ⇒ `Object`

#parse_list_options(options = {}) ⇒ `Object`

#parse_list_subtitles(options = {}) ⇒ `Object`

#parse_payload(options = {}, object_key = nil) ⇒ `Object`

#parse_query_options(options = {}) ⇒ `Object`

#print(*msgs) ⇒ `Object`

#print_error(*msgs) ⇒ `Object`

#println(*msgs) ⇒ `Object`

#puts(*msgs) ⇒ `Object`

#puts_error(*msgs) ⇒ `Object`

#raise_command_error(msg) ⇒ `Object`

#render_with_format(json_response, options, object_key = nil) ⇒ `Object`

#run_command_for_each_arg(args, &block) ⇒ `0|1`

#subcommand_aliases ⇒ `Object`

#subcommand_usage(*extra) ⇒ `Object`

#subcommands ⇒ `Object`

#usage ⇒ `Object`

#verify_access_token! ⇒ `Object`