morpheus-cli 4.2.8 → 4.2.10

data/lib/morpheus/cli/reports_command.rb

@@ -176,7 +176,7 @@ class Morpheus::Cli::ReportsCommand
               "ID" => lambda {|it| it['id'] },
               "SECTION" => lambda {|it| it['section'] },
               "DATA" => lambda {|it| truncate_string(it['data'], data_width) }
-            }, options.merge({:responsive_table => false}))
+            }, options.merge({:wrap => true}))
             
           else
             print yellow, "No report data found.", reset, "\n"
@@ -338,23 +338,11 @@ class Morpheus::Cli::ReportsCommand
 
       link = "#{@appliance_url}/login/oauth-redirect?access_token=#{@access_token}\\&redirectUri=/operations/reports/#{report_result['type']['code']}/reportResults/#{report_result['id']}"
 
-      open_command = nil
-      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-        open_command = "start #{link}"
-      elsif RbConfig::CONFIG['host_os'] =~ /darwin/
-        open_command = "open #{link}"
-      elsif RbConfig::CONFIG['host_os'] =~ /linux|bsd/
-        open_command = "xdg-open #{link}"
-      end
-
       if options[:dry_run]
-        puts "system: #{open_command}"
+        puts Morpheus::Util.open_url_command(link)
         return 0
       end
-
-      system(open_command)
-      
-      return 0
+      return Morpheus::Util.open_url(link)
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1

data/lib/morpheus/cli/roles.rb

@@ -94,7 +94,7 @@ class Morpheus::Cli::Roles
       opts.on('-p','--permissions', "Display Permissions") do |val|
         options[:include_feature_access] = true
       end
-      opts.on('-f','--feature-access', "Display Feature Access [deprecated]") do |val|
+      opts.on('-f','--feature-access', "Display Permissions [deprecated]") do |val|
         options[:include_feature_access] = true
       end
       opts.add_hidden_option('--feature-access')
@@ -200,7 +200,7 @@ class Morpheus::Cli::Roles
           {
             code: it['code'],
             name: it['name'],
-            access: get_access_string(it['access']),
+            access: format_access_string(it['access']),
           }
         end
         if options[:sort]
@@ -219,13 +219,6 @@ class Morpheus::Cli::Roles
       end
 
       print_h2 "Global Access", options
-      # role_access_rows = [
-      #   {name: "Groups", access: get_access_string(json_response['globalSiteAccess']) },
-      #   {name: "Clouds", access: get_access_string(json_response['globalZoneAccess']) },
-      #   {name: "Instance Types", access: get_access_string(json_response['globalInstanceTypeAccess']) },
-      #   {name: "Blueprints", access: get_access_string(json_response['globalAppTemplateAccess'] || json_response['globalBlueprintAccess']) }
-      # ]
-      # puts as_pretty_table(role_access_rows, [:name, :access], options)
       puts as_pretty_table([json_response], [
         {"Groups" => lambda {|it| get_access_string(it['globalSiteAccess']) } },
         {"Clouds" => lambda {|it| get_access_string(it['globalZoneAccess']) } },
@@ -241,7 +234,7 @@ class Morpheus::Cli::Roles
           rows = json_response['sites'].collect do |it|
             {
               name: it['name'],
-              access: get_access_string(it['access']),
+              access: format_access_string(it['access'], ["none","read","full"]),
             }
           end
           print as_pretty_table(rows, [:name, :access], options)
@@ -262,7 +255,7 @@ class Morpheus::Cli::Roles
           rows = json_response['zones'].collect do |it|
             {
               name: it['name'],
-              access: get_access_string(it['access']),
+              access: format_access_string(it['access'], ["none","read","full"]),
             }
           end
           print as_pretty_table(rows, [:name, :access], options)
@@ -283,7 +276,7 @@ class Morpheus::Cli::Roles
           rows = json_response['instanceTypePermissions'].collect do |it|
             {
               name: it['name'],
-              access: get_access_string(it['access']),
+              access: format_access_string(it['access'], ["none","read","full"]),
             }
           end
           print as_pretty_table(rows, [:name, :access], options)
@@ -306,7 +299,7 @@ class Morpheus::Cli::Roles
           rows = blueprint_permissions.collect do |it|
             {
               name: it['name'],
-              access: get_access_string(it['access']),
+              access: format_access_string(it['access'], ["none","read","full"]),
             }
           end
           print as_pretty_table(rows, [:name, :access], options)
@@ -393,7 +386,7 @@ class Morpheus::Cli::Roles
           {
             code: it['code'],
             name: it['name'],
-            access: get_access_string(it['access']),
+            access: format_access_string(it['access']),
           }
         end
         if options[:sort]
@@ -1306,15 +1299,7 @@ class Morpheus::Cli::Roles
   end
 
   private
-  # def get_access_string(val)
-  #   val ||= 'none'
-  #   if val == 'none'
-  #     "#{white}#{val.to_s.capitalize}#{cyan}"
-  #   else
-  #     "#{green}#{val.to_s.capitalize}#{cyan}"
-  #   end
-  # end
-
+  
   def add_role_option_types
     [
       {'fieldName' => 'authority', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
@@ -1343,14 +1328,6 @@ class Morpheus::Cli::Roles
     end
   end
 
-  def find_instance_type_by_name(name)
-    results = @instance_types_interface.list({name: name})
-    if results['instanceTypes'].empty?
-      print_red_alert "Instance Type not found by name #{name}"
-      return nil
-    end
-    return results['instanceTypes'][0]
-  end
 
   def load_whoami
     whoami_response = @whoami_interface.get()

data/lib/morpheus/cli/service_plans_command.rb

@@ -34,45 +34,39 @@ class Morpheus::Cli::ServicePlanCommand
       opts.on('-i', '--include-inactive [on|off]', String, "Can be used to enable / disable inactive filter. Default is on") do |val|
         params['includeInactive'] = val.to_s == 'on' || val.to_s == 'true' || val.to_s == '1' || val.to_s == ''
       end
-      build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
+      build_standard_list_options(opts, options)
       opts.footer = "List service plans."
     end
     optparse.parse!(args)
+    #verify_args!(args:args, optparse:optparse, count:0)
     connect(options)
-    if args.count != 0
-      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
-      return 1
-    end
-
-    begin
-      params.merge!(parse_list_options(options))
 
-      if !options[:provisionType].nil?
-        type = find_provision_type(options[:provisionType])
+    
+    params.merge!(parse_list_options(options))
 
-        if type.nil?
-          print_red_alert "Provision type #{options[:provisionType]} not found"
-          exit 1
-        end
-        params['provisionTypeId'] = type['id']
-      end
+    if !options[:provisionType].nil?
+      type = find_provision_type(options[:provisionType])
 
-      @service_plans_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @service_plans_interface.dry.list(params)
-        return
+      if type.nil?
+        print_red_alert "Provision type #{options[:provisionType]} not found"
+        exit 1
       end
-      json_response = @service_plans_interface.list(params)
-
-      render_result = render_with_format(json_response, options, 'servicePlans')
-      return 0 if render_result
+      params['provisionTypeId'] = type['id']
+    end
 
+    @service_plans_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @service_plans_interface.dry.list(params)
+      return
+    end
+    json_response = @service_plans_interface.list(params)
+    plans = json_response['servicePlans']
+    render_response(json_response, options, 'servicePlans') do
       title = "Morpheus Service Plans"
       subtitles = []
       subtitles += parse_list_subtitles(options)
       print_h1 title, subtitles
 
-      plans = json_response['servicePlans']
       if plans.empty?
         print cyan,"No service plans found.",reset,"\n"
       else
@@ -91,18 +85,18 @@ class Morpheus::Cli::ServicePlanCommand
           }
         end
         columns = [
-            :id, :name, :type, :active, :cores, :memory, :clouds, :visibility, :tenants, :price_sets
+            :id, :name, :type, :active, :cores, :memory, :clouds, :visibility, :tenants, {"PRICE SETS" => :price_sets}
         ]
         columns.delete(:active) if !params['includeInactive']
-
         print as_pretty_table(rows, columns, options)
         print_results_pagination(json_response)
       end
       print reset,"\n"
-      return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+    end
+    if plans.empty?
+      return 1,  "0 plans found"
+    else
+      return 0, nil
     end
   end
 

data/lib/morpheus/cli/setup.rb

@@ -0,0 +1,392 @@
+require 'morpheus/cli/cli_command'
+
+# The morpheus setup command provides interaction with /api/setup
+# This is initializing a fresh remote appliance.
+# and checking the remote status and version.
+class Morpheus::Cli::Setup
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::RemoteHelper
+  
+  set_command_name :setup
+  
+  register_subcommands :init
+
+  # no authorization needed
+  def connect(options={})
+    @api_client = establish_remote_appliance_connection({:no_authorization => true, :skip_login => true}.merge(options))
+    @setup_interface = @api_client.setup
+  end
+
+  def handle(args)
+    #handle_subcommand(args)
+    init(args)
+  end
+
+  # this is a wizard that walks through the /api/setup controller
+  # it only needs to be used once to initialize a new appliance
+  # def setup(args)
+  def init(args)
+    params, payload = {}, {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do|opts|
+      #opts.banner = subcommand_usage()
+      opts.banner = usage
+      build_standard_add_options(opts, options, [:quiet, :auto_confirm])
+      opts.on('--hubmode MODE','--hubmode MODE', "Choose an option for hub registration possible values are login, register, skip.") do |val|
+        options[:hubmode] = val.to_s.downcase
+      end
+      opts.on('--force','--force', "Force setup, make api request even if setup is unavailable.") do
+        options[:force] = true
+      end
+      # todo: need all the other options here hub-username/password, account-name, username, password, email, etc.
+      opts.footer = <<-EOT
+Setup a fresh remote appliance, initializing it.
+First, this checks if setup is available, and returns an error if not.
+Then it prompts to create the master tenant and admin user.
+If Morpheus Hub registration is enabled, you may login or register to retrieve a license key,
+or you can pass `--hubmode skip`.
+This is only available on a new, freshly installed remote appliance,
+and it may only be executed successfully one time.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, count:0, optparse:optparse)
+    connect(options)
+    exit_code, err = 0, nil
+    # construct payload
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!(parse_passed_options(options))
+    else
+      payload.deep_merge!(parse_passed_options(options))
+
+      # @setup_interface = Morpheus::SetupInterface.new({url:@appliance_url,access_token:@access_token})
+      appliance_status_json = nil
+      begin
+        appliance_status_json = @setup_interface.get()
+      rescue RestClient::Exception => e
+        # pre 4.2.1 api would return HTTP 400 here, but with setupNeeded=false
+        # so fallback to the old /api/setup/check
+        # this could be in the interface itself..
+        if e.response.code == 400
+          Morpheus::Logging::DarkPrinter.puts "HTTP 400 from /api/setup, falling back to older /api/setup/check" if Morpheus::Logging.debug?
+          begin
+            appliance_status_json = @setup_interface.check()
+          rescue RestClient::Exception => e2
+            # err = e2.message || "Bad Request"
+            begin
+              appliance_status_json = JSON.parse(e2.response.to_s)
+            rescue TypeError, JSON::ParserError => ex
+              #puts "Failed to parse error response as json: #{ex}"
+            end
+          end
+        end
+      end
+
+      # my_terminal.execute("setup needed?")
+      # theres a bug here with --remote-url :status == "unknown"
+      # but hey, we got json back, so set status to "ready"
+      remote_status_string = format_appliance_status(@remote_appliance, cyan)
+      if appliance_status_json && appliance_status_json['setupNeeded'] == true
+        # ok, setupNeeded
+        # print_error cyan,"Setup is needed, status is #{remote_status_string}",reset,"\n"
+      else
+        if options[:force] != true
+          print_error cyan,"Setup unavailable, status is #{remote_status_string}",reset,"\n"
+          #print_error red, "#{appliance_status_json['msg']}\n", reset
+          return 1, "already setup"
+        end
+      end
+
+      # retrieved hub.enabled and hub.url 
+      hub_settings = appliance_status_json['hubSettings'] || appliance_status_json['hub'] || {}
+
+      # store login/registration info in here, for prompt default values
+      hub_info = nil
+      print cyan
+      print_h2 "Remote Setup | #{display_appliance(@appliance_name, @appliance_url)}"
+      
+      print cyan
+      puts "It looks like you are the first one here, so let's begin."
+      print reset, "\n"
+      # print "\n"
+      unless Morpheus::Cli::OptionTypes.confirm("Would you like to setup and initialize the remote appliance now?", options)  
+        return 9, "aborted command"
+      end
+      print "\n"
+      hubmode = nil
+      hub_init_payload = nil # gets included as payload for hub scoped like hub.email
+      if hub_settings['enabled']
+
+        # Hub Registration
+          hub_action_dropdown = [
+            {'name' => 'Login to existing hub account', 'value' => 'login', 'isDefault' => true}, 
+            {'name' => 'Register a new hub account', 'value' => 'register'}, 
+            {'name' => 'Skip this step and manually install a license later.', 'value' => 'skip'},
+            {'name' => 'Abort', 'value' => 'abort'}
+          ]
+          
+
+        print cyan
+        puts "Morpheus Hub registration is enabled for your appliance."
+        puts "This step will connect to the Morpheus Hub at #{hub_settings['url']}"
+        puts "This is done to retrieve and install the license key for your appliance."
+        puts "You have several options for how to proceed:"
+        hub_action_dropdown.each_with_index do |hub_action, idx|
+          puts "#{idx+1}. #{hub_action['name']} [#{hub_action['value']}]"
+        end
+        print "\n", reset
+
+        while hubmode == nil do
+          
+          options[:options]['hubmode'] = options[:hubmode] if options.key?(:hubmode)
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'hubmode', 'fieldLabel' => 'Choose Hub Mode', 'type' => 'select', 'selectOptions' => hub_action_dropdown, 'required' => true, 'defaultValue' => 'login'}], options[:options])
+          hubmode = v_prompt['hubmode']
+
+          if hubmode == 'login'
+
+            # print cyan
+            # puts "MORPHEUS HUB #{hub_settings['url']}"
+            # puts "The Command Center for DevOps"
+            # print reset
+
+            # Hub Login
+            print_h2 "Morpheus Hub Login @ #{hub_settings['url']}", options
+            hub_login_option_types = [
+              {'fieldContext' => 'hub', 'fieldName' => 'email', 'fieldLabel' => 'Email', 'type' => 'text', 'required' => true, 'description' => 'Email Address of existing Morpheus Hub user to link with.'},
+              {'fieldContext' => 'hub', 'fieldName' => 'password', 'fieldLabel' => 'Password', 'type' => 'password', 'required' => true, 'description' => 'Password of existing Morpheus Hub user.'},
+            ]
+            v_prompt = Morpheus::Cli::OptionTypes.prompt(hub_login_option_types, options[:options])
+            hub_login_payload = v_prompt['hub']
+            hub_login_response = nil
+            begin
+              hub_login_response = @setup_interface.hub_login(hub_login_payload)
+              hub_init_payload = hub_login_payload
+              hub_info = {'email' => hub_login_payload['email'], 'password' => hub_login_payload['password'] }
+              hub_info.deep_merge!(hub_login_response['data']['info']) if (hub_login_response['data'] && hub_login_response['data']['info'])
+              hub_info.deep_merge!(hub_login_response['hub']) if hub_login_response['hub'].is_a?(Hash)
+              print_green_success "Logged into Morpheus Hub as #{hub_info['email']}"
+            rescue RestClient::Exception => e
+              hub_login_response = parse_rest_exception(e)
+              error_msg = hub_login_response["msg"] || "Hub login failed."
+              print_error red,error_msg,reset,"\n"
+              hubmode = nil
+              #print_rest_exception(e, options)
+              #exit 1
+            end
+            
+            # DEBUG
+            if options[:debug] && hub_login_response
+              print_h2 "JSON response for hub login"
+              Morpheus::Logging::DarkPrinter.puts as_json(hub_login_response)
+            end
+
+          elsif hubmode == 'register'
+            # Hub Registration
+            print_h2 "Morpheus Hub Registration", options
+            hub_register_option_types = [
+              {'fieldContext' => 'hub', 'fieldName' => 'companyName', 'fieldLabel' => 'Company Name', 'type' => 'text', 'required' => true, 'description' => 'Company Name of new Morpheus Hub account to be created.'},
+              {'fieldContext' => 'hub', 'fieldName' => 'firstName', 'fieldLabel' => 'First Name', 'type' => 'text', 'required' => true, 'description' => 'First Name of new Morpheus Hub user.'},
+              {'fieldContext' => 'hub', 'fieldName' => 'lastName', 'fieldLabel' => 'Last Name', 'type' => 'text', 'required' => true, 'description' => 'Last Name of new Morpheus Hub user.'},
+              {'fieldContext' => 'hub', 'fieldName' => 'email', 'fieldLabel' => 'Email', 'type' => 'text', 'required' => true, 'description' => 'Email Address of new Morpheus Hub user.'}
+            ]
+            v_prompt = Morpheus::Cli::OptionTypes.prompt(hub_register_option_types, options[:options])
+            hub_register_payload = v_prompt['hub']
+
+            # Password prompt with re-prompting if no match
+            need_password = true
+            if options[:no_prompt]
+              if options[:options]['hub'] && options[:options]['hub']['password']
+                options[:options]['hub']['confirmPassword'] = options[:options]['hub']['password']
+              end
+            end
+            while need_password do
+              password_option_types = [
+                {'fieldContext' => 'hub', 'fieldName' => 'password', 'fieldLabel' => 'Create Password', 'type' => 'password', 'required' => true, 'description' => 'Confirm password of new Morpheus Hub user.'},
+                {'fieldContext' => 'hub', 'fieldName' => 'confirmPassword', 'fieldLabel' => 'Confirm Password', 'type' => 'password', 'required' => true, 'description' => 'Confirm password of new Morpheus Hub user.'}
+              ]
+              v_prompt = Morpheus::Cli::OptionTypes.prompt(password_option_types, options[:options])
+              if v_prompt['hub']['password'] == v_prompt['hub']['confirmPassword']
+                hub_register_payload.deep_merge!(v_prompt['hub'])
+                need_password = false
+              else
+                print_error red, "Password confirmation does not match. Re-enter your new password.", reset, "\n"
+              end
+            end
+
+            begin
+              hub_register_response = @setup_interface.hub_register(hub_register_payload)
+              hub_init_payload = hub_register_payload
+              hub_info = {'email' => hub_register_payload['email'], 'password' => hub_register_payload['password'] }
+              hub_info.deep_merge!(hub_register_payload)
+              hub_info.deep_merge!(hub_register_response['data']['info']) if (hub_register_response['data'] && hub_register_response['data']['info'])
+              hub_info.deep_merge!(hub_register_response['hub']) if hub_register_response['hub'].is_a?(Hash)
+              print_green_success "Registered with Morpheus Hub as #{hub_info['email']}"
+              # uh ok so that means the init() request can use login
+              # this avoid duplicate email error
+              # but it can also just omit hubMode from the init() payload to achieve the same thing.
+              # hubmode = nil
+            rescue RestClient::Exception => e
+              hub_register_response = parse_rest_exception(e)
+              error_msg = hub_register_response["msg"] || "Hub Registration failed."
+              print_error red,error_msg,reset,"\n"
+              hubmode = nil
+              #print_rest_exception(e, options)
+              #exit 1
+            end
+            
+            # DEBUG
+            if options[:debug] && hub_register_response
+              print_h2 "JSON response for hub registration"
+              Morpheus::Logging::DarkPrinter.puts as_json(hub_register_response)
+            end
+            
+          elsif hubmode == 'skip'
+            print cyan,"Skipping hub registraton for now...",reset,"\n"
+            # puts "You may enter a license key later."
+          elsif hubmode == 'abort'
+            return 9, "aborted command"
+          else
+            hubmode = nil
+          end
+        end
+      end
+
+      # ok, we're done with the hub.
+      # now build the payload for POST /api/setup/init
+
+      payload = {}
+      # payload.deep_merge!(params)
+
+      # print cyan
+      #print_h1 "Morpheus Appliance Setup", [], options
+      #print cyan
+      #puts "Initializing remote appliance at URL: #{@appliance_url}"
+
+      # Master Account
+      print_h2 "Create Master Tenant", options
+      account_option_types = [
+        {'fieldName' => 'accountName', 'fieldLabel' => 'Master Tenant Name', 'type' => 'text', 'required' => true, 'defaultValue' => (hub_info ? hub_info['companyName'] : nil), 'description' => 'A unique name for the Master Tenant (account).'},
+      ]
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(account_option_types, options[:options])
+      payload.merge!(v_prompt)
+
+      # Master User
+      print_h2 "Create Master User", options
+      user_option_types = [
+        {'fieldName' => 'firstName', 'fieldLabel' => 'First Name', 'type' => 'text', 'required' => false, 'defaultValue' => (hub_info ? hub_info['firstName'] : nil), 'description' => 'First name of the user.'},
+        {'fieldName' => 'lastName', 'fieldLabel' => 'Last Name', 'type' => 'text', 'required' => false, 'defaultValue' => (hub_info ? hub_info['lastName'] : nil), 'description' => 'Last name of the user.'},
+        {'fieldName' => 'email', 'fieldLabel' => 'Email', 'type' => 'text', 'required' => true, 'defaultValue' => (hub_info ? hub_info['email'] : nil), 'description' => 'A unique email address for the user.'},
+        {'fieldName' => 'username', 'fieldLabel' => 'Username', 'type' => 'text', 'required' => true, 'description' => 'A unique username for the master user.'}
+      ]
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(user_option_types, options[:options])
+      payload.merge!(v_prompt)
+
+      # Password prompt with re-prompting if no match
+      need_password = true
+      if options[:no_prompt]
+        options[:options]['confirmPassword'] = payload['password']
+        payload['confirmPassword'] = payload['password'] if payload['password']
+      end
+      while need_password do
+        password_option_types = [
+          {'fieldName' => 'password', 'fieldLabel' => 'Create Password', 'type' => 'password', 'required' => true, 'description' => 'Create a new password for the user.'},
+          {'fieldName' => 'confirmPassword', 'fieldLabel' => 'Confirm Password', 'type' => 'password', 'required' => true, 'description' => 'Confirm the new password for the user.'},
+        ]
+        password_prompt = Morpheus::Cli::OptionTypes.prompt(password_option_types, options[:options])
+        if password_prompt['password'] == password_prompt['confirmPassword']
+          payload['password'] = password_prompt['password']
+          need_password = false
+        else
+          print_error red, "Password confirmation does not match. Re-enter your new password.", reset, "\n"
+        end
+      end
+
+      # Appliance Settings
+      default_appliance_url = appliance_status_json['applianceUrl']
+      if default_appliance_url && default_appliance_url.include?('10.0.2.2:8080') # ignore this default value.
+        default_appliance_url = @appliance_url
+      end
+      default_appliance_name = appliance_status_json['applianceName']
+      if default_appliance_name.nil?
+        default_appliance_name = @appliance_name
+      end
+      print_h2 "Appliance Settings", options
+      extra_option_types = [
+        {'fieldName' => 'applianceName', 'fieldLabel' => 'Appliance Name', 'type' => 'text', 'required' => true, 'defaultValue' => default_appliance_name, 'description' => 'A name for identifying your morpheus appliance.'},
+        {'fieldName' => 'applianceUrl', 'fieldLabel' => 'Appliance URL', 'type' => 'text', 'required' => true, 'defaultValue' => default_appliance_url, 'description' => 'Appliance URL. Can be used for integrations and callbacks.'},
+        {'fieldName' => 'backups', 'fieldLabel' => 'Enable Backups', 'type' => 'checkbox', 'required' => false, 'defaultValue' => 'off', 'description' => 'Backups. Default is off. This means backups are created automatically during provisioning.'},
+        {'fieldName' => 'monitoring', 'fieldLabel' => 'Enable Monitoring', 'type' => 'checkbox', 'required' => false, 'defaultValue' => 'on', 'description' => 'Enable Monitoring. This means checks are created automatically during provisioning.'},
+        {'fieldName' => 'logs', 'fieldLabel' => 'Enable Logs', 'type' => 'checkbox', 'required' => false, 'defaultValue' => 'on', 'description' => 'Enable Logs. This means container logs are collected.'}
+      ]
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(extra_option_types, options[:options])
+      payload.merge!(v_prompt)
+      
+      # include hubmode and hub params for login or registration
+      # actually we remove hubMode because it has already been setup, probably just now,
+      # and the init() request will just used the same creds instead of 
+      # reauthenticated/registering with the hub
+      if hubmode
+        payload['hubMode'] = hubmode
+      end
+      if hub_init_payload
+        payload['hub'] = hub_init_payload
+      end
+      if hubmode == 'register' || hubmode == 'login'
+        payload.delete('hubMode')
+        payload.delete('hub')
+      end
+
+    end
+      
+    # ok, make the api request
+    @setup_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @setup_interface.dry.init(payload)
+      return
+    end
+
+    json_response = @setup_interface.init(payload)
+
+    render_result = render_with_format(json_response, options)
+    return 0 if render_result
+
+    if options[:json]
+      print JSON.pretty_generate(json_response)
+      print "\n"
+      return
+    end
+    print "\n"
+    print green,"Setup complete for remote #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+    #print cyan, "You may now login with the command `login`.\n"
+    # uh, just use Credentials.login(username, password, {save: true})
+    cmd_res = Morpheus::Cli::Login.new.login(['--username', payload['username'], '--password', payload['password'], '-q'] + (options[:remote] ? ["-r",options[:remote]] : []))
+    # print "\n"
+    print cyan, "You are now logged in as the System Admin #{payload['username']}.\n"
+    print reset
+    #print "\n"
+
+    if hubmode == 'skip'
+      if ::Morpheus::Cli::OptionTypes::confirm("Would you like to install your License Key now?", options.merge({:default => true}))
+        cmd_res = Morpheus::Cli::License.new.apply([] + (options[:remote] ? ["-r",options[:remote]] : []))
+        # license_is_valid = cmd_res != false
+      end
+    end
+
+    if ::Morpheus::Cli::OptionTypes::confirm("Would you like to create the first group now?", options.merge({:default => true}))
+      cmd_res = Morpheus::Cli::Groups.new.add(['--use'] + (options[:remote] ? ["-r",options[:remote]] : []))
+
+      #print "\n"
+
+      # if cmd_res !=
+        if ::Morpheus::Cli::OptionTypes::confirm("Would you like to create the first cloud now?", options.merge({:default => true}))
+          cmd_res = Morpheus::Cli::Clouds.new.add([] + (options[:remote] ? ["-r",options[:remote]] : []))
+          #print "\n"
+        end
+      # end
+    end
+    print "\n",reset
+    return exit_code, err
+  end
+ 
+end