morpheus-cli 5.4.0 → 5.4.3.1

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

@@ -15,10 +15,10 @@ module Morpheus::Cli::AccountsHelper
     @accounts_interface
   end
 
-  def users_interface
+  def account_users_interface
     # @api_client.users
-    raise "#{self.class} has not defined @users_interface" if @users_interface.nil?
-    @users_interface
+    raise "#{self.class} has not defined @account_users_interface" if @account_users_interface.nil?
+    @account_users_interface
   end
 
   def user_groups_interface
@@ -244,7 +244,7 @@ module Morpheus::Cli::AccountsHelper
 
   def find_user_by_id(account_id, id, params={})
     begin
-      json_response = users_interface.get(account_id, id.to_i, params)
+      json_response = account_users_interface.get(account_id, id.to_i, params)
       return json_response['user']
     rescue RestClient::Exception => e
       if e.response && e.response.code == 404
@@ -256,7 +256,7 @@ module Morpheus::Cli::AccountsHelper
   end
 
   def find_user_by_username(account_id, username, params={})
-    users = users_interface.list(account_id, params.merge({username: username.to_s}))['users']
+    users = account_users_interface.list(account_id, params.merge({username: username.to_s}))['users']
     if users.empty?
       print_red_alert "User not found by username #{username}"
       return nil

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

@@ -105,12 +105,32 @@ module Morpheus::Cli::LoadBalancersHelper
     end
   end
 
-  def load_balancer_type_for_id(id)
-    return get_available_load_balancer_types().find { |z| z['id'].to_i == id.to_i}
+  def load_balancer_type_for_id(val)
+    record = get_available_load_balancer_types().find { |z| z['id'].to_i == val.to_i}
+    label = "Load Balancer Type"
+    if record.nil?
+      print_red_alert "#{label.downcase} not found by id #{val}"
+      return nil
+    end
+    return record
   end
 
-  def load_balancer_type_for_name(name)
-    return get_available_load_balancer_types().find { |z| z['name'].downcase == name.downcase || z['code'].downcase == name.downcase}
+  def load_balancer_type_for_name(val)
+    records = get_available_load_balancer_types().select { |z| z['name'].downcase == val.downcase || z['code'].downcase == val.downcase}
+    label = "Load Balancer Type"
+    if records.empty?
+      print_red_alert "#{label} not found by name '#{val}'"
+      return nil
+    elsif records.size > 1
+      print_red_alert "More than one #{label.downcase} found by name '#{val}'"
+      print_error "\n"
+      puts_error as_pretty_table(records, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      return nil
+    else
+      return records[0]
+    end
   end
 
   def find_load_balancer_type_by_name_or_id(val)

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

@@ -202,7 +202,7 @@ module Morpheus::Cli::PrintHelper
     if options[:outfile]
       print_result = print_to_file(output, options[:outfile], options[:overwrite])
       # with_stdout_to_file(options[:outfile], options[:overwrite]) { print output }
-      print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes File.size(options[:outfile])})\n" unless options[:quiet]
+      print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes(File.size(options[:outfile]))})\n" unless options[:quiet]
       #return print_result
       return
     end
@@ -220,6 +220,14 @@ module Morpheus::Cli::PrintHelper
     return
   end
 
+  def print_system_command_dry_run(cmd, options={})
+    print "\n"
+    print "#{cyan}#{bold}#{dark}SYSTEM COMMAND#{reset}\n"
+    print cmd
+    print reset, "\n"
+    return
+  end
+
   def format_api_request(http_method, url, headers, payload=nil, options={})
     out = ""
     # out << "\n"
@@ -385,33 +393,57 @@ module Morpheus::Cli::PrintHelper
     if json_response.nil? || json_response.empty?
       return ""
     end
-    
-    # options = OpenStruct.new(options) # laff, let's do this instead
     color = options.key?(:color) ? options[:color] : cyan
     label = options[:label]
-    n_label = options[:n_label]
-    # label = n_label if !label && n_label
+    n_label = options[:n_label] || (label ? label.to_s.pluralize : nil)
     message = options[:message] || "Viewing %{start_index}-%{end_index} of %{total} %{label}"
     blank_message = options[:blank_message] || nil # "No %{label} found"
 
-    # support lazy passing of common json_response {"meta": {"size": {25}, "total": 56} }
-    # otherwise use the root values given
-    meta = OpenStruct.new(json_response)
-    if meta.meta
-      meta = OpenStruct.new(meta.meta)
-    end
-    offset, size, total = meta.offset.to_i, meta.size.to_i, meta.total.to_i
-    #objects = meta.objects || options[:objects_key] ? json_response[options[:objects_key]] : nil
-    #objects ||= meta.instances || meta.servers || meta.users || meta.roles
-    #size = objects.size if objects && size == 0
-    if total == 0
+    # support lazy passing of common list json_response {"meta": {"size": 25, "total": 56} }
+    # priority is:
+    # 1. "meta" that api response contains for list endpoints
+    # 2. "total" and "size" values if passed explicitely by the cli (pretty sure symbols are no longer used)
+    # 3. examine the first array found in the response
+    meta = nil
+    records = nil
+    # assume records is the first array in the response
+    records_key = json_response.keys.find { |k| json_response[k].is_a?(Array) }
+    if records_key
+      records = json_response[records_key]
+      meta = {'offset' => 0, 'size' => records.size, 'total' => records.size}
+    end
+    if json_response[:meta] || json_response["meta"]
+      meta = json_response[:meta] || json_response["meta"]
+    elsif json_response.key?('size') || json_response.key?('total')
+      meta = json_response
+    elsif json_response.key?(:size) || json_response.key?(:total)
+      meta = {'size' => json_response[:size], 'total' => json_response[:total], 'offset' => json_response[:offset]}
+    elsif records
+      # just use the first key in the response
+      meta = {'size' => records.size, 'total' => records.size}
+    end
+    # did not find pagination meta info?
+    if meta.nil?
+      return ""
+    end
+    # api should not need to return the size, just use records.size
+    if meta["size"].nil? && records
+      meta["size"] = records.size
+    end
+    offset = meta['offset'].to_i
+    size = meta['size'].to_i
+    total = meta['total'].to_i
+    # perhaps no total count returned, let total be equal to size of list
+    if total == 0 && size > 0
       total = size
     end
+    # plural label?
     if total != 1
-      label = n_label || label
+      label = n_label
     end
     out_str = ""
-    string_key_values = {start_index: format_number(offset + 1), end_index: format_number(offset + size), total: format_number(total), size: format_number(size), offset: format_number(offset), label: label}
+    string_key_values = {start_index: format_number(offset + 1), end_index: format_number(offset + size), 
+      total: format_number(total), size: format_number(size), offset: format_number(offset), label: label}
     if size > 0
       if message
         out_str << message % string_key_values

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

@@ -1,8 +1,7 @@
 require 'morpheus/cli/mixins/print_helper'
 
 # Mixin for Morpheus::Cli command classes
-# Provides common methods for fetching and printing accounts, roles, and users.
-# The including class must establish @accounts_interface, @roles_interface, @users_interface
+# Provides common methods for viewing process history
 module Morpheus::Cli::ProcessesHelper
 
   def self.included(klass)

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

@@ -57,9 +57,9 @@ module Morpheus::Cli::ProvisioningHelper
     @api_client.accounts
   end
 
-  def get_available_groups(refresh=false)
+  def get_available_groups(params = {}, refresh=false)
     if !@available_groups || refresh
-      option_results = options_interface.options_for_source('groups',{})
+      option_results = options_interface.options_for_source('groups', params)
       @available_groups = option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"]}
       }
@@ -68,9 +68,9 @@ module Morpheus::Cli::ProvisioningHelper
     return @available_groups
   end
 
-  def get_available_clouds(group_id, refresh=false)
+  def get_available_clouds(group_id, params = {}, refresh=false)
     if !group_id
-      option_results = options_interface.options_for_source('clouds', {'default' => 'false'})
+      option_results = options_interface.options_for_source('clouds', params.merge({'default' => 'false'}))
       return option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"], "zoneTypeId" => it["zoneTypeId"]}
       }
@@ -80,7 +80,7 @@ module Morpheus::Cli::ProvisioningHelper
       return []
     end
     if !group["clouds"] || refresh
-      option_results = options_interface.options_for_source('clouds', {groupId: group_id})
+      option_results = options_interface.options_for_source('clouds', params.merge({groupId: group_id}))
       group["clouds"] = option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"], "zoneTypeId" => it["zoneTypeId"]}
       }
@@ -484,7 +484,7 @@ module Morpheus::Cli::ProvisioningHelper
     if options[:instance_type_code]
       instance_type_code = options[:instance_type_code]
     else
-      instance_type_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'type' => 'select', 'fieldLabel' => 'Type', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Select Instance Type.'}],options[:options],api_client,{groupId: group_id}, no_prompt, true)
+      instance_type_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'type' => 'select', 'fieldLabel' => 'Type', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Select Instance Type.'}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, restrictProvisionType:true}, no_prompt, true)
       instance_type_code = instance_type_prompt['type']
     end
     if instance_type_code.to_s =~ /\A\d{1,}\Z/
@@ -870,6 +870,12 @@ module Morpheus::Cli::ProvisioningHelper
       end
     end
 
+    # plan customizations
+    plan_opts = prompt_service_plan_options(service_plan, options, api_client, {zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
+    if plan_opts && !plan_opts.empty?
+      payload['servicePlanOptions'] = plan_opts
+    end
+
     # prompt networks
     if locked_fields.include?('networks')
       # payload['networkInterfaces'] = options[:options]['networkInterfaces'] if options[:options]['networkInterfaces']
@@ -942,6 +948,7 @@ module Morpheus::Cli::ProvisioningHelper
     # prompt for option types
     api_params['config'] = payload['config'] if payload['config']
     api_params['poolId'] = payload['config']['resourcePoolId'] if payload['config'] && payload['config']['resourcePoolId']
+    api_params['resourcePoolId'] = api_params['poolId']
 
     # set option type defaults from config
     if options[:default_config]
@@ -2093,6 +2100,15 @@ module Morpheus::Cli::ProvisioningHelper
     permissions
   end
 
+  def prompt_permissions_v2(options, excludes = [])
+    perms = prompt_permissions(options, excludes)
+    rtn = {}
+
+    rtn['visibility'] = perms['resourcePool']['visibility'] if !perms['resourcePool'].nil?
+    rtn['tenants'] = ((perms['tenantPermissions'] || {})['accounts'] || []).collect {|it| {'id' => it}}
+    rtn
+  end
+
   def print_permissions(permissions, excludes = [])
     if permissions.nil?
       print_h2 "Permissions"
@@ -2230,6 +2246,80 @@ module Morpheus::Cli::ProvisioningHelper
     return ports
   end
 
+  def prompt_service_plan_options(plan_info, options={}, api_client=nil, api_params={}, instance=nil)
+    plan_opts = {}
+    # provisioning with blueprint can lock fields
+    locked_fields = options[:locked_fields] || []
+    if options[:options]['servicePlanOptions']
+      plan_opts = options[:options]['servicePlanOptions']
+    end
+    default_max_cores = plan_info['maxCores'].to_i != 0 ? plan_info['maxCores'] : 1
+    default_cores_per_socket = plan_info['coresPerSocket'].to_i != 0 ? plan_info['coresPerSocket'] : 1
+    default_max_memory = plan_info['maxMemory'].to_i != 0 ? plan_info['maxMemory'] : nil
+    # use defaults from the instance/server
+    if instance
+      default_max_cores = instance["maxCores"] if instance["maxCores"]
+      default_cores_per_socket = instance["coresPerSocket"] if instance["coresPerSocket"]
+      default_max_memory = instance["maxMemory"] if instance["maxMemory"]
+    end
+    # Core Count
+    if plan_info["customCores"]
+      if locked_fields.include?('servicePlanOptions.maxCores')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxCores']
+          plan_opts['maxCores'] = options[:options]['servicePlanOptions']['maxCores'].to_i
+        end
+      else
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => 'servicePlanOptions', 'fieldName' => 'maxCores', 'type' => 'number', 'fieldLabel' => "Core Count", 'required' => true, 'defaultValue' => default_max_cores, 'description' => "Customize service plan options Core Count"}], options[:options])
+        if v_prompt['servicePlanOptions'] && v_prompt['servicePlanOptions']['maxCores']
+          plan_opts['maxCores'] = v_prompt['servicePlanOptions']['maxCores'].to_i
+        end
+      end
+    end
+    # Cores Per Socket
+    if plan_info["customCoresPerSocket"]
+      if locked_fields.include?('servicePlanOptions.coresPerSocket')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['coresPerSocket']
+          plan_opts['coresPerSocket'] = options[:options]['servicePlanOptions']['coresPerSocket'].to_i
+        end
+      else
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => 'servicePlanOptions', 'fieldName' => 'coresPerSocket', 'type' => 'number', 'fieldLabel' => "Cores Per Socket", 'required' => true, 'defaultValue' => default_cores_per_socket, 'description' => "Customize service plan options Cores Per Socket"}], options[:options])
+        if v_prompt['servicePlanOptions'] && v_prompt['servicePlanOptions']['coresPerSocket']
+          plan_opts['coresPerSocket'] = v_prompt['servicePlanOptions']['coresPerSocket'].to_i
+        end
+      end
+    end
+    # Memory
+    if plan_info["customMaxMemory"]
+      if locked_fields.include?('servicePlanOptions.maxMemory')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxMemory']
+          plan_opts['maxMemory'] = options[:options]['servicePlanOptions']['maxMemory'].to_i
+        end
+      else
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxMemory']
+          plan_opts['maxMemory'] = options[:options]['servicePlanOptions']['maxMemory'].to_i
+        else
+          # prompt for "memoryMB" field as MB or "memoryGB" in GB
+          # always convert maxMemory to bytes
+          if plan_info["memorySizeType"] == "MB" || options[:options]["memoryMB"]
+            v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memoryMB', 'type' => 'text', 'fieldLabel' => "Memory (MB)", 'required' => true, 'defaultValue' => default_max_memory ? (default_max_memory / (1024 * 1024)) : nil, 'description' => "Customize service plan options Memory (MB). Value is in megabytes."}], options[:options])
+            if v_prompt['memoryMB'].to_s != ""
+              plan_opts['maxMemory'] = v_prompt['memoryMB'].to_i * 1024 * 1024
+            end
+          else
+            v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memoryGB', 'type' => 'text', 'fieldLabel' => "Memory (GB)", 'required' => true, 'defaultValue' => default_max_memory ? (default_max_memory / (1024 * 1024 * 1024)) : nil, 'description' => "Customize service plan options Memory (GB). Value is in gigabytes."}], options[:options])
+            if v_prompt['memoryGB'].to_s != ""
+              plan_opts['maxMemory'] = v_prompt['memoryGB'].to_i * 1024 * 1024 * 1024
+            end
+          end
+          # remove transient memory field just used for prompting for MB or GB
+          plan_opts.delete("memoryMB")
+          plan_opts.delete("memoryGB")
+        end
+      end
+    end
+    return plan_opts
+  end
+
   def format_instance_status(instance, return_color=cyan)
     out = ""
     status_string = instance['status'].to_s