mtncloud-cli 1.0.0

data/lib/mtncloud/cli/cli_registry.rb

@@ -0,0 +1,337 @@
+require 'term/ansicolor'
+require 'shellwords'
+require 'mtncloud/logging'
+require 'mtncloud/cli/errors'
+require 'mtncloud/cli/error_handler'
+require 'mtncloud/cli/expression_parser'
+require 'mtncloud/ext/string'
+
+module MtnCloud
+  module Cli
+    class CliRegistry
+
+      class BadCommandDefinition < StandardError
+      end
+
+      class BadAlias < StandardError
+      end
+
+      def initialize
+        @commands = {} # this is command => Class that includes ::CliCommand
+        @aliases = {} # this is alias => String full input string
+      end
+
+      def flush
+        @commands = {}
+        @aliases = {}
+      end
+      
+      def all
+        @commands.reject {|cmd, klass| klass.hidden_command }
+      end
+
+      def get(cmd_name)
+        @commands[cmd_name.to_sym]
+      end
+
+      def add(cmd_name, klass)
+        @commands[cmd_name.to_sym] = klass
+      end
+
+      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 BadAlias.new "alias name '#{alias_name}' is invalid. That is the name of an existing command."
+        elsif alias_name.to_s.downcase.strip == command_string.to_s.downcase.strip
+          raise BadAlias.new "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
+
+      class << self
+        include Term::ANSIColor
+
+        def instance
+          @instance ||= CliRegistry.new
+        end
+
+        #todo: move execution out of the CliRegistry
+        def exec(command_name, args)
+          exec_command(command_name, args)
+        end
+
+        def exec_command(command_name, args)
+          #puts "exec_command(#{command_name}, #{args})"
+          result = nil
+          if has_alias?(command_name)
+            result = exec_alias(command_name, args)
+          elsif has_command?(command_name)
+            begin
+              result = instance.get(command_name).new.handle(args)
+            rescue SystemExit => e
+              result = MtnCloud::Cli::ErrorHandler.new(MtnCloud::Terminal.instance.stderr).handle_error(e) # lol
+            rescue => e
+              result = MtnCloud::Cli::ErrorHandler.new(MtnCloud::Terminal.instance.stderr).handle_error(e) # lol
+            end
+          else
+            # todo: need to just return error instead of raise
+            msg = "'#{command_name}' is not a known command. See '#{MtnCloud::Cli.prog_name} --help'."
+            suggestions = find_command_suggestions(command_name)
+            if suggestions && suggestions.size == 1
+              msg += "\nThe most similar command is:\n"
+              msg += "\t" + suggestions.first + "\n"
+            elsif suggestions && suggestions.size > 1
+              msg += "\nThe most similar commands are:\n"
+              suggestions.first(50).each do |suggestion|
+                msg += "\t" + suggestion + "\n"
+              end
+            end
+            #raise CommandNotFoundError.new(msg)
+            result = MtnCloud::Cli::ErrorHandler.new(MtnCloud::Terminal.instance.stderr).handle_error(CommandNotFoundError.new(msg)) # lol
+          end
+          return result
+        end
+
+        def exec_alias(alias_name, args)
+          found_alias_command = instance.get_alias(alias_name)
+          if !found_alias_command
+            raise MtnCloud::Cli::CommandError.new("'#{alias_name}' is not a defined alias.")
+          end
+          # if !is_valid_expression(found_alias_command)
+          #   raise MtnCloud::Cli::CommandError.new("alias '#{alias_name}' is not a valid expression: #{found_alias_command}")
+          # end
+          input = found_alias_command
+          if args && !args.empty?
+            input = "#{found_alias_command} " + args.collect {|arg| arg.include?(" ") ? "\"#{arg}\"" : "#{arg}" }.join(" ")
+          end
+          exec_expression(input)
+        end
+
+        def exec_expression(input)
+          # puts "exec_expression(#{input})"
+          flow = input
+          if input.is_a?(String)
+            begin
+              flow = MtnCloud::Cli::ExpressionParser.parse(input)
+            rescue MtnCloud::Cli::ExpressionParser::InvalidExpression => e
+              raise e
+            end
+          end
+          # puts "executing flow: #{flow.inspect}"
+          final_command_result = nil
+          if flow.size == 0
+            # no input eh?
+          else
+            last_command_result = nil
+            if ['&&','||', '|'].include?(flow.first)
+              raise MtnCloud::Cli::ExpressionParser::InvalidExpression.new "#{MtnCloud::Terminal.angry_prompt}invalid command format, begins with an operator: #{input}"
+            elsif ['&&','||', '|'].include?(flow.last)
+              raise MtnCloud::Cli::ExpressionParser::InvalidExpression.new "#{MtnCloud::Terminal.angry_prompt}invalid command format, ends with an operator: #{input}"
+            # elsif ['&&','||', '|'].include?(flow.last)
+            #   raise MtnCloud::Cli::ExpressionParser::InvalidExpression.new "invalid command format, consecutive operators: #{cmd}"
+            else
+              #MtnCloud::Logging::DarkPrinter.puts "Executing command flow: #{flow.inspect}" if MtnCloud::Logging.debug?
+              previous_command = nil
+              previous_command_result = nil
+              current_operator = nil
+              still_executing = true
+              # need to error before executing anything, could be dangerous otherwise!
+              # also maybe only pass flow commands if they have a space on either side..
+              if flow.include?("|")
+                raise MtnCloud::Cli::ExpressionParser::InvalidExpression.new "The PIPE (|) operator is not yet supported. You can wrap your arguments in quotations."
+              end
+              flow.each do |flow_cmd|
+                if still_executing
+                  if flow_cmd == '&&'
+                    # AND operator
+                    current_operator = flow_cmd
+                    exit_code, cmd_err = parse_command_result(previous_command_result)
+                    if exit_code != 0
+                      still_executing = false
+                    end
+                  elsif flow_cmd == '||' # or with previous command
+                    current_operator = flow_cmd
+                    exit_code, err = parse_command_result(previous_command_result)
+                    if exit_code == 0
+                      still_executing = false
+                    end
+                  elsif flow_cmd == '|' # or with previous command
+                    # todo, handle pipe!
+                    raise MtnCloud::Cli::ExpressionParser::InvalidExpression.new "The PIPE (|) operator is not yet supported. You can wrap your arguments in quotations."
+                    previous_command_result = nil
+                    still_executing = false
+                    # or just continue?
+                  elsif flow_cmd.is_a?(Array)
+                    # this is a subexpression, execute it as such
+                    current_operator = nil
+                    previous_command_result = exec_expression(flow_cmd)
+                  else # it's a command, not an operator
+                    current_operator = nil
+                    flow_argv = Shellwords.shellsplit(flow_cmd)
+                    previous_command_result = exec_command(flow_argv[0], flow_argv[1..-1])
+                  end
+                  previous_command = flow_cmd
+                else
+                  #MtnCloud::Logging::DarkPrinter.puts "operator skipped command: #{flow_cmd}" if MtnCloud::Logging.debug?
+                end
+                # previous_command = flow_cmd
+              end
+              final_command_result = previous_command_result
+            end
+          end
+          return final_command_result
+        end
+
+        def add(klass, command_name=nil)
+          klass_command_name = cli_ize(klass.name.split('::')[-1])
+          if has_command?(klass_command_name)
+            instance.remove(klass_command_name)
+          end
+          command_name ||= klass_command_name
+          instance.add(command_name, klass)
+        end
+
+        def has_command?(command_name)
+          if command_name.nil? || command_name == ''
+            false
+          else
+            !instance.get(command_name).nil?
+          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
+
+        def all_aliases
+          instance.all_aliases
+        end
+
+        def cli_ize(klass_name)
+          # borrowed from ActiveSupport
+          return klass_name unless klass_name =~ /[A-Z-]|::/
+          word = klass_name.to_s.gsub(/::/, '/')
+          word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(?=\b|[^a-z])/) { "#{$1 && '_'}" }
+          word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+          word.tr!("-", "_")
+          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
+
+        # parse any object into a command result [exit_code, error]
+        # 0 means success.
+        # This treats nil, true, or an object as success ie. [0, nil]
+        # and false is treated as an error [1, error]
+        # @return [Array] [exit_code, error]. Success returns [0, nil].
+        def parse_command_result(cmd_result)
+          exit_code, error = nil, nil
+          if cmd_result.is_a?(Array)
+            exit_code = cmd_result[0] || 0
+            error = cmd_result[1]
+          elsif cmd_result.is_a?(Hash)
+            exit_code = cmd_result[:exit_code] || 0
+            error = cmd_result[:error] || cmd_result[:err]
+          elsif cmd_result == nil || cmd_result == true
+            exit_code = 0
+          elsif cmd_result == false
+            exit_code = 1
+          elsif cmd_result.is_a?(Integer)
+            exit_code = cmd_result
+          elsif cmd_result.is_a?(Float)
+            exit_code = cmd_result.to_i
+          elsif cmd_result.is_a?(String)
+            exit_code = cmd_result.to_i
+          else
+            if cmd_result.respond_to?(:to_i)
+              exit_code = cmd_result.to_i
+            else
+              # happens for aliases right now.. and execution flow probably, need to handle Array
+              # uncomment to track them down, proceed with exit 0 for now
+              #MtnCloud::Logging::DarkPrinter.puts "debug: command #{command_name} produced an unexpected result: (#{cmd_result.class}) #{cmd_result}" if MtnCloud::Logging.debug?
+              exit_code = 0
+            end
+          end
+          return exit_code, error
+        end
+
+        def cached_command_list
+          @cached_command_list ||= (all.keys + all_aliases.keys).collect { |it| it.to_s }.sort
+        end
+
+        def clear_cached_command_list
+          @cached_command_list = nil
+        end
+
+        # find suggested commands (or aliases) for a name that was not found
+        # First this looks for the plural of the original guess
+        # Then pop characters off the end looking for partial matches
+        # as long as the guess is at least 3 characters
+        def find_command_suggestions(command_name)
+          every_command = cached_command_list
+          guess = command_name
+          suggestions = []
+          while suggestions.empty? && guess.size >= 3
+            plural_guess = guess.pluralize
+            if every_command.include?(guess)
+              suggestions << guess
+            end
+            if every_command.include?(plural_guess)
+              suggestions << plural_guess
+            end
+            # if every_command.include?(guess)
+            #   suggestions << plural_guess
+            # else
+              guess_regexp = /^#{Regexp.escape(guess)}/i
+              every_command.each do |it|
+                if it =~ guess_regexp
+                  suggestions << it
+                end
+              end
+            # end
+            guess = guess[0..-2]
+          end
+          suggestions.uniq!
+          suggestions.sort! { |x,y| [x.split('-').size, x] <=> [y.split('-').size, y] }
+          return suggestions
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mtncloud/cli/commands/access_token_command.rb

@@ -0,0 +1,201 @@
+require 'mtncloud/cli/cli_command'
+
+# This provides commands for authentication 
+# This also includes credential management.
+class MtnCloud::Cli::AccessTokenCommand
+  include MtnCloud::Cli::CliCommand
+
+  set_command_name :'access-token'
+  #set_command_name :'access'
+  register_subcommands :get => :print_access_token
+  register_subcommands :details => :details
+  register_subcommands :refresh => :use_refresh_token
+
+  def initialize()
+    # @appliance_name, @appliance_url = MtnCloud::Cli::Remote.active_appliance
+  end
+
+  # connect overridden to skip login and return an exit_code
+  def connect(options)
+    @api_client = establish_remote_appliance_connection(options.merge({:no_prompt => true, :skip_verify_access_token => true, :skip_login => true}))
+    # automatically get @appliance_name, @appliance_url, @wallet
+    if !@appliance_name
+      raise_command_error "#{command_name} requires a remote to be specified, use -r [remote] or set the active remote with `remote use`"
+    end
+    if !@appliance_url
+      unless options[:quiet]
+        print red,"Unable to determine remote appliance url. Review your remote configuration.#{reset}\n"
+      end
+      return 1
+    end
+    #@wallet = MtnCloud::Cli::Credentials.new(@appliance_name, @appliance_url).load_saved_credentials()
+    if @wallet.nil? || @wallet['access_token'].nil?
+      unless options[:quiet]
+        print_error yellow,"You are not currently logged in to #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+        print_error yellow,"Use `login` to authenticate or try passing the --username option.",reset,"\n"
+      end
+      return 1
+    end
+    return 0
+  end
+
+  def handle(args)
+    # access-token get by default, except access-token -h should list the subcommands.
+    if args.empty? || (args[0] && args[0] =~ /^\-/ && !['-h', '--help'].include?(args[0]))
+      print_access_token(args)
+    else
+      handle_subcommand(args)
+    end
+  end
+
+  def details(args)
+    options = {}
+    params = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_common_options(opts, options, [:remote, :quiet])
+      opts.footer = "Print your current authentication credentials.\n" +
+                    "This contains tokens that should be kept secret. Be careful."
+    end
+    optparse.parse!(args)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
+    end
+    connect_result = connect(options)
+    return connect_result if (connect_result.is_a?(Numeric) && connect_result != 0)
+  
+    # could fetch and show whoami info as well eh?
+    # extra api call though..
+
+    #print_h1 "MTN Cloud Credentials", [display_appliance(@appliance_name, @appliance_url)], options
+    print_h1 "Credentials", options
+    description_cols = {
+      "Username" => lambda {|wallet| wallet['username'] },
+      "Access Token" => lambda {|wallet| wallet['access_token'] },
+      "Refresh Token" => lambda {|wallet| wallet['refresh_token'] },
+      "Login Date" => lambda {|wallet| format_local_dt(wallet['login_date']) },
+      "Expire Date" => lambda {|wallet| wallet['expire_date'] ? format_local_dt(wallet['expire_date']) : "" },
+      "Remote" => lambda {|wallet| display_appliance(@appliance_name, @appliance_url) },
+    }
+    print cyan
+    puts as_description_list(@wallet, description_cols)
+    print reset
+    return 0
+  end
+
+  def print_access_token(args)
+    options = {}
+    params = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      build_common_options(opts, options, [:remote, :quiet])
+      opts.footer = "Print your current access token.\n" +
+                    "This token should be kept secret. Be careful."
+    end
+    optparse.parse!(args)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
+    end
+    connect_result = connect(options)
+    return connect_result if (connect_result.is_a?(Numeric) && connect_result != 0)
+    unless options[:quiet]
+      print cyan
+      puts @wallet['access_token']
+      print reset
+    end
+    return @wallet['access_token'] ? 0 : 1
+  end
+
+  def use_refresh_token(args)
+    options = {}
+    params = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage()
+      opts.on( '-T', '--token TOKEN', "Refresh Token to use. The saved credentials are used by default." ) do |val|
+        options[:refresh_token] = val
+      end
+      opts.on( '--token-file FILE', String, "Refresh Token File, read a file containing the refresh token." ) do |val|
+        token_file = File.expand_path(val)
+        if !File.exist?(token_file) || !File.file?(token_file)
+          raise ::OptionParser::InvalidOption.new("File not found: #{token_file}")
+        end
+        options[:refresh_token] = File.read(token_file).to_s.split("\n").first.strip
+      end
+      build_common_options(opts, options, [:auto_confirm, :remote, :dry_run, :json, :quiet], [:remote_username, :remote_password, :remote_token])
+      opts.footer = "Use the refresh token in your saved credentials, or a provided token.\n" +
+                    "This will replace your current access and refresh tokens with a new values.\n" +
+                    "Your current access token will be invalidated\n" +
+                    "All other users or applications with access to your token will need to update to the new token."
+    end
+    optparse.parse!(args)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args.join(' ')}\n#{optparse}"
+    end
+
+    connect_result = connect(options)
+    return connect_result if (connect_result.is_a?(Numeric) && connect_result != 0)
+    # if @wallet.nil? || @wallet['access_token'].nil?
+    #   unless options[:quiet]
+    #     print_error yellow,"You are not currently logged in to #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+    #     print_error yellow,"Use `login` to authenticate or try passing the --username option.",reset,"\n"
+    #   end
+    #   return 1
+    # end
+    refresh_token_value = nil
+    if options[:refresh_token]
+      refresh_token_value = options[:refresh_token]
+    else
+      if @wallet['refresh_token']
+        refresh_token_value = @wallet['refresh_token']
+      else
+        unless options[:quiet]
+          print_error yellow,"No refresh token found for appliance #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+          print_error yellow,"Use the 'login' command.",reset,"\n"
+        end
+        return 1
+      end
+    end
+    if options[:dry_run]
+      print_dry_run @api_client.auth.dry.use_refresh_token(refresh_token_value)
+      return 0
+    end
+    unless options[:quiet]
+      access_token = @wallet['access_token'].to_s
+      visible_part = access_token[0..7]
+      if visible_part
+        masked_access_token = visible_part + access_token[8..-1].gsub(/[^-]/, '*')
+      else
+        masked_access_token = access_token.gsub(/[^-]/, '*')
+      end
+      print cyan,"#{bold}WARNING!#{reset}#{cyan} You are about to invalidate your current access token '#{masked_access_token}'.",reset,"\n"
+      print cyan, "You will need to update everywhere this token is used.",reset, "\n"
+    end
+    
+    unless options[:yes] || MtnCloud::Cli::OptionTypes.confirm("Are you sure you want to refresh your access token?")
+      return 9, "aborted command"
+    end
+
+    # ok, let's use our refresh token
+    # this regenerates the current access token.
+    refresh_result = MtnCloud::Cli::Credentials.new(@appliance_name, @appliance_url).use_refresh_token(refresh_token_value, options)
+    new_wallet = refresh_result
+    if options[:json]
+      puts as_json(refresh_result, options)
+      return new_wallet ? 0 : 1
+    end
+    if new_wallet
+      unless options[:quiet]
+        print_green_success "Access token refreshed: #{new_wallet['access_token']}"
+        #print_green_success "Access token refreshed"
+        details([])
+      end
+      return 0
+    else
+      print_red_alert "Failed to use refresh token."
+      return 1
+    end
+  end
+
+  protected
+
+end