morpheus-cli 4.2.16 → 4.2.17

data/lib/morpheus/cli/library_layouts_command.rb

@@ -652,7 +652,7 @@ EOT
     connect(options)
     exit_code, err = 0, nil
     # if !is_master_account
-    #   print_red_alert "Permissions only available for master account"
+    #   print_red_alert "Permissions only available for master tenant"
     #   return 1
     # end
     layout = find_layout_by_name_or_id(nil, args[0])

data/lib/morpheus/cli/login.rb

@@ -30,7 +30,7 @@ class Morpheus::Cli::Login
     username, password = nil, nil
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = usage
-      opts.on( '-u', '--username USERNAME', "Username" ) do |val|
+      opts.on( '-u', '--username USERNAME', "Username. Sub-tenant users must format their username with a prefix like {subdomain}\\{username}" ) do |val|
         username = val
       end
       opts.on( '-p', '--password PASSWORD', "Password" ) do |val|
@@ -50,11 +50,15 @@ class Morpheus::Cli::Login
       opts.footer = <<-EOT
 Login to a remote appliance with a username and password or using an access token.
 Logging in with username and password will make an authentication api request to obtain an access token.
+[username] is required, this is the username of the Morpheus User
+[password] is required, this is the password of the Morpheus User
+Sub-tenant users will need to pass their tenant subdomain prefix. ie. {subdomain}\\{username}
+By default, the subdomain is the tenant account ID. Example: 2\\neo
 The --token option can be used to login with a valid access token instead of username and password.
 The specified token will be verified by making a whoami api request
 If successful, the access token will be saved with the active session for the remote appliance.
-This command will first logout any active session before attempting authorization.
-The --test option is available for testing credentials without updating your active session, neithing logging you out or in.
+This command will first logout any active session before attempting authentication.
+The --test option can be used to test credentials without updating the stored credentials for the appliance, neither logging you in or out.
 EOT
                     
     end
@@ -106,6 +110,8 @@ EOT
           if options[:test_only]
             print green,"Success! Test Credentials verified for #{wallet['username']}", reset, "\n"
           else
+            # clear whoami cache, it will be lazily load_saved_credentials
+            ::Morpheus::Cli::Whoami.clear_whoami(@appliance_name, wallet['username'])
             print green,"Success! Logged in as #{wallet['username']}", reset, "\n"
           end
         end

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

@@ -33,6 +33,43 @@ module Morpheus::Cli::AccountsHelper
     @roles_interface
   end
 
+  ## Tenants (Accounts)
+
+  def account_column_definitions()
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      # "Name" => lambda {|it| it['name'].to_s + (it['master'] ? " (Master Tenant)" : '') },
+      "Description" => 'description',
+      "Subdomain" => 'subdomain',
+      "# Instances" => 'stats.instanceCount',
+      "# Users" => 'stats.userCount',
+      "Role" => lambda {|it| it['role']['authority'] rescue nil },
+      "Master" => lambda {|it| format_boolean(it['master']) },
+      "Currency" => 'currency',
+      "Status" => lambda {|it| 
+        status_state = nil
+        if it['active']
+          status_state = "#{green}ACTIVE#{cyan}"
+        else
+          status_state = "#{red}INACTIVE#{cyan}"
+        end
+        status_state
+      },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  def list_account_column_definitions()
+    columns = account_column_definitions
+    columns.delete("Subdomain")
+    columns.delete("Master")
+    columns.delete("Currency")
+    return columns.upcase_keys!
+  end
+
+
   def find_account_by_name_or_id(val)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_account_by_id(val)
@@ -47,7 +84,7 @@ module Morpheus::Cli::AccountsHelper
       return json_response['account']
     rescue RestClient::Exception => e
       if e.response && e.response.code == 404
-        print_red_alert "Account not found by id #{id}"
+        print_red_alert "Tenant not found by id #{id}"
       else
         raise e
       end
@@ -57,12 +94,12 @@ module Morpheus::Cli::AccountsHelper
   def find_account_by_name(name)
     accounts = accounts_interface.list({name: name.to_s})['accounts']
     if accounts.empty?
-      print_red_alert "Account not found by name #{name}"
+      print_red_alert "Tenant not found by name #{name}"
       return nil
     elsif accounts.size > 1
-      print_red_alert "#{accounts.size} accounts found by name #{name}"
-      print_accounts_table(accounts, {color: red})
-      print_red_alert "Try using -A ID instead"
+      print_red_alert "Found #{accounts.size} tenants by name '#{name}'. Try using ID instead: #{format_list(accounts.collect {|it| it['id']}, 'or', 3)}"
+      print "\n"
+      print as_pretty_table(accounts, [:id, :name, :description], {color: red, thin: true})
       print reset,"\n"
       return nil
     else
@@ -87,6 +124,35 @@ module Morpheus::Cli::AccountsHelper
     return account
   end
 
+  ## Roles
+
+  def role_column_definitions(options={})
+    {
+      "ID" => 'id',
+      "Name" => 'authority',
+      "Description" => 'description',
+      #"Scope" => lambda {|it| it['scope'] },
+      "Type" => lambda {|it| format_role_type(it) },
+      "Multitenant" => lambda {|it| 
+        format_boolean(it['multitenant']).to_s + (it['multitenantLocked'] ? " (LOCKED)" : "")
+      },
+      "Owner" => lambda {|it| it['owner'] ? it['owner']['name'] : '' },
+      #"Tenant" => lambda {|it| it['account'] ? it['account']['name'] : '' },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
+    }
+  end
+
+  def subtenant_role_column_definitions(options={})
+    {
+      "ID" => 'id',
+      "Name" => 'authority',
+      "Description" => 'description',
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
+    }
+  end
+
   def find_role_by_name_or_id(account_id, val)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_role_by_id(account_id, val)
@@ -114,9 +180,11 @@ module Morpheus::Cli::AccountsHelper
       print_red_alert "Role not found by name #{name}"
       return nil
     elsif roles.size > 1
-      print_red_alert "#{roles.size} roles by name #{name}"
-      print_roles_table(roles, {color: red, thin: true})
-      print reset,"\n\n"
+      print_red_alert "Found #{roles.size} roles by name '#{name}'. Try using ID instead: #{format_list(roles.collect {|it| it['id']}, 'or', 3)}"
+      print "\n"
+      # print as_pretty_table(accounts, [:id, :name, :description], {color: red, thin: true})
+      print as_pretty_table(roles, {"ID" => 'id', "Name" => 'authority',"Description" => 'description'}.upcase_keys!, {color: red, thin: true})
+      print reset,"\n"
       return nil
     else
       return roles[0]
@@ -125,17 +193,57 @@ module Morpheus::Cli::AccountsHelper
 
   alias_method :find_role_by_authority, :find_role_by_name
 
-  def find_user_by_username_or_id(account_id, val)
+
+  ## Users
+
+  def user_column_definitions()
+    {
+      "ID" => 'id',
+      "Tenant" => lambda {|it| it['account'] ? it['account']['name'] : '' },
+      "First Name" => 'firstName',
+      "Last Name" => 'lastName',
+      "Username" => 'username',
+      "Email" => 'email',
+      "Role" => lambda {|it| format_user_role_names(it) },
+      "Notifications" => lambda {|it| it['receiveNotifications'].nil? ? '' : format_boolean(it['receiveNotifications']) },
+      "Status" => lambda {|it| format_user_status(it) },
+      "Last Login" => lambda {|it| format_duration_ago(it['lastLoginDate']) },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
+    }
+  end
+
+  def list_user_column_definitions()
+    columns = user_column_definitions
+    columns.delete("Notifications")
+    return columns.upcase_keys!
+  end
+
+  def format_user_status(user, return_color=cyan)
+    if user["enabled"] != true
+      red + "DISABLED" + return_color
+    elsif user["accountLocked"]
+      red + "ACCOUNT LOCKED" + return_color
+    elsif user["accountExpired"]
+      yellow + "ACCOUNT EXPIRED" + return_color
+    elsif user["passwordExpired"]
+      yellow + "PASSWORD EXPIRED" + return_color
+    else
+      green + "ACTIVE" + return_color
+    end
+  end
+
+  def find_user_by_username_or_id(account_id, val, params={})
     if val.to_s =~ /\A\d{1,}\Z/
-      return find_user_by_id(account_id, val)
+      return find_user_by_id(account_id, val, params)
     else
-      return find_user_by_username(account_id, val)
+      return find_user_by_username(account_id, val, params)
     end
   end
 
-  def find_user_by_id(account_id, id)
+  def find_user_by_id(account_id, id, params={})
     begin
-      json_response = users_interface.get(account_id, id.to_i, {includePermissions:true})
+      json_response = users_interface.get(account_id, id.to_i, params)
       return json_response['user']
     rescue RestClient::Exception => e
       if e.response && e.response.code == 404
@@ -146,22 +254,23 @@ module Morpheus::Cli::AccountsHelper
     end
   end
 
-  def find_user_by_username(account_id, username)
-    users = users_interface.list(account_id, {username: username.to_s})['users']
+  def find_user_by_username(account_id, username, params={})
+    users = 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
     elsif users.size > 1
-      print_red_alert "#{users.size} users by username #{username}"
-      print_users_table(users, {color: red, thin: true})
-      print reset,"\n\n"
+      print_red_alert "Found #{users.size} users by username '#{username}'. Try using ID instead: #{format_list(users.collect {|it| it['id']}, 'or', 3)}"
+      print "\n"
+      print as_pretty_table(users, list_user_column_definitions, {color: red, thin: true})
+      print reset,"\n"
       return nil
     else
       return users[0]
     end
   end
 
-  def find_all_user_ids(account_id, usernames)
+  def find_all_user_ids(account_id, usernames, params={})
     user_ids = []
     if usernames.is_a?(String)
       usernames = usernames.split(",").collect {|it| it.to_s.strip }.select {|it| it }.uniq
@@ -170,11 +279,11 @@ module Morpheus::Cli::AccountsHelper
     end
     usernames.each do |username|
       # save a query
-      #user = find_user_by_username_or_id(nil, username)
+      #user = find_user_by_username_or_id(nil, username, params)
       if username.to_s =~ /\A\d{1,}\Z/
         user_ids << username.to_i
       else
-        user = find_user_by_username(account_id, username)
+        user = find_user_by_username(account_id, username, params)
         if user.nil?
           return nil
         else
@@ -185,6 +294,32 @@ module Morpheus::Cli::AccountsHelper
     user_ids
   end
 
+
+  ## User Groups
+
+  def user_group_column_definitions()
+    {
+      "ID" => lambda {|it| it['id'] },
+      #"Account" => lambda {|it| it['account'] ? it['account']['name'] : '' },
+      "Name" => lambda {|it| it['name'] },
+      "Description" => lambda {|it| it['description'] },
+      "Server Group" => lambda {|it| it['serverGroup'] },
+      "Sudo Access" => lambda {|it| format_boolean it['sudoAccess'] },
+      # "Shared User" => lambda {|it| format_boolean it['sharedUser'] },
+      "# Users" => lambda {|it| it['users'].size rescue nil },
+      "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
+      "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
+    }
+  end
+
+  def list_user_group_column_definitions()
+    columns = user_group_column_definitions
+    columns.delete("Sudo Access")
+    columns.delete("Server Group")
+    columns.delete("Updated")
+    return columns.upcase_keys!
+  end
+
   def find_user_group_by_name_or_id(account_id, val)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_user_group_by_id(account_id, val)
@@ -212,9 +347,8 @@ module Morpheus::Cli::AccountsHelper
       print_red_alert "User Group not found by name #{name}"
       return nil
     elsif user_groups.size > 1
-      print_red_alert "#{user_groups.size} user groups found by name #{name}"
-      print_user_groups_table(user_groups, {color: red})
-      print_red_alert "Try using ID instead"
+      print_red_alert "Found #{user_groups.size} user groups by name '#{name}'. Try using ID instead: #{format_list(user_groups.collect {|it| it['id']}, 'or', 3)}"
+      print as_pretty_table(user_groups, [:id, :name, :description], {color: red, thin: true})
       print reset,"\n"
       return nil
     else
@@ -222,36 +356,6 @@ module Morpheus::Cli::AccountsHelper
     end
   end
 
-  def print_accounts_table(accounts, options={})
-    table_color = options.key?(:color) ? options[:color] : cyan
-    rows = accounts.collect do |account|
-      status_state = nil
-      if account['active']
-        status_state = "#{green}ACTIVE#{table_color}"
-      else
-        status_state = "#{red}INACTIVE#{table_color}"
-      end
-      {
-        id: account['id'],
-        name: account['name'],
-        description: account['description'],
-        role: account['role'] ? account['role']['authority'] : nil,
-        status: status_state,
-        dateCreated: format_local_dt(account['dateCreated'])
-      }
-    end
-    print table_color if table_color
-    print as_pretty_table(rows, [
-      :id,
-      :name,
-      :description,
-      :role,
-      {:dateCreated => {:display_name => "Date Created"} },
-      :status
-    ], options.merge({color:table_color}))
-    print reset if table_color
-  end
-
   def format_role_type(role)
     str = ""
     if role['roleType'] == "account"
@@ -271,52 +375,6 @@ module Morpheus::Cli::AccountsHelper
     return str
   end
 
-  def print_roles_table(roles, options={})
-    table_color = options.key?(:color) ? options[:color] : cyan
-    rows = roles.collect do |role|
-      {
-        id: role['id'],
-        name: role['authority'],
-        description: role['description'],
-        scope: role['scope'],
-        multitenant: role['multitenant'] ? 'Yes' : 'No',
-        type: format_role_type(role),
-        owner: role['owner'] ? role['owner']['name'] : "System",
-        dateCreated: format_local_dt(role['dateCreated'])
-      }
-    end
-    columns = [
-      :id,
-      :name,
-      :description,
-      # options[:is_master_account] ? :scope : nil,
-      options[:is_master_account] ? :type : nil,
-      options[:is_master_account] ? :multitenant : nil,
-      options[:is_master_account] ? :owner : nil,
-      {:dateCreated => {:display_name => "Date Created"} }
-    ].compact
-    if options[:include_fields]
-      columns = options[:include_fields]
-    end
-    # print table_color if table_color
-    print as_pretty_table(rows, columns, options)
-    # print reset if table_color
-  end
-
-  def print_users_table(users, options={})
-    table_color = options[:color] || cyan
-    rows = users.collect do |user|
-      {id: user['id'], username: user['username'], name: user['displayName'], first: user['firstName'], last: user['lastName'], email: user['email'], role: format_user_role_names(user), account: user['account'] ? user['account']['name'] : nil}
-    end
-    columns = [:id, :account, :first, :last, :username, :email, :role]
-    if options[:include_fields]
-      columns = options[:include_fields] 
-    end
-    #print table_color if table_color
-    print as_pretty_table(rows, columns, options)
-    #print reset if table_color
-  end
-
   ## These user access formatted methods should probably move up to PrintHelper to be more ubiquitous.
 
   def format_user_role_names(user)

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

@@ -0,0 +1,115 @@
+require 'morpheus/cli/mixins/print_helper'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for infrastructure management
+module Morpheus::Cli::BackupsHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def backups_interface
+    # @api_client.groups
+    raise "#{self.class} has not defined @backups_interface" if @backups_interface.nil?
+    @backups_interface
+  end
+
+  def backup_jobs_interface
+    # @api_client.groups
+    raise "#{self.class} has not defined @backup_jobs_interface" if @backup_jobs_interface.nil?
+    @backup_jobs_interface
+  end
+
+  def backup_object_key
+    'backup'
+  end
+
+  def backup_list_key
+    'backups'
+  end
+
+  def find_backup_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_backup_by_id(val)
+    else
+      return find_backup_by_name(val)
+    end
+  end
+
+  def find_backup_by_id(id)
+    begin
+      json_response = backups_interface.get(id.to_i)
+      return json_response[backup_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Backup not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_backup_by_name(name)
+    json_response = backups_interface.list({name: name.to_s})
+    backups = json_response[backup_list_key]
+    if backups.empty?
+      print_red_alert "Backup not found by name '#{name}'"
+      return nil
+    elsif backups.size > 1
+      print_red_alert "#{backups.size} backups found by name '#{name}'"
+      puts_error as_pretty_table(backups, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return backups[0]
+    end
+  end
+
+  def backup_job_object_key
+    # 'backupJob'
+    'job'
+  end
+
+  def backup_job_list_key
+    # 'backupJobs'
+    'jobs'
+  end
+
+  def find_backup_job_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_backup_job_by_id(val)
+    else
+      return find_backup_job_by_name(val)
+    end
+  end
+
+  def find_backup_job_by_id(id)
+    begin
+      json_response = backup_jobs_interface.get(id.to_i)
+      return json_response[backup_job_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Backup job not found by id '#{id}'"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_backup_job_by_name(name)
+    json_response = backup_jobs_interface.list({name: name.to_s})
+    backup_jobs = json_response[backup_job_list_key]
+    if backup_jobs.empty?
+      print_red_alert "Backup job not found by name '#{name}'"
+      return nil
+    elsif backup_jobs.size > 1
+      print_red_alert "#{backup_jobs.size} backup jobs found by name '#{name}'"
+      puts_error as_pretty_table(backup_jobs, [:id, :name], {color:red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return backup_jobs[0]
+    end
+  end
+end