gcloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/boto/glacier/exceptions.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2012 Thomas Parslow http://almostobsolete.net/
+#
+# 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.
+#
+from boto.compat import json
+
+
+class UnexpectedHTTPResponseError(Exception):
+    def __init__(self, expected_responses, response):
+        self.status = response.status
+        self.body = response.read()
+        self.code = None
+        try:
+            body = json.loads(self.body)
+            self.code = body["code"]
+            msg = 'Expected %s, got ' % expected_responses
+            msg += '(%d, code=%s, message=%s)' % (response.status,
+                                                  self.code,
+                                                  body["message"])
+        except Exception:
+            msg = 'Expected %s, got (%d, %s)' % (expected_responses,
+                                                 response.status,
+                                                 self.body)
+        super(UnexpectedHTTPResponseError, self).__init__(msg)
+
+
+class ArchiveError(Exception):
+    pass
+
+
+class UploadArchiveError(ArchiveError):
+    pass
+
+
+class DownloadArchiveError(ArchiveError):
+    pass
+
+
+class TreeHashDoesNotMatchError(ArchiveError):
+    pass

data/packages/gsutil/boto/boto/glacier/job.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2012 Thomas Parslow http://almostobsolete.net/
+#
+# 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.
+#
+from __future__ import with_statement
+import math
+import socket
+
+from .exceptions import TreeHashDoesNotMatchError, DownloadArchiveError
+from .utils import tree_hash_from_str
+
+
+class Job(object):
+
+    DefaultPartSize = 4 * 1024 * 1024
+
+    ResponseDataElements = (('Action', 'action', None),
+                            ('ArchiveId', 'archive_id', None),
+                            ('ArchiveSizeInBytes', 'archive_size', 0),
+                            ('Completed', 'completed', False),
+                            ('CompletionDate', 'completion_date', None),
+                            ('CreationDate', 'creation_date', None),
+                            ('InventorySizeInBytes', 'inventory_size', 0),
+                            ('JobDescription', 'description', None),
+                            ('JobId', 'id', None),
+                            ('SHA256TreeHash', 'sha256_treehash', None),
+                            ('SNSTopic', 'sns_topic', None),
+                            ('StatusCode', 'status_code', None),
+                            ('StatusMessage', 'status_message', None),
+                            ('VaultARN', 'arn', None))
+
+    def __init__(self, vault, response_data=None):
+        self.vault = vault
+        if response_data:
+            for response_name, attr_name, default in self.ResponseDataElements:
+                setattr(self, attr_name, response_data[response_name])
+        else:
+            for response_name, attr_name, default in self.ResponseDataElements:
+                setattr(self, attr_name, default)
+
+    def __repr__(self):
+        return 'Job(%s)' % self.arn
+
+    def get_output(self, byte_range=None, validate_checksum=False):
+        """
+        This operation downloads the output of the job.  Depending on
+        the job type you specified when you initiated the job, the
+        output will be either the content of an archive or a vault
+        inventory.
+
+        You can download all the job output or download a portion of
+        the output by specifying a byte range. In the case of an
+        archive retrieval job, depending on the byte range you
+        specify, Amazon Glacier returns the checksum for the portion
+        of the data. You can compute the checksum on the client and
+        verify that the values match to ensure the portion you
+        downloaded is the correct data.
+
+        :type byte_range: tuple
+        :param range: A tuple of integer specifying the slice (in bytes)
+            of the archive you want to receive
+
+        :type validate_checksum: bool
+        :param validate_checksum: Specify whether or not to validate
+            the associate tree hash.  If the response does not contain
+            a TreeHash, then no checksum will be verified.
+
+        """
+        response = self.vault.layer1.get_job_output(self.vault.name,
+                                                    self.id,
+                                                    byte_range)
+        if validate_checksum and 'TreeHash' in response:
+            data = response.read()
+            actual_tree_hash = tree_hash_from_str(data)
+            if response['TreeHash'] != actual_tree_hash:
+                raise TreeHashDoesNotMatchError(
+                    "The calculated tree hash %s does not match the "
+                    "expected tree hash %s for the byte range %s" % (
+                        actual_tree_hash, response['TreeHash'], byte_range))
+        return response
+
+    def download_to_file(self, filename, chunk_size=DefaultPartSize,
+                         verify_hashes=True, retry_exceptions=(socket.error,)):
+        """Download an archive to a file.
+
+        :type filename: str
+        :param filename: The name of the file where the archive
+            contents will be saved.
+
+        :type chunk_size: int
+        :param chunk_size: The chunk size to use when downloading
+            the archive.
+
+        :type verify_hashes: bool
+        :param verify_hashes: Indicates whether or not to verify
+            the tree hashes for each downloaded chunk.
+
+        """
+        num_chunks = int(math.ceil(self.archive_size / float(chunk_size)))
+        with open(filename, 'wb') as output_file:
+            self._download_to_fileob(output_file, num_chunks, chunk_size,
+                                     verify_hashes, retry_exceptions)
+
+    def _download_to_fileob(self, fileobj, num_chunks, chunk_size, verify_hashes,
+                            retry_exceptions):
+        for i in xrange(num_chunks):
+            byte_range = ((i * chunk_size), ((i + 1) * chunk_size) - 1)
+            data, expected_tree_hash = self._download_byte_range(
+                byte_range, retry_exceptions)
+            if verify_hashes:
+                actual_tree_hash = tree_hash_from_str(data)
+                if expected_tree_hash != actual_tree_hash:
+                    raise TreeHashDoesNotMatchError(
+                        "The calculated tree hash %s does not match the "
+                        "expected tree hash %s for the byte range %s" % (
+                            actual_tree_hash, expected_tree_hash, byte_range))
+            fileobj.write(data)
+
+    def _download_byte_range(self, byte_range, retry_exceptions):
+        # You can occasionally get socket.errors when downloading
+        # chunks from Glacier, so each chunk can be retried up
+        # to 5 times.
+        for _ in xrange(5):
+            try:
+                response = self.get_output(byte_range)
+                data = response.read()
+                expected_tree_hash = response['TreeHash']
+                return data, expected_tree_hash
+            except retry_exceptions, e:
+                continue
+        else:
+            raise DownloadArchiveError("There was an error downloading"
+                                       "byte range %s: %s" % (byte_range,
+                                                              e))

data/packages/gsutil/boto/boto/glacier/layer1.py

@@ -0,0 +1,637 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2012 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2012 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 os
+
+import boto.glacier
+from boto.compat import json
+from boto.connection import AWSAuthConnection
+from .exceptions import UnexpectedHTTPResponseError
+from .response import GlacierResponse
+from .utils import ResettingFileSender
+
+
+class Layer1(AWSAuthConnection):
+
+    Version = '2012-06-01'
+    """Glacier API version."""
+
+    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
+                 account_id='-', is_secure=True, port=None,
+                 proxy=None, proxy_port=None,
+                 proxy_user=None, proxy_pass=None, debug=0,
+                 https_connection_factory=None, path='/',
+                 provider='aws', security_token=None,
+                 suppress_consec_slashes=True,
+                 region=None, region_name='us-east-1'):
+
+        if not region:
+            for reg in boto.glacier.regions():
+                if reg.name == region_name:
+                    region = reg
+                    break
+
+        self.region = region
+        self.account_id = account_id
+        AWSAuthConnection.__init__(self, region.endpoint,
+                                   aws_access_key_id, aws_secret_access_key,
+                                   is_secure, port, proxy, proxy_port,
+                                   proxy_user, proxy_pass, debug,
+                                   https_connection_factory,
+                                   path, provider, security_token,
+                                   suppress_consec_slashes)
+
+    def _required_auth_capability(self):
+        return ['hmac-v4']
+
+    def make_request(self, verb, resource, headers=None,
+                     data='', ok_responses=(200,), params=None,
+                     sender=None, response_headers=None):
+        if headers is None:
+            headers = {}
+        headers['x-amz-glacier-version'] = self.Version
+        uri = '/%s/%s' % (self.account_id, resource)
+        response = AWSAuthConnection.make_request(self, verb, uri,
+                                                  params=params,
+                                                  headers=headers,
+                                                  sender=sender,
+                                                  data=data)
+        if response.status in ok_responses:
+            return GlacierResponse(response, response_headers)
+        else:
+            # create glacier-specific exceptions
+            raise UnexpectedHTTPResponseError(ok_responses, response)
+
+    # Vaults
+
+    def list_vaults(self, limit=None, marker=None):
+        """
+        This operation lists all vaults owned by the calling user’s
+        account. The list returned in the response is ASCII-sorted by
+        vault name.
+
+        By default, this operation returns up to 1,000 items. If there
+        are more vaults to list, the marker field in the response body
+        contains the vault Amazon Resource Name (ARN) at which to
+        continue the list with a new List Vaults request; otherwise,
+        the marker field is null. In your next List Vaults request you
+        set the marker parameter to the value Amazon Glacier returned
+        in the responses to your previous List Vaults request. You can
+        also limit the number of vaults returned in the response by
+        specifying the limit parameter in the request.
+
+        :type limit: int
+        :param limit: The maximum number of items returned in the
+            response. If you don't specify a value, the List Vaults
+            operation returns up to 1,000 items.
+
+        :type marker: str
+        :param marker: A string used for pagination. marker specifies
+            the vault ARN after which the listing of vaults should
+            begin. (The vault specified by marker is not included in
+            the returned list.) Get the marker value from a previous
+            List Vaults response. You need to include the marker only
+            if you are continuing the pagination of results started in
+            a previous List Vaults request. Specifying an empty value
+            ("") for the marker returns a list of vaults starting
+            from the first vault.
+        """
+        params = {}
+        if limit:
+            params['limit'] = limit
+        if marker:
+            params['marker'] = marker
+        return self.make_request('GET', 'vaults', params=params)
+
+    def describe_vault(self, vault_name):
+        """
+        This operation returns information about a vault, including
+        the vault Amazon Resource Name (ARN), the date the vault was
+        created, the number of archives contained within the vault,
+        and the total size of all the archives in the vault. The
+        number of archives and their total size are as of the last
+        vault inventory Amazon Glacier generated.  Amazon Glacier
+        generates vault inventories approximately daily. This means
+        that if you add or remove an archive from a vault, and then
+        immediately send a Describe Vault request, the response might
+        not reflect the changes.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+        """
+        uri = 'vaults/%s' % vault_name
+        return self.make_request('GET', uri)
+
+    def create_vault(self, vault_name):
+        """
+        This operation creates a new vault with the specified name.
+        The name of the vault must be unique within a region for an
+        AWS account. You can create up to 1,000 vaults per
+        account. For information on creating more vaults, go to the
+        Amazon Glacier product detail page.
+
+        You must use the following guidelines when naming a vault.
+
+        Names can be between 1 and 255 characters long.
+
+        Allowed characters are a–z, A–Z, 0–9, '_' (underscore),
+        '-' (hyphen), and '.' (period).
+
+        This operation is idempotent, you can send the same request
+        multiple times and it has no further effect after the first
+        time Amazon Glacier creates the specified vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+        """
+        uri = 'vaults/%s' % vault_name
+        return self.make_request('PUT', uri, ok_responses=(201,),
+                                 response_headers=[('Location', 'Location')])
+
+    def delete_vault(self, vault_name):
+        """
+        This operation deletes a vault. Amazon Glacier will delete a
+        vault only if there are no archives in the vault as per the
+        last inventory and there have been no writes to the vault
+        since the last inventory. If either of these conditions is not
+        satisfied, the vault deletion fails (that is, the vault is not
+        removed) and Amazon Glacier returns an error.
+
+        This operation is idempotent, you can send the same request
+        multiple times and it has no further effect after the first
+        time Amazon Glacier delete the specified vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+        """
+        uri = 'vaults/%s' % vault_name
+        return self.make_request('DELETE', uri, ok_responses=(204,))
+
+    def get_vault_notifications(self, vault_name):
+        """
+        This operation retrieves the notification-configuration
+        subresource set on the vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+        """
+        uri = 'vaults/%s/notification-configuration' % vault_name
+        return self.make_request('GET', uri)
+
+    def set_vault_notifications(self, vault_name, notification_config):
+        """
+        This operation retrieves the notification-configuration
+        subresource set on the vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+
+        :type notification_config: dict
+        :param notification_config: A Python dictionary containing
+            an SNS Topic and events for which you want Amazon Glacier
+            to send notifications to the topic.  Possible events are:
+
+            * ArchiveRetrievalCompleted - occurs when a job that was
+              initiated for an archive retrieval is completed.
+            * InventoryRetrievalCompleted - occurs when a job that was
+              initiated for an inventory retrieval is completed.
+
+            The format of the dictionary is:
+
+                {'SNSTopic': 'mytopic',
+                 'Events': [event1,...]}
+        """
+        uri = 'vaults/%s/notification-configuration' % vault_name
+        json_config = json.dumps(notification_config)
+        return self.make_request('PUT', uri, data=json_config,
+                                 ok_responses=(204,))
+
+    def delete_vault_notifications(self, vault_name):
+        """
+        This operation deletes the notification-configuration
+        subresource set on the vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+        """
+        uri = 'vaults/%s/notification-configuration' % vault_name
+        return self.make_request('DELETE', uri, ok_responses=(204,))
+
+    # Jobs
+
+    def list_jobs(self, vault_name, completed=None, status_code=None,
+                  limit=None, marker=None):
+        """
+        This operation lists jobs for a vault including jobs that are
+        in-progress and jobs that have recently finished.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type completed: boolean
+        :param completed: Specifies the state of the jobs to return.
+            If a value of True is passed, only completed jobs will
+            be returned.  If a value of False is passed, only
+            uncompleted jobs will be returned.  If no value is
+            passed, all jobs will be returned.
+
+        :type status_code: string
+        :param status_code: Specifies the type of job status to return.
+            Valid values are: InProgress|Succeeded|Failed.  If not
+            specified, jobs with all status codes are returned.
+
+        :type limit: int
+        :param limit: The maximum number of items returned in the
+            response. If you don't specify a value, the List Jobs
+            operation returns up to 1,000 items.
+
+        :type marker: str
+        :param marker: An opaque string used for pagination. marker
+            specifies the job at which the listing of jobs should
+            begin. Get the marker value from a previous List Jobs
+            response. You need only include the marker if you are
+            continuing the pagination of results started in a previous
+            List Jobs request.
+
+        """
+        params = {}
+        if limit:
+            params['limit'] = limit
+        if marker:
+            params['marker'] = marker
+        if status_code:
+            params['statuscode'] = status_code
+        if completed is not None:
+            params['completed'] = 'true' if completed else 'false'
+        uri = 'vaults/%s/jobs' % vault_name
+        return self.make_request('GET', uri, params=params)
+
+    def describe_job(self, vault_name, job_id):
+        """
+        This operation returns information about a job you previously
+        initiated, including the job initiation date, the user who
+        initiated the job, the job status code/message and the Amazon
+        Simple Notification Service (Amazon SNS) topic to notify after
+        Amazon Glacier completes the job.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+
+        :type job_id: str
+        :param job_id: The ID of the job.
+        """
+        uri = 'vaults/%s/jobs/%s' % (vault_name, job_id)
+        return self.make_request('GET', uri, ok_responses=(200,))
+
+    def initiate_job(self, vault_name, job_data):
+        """
+        This operation initiates a job of the specified
+        type. Retrieving an archive or a vault inventory are
+        asynchronous operations that require you to initiate a job. It
+        is a two-step process:
+
+        * Initiate a retrieval job.
+        * After the job completes, download the bytes.
+
+        The retrieval is executed asynchronously.  When you initiate
+        a retrieval job, Amazon Glacier creates a job and returns a
+        job ID in the response.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+
+        :type job_data: dict
+        :param job_data: A Python dictionary containing the
+            information about the requested job.  The dictionary
+            can contain the following attributes:
+
+            * ArchiveId - The ID of the archive you want to retrieve.
+              This field is required only if the Type is set to
+              archive-retrieval.
+            * Description - The optional description for the job.
+            * Format - When initiating a job to retrieve a vault
+              inventory, you can optionally add this parameter to
+              specify the output format.  Valid values are: CSV|JSON.
+            * SNSTopic - The Amazon SNS topic ARN where Amazon Glacier
+              sends a notification when the job is completed and the
+              output is ready for you to download.
+            * Type - The job type.  Valid values are:
+              archive-retrieval|inventory-retrieval
+            * RetrievalByteRange - Optionally specify the range of
+              bytes to retrieve.
+
+        """
+        uri = 'vaults/%s/jobs' % vault_name
+        response_headers = [('x-amz-job-id', u'JobId'),
+                            ('Location', u'Location')]
+        json_job_data = json.dumps(job_data)
+        return self.make_request('POST', uri, data=json_job_data,
+                                 ok_responses=(202,),
+                                 response_headers=response_headers)
+
+    def get_job_output(self, vault_name, job_id, byte_range=None):
+        """
+        This operation downloads the output of the job you initiated
+        using Initiate a Job. Depending on the job type
+        you specified when you initiated the job, the output will be
+        either the content of an archive or a vault inventory.
+
+        You can download all the job output or download a portion of
+        the output by specifying a byte range. In the case of an
+        archive retrieval job, depending on the byte range you
+        specify, Amazon Glacier returns the checksum for the portion
+        of the data. You can compute the checksum on the client and
+        verify that the values match to ensure the portion you
+        downloaded is the correct data.
+
+        :type vault_name: str :param
+        :param vault_name: The name of the new vault
+
+        :type job_id: str
+        :param job_id: The ID of the job.
+
+        :type byte_range: tuple
+        :param range: A tuple of integers specifying the slice (in bytes)
+            of the archive you want to receive
+        """
+        response_headers = [('x-amz-sha256-tree-hash', u'TreeHash'),
+                            ('Content-Range', u'ContentRange'),
+                            ('Content-Type', u'ContentType')]
+        headers = None
+        if byte_range:
+            headers = {'Range': 'bytes=%d-%d' % byte_range}
+        uri = 'vaults/%s/jobs/%s/output' % (vault_name, job_id)
+        response = self.make_request('GET', uri, headers=headers,
+                                     ok_responses=(200, 206),
+                                     response_headers=response_headers)
+        return response
+
+    # Archives
+
+    def upload_archive(self, vault_name, archive,
+                       linear_hash, tree_hash, description=None):
+        """
+        This operation adds an archive to a vault. For a successful
+        upload, your data is durably persisted. In response, Amazon
+        Glacier returns the archive ID in the x-amz-archive-id header
+        of the response. You should save the archive ID returned so
+        that you can access the archive later.
+
+        :type vault_name: str :param
+        :param vault_name: The name of the vault
+
+        :type archive: bytes
+        :param archive: The data to upload.
+
+        :type linear_hash: str
+        :param linear_hash: The SHA256 checksum (a linear hash) of the
+            payload.
+
+        :type tree_hash: str
+        :param tree_hash: The user-computed SHA256 tree hash of the
+            payload.  For more information on computing the
+            tree hash, see http://goo.gl/u7chF.
+
+        :type description: str
+        :param description: An optional description of the archive.
+        """
+        response_headers = [('x-amz-archive-id', u'ArchiveId'),
+                            ('Location', u'Location'),
+                            ('x-amz-sha256-tree-hash', u'TreeHash')]
+        uri = 'vaults/%s/archives' % vault_name
+        try:
+            content_length = str(len(archive))
+        except (TypeError, AttributeError):
+            # If a file like object is provided, try to retrieve
+            # the file size via fstat.
+            content_length = str(os.fstat(archive.fileno()).st_size)
+        headers = {'x-amz-content-sha256': linear_hash,
+                   'x-amz-sha256-tree-hash': tree_hash,
+                   'Content-Length': content_length}
+        if description:
+            headers['x-amz-archive-description'] = description
+        if self._is_file_like(archive):
+            sender = ResettingFileSender(archive)
+        else:
+            sender = None
+        return self.make_request('POST', uri, headers=headers,
+                                sender=sender,
+                                data=archive, ok_responses=(201,),
+                                response_headers=response_headers)
+
+    def _is_file_like(self, archive):
+        return hasattr(archive, 'seek') and hasattr(archive, 'tell')
+
+    def delete_archive(self, vault_name, archive_id):
+        """
+        This operation deletes an archive from a vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the new vault
+
+        :type archive_id: str
+        :param archive_id: The ID for the archive to be deleted.
+        """
+        uri = 'vaults/%s/archives/%s' % (vault_name, archive_id)
+        return self.make_request('DELETE', uri, ok_responses=(204,))
+
+    # Multipart
+
+    def initiate_multipart_upload(self, vault_name, part_size,
+                                  description=None):
+        """
+        Initiate a multipart upload.  Amazon Glacier creates a
+        multipart upload resource and returns it's ID.  You use this
+        ID in subsequent multipart upload operations.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type description: str
+        :param description: An optional description of the archive.
+
+        :type part_size: int
+        :param part_size: The size of each part except the last, in bytes.
+            The part size must be a multiple of 1024 KB multiplied by
+            a power of 2.  The minimum allowable part size is 1MB and the
+            maximum is 4GB.
+        """
+        response_headers = [('x-amz-multipart-upload-id', u'UploadId'),
+                            ('Location', u'Location')]
+        headers = {'x-amz-part-size': str(part_size)}
+        if description:
+            headers['x-amz-archive-description'] = description
+        uri = 'vaults/%s/multipart-uploads' % vault_name
+        response = self.make_request('POST', uri, headers=headers,
+                                     ok_responses=(201,),
+                                     response_headers=response_headers)
+        return response
+
+    def complete_multipart_upload(self, vault_name, upload_id,
+                                  sha256_treehash, archive_size):
+        """
+        Call this to inform Amazon Glacier that all of the archive parts
+        have been uploaded and Amazon Glacier can now assemble the archive
+        from the uploaded parts.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type upload_id: str
+        :param upload_id: The unique ID associated with this upload
+            operation.
+
+        :type sha256_treehash: str
+        :param sha256_treehash: The SHA256 tree hash of the entire
+            archive. It is the tree hash of SHA256 tree hash of the
+            individual parts. If the value you specify in the request
+            does not match the SHA256 tree hash of the final assembled
+            archive as computed by Amazon Glacier, Amazon Glacier
+            returns an error and the request fails.
+
+        :type archive_size: int
+        :param archive_size: The total size, in bytes, of the entire
+            archive. This value should be the sum of all the sizes of
+            the individual parts that you uploaded.
+        """
+        response_headers = [('x-amz-archive-id', u'ArchiveId'),
+                            ('Location', u'Location')]
+        headers = {'x-amz-sha256-tree-hash': sha256_treehash,
+                   'x-amz-archive-size': str(archive_size)}
+        uri = 'vaults/%s/multipart-uploads/%s' % (vault_name, upload_id)
+        response = self.make_request('POST', uri, headers=headers,
+                                     ok_responses=(201,),
+                                     response_headers=response_headers)
+        return response
+
+    def abort_multipart_upload(self, vault_name, upload_id):
+        """
+        Call this to abort a multipart upload identified by the upload ID.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type upload_id: str
+        :param upload_id: The unique ID associated with this upload
+            operation.
+        """
+        uri = 'vaults/%s/multipart-uploads/%s' % (vault_name, upload_id)
+        return self.make_request('DELETE', uri, ok_responses=(204,))
+
+    def list_multipart_uploads(self, vault_name, limit=None, marker=None):
+        """
+        Lists in-progress multipart uploads for the specified vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type limit: int
+        :param limit: The maximum number of items returned in the
+            response. If you don't specify a value, the operation
+            returns up to 1,000 items.
+
+        :type marker: str
+        :param marker: An opaque string used for pagination. marker
+            specifies the item at which the listing should
+            begin. Get the marker value from a previous
+            response. You need only include the marker if you are
+            continuing the pagination of results started in a previous
+            request.
+        """
+        params = {}
+        if limit:
+            params['limit'] = limit
+        if marker:
+            params['marker'] = marker
+        uri = 'vaults/%s/multipart-uploads' % vault_name
+        return self.make_request('GET', uri, params=params)
+
+    def list_parts(self, vault_name, upload_id, limit=None, marker=None):
+        """
+        Lists in-progress multipart uploads for the specified vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type upload_id: str
+        :param upload_id: The unique ID associated with this upload
+            operation.
+
+        :type limit: int
+        :param limit: The maximum number of items returned in the
+            response. If you don't specify a value, the operation
+            returns up to 1,000 items.
+
+        :type marker: str
+        :param marker: An opaque string used for pagination. marker
+            specifies the item at which the listing should
+            begin. Get the marker value from a previous
+            response. You need only include the marker if you are
+            continuing the pagination of results started in a previous
+            request.
+        """
+        params = {}
+        if limit:
+            params['limit'] = limit
+        if marker:
+            params['marker'] = marker
+        uri = 'vaults/%s/multipart-uploads/%s' % (vault_name, upload_id)
+        return self.make_request('GET', uri, params=params)
+
+    def upload_part(self, vault_name, upload_id, linear_hash,
+                    tree_hash, byte_range, part_data):
+        """
+        Lists in-progress multipart uploads for the specified vault.
+
+        :type vault_name: str
+        :param vault_name: The name of the vault.
+
+        :type linear_hash: str
+        :param linear_hash: The SHA256 checksum (a linear hash) of the
+            payload.
+
+        :type tree_hash: str
+        :param tree_hash: The user-computed SHA256 tree hash of the
+            payload.  For more information on computing the
+            tree hash, see http://goo.gl/u7chF.
+
+        :type upload_id: str
+        :param upload_id: The unique ID associated with this upload
+            operation.
+
+        :type byte_range: tuple of ints
+        :param byte_range: Identfies the range of bytes in the assembled
+            archive that will be uploaded in this part.
+
+        :type part_data: bytes
+        :param part_data: The data to be uploaded for the part
+        """
+        headers = {'x-amz-content-sha256': linear_hash,
+                   'x-amz-sha256-tree-hash': tree_hash,
+                   'Content-Range': 'bytes %d-%d/*' % byte_range}
+        response_headers = [('x-amz-sha256-tree-hash', u'TreeHash')]
+        uri = 'vaults/%s/multipart-uploads/%s' % (vault_name, upload_id)
+        return self.make_request('PUT', uri, headers=headers,
+                                 data=part_data, ok_responses=(204,),
+                                 response_headers=response_headers)