morpheus-cli 5.3.0.3 → 5.3.1

data/lib/morpheus/cli/cli_command.rb

@@ -204,7 +204,10 @@ module Morpheus
           # elsif option['type'] == 'select'
           end
           full_option = "--#{full_field_name} #{value_label}"
-          shorthand_option = option_type['shorthand']
+          # switch is an alias for the full option name, fieldName is the default
+          if option_type['switch']
+            full_option = "--#{option_type['switch']} #{value_label}"
+          end
           arg1, arg2 = full_option, String
           if option_type['shorthand']
             arg1, arg2 = full_option, option_type['shorthand']
@@ -243,7 +246,7 @@ module Morpheus
       ## the standard options for a command that makes api requests (most of them)
 
       def build_standard_get_options(opts, options, includes=[], excludes=[])
-        build_common_options(opts, options, includes + [:query, :json, :yaml, :csv, :fields, :quiet, :dry_run, :remote], excludes)
+        build_common_options(opts, options, includes + [:query, :json, :yaml, :csv, :fields, :select, :delim, :quiet, :dry_run, :remote], excludes)
       end
 
       def build_standard_post_options(opts, options, includes=[], excludes=[])
@@ -688,36 +691,50 @@ module Morpheus
               options[:format] = :csv
               #options[:csv_delim] = options[:csv_delim] || ","
             end
-
+            # deprecated --csv-delim, use --delimiter instead
             opts.on('--csv-delim CHAR', String, "Delimiter for CSV Output values. Default: ','") do |val|
               options[:csv] = true
               options[:format] = :csv
               val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
               options[:csv_delim] = val
             end
+            opts.add_hidden_option('--csv-delim') if opts.is_a?(Morpheus::Cli::OptionParser)
 
+            # deprecated --csv-newline, use --newline instead
             opts.on('--csv-newline [CHAR]', String, "Delimiter for CSV Output rows. Default: '\\n'") do |val|
               options[:csv] = true
               options[:format] = :csv
               if val == "no" || val == "none"
                 options[:csv_newline] = ""
               else
-                val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
+                val = val.to_s.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
                 options[:csv_newline] = val
               end
             end
+            opts.add_hidden_option('--csv-newline') if opts.is_a?(Morpheus::Cli::OptionParser)
 
             opts.on(nil, '--csv-quotes', "Wrap CSV values with \". Default: false") do
               options[:csv] = true
               options[:format] = :csv
               options[:csv_quotes] = true
             end
+            opts.add_hidden_option('--csv-quotes') if opts.is_a?(Morpheus::Cli::OptionParser)
 
             opts.on(nil, '--csv-no-header', "Exclude header for CSV Output.") do
               options[:csv] = true
               options[:format] = :csv
               options[:csv_no_header] = true
             end
+            opts.add_hidden_option('--csv-no-header') if opts.is_a?(Morpheus::Cli::OptionParser)
+
+            opts.on(nil, '--quotes', "Wrap CSV values with \". Default: false") do
+              options[:csv_quotes] = true
+            end
+            opts.add_hidden_option('--csv-quotes') if opts.is_a?(Morpheus::Cli::OptionParser)
+
+            opts.on(nil, '--no-header', "Exclude header for CSV Output.") do
+              options[:csv_no_header] = true
+            end
 
           when :fields
             opts.on('-f', '--fields x,y,z', Array, "Filter Output to a limited set of fields. Default is all fields for json,csv,yaml.") do |val|
@@ -738,10 +755,35 @@ module Morpheus
             opts.on(nil, '--all-fields', "Show all fields present in the data.") do
               options[:all_fields] = true
             end
-            #opts.add_hidden_option('--all-fields') if opts.is_a?(Morpheus::Cli::OptionParser)
             opts.on(nil, '--wrap', "Wrap table columns instead hiding them when terminal is not wide enough.") do
               options[:wrap] = true
             end
+          when :select
+            #opts.add_hidden_option('--all-fields') if opts.is_a?(Morpheus::Cli::OptionParser)
+            opts.on('--select x,y,z', String, "Filter Output to just print the value(s) of specific fields.") do |val|
+              options[:select_fields] = val.split(',').collect {|r| r.strip}
+            end
+
+          when :delim
+            opts.on('--delimiter [CHAR]', String, "Delimiter for output values. Default: ',', use with --select and --csv") do |val|
+              options[:csv] = true
+              options[:format] = :csv
+              val = val.to_s
+              val = val.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
+              options[:delim] = val
+            end
+
+            opts.on('--newline [CHAR]', String, "Delimiter for output rows. Default: '\\n', use with --select and --csv") do |val|
+              options[:csv] = true
+              options[:format] = :csv
+              val = val.to_s
+              if val == "no" || val == "none"
+                options[:newline] = ""
+              else
+                val = val.to_s.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t") if val.include?("\\")
+                options[:newline] = val
+              end
+            end
           when :thin
             opts.on( '--thin', '--thin', "Format headers and columns with thin borders." ) do |val|
               options[:border_style] = :thin
@@ -1285,7 +1327,20 @@ module Morpheus
       # returns the string rendered, or nil if nothing was rendered.
       def render_response(json_response, options, object_key=nil, &block)
         output = nil
-        if options[:json]
+        if options[:select_fields]
+          row = object_key ? json_response[object_key] : json_response
+          row = [row].flatten()
+          if row.is_a?(Array)
+            output = [row].flatten.collect { |record| 
+              options[:select_fields].collect { |field| 
+                value = get_object_value(record, field)
+                value.is_a?(String) ? value : JSON.fast_generate(value)
+              }.join(options[:delim] || ",")
+            }.join(options[:newline] || "\n")
+          else
+            output = records_as_csv([row], options)
+          end
+        elsif options[:json]
           output = as_json(json_response, options, object_key)
         elsif options[:yaml]
           output = as_yaml(json_response, options, object_key)

data/lib/morpheus/cli/clouds.rb

@@ -313,6 +313,7 @@ class Morpheus::Cli::Clouds
         end
 
         all_option_types = add_cloud_option_types(cloud_type)
+
         params = Morpheus::Cli::OptionTypes.prompt(all_option_types, options[:options], @api_client, {zoneTypeId: cloud_type['id']})
         # some optionTypes have fieldContext='zone', so move those to the root level of the zone payload
         if params['zone'].is_a?(Hash)

data/lib/morpheus/cli/clusters.rb

@@ -515,7 +515,7 @@ class Morpheus::Cli::Clusters
         tags = options[:tags]
 
         if !tags && !options[:no_prompt]
-          tags = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'tags', 'type' => 'text', 'fieldLabel' => 'Resource Tags', 'required' => false, 'description' => 'Resource Tags.'}],options[:options],@api_client,{})['tags']
+          tags = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'tags', 'type' => 'text', 'fieldLabel' => 'Resource Labels', 'required' => false, 'description' => 'Resource Tags.'}],options[:options],@api_client,{})['tags']
         end
 
         server_payload['tags'] = tags if tags

data/lib/morpheus/cli/commands/standard/man_command.rb

@@ -341,12 +341,12 @@ You can use this to create isolated environments (sandboxes), within which to ex
 
 ```shell
 export MORPHEUS_CLI_HOME=~/morpheus_test
-morpheus remote add demo https://demo.mymorpheus.com --insecure
+morpheus remote add demo https://demo-morpheus --insecure
 morpheus instances list
 ```
 
 Morpheus saves the remote appliance information, including api access tokens, 
-to the $MORPHEUS_HOME_DIRECTORY. These files are saved with file permissions **6000**.
+to the CLI home directory. These files are saved with file permissions **6000**.
 So, only one system user should be allowed to execute morpheus with that home directory.
 See [Configuration](#Configuration) for more information on the files morpheus reads and writes.
 
@@ -363,10 +363,9 @@ The `appliances` YAML file contains a list of known appliances, keyed by name.
 Example:
 ```yaml
 :qa:
-  :host: https://qa.mymorpheus.com
-  :active: true
+  :host: https://qa-morpheus
 :production:
-  :host: https://mymorpheus.com
+  :host: https://production-morpheus
 ```
 
 ### credentials file

data/lib/morpheus/cli/hosts.rb

@@ -17,7 +17,7 @@ class Morpheus::Cli::Hosts
   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, :snapshots, :software,
+                       :run_workflow, :make_managed, :upgrade_agent, :snapshots, :software, :software_sync,
                        {:'types' => :list_types},
                        {:exec => :execution_request},
                        :wiki, :update_wiki
@@ -152,215 +152,206 @@ class Morpheus::Cli::Hosts
     if args.count > 0
       options[:phrase] = args.join(" ")
     end
-    begin
-      params.merge!(parse_list_options(options))
-      account = nil
-      if options[:account]
-        account = find_account_by_name_or_id(options[:account])
-        if account.nil?
-          return 1
-        else
-          params['accountId'] = account['id']
-        end
-      end
-      group = options[:group] ? find_group_by_name_or_id_for_provisioning(options[:group]) : nil
-      if group
-        params['siteId'] = group['id']
+    
+    params.merge!(parse_list_options(options))
+    account = nil
+    if options[:account]
+      account = find_account_by_name_or_id(options[:account])
+      if account.nil?
+        return 1
+      else
+        params['accountId'] = account['id']
       end
+    end
+    group = options[:group] ? find_group_by_name_or_id_for_provisioning(options[:group]) : nil
+    if group
+      params['siteId'] = group['id']
+    end
 
-      # argh, this doesn't work because group_id is required for options/clouds
-      # cloud = options[:cloud] ? find_cloud_by_name_or_id_for_provisioning(group_id, options[:cloud]) : nil
-      cloud = options[:cloud] ? find_zone_by_name_or_id(nil, options[:cloud]) : nil
-      if cloud
-        params['zoneId'] = cloud['id']
-      end
+    # argh, this doesn't work because group_id is required for options/clouds
+    # cloud = options[:cloud] ? find_cloud_by_name_or_id_for_provisioning(group_id, options[:cloud]) : nil
+    cloud = options[:cloud] ? find_zone_by_name_or_id(nil, options[:cloud]) : nil
+    if cloud
+      params['zoneId'] = cloud['id']
+    end
 
-      if options[:created_by]
-        created_by_ids = find_all_user_ids(account ? account['id'] : nil, options[:created_by])
-        return if created_by_ids.nil?
-        params['createdBy'] = created_by_ids
-        # params['ownerId'] = created_by_ids # 4.2.1+
-      end
-      
-      cluster = nil
-      if options[:cluster]
-        if options[:cluster].to_s =~ /\A\d{1,}\Z/
-          params['clusterId'] = options[:cluster]
-        else
-          cluster = find_cluster_by_name_or_id(options[:cluster])
-          return 1 if cluster.nil?
-          params['clusterId'] = cluster['id']
-        end
+    if options[:created_by]
+      created_by_ids = find_all_user_ids(account ? account['id'] : nil, options[:created_by])
+      return if created_by_ids.nil?
+      params['createdBy'] = created_by_ids
+      # params['ownerId'] = created_by_ids # 4.2.1+
+    end
+    
+    cluster = nil
+    if options[:cluster]
+      if options[:cluster].to_s =~ /\A\d{1,}\Z/
+        params['clusterId'] = options[:cluster]
+      else
+        cluster = find_cluster_by_name_or_id(options[:cluster])
+        return 1 if cluster.nil?
+        params['clusterId'] = cluster['id']
       end
-      params['labels'] = options[:labels] if options[:labels]
-      if options[:tags] && !options[:tags].empty?
-        options[:tags].each do |k,v|
-          params['tags.' + k] = v
-        end
+    end
+    params['labels'] = options[:labels] if options[:labels]
+    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]
-        print_dry_run @servers_interface.dry.list(params)
-        return
-      end
-      json_response = @servers_interface.list(params)
+    @servers_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @servers_interface.dry.list(params)
+      return
+    end
+    json_response = @servers_interface.list(params)
 
-      if options[:json]
-        json_response.delete('stats') if options[:include_fields]
-        puts as_json(json_response, options, "servers")
-        return 0
-      elsif options[:yaml]
-        json_response.delete('stats') if options[:include_fields]
-        puts as_yaml(json_response, options, "servers")
-        return 0
-      elsif options[:csv]
-        # merge stats to be nice here..
-        if json_response['servers']
-          all_stats = json_response['stats'] || {}
+    # merge stats to be nice here..
+    all_stats = json_response['stats']
+    if options[:include_fields] || options[:all_fields]
+      if json_response['servers']
+        if all_stats
           json_response['servers'].each do |it|
             it['stats'] ||= all_stats[it['id'].to_s] || all_stats[it['id']]
           end
         end
-        puts records_as_csv(json_response['servers'], options)
-        return 0
+      end
+    end
+    render_response(json_response, options, "servers") do
+      
+      servers = json_response['servers']
+      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
+      if cloud
+        subtitles << "Cloud: #{cloud['name']}".strip
+      end
+      if cluster
+        subtitles << "Cluster: #{cluster['name']}".strip
+      elsif params['clusterId']
+        subtitles << "Cluster: #{params['clusterId']}".strip
+      end
+      subtitles += parse_list_subtitles(options)
+      print_h1 title, subtitles, options
+      if servers.empty?
+        print cyan,"No hosts found.",reset,"\n"
       else
-        servers = json_response['servers']
-        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
-        if cloud
-          subtitles << "Cloud: #{cloud['name']}".strip
-        end
-        if cluster
-          subtitles << "Cluster: #{cluster['name']}".strip
-        elsif params['clusterId']
-          subtitles << "Cluster: #{params['clusterId']}".strip
-        end
-        subtitles += parse_list_subtitles(options)
-        print_h1 title, subtitles, options
-        if servers.empty?
-          print cyan,"No hosts found.",reset,"\n"
-        else
-          # print_servers_table(servers)
-          # server returns stats in a separate key stats => {"id" => {} }
-          # the id is a string right now..for some reason..
-          all_stats = json_response['stats'] || {} 
-          servers.each do |it|
-            found_stats = all_stats[it['id'].to_s] || all_stats[it['id']]
-            if found_stats
-              if !it['stats']
-                it['stats'] = found_stats # || {}
-              else
-                it['stats'] = found_stats.merge!(it['stats'])
-              end
+        # print_servers_table(servers)
+        # server returns stats in a separate key stats => {"id" => {} }
+        # the id is a string right now..for some reason..
+        all_stats = json_response['stats'] || {} 
+        servers.each do |it|
+          found_stats = all_stats[it['id'].to_s] || all_stats[it['id']]
+          if found_stats
+            if !it['stats']
+              it['stats'] = found_stats # || {}
+            else
+              it['stats'] = found_stats.merge!(it['stats'])
             end
           end
+        end
 
-          rows = servers.collect {|server| 
-            stats = server['stats']
-            
-            if !stats['maxMemory']
-              stats['maxMemory'] = stats['usedMemory'] + stats['freeMemory']
+        rows = servers.collect {|server| 
+          stats = server['stats']
+          
+          if !stats['maxMemory']
+            stats['maxMemory'] = stats['usedMemory'] + stats['freeMemory']
+          end
+          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] || 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
-            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] || 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
-              if stats['maxStorage'] && stats['maxStorage'].to_i != 0
-                storage_usage_str = storage_usage_str + cyan + format_bytes_short(stats['usedStorage']).strip.rjust(8, ' ') + " / " + format_bytes_short(stats['maxStorage']).strip
-              end
+            if stats['maxStorage'] && stats['maxStorage'].to_i != 0
+              storage_usage_str = storage_usage_str + cyan + format_bytes_short(stats['usedStorage']).strip.rjust(8, ' ') + " / " + format_bytes_short(stats['maxStorage']).strip
             end
-            row = {
-              id: server['id'],
-              name: server['name'],
-              external_name: server['externalName'],
-              hostname: server['hostname'],
-              platform: server['serverOs'] ? server['serverOs']['name'].upcase : 'N/A',
-              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: (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,
-              created: format_local_dt(server['dateCreated']),
-              updated: format_local_dt(server['lastUpdated']),
-            }
-            row
-          }
-          # 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
-          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.upcase_keys!, options)
-          print reset
-          print_results_pagination(json_response)
+          row = {
+            id: server['id'],
+            name: server['name'],
+            external_name: server['externalName'],
+            hostname: server['hostname'],
+            platform: server['serverOs'] ? server['serverOs']['name'].upcase : 'N/A',
+            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: (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,
+            created: format_local_dt(server['dateCreated']),
+            updated: format_local_dt(server['lastUpdated']),
+          }
+          row
+        }
+        # 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
-        print reset,"\n"
+        # hide External Name if there are none
+        if !servers.find {|it| it['externalName'] && it['externalName'] != it['name']}
+          columns.delete("External Name")
+        end
+        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.upcase_keys!, options)
+        print reset
+        print_results_pagination(json_response)
       end
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
+      print reset,"\n"
     end
+    return 0, nil
   end
 
   def count(args)
@@ -491,7 +482,7 @@ class Morpheus::Cli::Hosts
       opts.on('--refresh-until STATUS', String, "Refresh until a specified status is reached.") do |val|
         options[:refresh_until_status] = val.to_s.downcase
       end
-      build_common_options(opts, options, [:json, :csv, :yaml, :fields, :dry_run, :remote])
+      build_standard_get_options(opts, options)
     end
     optparse.parse!(args)
     if args.count < 1
@@ -506,37 +497,24 @@ class Morpheus::Cli::Hosts
   end
 
   def _get(arg, options)
-    begin
-      @servers_interface.setopts(options)
-      if options[:dry_run]
-        if arg.to_s =~ /\A\d{1,}\Z/
-          print_dry_run @servers_interface.dry.get(arg.to_i)
-        else
-          print_dry_run @servers_interface.dry.list({name: arg})
-        end
-        return
-      end
-      json_response = nil
+    @servers_interface.setopts(options)
+    if options[:dry_run]
       if arg.to_s =~ /\A\d{1,}\Z/
-        json_response = @servers_interface.get(arg.to_i)
+        print_dry_run @servers_interface.dry.get(arg.to_i)
       else
-        server = find_host_by_name_or_id(arg)
-        json_response = @servers_interface.get(server['id'])
-        # json_response = {"server" => server} need stats
-      end
-      if options[:json]
-        json_response.delete('stats') if options[:include_fields]
-        puts as_json(json_response, options, "server")
-        return 0
-      elsif options[:yaml]
-        json_response.delete('stats') if options[:include_fields]
-        puts as_yaml(json_response, options, "server")
-        return 0
-      end
-      if options[:csv]
-        puts records_as_csv([json_response['server']], options)
-        return 0
+        print_dry_run @servers_interface.dry.list({name: arg})
       end
+      return
+    end
+    json_response = nil
+    if arg.to_s =~ /\A\d{1,}\Z/
+      json_response = @servers_interface.get(arg.to_i)
+    else
+      server = find_host_by_name_or_id(arg)
+      json_response = @servers_interface.get(server['id'])
+      # json_response = {"server" => server} need stats
+    end
+    render_response(json_response, options, "server") do
       server = json_response['server'] || json_response['host'] || {}
       #stats = server['stats'] || json_response['stats'] || {}
       stats = json_response['stats'] || {}
@@ -622,11 +600,8 @@ class Morpheus::Cli::Hosts
           _get(arg, options)
         end
       end
-
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
     end
+    return 0, nil
   end
 
   def stats(args)
@@ -781,7 +756,7 @@ class Morpheus::Cli::Hosts
       opts.on( '-t', '--type TYPE', "Server Type Code" ) do |val|
         options[:server_type_code] = val
       end
-      opts.on("--security-groups LIST", Integer, "Security Groups, comma sepearated list of security group IDs") do |val|
+      opts.on("--security-groups LIST", Integer, "Security Groups, comma separated list of security group IDs") do |val|
         options[:security_groups] = val.split(",").collect {|s| s.strip }.select {|s| !s.to_s.empty? }
       end
       opts.on('--refresh [SECONDS]', String, "Refresh until status is running,failed. Default interval is #{default_refresh_interval} seconds.") do |val|
@@ -842,7 +817,7 @@ class Morpheus::Cli::Hosts
         cloud_type = cloud_type_for_id(cloud['zoneTypeId'])
 
         # Server Type
-        cloud_server_types = cloud_type['serverTypes'].select{|b| b['creatable'] == true }.sort { |x,y| x['displayOrder'] <=> y['displayOrder'] }
+        cloud_server_types = cloud_type['serverTypes'].select{|b| b['creatable'] == true && b['containerHypervisor'] == false }.sort { |x,y| x['displayOrder'] <=> y['displayOrder'] }
         if options[:server_type_code]
           server_type_code = options[:server_type_code]
         else
@@ -1982,6 +1957,10 @@ class Morpheus::Cli::Hosts
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[host]")
       build_standard_list_options(opts, options)
+      opts.footer = <<-EOT
+List installed software for a host.
+[host] is required. This is the name or id of a host.
+EOT
     end
     optparse.parse!(args)
     verify_args!(args:args, optparse:optparse, count:1)
@@ -2026,6 +2005,48 @@ class Morpheus::Cli::Hosts
     end
   end
 
+  def software_sync(args)
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[host]")
+      build_standard_update_options(opts, options)
+      opts.footer = <<-EOT
+Sync installed software for a host.
+[host] is required. This is the name or id of a host.
+EOT
+    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?
+      payload = {}
+      if options[:payload]
+        payload = options[:payload]
+        payload.deep_merge!(parse_passed_options(options))
+      else
+        payload.deep_merge!(parse_passed_options(options))
+      end
+      params = {}
+      params.merge!(parse_query_options(options))
+      @servers_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @servers_interface.dry.software_sync(server['id'], payload, params)
+        return
+      end
+      json_response = @servers_interface.software_sync(server['id'], payload, params)
+      render_response(json_response, options) do
+        print_green_success "Syncing software for host #{server['name']}"
+        #get([server['id']])
+      end
+      return 0
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
   private
 
   def find_host_by_id(id)