morpheus-cli 5.5.3 → 5.5.3.2

data/lib/morpheus/cli/commands/monitoring_settings.rb

@@ -0,0 +1,228 @@
+require 'morpheus/cli/cli_command'
+
+class Morpheus::Cli::MonitoringSettings
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::AccountsHelper
+
+  set_command_name :'monitor-settings'
+  set_command_description "View and manage monitoring settings"
+  register_subcommands :get, :update
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @monitoring_settings_interface = @api_client.monitoring_settings
+    @options_interface = @api_client.options
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "Get monitoring settings."
+    end
+    optparse.parse!(args)
+    connect(options)
+    verify_args!(args:args, optparse:optparse, count:0)
+    params.merge!(parse_query_options(options))
+    @monitoring_settings_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @monitoring_settings_interface.dry.get(options)
+      return
+    end
+    json_response = @monitoring_settings_interface.get(options)
+    render_response(json_response, options, 'monitoringSettings') do
+      monitoring_settings = json_response['monitoringSettings']
+      service_now_settings = monitoring_settings['serviceNow']
+      new_relic_settings = monitoring_settings['newRelic']
+      print_h1 "Monitoring Settings"
+      print cyan
+      description_cols = {
+        "Auto Create Checks" => lambda {|it| format_boolean(it['autoManageChecks']) },
+        "Availability Time Frame" => lambda {|it| it['availabilityTimeFrame'] ? it['availabilityTimeFrame'].to_s + ' days' : '' },
+        "Availability Precision" => lambda {|it| it['availabilityPrecision'] ? it['availabilityPrecision'].to_s : '' },
+        "Default Check Interval" => lambda {|it| it['defaultCheckInterval'] ? it['defaultCheckInterval'].to_s + ' minutes' : '' },
+      }
+      print_description_list(description_cols, monitoring_settings, options)
+      
+        print_h2 "ServiceNow Settings", options.merge(:border_style => :thin)
+        description_cols = {
+          "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+          "Integration" => lambda {|it| it['integration'] ? it['integration']['name'] : '' },
+          "New Incident Action" => lambda {|it| format_service_now_action(it['newIncidentAction']) },
+          "Close Incident Action" => lambda {|it| format_service_now_action(it['closeIncidentAction']) },
+          "Info Mapping" => lambda {|it| format_service_now_mapping(it['infoMapping']) },
+          "Warning Mapping" => lambda {|it| format_service_now_mapping(it['warningMapping']) },
+          "Critical Mapping" => lambda {|it| format_service_now_mapping(it['criticalMapping']) },
+        }
+        print_description_list(description_cols, service_now_settings)
+
+        print_h2 "New Relic Settings", options.merge(:border_style => :thin)
+        description_cols = {
+          "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+          "License Key" => lambda {|it| it['licenseKey'] },
+        }
+        print_description_list(description_cols, new_relic_settings, options)
+      
+      print reset, "\n"
+    end
+    return 0, nil
+  end
+
+  def update(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = opts.banner = subcommand_usage()
+      opts.on('--auto-create-checks [on|off]', String, "Auto Create Checks") do |val|
+        params['autoManageChecks'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
+      end
+      opts.on("--availability-time-frame DAYS", Integer, "Availability Time Frame. The number of days availability should be calculated for. Changes will not take effect until your checks have passed their check interval.") do |val|
+        params['availabilityTimeFrame'] = val.to_i
+      end
+      opts.on("--availability-precision DIGITS", Integer, "Availability Precision. The number of decimal places availability should be displayed in. Can be anywhere between 0 and 5.") do |val|
+        params['availabilityPrecision'] = val.to_i
+      end
+      opts.on("--default-check-interval MINUTES", Integer, "Default Check Interval. The default interval to use when creating new checks. Value is in minutes.") do |val|
+        params['defaultCheckInterval'] = val.to_i
+      end
+      opts.on('--service-now-enabled [on|off]', String, "ServiceNow: Enabled (on) or disabled (off)") do |val|
+        params['serviceNow'] ||= {}
+        params['serviceNow']['enabled'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
+      end
+      opts.on('--service-now-integration ID', String, "ServiceNow: Integration ID or Name") do |val|
+        params['serviceNow'] ||= {}
+        params['serviceNow']['integration'] = val # {'id' => val.to_i}
+      end
+      opts.on("--service-now-new-incident-action create|none", String, "ServiceNow: New Incident Action") do |val|
+        # allowed_values = 'create|none'.split('|') #get_service_now_actions().keys
+        # if !allowed_values.include?(val)
+        #   raise ::OptionParser::InvalidOption.new("New Incident Action value '#{val}' is invalid.\nThe allowed values are: #{allowed_values.join(', ')}")
+        # end
+        params['serviceNow'] ||= {}
+        params['serviceNow']['newIncidentAction'] = val
+      end
+      opts.on("--service-now-close-incident-action close|activity|none", String, "ServiceNow: Close Incident Action") do |val|
+        # allowed_values = 'close|activity|none'.split('|') #get_service_now_mappings().keys
+        # if !allowed_values.include?(val)
+        #   raise ::OptionParser::InvalidOption.new("Close Incident Action value '#{val}' is invalid.\nThe allowed values are: #{allowed_values.join(', ')}")
+        # end
+        params['serviceNow'] ||= {}
+        params['serviceNow']['closeIncidentAction'] = val
+      end
+      opts.on("--service-now-info-mapping low|medium|high", String, "ServiceNow: Info Mapping") do |val|
+        # allowed_values = 'low|medium|high'.split('|') # get_service_now_mappings().keys
+        # if !allowed_values.include?(val)
+        #   raise ::OptionParser::InvalidOption.new("Info Mapping value '#{val}' is invalid.\nThe allowed values are: #{allowed_values.join(', ')}")
+        # end
+        params['serviceNow'] ||= {}
+        params['serviceNow']['infoMapping'] = val
+      end
+      opts.on("--service-now-warning-mapping low|medium|high", String, "ServiceNow: Warning Mapping") do |val|
+        # allowed_values = 'low|medium|high'.split('|') # get_service_now_mappings().keys
+        # if !allowed_values.include?(val)
+        #   raise ::OptionParser::InvalidOption.new("Warning Info Mapping value '#{val}' is invalid.\nThe allowed values are: #{allowed_values.join(', ')}")
+        # end
+        params['serviceNow'] ||= {}
+        params['serviceNow']['warningMapping'] = val
+      end
+      opts.on("--service-now-critical-mapping low|medium|high", String, "ServiceNow: Critical Mapping") do |val|
+        # allowed_values = 'low|medium|high'.split('|') # get_service_now_mappings().keys
+        # if !allowed_values.include?(val)
+        #   raise ::OptionParser::InvalidOption.new("Critical Info Mapping value '#{val}' is invalid.\nThe allowed values are: #{allowed_values.join(', ')}")
+        # end
+        params['serviceNow'] ||= {}
+        params['serviceNow']['criticalMapping'] = val
+      end
+      opts.on('--new-relic-enabled [on|off]', String, "New Relic: Enabled (on) or disabled (off)") do |val|
+        params['newRelic'] ||= {}
+        params['newRelic']['enabled'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
+      end
+      opts.on("--new-relic-license-key [VALUE]", String, "New Relic: License Key") do |val|
+        params['newRelic'] ||= {}
+        params['newRelic']['licenseKey'] = val
+      end
+      build_standard_update_options(opts, options)
+      opts.footer = "Update monitoring settings."
+    end
+    optparse.parse!(args)
+    connect(options)
+    verify_args!(args:args, optparse:optparse, count:0)
+    payload = parse_payload(options)
+    if !payload
+      payload = {}
+      payload.deep_merge!({object_key => parse_passed_options(options)}) # inject options passed with -O foo=bar
+      if params['serviceNow'] && params['serviceNow']['integration']
+        integration = find_by_name_or_id(:integration, params['serviceNow']['integration'])
+        if integration.nil?
+          exit 1 #return 1, "Integration not found by '#{options[:servicenow_integration]}'"
+        else
+          if integration['integrationType']['code'] != 'serviceNow'
+            raise_command_error "Integration '#{integration['id']}' must be a Service Now integration"
+          end
+          params['serviceNow'] ||= {}
+          params['serviceNow']['integration'] = {'id' => integration['id'].to_i}
+        end
+      end
+      payload.deep_merge!({object_key => params})
+    end
+    if payload[object_key].empty?
+      raise_command_error "Specify at least one option to update.\n#{optparse}"
+    end
+    @monitoring_settings_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @monitoring_settings_interface.dry.update(payload)
+      return
+    end
+    json_response = @monitoring_settings_interface.update(payload)
+    exit_code, err = 0, nil
+    render_response(json_response, options, object_key) do
+      if json_response['success']
+        print_green_success "Updated monitoring settings"
+        get([] + (options[:remote] ? ["-r",options[:remote]] : []))
+      else
+        exit_code, err = 1, "Error updating monitoring settings: #{json_response['msg'] || json_response['errors']}"
+        print_rest_errors(json_response)
+      end
+    end
+    return exit_code, err
+  end
+
+  private
+
+  def get_service_now_actions()
+    {
+      'create' => 'Create new incident in ServiceNow',
+      'close' => 'Resolve Incident in ServiceNow',
+      'activity' => 'Add Activity to Incident in ServiceNow',
+      'none' => 'No action',
+    }
+  end
+
+  def format_service_now_action(action_value)
+    get_service_now_actions()[action_value].to_s
+  end
+
+  def get_service_now_mappings()
+    {
+      'low' => 'Low',
+      'medium' => 'Medium',
+      'high' => 'High',
+    }
+  end
+
+  def format_service_now_mapping(mapping_value)
+    get_service_now_mappings()[mapping_value].to_s
+  end
+
+
+  def object_key
+    'monitoringSettings'
+  end
+
+end

data/lib/morpheus/cli/commands/network_server_groups_command.rb

@@ -0,0 +1,222 @@
+require 'morpheus/cli/cli_command'
+
+class Morpheus::Cli::NetworkServerGroups
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::WhoamiHelper
+  include Morpheus::Cli::RestCommand
+  include Morpheus::Cli::SecondaryRestCommand
+  include Morpheus::Cli::ProvisioningHelper
+
+  set_command_description "View and manage network server groups."
+  set_command_name :'network-server-groups'
+  register_subcommands :list, :get, :add, :update, :remove
+  register_interfaces :network_servers, :network_server_groups, :accounts
+  set_rest_perms_config({enabled:true, excludes:['groups', 'plans', 'visibility', 'resource'], context: 'permissions'})
+
+  protected
+
+  NSXT_CRITERIA_TYPES = ['Condition', 'NestedExpression'] unless defined? NSXT_CRITERIA_TYPES
+  NSXT_MEMBER_TYPES = ['Path', 'ExternalID'] unless defined? NSXT_MEMBER_TYPES
+  NSXT_IP_TYPES = ['IPAddress', 'MACAddress'] unless defined? NSXT_IP_TYPES
+  NSXT_AD_GROUP_TYPES = ['IdentityGroup'] unless defined? NSXT_AD_GROUP_TYPES
+
+  def network_server_group_list_key
+    'groups'
+  end
+
+  def network_server_group_object_key
+    'group'
+  end
+
+  def network_server_group_field_context
+    network_server_group_object_key
+  end
+
+  def load_option_types_for_network_server_group(record_type, parent_record)
+    parent_record['type']['groupOptionTypes']
+  end
+
+  def network_server_group_list_column_definitions(options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      members_lambda = lambda do |group|
+        members = []
+        {
+          'Criteria' => NSXT_CRITERIA_TYPES,
+          'Members' => NSXT_MEMBER_TYPES,
+          'IPS / MACS' => NSXT_IP_TYPES,
+          'AD Groups' => NSXT_AD_GROUP_TYPES
+        }.each do |label, types|
+          if (count = group['members'].select{|member| types.include?(member['type'])}.count) > 0
+            members << "#{count} #{label}"
+          end
+        end
+        members.join(', ')
+      end
+    else
+      members_lambda = lambda do |group|
+        group['members'].collect{|member| member['type']}.join(', ')
+      end
+    end
+
+    columns = {
+      'ID' => 'id',
+      'Name' => 'name',
+      'Description' => {:label => 'Description', :max_width => 50, :display_method => lambda {|group| group['description']}},
+      'Members' => members_lambda
+    }
+
+    if is_master_account
+      columns['Visibility'] = lambda {|it| it['visibility'].capitalize}
+      columns['Tenants'] = lambda do |it|
+        tenants = []
+        if it['permissions'] and it['permissions']['tenantPermissions']
+          tenants = @accounts_interface.list({:ids => it['permissions']['tenantPermissions']['accounts']})['accounts'].collect{|account| account['name']}
+        end
+        tenants.join(', ')
+      end
+    end
+    columns
+  end
+
+  def network_server_group_column_definitions(options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      tags_lambda = lambda{|group|
+        (group['tags'] || []).collect{|tag|
+          "#{tag['name']}#{(tag['value'] || '').length > 0 ? " (scope: #{tag['value']})" : ''}"
+        }.join(', ')
+      }
+    else
+      tags_lambda = lambda {|group| group['tags'] ? format_metadata(group['tags']) : '' }
+    end
+    columns = {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Description" => 'description',
+      "Tags" => tags_lambda
+    }
+    columns
+  end
+
+  def network_server_group_add_prompt(record_payload, record_type, parent_record, options)
+    unless parent_record['type']['code'] != 'nsx-t' or options[:no_prompt]
+      nsxt_add_prompt(record_payload, record_type, parent_record, options)
+    end
+  end
+
+  def nsxt_add_prompt(record_payload, record_type, parent_record, options)
+    # criteria
+    criteria = []
+    while criteria.count < 5 && Morpheus::Cli::OptionTypes.confirm("Add#{criteria.count == 0 ? '': ' another'} criteria?", {:default => false})
+      if true #members.count == 0 or members.last['memberValue'] == 'OR' # Can't have nested follow AND conjunction
+        type = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => 'Criteria Type', 'type' => 'select', 'selectOptions' => ['Condition', 'Nested Expression'].map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'Condition'}], options[:options])['type']
+      end
+      prompt_condition = lambda do
+        compare_type = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memberType', 'fieldLabel' => 'Criteria Item', 'type' => 'select', 'selectOptions' => ['Virtual Machine', 'Segment Port', 'Segment', 'IP Set'].map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'VirtualMachine'}], options[:options])['memberType']
+        compare_key = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'key', 'fieldLabel' => "#{compare_type} Field", 'type' => 'select', 'selectOptions' => (compare_type == 'VirtualMachine' ? ['Name', 'Tag', 'OS Name', 'Computer Name'] : ['Tag'] ).map{|it| {'name' => it, 'value' => it.sub(' ', '')}}, 'required' => true, 'defaultValue' => 'Tag'}], options[:options])['key']
+        compare_operator = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'operator', 'fieldLabel' => "#{compare_key} Operator", 'type' => 'select', 'selectOptions' => (compare_type == 'VirtualMachine' ? ['Equals', 'Contains', 'Starts With', 'Ends With'] : ['Equals']).map{|it| {'name' => it, 'value' => it.sub(' ', '').upcase}}, 'required' => true, 'defaultValue' => 'EQUALS'}], options[:options])['operator']
+        compare_value = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'value', 'type' => 'text', 'fieldLabel' => "#{compare_key} Value", 'required' => true, 'description' => 'Value to compare.'}], options[:options])['value']
+        compare_scope = nil
+        if compare_key == 'Tag'
+          compare_scope = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'scope', 'type' => 'text', 'fieldLabel' => "#{compare_key} Scope", 'required' => false}], options[:options], @api_client, {}, false, true)['scope']
+        end
+        compare_expr = {key: compare_key, operator: compare_operator, value: compare_value}
+        compare_expr.merge!({scope: compare_scope}) if compare_scope
+        {'type' => 'Condition', 'memberType' => compare_type, 'memberExpression' => JSON.generate(compare_expr)}
+      end
+
+      if criteria.count > 0
+        criteria.last['memberValue'] = 'OR'
+      end
+
+      if type == 'Condition'
+        prev_criteria = criteria.count > 0 ? criteria.last : nil
+        criteria << prompt_condition.call
+        if prev_criteria and prev_criteria['type'] != 'NestedExpression' and prev_criteria['memberType'] == criteria.last['memberType']
+          prev_criteria['memberValue'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memberValue', 'fieldLabel' => 'And/Or', 'type' => 'select', 'selectOptions' => ['and', 'or'].map{|it| {'name' => it, 'value' => it.upcase}}, 'required' => true, 'defaultValue' => 'AND', 'description' => 'Conjunction to use between this condition and the previous condition'}], options[:options])['memberValue']
+        end
+      else
+        # just prompt for conditions w/
+        nested_members = [prompt_condition.call]
+        while nested_members.count < 5 && Morpheus::Cli::OptionTypes.confirm("Add another criteria to nested expression?", {:default => false})
+          nested_members.last['memberValue'] = 'AND'
+          nested_members << prompt_condition.call
+        end
+        criteria << {'type' => type, 'members' => nested_members}
+      end
+    end
+
+    members = []
+    while members.count < 500 && Morpheus::Cli::OptionTypes.confirm("Add#{members.count == 0 ? '': ' another'} member?", {:default => false})
+      member_type = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memberType', 'fieldLabel' => 'Member Type', 'type' => 'select', 'selectOptions' => ['Group', 'Segment', 'Segment Port', 'Virtual Network Interface', 'Virtual Machine', 'Physical Server'].map{|it| {'name' => it, 'value' => it.gsub(' ', '')}}, 'required' => true, 'defaultValue' => 'Group'}], options[:options])['memberType']
+      member_value = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memberValue', 'fieldLabel' => member_type, 'type' => 'select', 'optionSource' => 'nsxtGroupMembers', 'optionSourceType' => 'nsxt', 'required' => true}], options[:options], @api_client, {networkServerId: parent_record['id'], memberType: member_type}, false, true)['memberValue']
+      type = ['Group', 'Segment', 'SegmentPort'].include?(member_type) ? 'Path' : 'ExternalID'
+      members << {'type' => type, 'memberType' => member_type, 'memberValue' => member_value}
+    end
+
+    # ip/mac
+    ips = []
+    while members.count + ips.count < 500 && Morpheus::Cli::OptionTypes.confirm("Add#{ips.count == 0 ? '': ' another'} IP/MAC address?", {:default => false})
+      member_value = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'ipAddress', 'type' => 'text', 'fieldLabel' => "IP/MAC Address", 'required' => true, 'description' => 'Enter an IP or MAC address. x.x.x.x'}], options[:options])['ipAddress']
+      type = member_value.match(/[a-fA-F0-9]{2}(:[a-fA-F0-9]{2}){5}/) ? 'MACAddress' : 'IPAddress'
+      ips << {'type' => type, 'memberValue' => member_value}
+    end
+
+    # ad groups
+    ad_groups = []
+    while members.count + ips.count + ad_groups.count < 500 && Morpheus::Cli::OptionTypes.confirm("Add#{ad_groups.count == 0 ? '': ' another'} AD Group?", {:default => false})
+      member_value = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'identityGroup', 'type' => 'select', 'optionSource' => 'nsxtIdentityGroups', 'optionSourceType' => 'nsxt', 'required' => true, 'fieldLabel' => "AD Group"}], options[:options], @api_client, {networkServerId: parent_record['id'], memberType: member_type}, false, true)['identityGroup']
+      ad_groups << {'type' => 'IdentityGroup', 'memberValue' => member_value}
+    end
+
+    record_payload['members'] = criteria + members + ips + ad_groups
+    record_payload
+  end
+
+  def render_response_details_for_get(record, options)
+    if options[:parent_record]['type']['code'] == 'nsx-t'
+      members = record['members'].select{|member| NSXT_CRITERIA_TYPES.include?(member['type'])}
+      if members.count > 0
+        cond_criteria = lambda do |member|
+          expr = JSON.parse(member['memberExpression'])
+          "#{member['memberType']} #{expr['key']} #{expr['operator']} #{expr['value']}#{expr['scope'].nil? ? '' : " w/ #{expr['scope']} scope"}"
+        end
+        criteria_parts = []
+        members.each_with_index do |member, index|
+          if member['type'] == 'NestedExpression'
+            criteria_parts << "("
+            member['members'].each do |child_member|
+              criteria_parts << "  #{cond_criteria.call(child_member)}"
+              criteria_parts << "  #{child_member['memberValue']}"
+            end
+            criteria_parts.pop # remove last conjunction
+            criteria_parts << ")"
+          else
+            criteria_parts << cond_criteria.call(member)
+            criteria_parts << member['memberValue']
+          end
+        end
+        criteria_parts.pop if ['AND', 'OR'].include?(criteria_parts.last) # remove last conjunction
+        print_h2 "Criteria (#{members.count})", options
+        print "#{cyan}#{criteria_parts.join("\n")}\n"
+      end
+
+      members = record['members'].select{|member| NSXT_MEMBER_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "Members (#{members.count})", options
+        print as_pretty_table(members, {'Type' => 'memberType', 'Path/ExternalID' => 'memberValue'}, options)
+      end
+
+      members = record['members'].select{|member| NSXT_IP_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "IP/MAC Addresses (#{members.count})", options
+        print "#{cyan}#{members.collect{|member| "#{member['memberValue']}"}.join("\n")}\n"
+      end
+
+      members = record['members'].select{|member| NSXT_AD_GROUP_TYPES.include?(member['type'])}
+      if members.count > 0
+        print_h2 "AD Groups (#{members.count})", options
+        print "#{cyan}#{members.collect{|member| "#{member['memberValue']}"}.join("\n")}\n"
+      end
+    end
+  end
+end

data/lib/morpheus/cli/commands/provisioning_settings_command.rb

@@ -83,7 +83,7 @@ class Morpheus::Cli::ProvisioningSettingsCommand
         "Default Blueprint Type" => lambda {|it| it['defaultTemplateType'] ? it['defaultTemplateType']['name'].capitalize : 'Morpheus'}
       }
       print_description_list(description_cols, settings)
-      print reset "\n"
+      print reset, "\n"
       return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)

data/lib/morpheus/cli/commands/reports_command.rb

@@ -303,6 +303,16 @@ class Morpheus::Cli::ReportsCommand
 
       end
 
+      if payload['report']['startMonth'].size > 7 || payload['report']['endMonth'].size > 7
+         print_green_success "The CLI generates a query that will use only month and year. However, the API does support yyyy-mm-dd from a previous version of Morpheus.\nReplace startMonth/endMonth keys with startDate,endDate ie:"
+         payload['report'].delete('startMonth')
+         payload['report'].delete('endMonth')
+         payload['report']['startDate'] = 'yyyy-mm-dd'
+         payload['report']['endDate'] = 'yyyy-mm-dd'
+         print_dry_run @reports_interface.dry.create(payload)
+      return 0
+      end
+
       @reports_interface.setopts(options)
       if options[:dry_run]
         print_dry_run @reports_interface.dry.create(payload)

data/lib/morpheus/cli/commands/service_catalog_command.rb

@@ -661,7 +661,8 @@ EOT
         it
       }
       if catalog_option_types && !catalog_option_types.empty?
-        config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, {})['config']
+        api_params = construct_catalog_api_params(catalog_item_type)
+        config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
         payload[add_item_object_key].deep_merge!({'config' => config_prompt})
       end
       if workflow_context
@@ -999,11 +1000,13 @@ EOT
         catalog_option_types = catalog_item_type['optionTypes']
         # instead of config.customOptions just use config...
         catalog_option_types = catalog_option_types.collect {|it|
+          it['fieldContext'] = nil
           it['fieldContext'] = 'config'
           it
         }
         if catalog_option_types && !catalog_option_types.empty?
-          config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, {})['config']
+          api_params = construct_catalog_api_params(catalog_item_type)
+          config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
           item_payload.deep_merge!({'config' => config_prompt})
         end
         
@@ -1471,4 +1474,35 @@ EOT
     out + return_color
   end
 
+  
+  def construct_catalog_api_params(record)
+    catalog_item_type_id = record['id'].to_i
+    api_params = {}
+    api_params['catalogItemType'] ||= {}
+    api_params['catalogItemType']['id'] = catalog_item_type_id
+    # Determine instance.type value
+    # the UI is injecting this parameter into the option source requests
+    # it is needed to populate api option lists eg. optionTypeClouds
+    # this should be fixed on the api side, so it automatically extracts this input from the config
+    begin
+      instance_type_code = nil
+      catalog_item_type = find_by_id(:catalog_item_type, catalog_item_type_id.to_i)
+      if catalog_item_type
+        if catalog_item_type['type'] == 'instance'
+          if catalog_item_type['config'] && catalog_item_type['config']['type']
+            instance_type_code = catalog_item_type['config']['type']
+          end
+        end
+      end
+      if instance_type_code
+        api_params['instance'] ||= {}
+        api_params['instance']['type'] = instance_type_code
+      end
+    rescue ::RestClient::Exception => e
+      # users may not have permission to this endpoint
+      # puts "Failed to load catalog item type"
+    end
+    return api_params
+  end
+
 end

data/lib/morpheus/cli/commands/whitelabel_settings_command.rb

@@ -137,7 +137,7 @@ class Morpheus::Cli::WhitelabelSettingsCommand
         print cyan
         print options[:details] ? content : truncate_string(content, trunc_len), "\n"
       end
-      print reset "\n"
+      print reset, "\n"
       return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)

data/lib/morpheus/cli/credentials.rb

@@ -123,7 +123,8 @@ module Morpheus
               end
               if password.empty?
                 # readline is still echoing secret with 'NUL:'' so just use $stdin on windows for now
-                if Morpheus::Cli.windows?
+                # and some other environments? just use noecho unless running unit tests
+                if Morpheus::Cli.windows? || !Morpheus::Cli.testing?
                   print "Password: #{required_blue_prompt} "
                   # this should be my_terminal.stdin instead of STDIN and $stdin
                   password = $stdin.noecho(&:gets).chomp!

data/lib/morpheus/cli/mixins/provisioning_helper.rb

@@ -1435,7 +1435,7 @@ module Morpheus::Cli::ProvisioningHelper
               'id' => current_volume['id'].to_i,
               'rootVolume' => false,
               'name' => current_volume['name'],
-              'size' => current_volume['size'] > (plan_size || 0) ? current_volume['size'] : plan_size,
+              'size' => current_volume['size'] ? current_volume['size'] : (plan_size || 0),
               'sizeId' => nil,
               'storageType' => (current_volume['type'] || current_volume['storageType']),
               'datastoreId' => current_volume['datastoreId']
@@ -2003,9 +2003,10 @@ module Morpheus::Cli::ProvisioningHelper
     group_access = nil
     all_plans = nil
     plan_access = nil
+    permissions = {}
 
     # Group Access
-    if !excludes.include?('groups')
+    unless excludes.include?('groups')
       if !options[:groupAccessAll].nil?
         all_groups = options[:groupAccessAll]
       end
@@ -2055,7 +2056,7 @@ module Morpheus::Cli::ProvisioningHelper
     end
 
     # Plan Access
-    if !excludes.include?('plans')
+    unless excludes.include?('plans')
       if !options[:planAccessAll].nil?
         all_plans = options[:planAccessAll]
       end
@@ -2101,13 +2102,14 @@ module Morpheus::Cli::ProvisioningHelper
       end
     end
 
-    resource_perms = {}
-    resource_perms['all'] = all_groups if !all_groups.nil?
-    resource_perms['sites'] = group_access if !group_access.nil?
-    resource_perms['allPlans'] = all_plans if !all_plans.nil?
-    resource_perms['plans'] = plan_access if !plan_access.nil?
-
-    permissions = {'resourcePermissions' => resource_perms}
+    unless excludes.include?('resource')
+      resource_perms = {}
+      resource_perms['all'] = all_groups if !all_groups.nil?
+      resource_perms['sites'] = group_access if !group_access.nil?
+      resource_perms['allPlans'] = all_plans if !all_plans.nil?
+      resource_perms['plans'] = plan_access if !plan_access.nil?
+      permissions['resourcePermissions'] = resource_perms
+    end
 
     available_accounts = get_available_accounts() #.collect {|it| {'name' => it['name'], 'value' => it['id']}}
     accounts = []
@@ -2115,7 +2117,7 @@ module Morpheus::Cli::ProvisioningHelper
     # Prompts for multi tenant
     if available_accounts.count > 1
       visibility = options[:visibility]
-      if !excludes.include?('visibility')
+      unless excludes.include?('visibility')
         if !visibility && !options[:no_prompt]
           visibility = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'visibility', 'fieldLabel' => 'Tenant Permissions Visibility', 'type' => 'select', 'defaultValue' => 'private', 'required' => true, 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}]}], options[:options], @api_client, {})['visibility']
         end
@@ -2123,7 +2125,7 @@ module Morpheus::Cli::ProvisioningHelper
       end
 
       # Tenants
-      if !excludes.include?('tenants')
+      unless excludes.include?('tenants')
         if !options[:tenants].nil?
           accounts = options[:tenants].collect {|id| id.to_i}
         elsif !options[:no_prompt]

data/lib/morpheus/cli/mixins/rest_command.rb

@@ -720,9 +720,13 @@ EOT
         else
           perms = prompt_permissions(options.deep_merge(rest_perms_config[:options] || {}), rest_perms_config[:excludes] || [])
         end
-        if !rest_perms_config[:name].nil?
+        unless rest_perms_config[:name].nil?
           perms.transform_keys! {|k| k == 'resourcePermissions' ? rest_perms_config[:name] : k}
         end
+        unless rest_perms_config[:context].nil?
+          perms_context = {}
+          perms_context[rest_perms_config[:context]] = perms
+        end
         record_payload.merge!(perms)
       end
       payload[rest_object_key] = record_payload