morpheus-cli 4.2.22 → 5.2.1

data/lib/morpheus/cli/groups.rb

@@ -52,7 +52,7 @@ class Morpheus::Cli::Groups
     end
     json_response = @groups_interface.list(params)
     exit_code, err = 0, nil
-    render_response(json_response, options) do
+    render_response(json_response, options, "groups") do
       groups = json_response['groups']
       subtitles = []
       subtitles += parse_list_subtitles(options)

data/lib/morpheus/cli/health_command.rb

@@ -30,6 +30,7 @@ class Morpheus::Cli::HealthCommand
       opts.on('-a', '--all', "Display all details: CPU, Memory, Database, etc." ) do
         options[:details] = true
         options[:show_cpu] = true
+        options[:show_threads] = true
         options[:show_memory] = true
         options[:show_database] = true
         options[:show_elastic] = true
@@ -47,6 +48,9 @@ class Morpheus::Cli::HealthCommand
       opts.on('--cpu', "Display CPU details" ) do
         options[:show_cpu] = true
       end
+      opts.on('--threads', "Display Thread details" ) do
+        options[:show_threads] = true
+      end
       opts.on('--memory', "Display Memory details" ) do
         options[:show_memory] = true
       end
@@ -184,6 +188,59 @@ class Morpheus::Cli::HealthCommand
         end
       end
 
+      # Threads ()
+      if options[:show_threads]
+        print_h2 "Threads", options
+        if health['threads'].nil?
+          print yellow,"No thread information returned.",reset,"\n\n"
+        else
+          print cyan
+
+          thread_summary_columns = {
+            "Thread Count" => lambda {|it| it['totalThreads'].size rescue '' },
+            "Busy Threads" => lambda {|it| it['busyThreads'].size rescue '' },
+            "Running Threads" => lambda {|it| it['runningThreads'].size rescue '' },
+            "Blocked Threads" => lambda {|it| it['blockedThreads'].size rescue '' },
+          }
+          print_description_list(thread_summary_columns, health['threads'], options)
+
+
+          thread_columns = [
+            {"Name".upcase => lambda {|it| it['name']} },
+            {"Status".upcase => lambda {|it| 
+              # hrmm
+              status_string = (it['status'] || it['state']).to_s.downcase
+              status_color = cyan
+              # if status_string.include?('waiting')
+              #   status_color = yellow
+              # end
+              "#{status_color}#{status_string.upcase}#{cyan}"
+            } },
+            # {"CPU Time" => lambda {|it| it['cpuTime'].to_s } },
+            # {"CPU Time" => lambda {|it| format_human_duration(it['cpuTime'].to_f / 1000) rescue '' } },
+            {"CPU Percent" => lambda {|it| it['cpuPercent'].to_i.to_s + '%' } }
+          ]
+
+          if health['threads']['busyThreads'] && health['threads']['busyThreads'].size > 0
+            print_h2 "Busy Threads"
+            print cyan
+            print as_pretty_table(health['threads']['busyThreads'], thread_columns, options)
+          end
+
+          if health['threads']['runningThreads'] && health['threads']['runningThreads'].size > 0
+            print_h2 "Running Threads"
+            print cyan
+            print as_pretty_table(health['threads']['runningThreads'], thread_columns, options)
+          end
+
+          if health['threads']['blockedThreads'] && health['threads']['blockedThreads'].size > 0
+            print_h2 "Blocked Threads"
+            print cyan
+            print as_pretty_table(health['threads']['blockedThreads'], thread_columns, options)
+          end
+        end
+      end
+
       # Memory
       if options[:show_memory]
         if health['memory'].nil?
@@ -475,8 +532,8 @@ class Morpheus::Cli::HealthCommand
       opts.footer = "List health logs. These are the logs of the morpheus appliance itself."
     end
     optparse.parse!(args)
-    if args.count != 0
-      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
+    if args.count > 0
+      options[:phrase] = args.join(" ")
     end
     connect(options)
     begin

data/lib/morpheus/cli/hosts.rb

@@ -16,10 +16,11 @@ class Morpheus::Cli::Hosts
   include Morpheus::Cli::LogsHelper
   set_command_name :hosts
   set_command_description "View and manage hosts (servers)."
-  register_subcommands :list, :count, :get, :view, :stats, :add, :update, :remove, :logs, :start, :stop, :resize, :run_workflow, :make_managed, :upgrade_agent
-  register_subcommands :'types' => :list_types
-  register_subcommands :exec => :execution_request
-  register_subcommands :wiki, :update_wiki
+  register_subcommands :list, :count, :get, :view, :stats, :add, :update, :remove, :logs, :start, :stop, :resize, 
+                       :run_workflow, :make_managed, :upgrade_agent, :snapshots, :software,
+                       {:'types' => :list_types},
+                       {:exec => :execution_request},
+                       :wiki, :update_wiki
   alias_subcommand :details, :get
   set_default_subcommand :list
 
@@ -53,9 +54,6 @@ class Morpheus::Cli::Hosts
     params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage()
-      opts.on( '-a', '--account ACCOUNT', "Account Name or ID" ) do |val|
-        options[:account] = val
-      end
       opts.on( '-g', '--group GROUP', "Group Name or ID" ) do |val|
         options[:group] = val
       end
@@ -81,6 +79,17 @@ class Morpheus::Cli::Hosts
         # params[:clusterId] = val
         options[:cluster] = val
       end
+      opts.on( '--plan NAME', String, "Filter by Plan name(s)" ) do |val|
+        # commas used in names a lot so use --plan one --plan two
+        params['plan'] ||= []
+        params['plan'] << val
+      end
+      opts.on( '--plan-id ID', String, "Filter by Plan id(s)" ) do |val|
+        params['planId'] = parse_id_list(val)
+      end
+      opts.on( '--plan-code CODE', String, "Filter by Plan code(s)" ) do |val|
+        params['planCode'] = parse_id_list(val)
+      end
       opts.on( '', '--vm', "Show only virtual machines" ) do |val|
         params[:vm] = true
       end
@@ -105,8 +114,16 @@ class Morpheus::Cli::Hosts
       opts.on( '--created-by USER', "Created By User Username or ID" ) do |val|
         options[:created_by] = val
       end
-      opts.on('--details', "Display more details: memory and storage usage used / max values." ) do
-        options[:details] = true
+      opts.on( '--tenant TENANT', "Tenant Name or ID" ) do |val|
+        options[:account] = val
+      end
+      opts.on('--tags Name=Value',String, "Filter by tags.") do |val|
+        val.split(",").each do |value_pair|
+          k,v = value_pair.strip.split("=")
+          options[:tags] ||= {}
+          options[:tags][k] ||= []
+          options[:tags][k] << (v || '')
+        end
       end
       opts.on('--tag-compliant', "Displays only servers that are valid according to applied tag policies. Does not show servers that do not have tag policies." ) do
         params[:tagCompliant] = true
@@ -114,11 +131,21 @@ class Morpheus::Cli::Hosts
       opts.on('--non-tag-compliant', "Displays only servers with tag compliance warnings." ) do
         params[:tagCompliant] = false
       end
-      build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.on('--stats', "Display values for memory and storage usage used / max values." ) do
+        options[:stats] = true
+      end
+      opts.on('-a', '--details', "Display all details: hostname, private ip, plan, stats, etc." ) do
+        options[:details] = true
+      end
+      build_standard_list_options(opts, options)
       opts.footer = "List hosts."
     end
     optparse.parse!(args)
     connect(options)
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
     begin
       params.merge!(parse_list_options(options))
       account = nil
@@ -159,6 +186,11 @@ class Morpheus::Cli::Hosts
           params['clusterId'] = cluster['id']
         end
       end
+      if options[:tags] && !options[:tags].empty?
+        options[:tags].each do |k,v|
+          params['tags.' + k] = v
+        end
+      end
 
       @servers_interface.setopts(options)
       if options[:dry_run]
@@ -190,6 +222,9 @@ class Morpheus::Cli::Hosts
         multi_tenant = json_response['multiTenant'] == true
         title = "Morpheus Hosts"
         subtitles = []
+        if account
+          subtitles << "Tenant: #{account['name']}".strip
+        end
         if group
           subtitles << "Group: #{group['name']}".strip
         end
@@ -230,7 +265,7 @@ class Morpheus::Cli::Hosts
             cpu_usage_str = !stats ? "" : generate_usage_bar((stats['usedCpu'] || stats['cpuUsage']).to_f, 100, {max_bars: 10})
             memory_usage_str = !stats ? "" : generate_usage_bar(stats['usedMemory'], stats['maxMemory'], {max_bars: 10})
             storage_usage_str = !stats ? "" : generate_usage_bar(stats['usedStorage'], stats['maxStorage'], {max_bars: 10})
-            if options[:details]
+            if options[:details] || options[:stats]
               if stats['maxMemory'] && stats['maxMemory'].to_i != 0
                 memory_usage_str = memory_usage_str + cyan + format_bytes_short(stats['usedMemory']).strip.rjust(8, ' ')  + " / " + format_bytes_short(stats['maxMemory']).strip
               end
@@ -240,31 +275,76 @@ class Morpheus::Cli::Hosts
             end
             row = {
               id: server['id'],
-              tenant: server['account'] ? server['account']['name'] : server['accountId'],
               name: server['name'],
+              external_name: server['externalName'],
+              hostname: server['hostname'],
               platform: server['serverOs'] ? server['serverOs']['name'].upcase : 'N/A',
-              cloud: server['zone'] ? server['zone']['name'] : '',
               type: server['computeServerType'] ? server['computeServerType']['name'] : 'unmanaged',
+              tenant: server['account'] ? server['account']['name'] : server['accountId'],
+              owner: server['owner'] ? server['owner']['username'] : server['owner'],
+              cloud: server['zone'] ? server['zone']['name'] : '',
+              plan: server['plan'] ? server['plan']['name'] : '',
+              ip: server['externalIp'],
+              internal_ip: server['internalIp'],
               nodes: server['containers'] ? server['containers'].size : '',
-              status: format_server_status(server, cyan),
+              # status: format_server_status(server, cyan),
+              status: (options[:details]||options[:all_fields]) ? format_server_status(server, cyan) : format_server_status_friendly(server, cyan),
               power: format_server_power_state(server, cyan),
               cpu: cpu_usage_str + cyan,
               memory: memory_usage_str + cyan,
-              storage: storage_usage_str + cyan
+              storage: storage_usage_str + cyan,
+              created: format_local_dt(server['dateCreated']),
+              updated: format_local_dt(server['lastUpdated']),
             }
             row
           }
-          columns = [:id, :name, :type, :cloud, :nodes, :status, :power]
-          if multi_tenant
-            columns.insert(4, :tenant)
+          # columns = [:id, :name, :type, :cloud, :ip, :internal_ip, :nodes, :status, :power]
+          columns = {
+            "ID" => :id,
+            "Name" => :name,
+            "External Name" => :external_name,
+            "Hostname" => :hostname,
+            "Type" => :type,
+            "Owner" => :owner,
+            "Tenant" => :tenant,
+            "Cloud" => :cloud,
+            "Plan" => :plan,
+            "IP" => :ip,
+            "Private IP" => :internal_ip,
+            "Nodes" => :nodes,
+            "Status" => :status,
+            "Power" => :power,
+            "CPU" => :cpu,
+            "Memory" => :memory,
+            "Storage" => :storage,
+            "Created" => :created,
+            "Updated" => :updated,
+          }
+          if options[:details] != true
+            columns.delete("External Name")
+            columns.delete("Hostname")
+            columns.delete("Plan")
+            columns.delete("Private IP")
+            columns.delete("Owner")
+            columns.delete("Tenant")
+            columns.delete("Power")
+            columns.delete("Created")
+            columns.delete("Updated")
+          end
+          # hide External Name if there are none
+          if !servers.find {|it| it['externalName'] && it['externalName'] != it['name']}
+            columns.delete("External Name")
           end
-          columns += [:cpu, :memory, :storage]
-          # custom pretty table columns ...
-          if options[:include_fields]
-            columns = options[:include_fields]
+          if !multi_tenant
+            columns.delete("Tenant")
           end
+          # columns += [:cpu, :memory, :storage]
+          # # custom pretty table columns ...
+          # if options[:include_fields]
+          #   columns = options[:include_fields]
+          # end
           print cyan
-          print as_pretty_table(rows, columns, options)
+          print as_pretty_table(rows, columns.upcase_keys!, options)
           print reset
           print_results_pagination(json_response)
         end
@@ -281,7 +361,7 @@ class Morpheus::Cli::Hosts
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[options]")
-      opts.on( '-a', '--account ACCOUNT', "Account Name or ID" ) do |val|
+      opts.on( '--tenant TENANT', "Tenant Name or ID" ) do |val|
         options[:account] = val
       end
       opts.on( '-g', '--group GROUP', "Group Name or ID" ) do |val|
@@ -392,6 +472,9 @@ class Morpheus::Cli::Hosts
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[name]")
+      opts.on( nil, '--costs', "Display Cost and Price" ) do
+        options[:include_costs] = true
+      end
       opts.on('--refresh [SECONDS]', String, "Refresh until status is provisioned,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
         options[:refresh_until_status] ||= "provisioned,failed"
         if !val.to_s.empty?
@@ -447,28 +530,46 @@ class Morpheus::Cli::Hosts
         puts records_as_csv([json_response['server']], options)
         return 0
       end
-      server = json_response['server']
+      server = json_response['server'] || json_response['host'] || {}
       #stats = server['stats'] || json_response['stats'] || {}
       stats = json_response['stats'] || {}
+      tags = server['tags'] || server['metadata']
       title = "Host Details"
       print_h1 title, [], options
       print cyan
-      print_description_list({
+      server_columns = {
         "ID" => 'id',
         "Name" => 'name',
+        "Hostname" => 'hostname',
         "Description" => 'description',
-        "Account" => lambda {|it| it['account'] ? it['account']['name'] : '' },
+        "Tags" => lambda {|it| tags ? format_metadata(tags) : '' },
+        "Owner" => lambda {|it| it['owner'] ? it['owner']['username'] : '' },
+        "Tenant" => lambda {|it| it['account'] ? it['account']['name'] : '' },
         #"Group" => lambda {|it| it['group'] ? it['group']['name'] : '' },
         "Cloud" => lambda {|it| it['zone'] ? it['zone']['name'] : '' },
+        "IP" => lambda {|it| it['externalIp'] },
+        "Private IP" => lambda {|it| it['internalIp'] },
         "Type" => lambda {|it| it['computeServerType'] ? it['computeServerType']['name'] : 'unmanaged' },
         "Platform" => lambda {|it| it['serverOs'] ? it['serverOs']['name'].upcase : 'N/A' },
         "Plan" => lambda {|it| it['plan'] ? it['plan']['name'] : '' },
+        "Cost" => lambda {|it| it['hourlyCost'] ? format_money(it['hourlyCost'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
+        "Price" => lambda {|it| it['hourlyPrice'] ? format_money(it['hourlyPrice'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
         "Agent" => lambda {|it| it['agentInstalled'] ? "#{server['agentVersion'] || ''} updated at #{format_local_dt(server['lastAgentUpdate'])}" : '(not installed)' },
-        "Status" => lambda {|it| format_server_status(it) },
         "Nodes" => lambda {|it| it['containers'] ? it['containers'].size : 0 },
-        "Power" => lambda {|it| format_server_power_state(it) },
-      }, server)
-      
+        # "Status" => lambda {|it| format_server_status(it) },
+        # "Power" => lambda {|it| format_server_power_state(it) },
+        "Status" => lambda {|it| format_server_status_friendly(it) }, # combo
+      }
+      server_columns.delete("Hostname") if server['hostname'].to_s.empty? || server['hostname'] == server['name']
+      server_columns.delete("IP") if server['externalIp'].to_s.empty?
+      server_columns.delete("Private IP") if server['internalIp'].to_s.empty?
+      # server_columns.delete("Tenant") if multi_tenant != true
+      server_columns.delete("Cost") if server['hourlyCost'].to_f == 0
+      server_columns.delete("Price") if server['hourlyPrice'].to_f == 0 || server['hourlyPrice'] == server['hourlyCost']
+      server_columns.delete("Tags") if tags.nil? || tags.empty?
+
+      print_description_list(server_columns, server)
+
       if server['statusMessage']
         print_h2 "Status Message", options
         if server['status'] == 'failed'
@@ -485,6 +586,16 @@ class Morpheus::Cli::Hosts
 
       print_h2 "Host Usage", options
       print_stats_usage(stats)
+
+      if options[:include_costs]
+        print_h2 "Host Cost"
+        cost_columns = {
+          "Cost" => lambda {|it| it['hourlyCost'] ? format_money(it['hourlyCost'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
+          "Price" => lambda {|it| it['hourlyPrice'] ? format_money(it['hourlyPrice'], (it['currency'] || 'USD'), {sigdig:15}).to_s + ' per hour' : '' },
+        }
+        print_description_list(cost_columns, server)
+      end
+
       print reset, "\n"
 
 
@@ -882,6 +993,19 @@ class Morpheus::Cli::Hosts
       opts.on('--power-schedule-type ID', String, "Power Schedule Type ID") do |val|
         params['powerScheduleType'] = val == "null" ? nil : val
       end
+      opts.on('--tags LIST', String, "Tags in the format 'name:value, name:value'. This will add and remove tags.") do |val|
+        options[:tags] = val
+      end
+      opts.on('--metadata LIST', String, "Alias for --tags.") do |val|
+        options[:tags] = val
+      end
+      opts.add_hidden_option('--metadata')
+      opts.on('--add-tags TAGS', String, "Add Tags in the format 'name:value, name:value'. This will only add/update tags.") do |val|
+        options[:add_tags] = val
+      end
+      opts.on('--remove-tags TAGS', String, "Remove Tags in the format 'name, name:value'. This removes tags, the :value component is optional and must match if passed.") do |val|
+        options[:remove_tags] = val
+      end
       # opts.on('--created-by ID', String, "Created By User ID") do |val|
       #   params['createdById'] = val
       # end
@@ -900,6 +1024,18 @@ class Morpheus::Cli::Hosts
       new_group = nil
       passed_options = options[:options] ? options[:options].reject {|k,v| k.is_a?(Symbol) } : {}
       params.deep_merge!(passed_options) unless passed_options.empty?
+      # metadata tags
+      if options[:tags]
+        params['tags'] = parse_metadata(options[:tags])
+      else
+        # params['tags'] = prompt_metadata(options)
+      end
+      if options[:add_tags]
+        params['addTags'] = parse_metadata(options[:add_tags])
+      end
+      if options[:remove_tags]
+        params['removeTags'] = parse_metadata(options[:remove_tags])
+      end
       payload = nil
       if options[:payload]
         payload = options[:payload]
@@ -1781,6 +1917,103 @@ class Morpheus::Cli::Hosts
     end
   end
 
+  def snapshots(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[host]")
+      # no pagination yet
+      # build_standard_list_options(opts, options)
+      build_standard_get_options(opts, options)
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    begin
+      server = find_host_by_name_or_id(args[0])
+      return 1 if server.nil?
+      params = {}
+      @servers_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @servers_interface.dry.snapshots(server['id'], params)
+        return
+      end
+      json_response = @servers_interface.snapshots(server['id'], params)
+      snapshots = json_response['snapshots']      
+      render_response(json_response, options, 'snapshots') do
+        print_h1 "Snapshots: #{server['name']}", [], options
+        if snapshots.empty?
+          print cyan,"No snapshots found",reset,"\n"
+        else
+          snapshot_column_definitions = {
+            "ID" => lambda {|it| it['id'] },
+            "Name" => lambda {|it| it['name'] },
+            "Description" => lambda {|it| it['description'] },
+            # "Type" => lambda {|it| it['snapshotType'] },
+            "Date Created" => lambda {|it| format_local_dt(it['snapshotCreated']) },
+            "Status" => lambda {|it| format_snapshot_status(it) }
+          }
+          print cyan
+          print as_pretty_table(snapshots, snapshot_column_definitions.upcase_keys!, options)
+          print_results_pagination({size: snapshots.size, total: snapshots.size})
+        end
+        print reset, "\n"
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+  def software(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[host]")
+      build_standard_list_options(opts, options)
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    begin
+      server = find_host_by_name_or_id(args[0])
+      return 1 if server.nil?
+      params = {}
+      params.merge!(parse_list_options(options))
+      @servers_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @servers_interface.dry.software(server['id'], params)
+        return
+      end
+      json_response = @servers_interface.software(server['id'], params)
+      software = json_response['software']
+      render_response(json_response, options, 'software') do
+        print_h1 "Software: #{server['name']}", [], options
+        if software.empty?
+          print cyan,"No software found",reset,"\n"
+        else
+          software_column_definitions = {
+            # "ID" => lambda {|it| it['id'] },
+            "Name" => lambda {|it| it['name'] },
+            "Version" => lambda {|it| it['packageVersion'] },
+            "Publisher" => lambda {|it| it['packagePublisher'] },
+            # "Release" => lambda {|it| it['packageRelease'] },
+            # "Type" => lambda {|it| it['packageType'] },
+            # "Architecture" => lambda {|it| it['architecture'] },
+            # "Install Date" => lambda {|it| format_local_dt(it['installDate']) },
+          }
+          print cyan
+          print as_pretty_table(software, software_column_definitions.upcase_keys!, options)
+          print_results_pagination({size: software.size, total: software.size})
+        end
+        print reset, "\n"
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
   private
 
   def find_host_by_id(id)
@@ -1897,16 +2130,43 @@ class Morpheus::Cli::Hosts
 
   def format_server_status(server, return_color=cyan)
     out = ""
-    status_string = server['status']
-    # todo: colorize, upcase?
-    out << status_string.to_s
+    status_string = server['status'].to_s.downcase
+    if status_string == 'provisioned'
+      out = "#{cyan}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'provisioning'
+      out = "#{cyan}#{status_string.upcase}#{cyan}"
+    elsif status_string == 'failed' or status_string == 'error'
+      out = "#{red}#{status_string.upcase}#{return_color}"
+    else
+      out = "#{yellow}#{status_string.upcase}#{return_color}"
+    end
     out
   end
 
+  def format_server_status_friendly(server, return_color=cyan)
+    out = ""
+    status_string = server['status'].to_s.downcase
+    if status_string == 'provisioned'
+      # out = format_server_power_state(server, return_color)
+      # make it looks like format_instance_status
+      if server['powerState'] == 'on'
+        out << "#{green}RUNNING#{return_color}"
+      elsif server['powerState'] == 'off'
+        out << "#{red}STOPPED#{return_color}"
+      else
+        out << "#{white}#{server['powerState'].to_s.upcase}#{return_color}"
+      end
+    else
+      out = format_server_status(server, return_color)
+    end
+    out
+  end
+  
+
    def make_managed_option_types(connected=true)
     [
       #{'fieldName' => 'account', 'fieldLabel' => 'Account', 'type' => 'select', 'optionSource' => 'accounts', 'required' => true},
-      {'fieldName' => 'sshUsername', 'fieldLabel' => 'SSH Username', 'type' => 'text', 'required' => true},
+      {'fieldName' => 'sshUsername', 'fieldLabel' => 'SSH Username', 'type' => 'text'},
       {'fieldName' => 'sshPassword', 'fieldLabel' => 'SSH Password', 'type' => 'password', 'required' => false},
       {'fieldName' => 'serverOs', 'fieldLabel' => 'OS Type', 'type' => 'select', 'optionSource' => 'osTypes', 'required' => false},
     ]