mtncloud-cli 1.0.0

data/lib/mtncloud/cli/error_handler.rb

@@ -0,0 +1,307 @@
+require 'term/ansicolor'
+require 'optparse'
+require 'json'
+require 'rest_client'
+require 'net/https'
+require 'mtncloud/logging'
+require 'mtncloud/cli/errors'
+require 'mtncloud/cli/expression_parser'
+
+class MtnCloud::Cli::ErrorHandler
+  include Term::ANSIColor
+
+  def initialize(io=$stderr)
+    @stderr = io
+  end
+
+  def handle_error(err, options={})
+    exit_code = 1
+    options = (options || {}).clone
+    if MtnCloud::Logging.debug?
+      options[:debug] = true
+    end
+    do_print_stacktrace = true
+    
+    #@stderr.puts "#{dark}Handling error #{err.class} - #{err}#{reset}"
+
+    case (err)
+    when SystemExit
+      # nothing to do, assume the command that exited printed an error already
+      # print "\n"
+      cmdexit = err
+      if cmdexit.success?
+        exit_code, err = 0, nil
+      else
+        exit_code, err = cmdexit.status, "Command exited with status: #{cmdexit.status}"
+      end
+      return exit_code, err
+    # when MtnCloud::Cli::CommandNotFoundError
+    #   puts_angry_error err.message
+    #   @stderr.puts "Try help to see a list of available commands"
+    #   do_print_stacktrace = false
+    #   if err.exit_code
+    #     exit_code = err.exit_code
+    #   end
+      when MtnCloud::Cli::CommandAborted
+        # user declined a confirmation prompt, do not print anything and exit 9
+        do_print_stacktrace = false
+        exit_code = err.exit_code if err.exit_code
+        # err = err.message
+    return 
+    when ::OptionParser::InvalidOption, ::OptionParser::AmbiguousOption, 
+        ::OptionParser::MissingArgument, ::OptionParser::InvalidArgument, 
+        ::OptionParser::NeedlessArgument
+      # raise err
+      # @stderr.puts "#{red}#{err.message}#{reset}"
+      puts_angry_error err.message
+      @stderr.puts err.optparse.banner if err.optparse && err.optparse.banner
+      @stderr.puts "Try --help for more usage information"
+      do_print_stacktrace = false
+      # exit_code = 127
+    when MtnCloud::Cli::CommandArgumentsError
+      puts_angry_error err.message
+      if err.args.include?("--help") || err.args.include?("--help")
+        @stderr.puts err.optparse
+      else
+        @stderr.puts err.optparse.banner if err.optparse && err.optparse.banner
+        @stderr.puts "Try --help for more usage information"
+      end
+      
+      do_print_stacktrace = false
+      if err.exit_code
+        exit_code = err.exit_code
+      end
+
+    when MtnCloud::Cli::CommandError
+      # this should probably always print the whole thing as red, but just does the first line for now.
+      # until verify_args! replaces raise_command_error where the full parser help is in the error message..
+      message_lines = err.message.split(/\r?\n/)
+      first_line = message_lines.shift
+      puts_angry_error first_line
+      if !message_lines.empty?
+        @stderr.puts message_lines.join("\n") unless message_lines.empty?
+      else
+        if err.args.include?("--help") || err.args.include?("--help")
+          @stderr.puts err.optparse
+        else
+          @stderr.puts err.optparse.banner if err.optparse && err.optparse.banner && message_lines.empty?
+          @stderr.puts "Try --help for more usage information"
+        end
+      end
+      do_print_stacktrace = false
+      if err.exit_code
+        exit_code = err.exit_code
+      end
+    when MtnCloud::Cli::ExpressionParser::InvalidExpression
+      # @stderr.puts "#{red}#{err.message}#{reset}"
+      puts_angry_error err.message
+      do_print_stacktrace = false
+      exit_code = 99
+    when SocketError
+      @stderr.puts "#{red}Error Communicating with the remote appliance.#{reset}"
+      @stderr.puts "#{red}#{err.message}#{reset}"
+    when RestClient::Exceptions::Timeout
+      @stderr.puts "#{red}Error Communicating with the remote appliance.#{reset}"
+      @stderr.puts "#{red}#{err.message}#{reset}"
+    when Errno::ECONNREFUSED
+      @stderr.puts "#{red}Error Communicating with the remote appliance.#{reset}"
+      @stderr.puts "#{red}#{err.message}#{reset}"
+    when OpenSSL::SSL::SSLError
+      @stderr.puts "#{red}Error Communicating with the remote appliance.#{reset}"
+      @stderr.puts "#{red}#{err.message}#{reset}"
+    when RestClient::Exception
+      print_rest_exception(err, options)
+      # no stacktrace for now...
+      return exit_code, err
+    when ArgumentError
+      @stderr.puts "#{red}Argument Error: #{err.message}#{reset}"
+    else
+      @stderr.puts "#{red}Unexpected Error#{reset}"
+    end
+
+    if do_print_stacktrace
+      if options[:debug]
+        if err.is_a?(Exception)
+          print_stacktrace(err)
+        else
+          @stderr.puts err.to_s
+        end
+      else
+        @stderr.puts "Use -V or --debug for more verbose debugging information."
+      end
+    end
+
+    return exit_code, err
+
+  end
+
+  def print_stacktrace(err)
+    @stderr.print red, "\n", "#{err.class}: #{err.message}", "\n", reset
+    @stderr.print err.backtrace.join("\n"), "\n\n"
+  end
+
+  # def handle_rest_exception(err, io=@stderr)
+  #   if !err.is_a?(RestClient::Exception)
+  #     raise err
+  #   end
+  #   print_rest_exception(err, io=@stderr)    
+  # end
+
+
+  def print_rest_exception(err, options)
+    e = err
+    # heh
+    if MtnCloud::Logging.debug? && options[:debug].nil?
+      options[:debug] = true
+    end
+    if err.response
+      if options[:debug]
+        begin
+          print_rest_exception_request_and_response(e)
+        ensure
+          @stderr.print reset
+        end
+        return
+      end
+      if err.response.code == 400
+        begin
+          print_rest_errors(JSON.parse(err.response.to_s), options)
+        rescue TypeError, JSON::ParserError => ex
+        end
+      elsif err.response.code == 404
+        begin
+          print_rest_errors(JSON.parse(err.response.to_s), options)
+        rescue TypeError, JSON::ParserError => ex
+          # not json, just 404
+          @stderr.print red, "Error Communicating with the remote appliance. #{e}", reset, "\n"  
+        end
+      else
+        @stderr.print red, "Error Communicating with the remote appliance. #{e}", reset, "\n"
+        if options[:json] || options[:debug]
+          begin
+            response = JSON.parse(e.response.to_s)
+            # @stderr.print red
+            @stderr.print JSON.pretty_generate(response)
+            @stderr.print reset, "\n"
+          rescue TypeError, JSON::ParserError => ex
+            @stderr.print red, "Failed to parse JSON response: #{ex}", reset, "\n"
+            # @stderr.print red
+            @stderr.print response.to_s
+            @stderr.print reset, "\n"
+          ensure
+            @stderr.print reset
+          end
+        else
+          # quick parse only for msg display
+          response = (JSON.parse(e.response.to_s) rescue nil)
+          if response.is_a?(Hash) && response['success'] == false && response['msg']
+            @stderr.print red, response['msg'].to_s, reset, "\n"
+          end
+          @stderr.puts "Use -V or --debug for more verbose debugging information."
+        end
+      end
+    else
+      @stderr.print red, "Error Communicating with the remote appliance. #{e}", reset, "\n"
+    end
+    # uh, having this print method return exit_code, err to standardize return values of methods that are still calling it, at the end just by chance..
+    # return exit_code, err
+    return 1, err
+  end
+
+  def print_rest_errors(response, options={})
+    begin
+      if options[:json]
+        @stderr.print red
+        @stderr.print JSON.pretty_generate(response)
+        @stderr.print reset, "\n"
+      else
+        if !response['success']
+          @stderr.print red,bold
+          if response['msg']
+            @stderr.puts response['msg']
+          end
+          if response['errors']
+            # response['errors'].each do |key, value|
+            #   @stderr.print "* #{key}: #{value}\n"
+            # end
+            # puts as_yaml(response['errors'])
+            @stderr.print format_rest_errors(response['errors'])
+          end
+          @stderr.print reset
+        else
+          # this should not really happen
+          @stderr.print cyan,bold, "\nSuccess!"
+        end
+      end
+    ensure
+      @stderr.print reset
+    end
+  end
+
+  def format_rest_errors(errors, context=nil)
+    out = ""
+    Hash(errors).each do |key, value|
+      if value.is_a?(Hash)
+        out << format_rest_errors(value, context ? "#{context}.#{key}" : key)
+      else
+        prefix = context ? (context + '.') : ''
+        out << "* #{prefix}#{key}: #{value}\n"
+      end
+    end
+    out
+  end
+
+  def print_rest_request(req)
+    @stderr.print "REQUEST"
+    @stderr.print "\n"
+    @stderr.print "#{req.method.to_s.upcase} #{req.url.inspect}"
+    @stderr.print "\n"
+  end
+
+  def print_rest_response(res)
+    # size = @raw_response ? File.size(@tf.path) : (res.body.nil? ? 0 : res.body.size)
+    size = (res.body.nil? ? 0 : res.body.size)
+    @stderr.print "RESPONSE"
+    @stderr.print "\n"
+    display_size = Filesize.from("#{size} B").pretty rescue size
+    @stderr.print "HTTP #{res.net_http_res.code} #{res.net_http_res.message} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{display_size}"
+    @stderr.print "\n"
+    begin
+      @stderr.print JSON.pretty_generate(JSON.parse(res.body))
+    rescue
+      @stderr.print res.body.to_s
+    end
+    @stderr.print "\n"
+  end
+
+  def print_rest_exception_request_and_response(e)
+    @stderr.puts "#{red}Error Communicating with the remote appliance. (HTTP #{e.response.code})#{reset}"
+    response = e.response
+    request = response.instance_variable_get("@request")
+    @stderr.print red
+    print_rest_request(request)
+    @stderr.print "\n"
+    print_rest_response(response)
+    @stderr.print reset
+  end
+
+
+protected
+  
+  def puts_angry_error(*msgs)
+    # @stderr.print "#{Term::ANSIColor.red}mtncloud: #{Term::ANSIColor.reset}#{msg}\n"
+    @stderr.print(MtnCloud::Terminal.angry_prompt)
+    @stderr.print(Term::ANSIColor.red)
+    @stderr.puts(*msgs)
+    @stderr.print(reset)
+  end
+
+  # def puts(*args)
+  #   @stderr.puts(*args) 
+  # end
+
+  # def print(*args)
+  #   @stderr.print(*args)
+  # end
+
+end

data/lib/mtncloud/cli/errors.rb

@@ -0,0 +1,53 @@
+module MtnCloud::Cli
+
+  # A standard error to raise in your CliCommand classes.
+  class CommandError < StandardError
+    
+    attr_reader :args, :optparse, :exit_code
+      
+    def initialize(msg, args=[], optparse=nil, exit_code=nil)
+      @args = args
+      @optparse = optparse
+      @exit_code = exit_code # || 1
+      super(msg)
+    end
+
+  end
+
+  # An error indicating the command was not recognized, assigned exit code 127
+  class CommandNotFoundError < CommandError
+    
+    def initialize(msg, args=[], optparse=nil, exit_code=nil)
+      super(msg, args, optparse, exit_code || 127)
+    end
+
+  end
+
+  # An error for wrong number of arguments
+  # could use ::OptionParser::MissingArgument, ::OptionParser::NeedlessArgument
+  # maybe return an error code other than 1?
+  class CommandArgumentsError < CommandError
+
+    def initialize(msg, args=[], optparse=nil, exit_code=nil)
+      super(msg, args, optparse, exit_code || 1)
+    end
+
+  end
+
+  # An error indicating authorization is required (unable to aquire access token)
+  class AuthorizationRequiredError < CommandError
+
+    def initialize(msg, args=[], optparse=nil, exit_code=nil)
+      super(msg, args, optparse, exit_code || 1)
+    end
+  end
+
+  # An error indicating the user declined to accept a confirmation prompt, assigned exit code 9
+  class CommandAborted < CommandError
+
+    def initialize(msg, args=[], optparse=nil, exit_code=nil)
+      super(msg, args, optparse, exit_code || 9)
+    end
+  end
+
+end

data/lib/mtncloud/cli/expression_parser.rb

@@ -0,0 +1,153 @@
+require 'shellwords'
+
+# Provides parsing of user input into an Array of expressions for execution
+# Syntax currently supports the && and || operators, and the use of parenthesis
+# returns an Array of objects.
+# Each object might be a command (String), an operator (well known String) 
+# or another expression (Array)
+module MtnCloud::Cli::ExpressionParser
+
+  # An error class for invalid expressions
+  class InvalidExpression < StandardError
+  end
+
+  ## constants used internally for parsing mtncloud expressions
+  # note: the space padding in the _TOKEN strings is important for splitting
+
+  OPEN_PARENTHESIS = "("
+  OPEN_PARENTHESIS_TOKEN = "___+++OPEN_PARENTHESIS+++___"
+  OPEN_PARENTHESIS_REGEX = /(\()(?=(?:[^"']|"[^'"]*")*$)/
+
+  CLOSED_PARENTHESIS = ")"
+  CLOSED_PARENTHESIS_TOKEN = "___+++CLOSED_PARENTHESIS+++___"
+  CLOSED_PARENTHESIS_REGEX = /(\))(?=(?:[^"']|"[^'"]*")*$)/
+
+  AND_OPERATOR = "&&"
+  AND_OPERATOR_TOKEN = "___+++AND_OPERATOR+++___"
+  AND_OPERATOR_REGEX = /(\&\&)(?=(?:[^"']|"[^'"]*")*$)/
+
+  OR_OPERATOR = "||"
+  OR_OPERATOR_TOKEN = "___+++OR_OPERATOR+++___"
+  OR_OPERATOR_REGEX = /(\|\|)(?=(?:[^"']|"[^'"]*")*$)/
+
+  PIPE_OPERATOR = "|"
+  PIPE_OPERATOR_TOKEN = "___+++PIPE_OPERATOR+++___"
+  PIPE_OPERATOR_REGEX = /(\|)(?=(?:[^"']|"[^'"]*")*$)/
+
+  COMMAND_DELIMETER = ";"
+  COMMAND_DELIMETER_REGEX = /(\;)(?=(?:[^"']|"[^'"]*")*$)/
+  COMMAND_DELIMETER_TOKEN = "___+++COMMAND_DELIMETER+++___"
+
+  # parse an expression of mtncloud commands into a list of expressions
+  def self.parse(input)
+    # the input is a comment
+    if input.to_s =~ /^\s*#/
+      return [input]
+    end
+    result = []
+    # first, build up a temporary command string
+    # swap in well known tokens so we can split it safely
+    expression_str = input.dup.to_s
+    expression_str.gsub!(OPEN_PARENTHESIS_REGEX, " #{OPEN_PARENTHESIS_TOKEN} ")
+    expression_str.gsub!(CLOSED_PARENTHESIS_REGEX, " #{CLOSED_PARENTHESIS_TOKEN} ")
+    expression_str.gsub!(AND_OPERATOR_REGEX, " #{AND_OPERATOR_TOKEN} ")
+    expression_str.gsub!(OR_OPERATOR_REGEX, " #{OR_OPERATOR_TOKEN} ")
+    expression_str.gsub!(PIPE_OPERATOR_REGEX, " #{PIPE_OPERATOR_TOKEN} ")
+    expression_str.gsub!(COMMAND_DELIMETER_REGEX, " #{COMMAND_DELIMETER_TOKEN} ")
+    # split on unquoted whitespace
+    tokens = expression_str.split(/(\s)(?=(?:[^"']|"[^'"]*")*$)/).collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
+    # swap back for nice looking tokens
+    tokens = tokens.map do |t|
+      case t
+      when OPEN_PARENTHESIS_TOKEN then OPEN_PARENTHESIS
+      when CLOSED_PARENTHESIS_TOKEN then CLOSED_PARENTHESIS
+      when AND_OPERATOR_TOKEN then AND_OPERATOR
+      when OR_OPERATOR_TOKEN then OR_OPERATOR
+      when PIPE_OPERATOR_TOKEN then PIPE_OPERATOR
+      when COMMAND_DELIMETER_TOKEN then COMMAND_DELIMETER
+      else
+        t
+      end
+    end
+    
+    # result = parse_expression_from_tokens(tokens)
+    begin
+      result = parse_expression_from_tokens(tokens)
+    rescue InvalidExpression => ex
+      raise InvalidExpression.new("#{ex}. Invalid Expression: #{input}")
+    end
+    return result
+  end
+
+  # turn a flat list of tokens into an array of expressions
+  def self.parse_expression_from_tokens(tokens)
+    result = []
+    remaining_tokens = tokens.dup
+    current_command_tokens = []
+    while !remaining_tokens.empty?
+      token = remaining_tokens.shift
+      if token == CLOSED_PARENTHESIS
+        raise InvalidExpression.new("Encountered a closed parenthesis ')' with no matching open parenthesis '('")
+      elsif token == OPEN_PARENTHESIS
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+        # start of a new sub expression
+        # find the index of the matching closed parenthesis
+        cur_expression_index = 0
+        closed_parenthesis_index = nil
+        remaining_tokens.each_with_index do |t, index|
+          if t == OPEN_PARENTHESIS
+            cur_expression_index += 1
+          elsif t == CLOSED_PARENTHESIS
+            if cur_expression_index == 0
+              closed_parenthesis_index = index
+              break
+            else
+              cur_expression_index -= 1
+            end
+          end
+          if cur_expression_index < 0
+            raise InvalidExpression.new("Encountered a closed parenthesis ')' with no matching open parenthesis '('")
+          end
+        end
+        if !closed_parenthesis_index
+          raise InvalidExpression.new("Encountered an open parenthesis '(' with no matching closed parenthesis ')'")
+        end
+        # ok, parse a subexpression for the tokens up that index
+        sub_tokens = remaining_tokens[0..closed_parenthesis_index-1]
+        result << parse_expression_from_tokens(sub_tokens)
+        # continue on parsing the remaining tokens
+        remaining_tokens = remaining_tokens[closed_parenthesis_index + 1..remaining_tokens.size - 1]
+      elsif token == AND_OPERATOR || token == OR_OPERATOR || token == PIPE_OPERATOR
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+        # add the operator
+        result << token
+      elsif token == COMMAND_DELIMETER
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+      else
+        # everything else is assumed to be part of a command, inject it
+        current_command_tokens << token
+      end
+    end
+    
+    # add the command
+    if current_command_tokens.size != 0
+      result << current_command_tokens.join(" ")
+      current_command_tokens = []
+    end
+
+    return result
+  end
+
+end