morpheus-cli 6.3.3 → 7.0.0

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

@@ -0,0 +1,215 @@
+require 'morpheus/cli/cli_command'
+
+class Morpheus::Cli::Hub
+  include Morpheus::Cli::CliCommand
+
+  set_command_description "View hub config and usage metrics."
+  set_command_name :'hub'
+  register_subcommands :get, {:usage => :usage_data}, :checkin, :register
+  
+  # this is a hidden utility command
+  set_command_hidden
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)   
+    @hub_interface = @api_client.hub
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def get(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "View hub configuration."
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    # execute api request
+    @hub_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @hub_interface.dry.get(params)
+      return
+    end
+    json_response = @hub_interface.get(params)
+    # render response
+    render_response(json_response, options) do
+      print_h1 "Morpheus Hub Config", [], options
+      print_description_list({
+        "Hub URL" => lambda {|it| it['hub']['url'] },
+        "Appliance ID" => lambda {|it| it['hub']['applianceUniqueId'] },
+        "Registered" => lambda {|it| format_boolean(it['hub']['registered']) },
+        "Stats Reporting" => lambda {|it| format_boolean(it['hub']['reportStatus']) },
+        "Send Data" => lambda {|it| format_boolean(it['hub']['sendData']) },
+      }, json_response, options)
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def usage_data(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_get_options(opts, options)
+      opts.footer = "View appliance usage data that is sent to the hub."
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    # execute api request
+    @hub_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @hub_interface.dry.usage(params)
+      return
+    end
+    json_response = @hub_interface.usage(params)
+    # render response
+    render_response(json_response, options) do
+      usage_data = json_response['data']
+      print_h1 "Morpheus Hub Usage", [], options
+      print_hub_usage_data_details(json_response, options)
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def checkin(args)
+    options = {}
+    params = {}
+    payload = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      opts.on( nil, '--asynchronous', "Execute the checkin asynchronously" ) do
+        params[:async] = true
+      end
+      build_standard_post_options(opts, options)
+      opts.footer = <<-EOT
+Checkin with the hub.
+This sends the current appliance usage data to the hub and
+it is only done if the appliance is registered with the hub
+and the appliance license has Stats Reporting enabled.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+    connect(options)
+    payload = parse_payload(options)
+    # execute api request
+    @hub_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @hub_interface.dry.checkin(payload, params)
+      return
+    end
+    json_response = @hub_interface.checkin(payload, params)
+    render_response(json_response, options) do
+      msg = json_response["msg"] || "Hub checkin complete"
+      print_green_success msg
+    end
+  end
+
+  def register(args)
+    options = {}
+    params = {}
+    payload = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      opts.on( '-f', '--force', "Force registration" ) do
+        params[:force] = true
+      end
+      build_standard_post_options(opts, options)
+      opts.footer = <<-EOT
+Register appliance with the hub to get a unique id for the appliance to checkin with.
+The registration is skipped if the appliance is already registered.
+The --force option can be used to execute this even if it is already registered.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+    connect(options)
+    payload = parse_payload(options)
+    # execute api request
+    @hub_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @hub_interface.dry.register(payload, params)
+      return
+    end
+    json_response = @hub_interface.register(payload, params)
+    render_response(json_response, options) do
+      msg = json_response["msg"] || "Hub registration complete"
+      print_green_success msg
+    end
+  end
+
+  protected
+
+  def print_hub_usage_data_details(json_response, options)
+    usage_data = json_response['data']
+
+    #print_h2 "Appliance Info", options
+
+    print_description_list({
+      "Appliance URL" => lambda {|it| it['applianceUrl'] },
+      "Appliance Version" => lambda {|it| it['applianceVersion'] },
+      # "Appliance Unique ID" => lambda {|it| ['hubUniqueId'] },
+      "Stats Version" => lambda {|it| it['statsVersion'] },
+      "Last Login" => lambda {|it| it['lastLoggedIn'] ? format_local_dt(it['lastLoggedIn'] / 1000).to_s : '' },
+      "Timestamp (ms)" => lambda {|it| it['ts'] ? format_local_dt(it['ts'] / 1000).to_s : '' },
+    }, usage_data, options)
+   
+
+    # print_h2 "Appliance Usage", options
+    # if usage_data['appliance']
+    #   # print_h2 "Appliance", options
+    #   print_description_list({
+    #     "Total Groups" => lambda {|it| it['appliance']['totalGroups'] },
+    #     "Total Clouds" => lambda {|it| it['appliance']['totalClouds'] },
+    #   }, usage_data, options)
+    # end
+
+    print_h2 "Appliance", options
+    # print_details_raw(usage_data['appliance'], options)
+    print_details(usage_data['appliance'], {
+      pretty: true,
+      column_format: {
+        totalMemory: lambda {|it| format_bytes it['totalMemory'] },
+        totalMemoryUsed: lambda {|it| format_bytes it['totalMemoryUsed'] },
+        totalStorage: lambda {|it| format_bytes it['totalStorage'] },
+        totalStorageUsed: lambda {|it| format_bytes it['totalStorageUsed'] },
+        managedMemoryTotal: lambda {|it| format_bytes it['managedMemoryTotal'] },
+        managedMemoryUsed: lambda {|it| format_bytes it['managedMemoryUsed'] },
+        managedStorageTotal: lambda {|it| format_bytes it['managedStorageTotal'] },
+        managedStorageUsed: lambda {|it| format_bytes it['managedStorageUsed'] },
+        unmanagedMemoryTotal: lambda {|it| format_bytes it['unmanagedMemoryTotal'] },
+        unmanagedMemoryUsed: lambda {|it| format_bytes it['unmanagedMemoryUsed'] },
+        unmanagedStorageTotal: lambda {|it| format_bytes it['unmanagedStorageTotal'] },
+        unmanagedStorageUsed: lambda {|it| format_bytes it['unmanagedStorageUsed'] },
+        cloudTypes: lambda {|it| it['cloudTypes'] ? it['cloudTypes'].collect {|row| "#{row['code']} (#{row['count']})"}.join(", ") : '' },
+        instanceTypes: lambda {|it| it['instanceTypes'] ? it['instanceTypes'].collect {|row| "#{row['code']} (#{row['count']})"}.join(", ") : '' },
+        provisionTypes: lambda {|it| it['provisionTypes'] ? it['provisionTypes'].collect {|row| "#{row['code']} (#{row['count']})"}.join(", ") : '' },
+        serverTypes: lambda {|it| it['serverTypes'] ? it['serverTypes'].collect {|row| "#{row['code']} (#{row['count']})"}.join(", ") : '' },
+        clusterTypes: lambda {|it| it['clusterTypes'] ? it['clusterTypes'].collect {|row| "#{row['code']} (#{row['count']})"}.join(", ") : '' },
+        lastLoggedIn: lambda {|it| it['lastLoggedIn'] ? format_local_dt(it['lastLoggedIn'] / 1000).to_s : '' },
+        ts: lambda {|it| it['lastLoggedIn'] ? format_local_dt(it['ts'] / 1000).to_s : '' },
+      }
+    })
+    
+    # print_h2 "Clouds", options
+    # print_h2 "Hosts", options
+    # print_h2 "Instances", options
+
+     
+  end
+
+
+  
+
+end

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

@@ -840,6 +840,9 @@ class Morpheus::Cli::JobsCommand
       opts.on("--internal [true|false]", String, "Filters executions based on internal flag. Internal executions are excluded by default.") do |val|
         params["internalOnly"] = (val.to_s != "false")
       end
+      opts.on("--automation [true|false]", String, "Filters executions based on automation flag. Non-automation executions include ansible and kubernetes job types.") do |val|
+        params["automation"] = (val.to_s != "false")
+      end
       build_standard_list_options(opts, options, [:details])
       opts.footer = "List job executions.\n" +
           "[job] is optional. Job ID or name to filter executions."
@@ -876,16 +879,15 @@ class Morpheus::Cli::JobsCommand
       if params["internalOnly"]
         subtitles << "internalOnly: #{params['internalOnly']}"
       end
+      if !params["automation"].nil?
+        subtitles << "automation: #{params['automation']}"
+      end
       print_h1 title, subtitles, options
       print_job_executions(job_executions, options)
-      print_results_pagination(json_response)
+      print_results_pagination(json_response) unless job_executions.size == 0
       print reset,"\n"
     end
-    if job_executions.empty?
-      return 3, "no executions found"
-    else
-      return 0, nil
-    end
+    return 0, nil
   end
 
   def get_execution(args)
@@ -968,7 +970,9 @@ class Morpheus::Cli::JobsCommand
       end
       if event_data[:error] && event_data[:error].strip.length > 0
         print_h2 "Error"
+        print red
         print event['message'] || event['error']
+        print reset
       end
       print reset,"\n"
       return 0

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

@@ -323,7 +323,7 @@ EOT
       {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Form name'},
       {'fieldName' => 'code', 'fieldLabel' => 'Code', 'type' => 'text', 'required' => true, 'description' => 'Unique form code'},
       {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
-      {'shorthand' => '-l', 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }},
+      {'shorthand' => '-l', 'optionalValue' => true, 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }},
     ]
   end
 

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

@@ -431,7 +431,7 @@ class Morpheus::Cli::LibraryOptionListsCommand
         # rest
         {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
         {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'displayOrder' => 2},
-        {'shorthand' => '-l', 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }, 'displayOrder' => 3},
+        {'shorthand' => '-l', 'optionalValue' => true, 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }, 'displayOrder' => 3},
         {'code' => 'optionTypeList.type', 'fieldName' => 'type', 'fieldLabel' => 'Type', 'type' => 'select', 'selectOptions' => get_available_option_list_types, 'defaultValue' => 'rest', 'required' => true, 'description' => 'Option List Type. eg. rest, api, ldap, manual', 'displayOrder' => 4},
         {'fieldName' => 'visibility', 'fieldLabel' => 'Visibility', 'type' => 'select', 'selectOptions' => [{'name' => 'Private', 'value' => 'private'}, {'name' => 'Public', 'value' => 'public'}], 'defaultValue' => 'private', 'displayOrder' => 5},
         {'dependsOnCode' => 'optionTypeList.type:rest', 'fieldName' => 'sourceUrl', 'fieldLabel' => 'Source Url', 'type' => 'text', 'required' => true, 'description' => "A REST URL can be used to fetch list data and is cached in the appliance database.", 'displayOrder' => 6},

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

@@ -302,7 +302,7 @@ class Morpheus::Cli::LibraryOptionTypesCommand
     [
       {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'displayOrder' => 1},
       {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'displayOrder' => 2},
-      {'shorthand' => '-l', 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }, 'displayOrder' => 3},
+      {'shorthand' => '-l', 'optionalValue' => true, 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }, 'displayOrder' => 3},
       {'fieldName' => 'fieldName', 'fieldLabel' => 'Field Name', 'type' => 'text', 'required' => true, 'description' => 'This is the input property that the value gets assigned to.', 'displayOrder' => 4},
       {'code' => 'optionType.type', 'fieldName' => 'type', 'fieldLabel' => 'Type', 'type' => 'select', 'selectOptions' => [{'name' => 'Text', 'value' => 'text'}, {'name' => 'Password', 'value' => 'password'}, {'name' => 'Number', 'value' => 'number'}, {'name' => 'Checkbox', 'value' => 'checkbox'}, {'name' => 'Select', 'value' => 'select'}, {'name' => 'Hidden', 'value' => 'hidden'}], 'defaultValue' => 'text', 'required' => true, 'displayOrder' => 5},
       {'fieldName' => 'optionList', 'fieldLabel' => 'Option List', 'type' => 'select', 'optionSource' => 'optionTypeLists', 'required' => true, 'dependsOnCode' => 'optionType.type:select', 'description' => "The Option List to be the source of options when type is 'select'.", 'displayOrder' => 6},

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

@@ -17,7 +17,6 @@ class Morpheus::Cli::License
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
-    @api_client = @api_client		
     @license_interface = @api_client.license
   end
 
@@ -40,78 +39,26 @@ class Morpheus::Cli::License
       raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
     end
     connect(options)
-    begin
-      # make api request
-      @license_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @license_interface.dry.get()
-        return 0, nil
-      end
-      json_response = @license_interface.get()
-      # 200 OK, parse results
+    
+    # make api request
+    @license_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @license_interface.dry.get()
+      return 0, nil
+    end
+    json_response = @license_interface.get()
+    render_response(json_response, options) do
       license = json_response['license']
       current_usage = json_response['currentUsage'] || {}
-      used_memory = json_response['licenseUsedMemory'] || current_usage['memory']
-      used_storage = current_usage['storage']
-      used_workloads = current_usage['workloads']
-      
-      # Determine exit status and any error conditions for the command
-      exit_code = 0
-      err = nil
+      print_h1 "License"
       if license.nil?
-        exit_code = 1
-        err = "No license currently installed."
-      end
-
-      # render common formats like dry run, curl, json , yaml , etc.
-      render_result = render_with_format(json_response, options)
-      return exit_code, err if render_result
-
-      if options[:quiet]
-        return exit_code, err
-      end
-      
-      if exit_code != 0 
-        print_error red, err.to_s, reset, "\n"
-        return exit_code, err
+        print "#{yellow}No license currently installed#{reset}\n\n"
+      else
+        print_license_details(json_response)
+        print_h2 "Current Usage", [], options
+        print_license_usage(license, current_usage)
+        print reset,"\n"
       end
-      
-      # render output
-
-      print_h1 "License"
-      max_memory = "Unlimited"
-      max_storage = "Unlimited"
-      max_memory = Filesize.from("#{license['maxMemory']} B").pretty  if license['maxMemory'].to_i != 0
-      max_storage = Filesize.from("#{license['maxStorage']} B").pretty  if license['maxStorage'].to_i != 0
-      used_memory = Filesize.from("#{used_memory} B").pretty if used_memory.to_i != 0
-      used_storage = Filesize.from("#{used_storage} B").pretty if used_storage.to_i != 0
-      #used_workloads = "n/a" if used_workloads.nil?
-      max_workloads = license["maxInstances"].to_i == 0 ? 'Unlimited' : license["maxInstances"]
-      print cyan
-      description_cols = {
-        "Account" => 'accountName',
-        "Product Tier" => lambda {|it| format_product_tier(it) },
-        "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
-        "End Date" => lambda {|it| 
-          if it['endDate']
-            format_local_dt(it['endDate']).to_s + ' (' + format_duration(Time.now, it['endDate']).to_s + ')' 
-          else
-            'Never'
-          end
-          },
-        "Memory" => lambda {|it| "#{used_memory} / #{max_memory}" },
-        "Storage" => lambda {|it| "#{used_storage} / #{max_storage}" },
-        "Workloads" => lambda {|it| "#{used_workloads} / #{max_workloads}" },
-        "Hard Limit" => lambda {|it| it[""] == false ? 'Yes' : 'No' },
-      }
-      print_description_list(description_cols, license)
-      print reset,"\n"
-    
-    return exit_code, err
-      
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      return false
     end
   end
 
@@ -126,6 +73,8 @@ class Morpheus::Cli::License
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[key]")
       build_common_options(opts, options, [:json, :dry_run, :remote])
+      opts.footer = "Install a new license key.\n" +
+                    "This will potentially change the enabled features and capabilities of your appliance."
     end
     optparse.parse!(args)
     if args.count > 1
@@ -192,7 +141,7 @@ class Morpheus::Cli::License
       end
       json_response = @license_interface.test(key)
       license = json_response['license']
-
+      current_usage = json_response['currentUsage'] || {}
       exit_code, err = 0, nil
       if license.nil?
         err = "Unable to decode license."
@@ -213,22 +162,9 @@ class Morpheus::Cli::License
       
       # all good
       print_h1 "License"
-      max_memory = "Unlimited"
-      max_storage = "Unlimited"
-      max_memory = Filesize.from("#{license['maxMemory']} B").pretty  if license['maxMemory'].to_i != 0
-      max_storage = Filesize.from("#{license['maxStorage']} B").pretty  if license['maxStorage'].to_i != 0
-      print cyan
-      description_cols = {
-        "Account" => 'accountName',
-        "Product Tier" => lambda {|it| format_product_tier(it) }, 
-        "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
-        "End Date" => lambda {|it| format_local_dt(it['endDate']) },
-        "Max Memory" => lambda {|it| max_memory },
-        "Max Storage" => lambda {|it| max_storage },
-        "Max Instances" => lambda {|it| it["maxInstances"].to_i == 0 ? 'Unlimited' : it["maxInstances"] },
-        "Hard Limit" => lambda {|it| it[""] == false ? 'Yes' : 'No' },
-      }
-      print_description_list(description_cols, license)
+      print_license_details(json_response)
+      print_h2 "License Usage", [], options
+      print_license_usage(license, current_usage)
       print reset,"\n"
       return exit_code, err
     rescue RestClient::Exception => e
@@ -299,4 +235,133 @@ class Morpheus::Cli::License
       product_tier.to_s.capitalize
     end
   end
+
+  def format_limit_type(license)
+    limit_type = license['limitType'] || 'workload'
+    if limit_type == 'standard' || limit_type == 'metrics'
+      'Standard'
+    else
+      limit_type.to_s.capitalize
+    end
+  end
+
+  def format_limit(max, used)
+    formatted_max = max.to_i > 0 ? format_number(max) : "Unlimited"
+    if used
+      formatted_used = format_number(used)
+      "#{formatted_used} / #{formatted_max}"
+    else
+      "#{formatted_max}"
+    end
+  end
+
+  def format_limit_bytes(max, used)
+    formatted_max = max.to_i > 0 ? format_bytes(max) : "Unlimited"
+    if used
+      formatted_used = format_bytes(used)
+      "#{formatted_used} / #{formatted_max}"
+    else
+      "#{formatted_max}"
+    end
+  end
+
+  def print_license_details(json_response)
+    license = json_response['license']
+    current_usage = json_response['currentUsage'] || {}
+    description_cols = {
+      "Account" => 'accountName',
+      "Product Tier" => lambda {|it| format_product_tier(it) },
+      "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
+      "End Date" => lambda {|it| 
+        if it['endDate']
+          format_local_dt(it['endDate']).to_s + ' (' + format_duration(Time.now, it['endDate']).to_s + ')' 
+        else
+          'Never'
+        end
+      },
+      "Multi-Tenant" => lambda {|it| format_boolean it["multiTenant"] },
+      "White Label" => lambda {|it| format_boolean it["whitelabel"] },
+      "Stats Reporting" => lambda {|it| format_boolean it["reportStatus"] },
+      "Hard Limit" => lambda {|it| format_boolean it["hardLimit"] },
+      "Limit Type" => lambda {|it| format_limit_type(it) },
+    }
+
+    description_cols.delete("Multi-Tenant") if !license['multiTenant']
+    description_cols.delete("White Label") if !license['whitelabel']
+
+    if license['zoneTypes'] && license['zoneTypes'].size > 0
+      description_cols["Included Clouds"] = lambda {|it| it['zoneTypes'].join(', ') }
+    elsif license['zoneTypesExcluded'] && license['zoneTypesExcluded'].size > 0
+      description_cols["Excluded Clouds"] = lambda {|it| it['zoneTypesExcluded'].join(', ') }
+    end
+    print_description_list(description_cols, license)
+  end
+
+  def print_license_usage(license, current_usage)
+    unlimited_label = "Unlimited"
+    # unlimited_label = "∞"
+    if license['limitType'] == 'standard'
+      # new standard metrics limit
+      used_managed_servers = current_usage['managedServers']
+      used_discovered_servers = current_usage['discoveredServers']
+      used_hosts = current_usage['hosts']
+      used_mvm = current_usage['mvm']
+      used_iac = current_usage['iac']
+      used_xaas = current_usage['xaas']
+      used_executions = current_usage['executions']
+      used_distributed_workers = current_usage['distributedWorkers']
+      used_discovered_objects = current_usage['discoveredObjects']
+
+
+      max_managed_servers = license["maxManagedServers"].to_i
+      max_discovered_servers = license['maxDiscoveredServers'].to_i
+      max_hosts = license['maxHosts'].to_i
+      max_mvm = license['maxMvm'].to_i
+      max_iac = license['maxIac'].to_i
+      max_xaas = license['maxXaas'].to_i
+      max_executions = license['maxExecutions'].to_i
+      max_distributed_workers = license['maxDistributedWorkers'].to_i
+      max_discovered_objects = license['maxDiscoveredObjects'].to_i
+      label_width = 20
+      chart_opts = {max_bars: 20, unlimited_label: '0%', percent_sigdig: 0}
+      out = ""
+      out << cyan + "Managed Servers".rjust(label_width, ' ') + ": " + generate_usage_bar(used_managed_servers, max_managed_servers, chart_opts) + cyan + used_managed_servers.to_s.rjust(8, ' ') + " / " + (max_managed_servers.to_i > 0 ? max_managed_servers.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Discovered Servers".rjust(label_width, ' ') + ": " + generate_usage_bar(used_discovered_servers, max_discovered_servers, chart_opts) + cyan + used_discovered_servers.to_s.rjust(8, ' ') + " / " + (max_discovered_servers.to_i > 0 ? max_discovered_servers.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Hosts".rjust(label_width, ' ') + ": " + generate_usage_bar(used_hosts, max_hosts, chart_opts) + cyan + used_hosts.to_s.rjust(8, ' ') + " / " + (max_hosts.to_i > 0 ? max_hosts.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "MVM Hosts".rjust(label_width, ' ') + ": " + generate_usage_bar(used_mvm, max_mvm, chart_opts) + cyan + used_mvm.to_s.rjust(8, ' ') + " / " + (max_mvm.to_i > 0 ? max_mvm.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Iac Deployments".rjust(label_width, ' ') + ": " + generate_usage_bar(used_iac, max_iac, chart_opts) + cyan + used_iac.to_s.rjust(8, ' ') + " / " + (max_iac.to_i > 0 ? max_iac.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Xaas Instances".rjust(label_width, ' ') + ": " + generate_usage_bar(used_xaas, max_xaas, chart_opts) + cyan + used_xaas.to_s.rjust(8, ' ') + " / " + (max_xaas.to_i > 0 ? max_xaas.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Executions".rjust(label_width, ' ') + ": " + generate_usage_bar(used_executions, max_executions, chart_opts) + cyan + used_executions.to_s.rjust(8, ' ') + " / " + (max_executions.to_i > 0 ? max_executions.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Distributed Workers".rjust(label_width, ' ') + ": " + generate_usage_bar(used_distributed_workers, max_distributed_workers, chart_opts) + cyan + used_distributed_workers.to_s.rjust(8, ' ') + " / " + (max_distributed_workers.to_i > 0 ? max_distributed_workers.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      #out << cyan + "Discovered Objects".rjust(label_width, ' ') + ": " + generate_usage_bar(used_discovered_objects, max_discovered_objects, chart_opts) + cyan + used_discovered_objects.to_s.rjust(8, ' ') + " / " + (max_discovered_objects.to_i > 0 ? max_discovered_objects.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      print out
+    else
+      # old workloads limit
+      used_memory = current_usage['memory']
+      used_storage = current_usage['storage']
+      used_workloads = current_usage['workloads']
+      max_memory = license['maxMemory'].to_i
+      max_storage = license['maxStorage'].to_i
+      max_workloads = license['maxInstances'].to_i
+      label_width = 15
+      chart_opts = {max_bars: 20, unlimited_label: '0%', percent_sigdig: 0}
+      out = ""
+      out << cyan + "Workloads".rjust(label_width, ' ') + ": " + generate_usage_bar(used_workloads, max_workloads, chart_opts) + cyan + used_workloads.to_s.rjust(15, ' ') + " / " + (max_workloads.to_i > 0 ? max_workloads.to_s : unlimited_label).to_s.ljust(15, ' ') + "\n"
+      out << cyan + "Memory".rjust(label_width, ' ') + ": " + generate_usage_bar(used_memory, max_memory, chart_opts) + cyan + Filesize.from("#{used_memory} B").pretty.strip.rjust(15, ' ') + " / " + (max_memory.to_i > 0 ? Filesize.from("#{max_memory} B").pretty : unlimited_label).strip.ljust(15, ' ') + "\n"
+      out << cyan + "Storage".rjust(label_width, ' ') + ": " + generate_usage_bar(used_storage, max_storage, chart_opts) + cyan + Filesize.from("#{used_storage} B").pretty.strip.rjust(15, ' ') + " / " + (max_storage.to_i > 0 ? Filesize.from("#{max_storage} B").pretty : unlimited_label).strip.ljust(15, ' ') + "\n"
+      print out
+    end
+  end
+
+  # todo: use this to dry print_license_usage
+  def format_limit(label, used, max, opts={})
+    unlimited_label = "Unlimited"
+    # unlimited_label = "∞"
+    label_width = opts[:label_width] || 15
+    chart_opts = {max_bars: 20, unlimited_label: '0%', percent_sigdig: 0}
+    chart_opts.merge!(opts[:chart_opts]) if opts[:chart_opts]
+    cyan + label.rjust(label_width, ' ') + ": " + generate_usage_bar(used, max, chart_opts) + cyan + used.to_s.rjust(label_width, ' ') + " / " + (max.to_i > 0 ? max.to_s : unlimited_label).to_s.ljust(label_width, ' ') + "\n"
+  end
+
+
 end

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

@@ -132,7 +132,7 @@ class Morpheus::Cli::NetworksCommand
                 pool: subnet['pool'] ? subnet['pool']['name'] : '',
                 dhcp: subnet['dhcpServer'] ? 'Yes' : 'No',
                 visibility: subnet['visibility'].to_s.capitalize,
-                active: format_boolean(network['active']),
+                active: format_boolean(subnet['active']),
                 tenants: subnet['tenants'] ? subnet['tenants'].collect {|it| it['name'] }.uniq.join(', ') : ''
               }
               rows << subnet_row

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

@@ -57,7 +57,7 @@ class Morpheus::Cli::SecurityPackagesCommand
         api_client.security_package_types.list({max:10000})['securityPackageTypes'].collect { |it| {"name" => it["name"], "value" => it["code"]} }
       }, 'required' => true, 'defaultValue' => 'SCAP Package'},      
       {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
-      {'shorthand' => '-l', 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }},
+      {'shorthand' => '-l', 'optionalValue' => true, 'fieldName' => 'labels', 'fieldLabel' => 'Labels', 'type' => 'text', 'required' => false, 'noPrompt' => true, 'processValue' => lambda {|val| parse_labels(val) }},
       {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'required' => false},
       {'fieldName' => 'enabled', 'fieldLabel' => 'Enabled', 'type' => 'checkbox', 'required' => false, 'defaultValue' => true},
       # {'code' => 'securityPackage.sourceType', 'fieldName' => 'sourceType', 'fieldLabel' => 'Source', 'type' => 'select', 'selectOptions' => [{'name'=>'url','value'=>'url'}], 'defaultValue' => 'url', 'required' => true},

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

@@ -385,7 +385,7 @@ EOT
 
     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]] : []))
+        cmd_res = Morpheus::Cli::License.new.install([] + (options[:remote] ? ["-r",options[:remote]] : []))
         # license_is_valid = cmd_res != false
       end
     end

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

@@ -1373,11 +1373,11 @@ class Morpheus::Cli::Tasks
     # this makes us all sad
     option_types.each do |option_type|
       if option_type['type'] == 'typeahead'
-        if ['operationalWorkflowName','containerScript','containerTemplate'].include?(option_type['code'])
+        if ['operationalWorkflowName','ifOperationalWorkflowName','elseOperationalWorkflowName','containerScript','containerTemplate'].include?(option_type['code'])
           option_type.deep_merge!({'config' => {'valueField' => 'name'}})
         end
       elsif option_type['type'] == 'hidden'
-        if ['operationalWorkflowId','containerScriptId','containerTemplateId'].include?(option_type['code'])
+        if ['operationalWorkflowId','ifOperationalWorkflowId','elseOperationalWorkflowId','containerScriptId','containerTemplateId'].include?(option_type['code'])
           option_type['processValue'] = lambda {|val| 
             if val.to_s.empty?
               selected_option = Morpheus::Cli::OptionTypes.get_last_select()

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

@@ -104,7 +104,16 @@ EOT
           "ACCESS TOKEN" => lambda {|it| it['maskedAccessToken'] },
           "REFRESH TOKEN" => lambda {|it| it['maskedRefreshToken'] },
           "ACCESS EXPIRATION" => lambda {|it| format_local_dt(it['expiration']) },
-          "ACCESS TTL" => lambda {|it| it['expiration'] ? (format_duration(it['expiration']) rescue '') : '' }
+          "ACCESS TTL" => lambda {|it| 
+            if it['expiration']
+              expires_on = parse_time(it['expiration'])
+              if expires_on && expires_on < Time.now
+                "Expired"
+              else
+                it['expiration'] ? (format_duration(it['expiration']) rescue '') : '' 
+              end
+            end
+          }
         }
         print cyan
         puts as_pretty_table(access_tokens, cols)