morpheus-cli 2.10.0 → 2.10.1

data/lib/morpheus/cli/cli_command.rb

@@ -1,5 +1,9 @@
+require 'morpheus/cli/option_parser'
 require 'morpheus/cli/cli_registry'
 require 'morpheus/cli/mixins/print_helper'
+require 'morpheus/cli/credentials'
+require 'morpheus/api/api_client'
+require 'morpheus/cli/remote'
 
 module Morpheus
   module Cli
@@ -7,9 +11,9 @@ module Morpheus
     module CliCommand
 
       def self.included(klass)
-        Morpheus::Cli::CliRegistry.add(klass)
         klass.send :include, Morpheus::Cli::PrintHelper
         klass.extend ClassMethods
+        Morpheus::Cli::CliRegistry.add(klass, klass.command_name)
       end
 
       def build_common_options(opts, options, includes=[])
@@ -26,9 +30,10 @@ module Morpheus
             end
 
           when :options
-            opts.on( '-O', '--option OPTION', "Option" ) do |option|
+            options[:options] ||= {}
+            opts.on( '-O', '--option OPTION', "Option in the format var=\"value\"" ) do |option|
               custom_option_args = option.split('=')
-              custom_options = options[:options] || {}
+              custom_options = options[:options]
               option_name_args = custom_option_args[0].split('.')
               if option_name_args.count > 1
                 nested_options = custom_options
@@ -43,7 +48,6 @@ module Morpheus
               else
                 custom_options[custom_option_args[0]] = custom_option_args[1]
               end
-              
               options[:options] = custom_options
             end
             opts.on('-N','--no-prompt', "Skip prompts. Use default values for all optional fields.") do |val|
@@ -52,8 +56,8 @@ module Morpheus
               options[:options] ||= {}
               options[:options][:no_prompt] = true
             end
+
           when :list
-            
             opts.on( '-m', '--max MAX', "Max Results" ) do |max|
               options[:max] = max.to_i
             end
@@ -75,10 +79,26 @@ module Morpheus
             end
 
           when :remote
-            opts.on( '-r', '--remote REMOTE', "Remote Appliance" ) do |remote|
-              options[:remote] = remote
+
+            # this is the only option now... 
+            # first, you must do `remote use [appliance]`
+            opts.on( '-r', '--remote REMOTE', "Remote Appliance Name to use for this command. The active appliance is used by default." ) do |val|
+              options[:remote] = val
+            end
+
+            # todo: also require this for talking to plain old HTTP
+            opts.on('-I','--insecure', "Allow for insecure HTTPS communication i.e. bad SSL certificate") do |val|
+              Morpheus::RestClient.enable_ssl_verification = false
             end
 
+            # skipping the rest of this for now..
+
+            next
+
+            # opts.on( '-r', '--remote REMOTE', "Remote Appliance" ) do |remote|
+            #   options[:remote] = remote
+            # end
+
             opts.on( '-U', '--url REMOTE', "API Url" ) do |remote|
               options[:remote_url] = remote
             end
@@ -94,36 +114,39 @@ module Morpheus
             opts.on( '-T', '--token ACCESS_TOKEN', "Access Token" ) do |remote|
               options[:remote_token] = remote
             end
-          
-          when :auto_confirm
+                      when :auto_confirm
             opts.on( '-y', '--yes', "Auto Confirm" ) do
               options[:yes] = true
             end
-          
-          when :json
+                      when :json
             opts.on('-j','--json', "JSON Output") do |json|
               options[:json] = true
             end
 
           when :dry_run
-            opts.on('-d','--dry-run', "Dry Run, print json without making the actual request.") do |json|
+            opts.on('-d','--dry-run', "Dry Run, print the API request instead of executing it") do |json|
               options[:dry_run] = true
             end
-          
+                      when :quiet
+            opts.on('-q','--quiet', "No Output, when successful") do |json|
+              options[:quiet] = true
+            end
+
           else
             raise "Unknown common_option key: #{option_key}"
           end
         end
 
         # options that are always included
-        opts.on('-C','--nocolor', "ANSI") do
+
+        # disable ANSI coloring
+        opts.on('-C','--nocolor', "Disable ANSI coloring") do
           Term::ANSIColor::coloring = false
         end
 
         opts.on('-V','--debug', "Print extra output for debugging. ") do |json|
           options[:debug] = true
-          # this is handled upstream for now...
-          # Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
+          Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
           # perhaps...
           # create a new logger instance just for this command instance
           # this way we don't elevate the global level for subsequent commands in a shell
@@ -132,21 +155,166 @@ module Morpheus
           #   @logger.log_level = Morpheus::Logging::Logger::DEBUG
           # end
         end
-        
+
         opts.on('-h', '--help', "Prints this help" ) do
           puts opts
           exit
         end
 
       end
-      
+
+      def command_name
+        self.class.command_name
+      end
+
+      def subcommands
+        self.class.subcommands
+      end
+
+      def subcommand_aliases
+        self.class.subcommand_aliases
+      end
+
+      def default_subcommand
+        self.class.default_subcommand
+      end
+
+      def usage
+        if !subcommands.empty?
+          "Usage: morpheus #{command_name} [command] [options]"
+        else
+          "Usage: morpheus #{command_name} [options]"
+        end
+      end
+
+      def subcommand_usage(*extra)
+        calling_method = caller[0][/`([^']*)'/, 1].to_s.sub('block in ', '')
+        subcommand_name = subcommands.key(calling_method)
+        extra = extra.flatten
+        if !subcommand_name.empty? && extra.first == subcommand_name
+          extra.shift
+        end
+        #extra = ["[options]"] if extra.empty?
+        "Usage: morpheus #{command_name} #{subcommand_name} #{extra.join(' ')}".squeeze(' ').strip
+      end
+
+      def print_usage()
+        puts usage
+        if !subcommands.empty?
+          puts "Commands:"
+          subcommands.sort.each {|cmd, method|
+            puts "\t#{cmd.to_s}"
+          }
+        end
+      end
+
+      # a default handler
+      def handle_subcommand(args)
+        commands = subcommands
+        if subcommands.empty?
+          raise "#{self.class} has no available subcommands"
+        end
+        # 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 || [])
+        end
+        cmd_name = args[0]
+        if subcommand_aliases[cmd_name]
+          cmd_name = subcommand_aliases[cmd_name]
+        end
+        cmd_method = subcommands[cmd_name]
+        if cmd_name && !cmd_method
+          #puts "unknown command '#{cmd_name}'"
+        end
+        if !cmd_method
+          print_usage
+          exit 127
+        end
+        self.send(cmd_method, args[1..-1])
+      end
+
+      def handle(args)
+        raise "#{self} has not defined handle()!"
+      end
+
+      # This supports the simple remote option eg. `instances add --remote "qa"`
+      # It will establish a connection to the pre-configured appliance named "qa"
+      # The calling command needs to populate @appliances and/or @appliance_name
+      # This returns a new instance of Morpheus::APIClient (and sets @access_token, and @appliance)
+      # Your command should be ready to make api requests after this.
+      # todo: probably don't exit here, just return nil or raise
+      def establish_remote_appliance_connection(options)
+        @appliances ||= ::Morpheus::Cli::Remote.appliances
+        if !@appliance_name
+          @appliance_name, @appliance_url = Morpheus::Cli::Remote.active_appliance
+        end
+
+        # todo: support old way of accepting --username and --password on the command line
+        # it's probably better not to do that tho, just so it stays out of history files
+
+        # use a specific remote appliance by name
+        if options[:remote]
+          @appliance_name = options[:remote].to_sym rescue nil
+          if !@appliances
+            print_red_alert "You have no appliances configured. See the `remote add` command."
+            exit 1
+          end
+          found_appliance = @appliances[@appliance_name.to_sym]
+          if !found_appliance
+            print_red_alert "You have no appliance named '#{@appliance_name}' configured. See the `remote add` command."
+            exit 1
+          end
+          @appliance = found_appliance
+          @appliance_name = @appliance_name
+          @appliance_url = @appliance[:host]
+          if options[:debug]
+            print dark,"# => Using remote appliance [#{@appliance_name}] #{@appliance_url}",reset,"\n" if !options[:quiet]
+          end
+        else
+          #@appliance_name, @appliance_url = Morpheus::Cli::Remote.active_appliance
+        end
+
+        if !@appliance_name
+          print_red_alert "You must specify a remote appliance with --remote, or see the `remote use` command."
+          exit 1
+        end
+
+        puts "#{dark} #=> establishing connection to [#{@appliance_name}] #{@appliance_url}#{reset}\n" if options[:debug]
+
+        # ok, get some credentials.
+        # this prompts for username, password  without options[:no_prompt]
+        @access_token = Morpheus::Cli::Credentials.new(@appliance_name, @appliance_url).request_credentials(options)
+        
+        # bail if we got nothing
+        if @access_token.empty?
+          print_red_alert "Invalid Credentials. Unable to acquire access token. Please verify your credentials and try again."
+          exit 1
+        end
+
+        # ok, connect to the appliance.. actually this just instantiates an ApiClient
+        # setup our api client for all including commands to use.
+        @api_client = Morpheus::APIClient.new(@access_token,nil,nil, @appliance_url)
+        return @api_client
+      end
 
       module ClassMethods
-        def cli_command_name(cmd_name)
-          Morpheus::Cli::CliRegistry.add(self, cmd_name)
+
+        def set_command_name(cmd_name)
+          @command_name = cmd_name
+          Morpheus::Cli::CliRegistry.add(self, self.command_name)
+        end
+
+        def default_command_name
+          Morpheus::Cli::CliRegistry.cli_ize(self.name.split('::')[-1])
+        end
+        
+        def command_name
+          @command_name ||= default_command_name
+          @command_name
         end
 
-        def cli_command_hidden(val=true)
+        def set_command_hidden(val=true)
           @hidden_command = val
         end
         
@@ -154,6 +322,76 @@ module Morpheus
           !!@hidden_command
         end
 
+        # construct map of command name => instance method
+        def register_subcommands(*cmds)
+          @subcommands ||= {}
+          cmds.flatten.each {|cmd| 
+            if cmd.is_a?(Hash)
+              cmd.each {|k,v| 
+                # @subcommands[k] = v
+                add_subcommand(k.to_s, v.to_s)
+              }
+            elsif cmd.is_a?(Array) 
+              cmd.each {|it| register_subcommands(it) }
+            elsif cmd.is_a?(String) || cmd.is_a?(Symbol)
+              #k = Morpheus::Cli::CliRegistry.cli_ize(cmd)
+              k = cmd.to_s.gsub('_', '-')
+              v = cmd.to_s.gsub('-', '_')
+              register_subcommands({(k) => v})
+            else
+              raise "Unable to register command of type: #{cmd.class} #{cmd}"
+            end
+          }
+          return
+        end
+
+        def set_default_subcommand(cmd)
+          @default_subcommand = cmd
+        end
+
+        def default_subcommand
+          @default_subcommand
+        end
+
+        def subcommands
+          @subcommands ||= {}
+        end
+
+        def has_subcommand?(cmd_name)
+          return false if cmd_name.empty?
+          @subcommands && @subcommands[cmd_name.to_s]
+        end
+
+        def add_subcommand(cmd_name, method)
+          @subcommands ||= {}
+          @subcommands[cmd_name.to_s] = method
+        end
+
+        def remove_subcommand(cmd_name)
+          @subcommands ||= {}
+          @subcommands.delete(cmd_name.to_s)
+        end
+
+        # register an alias for a command
+        def alias_subcommand(alias_cmd_name, cmd_name)
+          add_subcommand_alias(alias_cmd_name.to_s, cmd_name.to_s.gsub('_', '-'))
+          return
+        end
+
+        def subcommand_aliases
+          @subcommand_aliases ||= {}
+        end
+
+        def add_subcommand_alias(alias_cmd_name, cmd_name)
+          @subcommand_aliases ||= {}
+          @subcommand_aliases[alias_cmd_name.to_s] = cmd_name
+        end
+
+        def remove_subcommand_alias(alias_cmd_name)
+          @subcommand_aliases ||= {}
+          @subcommand_aliases.delete(alias_cmd_name.to_s)
+        end
+
       end
     end
   end

data/lib/morpheus/cli/cli_registry.rb

@@ -1,36 +1,76 @@
-
+require 'term/ansicolor'
 module Morpheus
   module Cli
     class CliRegistry
 
       def initialize
-        @commands = {}
+        @commands = {} # this is command => Class that includes ::CliCommand
+        @aliases = {} # this is alias => String full input string
       end
-      
+
       class << self
+        include Term::ANSIColor
         
+        ALIAS_SPLIT_REGEX=/(\;)(?=(?:[^"']|"[^'"]*")*$)/
+
         def instance
           @instance ||= CliRegistry.new
         end
 
+        #todo: move execution out of the CliRegistry
         def exec(command_name, args)
-          # begin
-            Term::ANSIColor::coloring = STDOUT.isatty
+          exec_command(command_name, args)
+        end
+
+        def exec_command(command_name, args)
+          #puts "exec_command(#{command_name}, #{args})"
+          found_alias_command = instance.get_alias(command_name)
+          if found_alias_command
+            exec_alias(command_name, args)
+          else
+            #puts "running regular command #{command_name} with arguments #{args.join(' ')}"
             instance.get(command_name).new.handle(args)
-          # rescue SystemExit, Interrupt
-          #   puts "Interrupted..."
-          # end
+          end
+        end
+
+        def exec_alias(alias_name, args)
+          #puts "exec_alias(#{alias_name}, #{args})"
+          found_alias_command = instance.get_alias(alias_name)
+          # support aliases of multiple commands, semicolon delimiter
+          # todo: 
+          all_commands = found_alias_command.gsub(ALIAS_SPLIT_REGEX, '__ALIAS_SPLIT_REGEX__').split('__ALIAS_SPLIT_REGEX__').collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
+          print "#{dark} #=> executing alias #{alias_name} as #{all_commands.join('; ')}#{reset}\n" if Morpheus::Logging.debug?
+          all_commands.each do |a_command_string|
+            alias_args = a_command_string.to_s.split(/\s+/) # or just ' '
+            command_name = alias_args.shift
+            command_args = alias_args + args
+            if command_name == alias_name
+              # needs to be better than this
+              print Term::ANSIColor.red,"alias '#{alias_name}' is calling itself? '#{found_alias_command}'", Term::ANSIColor.reset, "\n"
+              exit 1
+            end
+            # this allows aliases to use other aliases
+            # todo: prevent recursion infinite loop
+            if has_alias?(command_name)
+              exec_alias(command_name, command_args)
+            elsif has_command?(command_name)
+              #puts "executing alias #{found_alias_command} as #{command_name} with args #{args.join(' ')}"
+              instance.get(command_name).new.handle(alias_args + args)
+            else
+              # raise UnrecognizedCommandError.new(command_name)
+              print Term::ANSIColor.red,"alias '#{alias_name}' uses and unknown command: '#{command_name}'", Term::ANSIColor.reset, "\n"
+              exit 1
+            end
+          end
         end
 
         def add(klass, command_name=nil)
           klass_command_name = cli_ize(klass.name.split('::')[-1])
-
-          if has_command?(klass_command_name) && !command_name.nil?
+          if has_command?(klass_command_name)
             instance.remove(klass_command_name)
-            instance.add(command_name, klass)
-          else
-            instance.add(klass_command_name, klass)
           end
+          command_name ||= klass_command_name
+          instance.add(command_name, klass)
         end
 
         def has_command?(command_name)
@@ -41,11 +81,21 @@ module Morpheus
           end
         end
 
+        def has_alias?(alias_name)
+          if alias_name.nil? || alias_name == ''
+            false
+          else
+            !instance.get_alias(alias_name).nil?
+          end
+        end
+
         def all
           instance.all
         end
 
-        private
+        def all_aliases
+          instance.all_aliases
+        end
 
         def cli_ize(klass_name)
           # borrowed from ActiveSupport
@@ -58,6 +108,18 @@ module Morpheus
           word.downcase!
           word.chop.tr('_', '-')
         end
+
+        def parse_alias_definition(input)
+          # todo: one multi group regex would work
+          alias_name, command_string = nil, nil
+          chunks = input.to_s.sub(/^alias\s+/, "").split('=')
+          alias_name = chunks.shift
+          command_string = chunks.compact.reject {|it| it.empty? }.join('=')
+          command_string = command_string.strip.sub(/^'/, "").sub(/'\Z/, "").strip
+          return alias_name, command_string
+        end
+
+
       end
 
       def all
@@ -75,6 +137,29 @@ module Morpheus
       def remove(cmd_name)
         @commands.delete(cmd_name.to_sym)
       end
+
+      def all_aliases
+        @aliases
+      end
+
+      def get_alias(alias_name)
+        @aliases[alias_name.to_sym]
+      end
+
+      def add_alias(alias_name, command_string)
+        #return @commands[alias_name.to_sym]
+        if self.class.has_command?(alias_name)
+          raise "alias name '#{alias_name}' is invalid. That is the name of a morpheus command."
+        elsif alias_name.to_s.downcase.strip == command_string.to_s.downcase.strip
+          raise "alias #{alias_name}=#{command_string} is invalid..."
+        end
+        @aliases[alias_name.to_sym] = command_string
+      end
+
+      def remove_alias(alias_name)
+        @aliases.delete(alias_name.to_sym)
+      end
+
     end
   end
 end