[catapult] - Copy Telemetry's gsutilz over to third_party.

third_party/gsutil/third_party/boto/boto/support/layer1.py

Index: third_party/gsutil/third_party/boto/boto/support/layer1.py
diff --git a/third_party/gsutil/third_party/boto/boto/support/layer1.py b/third_party/gsutil/third_party/boto/boto/support/layer1.py
new file mode 100644
index 0000000000000000000000000000000000000000..33e83cc472d74c1cdbe251157a58d64922c388d2
--- /dev/null
+++ b/third_party/gsutil/third_party/boto/boto/support/layer1.py
@@ -0,0 +1,674 @@
+# Copyright (c) 2014 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# 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 boto
+from boto.compat import json
+from boto.connection import AWSQueryConnection
+from boto.regioninfo import RegionInfo
+from boto.exception import JSONResponseError
+from boto.support import exceptions
+
+
+class SupportConnection(AWSQueryConnection):
+    """
+    AWS Support
+    The AWS Support API reference is intended for programmers who need
+    detailed information about the AWS Support operations and data
+    types. This service enables you to manage your AWS Support cases
+    programmatically. It uses HTTP methods that return results in JSON
+    format.
+
+    The AWS Support service also exposes a set of `Trusted Advisor`_
+    features. You can retrieve a list of checks and their
+    descriptions, get check results, specify checks to refresh, and
+    get the refresh status of checks.
+
+    The following list describes the AWS Support case management
+    operations:
+
+
+    + **Service names, issue categories, and available severity
+      levels. **The DescribeServices and DescribeSeverityLevels
+      operations return AWS service names, service codes, service
+      categories, and problem severity levels. You use these values when
+      you call the CreateCase operation.
+    + **Case creation, case details, and case resolution.** The
+      CreateCase, DescribeCases, DescribeAttachment, and ResolveCase
+      operations create AWS Support cases, retrieve information about
+      cases, and resolve cases.
+    + **Case communication.** The DescribeCommunications,
+      AddCommunicationToCase, and AddAttachmentsToSet operations
+      retrieve and add communications and attachments to AWS Support
+      cases.
+
+
+    The following list describes the operations available from the AWS
+    Support service for Trusted Advisor:
+
+
+    + DescribeTrustedAdvisorChecks returns the list of checks that run
+      against your AWS resources.
+    + Using the `CheckId` for a specific check returned by
+      DescribeTrustedAdvisorChecks, you can call
+      DescribeTrustedAdvisorCheckResult to obtain the results for the
+      check you specified.
+    + DescribeTrustedAdvisorCheckSummaries returns summarized results
+      for one or more Trusted Advisor checks.
+    + RefreshTrustedAdvisorCheck requests that Trusted Advisor rerun a
+      specified check.
+    + DescribeTrustedAdvisorCheckRefreshStatuses reports the refresh
+      status of one or more checks.
+
+
+    For authentication of requests, AWS Support uses `Signature
+    Version 4 Signing Process`_.
+
+    See `About the AWS Support API`_ in the AWS Support User Guide for
+    information about how to use this service to create and manage
+    your support cases, and how to call Trusted Advisor for results of
+    checks on your resources.
+    """
+    APIVersion = "2013-04-15"
+    DefaultRegionName = "us-east-1"
+    DefaultRegionEndpoint = "support.us-east-1.amazonaws.com"
+    ServiceName = "Support"
+    TargetPrefix = "AWSSupport_20130415"
+    ResponseError = JSONResponseError
+
+    _faults = {
+        "CaseCreationLimitExceeded": exceptions.CaseCreationLimitExceeded,
+        "AttachmentLimitExceeded": exceptions.AttachmentLimitExceeded,
+        "CaseIdNotFound": exceptions.CaseIdNotFound,
+        "DescribeAttachmentLimitExceeded": exceptions.DescribeAttachmentLimitExceeded,
+        "AttachmentSetIdNotFound": exceptions.AttachmentSetIdNotFound,
+        "InternalServerError": exceptions.InternalServerError,
+        "AttachmentSetExpired": exceptions.AttachmentSetExpired,
+        "AttachmentIdNotFound": exceptions.AttachmentIdNotFound,
+        "AttachmentSetSizeLimitExceeded": exceptions.AttachmentSetSizeLimitExceeded,
+    }
+
+
+    def __init__(self, **kwargs):
+        region = kwargs.pop('region', None)
+        if not region:
+            region = RegionInfo(self, self.DefaultRegionName,
+                                self.DefaultRegionEndpoint)
+
+        if 'host' not in kwargs or kwargs['host'] is None:
+            kwargs['host'] = region.endpoint
+
+        super(SupportConnection, self).__init__(**kwargs)
+        self.region = region
+
+    def _required_auth_capability(self):
+        return ['hmac-v4']
+
+    def add_attachments_to_set(self, attachments, attachment_set_id=None):
+        """
+        Adds one or more attachments to an attachment set. If an
+        `AttachmentSetId` is not specified, a new attachment set is
+        created, and the ID of the set is returned in the response. If
+        an `AttachmentSetId` is specified, the attachments are added
+        to the specified set, if it exists.
+
+        An attachment set is a temporary container for attachments
+        that are to be added to a case or case communication. The set
+        is available for one hour after it is created; the
+        `ExpiryTime` returned in the response indicates when the set
+        expires. The maximum number of attachments in a set is 3, and
+        the maximum size of any attachment in the set is 5 MB.
+
+        :type attachment_set_id: string
+        :param attachment_set_id: The ID of the attachment set. If an
+            `AttachmentSetId` is not specified, a new attachment set is
+            created, and the ID of the set is returned in the response. If an
+            `AttachmentSetId` is specified, the attachments are added to the
+            specified set, if it exists.
+
+        :type attachments: list
+        :param attachments: One or more attachments to add to the set. The
+            limit is 3 attachments per set, and the size limit is 5 MB per
+            attachment.
+
+        """
+        params = {'attachments': attachments, }
+        if attachment_set_id is not None:
+            params['attachmentSetId'] = attachment_set_id
+        return self.make_request(action='AddAttachmentsToSet',
+                                 body=json.dumps(params))
+
+    def add_communication_to_case(self, communication_body, case_id=None,
+                                  cc_email_addresses=None,
+                                  attachment_set_id=None):
+        """
+        Adds additional customer communication to an AWS Support case.
+        You use the `CaseId` value to identify the case to add
+        communication to. You can list a set of email addresses to
+        copy on the communication using the `CcEmailAddresses` value.
+        The `CommunicationBody` value contains the text of the
+        communication.
+
+        The response indicates the success or failure of the request.
+
+        This operation implements a subset of the behavior on the AWS
+        Support `Your Support Cases`_ web form.
+
+        :type case_id: string
+        :param case_id: The AWS Support case ID requested or returned in the
+            call. The case ID is an alphanumeric string formatted as shown in
+            this example: case- 12345678910-2013-c4c1d2bf33c5cf47
+
+        :type communication_body: string
+        :param communication_body: The body of an email communication to add to
+            the support case.
+
+        :type cc_email_addresses: list
+        :param cc_email_addresses: The email addresses in the CC line of an
+            email to be added to the support case.
+
+        :type attachment_set_id: string
+        :param attachment_set_id: The ID of a set of one or more attachments
+            for the communication to add to the case. Create the set by calling
+            AddAttachmentsToSet
+
+        """
+        params = {'communicationBody': communication_body, }
+        if case_id is not None:
+            params['caseId'] = case_id
+        if cc_email_addresses is not None:
+            params['ccEmailAddresses'] = cc_email_addresses
+        if attachment_set_id is not None:
+            params['attachmentSetId'] = attachment_set_id
+        return self.make_request(action='AddCommunicationToCase',
+                                 body=json.dumps(params))
+
+    def create_case(self, subject, communication_body, service_code=None,
+                    severity_code=None, category_code=None,
+                    cc_email_addresses=None, language=None, issue_type=None,
+                    attachment_set_id=None):
+        """
+        Creates a new case in the AWS Support Center. This operation
+        is modeled on the behavior of the AWS Support Center `Open a
+        new case`_ page. Its parameters require you to specify the
+        following information:
+
+
+        #. **IssueType.** The type of issue for the case. You can
+           specify either "customer-service" or "technical." If you do
+           not indicate a value, the default is "technical."
+        #. **ServiceCode.** The code for an AWS service. You obtain
+           the `ServiceCode` by calling DescribeServices.
+        #. **CategoryCode.** The category for the service defined for
+           the `ServiceCode` value. You also obtain the category code for
+           a service by calling DescribeServices. Each AWS service
+           defines its own set of category codes.
+        #. **SeverityCode.** A value that indicates the urgency of the
+           case, which in turn determines the response time according to
+           your service level agreement with AWS Support. You obtain the
+           SeverityCode by calling DescribeSeverityLevels.
+        #. **Subject.** The **Subject** field on the AWS Support
+           Center `Open a new case`_ page.
+        #. **CommunicationBody.** The **Description** field on the AWS
+           Support Center `Open a new case`_ page.
+        #. **AttachmentSetId.** The ID of a set of attachments that
+           has been created by using AddAttachmentsToSet.
+        #. **Language.** The human language in which AWS Support
+           handles the case. English and Japanese are currently
+           supported.
+        #. **CcEmailAddresses.** The AWS Support Center **CC** field
+           on the `Open a new case`_ page. You can list email addresses
+           to be copied on any correspondence about the case. The account
+           that opens the case is already identified by passing the AWS
+           Credentials in the HTTP POST method or in a method or function
+           call from one of the programming languages supported by an
+           `AWS SDK`_.
+
+
+        A successful CreateCase request returns an AWS Support case
+        number. Case numbers are used by the DescribeCases operation
+        to retrieve existing AWS Support cases.
+
+        :type subject: string
+        :param subject: The title of the AWS Support case.
+
+        :type service_code: string
+        :param service_code: The code for the AWS service returned by the call
+            to DescribeServices.
+
+        :type severity_code: string
+        :param severity_code: The code for the severity level returned by the
+            call to DescribeSeverityLevels.
+
+        :type category_code: string
+        :param category_code: The category of problem for the AWS Support case.
+
+        :type communication_body: string
+        :param communication_body: The communication body text when you create
+            an AWS Support case by calling CreateCase.
+
+        :type cc_email_addresses: list
+        :param cc_email_addresses: A list of email addresses that AWS Support
+            copies on case correspondence.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        :type issue_type: string
+        :param issue_type: The type of issue for the case. You can specify
+            either "customer-service" or "technical." If you do not indicate a
+            value, the default is "technical."
+
+        :type attachment_set_id: string
+        :param attachment_set_id: The ID of a set of one or more attachments
+            for the case. Create the set by using AddAttachmentsToSet.
+
+        """
+        params = {
+            'subject': subject,
+            'communicationBody': communication_body,
+        }
+        if service_code is not None:
+            params['serviceCode'] = service_code
+        if severity_code is not None:
+            params['severityCode'] = severity_code
+        if category_code is not None:
+            params['categoryCode'] = category_code
+        if cc_email_addresses is not None:
+            params['ccEmailAddresses'] = cc_email_addresses
+        if language is not None:
+            params['language'] = language
+        if issue_type is not None:
+            params['issueType'] = issue_type
+        if attachment_set_id is not None:
+            params['attachmentSetId'] = attachment_set_id
+        return self.make_request(action='CreateCase',
+                                 body=json.dumps(params))
+
+    def describe_attachment(self, attachment_id):
+        """
+        Returns the attachment that has the specified ID. Attachment
+        IDs are generated by the case management system when you add
+        an attachment to a case or case communication. Attachment IDs
+        are returned in the AttachmentDetails objects that are
+        returned by the DescribeCommunications operation.
+
+        :type attachment_id: string
+        :param attachment_id: The ID of the attachment to return. Attachment
+            IDs are returned by the DescribeCommunications operation.
+
+        """
+        params = {'attachmentId': attachment_id, }
+        return self.make_request(action='DescribeAttachment',
+                                 body=json.dumps(params))
+
+    def describe_cases(self, case_id_list=None, display_id=None,
+                       after_time=None, before_time=None,
+                       include_resolved_cases=None, next_token=None,
+                       max_results=None, language=None,
+                       include_communications=None):
+        """
+        Returns a list of cases that you specify by passing one or
+        more case IDs. In addition, you can filter the cases by date
+        by setting values for the `AfterTime` and `BeforeTime` request
+        parameters.
+
+        Case data is available for 12 months after creation. If a case
+        was created more than 12 months ago, a request for data might
+        cause an error.
+
+        The response returns the following in JSON format:
+
+
+        #. One or more CaseDetails data types.
+        #. One or more `NextToken` values, which specify where to
+           paginate the returned records represented by the `CaseDetails`
+           objects.
+
+        :type case_id_list: list
+        :param case_id_list: A list of ID numbers of the support cases you want
+            returned. The maximum number of cases is 100.
+
+        :type display_id: string
+        :param display_id: The ID displayed for a case in the AWS Support
+            Center user interface.
+
+        :type after_time: string
+        :param after_time: The start date for a filtered date search on support
+            case communications. Case communications are available for 12
+            months after creation.
+
+        :type before_time: string
+        :param before_time: The end date for a filtered date search on support
+            case communications. Case communications are available for 12
+            months after creation.
+
+        :type include_resolved_cases: boolean
+        :param include_resolved_cases: Specifies whether resolved support cases
+            should be included in the DescribeCases results. The default is
+            false .
+
+        :type next_token: string
+        :param next_token: A resumption point for pagination.
+
+        :type max_results: integer
+        :param max_results: The maximum number of results to return before
+            paginating.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        :type include_communications: boolean
+        :param include_communications: Specifies whether communications should
+            be included in the DescribeCases results. The default is true .
+
+        """
+        params = {}
+        if case_id_list is not None:
+            params['caseIdList'] = case_id_list
+        if display_id is not None:
+            params['displayId'] = display_id
+        if after_time is not None:
+            params['afterTime'] = after_time
+        if before_time is not None:
+            params['beforeTime'] = before_time
+        if include_resolved_cases is not None:
+            params['includeResolvedCases'] = include_resolved_cases
+        if next_token is not None:
+            params['nextToken'] = next_token
+        if max_results is not None:
+            params['maxResults'] = max_results
+        if language is not None:
+            params['language'] = language
+        if include_communications is not None:
+            params['includeCommunications'] = include_communications
+        return self.make_request(action='DescribeCases',
+                                 body=json.dumps(params))
+
+    def describe_communications(self, case_id, before_time=None,
+                                after_time=None, next_token=None,
+                                max_results=None):
+        """
+        Returns communications (and attachments) for one or more
+        support cases. You can use the `AfterTime` and `BeforeTime`
+        parameters to filter by date. You can use the `CaseId`
+        parameter to restrict the results to a particular case.
+
+        Case data is available for 12 months after creation. If a case
+        was created more than 12 months ago, a request for data might
+        cause an error.
+
+        You can use the `MaxResults` and `NextToken` parameters to
+        control the pagination of the result set. Set `MaxResults` to
+        the number of cases you want displayed on each page, and use
+        `NextToken` to specify the resumption of pagination.
+
+        :type case_id: string
+        :param case_id: The AWS Support case ID requested or returned in the
+            call. The case ID is an alphanumeric string formatted as shown in
+            this example: case- 12345678910-2013-c4c1d2bf33c5cf47
+
+        :type before_time: string
+        :param before_time: The end date for a filtered date search on support
+            case communications. Case communications are available for 12
+            months after creation.
+
+        :type after_time: string
+        :param after_time: The start date for a filtered date search on support
+            case communications. Case communications are available for 12
+            months after creation.
+
+        :type next_token: string
+        :param next_token: A resumption point for pagination.
+
+        :type max_results: integer
+        :param max_results: The maximum number of results to return before
+            paginating.
+
+        """
+        params = {'caseId': case_id, }
+        if before_time is not None:
+            params['beforeTime'] = before_time
+        if after_time is not None:
+            params['afterTime'] = after_time
+        if next_token is not None:
+            params['nextToken'] = next_token
+        if max_results is not None:
+            params['maxResults'] = max_results
+        return self.make_request(action='DescribeCommunications',
+                                 body=json.dumps(params))
+
+    def describe_services(self, service_code_list=None, language=None):
+        """
+        Returns the current list of AWS services and a list of service
+        categories that applies to each one. You then use service
+        names and categories in your CreateCase requests. Each AWS
+        service has its own set of categories.
+
+        The service codes and category codes correspond to the values
+        that are displayed in the **Service** and **Category** drop-
+        down lists on the AWS Support Center `Open a new case`_ page.
+        The values in those fields, however, do not necessarily match
+        the service codes and categories returned by the
+        `DescribeServices` request. Always use the service codes and
+        categories obtained programmatically. This practice ensures
+        that you always have the most recent set of service and
+        category codes.
+
+        :type service_code_list: list
+        :param service_code_list: A JSON-formatted list of service codes
+            available for AWS services.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        """
+        params = {}
+        if service_code_list is not None:
+            params['serviceCodeList'] = service_code_list
+        if language is not None:
+            params['language'] = language
+        return self.make_request(action='DescribeServices',
+                                 body=json.dumps(params))
+
+    def describe_severity_levels(self, language=None):
+        """
+        Returns the list of severity levels that you can assign to an
+        AWS Support case. The severity level for a case is also a
+        field in the CaseDetails data type included in any CreateCase
+        request.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        """
+        params = {}
+        if language is not None:
+            params['language'] = language
+        return self.make_request(action='DescribeSeverityLevels',
+                                 body=json.dumps(params))
+
+    def describe_trusted_advisor_check_refresh_statuses(self, check_ids):
+        """
+        Returns the refresh status of the Trusted Advisor checks that
+        have the specified check IDs. Check IDs can be obtained by
+        calling DescribeTrustedAdvisorChecks.
+
+        :type check_ids: list
+        :param check_ids: The IDs of the Trusted Advisor checks.
+
+        """
+        params = {'checkIds': check_ids, }
+        return self.make_request(action='DescribeTrustedAdvisorCheckRefreshStatuses',
+                                 body=json.dumps(params))
+
+    def describe_trusted_advisor_check_result(self, check_id, language=None):
+        """
+        Returns the results of the Trusted Advisor check that has the
+        specified check ID. Check IDs can be obtained by calling
+        DescribeTrustedAdvisorChecks.
+
+        The response contains a TrustedAdvisorCheckResult object,
+        which contains these three objects:
+
+
+        + TrustedAdvisorCategorySpecificSummary
+        + TrustedAdvisorResourceDetail
+        + TrustedAdvisorResourcesSummary
+
+
+        In addition, the response contains these fields:
+
+
+        + **Status.** The alert status of the check: "ok" (green),
+          "warning" (yellow), "error" (red), or "not_available".
+        + **Timestamp.** The time of the last refresh of the check.
+        + **CheckId.** The unique identifier for the check.
+
+        :type check_id: string
+        :param check_id: The unique identifier for the Trusted Advisor check.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        """
+        params = {'checkId': check_id, }
+        if language is not None:
+            params['language'] = language
+        return self.make_request(action='DescribeTrustedAdvisorCheckResult',
+                                 body=json.dumps(params))
+
+    def describe_trusted_advisor_check_summaries(self, check_ids):
+        """
+        Returns the summaries of the results of the Trusted Advisor
+        checks that have the specified check IDs. Check IDs can be
+        obtained by calling DescribeTrustedAdvisorChecks.
+
+        The response contains an array of TrustedAdvisorCheckSummary
+        objects.
+
+        :type check_ids: list
+        :param check_ids: The IDs of the Trusted Advisor checks.
+
+        """
+        params = {'checkIds': check_ids, }
+        return self.make_request(action='DescribeTrustedAdvisorCheckSummaries',
+                                 body=json.dumps(params))
+
+    def describe_trusted_advisor_checks(self, language):
+        """
+        Returns information about all available Trusted Advisor
+        checks, including name, ID, category, description, and
+        metadata. You must specify a language code; English ("en") and
+        Japanese ("ja") are currently supported. The response contains
+        a TrustedAdvisorCheckDescription for each check.
+
+        :type language: string
+        :param language: The ISO 639-1 code for the language in which AWS
+            provides support. AWS Support currently supports English ("en") and
+            Japanese ("ja"). Language parameters must be passed explicitly for
+            operations that take them.
+
+        """
+        params = {'language': language, }
+        return self.make_request(action='DescribeTrustedAdvisorChecks',
+                                 body=json.dumps(params))
+
+    def refresh_trusted_advisor_check(self, check_id):
+        """
+        Requests a refresh of the Trusted Advisor check that has the
+        specified check ID. Check IDs can be obtained by calling
+        DescribeTrustedAdvisorChecks.
+
+        The response contains a RefreshTrustedAdvisorCheckResult
+        object, which contains these fields:
+
+
+        + **Status.** The refresh status of the check: "none",
+          "enqueued", "processing", "success", or "abandoned".
+        + **MillisUntilNextRefreshable.** The amount of time, in
+          milliseconds, until the check is eligible for refresh.
+        + **CheckId.** The unique identifier for the check.
+
+        :type check_id: string
+        :param check_id: The unique identifier for the Trusted Advisor check.
+
+        """
+        params = {'checkId': check_id, }
+        return self.make_request(action='RefreshTrustedAdvisorCheck',
+                                 body=json.dumps(params))
+
+    def resolve_case(self, case_id=None):
+        """
+        Takes a `CaseId` and returns the initial state of the case
+        along with the state of the case after the call to ResolveCase
+        completed.
+
+        :type case_id: string
+        :param case_id: The AWS Support case ID requested or returned in the
+            call. The case ID is an alphanumeric string formatted as shown in
+            this example: case- 12345678910-2013-c4c1d2bf33c5cf47
+
+        """
+        params = {}
+        if case_id is not None:
+            params['caseId'] = case_id
+        return self.make_request(action='ResolveCase',
+                                 body=json.dumps(params))
+
+    def make_request(self, action, body):
+        headers = {
+            'X-Amz-Target': '%s.%s' % (self.TargetPrefix, action),
+            'Host': self.region.endpoint,
+            'Content-Type': 'application/x-amz-json-1.1',
+            'Content-Length': str(len(body)),
+        }
+        http_request = self.build_base_http_request(
+            method='POST', path='/', auth_path='/', params={},
+            headers=headers, data=body)
+        response = self._mexe(http_request, sender=None,
+                              override_num_retries=10)
+        response_body = response.read().decode('utf-8')
+        boto.log.debug(response_body)
+        if response.status == 200:
+            if response_body:
+                return json.loads(response_body)
+        else:
+            json_body = json.loads(response_body)
+            fault_name = json_body.get('__type', None)
+            exception_class = self._faults.get(fault_name, self.ResponseError)
+            raise exception_class(response.status, response.reason,
+                                  body=json_body)