morpheus-cli 8.1.1.1 → 9.0.0

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

@@ -0,0 +1,391 @@
+require 'morpheus/cli/cli_command'
+
+# This provides commands for authentication 
+# This also includes credential management.
+class Morpheus::Cli::TokensCommand
+  include Morpheus::Cli::CliCommand
+  include Morpheus::Cli::AccountsHelper
+
+  set_command_name :'tokens'
+  set_command_description "View and manage API access tokens."
+  register_subcommands :list, :get, :add, :remove, :remove_all
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @tokens_interface = @api_client.tokens
+    @accounts_interface = @api_client.accounts
+    @account_users_interface = @api_client.account_users
+  end
+  
+  def handle(args)
+    handle_subcommand(args)
+  end
+  
+  def list(args)
+    options = {}
+    params = {}
+    ref_ids = []
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[search]")
+      build_standard_list_options(opts, options)
+      opts.on("--client-id CLIENT", "Filter by Client ID. eg. morph-api, morph-cli") do |val|
+        params['clientId'] = val.to_s
+      end
+      opts.on("--name TOKEN", "Filter by name") do |val|
+        params['name'] = val.to_s
+      end
+      opts.on("--value TOKEN", "Filter by access token value") do |val|
+        params['token'] = val.to_s
+      end
+      opts.on("-u", "--user USER", "User username or ID") do |val|
+        options[:user] = val.to_s
+      end
+      opts.on("--user-id ID", String, "User ID") do |val|
+        params['userId'] = val.to_s
+      end
+      opts.footer = "List API access tokens."
+    end
+    optparse.parse!(args)
+    connect(options)
+    # verify_args!(args:args, optparse:optparse, count:0)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    if options[:user]
+      user = find_user_by_username_or_id(nil, options[:user], {global:true})
+      return 1 if user.nil?
+      params['userId'] = user['id']
+    end
+    @tokens_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @tokens_interface.dry.list(params)
+      return
+    end
+    json_response = @tokens_interface.list(params)
+    tokens = json_response['tokens']
+    render_response(json_response, options, 'tokens') do
+      print_h1 "Morpheus API Tokens", parse_list_subtitles(options), options
+      if tokens.empty?
+        print yellow,"No tokens found.",reset,"\n"
+      else
+        columns = token_columns.select {|k,v| ["ID", "Name", "Client ID", "Username", "Access Token", "Expiration", "TTL", "Date Created"].include?(k) }.upcase_keys!
+        #columns = token_columns.upcase_keys!
+        print as_pretty_table(tokens, columns, options)
+        print_results_pagination(json_response)
+      end
+      print reset,"\n"
+    end
+  end
+  
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      opts.on("-u", "--user USER", "User username or ID") do |val|
+        options[:user] = val.to_s
+      end
+      opts.on("--user-id ID", String, "User ID") do |val|
+        params['userId'] = val.to_s
+      end
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a specific token.
+[token] is required. This is the id or name or value of the token.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    if options[:user]
+      user = find_user_by_username_or_id(nil, options[:user], {global:true})
+      return 1 if user.nil?
+      params['userId'] = user['id']
+    end
+    id_list = parse_id_list(args).collect do |id|
+      if id.to_s =~ /\A\d{1,}\Z/
+        id
+      else
+        # Looking for a token by secret value? eg. "93cb5548-********""
+        if id.to_s =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+          token = find_token_by_token(id, params['userId'])
+          if token
+            token['id']
+          else
+            return 1, "Token not found for '#{id[0..8]}********'"
+          end
+        else
+          token = find_token_by_name(id, params['userId'])
+          if token
+            token['id']
+          else
+            return 1, "Token not found for '#{id}'"
+          end
+        end
+      end
+    end
+    return run_command_for_each_arg(id_list) do |id|
+      _get(id, params, options)
+    end
+  end
+
+  def _get(id, params, options)
+    @tokens_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @tokens_interface.dry.get(id, params)
+      return
+    end
+    json_response = @tokens_interface.get(id, params)
+    render_response(json_response, options, 'token') do
+      token = json_response['token']
+      print_h1 "Token Details", [], options
+      print cyan
+      print_description_list(token_columns, token)
+      print reset,"\n"
+    end
+  end
+
+  def add(args)
+    options = {}
+    params = {}
+
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name]")
+      build_option_type_options(opts, options, add_token_option_types)
+      opts.on("-u", "--user USER", "User username or ID") do |val|
+        options[:user] = val.to_s
+      end
+      opts.on("--user-id ID", String, "User ID") do |val|
+        params['userId'] = val.to_s
+      end
+      build_standard_add_options(opts, options)
+      opts.footer = <<-EOT
+Create a new token
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:0, max:1)
+    connect(options)
+    if args[0]
+      options[:options]['name'] = args[0]
+    end
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({'token' => parse_passed_options(options)})
+    else
+      payload.deep_merge!({'token' => parse_passed_options(options)})
+      v_prompt = Morpheus::Cli::OptionTypes.prompt(add_token_option_types, options[:options], @api_client, options[:params])
+      params.deep_merge!(v_prompt)
+      payload['token'].deep_merge!(params)
+    end
+    if options[:user]
+      user = find_user_by_username_or_id(nil, options[:user], {global:true})
+      return 1 if user.nil?
+      params['userId'] = user['id']
+    end
+    @tokens_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @tokens_interface.dry.create(payload, params)
+      return 0, nil
+    end
+    json_response = @tokens_interface.create(payload, params)
+    render_response(json_response, options, 'token') do
+      token = json_response['token']
+      # print_green_success "Created new token"
+      # print_green_success "Access Token: #{token['accessToken']}"
+      # print_green_success "Refresh Token: #{token['refreshToken']}"
+      # return _get(token["id"], {}, options)
+      print_green_success "Added token #{token['name'] || token['id']}"
+      # show new access and refresh tokens unmasked and in green
+      columns = token_columns
+      columns["Access Token"] = lambda {|it| "#{green}#{it['accessToken']}#{cyan}" }
+      columns["Refresh Token"] = lambda {|it| "#{green}#{it['refreshToken']}#{cyan}" }
+      print_h1 "New Token Details", [], options
+      print cyan
+      print_description_list(columns, token)
+      print reset,"\n"
+    end
+  end
+
+  def remove(args)
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id list]")
+      opts.on("--client-id CLIENT", "Filter by Client ID. eg. morph-api, morph-cli") do |val|
+        params['clientId'] = val.to_s
+      end
+      opts.on("-u", "--user USER", "User username or ID") do |val|
+        options[:user] = val.to_s
+      end
+      opts.on("--user-id ID", String, "User ID") do |val|
+        params['userId'] = val.to_s
+      end
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete a token.
+[id] is required. This is the id of a token.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    if options[:user]
+      user = find_user_by_username_or_id(nil, options[:user], {global:true})
+      return 1 if user.nil?
+      params['userId'] = user['id']
+    end
+    token = find_token_by_name_or_id(args[0], params['userId'])
+    return 1, "Token not found" if token.nil?
+    parse_options(options, params)
+    confirm!("Are you sure you want to delete the token ID: #{token['id']} Value: #{token['maskedAccessToken']}?", options)
+    execute_api(@tokens_interface, :destroy, [token['id']], options) do |json_response|
+      print_green_success "Removed token #{token['maskedAccessToken']}"
+    end
+  end
+
+  def remove_all(args)
+    client_id = nil
+    options = {}
+    params = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[id]")
+      opts.on("--client-id CLIENT", "Delete all tokens for a specific Client ID. eg. morph-api, morph-cli") do |val|
+        client_id = val.to_s
+      end
+      opts.on("-u", "--user USER", "User username or ID") do |val|
+        options[:user] = val.to_s
+      end
+      opts.on("--user-id ID", String, "User ID") do |val|
+        params['userId'] = val.to_s
+      end
+      build_standard_remove_options(opts, options)
+      opts.footer = <<-EOT
+Delete many tokens at once.
+[id list] is required. This is the list of token ids to be deleted
+This command supports using --client-id CLIENT option instead of [id list]
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse)
+    connect(options)
+    if options[:user]
+      user = find_user_by_username_or_id(nil, options[:user], {global:true})
+      return 1 if user.nil?
+      params['userId'] = user['id']
+    end
+    id_list = parse_id_list(args)
+    if client_id
+      confirm!("Are you sure you want to perform this bulk delete tokens '#{client_id}'?", options)
+      params['clientId'] = client_id
+      execute_api(@tokens_interface, :destroy_all, [params], options) do |json_response|
+        print_green_success "Removed all your tokens for client #{client_id}"
+      end
+    elsif id_list && !id_list.empty?
+      confirm!("Are you sure you want to perform this bulk delete of #{id_list.size} tokens?", options)
+      params['id'] = id_list
+      execute_api(@tokens_interface, :destroy_all, [params], options) do |json_response|
+        print_green_success "Removed #{id_list.size} tokens"
+      end
+    else
+      raise_command_error "Bulk delete requires a list of ids"
+    end
+  end
+
+  protected
+
+  def token_columns
+    {
+      "ID" => lambda {|it| it['id'] },
+      "Name" => lambda {|it| it['name'] },
+      "Client ID" => lambda {|it| it['clientId'] },
+      "Username" => lambda {|it| it['username'] },
+      "Access Token" => lambda {|it| it['maskedAccessToken'] },
+      #"Refresh Token" => lambda {|it| it['maskedRefreshToken'] },
+      "Scope" => lambda {|it| it['scope'] },
+      "Expiration" => lambda {|it| format_local_dt(it['expiration']) },
+      "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
+      },
+      # "Date Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+    }
+  end
+
+  def add_token_option_types
+    [
+      {'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'description' => "Optional display name for this access token"},
+      {'fieldName' => 'clientId', 'fieldLabel' => 'Client ID', 'type' => 'select', 'optionSource' => 'clients', 'required' => true, 'defaultValue' => 'morph-api'},
+    ]
+  end
+
+  def find_token_by_name_or_id(val, user_id=nil)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_token_by_id(val, user_id=nil)
+    else
+      return find_token_by_name(val, user_id=nil)
+    end
+  end
+
+  def find_token_by_id(id, user_id=nil)
+    params = {}
+    params['userId'] = user_id if user_id
+    begin
+      json_response = @tokens_interface.get(id.to_i, params)
+      return json_response['token']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Token not found by id '#{id}'" + (user_id ? " for user #{user_id}" : "")
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_token_by_name(name, user_id=nil)
+    params = {name: name.to_s}
+    params['userId'] = user_id if user_id
+    json_response = @tokens_interface.list(params)
+    tokens = json_response['tokens']
+    if tokens.empty?
+      print_red_alert "Token not found by name '#{name}'" + (user_id ? " for user #{user_id}" : "")
+      return nil
+    elsif tokens.size > 1
+      print_red_alert "#{tokens.size} tokens found matching '#{name}'" + (user_id ? " for user #{user_id}" : "")
+      puts_error as_pretty_table(tokens, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return tokens[0]
+    end
+  end
+
+  def find_token_by_token(value, user_id=nil)
+    params = {token: value.to_s}
+    params['userId'] = user_id if user_id
+    json_response = @tokens_interface.list(params)
+    tokens = json_response['tokens']
+    if tokens.empty?
+      print_red_alert "Tokens not found by value" + (user_id ? " for user #{user_id}" : "")
+      return nil
+    elsif tokens.size > 1
+      print_red_alert "#{tokens.size} tokens found matching '#{value}'" + (user_id ? " for user #{user_id}" : "")
+      puts_error as_pretty_table(tokens, [:id, :'accessToken'], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return tokens[0]
+    end
+  end
+
+end

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

@@ -726,11 +726,24 @@ class Morpheus::Cli::Workflows
         # prompt to workflow optionTypes for customOptions
         custom_options = nil
         if workflow['optionTypes'] && workflow['optionTypes'].size() > 0
+          # Clone to avoid mutating workflow data, and clear fieldContext so that
+          # accumulated results remain flat (not nested under 'customOptions') when
+          # passed as params to dependent option source API calls. If fieldContext
+          # were left as 'customOptions', option_params would be sent to the options
+          # API as customOptions[zoneId]=2 instead of the expected flat zoneId=2,
+          # causing dependent option lists (e.g. Resource Pools) to return empty.
           custom_option_types = workflow['optionTypes'].collect {|it|
-            it['fieldContext'] = 'customOptions'
-            it
+            ot = it.clone
+            ot.delete('fieldContext')
+            ot
           }
-          custom_options = Morpheus::Cli::OptionTypes.prompt(custom_option_types, options[:options], @api_client, {})
+          # Support both -O fieldName=value AND the legacy -O customOptions.fieldName=value syntax.
+          prompt_options = (options[:options] || {}).dup
+          if prompt_options['customOptions'].is_a?(Hash)
+            prompt_options.merge!(prompt_options.delete('customOptions'))
+          end
+          prompt_results = Morpheus::Cli::OptionTypes.prompt(custom_option_types, prompt_options, @api_client, {})
+          custom_options = {'customOptions' => prompt_results} unless prompt_results.empty?
         end
         job_payload = {}
         job_payload.deep_merge!(params)

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

@@ -63,11 +63,11 @@ module Morpheus::Cli::InfrastructureHelper
     @subnet_types_interface
   end
 
-  def find_group_by_name_or_id(val)
+  def find_group_by_name_or_id(val, include_tenants=true)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_group_by_id(val)
     else
-      return find_group_by_name(val)
+      return find_group_by_name(val, include_tenants)
     end
   end
 
@@ -85,21 +85,29 @@ module Morpheus::Cli::InfrastructureHelper
     end
   end
 
-  def find_group_by_name(name)
-    json_results = groups_interface.list({name: name})
-    if json_results['groups'].empty?
+  def find_group_by_name(name, include_tenants=false)
+    params = {name: name}
+    params['includeTenants'] = true if include_tenants
+    groups = groups_interface.list(params)['groups']
+    if groups.empty?
       print_red_alert "Group not found by name #{name}"
       exit 1
+    elsif groups.size > 1
+      print_red_alert "Multiple groups exist with the name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(groups, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      exit 1
     end
-    group = json_results['groups'][0]
-    return group
+    return groups[0]
   end
 
-  def find_cloud_by_name_or_id(val)
+  def find_cloud_by_name_or_id(val, include_tenants=false)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_cloud_by_id(val)
     else
-      return find_cloud_by_name(val)
+      return find_cloud_by_name(val, include_tenants)
     end
   end
 
@@ -113,14 +121,22 @@ module Morpheus::Cli::InfrastructureHelper
     return cloud
   end
 
-  def find_cloud_by_name(name)
-    json_results = clouds_interface.list({name: name})
-    if json_results['zones'].empty?
+  def find_cloud_by_name(name, include_tenants=false)
+    params = {name: name}
+    params['includeTenants'] = true if include_tenants
+    clouds = clouds_interface.list(params)['zones']
+    if clouds.empty?
       print_red_alert "Cloud not found by name #{name}"
       exit 1
+    elsif clouds.size > 1
+      print_red_alert "Multiple clouds exist with the name '#{name}'"
+      print_error "\n"
+      puts_error as_pretty_table(clouds, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      exit 1
     end
-    cloud = json_results['zones'][0]
-    return cloud
+    return clouds[0]
   end
 
   def get_available_cloud_types(refresh=false, params = {})

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

@@ -225,11 +225,11 @@ module Morpheus::Cli::ProvisioningHelper
     end
   end
 
-  def find_instance_by_name_or_id(val)
+  def find_instance_by_name_or_id(val, include_tenants=false)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_instance_by_id(val)
     else
-      return find_instance_by_name(val)
+      return find_instance_by_name(val, include_tenants)
     end
   end
 
@@ -247,14 +247,21 @@ module Morpheus::Cli::ProvisioningHelper
     end
   end
 
-  def find_instance_by_name(name)
-    json_results = instances_interface.list({name: name.to_s})
-    if json_results['instances'].empty?
+  def find_instance_by_name(name, include_tenants=false)
+    params = {name: name.to_s}
+    params['includeTenants'] = true if include_tenants
+    instances = instances_interface.list(params)['instances']
+    if instances.empty?
       print_red_alert "Instance not found by name #{name}"
       exit 1
+    elsif instances.size > 1
+      print_red_alert "Multiple Instances exist with the name '#{name}'"
+      puts_error as_pretty_table(instances, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print_error reset,"\n"
+      exit 1
     end
-    instance = json_results['instances'][0]
-    return instance
+    return instances[0]
   end
 
   def parse_instance_id_list(id_list)
@@ -1056,6 +1063,13 @@ module Morpheus::Cli::ProvisioningHelper
       end
     end
 
+    # Fix any hugepages option type is using on/off which
+    if payload['config']
+      if payload['config']['hugepages'] == "off"
+        payload['config'].delete('hugepages')
+      end
+    end
+
     return payload
   end
 

data/lib/morpheus/cli/version.rb

@@ -1,6 +1,6 @@
 
 module Morpheus
   module Cli
-    VERSION = "8.1.1.1"
+    VERSION = "9.0.0"
   end
 end

data/test/api/systems_interface_test.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+$LOAD_PATH.unshift(File.expand_path('../../lib', __dir__))
+require 'morpheus/api/systems_interface'
+
+class SystemsInterfaceTest < Test::Unit::TestCase
+
+  def setup
+    @systems_interface = Morpheus::SystemsInterface.new(access_token: 'token', url: 'https://example.test', verify_ssl: false)
+  end
+
+  def test_list_network_server_update_definitions_builds_expected_request
+    request = @systems_interface.dry.list_network_server_update_definitions(2, 3, {phrase: 'fw'})
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/infrastructure/systems/2/network-servers/3/update-definitions', request[:url]
+    assert_equal({phrase: 'fw'}, request[:params])
+  end
+
+  def test_apply_network_server_update_definition_builds_expected_request
+    request = @systems_interface.dry.apply_network_server_update_definition(2, 3, 4, {dryRun: true}, {foo: 'bar'})
+    assert_equal :post, request[:method]
+    assert_equal 'https://example.test/api/infrastructure/systems/2/network-servers/3/update-definitions/4', request[:url]
+    assert_equal({foo: 'bar'}, request[:params])
+    assert_equal({dryRun: true}.to_json, request[:payload])
+  end
+
+end