Upgrade gsutil to 3.4

third_party/gsutil/boto/boto/roboto/awsqueryrequest.py

 # Copyright (c) 2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
 #
 # The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
 # ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
 # SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 # IN THE SOFTWARE.
 
 import sys
 import os
 import boto
 import optparse
 import copy
 import boto.exception
+import boto.roboto.awsqueryservice
+
+import bdb
+import traceback
+try:
+    import epdb as debugger
+except ImportError:
+    import pdb as debugger
+
+def boto_except_hook(debugger_flag, debug_flag):
+    def excepthook(typ, value, tb):
+        if typ is bdb.BdbQuit:
+            sys.exit(1)
+        sys.excepthook = sys.__excepthook__
+
+        if debugger_flag and sys.stdout.isatty() and sys.stdin.isatty():
+            if debugger.__name__ == 'epdb':
+                debugger.post_mortem(tb, typ, value)
+            else:
+                debugger.post_mortem(tb)
+        elif debug_flag:
+            print traceback.print_tb(tb)
+            sys.exit(1)
+        else:
+            print value
+            sys.exit(1)
+
+    return excepthook
 
 class Line(object):
 
     def __init__(self, fmt, data, label):
         self.fmt = fmt
         self.data = data
         self.label = label
         self.line = '%s\t' % label
         self.printed = False
 
@@ skipping 195 matching lines @@
                 if param.name in required:
                     required.remove(param.name)
                 if param.request_param:
                     if param.encoder:
                         param.encoder(param, self.request_params, value)
                     else:
                         Encoder.encode(param, self.request_params, value)
             if python_name in self.args:
                 del self.connection_args[python_name]
         if required:
-            raise RequiredParamError(required)
+            l = []
+            for p in self.Params+self.Args:
+                if p.name in required:
+                    if p.short_name and p.long_name:
+                        l.append('(%s, %s)' % (p.optparse_short_name,
+                                               p.optparse_long_name))
+                    elif p.short_name:
+                        l.append('(%s)' % p.optparse_short_name)
+                    else:
+                        l.append('(%s)' % p.optparse_long_name)
+            raise RequiredParamError(','.join(l))
         boto.log.debug('request_params: %s' % self.request_params)
         self.process_markers(self.Response)
 
     def process_markers(self, fmt, prev_name=None):
         if fmt and fmt['type'] == 'object':
             for prop in fmt['properties']:
                 self.process_markers(prop, fmt['name'])
         elif fmt and fmt['type'] == 'array':
             self.list_markers.append(prev_name)
             self.item_markers.append(fmt['name'])
@@ skipping 19 matching lines @@
             boto.log.error('%s' % self.body)
             raise conn.ResponseError(self.http_response.status,
                                      self.http_response.reason,
                                      self.body)
 
     def add_standard_options(self):
         group = optparse.OptionGroup(self.parser, 'Standard Options')
         # add standard options that all commands get
         group.add_option('-D', '--debug', action='store_true',
                          help='Turn on all debugging output')
+        group.add_option('--debugger', action='store_true',
+                         default=False,
+                         help='Enable interactive debugger on error')
         group.add_option('-U', '--url', action='store',
                          help='Override service URL with value provided')
         group.add_option('--region', action='store',
                          help='Name of the region to connect to')
         group.add_option('-I', '--access-key-id', action='store',
                          help='Override access key value')
         group.add_option('-S', '--secret-key', action='store',
                          help='Override secret key value')
         group.add_option('--version', action='store_true',
                          help='Display version string')
@@ skipping 18 matching lines @@
         if options.region:
             self.args['region'] = options.region
         if options.access_key_id:
             self.args['aws_access_key_id'] = options.access_key_id
         if options.secret_key:
             self.args['aws_secret_access_key'] = options.secret_key
         if options.version:
             # TODO - Where should the version # come from?
             print 'version x.xx'
             exit(0)
+        sys.excepthook = boto_except_hook(options.debugger,
+                                          options.debug)
 
+    def get_usage(self):
+        s = 'usage: %prog [options] '
+        l = [ a.long_name for a in self.Args ]
+        s += ' '.join(l)
+        for a in self.Args:
+            if a.doc:
+                s += '\n\n\t%s - %s' % (a.long_name, a.doc)
+        return s
+    
     def build_cli_parser(self):
-        self.parser = optparse.OptionParser()
+        self.parser = optparse.OptionParser(description=self.Description,
+                                            usage=self.get_usage())
         self.add_standard_options()
         for param in self.Params:
             ptype = action = choices = None
             if param.ptype in self.CLITypeMap:
                 ptype = self.CLITypeMap[param.ptype]
                 action = 'store'
             if param.ptype == 'boolean':
                 action = 'store_true'
             elif param.ptype == 'array':
                 if len(param.items) == 1:
@@ skipping 62 matching lines @@
             else:
                 self.args['filters'] = d
         try:
             response = self.main()
             self.cli_formatter(response)
         except RequiredParamError, e:
             print e
             sys.exit(1)
         except self.ServiceClass.ResponseError, err:
             print 'Error(%s): %s' % (err.error_code, err.error_message)
+            sys.exit(1)
+        except boto.roboto.awsqueryservice.NoCredentialsError, err:
+            print 'Unable to find credentials.'
+            sys.exit(1)
+        except Exception, e:
+            print e
+            sys.exit(1)
 
     def _generic_cli_formatter(self, fmt, data, label=''):
         if fmt['type'] == 'object':
             for prop in fmt['properties']:
                 if 'name' in fmt:
                     if fmt['name'] in data:
                         data = data[fmt['name']]
                     if fmt['name'] in self.list_markers:
                         label = fmt['name']
                         if label[-1] == 's':
@@ skipping 18 matching lines @@
         reasonable.  If you want specific formatting, you should
         override this method and do your own thing.
 
         :type data: dict
         :param data: The data returned by AWS.
         """
         if data:
             self._generic_cli_formatter(self.Response, data)