morpheus-cli 6.3.4 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 044ab9d85780cd6e8c58298dd7eea8c389093c0c40f97e444c1050ecb9447d65
-  data.tar.gz: 54d733790244eea47f2310d0211dc4173ff26a89b9cde962cc64627f1ea8a68a
+  metadata.gz: 763ccc16e1c853b5d76e8466a21fd94abbd098615a884ff252f72015d5031338
+  data.tar.gz: c8ea0dcb3534ca6c3c557ce58763dfcef22ed59e7bdd33bde6eff00ee8513c1f
 SHA512:
-  metadata.gz: 527cceb963b7b673ec478a1717cf39b0481a295a59026430944621d6e9133044e6296107d90c336750ff5413599032379e0d012285a23a63e1ecd1287558a863
-  data.tar.gz: a160e2dc2676bcaaded2318268f72df801b9c6514293ba6c1ce59c54cc6803221e04885066d961bdb78dbcfa49855236f79ab24727685d35442e40dda5933ad5
+  metadata.gz: a68ef51fb607ce70ba7c93bdeb5ab637c741ce03ad24e987a63a2ba0db2d2ffac674bae2ff4aab02c543c76df93da178fe5a1d8e709df99444f2b4ba8e506945
+  data.tar.gz: 90b6702b8ebc4b75a0aa29da1802155dab2aca529c2d9538adb363f6c663b4241f632c7b22cc17e9e5b949598994e152107072ff19d7429bf944c69fcc4ad35e

data/Dockerfile

@@ -1,5 +1,5 @@
 FROM ruby:2.7.5
 
-RUN gem install morpheus-cli -v 6.3.4
+RUN gem install morpheus-cli -v 7.0.0
 
 ENTRYPOINT ["morpheus"]

data/lib/morpheus/api/api_client.rb

@@ -846,6 +846,10 @@ class Morpheus::APIClient
     Morpheus::HealthInterface.new(common_interface_options).setopts(@options)
   end
 
+  def hub
+    Morpheus::HubInterface.new(common_interface_options).setopts(@options)
+  end
+
   def audit
     Morpheus::AuditInterface.new(common_interface_options).setopts(@options)
   end

data/lib/morpheus/api/catalog_item_types_interface.rb

@@ -8,8 +8,7 @@ class Morpheus::CatalogItemTypesInterface < Morpheus::RestInterface
 
   # NOT json, multipart file upload, uses PUT update endpoint
   def update_logo(id, logo_file, dark_logo_file=nil)
-    #url = "#{base_path}/#{id}/update-logo"
-    url = "#{base_path}/#{id}"
+    url = "#{base_path}/#{id}/update-logo"
     headers = { :params => {}, :authorization => "Bearer #{@access_token}"}
     payload = {}
     payload["catalogItemType"] = {}

data/lib/morpheus/api/hub_interface.rb

@@ -0,0 +1,25 @@
+require 'morpheus/api/api_client'
+
+class Morpheus::HubInterface < Morpheus::APIClient
+
+  def base_path
+    "/api/hub"
+  end
+
+  def get(params={}, headers={})
+    execute(method: :get, url: "#{base_path}", params: params, headers: headers)
+  end
+
+  def usage(params={}, headers={})
+    execute(method: :get, url: "#{base_path}/usage", params: params, headers: headers)
+  end
+
+  def checkin(payload={}, params={}, headers={})
+    execute(method: :post, url: "#{base_path}/checkin", payload: payload, params: params, headers: headers)
+  end
+
+  def register(payload={}, params={}, headers={})
+    execute(method: :post, url: "#{base_path}/register", payload: payload, params: params, headers: headers)
+  end
+
+end

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

@@ -71,9 +71,6 @@ class Morpheus::Cli::CatalogItemTypesCommand
         print cyan,"No catalog item types found.",reset,"\n"
       else
         list_columns = catalog_item_type_list_column_definitions.upcase_keys!
-        list_columns.delete("Blueprint")
-        list_columns.delete("Workflow")
-        list_columns.delete("Context")
         #list_columns["Config"] = lambda {|it| truncate_string(it['config'], 100) }
         print as_pretty_table(catalog_item_types, list_columns.upcase_keys!, options)
         print_results_pagination(json_response)
@@ -701,12 +698,13 @@ EOT
       "Description" => 'description',
       "Type" => lambda {|it| format_catalog_type(it) },
       "Visibility" => 'visibility',
-      "Layout Code" => 'layoutCode',
+      #"Layout Code" => 'layoutCode',
       "Blueprint" => lambda {|it| it['blueprint'] ? it['blueprint']['name'] : nil },
       "Workflow" => lambda {|it| it['workflow'] ? it['workflow']['name'] : nil },
-      "Context" => lambda {|it| it['context'] },
+      # "Context" => lambda {|it| it['context'] },
       # "Content" => lambda {|it| it['content'] },
       "Form Type" => lambda {|it| it['formType'] == 'form' ? "Form" : "Inputs" },
+      "Form" => lambda {|it| it['form'] ? it['form']['name'] : nil }, 
       "Enabled" => lambda {|it| format_boolean(it['enabled']) },
       "Featured" => lambda {|it| format_boolean(it['featured']) },
       #"Config" => lambda {|it| it['config'] },

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/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/mixins/jobs_helper.rb

@@ -84,6 +84,7 @@ module Morpheus::Cli::JobsHelper
       end
       if process_data[:error] && process_data[:error].strip.length > 0
         print_h2 "Error"
+        print red
         print (process['message'] || process['error']).to_s.strip
         print reset,"\n"
       end
@@ -129,6 +130,8 @@ module Morpheus::Cli::JobsHelper
         out << "#{green}#{status_string.upcase}"
       elsif ['error', 'offline', 'failed', 'failure'].include?(status_string)
         out << "#{red}#{status_string.upcase}"
+      elsif ['running'].include?(status_string)
+        out << "#{cyan}#{status_string.upcase}"
       else
         out << "#{yellow}#{status_string.upcase}"
       end

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

@@ -514,7 +514,8 @@ module Morpheus::Cli::PrintHelper
     else
       percent = ((used_value.to_f / max_value.to_f) * 100)
     end
-    percent_label = ((used_value.nil? || max_value.to_f == 0.0) ? "n/a" : "#{percent.round(percent_sigdig)}%").rjust(6, ' ')
+    unlimited_label = opts[:unlimited_label] || "n/a" 
+    percent_label = ((used_value.nil? || max_value.to_f == 0.0) ? unlimited_label : "#{percent.round(percent_sigdig)}%").rjust(6, ' ')
     bar_display = ""
     if percent > 100
       max_bars.times { bars << "|" }
@@ -1000,6 +1001,83 @@ module Morpheus::Cli::PrintHelper
     print as_description_list(obj, columns, opts)
   end
 
+  def print_pretty_details(obj, opts={})
+    print as_pretty_details(obj, opts)
+  end
+
+  def as_pretty_details(obj, opts={})
+    print as_pretty_details(obj, opts.merge({pretty: true}))
+  end
+
+  def print_details(obj, opts={})
+    print as_details(obj, opts)
+  end
+
+  def as_details(obj, opts={})
+    #return "" if obj.nil?
+    columns = {}
+    keys = obj.keys
+    if opts[:sort]
+      keys.sort!
+    end
+    keys.each do |key|
+      display_proc = nil
+      if opts[:column_format] && opts[:column_format].key?(key.to_sym)
+        display_proc = opts[:column_format][key.to_sym]
+      else
+        display_proc = lambda {|it| format_detail_value(it[key]) }
+      end
+      label = opts[:pretty] ? key.to_s.titleize : key.to_s
+      columns[label] = display_proc
+    end
+    as_description_list(obj, columns, opts)
+  end
+
+  def format_detail_value(value)
+    rtn = value
+    if value.is_a?(Array)
+      # show the first three objects
+      rtn = value.first(3).collect { |row| format_abbreviated_value(row) }.join(", ")
+    elsif value.is_a?(Hash)
+      # show the first three properties
+      keys = values.keys.select { |key| value[key].is_a?(Numeric) || value[key].is_a?(String) }.first(3)
+      rtn = keys.collect { |key|
+        "#{key.to_s.titleize}: #{format_abbreviated_value(value[key])}"
+      }.join(", ")
+    elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      rtn = format_boolean(value)
+    else
+      rtn = value.to_s
+    end
+    return rtn
+  end
+
+  def format_abbreviated_value(value)
+    if value.is_a?(Hash)
+      if value.keys.size == 0
+        "{}"
+      else
+        # show the first three properties
+        keys = value.keys.select { |key| value[key].is_a?(Numeric) || value[key].is_a?(String) }.first(3)
+        keys.collect { |key|
+          "#{key.to_s.titleize}: #{value[key]}"
+        }.join(", ")
+      end
+    elsif value.is_a?(Array)
+      if value.size == 0
+        return "[]"
+      elsif obj.size == 1
+        "[(#{obj.size})]"
+      else
+        "[(#{obj.size})]"
+      end
+    elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      format_boolean(value)
+    else
+      value.to_s
+    end
+  end
+
   # build_column_definitions constructs an Array of column definitions (OpenStruct)
   # Each column is defined by a label (String), and a display_method (Proc)
   #
@@ -1059,7 +1137,7 @@ module Morpheus::Cli::PrintHelper
           column_def.display_method = lambda {|data| get_object_value(data, v) }
         elsif v.is_a?(Proc)
           column_def.display_method = v
-        elsif v.is_a?(Hash) || v.is_a?(OStruct)
+        elsif v.is_a?(Hash) || v.is_a?(OpenStruct)
           if v[:display_name] || v[:label]
             column_def.label = v[:display_name] || v[:label]
           end

data/lib/morpheus/cli/version.rb

@@ -1,6 +1,6 @@
 
 module Morpheus
   module Cli
-    VERSION = "6.3.4"
+    VERSION = "7.0.0"
   end
 end

data/lib/morpheus/routes.rb

@@ -223,9 +223,10 @@ module Morpheus::Routes
         path = "/admin/settings/environments"
       when "software-licenses"
         path = "/admin/settings/software-licenses"
-      when "license"
+      when "license","licenses"
         path = "/admin/settings/#!license"
       end
+      # todo: this is weird, fix it so "view license matches license before software-licenses without needing the above alias..
       # dasherize path and attempt to match the plural first
       plural_path = path.pluralize
       paths = [path.dasherize]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: morpheus-cli
 version: !ruby/object:Gem::Version
-  version: 6.3.4
+  version: 7.0.0
 platform: ruby
 authors:
 - David Estes
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-15 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -239,6 +239,7 @@ files:
 - lib/morpheus/api/guidance_interface.rb
 - lib/morpheus/api/guidance_settings_interface.rb
 - lib/morpheus/api/health_interface.rb
+- lib/morpheus/api/hub_interface.rb
 - lib/morpheus/api/image_builder_boot_scripts_interface.rb
 - lib/morpheus/api/image_builder_image_builds_interface.rb
 - lib/morpheus/api/image_builder_interface.rb
@@ -426,6 +427,7 @@ files:
 - lib/morpheus/cli/commands/health_command.rb
 - lib/morpheus/cli/commands/history_command.rb
 - lib/morpheus/cli/commands/hosts.rb
+- lib/morpheus/cli/commands/hub.rb
 - lib/morpheus/cli/commands/image_builder_command.rb
 - lib/morpheus/cli/commands/instance_types.rb
 - lib/morpheus/cli/commands/instances.rb