morpheus-cli 4.1.8 → 4.1.9

data/lib/morpheus/cli/library_option_types_command.rb

@@ -120,8 +120,8 @@ class Morpheus::Cli::LibraryOptionTypesCommand
         return
       end
       option_type = find_option_type_by_name_or_id(id)
-      exit 1 if option_type.nil?
-
+      return 1 if option_type.nil?
+      json_response = {'optionType' => option_type}
       if options[:json]
         puts as_json(json_response, options, "optionType")
         return 0

data/lib/morpheus/cli/log_settings_command.rb

@@ -5,9 +5,9 @@ class Morpheus::Cli::LogSettingsCommand
   include Morpheus::Cli::AccountsHelper
 
   set_command_name :'log-settings'
-  set_command_hidden
+
   register_subcommands :get, :update
-  register_subcommands :enable_integration, :disable_integration
+  register_subcommands :enable_integration, :disable_integration, :remove_integration
   register_subcommands :add_syslog_rule, :remove_syslog_rule
   
   set_default_subcommand :get
@@ -92,7 +92,7 @@ class Morpheus::Cli::LogSettingsCommand
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = opts.banner = subcommand_usage()
       opts.on("--enabled [on|off]", ['on','off'], "Logs enabled") do |val|
-        params['enabled'] = ['true','on'].include?(val.to_s.strip)
+        params['enabled'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
       end
       opts.on("-R", "--retention NUMBER", Integer, "Availability time frame in days") do |val|
         params['retentionDays'] = val.to_i
@@ -284,6 +284,49 @@ class Morpheus::Cli::LogSettingsCommand
     end
   end
 
+  def remove_integration(args)
+    options = {}
+
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = opts.banner = subcommand_usage("[name]")
+      build_common_options(opts, options, [:json, :dry_run, :quiet, :remote])
+      opts.footer = "Deletes specifed integration.\n" +
+          "[name] is required. Currently supports splunk and logrhythm integrations."
+    end
+
+    optparse.parse!(args)
+    connect(options)
+    if args.count != 1
+      raise_command_error "wrong number of arguments, expected 1 and got (#{args.count}) #{args}\n#{optparse}"
+      return 1
+    end
+
+    begin
+      @log_settings_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @log_settings_interface.dry.destroy_integration(args[0])
+        return
+      end
+      json_response = @log_settings_interface.destroy_integration(args[0])
+
+      if options[:json]
+        puts as_json(json_response, options)
+      elsif !options[:quiet]
+        if json_response['success']
+          print_green_success  "Integration removed"
+          get([] + (options[:remote] ? ["-r",options[:remote]] : []))
+        else
+          print_red_alert "Error removing integration: #{json_response['msg'] || json_response['errors']}"
+        end
+      end
+      return 0
+
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
   def add_syslog_rule(args)
     options = {}
 

data/lib/morpheus/cli/logs_command.rb

@@ -62,6 +62,15 @@ class Morpheus::Cli::LogsCommand
       # opts.on('--interval TIME','--interval TIME', "Interval of time to include, in seconds. Default is 30 days ago.") do |val|
       #   options[:interval] = parse_time(val).utc.iso8601
       # end
+      opts.on('--level VALUE', String, "Log Level. DEBUG,INFO,WARN,ERROR") do |val|
+        params['level'] = params['level'] ? [params['level'], val].flatten : val
+      end
+      opts.on('--table', '--table', "Format ouput as a table.") do
+        options[:table] = true
+      end
+      opts.on('-a', '--all', "Display all details: entire message." ) do
+        options[:details] = true
+      end
       build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
       opts.footer = "List logs for a container.\n" +
                     "[id] is required. This is the id of a container."
@@ -73,7 +82,7 @@ class Morpheus::Cli::LogsCommand
     connect(options)
     begin
       params.merge!(parse_list_options(options))
-      params[:query] = params.delete(:phrase) unless params[:phrase].nil?
+      params['query'] = params.delete('phrase') if params['phrase']
       params['order'] = params['direction'] unless params['direction'].nil? # old api version expects order instead of direction
       params['startMs'] = (options[:start].to_i * 1000) if options[:start]
       params['endMs'] = (options[:end].to_i * 1000) if options[:end]
@@ -85,22 +94,19 @@ class Morpheus::Cli::LogsCommand
         return
       end
       json_response = @logs_interface.list(params)
-      render_result = render_with_format(json_response, options, 'data')
+      render_result = json_response['logs'] ? render_with_format(json_response, options, 'logs') : render_with_format(json_response, options, 'data')
       return 0 if render_result
 
       title = "Morpheus Logs"
       subtitles = parse_list_subtitles(options)
-      if params[:start]
-        subtitles << "Start: #{params[:start]}".strip
-      end
-      if params[:end]
-        subtitles << "End: #{params[:end]}".strip
+      if options[:start]
+        subtitles << "Start: #{options[:start]}".strip
       end
-      if params[:interval]
-        subtitles << "Interval: #{params[:interval]}".strip
+      if options[:end]
+        subtitles << "End: #{options[:end]}".strip
       end
-      if params[:query]
-        subtitles << "Search: #{params[:query]}".strip
+      if params['query']
+        subtitles << "Search: #{params['query']}".strip
       end
       if params['servers']
         subtitles << "Servers: #{params['servers']}".strip
@@ -111,15 +117,16 @@ class Morpheus::Cli::LogsCommand
       if params['clusters']
         subtitles << "Clusters: #{params['clusters']}".strip
       end
-      if params[:query]
-        subtitles << "Search: #{params[:query]}".strip
+      if params['level']
+        subtitles << "Level: #{params['level']}"
       end
       print_h1 title, subtitles, options
-      if json_response['data'].empty?
-        puts "#{cyan}No logs found.#{reset}"
+      logs = json_response['data'] || json_response['logs']
+      if logs.empty?
+        print "#{cyan}No logs found.#{reset}\n"
       else
-        puts format_log_records(json_response['data'], options)
-        print_results_pagination({'meta'=>{'total'=>json_response['total'],'size'=>json_response['data'].size,'max'=>(json_response['max'] || options[:max]),'offset'=>(json_response['offset'] || options[:offset] || 0)}})
+        print format_log_records(logs, options)
+        print_results_pagination({'meta'=>{'total'=>(json_response['total']['value'] rescue json_response['total']),'size'=>logs.size,'max'=>(json_response['max'] || options[:max]),'offset'=>(json_response['offset'] || options[:offset] || 0)}})
       end
       print reset,"\n"
       return 0

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

@@ -331,6 +331,8 @@ module Morpheus::Cli::AccountsHelper
     val ||= 'none'
     if val == 'none'
       "#{white}#{val.to_s.capitalize}#{cyan}"
+    # elsif val == 'read'
+    #   "#{cyan}#{val.to_s.capitalize}#{cyan}"
     else
       "#{green}#{val.to_s.capitalize}#{cyan}"
     end

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

@@ -15,6 +15,12 @@ module Morpheus::Cli::LogsHelper
     @logs_interface
   end
 
+  def instances_interface
+    # @api_client.instances
+    raise "#{self.class} has not defined @instances_interface" if @instances_interface.nil?
+    @instances_interface
+  end
+
   def containers_interface
     ## @api_client.containers
     raise "#{self.class} has not defined @logs_interface" if @containers_interface.nil?
@@ -33,33 +39,81 @@ module Morpheus::Cli::LogsHelper
     @clusters_interface
   end
 
-  def print_log_records(log_records, options={})
-    print format_log_records(log_records, options)
-  end
-  
-  def format_log_records(log_records, options={})
+  def format_log_records(log_records, options={}, show_object=true)
+    if options[:table]
+      return format_log_table(log_records, options, show_object)
+    end
     out = ""
     table_color = options.key?(:color) ? options[:color] : cyan
     log_records.each do |log_entry|
-      log_level = ''
-      case log_entry['level']
-      when 'INFO'
-        log_level = "#{blue}#{bold}INFO#{reset}"
-      when 'DEBUG'
-        log_level = "#{white}#{bold}DEBUG#{reset}"
-      when 'WARN'
-        log_level = "#{yellow}#{bold}WARN#{reset}"
-      when 'ERROR'
-        log_level = "#{red}#{bold}ERROR#{reset}"
-      when 'FATAL'
-        log_level = "#{red}#{bold}FATAL#{reset}"
-      end
+      log_level = format_log_level(log_entry['level'], table_color, 6)
       out << table_color if table_color
-      out << "[#{log_entry['ts']}] #{log_level} - #{log_entry['message'].to_s.strip}"
+      # out << "[#{log_entry['ts']}] #{log_level} - #{log_entry['message'].to_s.strip}"
+      out << "#{log_level} "
+      out << "[#{log_entry['ts']}] "
+      if show_object
+        out << "(#{log_entry['typeCode']} #{log_entry['objectId']}) "
+      end
+      log_msg = ""
+      if options[:details] || options[:all]
+          log_msg = log_entry['message'].to_s.strip
+        else
+          # truncate_string(log_entry['message'].to_s.split.select {|it| it.to_s.strip != "" }.first, 100) 
+          log_msg = truncate_string(log_entry['message'].to_s.gsub("\r\n", " ").gsub("\n", " "), 100) 
+        end
+      out << "- #{log_msg}"
       out << table_color if table_color
       out << "\n"
     end
     return out
   end
 
+  def format_log_table(logs, options={}, show_object=true)
+    out = ""
+    table_color = options.key?(:color) ? options[:color] : cyan
+    log_columns = [
+      {"LEVEL" => lambda {|log_entry| format_log_level(log_entry['level'], table_color) } },
+      {"DATE" => lambda {|log_entry| log_entry['ts'] } },
+      {"SOURCE" => lambda {|log_entry| "#{log_entry['typeCode']} #{log_entry['objectId']}" } },
+      {"MESSAGE" => lambda {|log_entry| 
+        if options[:details] || options[:all]
+          log_entry['message'].to_s
+        else
+          truncate_string(log_entry['message'].to_s.split.first, 100) 
+        end
+      } }
+    ]
+    if show_object != true
+      log_columns = log_columns.reject {|it| it.key?("SOURCE") }
+    end
+    # if options[:include_fields]
+    #   columns = options[:include_fields]
+    # end
+    out << as_pretty_table(logs, log_columns, options.merge(responsive_table:false))
+    # out << "\n"
+    return out
+  end
+
+  def format_log_level(val, return_color=cyan, label_width=nil)
+    log_level = ''
+    display_value = val.to_s
+    if label_width
+      display_value = display_value.ljust(label_width, ' ')
+    end
+    case val
+    when 'INFO'
+      log_level = "#{blue}#{bold}#{display_value}#{reset}#{return_color}"
+    when 'DEBUG'
+      log_level = "#{white}#{bold}#{display_value}#{reset}#{return_color}"
+    when 'WARN'
+      log_level = "#{yellow}#{bold}#{display_value}#{reset}#{return_color}"
+    when 'ERROR'
+      log_level = "#{red}#{bold}#{display_value}#{reset}#{return_color}"
+    when 'FATAL'
+      log_level = "#{red}#{bold}#{display_value}#{reset}#{return_color}"
+    else
+      log_level = val
+    end
+    return log_level
+  end
 end

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

@@ -1026,7 +1026,8 @@ module Morpheus::Cli::PrintHelper
 
     if options[:include_fields]
       if object_key
-        data[object_key] = filter_data(data[object_key], options[:include_fields])
+        # data[object_key] = filter_data(data[object_key], options[:include_fields])
+        data = {(object_key) => filter_data(data[object_key], options[:include_fields]) }
       else
         data = filter_data(data, options[:include_fields])
       end
@@ -1115,4 +1116,31 @@ module Morpheus::Cli::PrintHelper
     end
   end
 
+  def format_percent(val, sig_dig=2)
+    if val.nil?
+      return ""
+    end
+    percent_value = val.to_f
+    if percent_value == 0
+      return "0%"
+    else
+      return percent_value.round(sig_dig).to_s + "%"
+    end
+  end
+
+  # returns 0.50 / s ie {{value}} / {{unit}}
+  def format_rate(amount, unit='s', sig_dig=2)
+    if amount.to_f == 0
+      return "0.00" + " / " + unit.to_s
+    else
+      rtn = amount.to_f.round(2).to_s
+      parts = rtn.split('.')
+      # number_str = format_number(parts[0])
+      number_str = parts[0].to_s
+      decimal_str = "#{parts[1]}".ljust(sig_dig, "0")
+      number_str + "." + decimal_str
+      return number_str + "." + decimal_str + " / " + unit.to_s
+    end
+  end
+
 end

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

@@ -31,6 +31,28 @@ module Morpheus::Cli::ProvisioningHelper
     @instance_types_interface
   end
 
+  def instance_type_layouts_interface
+    # @api_client.instance_types
+    raise "#{self.class} has not defined @library_layouts" if @library_layouts_interface.nil?
+    @library_layouts_interface
+  end
+
+  def clouds_interface
+    # @api_client.instance_types
+    raise "#{self.class} has not defined @clouds_interface" if @clouds_interface.nil?
+    @clouds_interface
+  end
+
+  def cloud_datastores_interface
+    raise "#{self.class} has not defined @clouds_datastores_interface" if  @clouds_datastores_interface.nil?
+    @clouds_datastores_interface
+  end
+
+  def accounts_interface
+    raise "#{self.class} has not defined @accounts_interface" if @accounts_interface.nil?
+    @accounts_interface
+  end
+
   def get_available_groups(refresh=false)
     if !@available_groups || refresh
       option_results = options_interface.options_for_source('groups',{})
@@ -62,6 +84,22 @@ module Morpheus::Cli::ProvisioningHelper
     return group["clouds"]
   end
 
+  def get_available_accounts(refresh=false)
+    if !@available_accounts || refresh
+      @available_accounts = accounts_interface.list()['accounts']
+    end
+    @available_accounts
+  end
+
+  def get_available_plans(refresh=false)
+    if !@available_plans || refresh
+      @available_plans = instances_interface.search_plans['searchPlans'].collect {|it|
+        {"name" => it["name"], "value" => it["id"]}
+      }
+    end
+    @available_plans
+  end
+
   def find_group_by_id_for_provisioning(val)
     groups = get_available_groups()
     group = groups.find {|it| it["id"].to_s == val.to_s }
@@ -208,6 +246,15 @@ module Morpheus::Cli::ProvisioningHelper
     return instance
   end
 
+  def find_instance_type_layout_by_id(layout_id, id)
+    json_results = instance_type_layouts_interface.get(layout_id, id)
+    if json_results['instanceTypeLayout'].empty?
+      print_red_alert "Instance type layout not found by id #{id}"
+      exit 1
+    end
+    json_results['instanceTypeLayout']
+  end
+
   def find_workflow_by_name_or_id(val)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_workflow_by_id(val)
@@ -244,8 +291,12 @@ module Morpheus::Cli::ProvisioningHelper
     end
   end
 
+  def find_cloud_resource_pool_by_name_or_id(cloud_id, val)
+    (val.to_s =~ /\A\d{1,}\Z/) ? find_cloud_resource_pool_by_id(cloud_id, val) : find_cloud_resource_pool_by_name(cloud_id, val)
+  end
+
   def get_provision_type_for_zone_type(zone_type_id)
-    @clouds_interface.cloud_type(zone_type_id)['zoneType']['provisionTypes'].first rescue nil
+    clouds_interface.cloud_type(zone_type_id)['zoneType']['provisionTypes'].first rescue nil
   end
 
   # prompts user for all the configuartion options for a particular instance
@@ -254,8 +305,10 @@ module Morpheus::Cli::ProvisioningHelper
     #puts "prompt_new_instance() #{options}"
     print reset # clear colors
     options[:options] ||= {}
+
     # Group
-    default_group = @active_group_id ? find_group_by_name_or_id_for_provisioning(@active_group_id) : nil
+    default_group = find_group_by_name_or_id_for_provisioning(options[:default_group] || @active_group_id) if options[:default_group] || @active_group_id
+
     group_id = nil
     group = options[:group] ? find_group_by_name_or_id_for_provisioning(options[:group]) : nil
     if group
@@ -278,8 +331,11 @@ module Morpheus::Cli::ProvisioningHelper
       available_clouds = get_available_clouds(group_id)
       cloud_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'cloud', 'type' => 'select', 'fieldLabel' => 'Cloud', 'selectOptions' => get_available_clouds(group_id), 'required' => true, 'description' => 'Select Cloud.', 'defaultValue' => options[:default_cloud] ? options[:default_cloud] : nil}],options[:options],api_client,{groupId: group_id})
       cloud_id = cloud_prompt['cloud']
-      cloud = available_clouds.find {|it| it['id'] == cloud_id.to_i || it['name'] == cloud_id.to_s }
     end
+
+    cloud = clouds_interface.get(cloud_id)['zone']
+    cloud_type = cloud['zoneType'] || {}
+
     # Instance Type
     instance_type_code = nil
     if options[:instance_type_code]
@@ -302,9 +358,38 @@ module Morpheus::Cli::ProvisioningHelper
     elsif options[:options]['instance'] && options[:options]['instance']['name']
       options[:options]['name'] = options[:options]['instance']['name']
     end
-    name_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Instance Name', 'type' => 'text', 'required' => options[:name_required]}], options[:options])
-    instance_name = name_prompt['name']
-    
+
+    while instance_name.nil? do
+      name_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Instance Name', 'type' => 'text', 'required' => options[:name_required], 'defaultValue' => options[:default_name]}], options[:options])
+
+      if name_prompt['name'].nil? && !options[:name_required]
+        break
+      else
+        if instances_interface.get({name: name_prompt['name']})['instances'].empty?
+          instance_name = name_prompt['name']
+        else
+          print_red_alert "Name must be unique"
+
+          if options[:default_name] == name_prompt['name']
+            options[:default_name] += '-2'
+          end
+        end
+      end
+    end
+
+    # config
+    config = {}
+    if cloud_type['code'] == 'amazon' && (cloud['config'] || {})['isVpc'] == 'false' && (cloud['config'] || {})['vpc'] == ''
+      config['isEC2'] = true
+    else
+      config['isEC2'] = false
+      if cloud_type['code'] == 'amazon' && (cloud['config'] || {})['isVpc'] == 'true' && (cloud['config'] || {})['vpc'] != ''
+        config['isVpcSelectable'] = false
+        config['resourcePoolId'] = cloud['config']['vpc']
+      else
+        config['isVpcSelectable'] = true
+      end
+    end
 
     payload = {
       'zoneId' => cloud_id,
@@ -319,7 +404,8 @@ module Morpheus::Cli::ProvisioningHelper
         'instanceType' => {
           'code' => instance_type_code
         }
-      }
+      },
+      'config' => config
     }
 
     # allow arbitrary -O values passed by the user
@@ -361,45 +447,53 @@ module Morpheus::Cli::ProvisioningHelper
     payload['instance']['tags'] = v_prompt['tags'].split(',').collect {|it| it.to_s.strip }.compact.uniq if !v_prompt['tags'].empty?
 
     # Version and Layout
-
-    available_versions = options_interface.options_for_source('instanceVersions',{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})['data']
-    default_version_value = payload['instance']['version'] ? payload['instance']['version'] : payload['version']
-    default_layout_value = payload['instance']['layout'] ? payload['instance']['layout'] : payload['layout']
-    if default_layout_value && default_layout_value.is_a?(Hash)
-      default_layout_value = default_layout_value['id']
-    end
-    # JD: version is always nil because it is not stored in the blueprint or config !!
-    # so for now, infer the version from the layout
-    # requires api 3.6.2 to get "layouts" from /options/versions
-    if default_layout_value && default_version_value.to_s.empty?
-      available_versions.each do |available_version|
-        if available_version["layouts"]
-          selected_layout = available_version["layouts"].find {|it| it["value"].to_s == default_layout_value.to_s || it["id"].to_s == default_layout_value.to_s || it["code"].to_s == default_layout_value.to_s }
-          if selected_layout
-            default_version_value = available_version["value"]
-            break
+    if options[:version]
+      version_value = options[:version]
+    else
+      available_versions = options_interface.options_for_source('instanceVersions',{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})['data']
+      default_version_value = payload['instance']['version'] ? payload['instance']['version'] : payload['version']
+      default_layout_value = payload['instance']['layout'] ? payload['instance']['layout'] : payload['layout']
+      if default_layout_value && default_layout_value.is_a?(Hash)
+        default_layout_value = default_layout_value['id']
+      end
+      # JD: version is always nil because it is not stored in the blueprint or config !!
+      # so for now, infer the version from the layout
+      # requires api 3.6.2 to get "layouts" from /options/versions
+      if default_layout_value && default_version_value.to_s.empty?
+        available_versions.each do |available_version|
+          if available_version["layouts"]
+            selected_layout = available_version["layouts"].find {|it| it["value"].to_s == default_layout_value.to_s || it["id"].to_s == default_layout_value.to_s || it["code"].to_s == default_layout_value.to_s }
+            if selected_layout
+              default_version_value = available_version["value"]
+              break
+            end
           end
         end
       end
-    end
 
-    # do not require version if a layout is passed
-    version_value = default_version_value
-    version_is_required = default_layout_value.nil?
-    if default_layout_value.nil? && options[:options]["layout"].nil? && options[:always_prompt] != true
-      #version_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'version', 'type' => 'select', 'fieldLabel' => 'Version', 'optionSource' => 'instanceVersions', 'required' => true, 'skipSingleOption' => true, 'autoPickOption' => true, 'description' => 'Select which version of the instance type to be provisioned.', 'defaultValue' => default_version_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})
-      version_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'version', 'type' => 'select', 'fieldLabel' => 'Version', 'selectOptions' => available_versions, 'required' => version_is_required, 'skipSingleOption' => true, 'autoPickOption' => true, 'description' => 'Select which version of the instance type to be provisioned.', 'defaultValue' => default_version_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})
-      version_value = version_prompt['version']
+      # do not require version if a layout is passed
+      version_value = default_version_value
+      version_is_required = default_layout_value.nil?
+      if default_layout_value.nil? && options[:options]["layout"].nil? && options[:always_prompt] != true
+        #version_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'version', 'type' => 'select', 'fieldLabel' => 'Version', 'optionSource' => 'instanceVersions', 'required' => true, 'skipSingleOption' => true, 'autoPickOption' => true, 'description' => 'Select which version of the instance type to be provisioned.', 'defaultValue' => default_version_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})
+        version_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'version', 'type' => 'select', 'fieldLabel' => 'Version', 'selectOptions' => available_versions, 'required' => version_is_required, 'skipSingleOption' => true, 'autoPickOption' => true, 'description' => 'Select which version of the instance type to be provisioned.', 'defaultValue' => default_version_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id']})
+        version_value = version_prompt['version']
+      end
     end
+
     # JD: there is a bug here, the version needs to be passed perhaps? or the optionSource methods need updating...
     # could just allow for now ...
     # if options[:options]["layout"]
     #   layout_id = options[:options]["layout"]
     #   ...
     # end
-    layout_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'layout', 'type' => 'select', 'fieldLabel' => 'Layout', 'optionSource' => 'layoutsForCloud', 'required' => true, 'description' => 'Select which configuration of the instance type to be provisioned.', 'defaultValue' => default_layout_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], version: version_value})
-    layout_id = layout_prompt['layout']
-    layout = instance_type['instanceTypeLayouts'].find{ |lt| lt['id'] == layout_id.to_i}
+    layout_id = options[:layout].to_i if options[:layout]
+
+    if !layout_id
+      layout_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'layout', 'type' => 'select', 'fieldLabel' => 'Layout', 'optionSource' => 'layoutsForCloud', 'required' => true, 'description' => 'Select which configuration of the instance type to be provisioned.', 'defaultValue' => default_layout_value}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], version: version_value, creatable: true})['layout']
+    end
+
+    layout = find_instance_type_layout_by_id(instance_type['id'], layout_id.to_i)
     if !layout
       print_red_alert "Layout not found by id #{layout_id}"
       exit 1
@@ -407,22 +501,31 @@ module Morpheus::Cli::ProvisioningHelper
     payload['instance']['layout'] = {'id' => layout['id']}
 
     # prompt for service plan
-    service_plans_json = @instances_interface.service_plans({zoneId: cloud_id, layoutId: layout_id, siteId: group_id})
+    service_plans_json = @instances_interface.service_plans({zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
     service_plans = service_plans_json["plans"]
-    service_plans_dropdown = service_plans.collect {|sp| {'name' => sp["name"], 'value' => sp["id"], 'code' => sp['code']} } # already sorted
-    default_plan = nil
-    if payload['plan']
-      default_plan = payload['plan']
-    elsif payload['instance'] && payload['instance']['plan']
-      default_plan = payload['instance']['plan']
-    end
-    default_plan_value = default_plan.is_a?(Hash) ? default_plan['id'] : default_plan
-    plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'description' => 'Choose the appropriately sized plan for this instance', 'defaultValue' => default_plan_value}],options[:options])
-    plan_id = plan_prompt['servicePlan']
-    service_plan = service_plans.find {|sp| sp["id"] == plan_id.to_i }
+    service_plan = service_plans.find {|sp| sp['id'] == options[:service_plan].to_i} if options[:service_plan]
+
     if !service_plan
-      print_red_alert "Plan not found by id #{plan_id}"
-      exit 1
+      service_plans_dropdown = service_plans.collect {|sp| {'name' => sp["name"], 'value' => sp["id"], 'code' => sp['code']} } # already sorted
+      default_plan = nil
+      if payload['plan']
+        default_plan = payload['plan']
+      elsif payload['instance'] && payload['instance']['plan']
+        default_plan = payload['instance']['plan']
+      end
+
+      if options[:default_plan] && service_plans_dropdown.find {|sp| [sp["name"], sp["value"].to_s, sp["code"]].include?(options[:default_plan].to_s)}
+        default_plan_value = options[:default_plan]
+      else
+        default_plan_value = options[:default_plan] || (default_plan.is_a?(Hash) ? default_plan['id'] : default_plan)
+      end
+      plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'description' => 'Choose the appropriately sized plan for this instance', 'defaultValue' => default_plan_value}],options[:options])
+      plan_id = plan_prompt['servicePlan']
+      service_plan = service_plans.find {|sp| sp["id"] == plan_id.to_i }
+      if !service_plan
+        print_red_alert "Plan not found by id #{plan_id}"
+        exit 1
+      end
     end
     #todo: consolidate these, instances api looks for instance.plan.id and apps looks for plan.id
     payload['plan'] = {'id' => service_plan["id"], 'code' => service_plan["code"], 'name' => service_plan["name"]}
@@ -458,50 +561,87 @@ module Morpheus::Cli::ProvisioningHelper
       # pluck out the resourcePoolId option type to prompt for
       resource_pool_option_type = option_type_list.find {|opt| ['resourcePool','resourcePoolId','azureResourceGroupId'].include?(opt['fieldName']) }
       option_type_list = option_type_list.reject {|opt| ['resourcePool','resourcePoolId','azureResourceGroupId'].include?(opt['fieldName']) }
-      resource_pool_option_type ||= {'fieldContext' => 'config', 'fieldName' => 'resourcePoolId', 'type' => 'select', 'fieldLabel' => 'Resource Pool', 'optionSource' => 'zonePools', 'required' => true, 'skipSingleOption' => true, 'description' => 'Select resource pool.'}
-      resource_pool_prompt = Morpheus::Cli::OptionTypes.prompt([resource_pool_option_type],options[:options],api_client,{groupId: group_id, siteId: group_id, zoneId: cloud_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], planId: service_plan["id"], layoutId: layout["id"]})
-      resource_pool_prompt.deep_compact!
-      payload.deep_merge!(resource_pool_prompt)
-      resource_pool = Morpheus::Cli::OptionTypes.get_last_select()
-      if resource_pool_option_type['fieldContext'] && resource_pool_prompt[resource_pool_option_type['fieldContext']]
-        pool_id = resource_pool_prompt[resource_pool_option_type['fieldContext']][resource_pool_option_type['fieldName']]
-      elsif resource_pool_prompt[resource_pool_option_type['fieldName']]
-        pool_id = resource_pool_prompt[resource_pool_option_type['fieldName']]
+      resource_pool_options = @options_interface.options_for_source('zonePools', {groupId: group_id, siteId: group_id, zoneId: cloud_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], planId: service_plan["id"], layoutId: layout["id"]})['data']
+      resource_pool = resource_pool_options.find {|opt| opt['id'] == options[:resource_pool].to_i} if options[:resource_pool]
+
+      if resource_pool
+        pool_id = resource_pool['id']
+      else
+        if options[:default_resource_pool]
+          default_resource_pool = resource_pool_options.find {|rp| rp['id'] == options[:default_resource_pool]}
+        end
+        resource_pool_option_type ||= {'fieldContext' => 'config', 'fieldName' => 'resourcePoolId', 'type' => 'select', 'fieldLabel' => 'Resource Pool', 'selectOptions' => resource_pool_options, 'required' => true, 'skipSingleOption' => true, 'description' => 'Select resource pool.', 'defaultValue' => default_resource_pool ? default_resource_pool['name'] : nil}
+        resource_pool_prompt = Morpheus::Cli::OptionTypes.prompt([resource_pool_option_type],options[:options],api_client,{})
+        resource_pool_prompt.deep_compact!
+        payload.deep_merge!(resource_pool_prompt)
+        resource_pool = Morpheus::Cli::OptionTypes.get_last_select()
+        if resource_pool_option_type['fieldContext'] && resource_pool_prompt[resource_pool_option_type['fieldContext']]
+          pool_id = resource_pool_prompt[resource_pool_option_type['fieldContext']][resource_pool_option_type['fieldName']]
+        elsif resource_pool_prompt[resource_pool_option_type['fieldName']]
+          pool_id = resource_pool_prompt[resource_pool_option_type['fieldName']]
+        end
       end
     end
 
     # remove host selection for kubernetes
-    if resource_pool && resource_pool['providerType'] == 'kubernetes'
-      option_type_list = option_type_list.reject {|opt|
-        ['provisionServerId'].include?(opt['fieldName'])
-      }
+    if resource_pool
+      payload['config']['poolProviderType'] = resource_pool['providerType'] if resource_pool['providerType']
+      if resource_pool['providerType'] == 'kubernetes'
+        option_type_list = option_type_list.reject {|opt| ['provisionServerId'].include?(opt['fieldName'])}
+      end
+
+      # add selectable datastores for resource pool
+      if options[:select_datastore]
+        service_plan['datastores'] = {'cluster' => [], 'store' => []}
+        selectable_datastores = cloud_datastores_interface.selectable(cloud_id, {'siteId' => group_id, 'resourcePoolId' => resource_pool['id']})
+        ['cluster', 'store'].each do |type|
+          service_plan['datastores'][type] ||= []
+          selectable_datastores[type].reject { |ds| service_plan['datastores'][type].find {|it| it['id'] == ds['id']} }.each { |ds|
+            service_plan['datastores'][type] << ds
+          }
+        end
+
+        if layout['provisionType'] && layout['provisionType']['supportsAutoDatastore']
+          service_plan['autoOptions'] ||= []
+          if service_plan['datastores']['cluster'].count > 0 && !service_plan['autoOptions'].find {|it| it['id'] == 'autoCluster'}
+            service_plan['autoOptions'] << {'id' => 'autoCluster', 'name' => 'Auto - Cluster'}
+          end
+          if service_plan['datastores']['store'].count > 0 && !service_plan['autoOptions'].find {|it| it['id'] == 'auto'}
+            service_plan['autoOptions'] << {'id' => 'auto', 'name' => 'Auto - Datastore'}
+          end
+        end
+      end
     end
 
     # plan_info has this property already..
     # has_datastore = layout["provisionType"] && layout["provisionType"]["id"] && layout["provisionType"]["hasDatastore"]
     # service_plan['hasDatastore'] = has_datastore
 
+    # set root volume name if has mounts
+    mounts = (layout['mounts'] || []).reject {|it| !it['canPersist']}
+    if mounts.count > 0
+      options[:root_volume_name] = mounts[0]['shortName']
+    end
+
     # prompt for volumes
-    # if payload['volumes'].nil?
-      volumes = prompt_volumes(service_plan, options, api_client, {zoneId: cloud_id, layoutId: layout_id, siteId: group_id})
-      if !volumes.empty?
-        payload['volumes'] = volumes
-      end
-    # end
+    volumes = prompt_volumes(service_plan, options, api_client, {zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
+    if !volumes.empty?
+      payload['volumes'] = volumes
+    end
 
-    # if payload['networkInterfaces'].nil?
-      if layout["provisionType"] && layout["provisionType"]["id"] && layout["provisionType"]["hasNetworks"]
-        # prompt for network interfaces (if supported)
-        begin
-          network_interfaces = prompt_network_interfaces(cloud_id, layout["provisionType"]["id"], pool_id, options)
-          if !network_interfaces.empty?
-            payload['networkInterfaces'] = network_interfaces
-          end
-        rescue RestClient::Exception => e
-          print yellow,"Unable to load network options. Proceeding...",reset,"\n"
-          print_rest_exception(e, options) if Morpheus::Logging.debug?
+    # prompt networks
+    if layout["provisionType"] && layout["provisionType"]["id"] && layout["provisionType"]["hasNetworks"] # && layout["provisionType"]["supportsNetworkSelection"]
+      # prompt for network interfaces (if supported)
+      begin
+        network_interfaces = prompt_network_interfaces(cloud_id, layout["provisionType"]["id"], pool_id, options)
+        if !network_interfaces.empty?
+          payload['networkInterfaces'] = network_interfaces
         end
+      rescue RestClient::Exception => e
+        print yellow,"Unable to load network options. Proceeding...",reset,"\n"
+        print_rest_exception(e, options) if Morpheus::Logging.debug?
       end
+    end
     # end
 
     # Security Groups
@@ -511,27 +651,34 @@ module Morpheus::Cli::ProvisioningHelper
     # ok.. seed data has changed and serverTypes do not have this optionType anymore...
     if sg_option_type.nil?
       if layout["provisionType"] && (layout["provisionType"]["code"] == 'amazon')
-        sg_option_type = {'fieldContext' => 'config', 'fieldName' => 'securityId', 'type' => 'select', 'fieldLabel' => 'Security Group', 'optionSource' => 'amazonSecurityGroup', 'required' => true, 'description' => 'Select security group.'}
+        sg_option_type = {'fieldContext' => 'config', 'fieldName' => 'securityId', 'type' => 'select', 'fieldLabel' => 'Security Group', 'optionSource' => 'amazonSecurityGroup', 'required' => true, 'description' => 'Select security group.', 'defaultValue' => options[:default_security_group]}
       end
     end
     has_security_groups = !!sg_option_type
     if options[:security_groups]
       payload['securityGroups'] = options[:security_groups].collect {|sg_id| {'id' => sg_id} }
-    else
-      if has_security_groups
-        security_groups_array = prompt_security_groups(sg_option_type, {zoneId: cloud_id, poolId: pool_id}, options)
-        if !security_groups_array.empty?
-          payload['securityGroups'] = security_groups_array.collect {|sg_id| {'id' => sg_id} }
-        end
+    elsif has_security_groups
+      security_groups_array = prompt_security_groups(sg_option_type, {zoneId: cloud_id, poolId: pool_id}, options)
+      if !security_groups_array.empty?
+        payload['securityGroups'] = security_groups_array.collect {|sg_id| {'id' => sg_id} }
       end
     end
 
-
     # prompt for option types
     api_params = {groupId: group_id, cloudId: cloud_id, zoneId: cloud_id, instanceTypeId: instance_type['id'], version: version_value}
     api_params['config'] = payload['config'] if payload['config']
     api_params['poolId'] = payload['config']['resourcePoolId'] if payload['config'] && payload['config']['resourcePoolId']
 
+    # set option type defaults from config
+    if options[:default_config]
+      options[:default_config].each do |k,v|
+        if v && !(v.kind_of?(Array) && v.empty?)
+          option_type = option_type_list.find {|ot| ot['fieldContext'] == 'config' && ot['fieldName'] == k}
+          option_type['defaultValue'] = v if option_type
+        end
+      end
+    end
+
     instance_config_payload = Morpheus::Cli::OptionTypes.prompt(option_type_list, options[:options], @api_client, api_params)
     payload.deep_merge!(instance_config_payload)
 
@@ -558,10 +705,10 @@ module Morpheus::Cli::ProvisioningHelper
   # returns array of volumes based on service plan options (plan_info)
   def prompt_volumes(plan_info, options={}, api_client=nil, api_params={})
     #puts "Configure Volumes:"
-    no_prompt = (options[:no_prompt] || (options[:options] && options[:options][:no_prompt]))
+    # return [] if plan_info['noDisks']
 
+    no_prompt = (options[:no_prompt] || (options[:options] && options[:options][:no_prompt]))
     volumes = []
-
     plan_size = nil
     if plan_info['maxStorage']
       plan_size = plan_info['maxStorage'].to_i / (1024 * 1024 * 1024)
@@ -615,7 +762,7 @@ module Morpheus::Cli::ProvisioningHelper
 
     field_context = "rootVolume"
 
-    volume_label = 'root'
+    volume_label = options[:root_volume_name] || 'root'
     volume = {
       'id' => -1,
       'rootVolume' => true,
@@ -634,7 +781,8 @@ module Morpheus::Cli::ProvisioningHelper
       storage_type_id = nil
       storage_type = nil
     else
-      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'storageType', 'type' => 'select', 'fieldLabel' => 'Root Storage Type', 'selectOptions' => root_storage_types, 'required' => true, 'skipSingleOption' => true, 'description' => 'Choose a storage type.', 'defaultValue' => volume['storageType']}], options[:options])
+      default_storage_type = root_storage_types.find {|t| t['value'].to_s == volume['storageType'].to_s}
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'storageType', 'type' => 'select', 'fieldLabel' => 'Root Storage Type', 'selectOptions' => root_storage_types, 'required' => true, 'skipSingleOption' => true, 'description' => 'Choose a storage type.', 'defaultValue' => default_storage_type ? default_storage_type['name'] : volume['storageType']}], options[:options])
       storage_type_id = v_prompt[field_context]['storageType']
       storage_type = plan_info['storageTypes'].find {|i| i['id'] == storage_type_id.to_i }
       volume['storageType'] = storage_type_id
@@ -670,8 +818,10 @@ module Morpheus::Cli::ProvisioningHelper
       #volume['sizeId'] = nil #volume.delete('sizeId')
     end
     if !datastore_options.empty?
-      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'datastoreId', 'type' => 'select', 'fieldLabel' => 'Root Datastore', 'selectOptions' => datastore_options, 'required' => true, 'description' => 'Choose a datastore.', 'defaultValue' => volume['datastoreId']}], options[:options])
+      default_datastore = datastore_options.find {|ds| ds['value'].to_s == volume['datastoreId'].to_s}
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'datastoreId', 'type' => 'select', 'fieldLabel' => 'Root Datastore', 'selectOptions' => datastore_options, 'required' => true, 'description' => 'Choose a datastore.', 'defaultValue' => default_datastore ? default_datastore['name'] : volume['datastoreId']}], options[:options])
       volume['datastoreId'] = v_prompt[field_context]['datastoreId']
+      volume['hasDatastore'] = true
     end
 
     volumes << volume
@@ -736,6 +886,7 @@ module Morpheus::Cli::ProvisioningHelper
           if !datastore_options.empty?
             v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'datastoreId', 'type' => 'select', 'fieldLabel' => "Disk #{volume_index} Datastore", 'selectOptions' => datastore_options, 'required' => true, 'description' => 'Choose a datastore.', 'defaultValue' => volume['datastoreId']}], options[:options])
             volume['datastoreId'] = v_prompt[field_context]['datastoreId']
+            volume['hasDatastore'] = true
           end
 
           volumes << volume
@@ -1056,6 +1207,10 @@ module Morpheus::Cli::ProvisioningHelper
     if network_groups
       networks = network_groups + networks
     end
+    network_subnets = zone_network_data['networkSubnets']
+    if network_subnets
+      networks += network_subnets
+    end
     network_interface_types = (zone_network_data['networkTypes'] || []).sort { |x,y| x['displayOrder'] <=> y['displayOrder'] }
     enable_network_type_selection = (zone_network_data['enableNetworkTypeSelection'] == 'on' || zone_network_data['enableNetworkTypeSelection'] == true)
     has_networks = zone_network_data["hasNetworks"] == true
@@ -1102,11 +1257,26 @@ module Morpheus::Cli::ProvisioningHelper
         network_interface = options[:options]['networkInterfaces'][interface_index]
       end
 
+      default_network_id = network_interface['networkId'] || network_interface['id']
+
+      if network_interface['network'] && network_interface['network']['id']
+        if network_interface['network']['subnet']
+          default_network_id = "subnet-#{network_interface['network']['subnet']}"
+        elsif network_interface['network']['group']
+          default_network_id = "networkGroup-#{network_interface['network']['group']}"
+        else
+          default_network_id = "network-#{network_interface['network']['id']}"
+        end
+      end
+
+      default_network_value = (network_options.find {|n| n['value'] == default_network_id} || {})['name']
+
       # choose network
-      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'networkId', 'type' => 'select', 'fieldLabel' => "Network", 'selectOptions' => network_options, 'required' => true, 'skipSingleOption' => false, 'description' => 'Choose a network for this interface.', 'defaultValue' => network_interface['networkId']}], options[:options])
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'networkId', 'type' => 'select', 'fieldLabel' => "Network", 'selectOptions' => network_options, 'required' => true, 'skipSingleOption' => false, 'description' => 'Choose a network for this interface.', 'defaultValue' => default_network_value}], options[:options])
       network_interface['network'] = {}
       network_interface['network']['id'] = v_prompt[field_context]['networkId'].to_s
       selected_network = networks.find {|it| it["id"].to_s == network_interface['network']['id'] }
+      network_options.reject! {|it| it['value'] == v_prompt[field_context]['networkId']}
 
       if !selected_network
         print_red_alert "Network not found by id #{network_interface['network']['id']}!"
@@ -1115,7 +1285,8 @@ module Morpheus::Cli::ProvisioningHelper
 
       # choose network interface type
       if enable_network_type_selection && !network_interface_type_options.empty?
-        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'networkInterfaceTypeId', 'type' => 'select', 'fieldLabel' => "Network Interface Type", 'selectOptions' => network_interface_type_options, 'required' => true, 'skipSingleOption' => true, 'description' => 'Choose a network interface type.', 'defaultValue' => network_interface['networkInterfaceTypeId']}], options[:options])
+        default_interface_type_value = (network_interface_type_options.find {|t| t['value'].to_s == network_interface['networkInterfaceTypeId'].to_s} || {})['name']
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'networkInterfaceTypeId', 'type' => 'select', 'fieldLabel' => "Network Interface Type", 'selectOptions' => network_interface_type_options, 'required' => true, 'skipSingleOption' => true, 'description' => 'Choose a network interface type.', 'defaultValue' => default_interface_type_value}], options[:options])
         network_interface['networkInterfaceTypeId'] = v_prompt[field_context]['networkInterfaceTypeId'].to_i
       end
 
@@ -1140,7 +1311,7 @@ module Morpheus::Cli::ProvisioningHelper
       interface_index += 1
       if options[:options] && options[:options]['networkInterfaces'] && options[:options]['networkInterfaces'][interface_index]
         add_another_interface = true
-      elsif max_networks && network_interfaces.size >= max_networks
+      elsif (max_networks && network_interfaces.size >= max_networks) || network_options.count == 0
         add_another_interface = false
       else
         has_another_interface = options[:options] && options[:options]["networkInterface#{interface_index+1}"]
@@ -1211,12 +1382,14 @@ module Morpheus::Cli::ProvisioningHelper
   def prompt_security_groups(sg_option_type, api_params, options)
     no_prompt = (options[:no_prompt] || (options[:options] && options[:options][:no_prompt]))
     security_groups_array = []
-
     sg_required = sg_option_type['required']
     sg_index = 0
     add_another_sg = sg_required || (!no_prompt && Morpheus::Cli::OptionTypes.confirm("Add a security group?", {default: false}))
     while add_another_sg do
       cur_sg_option_type = sg_option_type.merge({'required' => (sg_index == 0 ? sg_required : false)})
+      if sg_index == 0 && !options[:default_security_group].nil?
+        cur_sg_option_type['defaultValue'] = options[:default_security_group]
+      end
       field_context = cur_sg_option_type['fieldContext']
       field_name = cur_sg_option_type['fieldName']
       v_prompt = Morpheus::Cli::OptionTypes.prompt([cur_sg_option_type], options[:options], api_client, api_params)
@@ -1331,4 +1504,289 @@ module Morpheus::Cli::ProvisioningHelper
     [{'name' => 'Dev', 'value' => 'dev'}, {'name' => 'Test', 'value' => 'qa'}, {'name' => 'Staging', 'value' => 'staging'}, {'name' => 'Production', 'value' => 'production'}]
   end
 
+  def add_perms_options(opts, options, excludes = [])
+    if !excludes.include?('groups')
+      opts.on('--group-access-all [on|off]', String, "Toggle Access for all groups.") do |val|
+        options[:groupAccessAll] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
+      end
+      opts.on('--group-access LIST', Array, "Group Access, comma separated list of group IDs.") do |list|
+        if list.size == 1 && list[0] == 'null' # hacky way to clear it
+          options[:groupAccessList] = []
+        else
+          options[:groupAccessList] = list.collect {|it| it.to_s.strip.empty? ? nil : it.to_s.strip }.compact.uniq
+        end
+      end
+      if !excludes.include?('groupDefaults')
+        opts.on('--group-defaults LIST', Array, "Group Default Selection, comma separated list of group IDs") do |list|
+          if list.size == 1 && list[0] == 'null' # hacky way to clear it
+            options[:groupDefaultsList] = []
+          else
+            options[:groupDefaultsList] = list.collect {|it| it.to_s.strip.empty? ? nil : it.to_s.strip }.compact.uniq
+          end
+        end
+      end
+    end
+
+    if !excludes.include?('plans')
+      opts.on('--plan-access-all [on|off]', String, "Toggle Access for all service plans.") do |val|
+        options[:planAccessAll] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == ''
+      end
+      opts.on('--plan-access LIST', Array, "Service Plan Access, comma separated list of plan IDs.") do |list|
+        if list.size == 1 && list[0] == 'null' # hacky way to clear it
+          options[:planAccessList] = []
+        else
+          options[:planAccessList] = list.collect {|it| it.to_s.strip.empty? ? nil : it.to_s.strip }.compact.uniq
+        end
+      end
+      opts.on('--plan-defaults LIST', Array, "Plan Default Selection, comma separated list of plan IDs") do |list|
+        if list.size == 1 && list[0] == 'null' # hacky way to clear it
+          options[:planDefaultsList] = []
+        else
+          options[:planDefaultsList] = list.collect {|it| it.to_s.strip.empty? ? nil : it.to_s.strip }.compact.uniq
+        end
+      end
+    end
+
+    if !excludes.include?('visibility')
+      opts.on('--visibility VISIBILITY', String, "Visibility [private|public]") do |val|
+        options[:visibility] = val
+      end
+    end
+
+    if !excludes.include?('tenants')
+      opts.on('--tenants LIST', Array, "Tenant Access, comma separated list of account IDs") do |list|
+        if list.size == 1 && list[0] == 'null' # hacky way to clear it
+          options[:tenants] = []
+        else
+          options[:tenants] = list.collect {|it| it.to_s.strip.empty? ? nil : it.to_s.strip }.compact.uniq
+        end
+      end
+    end
+  end
+
+  def prompt_permissions(options, excludes = [])
+    all_groups = nil
+    group_access = nil
+    all_plans = nil
+    plan_access = nil
+
+    # Group Access
+    if !excludes.include?('groups')
+      if !options[:groupAccessAll].nil?
+        all_groups = options[:groupAccessAll]
+      end
+
+      if !options[:groupAccessList].empty?
+        group_access = options[:groupAccessList].collect {|site_id| {'id' => site_id.to_i}} || []
+      elsif !options[:no_prompt]
+        available_groups = options[:available_groups] || get_available_groups
+
+        if available_groups.empty?
+          #print_red_alert "No available groups"
+          #exit 1
+        elsif available_groups.count > 1
+          available_groups.unshift({"id" => '0', "name" => "All", "value" => "all"})
+
+          # default to all
+          group_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'group', 'type' => 'select', 'fieldLabel' => 'Group Access', 'selectOptions' => available_groups, 'required' => false, 'description' => 'Add Group Access.'}], options[:options], @api_client, {})['group']
+
+          if !group_id.nil?
+            if group_id == 'all'
+              all_groups = true
+            else
+              group_access = (excludes.include?('groupDefaults') ? [{'id' => group_id}] : [{'id' => group_id, 'default' => Morpheus::Cli::OptionTypes.confirm("Set '#{available_groups.find{|it| it['value'] == group_id}['name']}' as default?", {:default => false})}])
+            end
+            available_groups = available_groups.reject {|it| it['value'] == group_id}
+
+            while !group_id.nil? && !available_groups.empty? && Morpheus::Cli::OptionTypes.confirm("Add another group access?", {:default => false})
+              group_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'group', 'type' => 'select', 'fieldLabel' => 'Group Access', 'selectOptions' => available_groups, 'required' => false, 'description' => 'Add Group Access.'}], options[:options], @api_client, {})['group']
+
+              if !group_id.nil?
+                if group_id == 'all'
+                  all_groups = true
+                else
+                  group_access ||= []
+                  group_access << (excludes.include?('groupDefaults') ? {'id' => group_id} : {'id' => group_id, 'default' => Morpheus::Cli::OptionTypes.confirm("Set '#{available_groups.find{|it| it['value'] == group_id}['name']}' as default?", {:default => false})})
+                end
+                available_groups = available_groups.reject {|it| it['value'] == group_id}
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Plan Access
+    if !excludes.include?('plans')
+      if !options[:planAccessAll].nil?
+        all_plans = options[:planAccessAll]
+      end
+
+      if !options[:planAccessList].empty?
+        plan_access = options[:planAccessList].collect {|plan_id| {'id' => plan_id.to_i}}
+      elsif !options[:no_prompt]
+        available_plans = options[:available_plans] || get_available_plans
+
+        if available_plans.empty?
+          #print_red_alert "No available plans"
+          #exit 1
+        elsif !available_plans.empty? && !options[:no_prompt]
+          available_plans.unshift({"id" => '0', "name" => "All", "value" => "all"})
+
+          # default to all
+          plan_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'plan', 'type' => 'select', 'fieldLabel' => 'Service Plan Access', 'selectOptions' => available_plans, 'required' => false, 'description' => 'Add Service Plan Access.'}], options[:options], @api_client, {})['plan']
+
+          if !plan_id.nil?
+            if plan_id == 'all'
+              all_plans = true
+            else
+              plan_access = [{'id' => plan_id, 'default' => Morpheus::Cli::OptionTypes.confirm("Set '#{available_plans.find{|it| it['id'] == plan_id}['name']}' as default?", {:default => false})}]
+            end
+
+            available_plans = available_plans.reject {|it| it['value'] == plan_id}
+
+            while !plan_id.nil? && !available_plans.empty? && Morpheus::Cli::OptionTypes.confirm("Add another service plan access?", {:default => false})
+              plan_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'plan', 'type' => 'select', 'fieldLabel' => 'Service Plan Access', 'selectOptions' => available_plans, 'required' => false, 'description' => 'Add Service Plan Access.'}], options[:options], @api_client, {})['plan']
+
+              if !plan_id.nil?
+                if plan_id == 'all'
+                  all_plans = true
+                else
+                  plan_access ||= []
+                  plan_access << {'id' => plan_id, 'default' => Morpheus::Cli::OptionTypes.confirm("Set '#{available_plans.find{|it| it['value'] == plan_id}['name']}' as default?", {:default => false})}
+                end
+                available_plans = available_plans.reject {|it| it['value'] == plan_id}
+              end
+            end
+          end
+        end
+      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}
+
+    available_accounts = get_available_accounts.collect {|it| {'name' => it['name'], 'value' => it['id']}}
+    accounts = []
+
+    # Prompts for multi tenant
+    if available_accounts.count > 1
+      visibility = options[: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
+
+      permissions['resourcePool'] = {'visibility' => visibility} if visibility
+
+      # Tenants
+      if !excludes.include?('tenants')
+        if !options[:tenants].nil?
+          accounts = options[:tenants].collect {|id| id.to_i}
+        elsif !options[:no_prompt]
+          account_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'account_id', 'type' => 'select', 'fieldLabel' => 'Add Tenant', 'selectOptions' => available_accounts, 'required' => false, 'description' => 'Add Tenant Permissions.'}], options[:options], @api_client, {})['account_id']
+
+          if !account_id.nil?
+            accounts << account_id
+            available_accounts = available_accounts.reject {|it| it['value'] == account_id}
+
+            while !available_accounts.empty? && (account_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'account_id', 'type' => 'select', 'fieldLabel' => 'Add Another Tenant', 'selectOptions' => available_accounts, 'required' => false, 'description' => 'Add Tenant Permissions.'}], options[:options], @api_client, {})['account_id'])
+              if !account_id.nil?
+                accounts << account_id
+                available_accounts = available_accounts.reject {|it| it['value'] == account_id}
+              end
+            end
+          end
+        end
+        permissions['tenantPermissions'] = {'accounts' => accounts}
+      end
+    end
+    permissions
+  end
+
+  def print_permissions(permissions, excludes = [])
+    if permissions.nil?
+      print_h2 "Permissions"
+      print yellow,"No permissions found.",reset,"\n"
+    else
+      if !permissions['resourcePermissions'].nil?
+        if !excludes.include?('groups')
+          print_h2 "Group Access"
+
+          if excludes.include?('groupDefaults')
+            groups = []
+            groups << 'All' if permissions['resourcePermissions']['all']
+            groups += permissions['resourcePermissions']['sites'].collect {|it| it['name']} if permissions['resourcePermissions']['sites']
+
+            if groups.count > 0
+              print cyan,"#{groups.join(', ')}".center(20)
+            else
+              print yellow,"No group access",reset,"\n"
+            end
+            print "\n"
+          else
+            rows = []
+            if permissions['resourcePermissions']['all']
+              rows.push({group: 'All'})
+            end
+            if permissions['resourcePermissions']['sites']
+              permissions['resourcePermissions']['sites'].each do |site|
+                rows.push({group: site['name'], default: site['default'] ? 'Yes' : ''})
+              end
+            end
+            if rows.empty?
+              print yellow,"No group access",reset,"\n"
+            else
+              columns = [:group, :default]
+              print cyan
+              print as_pretty_table(rows, columns)
+            end
+          end
+        end
+
+        if !excludes.include?('plans')
+          print_h2 "Plan Access"
+          rows = []
+          if permissions['resourcePermissions']['allPlans']
+            rows.push({plan: 'All'})
+          end
+          if permissions['resourcePermissions']['plans']
+            permissions['resourcePermissions']['plans'].each do |plan|
+              rows.push({plan: plan['name'], default: plan['default'] ? 'Yes' : ''})
+            end
+          end
+          if rows.empty?
+            print yellow,"No plan access",reset,"\n"
+          else
+            columns = [:plan, :default]
+            print cyan
+            print as_pretty_table(rows, columns)
+          end
+        end
+
+        if !excludes.include?('tenants')
+          if !permissions['tenantPermissions'].nil?
+            print_h2 "Tenant Permissions"
+            if !permissions['resourcePool'].nil?
+              print cyan
+              print "Visibility: #{permissions['resourcePool']['visibility'].to_s.capitalize}".center(20)
+              print "\n"
+            end
+            if !permissions['tenantPermissions'].nil?
+              print cyan
+              print "Accounts: #{permissions['tenantPermissions']['accounts'].join(', ')}".center(20)
+              print "\n"
+            end
+          end
+        end
+        print "\n"
+      end
+    end
+  end
+
 end