morpheus-cli 5.3.0.3 → 5.3.2.1

data/lib/morpheus/cli/log_settings_command.rb

@@ -6,11 +6,12 @@ class Morpheus::Cli::LogSettingsCommand
 
   set_command_name :'log-settings'
 
-  register_subcommands :get, :update
-  register_subcommands :enable_integration, :disable_integration, :remove_integration
+  register_subcommands :get, :update  
   register_subcommands :add_syslog_rule, :remove_syslog_rule
   
-  set_default_subcommand :get
+  # these command are deprecated in 5.3.3 and can be removed
+  register_subcommands :enable_integration, :disable_integration, :remove_integration
+  set_subcommands_hidden :enable_integration, :disable_integration, :remove_integration
 
   def connect(opts)
     @api_client = establish_remote_appliance_connection(opts)
@@ -186,6 +187,7 @@ class Morpheus::Cli::LogSettingsCommand
   end
 
   def enable_integration(args)
+    print_error yellow,"[DEPRECATED] The command `#{command_name} enable-integration` is deprecated.",reset,"\n"
     options = {}
 
     optparse = Morpheus::Cli::OptionParser.new do |opts|
@@ -240,6 +242,7 @@ class Morpheus::Cli::LogSettingsCommand
   end
 
   def disable_integration(args)
+    print_error yellow,"[DEPRECATED] The command `#{command_name} disable-integration` is deprecated.",reset,"\n"
     options = {}
 
     optparse = Morpheus::Cli::OptionParser.new do |opts|
@@ -285,6 +288,7 @@ class Morpheus::Cli::LogSettingsCommand
   end
 
   def remove_integration(args)
+    print_error yellow,"[DEPRECATED] The command `#{command_name } remove-integration` is deprecated.",reset,"\n"
     options = {}
 
     optparse = Morpheus::Cli::OptionParser.new do |opts|

data/lib/morpheus/cli/login.rb

@@ -36,6 +36,13 @@ class Morpheus::Cli::Login
       opts.on( '-p', '--password PASSWORD', "Password" ) do |val|
         password = val
       end
+      opts.on( '--password-file FILE', String, "Password File, read a file containing the password." ) do |val|
+        password_file = File.expand_path(val)
+        if !File.exists?(password_file) || !File.file?(password_file) # check readable too
+          raise ::OptionParser::InvalidOption.new("File not found: #{password_file}")
+        end
+        password = File.read(password_file) #.to_s.split("\n").first.strip
+      end
       opts.on( '-t', '--test', "Test credentials only, does not update stored credentials for the appliance." ) do
         options[:test_only] = true
       end
@@ -70,7 +77,9 @@ EOT
     # connect(options)
     @api_client = establish_remote_appliance_connection(options.merge({:no_prompt => true, :skip_verify_access_token => true, :skip_login => true}))
     
-    if @remote_appliance[:authenticated]
+    if options[:test_only]
+      puts "Testing credentials, your current session will not be modified."
+    elsif @remote_appliance[:authenticated]
       puts "You will be automatically logged out of your current session as '#{@remote_appliance[:username]}'"
     end
 

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

@@ -0,0 +1,156 @@
+require 'morpheus/cli/mixins/print_helper'
+require 'morpheus/cli/option_types'
+require 'morpheus/rest_client'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for load balancer management
+# including load balancers, load balancer types, virtual servers, etc.
+module Morpheus::Cli::LoadBalancersHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def load_balancers_interface
+    # @api_client.load_balancers
+    raise "#{self.class} has not defined @load_balancers_interface" if @load_balancers_interface.nil?
+    @load_balancers_interface
+  end
+
+  def load_balancer_types_interface
+    # @api_client.load_balancer_types
+    raise "#{self.class} has not defined @load_balancer_types_interface" if @load_balancer_types_interface.nil?
+    @load_balancer_types_interface
+  end
+
+  def load_balancer_object_key
+    'loadBalancer'
+  end
+
+  def load_balancer_list_key
+    'loadBalancers'
+  end
+
+  def load_balancer_label
+    'Load Balancer'
+  end
+
+  def load_balancer_plural_label
+    'Load Balancers'
+  end
+
+  def load_balancer_type_object_key
+    'loadBalancerType'
+  end
+
+  def load_balancer_type_list_key
+    'loadBalancerTypes'
+  end
+
+  def load_balancer_type_label
+    'Load Balancer Type'
+  end
+
+  def load_balancer_type_plural_label
+    'Load Balancer Types'
+  end
+
+  def find_load_balancer_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_load_balancer_by_id(val)
+    else
+      return find_load_balancer_by_name(val)
+    end
+  end
+
+  def find_load_balancer_by_id(id)
+    begin
+      json_response = load_balancers_interface.get(id.to_i)
+      return json_response[load_balancer_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Load Balancer not found by id #{id}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_load_balancer_by_name(name)
+    lbs = load_balancers_interface.list({name: name.to_s})[load_balancer_list_key]
+    if lbs.empty?
+      print_red_alert "Load Balancer not found by name #{name}"
+      return nil
+    elsif lbs.size > 1
+      print_red_alert "#{lbs.size} load balancers found by name #{name}"
+      #print_lbs_table(lbs, {color: red})
+      print reset,"\n\n"
+      return nil
+    else
+      return lbs[0]
+    end
+  end
+
+  def get_available_load_balancer_types(refresh=false)
+    if !@available_load_balancer_types || refresh
+      @available_load_balancer_types = load_balancer_types_interface.list({max:1000})[load_balancer_type_list_key]
+    end
+    return @available_load_balancer_types
+  end
+
+  def load_balancer_type_for_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return load_balancer_type_for_id(val)
+    else
+      return load_balancer_type_for_name(val)
+    end
+  end
+
+  def load_balancer_type_for_id(id)
+    return get_available_load_balancer_types().find { |z| z['id'].to_i == id.to_i}
+  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}
+  end
+
+  def find_load_balancer_type_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_load_balancer_type_by_id(val)
+    else
+      return find_load_balancer_type_by_name(val)
+    end
+  end
+
+  def find_load_balancer_type_by_id(id)
+    begin
+      json_response = load_balancer_types_interface.get(id.to_i)
+      return json_response[load_balancer_type_object_key]
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Load Balancer Type not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_load_balancer_type_by_name(name)
+    json_response = load_balancer_types_interface.list({name: name.to_s})
+    load_balancer_types = json_response[load_balancer_type_list_key]
+    if load_balancer_types.empty?
+      print_red_alert "Load Balancer Type not found by name #{name}"
+      return load_balancer_types
+    elsif load_balancer_types.size > 1
+      print_red_alert "#{load_balancer_types.size} load balancer types found by name #{name}"
+      rows = load_balancer_types.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      return load_balancer_types[0]
+    end
+  end
+
+end

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

@@ -228,7 +228,8 @@ module Morpheus::Cli::PrintHelper
     out << cyan
     if payload
       out << "\n"
-      content_type = (headers && headers['Content-Type']) ? headers['Content-Type'] : 'application/x-www-form-urlencoded'
+      is_multipart = (payload.is_a?(Hash) && payload[:multipart] == true)
+      content_type = (headers && headers['Content-Type']) ? headers['Content-Type'] : (is_multipart ? 'multipart/form-data' : 'application/x-www-form-urlencoded')
       if content_type == 'application/json'
         if payload.is_a?(String)
           begin
@@ -257,12 +258,21 @@ module Morpheus::Cli::PrintHelper
             out << payload
           end
         else
-          if content_type == 'application/x-www-form-urlencoded'
+          if content_type == 'application/x-www-form-urlencoded' || content_type.to_s.include?('multipart')
             body_str = payload.to_s
             begin
+              payload.delete(:multipart) if payload.is_a?(Hash)
+              # puts "grailsifying it!"
+              payload = Morpheus::RestClient.grails_params(payload)
+              payload.each do |k,v|
+                if v.is_a?(File)
+                  payload[k] = "@#{v.path}"
+                  payload[k] = v.path
+                end
+              end
               body_str = URI.encode_www_form(payload)
             rescue => ex
-              # raise ex
+              raise ex
             end
             if options[:scrub]
               out << Morpheus::Logging.scrub_message(body_str)
@@ -273,7 +283,7 @@ module Morpheus::Cli::PrintHelper
             if options[:scrub]
               out << Morpheus::Logging.scrub_message(payload)
             else
-              out << payload
+              out << payload.to_s
             end
           end
         end
@@ -327,7 +337,9 @@ module Morpheus::Cli::PrintHelper
         else
           out << "  -d '#{payload}'"
         end
+        out << "\n"
       else
+        is_multipart = (payload.is_a?(Hash) && payload[:multipart] == true)
         content_type = headers['Content-Type'] || 'application/x-www-form-urlencoded'
         
         if payload.is_a?(File)
@@ -337,21 +349,22 @@ module Morpheus::Cli::PrintHelper
           out << "  -d @#{payload.path}"
         elsif payload.is_a?(String)
           out << "  -d '#{payload}'"
-        else
-          if content_type == 'application/x-www-form-urlencoded'
-            body_str = payload.to_s
-            begin
-              body_str = URI.encode_www_form(payload)
-            rescue => ex
-              # raise ex
+        elsif payload.respond_to?(:map)
+          payload.delete(:multipart) if payload.is_a?(Hash)
+          # puts "grailsifying it!"
+          payload = Morpheus::RestClient.grails_params(payload)
+          payload.each do |k,v|
+            if v.is_a?(File)
+              out << "  -F '#{k}=@#{v.path}"
+            else
+              out << "  -d '#{URI.encode_www_form({(k) => v})}'"
             end
-            out << "  -d '#{body_str}'"
-          else
-            out << "  -d '#{payload}'"
+            out << "\n"
           end
+          #body_str = URI.encode_www_form(payload)
+          # out << "  -d '#{body_str}'"
         end
       end
-      out << "\n"
     else
       out << "\n"
     end
@@ -431,12 +444,13 @@ module Morpheus::Cli::PrintHelper
     out = ""
     bars = []
     percent = 0
+    percent_sigdig = opts[:percent_sigdig] || 2
     if max_value.to_i == 0
       percent = 0
     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(2)}%").rjust(6, ' ')
+    percent_label = ((used_value.nil? || max_value.to_f == 0.0) ? "n/a" : "#{percent.round(percent_sigdig)}%").rjust(6, ' ')
     bar_display = ""
     if percent > 100
       max_bars.times { bars << "|" }
@@ -674,7 +688,7 @@ module Morpheus::Cli::PrintHelper
       else
         # so let's use the passed in column definitions instead of the raw data properties
         # columns = options[:include_fields]
-        new_columns = []
+        new_columns = {}
         options[:include_fields].each do |f|
           matching_column = nil
           # column definitions vary right now, array of symbols/strings/hashes or perhaps a single hash
@@ -692,7 +706,7 @@ module Morpheus::Cli::PrintHelper
               matching_column = columns[matching_key]
             end
           end
-          new_columns << (matching_column ? matching_column : f)
+          new_columns[f] = matching_column ? matching_column : f
         end
         columns = new_columns
       end
@@ -1072,6 +1086,7 @@ module Morpheus::Cli::PrintHelper
         column_defs.each do |column_def|
           label = column_def.label
           value = column_def.display_method.call(obj)
+          value = value.is_a?(String) ? value : JSON.fast_generate(value)
           # value = get_object_value(obj, column_def)
           if do_quotes
             cells << quote_csv_value(value)
@@ -1320,4 +1335,15 @@ module Morpheus::Cli::PrintHelper
     parse_json_or_yaml(config, parsers)
   end
 
+  def format_option_types_table(option_types, options={}, domain_name=nil)
+    columns = [
+      {"FIELD LABEL" => lambda {|it| it['fieldLabel'] } },
+      {"FIELD NAME" => lambda {|it| [it['fieldContext'] == domain_name ? nil : it['fieldContext'], it['fieldName']].select {|it| !it.to_s.empty? }.join('.') } },
+      {"TYPE" => lambda {|it| it['type'] } },
+      {"DEFAULT" => lambda {|it| it['defaultValue'] } },
+      {"REQUIRED" => lambda {|it| format_boolean it['required'] } },
+    ]
+    as_pretty_table(option_types, columns, options)
+  end
+  
 end

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

@@ -508,7 +508,7 @@ module Morpheus::Cli::ProvisioningHelper
       if name_prompt['name'].nil? && !options[:name_required]
         break
       else
-        if instances_interface.get({name: name_prompt['name']})['instances'].empty?
+        if instances_interface.list({name: name_prompt['name']})['instances'].empty?
           instance_name = name_prompt['name']
         else
           print_red_alert "Name must be unique"
@@ -696,7 +696,7 @@ module Morpheus::Cli::ProvisioningHelper
     # prompt for service plan
     plan_id = nil
     service_plan = nil
-    service_plans_json = @instances_interface.service_plans({zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
+    service_plans_json = instances_interface.service_plans({zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
     service_plans = service_plans_json["plans"]
     if locked_fields.include?('plan.id')
       plan_id = options[:options]['plan']['id'] rescue nil
@@ -764,7 +764,7 @@ module Morpheus::Cli::ProvisioningHelper
         # pluck out the resourcePoolId option type to prompt for
         resource_pool_option_type = option_type_list.find {|opt| ['resourcePool','resourcePoolId','azureResourceGroupId'].include?(opt['fieldName']) }
         option_type_list = option_type_list.reject {|opt| ['resourcePool','resourcePoolId','azureResourceGroupId'].include?(opt['fieldName']) }
-        resource_pool_options = @options_interface.options_for_source('zonePools', {groupId: group_id, siteId: group_id, zoneId: cloud_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], planId: service_plan["id"], layoutId: layout["id"]})['data']
+        resource_pool_options = options_interface.options_for_source('zonePools', {groupId: group_id, siteId: group_id, zoneId: cloud_id, cloudId: cloud_id, instanceTypeId: instance_type['id'], planId: service_plan["id"], layoutId: layout["id"]})['data']
         resource_pool = resource_pool_options.find {|opt| opt['id'] == options[:resource_pool].to_i} if options[:resource_pool]
 
         if resource_pool
@@ -1409,7 +1409,7 @@ module Morpheus::Cli::ProvisioningHelper
       if plan_info['addVolumes']
         volume_index = current_volumes.size
         has_another_volume = options[:options] && options[:options]["dataVolume#{volume_index}"]
-        add_another_volume = has_another_volume || (!no_prompt && Morpheus::Cli::OptionTypes.confirm("Add data volume?"))
+        add_another_volume = has_another_volume || (!no_prompt && Morpheus::Cli::OptionTypes.confirm("Add data volume?", {:default => false}))
         while add_another_volume do
             #puts "Configure Data #{volume_index} Volume"
 

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

@@ -0,0 +1,657 @@
+# RestCommand is a mixin for Morpheus::Cli command classes.
+# Provides basic CRUD commands: list, get, add, update, remove
+# Currently the command class must also include Morpheus::Cli::CliCommand
+# The command class can define a few variables to dictate what the resource
+# is called and the the api interface used to fetch the records. The command class 
+# or helper must also provide several methods to provide the default behavior.
+# In the example below, the command (helper) defines the following methods:
+#  * load_balancer_object_key() - Key name of object returned by the "get" api endpoint.
+#  * load_balancer_list_key() - Key name of array of records returned by the "list" api endpoint.
+#  * load_balancer_column_definitions() - Column definitions for the "get" command display output.
+#  * load_balancer_list_column_definitions() - Column definitions for the "list" command display output.
+#
+# # An example of a RestCommand for `morpheus load-balancers`.
+# class Morpheus::Cli::LoadBalancers
+#
+#   include Morpheus::Cli::CliCommand
+#   include Morpheus::Cli::RestCommand
+#   include Morpheus::Cli::LoadBalancersHelper
+#
+#   # All of the example settings below are redundant
+#   # and would be the default values if not set.
+#   set_rest_name :load_balancers
+#   set_rest_label "Load Balancer"
+#   set_rest_plural_label "Load Balancers"
+#   set_rest_object_key "load_balancer"
+#   set_rest_has_type true
+#   set_rest_type "load_balancer_types"
+#   register_interfaces :load_balancers, :load_balancer_types
+#
+# end
+#
+module Morpheus::Cli::RestCommand
+  def self.included(base)
+    #puts "including RestCommand for #{base}"
+    #base.send :include, Morpheus::Cli::CliCommand
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # rest_name is the plural name of the rest command resource eg. NeatThingsCommand would be "neat_things"
+    # It is used to derive all other default rest settings key, label, etc.  
+    # The default name the command name with underscores `_` instead of dashes `-`.
+    def rest_name
+      @rest_name || default_rest_name
+    end
+
+    def default_rest_name
+      self.command_name.to_s.gsub("-", "_")
+    end
+
+    def rest_name=(v)
+      @rest_name = v
+    end
+
+    alias :set_rest_name :rest_name=
+
+    # rest_key is the singular name of the resource eg. "neat_thing"
+    def rest_key
+      @rest_key || default_rest_key
+    end
+
+    def default_rest_key
+      rest_name.chomp("s")
+    end
+
+    def rest_key=(v)
+      @rest_key = v
+    end
+
+    alias :set_rest_key :rest_key=
+
+    # rest_arg is a label for the arg in the command usage eg. "thing" gets displayed as [thing]
+    def rest_arg
+      @rest_arg || default_rest_arg
+    end
+
+    def default_rest_arg
+      rest_key.gsub("_", " ") # "[" + rest_key.gsub("_", " ") + "]"
+    end
+
+    def rest_arg=(v)
+      @rest_arg = v
+    end
+
+    alias :set_rest_arg :rest_arg=
+
+    # rest_label is the capitalized resource label eg. "Neat Thing"    
+    def rest_label
+      @rest_label || default_rest_label
+    end
+
+    def default_rest_label
+      rest_key.to_s.split("_").collect {|it| it.to_s.capitalize }.join(" ")
+    end
+
+    def rest_label=(v)
+      @rest_label = v
+    end
+
+    alias :set_rest_label :rest_label=
+
+    # the plural version of the label eg. "Neat Things"
+    def rest_plural_label
+      @rest_plural_label || default_rest_plural_label
+    end
+    
+    def default_rest_plural_label
+      #rest_name.to_s.split("_").collect {|it| it.to_s.capitalize }.join(" ")
+      rest_label.to_s.pluralize
+    end
+
+    def rest_plural_label=(v)
+      @rest_plural_label = v
+    end
+    
+    alias :set_rest_plural_label :rest_plural_label=
+
+    # rest_interface_name is the interface name for the resource. eg. "neat_things"
+    def rest_interface_name
+      @rest_interface_name || default_rest_interface_name
+    end
+
+    def default_rest_interface_name
+      rest_name
+    end
+
+    def rest_interface_name=(v)
+      @rest_interface_name = v
+    end
+
+    alias :set_rest_interface_name :rest_interface_name=
+
+    # rest_has_type indicates a resource has a type. default is false
+    def rest_has_type
+      @rest_has_type == true
+    end
+
+    def default_rest_has_type
+      false
+    end
+
+    def rest_has_type=(v)
+      @rest_has_type = !!v
+    end
+
+    alias :set_rest_has_type :rest_has_type=
+
+    ## duplicated the rest_* settings with rest_type, for the types resource
+
+    # rest_type_name is the rest_name for the type, only applicable if rest_has_type
+    def rest_type_name
+      @rest_type_name || default_rest_type_name
+    end
+
+    def default_rest_type_name
+      rest_key + "_types"
+    end
+
+    def rest_type_name=(v)
+      @rest_type_name = v
+    end
+
+    alias :set_rest_type_name :rest_type_name=
+    alias :set_rest_type :rest_type_name=
+    #alias :rest_type= :rest_type_name=
+
+    # rest_type_key is the singular name of the resource eg. "neat_thing"
+    def rest_type_key
+      @rest_type_key || default_rest_type_key
+    end
+
+    def default_rest_type_key
+      rest_type_name.chomp("s")
+    end
+
+    def rest_type_key=(v)
+      @rest_type_key = v
+    end
+
+    alias :set_rest_type_key :rest_type_key=
+
+    def rest_type_arg
+      @rest_type_arg || default_rest_type_arg
+    end
+
+    def default_rest_type_arg
+      # rest_type_key.gsub("_", " ") # "[" + rest_key.gsub("_", " ") + "]"
+      "type" # [type]
+    end
+
+    def rest_type_arg=(v)
+      @rest_type_arg = v
+    end
+
+    alias :set_rest_type_arg :rest_type_arg=
+
+    # rest_type_label is the capitalized resource label eg. "Neat Thing"    
+    def rest_type_label
+      @rest_type_label || default_rest_type_label
+    end
+
+    def default_rest_type_label
+      rest_type_key.to_s.split("_").collect {|it| it.to_s.capitalize }.join(" ")
+    end
+
+    def rest_type_label=(v)
+      @rest_type_label = v
+    end
+
+    alias :set_rest_type_label :rest_type_label=
+
+    # the plural version of the label eg. "Neat Things"
+    def rest_type_plural_label
+      @rest_type_plural_label || default_rest_type_plural_label
+    end
+    
+    def default_rest_type_plural_label
+      #rest_type_name.to_s.split("_").collect {|it| it.to_s.capitalize }.join(" ")
+      rest_type_label.to_s.pluralize
+    end
+
+    def rest_type_plural_label=(v)
+      @rest_type_plural_label = v
+    end
+    
+    alias :set_rest_type_plural_label :rest_type_plural_label=
+
+    # the name of the default interface, matches the rest name eg. "neat_things"
+    def rest_type_interface_name
+      @rest_type_interface_name || default_rest_type_interface_name
+    end
+
+    def default_rest_type_interface_name
+      rest_type_name
+    end
+
+    def rest_type_interface_name=(v)
+      @rest_type_interface_name = v
+    end
+
+    alias :set_rest_type_interface_name :rest_type_interface_name=
+
+    # set or append to the list of interface names to register for this command
+    # The registered interfaces will be pre-loaded into instance variables
+    # eg. [:neat_things, :neat_thing_types] will instantiate @neat_things_interface and @neat_thing_types_interface
+    def register_interfaces(*interfaces)
+      @registered_interfaces ||= []
+      interfaces.flatten.each do |it|
+        @registered_interfaces << it.to_sym
+      end
+      # put the default rest_interface first
+      if rest_interface_name && !@registered_interfaces.include?(rest_interface_name)
+        @registered_interfaces.unshift(rest_interface_name)
+      end
+      # and also the rest_type_interface
+      if rest_has_type && !@registered_interfaces.include?(rest_type_interface_name)
+        @registered_interfaces.unshift(rest_type_interface_name)
+      end
+    end
+
+    alias :register_interface :register_interfaces
+
+    # get list of interface names that are registered for this command
+    # automatically includes the interface for the rest_name and rest_type_name if has_type
+    def registered_interfaces
+      @registered_interfaces ||= []
+      # put the default rest_interface first
+      if @registered_interfaces.empty?
+        if rest_interface_name
+          @registered_interfaces.unshift(rest_interface_name)
+        end
+        if rest_has_type
+          @registered_interfaces.unshift(rest_type_interface_name)
+        end
+      end
+      @registered_interfaces
+    end
+
+     # clear the list of registered interfaces, perhaps useful in a command subclass
+    def clear_registered_interfaces()
+      @registered_interfaces = []
+    end
+
+  end
+
+  def rest_name
+    self.class.rest_name
+  end
+
+  def rest_key
+    self.class.rest_key
+  end
+
+  def rest_arg
+    self.class.rest_arg
+  end
+
+  def rest_label
+    self.class.rest_label
+  end
+
+  def rest_plural_label
+    self.class.rest_plural_label
+  end
+
+  def rest_interface_name
+    self.class.rest_interface_name
+  end
+
+  # returns the default rest interface, allows using rest_interface_name = "your"
+  # or override this method to return @your_interface if needed
+  def rest_interface
+    instance_variable_get("@#{rest_interface_name}_interface")
+  end
+
+  def rest_object_key
+    self.send("#{rest_key}_object_key")
+  end
+
+  def rest_list_key
+    self.send("#{rest_key}_list_key")
+  end
+
+  def rest_column_definitions
+    self.send("#{rest_key}_column_definitions")
+  end
+
+  def rest_list_column_definitions
+    self.send("#{rest_key}_list_column_definitions")
+  end
+
+  def rest_find_by_name_or_id(name)
+    return self.send("find_#{rest_key}_by_name_or_id", name)
+  end
+
+  def rest_has_type
+    self.class.rest_has_type
+  end
+
+  ## duplicated the rest_* settings with rest_type, for the types resource
+
+  def rest_type_name
+    self.class.rest_type_name
+  end
+
+  def rest_type_key
+    self.class.rest_type_key
+  end
+
+  def rest_type_arg
+    self.class.rest_type_arg
+  end
+
+  def rest_type_label
+    self.class.rest_type_label
+  end
+
+  def rest_type_plural_label
+    self.class.rest_type_plural_label
+  end
+
+  def rest_type_interface_name
+    self.class.rest_type_interface_name # || "@#{rest_type_name}_interface"
+  end
+
+  def rest_type_interface
+    instance_variable_get("@#{rest_type_interface_name}_interface")
+  end
+
+  def rest_type_object_key
+    self.send("#{rest_type_key}_object_key")
+  end
+
+  def rest_type_list_key
+    self.send("#{rest_type_key}_list_key")
+  end
+
+  def rest_type_column_definitions
+    self.send("#{rest_type_key}_column_definitions")
+  end
+
+  def rest_type_list_column_definitions
+    self.send("#{rest_type_key}_list_column_definitions")
+  end
+
+  def rest_type_find_by_name_or_id(name)
+    return self.send("find_#{rest_type_key}_by_name_or_id", name)
+  end
+
+  def registered_interfaces
+    self.class.registered_interfaces
+  end
+
+  # standard connect method to establish @api_client
+  # and @{name}_interface variables for each registered interface.
+  def connect(options)
+    @api_client = establish_remote_appliance_connection(options)
+    self.class.registered_interfaces.each do |interface_name|
+      if interface_name.is_a?(String) || interface_name.is_a?(Symbol)
+        instance_variable_set("@#{interface_name}_interface", @api_client.send(interface_name))
+      elsif interface_name.is_a?(Hash)
+        interface_name.each do |k,v|
+          instance_variable_set("#{k}_interface", @api_client.send(v))
+        end
+      end
+    end
+  end
+
+  def handle(args)
+    handle_subcommand(args)
+  end
+
+  def list(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_standard_list_options(opts, options)
+      opts.footer = "List #{rest_plural_label.downcase}."
+    end
+    optparse.parse!(args)
+    connect(options)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    params.merge!(parse_list_options(options))
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.list(params)
+      return
+    end
+    json_response = rest_interface.list(params)
+    render_response(json_response, options, rest_list_key) do
+      records = json_response[rest_list_key]
+      print_h1 "Morpheus #{rest_plural_label}"
+      if records.nil? || records.empty?
+        print cyan,"No #{rest_plural_label.downcase} found.",reset,"\n"
+      else
+        print as_pretty_table(records, rest_list_column_definitions.upcase_keys!, options)
+        print_results_pagination(json_response) if json_response['meta']
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def get(args)
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[type]")
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about #{a_or_an(rest_label)} #{rest_label.downcase}.
+[#{rest_arg}] is required. This is the name or id of #{a_or_an(rest_label)} #{rest_label.downcase}.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, min:1)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    id_list = parse_id_list(args)
+    return run_command_for_each_arg(id_list) do |arg|
+      _get(arg, params, options)
+    end
+  end
+
+  def _get(id, params, options)
+    if id !~ /\A\d{1,}\Z/
+      record = rest_find_by_name_or_id(id)
+      if record.nil?
+        raise_command_error "#{rest_label} not found for name '#{id}'"
+      end
+      id = record['id']
+    end
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.get(id, params)
+      return
+    end
+    json_response = rest_interface.get(id, params)
+    render_response_for_get(json_response, options)
+    return 0, nil
+  end
+
+  def render_response_for_get(json_response, options)
+    render_response(json_response, options, rest_object_key) do
+      record = json_response[rest_object_key]
+      print_h1 rest_label, [], options
+      print cyan
+      print_description_list(rest_column_definitions, record, options)
+      # show config settings...
+      if record['optionTypes'] && record['optionTypes'].size > 0
+        print_h2 "Option Types", options
+        print format_option_types_table(record['optionTypes'], options, rest_object_key)
+      end
+      print reset,"\n"
+    end
+  end
+
+  def add(args)
+    record_type_id = nil
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      if rest_has_type
+        opts.banner = subcommand_usage("[name] -t TYPE")
+        opts.on( '-t', "--#{rest_type_arg} TYPE", "#{rest_type_label}" ) do |val|
+          record_type_id = val
+        end
+      else
+        opts.banner = subcommand_usage("[name]")
+      end
+      # if defined?(add_#{rest_key}_option_types)
+      #   build_option_type_options(opts, options, add_#{rest_key}_option_types)
+      # end
+      build_standard_add_options(opts, options)
+    end
+    optparse.parse!(args)
+    # todo: make supporting args[0] optional and more flexible
+    # for now args[0] is assumed to be the 'name'
+    record_name = nil
+    if args[0] # && rest_has_name
+      record_name = args[0]
+    end
+    verify_args!(args:args, optparse:optparse, min:0, max: 1)
+    # todo: maybe need a flag to make this required, it could be an option type too, so
+    if rest_has_type
+      if record_type_id.nil?
+        raise_command_error "#{rest_type_label} is required.\n#{optparse}"
+      end
+    end
+    connect(options)
+    if rest_has_type
+      record_type = rest_type_find_by_name_or_id(record_type_id)
+      if record_type.nil?
+        raise_command_error "#{rest_type_label} not found for '#{record_type_id}'.\n#{optparse}"
+      end
+    end
+    passed_options = parse_passed_options(options)
+    payload = {}
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({rest_object_key => passed_options})
+    else
+      record_payload = {}
+      if record_name
+        record_payload['name'] = record_name
+        options[:options]['name'] = record_name # injected for prompt
+      end
+      if rest_has_type && record_type
+        # record_payload['type'] = {'code' => record_type['code']}
+        record_payload['type'] = record_type['code']
+        options[:options]['type'] = record_type['code'] # injected for prompt
+      end
+      record_payload.deep_merge!(passed_options)
+      # options by type
+      my_option_types = record_type ? record_type['optionTypes'] : nil
+      if my_option_types && !my_option_types.empty?
+        # remove redundant fieldContext
+        my_option_types.each do |option_type| 
+          if option_type['fieldContext'] == rest_object_key
+            option_type['fieldContext'] = nil
+          end
+        end
+        v_prompt = Morpheus::Cli::OptionTypes.prompt(my_option_types, options[:options], @api_client, options[:params])
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
+      payload[rest_object_key] = record_payload
+    end
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.create(payload)
+      return
+    end      
+    json_response = rest_interface.create(payload)
+    render_response(json_response, options, rest_object_key) do
+      record = json_response[rest_object_key]
+      print_green_success "Added #{rest_label.downcase} #{record['name'] || record['id']}"
+      return _get(record["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+  def update(args)
+    id = args[0]
+    options = {}
+    params = {}
+    account_name = nil
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[#{rest_arg}] [options]")
+      build_standard_update_options(opts, options)
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    record = rest_find_by_name_or_id(id)
+    passed_options = parse_passed_options(options)
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!({rest_object_key => passed_options}) unless passed_options.empty?
+    else
+      record_payload = passed_options
+      if record_payload.empty?
+        raise_command_error "Specify at least one option to update.\n#{optparse}"
+      end
+      payload[rest_object_key] = record_payload
+    end
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.update(record['id'], payload)
+      return
+    end
+    json_response = rest_interface.update(record['id'], payload)
+    render_response(json_response, options, rest_object_key) do
+      print_green_success "Updated #{rest_label.downcase} #{record['name'] || record['id']}"
+      _get(record["id"], {}, options)
+    end
+    return 0, nil
+  end
+
+  def remove(args)
+    id = args[0]
+    params = {}
+    options = {}
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[#{rest_arg}]")
+      build_standard_remove_options(opts, options)
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    params.merge!(parse_query_options(options))
+    record = rest_find_by_name_or_id(id)
+    if record.nil?
+      return 1, "#{rest_name} not found for '#{id}'"
+    end
+    unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to delete the #{rest_label.downcase} #{record['name'] || record['id']}?")
+      return 9, "aborted"
+    end
+    rest_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run rest_interface.dry.destroy(record['id'])
+      return 0, nil
+    end
+    json_response = rest_interface.destroy(record['id'], params)
+    render_response(json_response, options) do
+      print_green_success "Removed #{rest_label.downcase} #{record['name'] || record['id']}"
+    end
+    return 0, nil
+  end
+
+end
+