Module: Morpheus::Cli::CliCommand

Included in:: AccessTokenCommand, AccountGroupsCommand, ActivityCommand, AliasCommand, ApplianceSettingsCommand, ApprovalsCommand, Apps, ArchivesCommand, Audit, BackupJobsCommand, BackupServices, BackupSettingsCommand, BackupsCommand, BenchmarkCommand, BlueprintsCommand, BootScriptsCommand, BudgetsCommand, CatCommand, CatalogCommand, CatalogItemTypesCommand, CertificatesCommand, ChangePasswordCommand, ClientsCommand, CloudDatastoresCommand, CloudFoldersCommand, CloudResourcePoolsCommand, Clouds, Clusters, ColoringCommand, ContainersCommand, CredentialTypesCommand, CredentialsCommand, CurlCommand, CypherCommand, DashboardCommand, DebugCommand, Deploy, Deployments, Deploys, Doc, Echo, EditProfileCommand, EditRcCommand, EnvironmentsCommand, ExecuteSchedulesCommand, ExecutionRequestCommand, ExitCommand, FileCopyRequestCommand, ForgotPassword, GetPromptCommand, Groups, GuidanceCommand, GuidanceSettings, HealthCommand, HistoryCommand, Hosts, ImageBuilderCommand, InstanceTypes, Instances, IntegrationsCommand, InvoicesCommand, JobsCommand, KeyPairs, LibraryClusterLayoutsCommand, LibraryContainerScriptsCommand, LibraryContainerTemplatesCommand, LibraryContainerTypesCommand, LibraryInstanceTypesCommand, LibraryLayoutsCommand, LibraryOptionListsCommand, LibraryOptionTypesCommand, LibrarySpecTemplatesCommand, LibraryUpgradesCommand, License, LoadBalancerMonitors, LoadBalancerPools, LoadBalancerProfiles, LoadBalancerTypes, LoadBalancerVirtualServers, LoadBalancers, LogLevelCommand, LogSettingsCommand, Login, Logout, LogsCommand, ManCommand, MonitoringAlertsCommand, MonitoringAppsCommand, MonitoringChecksCommand, MonitoringContactsCommand, MonitoringGroupsCommand, MonitoringIncidentsCommand, MonitoringSettings, NetworkDhcpRelaysCommand, NetworkDhcpServersCommand, NetworkDomainsCommand, NetworkEdgeClustersCommand, NetworkFirewallsCommand, NetworkFloatingIps, NetworkGroupsCommand, NetworkPoolServerTypes, NetworkPoolServersCommand, NetworkPoolsCommand, NetworkProxiesCommand, NetworkRoutersCommand, NetworkServerGroups, NetworkServicesCommand, NetworkStaticRoutesCommand, NetworkTransportZonesCommand, NetworksCommand, OpenCommand, Options, PackagesCommand, Ping, PluginsCommand, PoliciesCommand, PowerSchedulesCommand, PreseedScriptsCommand, PriceSetsCommand, PricesCommand, Processes, Projects, ProvisioningLicensesCommand, ProvisioningSettingsCommand, RecentActivityCommand, Remote, RemoveFileCommand, ReportsCommand, ResourcePoolGroupsCommand, Roles, ScaleThresholds, SearchCommand, SecurityGroupRules, SecurityGroups, SecurityPackageTypesCommand, SecurityPackagesCommand, SecurityScansCommand, ServicePlanCommand, SetPromptCommand, Setup, Shell, Sleep, Snapshots, SourceCommand, SslVerificationCommand, StorageProvidersCommand, StorageServerTypes, StorageServers, StorageVolumeTypes, StorageVolumes, SubnetsCommand, Tasks, TeeCommand, TenantsCommand, UpdateCommand, UsageCommand, UserGroupsCommand, UserSettingsCommand, UserSourcesCommand, Users, VdiAllocationsCommand, VdiAppsCommand, VdiCommand, VdiGatewaysCommand, VdiPoolsCommand, VersionCommand, View, 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(base) ⇒ Object

Instance Method Summary collapse

#add_query_parameter(params, key, value) ⇒ Object

Add a name=value query parameter, building an array if there is more than one.
#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_get_options(opts, options, params) ⇒ Object

The default way to build options for the list command.
#build_list_options(opts, options, params) ⇒ Object

The default way to build options for the list command.
#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_payload(options, object_key = nil) ⇒ Object
#build_standard_add_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_api_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_delete_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_get_options(opts, options, includes = [], excludes = []) ⇒ Object

the standard options for a command that makes api requests (most of them).
#build_standard_list_options(opts, options, includes = [], excludes = []) ⇒ Object

list is GET that supports phrase,max,offset,sort,direction.
#build_standard_post_options(opts, options, includes = [], excludes = []) ⇒ Object
#build_standard_put_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_description ⇒ Object
#command_name ⇒ Object
#confirm(msg, options) ⇒ Object
#confirm!(msg, options) ⇒ Object
#default_refresh_interval ⇒ Object
#default_sigdig ⇒ Object

number of decimal places to show with curreny.
#default_subcommand ⇒ Object
#establish_remote_appliance_connection(options) ⇒ Object

This supports the simple remote option eg.
#find_all(*args) ⇒ Object (also: #find_all_records)

Load a list of records by type find_record(:app, 1) report_types = find_all(“reportTypes”, phrase:“amazon”) pools = find_all(“loadBalancerPool”, load_balancer_id).
#find_all_json(*args) ⇒ Object (also: #find_all_records_json)

Load json response for a list of records by type.
#find_by_id(*args) ⇒ Object

Find a resource by type and id Usage: find_by_name_or_id(“app”, 3).
#find_by_name(*args) ⇒ Object

Find a record by type and name Usage: find_by_name_or_id(“network”, “Skynet”).
#find_by_name_or_id(*args) ⇒ Object

Find a resource by type and name or id Example: find_by_name_or_id(“instance”, “K2”) find_by_name_or_id(“storage_volume”, 42) find_by_name_or_id(“instance”, “My Instance”) find_by_name_or_id(“load_balancer_pool”, load_balancer_id, id).
#find_record(*args) ⇒ Hash

Load a single record (Hash) by type and id and optional parameters Examples: apps = find_record(:app) report_types = find_record(“reportTypes”, phrase:“amazon”) pools = find_record(“loadBalancerPool”, balancer_id).
#find_record_json(*args) ⇒ Object

Load list of records by type and (optional) parameters Examples: apps = find_record(:app, 1) report_types = find_record(“reportType”, 1) pools = find_all(“loadBalancerPool”, load_balancer_id).
#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.
#get_interface(type) ⇒ Object

Load json response for a list of records by type.
#get_list_key(type) ⇒ Object
#get_object_key(type) ⇒ Object
#get_subcommand_description(subcmd) ⇒ Object

def subcommand_descriptions self.class.subcommand_descriptions end.
#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_array(val, opts = {}) ⇒ Object
#parse_bytes_param(bytes_param, option, assumed_unit = nil, allow_zero = false) ⇒ Object
#parse_get_options!(args, options, params) ⇒ Object

The default way to parse options for the get command.
#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_labels(val) ⇒ Object
#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_options!(args, options, params) ⇒ Object

The default way to parse options for the list command.
#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_parameter_as_resource_id!(type, options, params, param_name = nil, lookup_ids = false) ⇒ Object

The default way to parse options for the get command.
#parse_passed_options(options, parse_opts = {}) ⇒ Object

this returns all the options passed in by -O, parsed all nicely into objects.
#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
#prog_name ⇒ Object
#puts(*msgs) ⇒ Object
#puts_error(*msgs) ⇒ Object
#raise_args_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ Object
#raise_command_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ Object
#render_response(json_response, options, object_key = nil, &block) ⇒ Object (also: #render_with_format)

basic rendering for options :json, :yml, :csv, :quiet, 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_description ⇒ Object
#subcommand_usage(*extra) ⇒ Object
#subcommands ⇒ Object
#usage ⇒ Object
#validate_outfile(outfile, options) ⇒ Object
#verify_args!(opts = {}) ⇒ Object

verify_args! verifies that the right number of commands were passed and raises a command error if not.
#visible_subcommands ⇒ 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(base) ⇒ `Object`

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

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

Instance Method Details

#add_query_parameter(params, key, value) ⇒ `Object`

Add a name=value query parameter, building an array if there is more than one

Parameters:

params (Hash) —

the query parameter map to append to
key (String) —

the parameter name
value (Object) —

the parameter value

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

def add_query_parameter(params, key, value)
  # key = key.to_s
  if params.key?(key) && !params[key].nil?
    if !params[key].is_a?(Array)
      params[key] = [params[key]]
    end
    params[key] << value
  else
    params[key] = value
  end
  params
end

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

support -O OPTION switch

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

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 292

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 :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', "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 :details
      opts.on('-a', '--all', "Show all details." ) do
        options[:details] = true
      end
      opts.on('--details', '--details', "Show more details" ) do
        options[:details] = true
      end
      opts.add_hidden_option('--details')

    when :sigdig
      opts.on('--sigdig DIGITS', "Significant digits to display for prices (currency). Default is #{default_sigdig}.") do |val|
        options[:sigdig] = val.to_i
      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('.')
        option_type = (options[:option_types] || []).find {|it| it['fieldName'] == custom_option_args[0]} || {}
        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]
              unless option_type['noParse']
                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
              end
              nested_options[name_element] = val
            end
          end
        else
          val = custom_option_args[1]
          unless option_type['noParse']
            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
          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
      # --always-prompt can be used with for update commands where it normally defaults to --no-prompt
      opts.on('--prompt', "Always prompt for input on every option, even those not prompted for by default.") do
        options[:always_prompt] = true
        options[:options][:always_prompt] = true
      end
      opts.on('-N','--no-prompt', "No prompt, skips all input prompting.") do |val|
        options[:no_prompt] = true
        options[:options][:no_prompt] = true
      end
      # opts.on('--skip-prompt x,y,z', String, "Skip prompt, do not prompt for input of the specified options.") do |val|
      #   options[:skip_prompt] ||= []
      #   options[:skip_prompt] += parse_array(val)
      #   options[:options][:skip_prompt] = options[:skip_prompt]
      # end
      # opts.on('--only-prompt x,y,z', String, "Only prompt for input on the specified options.") do |val|
      #   options[:only_prompt] ||= []
      #   options[:only_prompt] += parse_array(val)
      #   options[:options][:only_prompt] = options[:only_prompt]
      # end
      opts.on('--no-options', String, "No options, skips all option parsing so no options are required and no default values are used.") do
        options[:no_options] = true
        options[:options][:no_options] = options[:no_options]
      end
      opts.on('--skip-options x,y,z', String, "Skip parsing of the specified options so that they are not required and their default value is not used.") do |val|
        options[:skip_options] ||= []
        options[:skip_options] += parse_array(val)
        options[:options][:skip_options] = options[:skip_options]
      end
      # opts.on('--only-options x,y,z', String, "Only parse the specified options and skip all others.") do |val|
      #   options[:only_options] ||= []
      #   options[:only_options] += parse_array(val)
      #   options[:options][:only_options] = options[:only_options]
      # end
      
      # hide these while incubating
      opts.add_hidden_option('--skip-prompt')
      opts.add_hidden_option('--only-prompt')
      opts.add_hidden_option('--no-options')
      opts.add_hidden_option('--skip-options')
      opts.add_hidden_option('--only-options')

    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.exist?(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.exist?(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|
        # api supports max=-1 for all at the moment..
        if val.to_s == "all" || val.to_s == "-1"
          options[:max] = "-1"
        else
          max = val.to_i
          if max <= 0
            raise ::OptionParser::InvalidArgument.new("must be a positive integer")
          end
          options[:max] = max
        end
      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

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

      opts.on( '-S', '--sort ORDER', "Sort Order. DIRECTION may be included as \"ORDER [asc|desc]\"." ) do |v|
        if v.to_s.include?(",")
          # sorting on multiple properties, just pass it as is, newer api supports multiple fields
          options[:sort] = v
        else
          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
      end

      opts.on( '-D', '--desc', "Descending Sort Direction." ) do |v|
        options[:direction] = "desc"
      end

      opts.on( "--reverse", "Reverse order of results. This invert is done by the client, not necessarily the entire dataset." ) do
        options[:reverse] = true
      end

      # arbitrary query parameters in the format -Q "category=web&phrase=nginx"
      # 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
      #   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"
      # or pass it many times like -Q foo=bar -Q hello=world
      opts.on( '-Q', '--query PARAMS', "Query parameters. PARAMS format is 'foo=bar&category=web'" ) do |val|
        if options[:query_filters_raw] && !options[:query_filters_raw].empty?
          options[:query_filters_raw] += ("&" + val)
        else
          options[:query_filters_raw] = val
        end
        options[:query_filters] ||= {}
        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 :find_by_name
      opts.on('--find-by-name', "Always treat the identifier argument as a name, never an ID. Useful for specifying names that look like numbers. eg. '1234'" ) do
        options[:find_by_name] = true
      end
      # opts.add_hidden_option('--find-by-name') if opts.is_a?(Morpheus::Cli::OptionParser)

    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( '--token-file FILE', String, "Token File, read a file containing the access token." ) do |val|
        token_file = File.expand_path(val)
        if !File.exist?(token_file) || !File.file?(token_file)
          raise ::OptionParser::InvalidOption.new("File not found: #{token_file}")
        end
        options[:remote_token] = File.read(token_file).to_s.split("\n").first.strip
      end
      opts.add_hidden_option('--token-file') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on( '-U', '--username USERNAME', "Username for authentication." ) do |val|
        options[:remote_username] = val
      end unless excludes.include?(:remote_username)
      

      unless excludes.include?(:remote_password)
        opts.on( '-P', '--password PASSWORD', "Password for authentication." ) do |val|
          options[:remote_password] = val
        end
        opts.on( '--password-file FILE', String, "Password File, read a file containing the password for authentication." ) do |val|
          password_file = File.expand_path(val)
          if !File.exist?(password_file) || !File.file?(password_file)
            raise ::OptionParser::InvalidOption.new("File not found: #{password_file}")
          end
          file_content = File.read(password_file) #.strip
          options[:remote_password] = File.read(password_file).to_s.split("\n").first
        end
        opts.add_hidden_option('--password-file') if opts.is_a?(Morpheus::Cli::OptionParser)
      end

      # 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('-H, --header') 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
      # -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
        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
      # deprecated --csv-delim, use --delimiter instead
      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.add_hidden_option('--csv-delim') if opts.is_a?(Morpheus::Cli::OptionParser)

      # deprecated --csv-newline, use --newline instead
      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.to_s.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
          options[:csv_newline] = val
        end
      end
      opts.add_hidden_option('--csv-newline') if opts.is_a?(Morpheus::Cli::OptionParser)

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

      opts.on(nil, '--csv-no-header', "Exclude header for CSV Output.") do
        options[:csv] = true
        options[:format] = :csv
        options[:csv_no_header] = true
      end
      opts.add_hidden_option('--csv-no-header') if opts.is_a?(Morpheus::Cli::OptionParser)

      opts.on(nil, '--quotes', "Wrap CSV values with \". Default: false") do
        options[:csv_quotes] = true
      end
      opts.add_hidden_option('--csv-quotes') if opts.is_a?(Morpheus::Cli::OptionParser)

      opts.on(nil, '--no-header', "Exclude header for CSV Output.") do
        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, --old-fields') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on('--raw-fields [x,y,z]', String, "Raw fields filters output like --fields except the properties [x,y,z] must be specified from the root of the response instead of relative to the the list or object context for this particular resource.") do |val|
        if val.size == 1 && val[0].downcase == 'all'
          options[:all_fields] = true
        else
          options[:include_fields] = val.split(',').collect {|r| r.strip}.compact
        end
        options[:raw_fields] = true
      end
      opts.add_hidden_option('--raw-fields') 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.on(nil, '--wrap', "Wrap table columns instead hiding them when terminal is not wide enough.") do
        options[:wrap] = true
      end
    when :select
      #opts.add_hidden_option('--all-fields') if opts.is_a?(Morpheus::Cli::OptionParser)
      opts.on('--select x,y,z', String, "Filter Output to just print the value(s) of specific fields.") do |val|
        options[:select_fields] = val.split(',').collect {|r| r.strip}
      end
      opts.on('--raw-select x,y,z', String, "Raw select works like --select except the properties [x,y,z] must be specified from the root of the response instead of relative to the the list or object context for this particular resource.") do |val|
        options[:select_fields] = val.split(',').collect {|r| r.strip}
        options[:raw_fields] = true
      end
      opts.add_hidden_option('--raw-select') if opts.is_a?(Morpheus::Cli::OptionParser)

    when :delim
      opts.on('--delimiter [CHAR]', String, "Delimiter for output values. Default: ',', use with --select and --csv") do |val|
        options[:csv] = true
        options[:format] = :csv
        val = val.to_s
        val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
        options[:delim] = val
      end

      opts.on('--newline [CHAR]', String, "Delimiter for output rows. Default: '\\n', use with --select and --csv") do |val|
        options[:csv] = true
        options[:format] = :csv
        val = val.to_s
        if val == "no" || val == "none"
          options[:newline] = ""
        else
          val = val.to_s.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
          options[:newline] = val
        end
      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', "Curl, print the API request as a curl command instead of executing it.") 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?
  # Also useful for seeing exit status for every command.
  opts.on('-B','--benchmark', "Print benchmark time and exit/error 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

  # A way to ensure debugging is off, it should go back on after the command is complete.
  opts.on('--no-debug','--no-debug', "Disable debugging.") do
    options[:debug] = false
    Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::INFO)
    ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
  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 0 # 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 0 # return 0 maybe?
  end

  opts
end

#build_get_options(opts, options, params) ⇒ `Object`

The default way to build options for the list command

Parameters:

opts (OptionParser)
options (Hash)
params (Hash)



1309
1310
1311

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

def build_get_options(opts, options, params)
  build_standard_get_options(opts, options)
end

#build_list_options(opts, options, params) ⇒ `Object`

The default way to build options for the list command

Parameters:

opts (OptionParser)
options (Hash)
params (Hash)



1289
1290
1291

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

def build_list_options(opts, options, params)
  build_standard_list_options(opts, options)
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 148

def build_option_type_options(opts, options, option_types=[])
  #opts.separator ""
  #opts.separator "Options:"
  options[:options] ||= {} # this is where these go..for now
  options[:option_types] = (options[:option_types] || []) + option_types
  custom_options = options[:options]
  
  # add each one to the OptionParser
  option_types.each do |option_type|
    # skip hidden types
    if option_type['type'] == 'hidden'
      next
    end
    if option_type['fieldName'].empty?
      puts_error "Missing fieldName for option type: #{option_type}" if Morpheus::Logging.debug?
      next
    end
    full_field_name = option_type['fieldContext'].to_s.empty? ? option_type['fieldName'] : "#{option_type['fieldContext']}.#{option_type['fieldName']}"
    field_namespace = full_field_name.split(".")
    field_name = field_namespace.pop

    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']}"
    # 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
    full_option = "--#{full_field_name} #{value_label}"
    # switch is an alias for the full option name, fieldName is the default
    if option_type['switch']
      full_option = "--#{option_type['switch']} #{value_label}"
    end
    arg1, arg2 = full_option, String
    if option_type['shorthand']
      arg1, arg2 = full_option, option_type['shorthand']
    end
    opts.on(arg1, arg2, description) do |val|
      if option_type['type'] == 'checkbox'
        val = (val.to_s != 'false' && val.to_s != 'off')
      elsif option_type['dataType'] != 'string'
        # 'dataType': 'string' added to cli to avoid auto conversion to JSON
        # 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
      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_payload(options, object_key = nil) ⇒ `Object`

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

def build_payload(options, object_key=nil)
  payload = {}
  if options[:payload]
    parse_payload(options, object_key)
  else
    apply_options(payload, options, object_key)
  end
  return payload
end

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



266
267
268

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

def build_standard_add_options(opts, options, includes=[], excludes=[])
  build_standard_post_options(opts, options, includes, excludes)
end

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



278
279
280

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

def build_standard_api_options(opts, options, includes=[], excludes=[])
  build_common_options(opts, options, includes + [:query, :options, :payload, :json, :yaml, :csv, :fields, :select, :delim, :quiet, :dry_run, :remote], excludes)
end

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



257
258
259

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

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

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

the standard options for a command that makes api requests (most of them)



245
246
247

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

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

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

list is GET that supports phrase,max,offset,sort,direction



262
263
264

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

def build_standard_list_options(opts, options, includes=[], excludes=[])
  build_standard_get_options(opts, options, [:list] + includes, excludes)
end

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



249
250
251

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

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

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



253
254
255

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

def build_standard_put_options(opts, options, includes=[], excludes=[])
  build_standard_post_options(opts, options, includes, excludes)
end

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



274
275
276

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

def build_standard_remove_options(opts, options, includes=[], excludes=[])
  build_standard_delete_options(opts, options, includes, excludes)
end

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



270
271
272

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

def build_standard_update_options(opts, options, includes=[], excludes=[])
  build_standard_put_options(opts, options, includes, excludes)
end

#command_description ⇒ `Object`



962
963
964

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

def command_description
  self.class.command_description
end

#command_name ⇒ `Object`



958
959
960

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

def command_name
  self.class.command_name
end

#confirm(msg, options) ⇒ `Object`



1277
1278
1279

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

def confirm(msg, options)
  options[:yes] or ::Morpheus::Cli::OptionTypes::confirm(msg, options)
end

#confirm!(msg, options) ⇒ `Object`



1281
1282
1283

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

def confirm!(msg, options)
  confirm(msg, options) or raise CommandAborted.new("confirmation declined: #{msg}")
end

#default_refresh_interval ⇒ `Object`



996
997
998

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

def default_refresh_interval
  self.class.default_refresh_interval
end

#default_sigdig ⇒ `Object`

number of decimal places to show with curreny



283
284
285

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

def default_sigdig
  2
end

#default_subcommand ⇒ `Object`



992
993
994

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

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” By default it will connect to the active (current) remote appliance 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. This will prompt for credentials if none are found, use :skip_login Credentials will be saved unless –remote-url or –token is being used.

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

def establish_remote_appliance_connection(options)
  # todo: probably refactor and don't rely on this method to set these instance vars
  @remote_appliance = nil
  @appliance_name, @appliance_url, @access_token = nil, nil, nil
  @api_client = nil
  @do_save_credentials = true
  # skip saving if --remote-url or --username or --password are passed in
  if options[:remote_url] || options[:remote_token] || options[:remote_username] || options[:remote_password]
    @do_save_credentials = false
  end
  appliance = nil
  if options[:remote_url]
    # --remote-url means use an arbitrary url, do not save any appliance config
    # appliance = {name:'remote-url', url:options[:remote_url]}
    appliance = {url:options[:remote_url]}
    appliance[:temporary] = true
    #appliance[:status] = "ready" # or  "unknown"
    # appliance[:last_check] = nil
  elsif options[:remote]
    # --remote means use the specified remote
    appliance = ::Morpheus::Cli::Remote.load_remote(options[:remote])
    if appliance.nil?
      if ::Morpheus::Cli::Remote.appliances.empty?
        raise_command_error "No remote appliances exist, see the command `remote add`."
      else
        raise_command_error "Remote appliance not found by the name '#{options[:remote]}', see `remote list`"
      end
    end
  else
    # use active remote
    appliance = ::Morpheus::Cli::Remote.load_active_remote()
    if !appliance
      if ::Morpheus::Cli::Remote.appliances.empty?
        raise_command_error "No remote appliances exist, see the command `remote add`"
      else
        raise_command_error "#{command_name} requires a remote to be specified, try the option -r [remote] or see the command `remote use`"
      end
    end
  end
  @remote_appliance = appliance
  @appliance_name = appliance[:name]
  @appliance_url = appliance[:url] || appliance[:host] # it used to store :host in the YAML
  # set enable_ssl_verification
  # 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...
  allow_insecure = false
  if options[:insecure] || appliance[:insecure] || Morpheus::Cli::Shell.insecure
    allow_insecure = true
  end
  @verify_ssl = !allow_insecure
  # Morpheus::RestClient.enable_ssl_verification = allow_insecure != true
  if allow_insecure && Morpheus::RestClient.ssl_verification_enabled?
    Morpheus::RestClient.enable_ssl_verification = false
  elsif !allow_insecure && !Morpheus::RestClient.ssl_verification_enabled?
    Morpheus::RestClient.enable_ssl_verification = true
  end

  # always support 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 remote #{display_appliance(@appliance_name, @appliance_url)}" if Morpheus::Logging.debug? # && !options[:quiet]

  if options[:no_authorization]
    # maybe handle this here..
    options[:skip_login] = true
    options[:skip_verify_access_token] = true
  end

  # ok, get some credentials.
  # use saved credentials by default or prompts for username, password.
  # passing --remote-url will skip loading saved credentials and prompt for login to use with the url
  # passing --token skips login prompting and uses the provided token.
  # passing --token or --username will skip saving credentials to appliance config, they are just used for one command
  # ideally this should not prompt now and wait until the client is used on a protected endpoint.
  # @wallet = nil
  if options[:remote_token]
    @wallet = {'access_token' => options[:remote_token]} #'username' => 'anonymous'
  elsif options[:remote_url]
    credentials = Morpheus::Cli::Credentials.new(@appliance_name, @appliance_url)
    unless options[:skip_login]
      @wallet = credentials.request_credentials(options, @do_save_credentials)
    end
  else
    credentials = Morpheus::Cli::Credentials.new(@appliance_name, @appliance_url)
    # use saved credentials unless --username or passed
    unless options[:remote_username]
      @wallet = credentials.load_saved_credentials()
    end
    # using active remote OR --remote flag
    # used saved credentials or login
    # ideally this sould not prompt now and wait  until the client is used on a protected endpoint.

    
    if @wallet.nil? || @wallet['access_token'].nil?
      unless options[:skip_login]
        @wallet = credentials.request_credentials(options, @do_save_credentials)
      end
    end
    
  end
  @access_token = @wallet ? @wallet['access_token'] : nil

  # validate we have a token
  # hrm...
  unless options[:skip_verify_access_token]
    if @access_token.empty?
      raise AuthorizationRequiredError.new("Failed to acquire access token for #{display_appliance(@appliance_name, @appliance_url)}. Verify your credentials are correct.")  
    end
  end

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

#find_all(*args) ⇒ `Object` Also known as: find_all_records

Load a list of records by type find_record(:app, 1) report_types = find_all(“reportTypes”, phrase:“amazon”) pools = find_all(“loadBalancerPool”, load_balancer_id)

Examples:

Find an app by id

Returns:

Array of records

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

def find_all(*args)
  #Morpheus::Logging::DarkPrinter.puts "find_all(#{args.join(', ')})" if Morpheus::Logging.debug?
  type, *request_args = args
  type = type.to_s.singularize.underscore
  list_key = respond_to?("#{type}_list_key", true) ? send("#{type}_list_key") : get_list_key(type)
  json_response = find_all_json(*args)
  if !json_response.key?(list_key)
    # maybe just use the first key like this:
    # list_key = json_response.keys.find { |k| json_response[k].is_a?(Array) }
    # puts_error(json_response) if Morpheus::Logging.debug?
    raise "API response is missing list property '#{list_key}'"
  end
  return json_response[list_key]
end

#find_all_json(*args) ⇒ `Object` Also known as: find_all_records_json

Load json response for a list of records by type

Returns:

Hash of JSON data

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

def find_all_json(*args)
  type, *request_args = args
  get_interface(type).list(*request_args)
end

#find_by_id(*args) ⇒ `Object`

Find a resource by type and id Usage: find_by_name_or_id(“app”, 3)

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

def find_by_id(*args)
  #Morpheus::Logging::DarkPrinter.puts "find_by_id(#{args.join(', ')})" if Morpheus::Logging.debug?
  # type, ids = args.first, args[1..-1]
  type, *ids = args
  type = type.to_s.singularize.underscore
  # still relying on the command or helper to define these _label and _key methods
  # label = send("#{type}_label")
  # object_key = send("#{type}_object_key")
  # ^ nope, not for long!
  object_key = respond_to?("#{type}_object_key", true) ? send("#{type}_object_key") : type.camelcase.singularize
  label = respond_to?("#{type}_label", true) ? send("#{type}_label") : type.titleize
  interface_name = "@#{type.pluralize}_interface"
  interface = instance_variable_get(interface_name)
  if interface.nil?
    api_client = instance_variable_get("@api_client")
    if api_client
      if api_client.respond_to?(type.pluralize)
        interface = api_client.send(type.pluralize)
      else
        raise "@api_client.#{type.pluralize} is not a recognized interface"
      end
    else
      raise "#{self.class} has not defined interface #{interface_name} or @api_client"
    end
  end
  begin
    json_response = interface.get(*ids)
    if !json_response.key?(object_key)
      # maybe just use the first key like this:
      # object_key = json_response.keys.find { |k| json_response[k].is_a?(Hash) }
      #puts_error(json_response) if Morpheus::Logging.debug?
      raise "API response is missing object property '#{object_key}'"
    end
    record = json_response[object_key]
    if record.nil?
      print_red_alert "#{label} not found in API response (#{object_key})"
      return nil
    else
      return json_response[object_key]
    end
  rescue ::RestClient::Exception => e
    if e.response && e.response.code == 404
      print_red_alert "#{label} not found by id #{ids.last}"
      return nil
    else
      raise e
    end
  end
end

#find_by_name(*args) ⇒ `Object`

Find a record by type and name Usage: find_by_name_or_id(“network”, “Skynet”)

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

def find_by_name(*args)
  #Morpheus::Logging::DarkPrinter.puts "find_by_name(#{args.join(', ')})" if Morpheus::Logging.debug?
  # type, ids = args.first, args[1..-1]
  type, *ids = args
  type = type.to_s.singularize.underscore
  val = ids.pop
  params = {}
  name_property = 'name'
  if type == 'user'
    name_property = 'username'
    params['global'] = 'true'
  end
  params[name_property] = val.to_s
  request_args = ids + [params]
  request_args.unshift(type)
  records = find_all(*request_args)
  # still relying on the command or helper to define these _label and _key methods
  label = respond_to?("#{type}_label", true) ? send("#{type}_label") : type.titleize
  if records.empty?
    print_red_alert "#{label} not found by name '#{val}'"
    return nil
  elsif records.size > 1
    print_red_alert "More than one #{label.downcase} found by #{name_property} '#{val}'"
    print_error "\n"
    if type == "user"
      puts_error as_pretty_table(records, [:id, :username, {"FIRST NAME" => "firstName"}, {"LAST NAME" => "lastName"}, {"TENANT" => lambda {|it| it['account']['name'] rescue ''}}], {color:red})
    else
      puts_error as_pretty_table(records, [:id, :name], {color:red})
    end
    print_red_alert "Try using ID instead"
    print_error reset,"\n"
    return nil
  else
    return records[0]
  end
end

#find_by_name_or_id(*args) ⇒ `Object`

Find a resource by type and name or id Example: find_by_name_or_id(“instance”, “K2”)

find_by_name_or_id("storage_volume", 42)
find_by_name_or_id("instance", "My Instance")
find_by_name_or_id("load_balancer_pool", load_balancer_id, id)

Parameters:

type (String of Symbol) —

Type of resource formatted as singular, lowerscore with underscores.
*id (String or Numeric) —

ID of resource, multiple arguments may be passed when using a secondary interface where parent_id, id is required.

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

def find_by_name_or_id(*args)
  val = args.last
  if val.to_s =~ /\A\d{1,}\Z/
    return find_by_id(*args)
  else
    return find_by_name(*args)
  end
end

#find_record(*args) ⇒ `Hash`

Load a single record (Hash) by type and id and optional parameters Examples: apps = find_record(:app) report_types = find_record(“reportTypes”, phrase:“amazon”) pools = find_record(“loadBalancerPool”, balancer_id)

Returns:

(Hash) —

of the object that was found or raises an exception if 404 not found encountered.

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

def find_record(*args)
  #Morpheus::Logging::DarkPrinter.puts "find_record(#{args.join(', ')})" if Morpheus::Logging.debug?
  type, *request_args = args
  type = type.to_s.singularize.underscore
  object_key = respond_to?("#{type}_object_key", true) ? send("#{type}_object_key") : get_object_key(type)
  json_response = find_record_json(*args)
  if !json_response.key?(object_key)
    # maybe just use the first key like this:
    # object_key = json_response.keys.find { |k| json_response[k].is_a?(Hash) }
    # puts_error(json_response) if Morpheus::Logging.debug?
    raise "API response is missing object property '#{object_key}'"
  end
  return json_response[object_key]
end

#find_record_json(*args) ⇒ `Object`

Load list of records by type and (optional) parameters Examples: apps = find_record(:app, 1) report_types = find_record(“reportType”, 1) pools = find_all(“loadBalancerPool”, load_balancer_id)

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

def find_record_json(*args)
  #Morpheus::Logging::DarkPrinter.puts "find_record_json(#{args.join(', ')})" if Morpheus::Logging.debug?
  type, *request_args = args
  get_interface(type).get(*request_args)
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 1026

def full_command_usage
  out = ""
  out << usage.to_s.strip if usage
  out << "\n"
  my_subcommands = visible_subcommands
  if !my_subcommands.empty?
    out << "Commands:"
    out << "\n"
    my_subcommands.sort.each {|subcmd, method|
      desc = get_subcommand_description(subcmd)
      out << "\t#{subcmd.to_s}"
      out << "\t#{desc}" if desc
      out << "\n"
    }
  end
  if command_description && !command_description.to_s.strip.empty?
    out << "\n"
    out << "#{command_description.strip}\n"
  end
  # out << "\n"
  out
end

#get_interface(type) ⇒ `Object`

Load json response for a list of records by type

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

def get_interface(type)
  #Morpheus::Logging::DarkPrinter.puts "get_interface(#{type})" if Morpheus::Logging.debug?
  # todo: can probably just do @api_client ? @api_client.interface(interface_name) : nil
  type = type.to_s.singularize.underscore
  interface_name = "@#{type.pluralize}_interface"
  interface = nil
  if instance_variable_defined?(interface_name)
    interface = instance_variable_get(interface_name)
    if interface.nil?
      # Fix is to update connect() to do @apps_interface = @api_client.apps
      raise "API Interface #{interface_name} is nil"
    end
  else
    if @api_client.is_a?(Morpheus::APIClient)
      interface = @api_client.interface(type.pluralize)
    else
      raise "#{self.class} has not initalized @api_client"
    end
  end
  return interface
end

#get_list_key(type) ⇒ `Object`



1784
1785
1786

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

def get_list_key(type)
  return get_object_key(type).pluralize
end

#get_object_key(type) ⇒ `Object`

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

def get_object_key(type)
  key = type.camelcase.singularize
  # add aliases here as needed
  if key == "cloud"
    key = "zone"
  end
  return key
end

#get_subcommand_description(subcmd) ⇒ `Object`

def subcommand_descriptions

self.class.subcommand_descriptions

end



982
983
984

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

def get_subcommand_description(subcmd)
  self.class.get_subcommand_description(subcmd)
end

#handle(args) ⇒ `Object`



1082
1083
1084

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

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 1050

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 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
    error_msg = "'#{command_name} #{subcommand_name}' is not a #{prog_name} command.\n#{full_command_usage}"
    raise CommandNotFoundError.new(error_msg)
  end
  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`



1008
1009
1010

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

def my_help_command
  "#{prog_name} #{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_array(val, opts = {}) ⇒ `Object`

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

def parse_array(val, opts={})
  opts = {strip:true, allow_blank:false}.merge(opts)
  values = []
  if val.is_a?(Array)
    values = val
  else
    # parse csv and strip white space by default
    values = val.to_s.split(",")#.collect {|it| it.to_s.strip }
    if opts[:strip]
      values = values.collect {|it| it.to_s.strip }
    end
    if !opts[:allow_blank]
      values.reject! {|it| it.to_s.strip.empty? }
    end
  end
  values
end

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

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

def parse_bytes_param(bytes_param, option, assumed_unit = nil, allow_zero = false)
  if bytes_param && ( bytes_param.to_f > 0 || ( allow_zero && bytes_param.to_i == 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_get_options!(args, options, params) ⇒ `Object`

The default way to parse options for the get command

Parameters:

opts (OptionParser)
options (Hash)
params (Hash)



1317
1318
1319

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

def parse_get_options!(args, options, params)
  params.merge!(parse_query_options(options))
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



113
114
115

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

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_labels(val) ⇒ `Object`



1466
1467
1468

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

def parse_labels(val)
  parse_array(val, {strip:true, allow_blank:false})
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 1371

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))
  # ok, any string keys in options can become query parameters, eg. options['name'] = 'foobar'
  # do it!
  # options.each do |k, v|
  #   list_params[k] = v
  # end
  return list_params
end

#parse_list_options!(args, options, params) ⇒ `Object`

The default way to parse options for the list command

Parameters:

args (Array)
options (Hash)
params (Hash)

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

def parse_list_options!(args, options, params)
  if args.count > 0
    options[:phrase] = args.join(" ")
    # params['phrase'] =  = args.join(" ")
  end
  params.merge!(parse_list_options(options))
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 1407

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_parameter_as_resource_id!(type, options, params, param_name = nil, lookup_ids = false) ⇒ `Object`

The default way to parse options for the get command

Parameters:

type (string)
options (Hash) —

The command options
params (Hash) —

The query parameters the output is being appended to
param_name (String) (defaults to: nil)
lookup_ids (Boolean) (defaults to: false) —

Also lookup ids to make sure they exist or else error

Returns:

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

def parse_parameter_as_resource_id!(type, options, params, param_name=nil, lookup_ids=false)
  # type = type.to_s.singularize
  if options.key?(type)
    val = options[type].to_s
    param_name ||= "#{type.to_s.camelcase}Id"
    if val
      if val.to_s !~ /\A\d{1,}\Z/ || lookup_ids
        record = find_by_name(type, val)
        if record.nil?
           # avoid double error render by exiting here, ew
          exit 1
          raise_command_error "#{type.titleize} not found for '#{val}'"
        end
        params[param_name] = record['id']
      else
        params[param_name] = val
      end
      return params[param_name]
    end
  end
  return nil
end

#parse_passed_options(options, parse_opts = {}) ⇒ `Object`

this returns all the options passed in by -O, parsed all nicely into objects.

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

def parse_passed_options(options, parse_opts={})
  excludes = [parse_opts[:exclude], parse_opts[:excludes]].flatten.compact
  passed_options = options[:options] ? options[:options].reject {|k,v| k.is_a?(Symbol) || excludes.include?(k) } : {}
  return passed_options
end

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

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

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 1392

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

#prog_name ⇒ `Object`



954
955
956

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

def prog_name
  self.class.prog_name
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_args_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ `Object`

Raises:

(Morpheus::Cli::CommandArgumentsError)



104
105
106

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

def raise_args_error(msg, args=[], optparse=nil, exit_code=nil)
  raise Morpheus::Cli::CommandArgumentsError.new(msg, args, optparse, exit_code)
end

#raise_command_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ `Object`

Raises:

(Morpheus::Cli::CommandError)



100
101
102

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

def raise_command_error(msg, args=[], optparse=nil, exit_code=nil)
  raise Morpheus::Cli::CommandError.new(msg, args, optparse, exit_code)
end

#render_response(json_response, options, object_key = nil, &block) ⇒ `Object` Also known as: render_with_format

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

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

def render_response(json_response, options, object_key=nil, &block)
  output = nil
  if options[:select_fields]
    # support foos get --raw-select foo.x,foo.y,foo.z
    # and foos list --raw-select foos.x,foos.y,foos.z
    row = (object_key && !options[:raw_fields]) ? json_response[object_key] : json_response
    records = [row].flatten()
    # look for an array in the first field only now...
    field_parts = options[:select_fields][0].to_s.split(".")
    field_context = field_parts[0]
    context_data = json_response[field_context]
    if field_parts.size > 1 && context_data.is_a?(Array)
      # inject all the root level properties to be selectable too..
      context_data = json_response.delete(field_context)
      # records = context_data
      records = context_data.collect {|it| it.is_a?(Hash) ? json_response.merge(it) : json_response }
      options[:select_fields] = options[:select_fields].collect {|it| it.sub(field_context+'.', '')}
    end
    output = records.collect { |record| 
      options[:select_fields].collect { |field| 
        value = get_object_value(record, field)
        value.is_a?(String) ? value : JSON.fast_generate(value)
      }.join(options[:delim] || ",")
    }.join(options[:newline] || "\n")
  elsif options[:json]
    output = as_json(json_response, options, object_key)
  elsif options[:yaml]
    output = as_yaml(json_response, options, object_key)
  elsif options[:csv]
    output = as_csv(json_response, nil, options, object_key)
  end
  if options[:outfile]
    full_outfile = File.expand_path(options[:outfile])
    if output
      print_to_file(output, options[:outfile], options[:overwrite])
      print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes(File.size(full_outfile))})\n" unless options[:quiet]
    else
      # uhhh ok lets try this
      Morpheus::Logging::DarkPrinter.puts "using experimental feature: --out without a common format like json, yml or csv" if Morpheus::Logging.debug?
      result = with_stdout_to_file(options[:outfile], options[:overwrite], 'w+', &block)
      if result && result != 0
        return result
      end
      print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes(File.size(full_outfile))})\n" unless options[:quiet]
      return 0, nil
    end
  else
    # --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
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 1088

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`



974
975
976

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

def subcommand_aliases
  self.class.subcommand_aliases
end

#subcommand_description ⇒ `Object`

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

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

#subcommand_usage(*extra) ⇒ `Object`

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

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: #{prog_name} #{command_name} #{subcommand_name} #{extra.join(' ')}".squeeze(' ').strip
end

#subcommands ⇒ `Object`



966
967
968

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

def subcommands
  self.class.subcommands
end

#usage ⇒ `Object`

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

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

#validate_outfile(outfile, options) ⇒ `Object`

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

def validate_outfile(outfile, options)
  full_filename = File.expand_path(outfile)
  outdir = File.dirname(full_filename)
  if Dir.exist?(full_filename)
    print_red_alert "[local-file] is invalid. It is the name of an existing directory: #{outfile}"
    return false
  end
  if !Dir.exist?(outdir)
    if options[:mkdir]
      print cyan,"Creating local directory #{outdir}",reset,"\n"
      FileUtils.mkdir_p(outdir)
    else
      print_red_alert "[local-file] is invalid. Directory not found: #{outdir}"
      return false
    end
  end
  if File.exist?(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

#verify_args!(opts = {}) ⇒ `Object`

verify_args! verifies that the right number of commands were passed and raises a command error if not. Example: verify_args!(args:args, count:1, optparse:optparse) this could go be done in optparse.parse instead perhaps

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

def verify_args!(opts={})
  args = opts[:args] || []
  count = opts[:count]
  # simplify output for verify_args!(min:2, max:2) or verify_args!(max:0)
  if opts[:min] && opts[:max] && opts[:min] == opts[:max]
    count = opts[:min]
  elsif opts[:max] == 0
    count = 0
  end
  if count
    if args.count < count
      raise_args_error("not enough arguments, expected #{count} and got #{args.count == 0 ? '0' : args.count.to_s + ': '}#{args.join(', ')}", args, opts[:optparse])
    elsif args.count > count
      raise_args_error("too many arguments, expected #{count} and got #{args.count == 0 ? '0' : args.count.to_s + ': '}#{args.join(', ')}", args, opts[:optparse])
    end
  else
    if opts[:min]
      if args.count < opts[:min]
        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]
      if args.count > opts[:max]
        raise_args_error("too many 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
  end
  true
end

#visible_subcommands ⇒ `Object`



970
971
972

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

def visible_subcommands
  self.class.visible_subcommands
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(base) ⇒ Object

Instance Method Details

#add_query_parameter(params, key, value) ⇒ Object

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

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

#build_get_options(opts, options, params) ⇒ Object

#build_list_options(opts, options, params) ⇒ Object

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

#build_payload(options, object_key = nil) ⇒ Object

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

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

#build_standard_delete_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_post_options(opts, options, includes = [], excludes = []) ⇒ Object

#build_standard_put_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_description ⇒ Object

#command_name ⇒ Object

#confirm(msg, options) ⇒ Object

#confirm!(msg, options) ⇒ Object

#default_refresh_interval ⇒ Object

#default_sigdig ⇒ Object

#default_subcommand ⇒ Object

#establish_remote_appliance_connection(options) ⇒ Object

#find_all(*args) ⇒ Object Also known as: find_all_records

#find_all_json(*args) ⇒ Object Also known as: find_all_records_json

#find_by_id(*args) ⇒ Object

#find_by_name(*args) ⇒ Object

#find_by_name_or_id(*args) ⇒ Object

#find_record(*args) ⇒ Hash

#find_record_json(*args) ⇒ Object

#full_command_usage ⇒ Object

#get_interface(type) ⇒ Object

#get_list_key(type) ⇒ Object

#get_object_key(type) ⇒ Object

#get_subcommand_description(subcmd) ⇒ Object

#handle(args) ⇒ Object

#handle_subcommand(args) ⇒ Object

#interactive? ⇒ Boolean

#my_help_command ⇒ Object

#my_terminal ⇒ Morpheus::Terminal

#my_terminal=(term) ⇒ Object

#parse_array(val, opts = {}) ⇒ Object

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

#parse_get_options!(args, options, params) ⇒ Object

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

#parse_labels(val) ⇒ Object

#parse_list_options(options = {}) ⇒ Object

#parse_list_options!(args, options, params) ⇒ Object

#parse_list_subtitles(options = {}) ⇒ Object

#parse_parameter_as_resource_id!(type, options, params, param_name = nil, lookup_ids = false) ⇒ Object

#parse_passed_options(options, parse_opts = {}) ⇒ Object

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

#parse_query_options(options = {}) ⇒ Object

#print(*msgs) ⇒ Object

#print_error(*msgs) ⇒ Object

#println(*msgs) ⇒ Object

#prog_name ⇒ Object

#puts(*msgs) ⇒ Object

#puts_error(*msgs) ⇒ Object

#raise_args_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ Object

#raise_command_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ Object

#render_response(json_response, options, object_key = nil, &block) ⇒ Object Also known as: render_with_format

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

#subcommand_aliases ⇒ Object

#subcommand_description ⇒ Object

#subcommand_usage(*extra) ⇒ Object

#subcommands ⇒ Object

#usage ⇒ Object

#no_prompt ⇒ `Object` (readonly)

.included(base) ⇒ `Object`

#add_query_parameter(params, key, value) ⇒ `Object`

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

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

#build_get_options(opts, options, params) ⇒ `Object`

#build_list_options(opts, options, params) ⇒ `Object`

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

#build_payload(options, object_key = nil) ⇒ `Object`

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

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

#build_standard_delete_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_post_options(opts, options, includes = [], excludes = []) ⇒ `Object`

#build_standard_put_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_description ⇒ `Object`

#command_name ⇒ `Object`

#confirm(msg, options) ⇒ `Object`

#confirm!(msg, options) ⇒ `Object`

#default_refresh_interval ⇒ `Object`

#default_sigdig ⇒ `Object`

#default_subcommand ⇒ `Object`

#establish_remote_appliance_connection(options) ⇒ `Object`

#find_all(*args) ⇒ `Object` Also known as: find_all_records

#find_all_json(*args) ⇒ `Object` Also known as: find_all_records_json

#find_by_id(*args) ⇒ `Object`

#find_by_name(*args) ⇒ `Object`

#find_by_name_or_id(*args) ⇒ `Object`

#find_record(*args) ⇒ `Hash`

#find_record_json(*args) ⇒ `Object`

#full_command_usage ⇒ `Object`

#get_interface(type) ⇒ `Object`

#get_list_key(type) ⇒ `Object`

#get_object_key(type) ⇒ `Object`

#get_subcommand_description(subcmd) ⇒ `Object`

#handle(args) ⇒ `Object`

#handle_subcommand(args) ⇒ `Object`

#interactive? ⇒ `Boolean`

#my_help_command ⇒ `Object`

#my_terminal ⇒ `Morpheus::Terminal`

#my_terminal=(term) ⇒ `Object`

#parse_array(val, opts = {}) ⇒ `Object`

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

#parse_get_options!(args, options, params) ⇒ `Object`

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

#parse_labels(val) ⇒ `Object`

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

#parse_list_options!(args, options, params) ⇒ `Object`

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

#parse_parameter_as_resource_id!(type, options, params, param_name = nil, lookup_ids = false) ⇒ `Object`

#parse_passed_options(options, parse_opts = {}) ⇒ `Object`

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

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

#print(*msgs) ⇒ `Object`

#print_error(*msgs) ⇒ `Object`

#println(*msgs) ⇒ `Object`

#prog_name ⇒ `Object`

#puts(*msgs) ⇒ `Object`

#puts_error(*msgs) ⇒ `Object`

#raise_args_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ `Object`

#raise_command_error(msg, args = [], optparse = nil, exit_code = nil) ⇒ `Object`

#render_response(json_response, options, object_key = nil, &block) ⇒ `Object` Also known as: render_with_format

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

#subcommand_aliases ⇒ `Object`

#subcommand_description ⇒ `Object`

#subcommand_usage(*extra) ⇒ `Object`

#subcommands ⇒ `Object`

#usage ⇒ `Object`

#validate_outfile(outfile, options) ⇒ `Object`

#verify_args!(opts = {}) ⇒ `Object`

#visible_subcommands ⇒ `Object`