gcloud 0.0.7 → 0.1.0

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

@@ -1,93 +0,0 @@
-# -*- 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 .layer1 import Layer1
-from .vault import Vault
-
-
-class Layer2(object):
-    """
-    Provides a more pythonic and friendly interface to Glacier based on Layer1
-    """
-
-    def __init__(self, *args, **kwargs):
-        # Accept a passed in layer1, mainly to allow easier testing
-        if "layer1" in kwargs:
-            self.layer1 = kwargs["layer1"]
-        else:
-            self.layer1 = Layer1(*args, **kwargs)
-
-    def create_vault(self, name):
-        """Creates a vault.
-
-        :type name: str
-        :param name: The name of the vault
-
-        :rtype: :class:`boto.glacier.vault.Vault`
-        :return: A Vault object representing the vault.
-        """
-        self.layer1.create_vault(name)
-        return self.get_vault(name)
-
-    def delete_vault(self, name):
-        """Delete a vault.
-
-        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 vault to delete.
-        """
-        return self.layer1.delete_vault(name)
-
-    def get_vault(self, name):
-        """
-        Get an object representing a named vault from Glacier. This
-        operation does not check if the vault actually exists.
-
-        :type name: str
-        :param name: The name of the vault
-
-        :rtype: :class:`boto.glacier.vault.Vault`
-        :return: A Vault object representing the vault.
-        """
-        response_data = self.layer1.describe_vault(name)
-        return Vault(self.layer1, response_data)
-
-    def list_vaults(self):
-        """
-        Return a list of all vaults associated with the account ID.
-
-        :rtype: List of :class:`boto.glacier.vault.Vault`
-        :return: A list of Vault objects.
-        """
-        response_data = self.layer1.list_vaults()
-        return [Vault(self.layer1, rd) for rd in response_data['VaultList']]

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

@@ -1,48 +0,0 @@
-# -*- 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 GlacierResponse(dict):
-    """
-    Represents a response from Glacier layer1. It acts as a dictionary
-    containing the combined keys received via JSON in the body (if
-    supplied) and headers.
-    """
-    def __init__(self, http_response, response_headers):
-        self.http_response = http_response
-        self.status = http_response.status
-        self[u'RequestId'] = http_response.getheader('x-amzn-requestid')
-        if response_headers:
-            for header_name, item_name in response_headers:
-                self[item_name] = http_response.getheader(header_name)
-        if http_response.getheader('Content-Type') == 'application/json':
-            body = json.loads(http_response.read())
-            self.update(body)
-        size = http_response.getheader('Content-Length', None)
-        if size is not None:
-            self.size = size
-
-    def read(self, amt=None):
-        "Reads and returns the response body, or up to the next amt bytes."
-        return self.http_response.read(amt)

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

@@ -1,163 +0,0 @@
-# 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 hashlib
-import math
-
-
-_MEGABYTE = 1024 * 1024
-DEFAULT_PART_SIZE = 4 * _MEGABYTE
-MAXIMUM_NUMBER_OF_PARTS = 10000
-
-
-def minimum_part_size(size_in_bytes, default_part_size=DEFAULT_PART_SIZE):
-    """Calculate the minimum part size needed for a multipart upload.
-
-    Glacier allows a maximum of 10,000 parts per upload.  It also
-    states that the maximum archive size is 10,000 * 4 GB, which means
-    the part size can range from 1MB to 4GB (provided it is one 1MB
-    multiplied by a power of 2).
-
-    This function will compute what the minimum part size must be in
-    order to upload a file of size ``size_in_bytes``.
-
-    It will first check if ``default_part_size`` is sufficient for
-    a part size given the ``size_in_bytes``.  If this is not the case,
-    then the smallest part size than can accomodate a file of size
-    ``size_in_bytes`` will be returned.
-
-    If the file size is greater than the maximum allowed archive
-    size of 10,000 * 4GB, a ``ValueError`` will be raised.
-
-    """
-    # The default part size (4 MB) will be too small for a very large
-    # archive, as there is a limit of 10,000 parts in a multipart upload.
-    # This puts the maximum allowed archive size with the default part size
-    # at 40,000 MB. We need to do a sanity check on the part size, and find
-    # one that works if the default is too small.
-    part_size = _MEGABYTE
-    if (default_part_size * MAXIMUM_NUMBER_OF_PARTS) < size_in_bytes:
-        if size_in_bytes > (4096 * _MEGABYTE * 10000):
-            raise ValueError("File size too large: %s" % size_in_bytes)
-        min_part_size = size_in_bytes / 10000
-        power = 3
-        while part_size < min_part_size:
-            part_size = math.ldexp(_MEGABYTE, power)
-            power += 1
-        part_size = int(part_size)
-    else:
-        part_size = default_part_size
-    return part_size
-
-
-def chunk_hashes(bytestring, chunk_size=_MEGABYTE):
-    chunk_count = int(math.ceil(len(bytestring) / float(chunk_size)))
-    hashes = []
-    for i in xrange(chunk_count):
-        start = i * chunk_size
-        end = (i + 1) * chunk_size
-        hashes.append(hashlib.sha256(bytestring[start:end]).digest())
-    if not hashes:
-        return [hashlib.sha256('').digest()]
-    return hashes
-
-
-def tree_hash(fo):
-    """
-    Given a hash of each 1MB chunk (from chunk_hashes) this will hash
-    together adjacent hashes until it ends up with one big one. So a
-    tree of hashes.
-    """
-    hashes = []
-    hashes.extend(fo)
-    while len(hashes) > 1:
-        new_hashes = []
-        while True:
-            if len(hashes) > 1:
-                first = hashes.pop(0)
-                second = hashes.pop(0)
-                new_hashes.append(hashlib.sha256(first + second).digest())
-            elif len(hashes) == 1:
-                only = hashes.pop(0)
-                new_hashes.append(only)
-            else:
-                break
-        hashes.extend(new_hashes)
-    return hashes[0]
-
-
-def compute_hashes_from_fileobj(fileobj, chunk_size=1024 * 1024):
-    """Compute the linear and tree hash from a fileobj.
-
-    This function will compute the linear/tree hash of a fileobj
-    in a single pass through the fileobj.
-
-    :param fileobj: A file like object.
-
-    :param chunk_size: The size of the chunks to use for the tree
-        hash.  This is also the buffer size used to read from
-        `fileobj`.
-
-    :rtype: tuple
-    :return: A tuple of (linear_hash, tree_hash).  Both hashes
-        are returned in hex.
-
-    """
-    linear_hash = hashlib.sha256()
-    chunks = []
-    chunk = fileobj.read(chunk_size)
-    while chunk:
-        linear_hash.update(chunk)
-        chunks.append(hashlib.sha256(chunk).digest())
-        chunk = fileobj.read(chunk_size)
-    if not chunks:
-        chunks = [hashlib.sha256('').digest()]
-    return linear_hash.hexdigest(), bytes_to_hex(tree_hash(chunks))
-
-
-def bytes_to_hex(str_as_bytes):
-    return ''.join(["%02x" % ord(x) for x in str_as_bytes]).strip()
-
-
-def tree_hash_from_str(str_as_bytes):
-    """
-
-    :type str_as_bytes: str
-    :param str_as_bytes: The string for which to compute the tree hash.
-
-    :rtype: str
-    :return: The computed tree hash, returned as hex.
-
-    """
-    return bytes_to_hex(tree_hash(chunk_hashes(str_as_bytes)))
-
-
-class ResettingFileSender(object):
-    def __init__(self, archive):
-        self._archive = archive
-        self._starting_offset = archive.tell()
-
-    def __call__(self, connection, method, path, body, headers):
-        try:
-            connection.request(method, path, self._archive, headers)
-            return connection.getresponse()
-        finally:
-            self._archive.seek(self._starting_offset)

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

@@ -1,387 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2012 Thomas Parslow http://almostobsolete.net/
-# Copyright (c) 2012 Robie Basak <robie@justgohome.co.uk>
-#
-# 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
-from .exceptions import UploadArchiveError
-from .job import Job
-from .writer import compute_hashes_from_fileobj, resume_file_upload, Writer
-from .concurrent import ConcurrentUploader
-from .utils import minimum_part_size, DEFAULT_PART_SIZE
-import os.path
-
-
-_MEGABYTE = 1024 * 1024
-_GIGABYTE = 1024 * _MEGABYTE
-
-MAXIMUM_ARCHIVE_SIZE = 10000 * 4 * _GIGABYTE
-MAXIMUM_NUMBER_OF_PARTS = 10000
-
-
-class Vault(object):
-
-    DefaultPartSize = DEFAULT_PART_SIZE
-    SingleOperationThreshold = 100 * _MEGABYTE
-
-    ResponseDataElements = (('VaultName', 'name', None),
-                            ('VaultARN', 'arn', None),
-                            ('CreationDate', 'creation_date', None),
-                            ('LastInventoryDate', 'last_inventory_date', None),
-                            ('SizeInBytes', 'size', 0),
-                            ('NumberOfArchives', 'number_of_archives', 0))
-
-    def __init__(self, layer1, response_data=None):
-        self.layer1 = layer1
-        if response_data:
-            for response_name, attr_name, default in self.ResponseDataElements:
-                value = response_data[response_name]
-                if isinstance(value, unicode):
-                    value = value.encode('utf8')
-                setattr(self, attr_name, value)
-        else:
-            for response_name, attr_name, default in self.ResponseDataElements:
-                setattr(self, attr_name, default)
-
-    def __repr__(self):
-        return 'Vault("%s")' % self.arn
-
-    def delete(self):
-        """
-        Delete's this vault. WARNING!
-        """
-        self.layer1.delete_vault(self.name)
-
-    def upload_archive(self, filename, description=None):
-        """
-        Adds an archive to a vault. For archives greater than 100MB the
-        multipart upload will be used.
-
-        :type file: str
-        :param file: A filename to upload
-
-        :type description: str
-        :param description: An optional description for the archive.
-
-        :rtype: str
-        :return: The archive id of the newly created archive
-        """
-        if os.path.getsize(filename) > self.SingleOperationThreshold:
-            return self.create_archive_from_file(filename, description=description)
-        return self._upload_archive_single_operation(filename, description)
-
-    def _upload_archive_single_operation(self, filename, description):
-        """
-        Adds an archive to a vault in a single operation. It's recommended for
-        archives less than 100MB
-
-        :type file: str
-        :param file: A filename to upload
-
-        :type description: str
-        :param description: A description for the archive.
-
-        :rtype: str
-        :return: The archive id of the newly created archive
-        """
-        with open(filename, 'rb') as fileobj:
-            linear_hash, tree_hash = compute_hashes_from_fileobj(fileobj)
-            fileobj.seek(0)
-            response = self.layer1.upload_archive(self.name, fileobj,
-                                                  linear_hash, tree_hash,
-                                                  description)
-        return response['ArchiveId']
-
-    def create_archive_writer(self, part_size=DefaultPartSize,
-                              description=None):
-        """
-        Create a new archive and begin a multi-part upload to it.
-        Returns a file-like object to which the data for the archive
-        can be written. Once all the data is written the file-like
-        object should be closed, you can then call the get_archive_id
-        method on it to get the ID of the created archive.
-
-        :type part_size: int
-        :param part_size: The part size for the multipart upload.
-
-        :type description: str
-        :param description: An optional description for the archive.
-
-        :rtype: :class:`boto.glacier.writer.Writer`
-        :return: A Writer object that to which the archive data
-            should be written.
-        """
-        response = self.layer1.initiate_multipart_upload(self.name,
-                                                         part_size,
-                                                         description)
-        return Writer(self, response['UploadId'], part_size=part_size)
-
-    def create_archive_from_file(self, filename=None, file_obj=None,
-                                 description=None, upload_id_callback=None):
-        """
-        Create a new archive and upload the data from the given file
-        or file-like object.
-
-        :type filename: str
-        :param filename: A filename to upload
-
-        :type file_obj: file
-        :param file_obj: A file-like object to upload
-
-        :type description: str
-        :param description: An optional description for the archive.
-
-        :type upload_id_callback: function
-        :param upload_id_callback: if set, call with the upload_id as the
-            only parameter when it becomes known, to enable future calls
-            to resume_archive_from_file in case resume is needed.
-
-        :rtype: str
-        :return: The archive id of the newly created archive
-        """
-        part_size = self.DefaultPartSize
-        if not file_obj:
-            file_size = os.path.getsize(filename)
-            try:
-                min_part_size = minimum_part_size(file_size,
-                                                  self.DefaultPartSize)
-            except ValueError:
-                raise UploadArchiveError("File size of %s bytes exceeds "
-                                         "40,000 GB archive limit of Glacier.")
-            file_obj = open(filename, "rb")
-        writer = self.create_archive_writer(
-            description=description,
-            part_size=part_size)
-        if upload_id_callback:
-            upload_id_callback(writer.upload_id)
-        while True:
-            data = file_obj.read(part_size)
-            if not data:
-                break
-            writer.write(data)
-        writer.close()
-        return writer.get_archive_id()
-
-    @staticmethod
-    def _range_string_to_part_index(range_string, part_size):
-        start, inside_end = [int(value) for value in range_string.split('-')]
-        end = inside_end + 1
-        length = end - start
-        if length == part_size + 1:
-            # Off-by-one bug in Amazon's Glacier implementation,
-            # see: https://forums.aws.amazon.com/thread.jspa?threadID=106866
-            # Workaround: since part_size is too big by one byte, adjust it
-            end -= 1
-            inside_end -= 1
-            length -= 1
-        assert not (start % part_size), (
-            "upload part start byte is not on a part boundary")
-        assert (length <= part_size), "upload part is bigger than part size"
-        return start // part_size
-
-    def resume_archive_from_file(self, upload_id, filename=None,
-                                 file_obj=None):
-        """Resume upload of a file already part-uploaded to Glacier.
-
-        The resumption of an upload where the part-uploaded section is empty
-        is a valid degenerate case that this function can handle.
-
-        One and only one of filename or file_obj must be specified.
-
-        :type upload_id: str
-        :param upload_id: existing Glacier upload id of upload being resumed.
-
-        :type filename: str
-        :param filename: file to open for resume
-
-        :type fobj: file
-        :param fobj: file-like object containing local data to resume. This
-            must read from the start of the entire upload, not just from the
-            point being resumed. Use fobj.seek(0) to achieve this if necessary.
-
-        :rtype: str
-        :return: The archive id of the newly created archive
-
-        """
-        part_list_response = self.list_all_parts(upload_id)
-        part_size = part_list_response['PartSizeInBytes']
-
-        part_hash_map = {}
-        for part_desc in part_list_response['Parts']:
-            part_index = self._range_string_to_part_index(
-                part_desc['RangeInBytes'], part_size)
-            part_tree_hash = part_desc['SHA256TreeHash'].decode('hex')
-            part_hash_map[part_index] = part_tree_hash
-
-        if not file_obj:
-            file_obj = open(filename, "rb")
-
-        return resume_file_upload(
-            self, upload_id, part_size, file_obj, part_hash_map)
-
-    def concurrent_create_archive_from_file(self, filename, description):
-        """
-        Create a new archive from a file and upload the given
-        file.
-
-        This is a convenience method around the
-        :class:`boto.glacier.concurrent.ConcurrentUploader`
-        class.  This method will perform a multipart upload
-        and upload the parts of the file concurrently.
-
-        :type filename: str
-        :param filename: A filename to upload
-
-        :raises: `boto.glacier.exception.UploadArchiveError` is an error
-            occurs during the upload process.
-
-        :rtype: str
-        :return: The archive id of the newly created archive
-
-        """
-        uploader = ConcurrentUploader(self.layer1, self.name)
-        archive_id = uploader.upload(filename, description)
-        return archive_id
-
-    def retrieve_archive(self, archive_id, sns_topic=None,
-                         description=None):
-        """
-        Initiate a archive retrieval job to download the data from an
-        archive. You will need to wait for the notification from
-        Amazon (via SNS) before you can actually download the data,
-        this takes around 4 hours.
-
-        :type archive_id: str
-        :param archive_id: The id of the archive
-
-        :type description: str
-        :param description: An optional description for the job.
-
-        :type sns_topic: str
-        :param sns_topic: The Amazon SNS topic ARN where Amazon Glacier
-            sends notification when the job is completed and the output
-            is ready for you to download.
-
-        :rtype: :class:`boto.glacier.job.Job`
-        :return: A Job object representing the retrieval job.
-        """
-        job_data = {'Type': 'archive-retrieval',
-                    'ArchiveId': archive_id}
-        if sns_topic is not None:
-            job_data['SNSTopic'] = sns_topic
-        if description is not None:
-            job_data['Description'] = description
-
-        response = self.layer1.initiate_job(self.name, job_data)
-        return self.get_job(response['JobId'])
-
-    def retrieve_inventory(self, sns_topic=None,
-                           description=None):
-        """
-        Initiate a inventory retrieval job to list the items in the
-        vault. You will need to wait for the notification from
-        Amazon (via SNS) before you can actually download the data,
-        this takes around 4 hours.
-
-        :type description: str
-        :param description: An optional description for the job.
-
-        :type sns_topic: str
-        :param sns_topic: The Amazon SNS topic ARN where Amazon Glacier
-            sends notification when the job is completed and the output
-            is ready for you to download.
-
-        :rtype: :class:`boto.glacier.job.Job`
-        :return: A Job object representing the retrieval job.
-        """
-        job_data = {'Type': 'inventory-retrieval'}
-        if sns_topic is not None:
-            job_data['SNSTopic'] = sns_topic
-        if description is not None:
-            job_data['Description'] = description
-
-        response = self.layer1.initiate_job(self.name, job_data)
-        return response['JobId']
-
-    def delete_archive(self, archive_id):
-        """
-        This operation deletes an archive from the vault.
-
-        :type archive_id: str
-        :param archive_id: The ID for the archive to be deleted.
-        """
-        return self.layer1.delete_archive(self.name, archive_id)
-
-    def get_job(self, job_id):
-        """
-        Get an object representing a job in progress.
-
-        :type job_id: str
-        :param job_id: The ID of the job
-
-        :rtype: :class:`boto.glacier.job.Job`
-        :return: A Job object representing the job.
-        """
-        response_data = self.layer1.describe_job(self.name, job_id)
-        return Job(self, response_data)
-
-    def list_jobs(self, completed=None, status_code=None):
-        """
-        Return a list of Job objects related to this 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.
-
-        :rtype: list of :class:`boto.glacier.job.Job`
-        :return: A list of Job objects related to this vault.
-        """
-        response_data = self.layer1.list_jobs(self.name, completed,
-                                              status_code)
-        return [Job(self, jd) for jd in response_data['JobList']]
-
-    def list_all_parts(self, upload_id):
-        """Automatically make and combine multiple calls to list_parts.
-
-        Call list_parts as necessary, combining the results in case multiple
-        calls were required to get data on all available parts.
-
-        """
-        result = self.layer1.list_parts(self.name, upload_id)
-        marker = result['Marker']
-        while marker:
-            additional_result = self.layer1.list_parts(
-                self.name, upload_id, marker=marker)
-            result['Parts'].extend(additional_result['Parts'])
-            marker = additional_result['Marker']
-        # The marker makes no sense in an unpaginated result, and clearing it
-        # makes testing easier. This also has the nice property that the result
-        # is a normal (but expanded) response.
-        result['Marker'] = None
-        return result