Roll version of gsutil to 4.15.

third_party/gsutil/gslib/boto_translation.py

 # -*- coding: utf-8 -*-
 # Copyright 2013 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
@@ skipping 12 matching lines @@
 import httplib
 import json
 import multiprocessing
 import os
 import pickle
 import random
 import re
 import socket
 import tempfile
 import textwrap
+import threading
 import time
 import xml
 from xml.dom.minidom import parseString as XmlParseString
 from xml.sax import _exceptions as SaxExceptions
 
 import boto
 from boto import handler
 from boto.exception import ResumableDownloadException as BotoResumableDownloadException
 from boto.exception import ResumableTransferDisposition
 from boto.gs.cors import Cors
@@ skipping 24 matching lines @@
 from gslib.hashing_helper import Base64EncodeHash
 from gslib.hashing_helper import Base64ToHexHash
 from gslib.project_id import GOOG_PROJ_ID_HDR
 from gslib.project_id import PopulateProjectId
 from gslib.storage_url import StorageUrlFromString
 from gslib.third_party.storage_apitools import storage_v1_messages as apitools_messages
 from gslib.translation_helper import AclTranslation
 from gslib.translation_helper import AddS3MarkerAclToObjectMetadata
 from gslib.translation_helper import CorsTranslation
 from gslib.translation_helper import CreateBucketNotFoundException
+from gslib.translation_helper import CreateNotFoundExceptionForObjectWrite
 from gslib.translation_helper import CreateObjectNotFoundException
 from gslib.translation_helper import DEFAULT_CONTENT_TYPE
 from gslib.translation_helper import EncodeStringAsLong
 from gslib.translation_helper import GenerationFromUrlAndString
 from gslib.translation_helper import HeadersFromObjectMetadata
 from gslib.translation_helper import LifecycleTranslation
 from gslib.translation_helper import REMOVE_CORS_CONFIG
 from gslib.translation_helper import S3MarkerAclFromObjectMetadata
 from gslib.util import ConfigureNoOpAuthIfNeeded
 from gslib.util import DEFAULT_FILE_BUFFER_SIZE
-from gslib.util import GetFileSize
 from gslib.util import GetMaxRetryDelay
 from gslib.util import GetNumRetries
-from gslib.util import MultiprocessingIsAvailable
 from gslib.util import S3_DELETE_MARKER_GUID
 from gslib.util import TWO_MIB
 from gslib.util import UnaryDictToXml
 from gslib.util import UTF8
 from gslib.util import XML_PROGRESS_CALLBACKS
 
 TRANSLATABLE_BOTO_EXCEPTIONS = (boto.exception.BotoServerError,
                                 boto.exception.InvalidUriError,
                                 boto.exception.ResumableDownloadException,
                                 boto.exception.ResumableUploadException,
                                 boto.exception.StorageCreateError,
                                 boto.exception.StorageResponseError)
 
-# If multiprocessing is available, this will be overridden to a (thread-safe)
-# multiprocessing.Value in a call to InitializeMultiprocessingVariables.
+# pylint: disable=global-at-module-level
+global boto_auth_initialized, boto_auth_initialized_lock
+# If multiprocessing is available, these will be overridden to process-safe
+# variables in InitializeMultiprocessingVariables.
+boto_auth_initialized_lock = threading.Lock()
 boto_auth_initialized = False
 
 NON_EXISTENT_OBJECT_REGEX = re.compile(r'.*non-\s*existent\s*object',
                                        flags=re.DOTALL)
 # Determines whether an etag is a valid MD5.
 MD5_REGEX = re.compile(r'^"*[a-fA-F0-9]{32}"*$')
 
 
-def InitializeMultiprocessingVariables():
+def InitializeMultiprocessingVariables():  # pylint: disable=invalid-name
   """Perform necessary initialization for multiprocessing.
 
     See gslib.command.InitializeMultiprocessingVariables for an explanation
     of why this is necessary.
   """
-  global boto_auth_initialized  # pylint: disable=global-variable-undefined
+  # pylint: disable=global-variable-undefined
+  global boto_auth_initialized, boto_auth_initialized_lock
+  boto_auth_initialized_lock = gslib.util.CreateLock()
   boto_auth_initialized = multiprocessing.Value('i', 0)
 
 
+class DownloadProxyCallbackHandler(object):
+  """Intermediary callback to keep track of the number of bytes downloaded."""
+
+  def __init__(self, start_byte, callback):
+    self._start_byte = start_byte
+    self._callback = callback
+
+  def call(self, bytes_downloaded, total_size):
+    """Saves necessary data and then calls the given Cloud API callback.
+
+    Args:
+      bytes_downloaded: Number of bytes processed so far.
+      total_size: Total size of the ongoing operation.
+    """
+    if self._callback:
+      self._callback(self._start_byte + bytes_downloaded, total_size)
+
+
 class BotoTranslation(CloudApi):
   """Boto-based XML translation implementation of gsutil Cloud API.
 
   This class takes gsutil Cloud API objects, translates them to XML service
   calls, and translates the results back into gsutil Cloud API objects for
   use by the caller.
   """
 
   def __init__(self, bucket_storage_uri_class, logger, provider=None,
-               credentials=None, debug=0):
+               credentials=None, debug=0, trace_token=None):
     """Performs necessary setup for interacting with the cloud storage provider.
 
     Args:
       bucket_storage_uri_class: boto storage_uri class, used by APIs that
                                 provide boto translation or mocking.
       logger: logging.logger for outputting log messages.
       provider: Provider prefix describing cloud storage provider to connect to.
                 'gs' and 's3' are supported. Function implementations ignore
                 the provider argument and use this one instead.
       credentials: Unused.
       debug: Debug level for the API implementation (0..3).
+      trace_token: Unused in this subclass.
     """
     super(BotoTranslation, self).__init__(bucket_storage_uri_class, logger,
                                           provider=provider, debug=debug)
     _ = credentials
-    global boto_auth_initialized  # pylint: disable=global-variable-undefined
-    if MultiprocessingIsAvailable()[0] and not boto_auth_initialized.value:
+    # pylint: disable=global-variable-undefined, global-variable-not-assigned
+    global boto_auth_initialized, boto_auth_initialized_lock
+    with boto_auth_initialized_lock:
       ConfigureNoOpAuthIfNeeded()
-      boto_auth_initialized.value = 1
-    elif not boto_auth_initialized:
-      ConfigureNoOpAuthIfNeeded()
-      boto_auth_initialized = True
+      if isinstance(boto_auth_initialized, bool):
+        boto_auth_initialized = True
+      else:
+        boto_auth_initialized.value = 1
     self.api_version = boto.config.get_value(
         'GSUtil', 'default_api_version', '1')
 
   def GetBucket(self, bucket_name, provider=None, fields=None):
     """See CloudApi class for function doc strings."""
     _ = provider
     bucket_uri = self._StorageUriForBucket(bucket_name)
     headers = {}
     self._AddApiVersionToHeaders(headers)
     try:
@@ skipping 145 matching lines @@
         raise NotFoundException('Bucket %s does not exist.' % bucket_name)
       else:
         self._TranslateExceptionAndRaise(e, bucket_name=bucket_name)
 
   def ListObjects(self, bucket_name, prefix=None, delimiter=None,
                   all_versions=None, provider=None, fields=None):
     """See CloudApi class for function doc strings."""
     _ = provider
     get_fields = self._ListToGetFields(list_fields=fields)
     bucket_uri = self._StorageUriForBucket(bucket_name)
-    prefix_list = []
     headers = {}
+    yield_prefixes = fields is None or 'prefixes' in fields
+    yield_objects = fields is None or any(
+        field.startswith('items/') for field in fields)
     self._AddApiVersionToHeaders(headers)
     try:
       objects_iter = bucket_uri.list_bucket(prefix=prefix or '',
                                             delimiter=delimiter or '',
                                             all_versions=all_versions,
                                             headers=headers)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
       self._TranslateExceptionAndRaise(e, bucket_name=bucket_name)
 
     try:
       for key in objects_iter:
-        if isinstance(key, Prefix):
-          prefix_list.append(key.name)
+        if yield_prefixes and isinstance(key, Prefix):
           yield CloudApi.CsObjectOrPrefix(key.name,
                                           CloudApi.CsObjectOrPrefixType.PREFIX)
-        else:
+        elif yield_objects:
           key_to_convert = key
 
           # Listed keys are populated with these fields during bucket listing.
           key_http_fields = set(['bucket', 'etag', 'name', 'updated',
                                  'generation', 'metageneration', 'size'])
 
           # When fields == None, the caller is requesting all possible fields.
           # If the caller requested any fields that are not populated by bucket
           # listing, we'll need to make a separate HTTP call for each object to
           # get its metadata and populate the remaining fields with the result.
@@ skipping 51 matching lines @@
       download_strategy=CloudApi.DownloadStrategy.ONE_SHOT,
       start_byte=0, end_byte=None, progress_callback=None,
       serialization_data=None, digesters=None):
     """See CloudApi class for function doc strings."""
     # This implementation will get the object metadata first if we don't pass it
     # in via serialization_data.
     headers = {}
     self._AddApiVersionToHeaders(headers)
     if 'accept-encoding' not in headers:
       headers['accept-encoding'] = 'gzip'
-    if end_byte:
+    if end_byte is not None:
       headers['range'] = 'bytes=%s-%s' % (start_byte, end_byte)
     elif start_byte > 0:
       headers['range'] = 'bytes=%s-' % (start_byte)
-    else:
+    elif start_byte < 0:
       headers['range'] = 'bytes=%s' % (start_byte)
 
     # Since in most cases we already made a call to get the object metadata,
     # here we avoid an extra HTTP call by unpickling the key.  This is coupled
     # with the implementation in _BotoKeyToObject.
     if serialization_data:
       serialization_dict = json.loads(serialization_data)
       key = pickle.loads(binascii.a2b_base64(serialization_dict['url']))
     else:
       key = self._GetBotoKey(bucket_name, object_name, generation=generation)
@@ skipping 11 matching lines @@
 
     if total_size:
       num_progress_callbacks = max(int(total_size) / TWO_MIB,
                                    XML_PROGRESS_CALLBACKS)
     else:
       num_progress_callbacks = XML_PROGRESS_CALLBACKS
 
     try:
       if download_strategy is CloudApi.DownloadStrategy.RESUMABLE:
         self._PerformResumableDownload(
-            download_stream, key, headers=headers, callback=progress_callback,
+            download_stream, start_byte, end_byte, key,
+            headers=headers, callback=progress_callback,
             num_callbacks=num_progress_callbacks, hash_algs=hash_algs)
       elif download_strategy is CloudApi.DownloadStrategy.ONE_SHOT:
         self._PerformSimpleDownload(
             download_stream, key, progress_callback=progress_callback,
             num_progress_callbacks=num_progress_callbacks, headers=headers,
             hash_algs=hash_algs)
       else:
         raise ArgumentException('Unsupported DownloadStrategy: %s' %
                                 download_strategy)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
@@ skipping 41 matching lines @@
       headers = {}
       self._AddApiVersionToHeaders(headers)
     try:
       key.get_contents_to_file(download_stream, cb=progress_callback,
                                num_cb=num_progress_callbacks, headers=headers,
                                hash_algs=hash_algs)
     except TypeError:  # s3 and mocks do not support hash_algs
       key.get_contents_to_file(download_stream, cb=progress_callback,
                                num_cb=num_progress_callbacks, headers=headers)
 
-  def _PerformResumableDownload(self, fp, key, headers=None, callback=None,
+  def _PerformResumableDownload(self, fp, start_byte, end_byte, key,
+                                headers=None, callback=None,
                                 num_callbacks=XML_PROGRESS_CALLBACKS,
                                 hash_algs=None):
     """Downloads bytes from key to fp, resuming as needed.
 
     Args:
-      fp: File pointer into which data should be downloaded
+      fp: File pointer into which data should be downloaded.
+      start_byte: Start byte of the download.
+      end_byte: End byte of the download.
       key: Key object from which data is to be downloaded
       headers: Headers to send when retrieving the file
       callback: (optional) a callback function that will be called to report
            progress on the download.  The callback should accept two integer
            parameters.  The first integer represents the number of
            bytes that have been successfully transmitted from the service.  The
            second represents the total number of bytes that need to be
            transmitted.
       num_callbacks: (optional) If a callback is specified with the callback
            parameter, this determines the granularity of the callback
            by defining the maximum number of times the callback will be
            called during the file transfer.
       hash_algs: Dict of hash algorithms to apply to downloaded bytes.
 
     Raises:
       ResumableDownloadException on error.
     """
     if not headers:
       headers = {}
       self._AddApiVersionToHeaders(headers)
 
     retryable_exceptions = (httplib.HTTPException, IOError, socket.error,
                             socket.gaierror)
 
     debug = key.bucket.connection.debug
 
     num_retries = GetNumRetries()
     progress_less_iterations = 0
+    last_progress_byte = start_byte
 
     while True:  # Retry as long as we're making progress.
-      had_file_bytes_before_attempt = GetFileSize(fp)
       try:
-        cur_file_size = GetFileSize(fp, position_to_eof=True)
-
-        def DownloadProxyCallback(total_bytes_downloaded, total_size):
-          """Translates a boto callback into a gsutil Cloud API callback.
-
-          Callbacks are originally made by boto.s3.Key.get_file(); here we take
-          into account that we're resuming a download.
-
-          Args:
-            total_bytes_downloaded: Actual bytes downloaded so far, not
-                                    including the point we resumed from.
-            total_size: Total size of the download.
-          """
-          if callback:
-            callback(cur_file_size + total_bytes_downloaded, total_size)
-
+        cb_handler = DownloadProxyCallbackHandler(start_byte, callback)
         headers = headers.copy()
-        headers['Range'] = 'bytes=%d-%d' % (cur_file_size, key.size - 1)
-        cb = DownloadProxyCallback
+        headers['Range'] = 'bytes=%d-%d' % (start_byte, end_byte)
 
         # Disable AWSAuthConnection-level retry behavior, since that would
         # cause downloads to restart from scratch.
         try:
-          key.get_file(fp, headers, cb, num_callbacks, override_num_retries=0,
-                       hash_algs=hash_algs)
+          key.get_file(fp, headers, cb_handler.call, num_callbacks,
+                       override_num_retries=0, hash_algs=hash_algs)
         except TypeError:
-          key.get_file(fp, headers, cb, num_callbacks, override_num_retries=0)
+          key.get_file(fp, headers, cb_handler.call, num_callbacks,
+                       override_num_retries=0)
         fp.flush()
         # Download succeeded.
         return
       except retryable_exceptions, e:
         if debug >= 1:
           self.logger.info('Caught exception (%s)', repr(e))
         if isinstance(e, IOError) and e.errno == errno.EPIPE:
           # Broken pipe error causes httplib to immediately
           # close the socket (http://bugs.python.org/issue5542),
           # so we need to close and reopen the key before resuming
           # the download.
           if self.provider == 's3':
-            key.get_file(fp, headers, cb, num_callbacks, override_num_retries=0)
+            key.get_file(fp, headers, cb_handler.call, num_callbacks,
+                         override_num_retries=0)
           else:  # self.provider == 'gs'
-            key.get_file(fp, headers, cb, num_callbacks,
+            key.get_file(fp, headers, cb_handler.call, num_callbacks,
                          override_num_retries=0, hash_algs=hash_algs)
       except BotoResumableDownloadException, e:
         if (e.disposition ==
             ResumableTransferDisposition.ABORT_CUR_PROCESS):
           raise ResumableDownloadException(e.message)
         else:
           if debug >= 1:
             self.logger.info('Caught ResumableDownloadException (%s) - will '
                              'retry', e.message)
 
       # At this point we had a re-tryable failure; see if made progress.
-      if GetFileSize(fp) > had_file_bytes_before_attempt:
+      start_byte = fp.tell()
+      if start_byte > last_progress_byte:
+        last_progress_byte = start_byte
         progress_less_iterations = 0
       else:
         progress_less_iterations += 1
 
       if progress_less_iterations > num_retries:
         # Don't retry any longer in the current process.
         raise ResumableDownloadException(
             'Too many resumable download attempts failed without '
             'progress. You might try this download again later')
 
@@ skipping 201 matching lines @@
     try:
       self._PerformResumableUpload(dst_uri.new_key(headers=headers),
                                    upload_stream, size, tracker_callback,
                                    canned_acl=canned_acl,
                                    serialization_data=serialization_data,
                                    progress_callback=progress_callback,
                                    headers=headers)
       return self._HandleSuccessfulUpload(dst_uri, object_metadata,
                                           fields=fields)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
+      not_found_exception = CreateNotFoundExceptionForObjectWrite(
+          self.provider, object_metadata.bucket)
       self._TranslateExceptionAndRaise(e, bucket_name=object_metadata.bucket,
-                                       object_name=object_metadata.name)
+                                       object_name=object_metadata.name,
+                                       not_found_exception=not_found_exception)
 
   def UploadObjectStreaming(self, upload_stream, object_metadata,
                             canned_acl=None, progress_callback=None,
                             preconditions=None, provider=None, fields=None):
     """See CloudApi class for function doc strings."""
     headers, dst_uri = self._UploadSetup(object_metadata,
                                          preconditions=preconditions)
 
     try:
       self._PerformStreamingUpload(
           dst_uri, upload_stream, canned_acl=canned_acl,
           progress_callback=progress_callback, headers=headers)
       return self._HandleSuccessfulUpload(dst_uri, object_metadata,
                                           fields=fields)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
+      not_found_exception = CreateNotFoundExceptionForObjectWrite(
+          self.provider, object_metadata.bucket)
       self._TranslateExceptionAndRaise(e, bucket_name=object_metadata.bucket,
-                                       object_name=object_metadata.name)
+                                       object_name=object_metadata.name,
+                                       not_found_exception=not_found_exception)
 
   def UploadObject(self, upload_stream, object_metadata, canned_acl=None,
                    preconditions=None, size=None, progress_callback=None,
                    provider=None, fields=None):
     """See CloudApi class for function doc strings."""
     headers, dst_uri = self._UploadSetup(object_metadata,
                                          preconditions=preconditions)
 
     try:
       md5 = None
       if object_metadata.md5Hash:
         md5 = []
         # boto expects hex at index 0, base64 at index 1
         md5.append(Base64ToHexHash(object_metadata.md5Hash))
         md5.append(object_metadata.md5Hash.strip('\n"\''))
       self._PerformSimpleUpload(dst_uri, upload_stream, md5=md5,
                                 canned_acl=canned_acl,
                                 progress_callback=progress_callback,
                                 headers=headers)
       return self._HandleSuccessfulUpload(dst_uri, object_metadata,
                                           fields=fields)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
+      not_found_exception = CreateNotFoundExceptionForObjectWrite(
+          self.provider, object_metadata.bucket)
       self._TranslateExceptionAndRaise(e, bucket_name=object_metadata.bucket,
-                                       object_name=object_metadata.name)
+                                       object_name=object_metadata.name,
+                                       not_found_exception=not_found_exception)
 
   def DeleteObject(self, bucket_name, object_name, preconditions=None,
                    generation=None, provider=None):
     """See CloudApi class for function doc strings."""
     _ = provider
     headers = {}
     self._AddApiVersionToHeaders(headers)
     self._AddPreconditionsToHeaders(preconditions, headers)
 
     uri = self._StorageUriForObject(bucket_name, object_name,
@@ skipping 38 matching lines @@
         preserve_acl = True
 
     try:
       new_key = dst_uri.copy_key(
           src_obj_metadata.bucket, src_obj_metadata.name,
           preserve_acl=preserve_acl, headers=headers,
           src_version_id=src_version_id, src_generation=src_generation)
 
       return self._BotoKeyToObject(new_key, fields=fields)
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
-      self._TranslateExceptionAndRaise(e, dst_obj_metadata.bucket,
-                                       dst_obj_metadata.name)
+      not_found_exception = CreateNotFoundExceptionForObjectWrite(
+          self.provider, dst_obj_metadata.bucket, src_provider=self.provider,
+          src_bucket_name=src_obj_metadata.bucket,
+          src_object_name=src_obj_metadata.name, src_generation=src_generation)
+      self._TranslateExceptionAndRaise(e, bucket_name=dst_obj_metadata.bucket,
+                                       object_name=dst_obj_metadata.name,
+                                       not_found_exception=not_found_exception)
 
   def ComposeObject(self, src_objs_metadata, dst_obj_metadata,
                     preconditions=None, provider=None, fields=None):
     """See CloudApi class for function doc strings."""
     _ = provider
     ValidateDstObjectMetadata(dst_obj_metadata)
 
     dst_obj_name = dst_obj_metadata.name
     dst_obj_metadata.name = None
     dst_bucket_name = dst_obj_metadata.bucket
@@ skipping 440 matching lines @@
     except boto.exception.GSResponseError, e:
       if e.status == 403:
         # Consume access denied exceptions to mimic JSON behavior of simply
         # returning None if sufficient permission is not present.  The caller
         # needs to handle the case where the ACL is not populated.
         pass
       else:
         raise
 
   def _TranslateExceptionAndRaise(self, e, bucket_name=None, object_name=None,
-                                  generation=None):
+                                  generation=None, not_found_exception=None):
     """Translates a Boto exception and raises the translated or original value.
 
     Args:
       e: Any Exception.
       bucket_name: Optional bucket name in request that caused the exception.
       object_name: Optional object name in request that caused the exception.
       generation: Optional generation in request that caused the exception.
+      not_found_exception: Optional exception to raise in the not-found case.
 
     Raises:
       Translated CloudApi exception, or the original exception if it was not
       translatable.
     """
     translated_exception = self._TranslateBotoException(
         e, bucket_name=bucket_name, object_name=object_name,
-        generation=generation)
+        generation=generation, not_found_exception=not_found_exception)
     if translated_exception:
       raise translated_exception
     else:
       raise
 
   def _TranslateBotoException(self, e, bucket_name=None, object_name=None,
-                              generation=None):
+                              generation=None, not_found_exception=None):
     """Translates boto exceptions into their gsutil Cloud API equivalents.
 
     Args:
       e: Any exception in TRANSLATABLE_BOTO_EXCEPTIONS.
       bucket_name: Optional bucket name in request that caused the exception.
       object_name: Optional object name in request that caused the exception.
       generation: Optional generation in request that caused the exception.
+      not_found_exception: Optional exception to raise in the not-found case.
 
     Returns:
       CloudStorageApiServiceException for translatable exceptions, None
       otherwise.
 
     Because we're using isinstance, check for subtypes first.
     """
     if isinstance(e, boto.exception.StorageResponseError):
       if e.status == 400:
         return BadRequestException(e.code, status=e.status, body=e.body)
       elif e.status == 401 or e.status == 403:
         return AccessDeniedException(e.code, status=e.status, body=e.body)
       elif e.status == 404:
-        if bucket_name:
+        if not_found_exception:
+          # The exception is pre-constructed prior to translation; the HTTP
+          # status code isn't available at that time.
+          setattr(not_found_exception, 'status', e.status)
+          return not_found_exception
+        elif bucket_name:
           if object_name:
             return CreateObjectNotFoundException(e.status, self.provider,
                                                  bucket_name, object_name,
                                                  generation=generation)
           return CreateBucketNotFoundException(e.status, self.provider,
                                                bucket_name)
-        return NotFoundException(e.code, status=e.status, body=e.body)
+        return NotFoundException(e.message, status=e.status, body=e.body)
+
       elif e.status == 409 and e.code and 'BucketNotEmpty' in e.code:
         return NotEmptyException('BucketNotEmpty (%s)' % bucket_name,
                                  status=e.status, body=e.body)
       elif e.status == 410:
         # 410 errors should always cause us to start over - either the UploadID
         # has expired or there was a server-side problem that requires starting
         # the upload over from scratch.
         return ResumableUploadStartOverException(e.message)
       elif e.status == 412:
         return PreconditionException(e.code, status=e.status, body=e.body)
@@ skipping 163 matching lines @@
     try:
       uri = boto.storage_uri(
           storage_url.url_string, suppress_consec_slashes=False,
           bucket_storage_uri_class=self.bucket_storage_uri_class,
           debug=self.debug)
       web_config_xml = UnaryDictToXml(uri.get_website_config())
     except TRANSLATABLE_BOTO_EXCEPTIONS, e:
       self._TranslateExceptionAndRaise(e)
 
     return XmlParseString(web_config_xml).toprettyxml()