morpheus-cli 5.3.3 → 5.4.2

data/lib/morpheus/api/read_interface.rb

@@ -6,9 +6,10 @@ require 'morpheus/api/api_client'
 class Morpheus::ReadInterface < Morpheus::APIClient
 
   # subclasses should override in your interface
-  # Example: "/api/thing-types"
+  # Example: "/api/things"
   def base_path
-    raise "#{self.class} has not defined base_path!"
+    raise "#{self.class} has not defined base_path!" if @options[:base_path].nil?
+    @options[:base_path]
   end
 
   def list(params={}, headers={})
@@ -17,7 +18,7 @@ class Morpheus::ReadInterface < Morpheus::APIClient
 
   def get(id, params={}, headers={})
     validate_id!(id)
-    execute(method: :get, url: "#{base_path}/#{id}", params: params, headers: headers)
+    execute(method: :get, url: "#{base_path}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
 end

data/lib/morpheus/api/rest_interface.rb

@@ -7,7 +7,8 @@ class Morpheus::RestInterface < Morpheus::APIClient
   # subclasses should override in your interface
   # Example: "/api/things"
   def base_path
-    raise "#{self.class} has not defined base_path!"
+    raise "#{self.class} has not defined base_path!" if @options[:base_path].nil?
+    @options[:base_path]
   end
 
   def list(params={}, headers={})
@@ -16,7 +17,7 @@ class Morpheus::RestInterface < Morpheus::APIClient
 
   def get(id, params={}, headers={})
     validate_id!(id)
-    execute(method: :get, url: "#{base_path}/#{id}", params: params, headers: headers)
+    execute(method: :get, url: "#{base_path}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
   def create(payload, params={}, headers={})
@@ -25,12 +26,12 @@ class Morpheus::RestInterface < Morpheus::APIClient
 
   def update(id, payload, params={}, headers={})
     validate_id!(id)
-    execute(method: :put, url: "#{base_path}/#{id}", params: params, payload: payload, headers: headers)
+    execute(method: :put, url: "#{base_path}/#{CGI::escape(id.to_s)}", params: params, payload: payload, headers: headers)
   end
 
   def destroy(id, params = {}, headers={})
     validate_id!(id)
-    execute(method: :delete, url: "#{base_path}/#{id}", params: params, headers: headers)
+    execute(method: :delete, url: "#{base_path}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
 end

data/lib/morpheus/api/roles_interface.rb

@@ -92,6 +92,13 @@ class Morpheus::RolesInterface < Morpheus::APIClient
     execute(method: :put, url: url, headers: headers, payload: payload.to_json)
   end
 
+  def update_report_type(account_id, id, options)
+    url = build_url(account_id, id) + "/update-report-type"
+    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
+    payload = options
+    execute(method: :put, url: url, headers: headers, payload: payload.to_json)
+  end
+
   private
 
   def build_url(account_id=nil, role_id=nil)

data/lib/morpheus/api/secondary_read_interface.rb

@@ -19,7 +19,7 @@ class Morpheus::SecondaryReadInterface < Morpheus::APIClient
   def get(resource_id, id, params={}, headers={})
     validate_id!(resource_id)
     validate_id!(id)
-    execute(method: :get, url: "#{base_path(resource_id)}/#{id}", params: params, headers: headers)
+    execute(method: :get, url: "#{base_path(resource_id)}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
 end

data/lib/morpheus/api/secondary_rest_interface.rb

@@ -2,41 +2,41 @@ require 'morpheus/api/api_client'
 
 # Interface class to be subclassed by interfaces that provide CRUD endpoints
 # for objects underneath another resource
-# Subclasses must override the base_path(resource_id) method
+# Subclasses must override the base_path(parent_id) method
 class Morpheus::SecondaryRestInterface < Morpheus::APIClient
 
   # subclasses should override in your interface
-  # Example: "/api/things/#{resource_id}/widgets"
-  def base_path(resource_id)
-    raise "#{self.class} has not defined base_path(resource_id)!"
+  # Example: "/api/things/#{parent_id}/widgets"
+  def base_path(parent_id)
+    raise "#{self.class} has not defined base_path(parent_id)!"
   end
 
-  def list(resource_id, params={}, headers={})
-    validate_id!(resource_id)
-    execute(method: :get, url: "#{base_path(resource_id)}", params: params, headers: headers)
+  def list(parent_id, params={}, headers={})
+    validate_id!(parent_id)
+    execute(method: :get, url: "#{base_path(parent_id)}", params: params, headers: headers)
   end
 
-  def get(resource_id, id, params={}, headers={})
-    validate_id!(resource_id)
+  def get(parent_id, id, params={}, headers={})
+    validate_id!(parent_id)
     validate_id!(id)
-    execute(method: :get, url: "#{base_path(resource_id)}/#{id}", params: params, headers: headers)
+    execute(method: :get, url: "#{base_path(parent_id)}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
-  def create(resource_id, payload, params={}, headers={})
-    validate_id!(resource_id)
-    execute(method: :post, url: "#{base_path(resource_id)}", params: params, payload: payload, headers: headers)
+  def create(parent_id, payload, params={}, headers={})
+    validate_id!(parent_id)
+    execute(method: :post, url: "#{base_path(parent_id)}", params: params, payload: payload, headers: headers)
   end
 
-  def update(resource_id, id, payload, params={}, headers={})
-    validate_id!(resource_id)
+  def update(parent_id, id, payload, params={}, headers={})
+    validate_id!(parent_id)
     validate_id!(id)
-    execute(method: :put, url: "#{base_path(resource_id)}/#{id}", params: params, payload: payload, headers: headers)
+    execute(method: :put, url: "#{base_path(parent_id)}/#{CGI::escape(id.to_s)}", params: params, payload: payload, headers: headers)
   end
 
-  def destroy(resource_id, id, params = {}, headers={})
-    validate_id!(resource_id)
+  def destroy(parent_id, id, params = {}, headers={})
+    validate_id!(parent_id)
     validate_id!(id)
-    execute(method: :delete, url: "#{base_path(resource_id)}/#{id}", params: params, headers: headers)
+    execute(method: :delete, url: "#{base_path(parent_id)}/#{CGI::escape(id.to_s)}", params: params, headers: headers)
   end
 
 end

data/lib/morpheus/api/storage_server_types_interface.rb

@@ -0,0 +1,14 @@
+require 'morpheus/api/read_interface'
+
+class Morpheus::StorageServerTypesInterface < Morpheus::ReadInterface
+
+  def base_path
+    "/api/storage-server-types"
+  end
+
+  # def option_types(id, params={}, headers={})
+  #   validate_id!(id)
+  #   execute(method: :get, url: "#{base_path}/#{id}/option-types", params: params, headers: headers)
+  # end
+
+end

data/lib/morpheus/api/storage_servers_interface.rb

@@ -0,0 +1,9 @@
+require 'morpheus/api/rest_interface'
+
+class Morpheus::StorageServersInterface < Morpheus::RestInterface
+
+  def base_path
+    "/api/storage-servers"
+  end
+
+end

data/lib/morpheus/api/storage_volume_types_interface.rb

@@ -0,0 +1,9 @@
+require 'morpheus/api/read_interface'
+
+class Morpheus::StorageVolumeTypesInterface < Morpheus::ReadInterface
+
+  def base_path
+    "/api/storage-volume-types"
+  end
+
+end

data/lib/morpheus/api/storage_volumes_interface.rb

@@ -0,0 +1,9 @@
+require 'morpheus/api/rest_interface'
+
+class Morpheus::StorageVolumesInterface < Morpheus::RestInterface
+
+  def base_path
+    "/api/storage-volumes"
+  end
+
+end

data/lib/morpheus/api/users_interface.rb

@@ -1,78 +1,31 @@
-require 'morpheus/api/api_client'
+require 'morpheus/api/rest_interface'
 
-class Morpheus::UsersInterface < Morpheus::APIClient
+class Morpheus::UsersInterface < Morpheus::RestInterface
 
-  def get(account_id, id, params={})
-    raise "#{self.class}.get() passed a blank id!" if id.to_s == ''
-    url = build_url(account_id, id)
-    headers = { params: params, authorization: "Bearer #{@access_token}" }
-    opts = {method: :get, url: url, timeout: 10, headers: headers}
-    execute(opts)
+  def base_path
+    "/api/users"
   end
 
-  def list(account_id, params={})
-    url = build_url(account_id)
-    headers = { params: params, authorization: "Bearer #{@access_token}" }
-    opts = {method: :get, url: url, timeout: 10, headers: headers}
-    execute(opts)
+  def feature_permissions(id, params={}, headers={})
+    validate_id!(id)
+    execute(method: :get, url: "#{base_path}/#{id}/feature-permissions", params: params, headers: headers)
   end
 
-  def feature_permissions(account_id, id)
-    url = build_url(account_id, id) + "/feature-permissions"
-    headers = { params: {}, authorization: "Bearer #{@access_token}" }
-    opts = {method: :get, url: url, timeout: 10, headers: headers}
-    execute(opts)
+  def permissions(id, params={}, headers={})
+    validate_id!(id)
+    execute(method: :get, url: "#{base_path}/#{id}/permissions", params: params, headers: headers)
   end
 
-  def permissions(account_id, id)
-    url = build_url(account_id, id) + "/permissions"
-    headers = { params: {}, authorization: "Bearer #{@access_token}" }
-    opts = {method: :get, url: url, timeout: 10, headers: headers}
-    execute(opts)
-  end
-
-  def available_roles(account_id, id=nil, options={})
-    url = build_url(account_id, id) + "/available-roles"
-    headers = { params: {}, authorization: "Bearer #{@access_token}" }
-    headers[:params].merge!(options)
-    opts = {method: :get, url: url, timeout: 10, headers: headers}
-    execute(opts)
-  end
-
-  def create(account_id, options)
-    url = build_url(account_id)
-    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-    payload = options
-    opts = {method: :post, url: url, timeout: 10, headers: headers, payload: payload.to_json}
-    execute(opts)
-  end
-
-  def update(account_id, id, options)
-    url = build_url(account_id, id)
-    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-    payload = options
-    opts = {method: :put, url: url, timeout: 10, headers: headers, payload: payload.to_json}
-    execute(opts)
-  end
-
-  def destroy(account_id, id)
-    url = build_url(account_id, id)
-    headers = { :authorization => "Bearer #{@access_token}", 'Content-Type' => 'application/json' }
-    opts = {method: :delete, url: url, timeout: 10, headers: headers}
-    execute(opts)
+  def available_roles(id=nil, params={}, headers={})
+    execute(method: :get, url: "#{build_url(id)}/available-roles", params: params, headers: headers)
   end
 
   private
 
-  def build_url(account_id=nil, user_id=nil)
-    url = "#{@base_url}/api"
-    if account_id
-      url += "/accounts/#{account_id}/users"
-    else
-      url += "/users"
-    end
-    if user_id
-      url += "/#{user_id}"
+  def build_url(id=nil)
+    url = base_path
+    if id
+      url += "/#{id}"
     end
     url
   end

data/lib/morpheus/api/virtual_servers_interface.rb

@@ -0,0 +1,9 @@
+require 'morpheus/api/rest_interface'
+
+class Morpheus::VirtualServersInterface < Morpheus::RestInterface
+
+  def base_path
+    "/api/load-balancer-virtual-servers"
+  end
+
+end

data/lib/morpheus/cli/cli_command.rb

@@ -1,15 +1,14 @@
-require 'yaml'
-require 'json'
-require 'fileutils'
 require 'morpheus/logging'
 require 'morpheus/benchmarking'
-require 'morpheus/cli/option_parser'
+require 'morpheus/terminal'
 require 'morpheus/cli/cli_registry'
+require 'morpheus/cli/option_parser'
+require 'morpheus/cli/option_types'
 require 'morpheus/cli/mixins/print_helper'
 require 'morpheus/cli/credentials'
+#require 'morpheus/cli/commands/shell'
+#require 'morpheus/cli/commands/remote'
 require 'morpheus/api/api_client'
-require 'morpheus/cli/remote'
-require 'morpheus/terminal'
 
 module Morpheus
   module Cli
@@ -215,7 +214,8 @@ module Morpheus
           opts.on(arg1, arg2, description) do |val|
             if option_type['type'] == 'checkbox'
               val = (val.to_s != 'false' && val.to_s != 'off')
-            else
+            elsif option_type['dataType'] != 'string'
+              # 'dataType': 'string' added to cli to avoid auto conversion to JSON
               # attempt to parse JSON, this allows blank arrays for multiSelect like --tenants []
               if (val.to_s[0] == '{' && val.to_s[-1] == '}') || (val.to_s[0] == '[' && val.to_s[-1] == ']')
                 begin
@@ -1011,7 +1011,7 @@ module Morpheus
         # meh, could deprecate and make subcommand define handle() itself
         # if args.count == 0 && default_subcommand
         #   # p "using default subcommand #{default_subcommand}"
-        #   return self.send(default_subcommand, args || [])
+        #   return send(default_subcommand, args || [])
         # end
         subcommand_name = args[0]
         if args.empty?
@@ -1032,7 +1032,7 @@ module Morpheus
           error_msg = "'#{command_name} #{subcommand_name}' is not a #{prog_name} command.\n#{full_command_usage}"
           raise CommandNotFoundError.new(error_msg)
         end
-        self.send(cmd_method, args[1..-1])
+        send(cmd_method, args[1..-1])
       end
 
       def handle(args)
@@ -1230,6 +1230,72 @@ module Morpheus
         true
       end
 
+      # The default way to build options for the list command
+      # @param [OptionParser] opts
+      # @param [Hash] options
+      # @param [Hash] params
+      def build_list_options(opts, options, params)
+        build_standard_list_options(opts, options)
+      end
+
+      # The default way to parse options for the list command
+      # @param [Array] args
+      # @param [Hash] options
+      # @param [Hash] params
+      def parse_list_options!(args, options, params)
+        if args.count > 0
+          options[:phrase] = args.join(" ")
+          # params['phrase'] =  = args.join(" ")
+        end
+        params.merge!(parse_list_options(options))
+      end
+
+      # The default way to build options for the list command
+      # @param [OptionParser] opts
+      # @param [Hash] options
+      # @param [Hash] params
+      def build_get_options(opts, options, params)
+        build_standard_get_options(opts, options)
+      end
+      
+      # The default way to parse options for the get command
+      # @param [OptionParser] opts
+      # @param [Hash] options
+      # @param [Hash] params
+      def parse_get_options!(args, options, params)
+        params.merge!(parse_query_options(options))
+      end
+
+      # The default way to parse options for the get command
+      # @param type [string]
+      # @param options [Hash] The command options
+      # @param params [Hash] The query parameters the output is being appended to
+      # @param param_name [String]
+      # @param lookup_ids [Boolean] Also lookup ids to make sure they exist or else error
+      # @return 
+      def parse_parameter_as_resource_id!(type, options, params, param_name=nil, lookup_ids=false)
+        # type = type.to_s.singularize
+        if options.key?(type)
+          val = options[type].to_s
+          param_name ||= "#{type.to_s.camelcase}Id"
+          if val
+            if val.to_s !~ /\A\d{1,}\Z/ || lookup_ids
+              record = find_by_name(type, val)
+              if record.nil?
+                 # avoid double error render by exiting here, ew
+                exit 1
+                raise_command_error "Storage Server not found for '#{val}'"
+              end
+              params[param_name] = record['id']
+            else
+              params[param_name] = val
+            end
+            return params[param_name]
+          end
+        end
+        return nil
+      end
+
       # parse the parameters provided by the common :list options
       # this includes the :query options too via parse_query_options().
       # returns Hash of params the format {"phrase": => "foobar", "max": 100}
@@ -1244,7 +1310,11 @@ module Morpheus
         end
         # arbitrary filters
         list_params.merge!(parse_query_options(options))
-        
+        # ok, any string keys in options can become query parameters, eg. options['name'] = 'foobar'
+        # do it!
+        # options.each do |k, v|
+        #   list_params[k] = v
+        # end
         return list_params
       end
 
@@ -1365,7 +1435,7 @@ module Morpheus
           full_outfile = File.expand_path(options[:outfile])
           if output
             print_to_file(output, options[:outfile], options[:overwrite])
-            print "#{cyan}Wrote output to file #{options[:outfile]} (#{File.size(full_outfile)} B)\n" unless options[:quiet]
+            print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes(File.size(full_outfile))})\n" unless options[:quiet]
           else
             # uhhh ok lets try this
             Morpheus::Logging::DarkPrinter.puts "using experimental feature: --out without a common format like json, yml or csv" if Morpheus::Logging.debug?
@@ -1373,7 +1443,7 @@ module Morpheus
             if result && result != 0
               return result
             end
-            print "#{cyan}Wrote output to file #{options[:outfile]} (#{File.size(full_outfile)} B)\n" unless options[:quiet]
+            print "#{cyan}Wrote output to file #{options[:outfile]} (#{format_bytes(File.size(full_outfile))})\n" unless options[:quiet]
             return 0, nil
           end
         else
@@ -1404,6 +1474,184 @@ module Morpheus
 
       alias :render_with_format :render_response
 
+      # Dynamic find methods to load a record of any type
+      # def find_by_name_or_id(type, val)
+      #   interface = instance_variable_get "@#{type}s_interface"
+      #   typeCamelCase = type.gsub(/(?:^|_)([a-z])/) do $1.upcase end
+      #   typeCamelCase = typeCamelCase[0, 1].downcase + typeCamelCase[1..-1]
+      #   (val.to_s =~ /\A\d{1,}\Z/) ? interface.get(val.to_i)[typeCamelCase] : interface.list({'name' => val})["#{typeCamelCase}s"].first
+      # end
+
+      # Find a resource by type and name or id
+      # @param type [String of Symbol] Type of resource formatted as singular, lowerscore with underscores.
+      # @param *id [String or Numeric] ID of resource, multiple arguments may be passed when using a secondary interface where parent_id, id is required.
+      # Example: find_by_name_or_id("instance", "K2")
+      #          find_by_name_or_id("storage_volume", 42)
+      #          find_by_name_or_id("instance", "My Instance")
+      #          find_by_name_or_id("load_balancer_pool", load_balancer_id, id)
+      def find_by_name_or_id(*args)
+        val = args.last
+        if val.to_s =~ /\A\d{1,}\Z/
+          return find_by_id(*args)
+        else
+          return find_by_name(*args)
+        end
+      end
+
+      
+      # Find a resource by type and id
+      # Usage: find_by_name_or_id("app", 3)
+      def find_by_id(*args)
+        #Morpheus::Logging::DarkPrinter.puts "find_by_id(#{args.join(', ')})" if Morpheus::Logging.debug?
+        # type, ids = args.first, args[1..-1]
+        type, *ids = args
+        type = type.to_s.singularize.underscore
+        # still relying on the command or helper to define these _label and _key methods
+        label = send("#{type}_label")
+        object_key = send("#{type}_object_key")
+        interface_name = "@#{type.pluralize}_interface"
+        interface = instance_variable_get(interface_name)
+        if interface.nil?
+          raise "#{self.class} has not defined interface #{interface_name}"
+        end
+        begin
+          json_response = interface.get(*ids)
+          return json_response[object_key]
+        rescue Exception => e
+          if e.response && e.response.code == 404
+            print_red_alert "#{label} not found by id #{ids.last}"
+            return nil
+          else
+            raise e
+          end
+        end
+      end
+
+      # Find a record by type and name
+      # Usage: find_by_name_or_id("network", "Skynet")
+      def find_by_name(*args)
+        #Morpheus::Logging::DarkPrinter.puts "find_by_name(#{args.join(', ')})" if Morpheus::Logging.debug?
+        # type, ids = args.first, args[1..-1]
+        type, *ids = args
+        type = type.to_s.singularize.underscore
+        val = ids.pop
+        params = {}
+        name_property = 'name'
+        if type == 'user'
+          name_property = 'username'
+          params['global'] = 'true'
+        end
+        params[name_property] = val.to_s
+        request_args = ids + [params]
+        request_args.unshift(type)
+        records = find_all(*request_args)
+        # still relying on the command or helper to define these _label and _key methods
+        label = respond_to?("#{type}_label", true) ? send("#{type}_label") : type.titleize
+        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_property} '#{val}'"
+          print_error "\n"
+          if type == "user"
+            puts_error as_pretty_table(records, [:id, :username, {"FIRST NAME" => "firstName"}, {"LAST NAME" => "lastName"}, {"TENANT" => lambda {|it| it['account']['name'] rescue ''}}], {color:red})
+          else
+            puts_error as_pretty_table(records, [:id, :name], {color:red})
+          end
+          print_red_alert "Try using ID instead"
+          print_error reset,"\n"
+          return nil
+        else
+          return records[0]
+        end
+      end
+
+      # Load a list of records by type
+      # @example Find an app by id
+      # find_record(:app, 1)
+      # report_types = find_all("reportTypes", {phrase:"amazon"})
+      # pools = find_all("loadBalancerPool", load_balancer_id)
+      # @return Array of records
+      def find_all(*args)
+        #Morpheus::Logging::DarkPrinter.puts "find_all(#{args.join(', ')})" if Morpheus::Logging.debug?
+        type, *request_args = args
+        type = type.to_s.singularize.underscore
+        list_key = respond_to?("#{type}_list_key", true) ? send("#{type}_list_key") : type.camelcase.pluralize
+        json_response = find_all_json(*args)
+        if !json_response.key?(list_key)
+          # maybe just use the first key like this:
+          # list_key = json_response.keys.find { |k| json_response[k].is_a?(Array) }
+          # print_error(json_response) if Morpheus::Logging.debug?
+          raise "API response is missing list property '#{list_key}'"
+        end
+        return json_response[list_key]
+      end
+
+      # Load json response for a list of records by type
+      # @return Hash of JSON data
+      def find_all_json(*args)
+        type, *request_args = args
+        get_interface(type).list(*request_args)
+      end
+
+      alias :find_all_records :find_all
+      alias :find_all_records_json :find_all_json
+
+      # Load a single record (Hash) by type and id and optional parameters
+      # Examples:
+      # apps = find_record(:app)
+      # report_types = find_record("reportTypes", {phrase:"amazon"})
+      # pools = find_record("loadBalancerPool", balancer_id)
+      # @return [Hash] of the object that was found or raises an exception if 404 not found encountered.
+      def find_record(*args)
+        #Morpheus::Logging::DarkPrinter.puts "find_record(#{args.join(', ')})" if Morpheus::Logging.debug?
+        type, *request_args = args
+        type = type.to_s.singularize.underscore
+        object_key = respond_to?("#{type}_object_key", true) ? send("#{type}_object_key") : type.camelcase.singularize
+        json_response = find_record_json(*args)
+        if !json_response.key?(object_key)
+          # maybe just use the first key like this:
+          # object_key = json_response.keys.find { |k| json_response[k].is_a?(Hash) }
+          # print_error(json_response) if Morpheus::Logging.debug?
+          raise "API response is missing object property '#{object_key}'"
+        end
+        return json_response[object_key]
+      end
+
+      # Load list of records by type and (optional) parameters
+      # Examples:
+      # apps = find_record(:app, 1)
+      # report_types = find_record("reportType", 1)
+      # pools = find_all("loadBalancerPool", load_balancer_id)
+      def find_record_json(*args)
+        #Morpheus::Logging::DarkPrinter.puts "find_record_json(#{args.join(', ')})" if Morpheus::Logging.debug?
+        type, *request_args = args
+        get_interface(type).get(*request_args)
+      end
+
+       # Load json response for a list of records by type
+      def get_interface(type)
+        #Morpheus::Logging::DarkPrinter.puts "get_interface(#{type})" if Morpheus::Logging.debug?
+        # todo: can probably just do @api_client ? @api_client.interface(interface_name) : nil
+        type = type.to_s.singularize.underscore
+        interface_name = "@#{type.pluralize}_interface"
+        interface = nil
+        if instance_variable_defined?(interface_name)
+          interface = instance_variable_get(interface_name)
+          if interface.nil?
+            # Fix is to update connect() to do @apps_interface = @api_client.apps
+            raise "API Interface #{interface_name} is nil"
+          end
+        else
+          if @api_client.is_a?(Morpheus::APIClient)
+            interface = @api_client.interface(type.pluralize)
+          else
+            raise "#{self.class} has not initalized @api_client"
+          end
+        end
+        return interface
+      end
+
       module ClassMethods
 
         def prog_name
@@ -1411,14 +1659,14 @@ module Morpheus
         end
 
         def set_command_name(cmd_name)
-          @command_name = cmd_name
+          @command_name = cmd_name.to_sym
           Morpheus::Cli::CliRegistry.add(self, self.command_name)
         end
 
         def default_command_name
           class_name = self.name.split('::')[-1]
           #class_name.sub!(/Command$/, '')
-          Morpheus::Cli::CliRegistry.cli_ize(class_name)
+          Morpheus::Cli::CliRegistry.cli_ize(class_name).to_sym
         end
         
         def command_name

data/lib/morpheus/cli/cli_registry.rb

@@ -4,6 +4,7 @@ require 'morpheus/logging'
 require 'morpheus/cli/errors'
 require 'morpheus/cli/error_handler'
 require 'morpheus/cli/expression_parser'
+require 'morpheus/ext/string'
 
 module Morpheus
   module Cli
@@ -297,7 +298,7 @@ module Morpheus
           every_command = cached_command_list
           guess = command_name
           suggestions = []
-          while guess.size >= 3
+          while suggestions.empty? && guess.size >= 3
             plural_guess = guess.pluralize
             if every_command.include?(guess)
               suggestions << guess