コード例 #1
0
def buckets_patch(bucket_name):
    """Implement the 'Buckets: patch' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    patch = json.loads(flask.request.data)
    bucket.apply_patch(patch)
    return testbench_utils.filtered_response(flask.request, bucket.metadata)
コード例 #2
0
def bucket_acl_update(bucket_name, entity):
    """Implement the 'BucketAccessControls: update' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    payload = json.loads(flask.request.data)
    acl = bucket.update_acl(entity, payload.get('role', ''))
    return testbench_utils.filtered_response(flask.request, acl)
コード例 #3
0
ファイル: testbench.py プロジェクト: hard2Li/google-cloud-cpp
def resumable_upload_chunk(bucket_name):
    """Receive a chunk for a resumable upload."""
    gcs_url = flask.url_for(
        "objects_insert", bucket_name=bucket_name, _external=True
    ).replace("/upload/", "/")
    bucket = testbench_utils.lookup_bucket(bucket_name)
    return bucket.receive_upload_chunk(gcs_url, flask.request)
コード例 #4
0
def buckets_get(bucket_name):
    """Implement the 'Buckets: get' API: return the metadata for a bucket."""
    base_url = flask.url_for('gcs_index', _external=True)
    insert_magic_bucket(base_url)
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    return testbench_utils.filtered_response(flask.request, bucket.metadata)
コード例 #5
0
ファイル: testbench.py プロジェクト: hard2Li/google-cloud-cpp
def bucket_test_iam_permissions(bucket_name):
    """Implement the 'Buckets: testIamPermissions' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    return testbench_utils.filtered_response(
        flask.request, bucket.test_iam_permissions(flask.request)
    )
コード例 #6
0
ファイル: testbench.py プロジェクト: hard2Li/google-cloud-cpp
def bucket_set_iam_policy(bucket_name):
    """Implement the 'Buckets: setIamPolicy' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    return testbench_utils.filtered_response(
        flask.request, bucket.set_iam_policy(flask.request)
    )
コード例 #7
0
ファイル: testbench.py プロジェクト: hard2Li/google-cloud-cpp
def bucket_default_object_acl_patch(bucket_name, entity):
    """Implement the 'DefaultObjectAccessControls: patch' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    payload = json.loads(flask.request.data)
    acl = bucket.update_default_object_acl(entity, payload.get("role", ""))
    return testbench_utils.filtered_response(flask.request, acl)
コード例 #8
0
 def _update_predefined_acl(self, predefined_acl):
     """Update the ACL based on the given request parameter value."""
     if predefined_acl is None:
         predefined_acl = 'projectPrivate'
     self.insert_acl(
         testbench_utils.canonical_entity_name('project-owners-123456789'),
         'OWNER')
     bucket = testbench_utils.lookup_bucket(self.bucket_name)
     owner = bucket.metadata.get('owner')
     if owner is None:
         owner_entity = 'project-owners-123456789'
     else:
         owner_entity = owner.get('entity')
     if predefined_acl == 'authenticatedRead':
         self.insert_acl('allAuthenticatedUsers', 'READER')
     elif predefined_acl == 'bucketOwnerFullControl':
         self.insert_acl(owner_entity, 'OWNER')
     elif predefined_acl == 'bucketOwnerRead':
         self.insert_acl(owner_entity, 'READER')
     elif predefined_acl == 'private':
         self.insert_acl('project-owners', 'OWNER')
     elif predefined_acl == 'projectPrivate':
         self.insert_acl(
             testbench_utils.canonical_entity_name(
                 'project-editors-123456789'), 'OWNER')
         self.insert_acl(
             testbench_utils.canonical_entity_name(
                 'project-viewers-123456789'), 'READER')
     elif predefined_acl == 'publicRead':
         self.insert_acl(testbench_utils.canonical_entity_name('allUsers'),
                         'READER')
     else:
         raise error_response.ErrorResponse('Invalid predefinedAcl value',
                                            status_code=400)
コード例 #9
0
def bucket_acl_create(bucket_name):
    """Implement the 'BucketAccessControls: create' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    payload = json.loads(flask.request.data)
    return testbench_utils.filtered_response(
        flask.request,
        bucket.insert_acl(payload.get('entity', ''), payload.get('role', '')))
コード例 #10
0
ファイル: testbench.py プロジェクト: tritone/google-cloud-cpp
def bucket_notification_list(bucket_name):
    """Implement the 'Notifications: list' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    return testbench_utils.filtered_response(
        flask.request,
        {"kind": "storage#notifications", "items": bucket.list_notifications()},
    )
コード例 #11
0
def bucket_default_object_acl_list(bucket_name):
    """Implement the 'BucketAccessControls: list' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    result = {
        'items': bucket.metadata.get('defaultObjectAcl', []),
    }
    return testbench_utils.filtered_response(flask.request, result)
コード例 #12
0
ファイル: testbench.py プロジェクト: hard2Li/google-cloud-cpp
def objects_insert(bucket_name):
    """Implement the 'Objects: insert' API.  Insert a new GCS Object."""
    gcs_url = flask.url_for(
        "objects_insert", bucket_name=bucket_name, _external=True
    ).replace("/upload/", "/")
    insert_magic_bucket(gcs_url)

    upload_type = flask.request.args.get("uploadType")
    if upload_type is None:
        raise error_response.ErrorResponse(
            "uploadType not set in Objects: insert", status_code=400
        )
    if upload_type not in {"multipart", "media", "resumable"}:
        raise error_response.ErrorResponse(
            "testbench does not support %s uploadType" % upload_type, status_code=400
        )

    if upload_type == "resumable":
        bucket = testbench_utils.lookup_bucket(bucket_name)
        upload_url = flask.url_for(
            "objects_insert", bucket_name=bucket_name, _external=True
        )
        return bucket.create_resumable_upload(upload_url, flask.request)

    object_path = None
    blob = None
    current_version = None
    if upload_type == "media":
        object_name = flask.request.args.get("name", None)
        if object_name is None:
            raise error_response.ErrorResponse(
                "name not set in Objects: insert", status_code=412
            )
        object_path, blob = testbench_utils.get_object(
            bucket_name, object_name, gcs_object.GcsObject(bucket_name, object_name)
        )
        blob.check_preconditions(flask.request)
        current_version = blob.insert(gcs_url, flask.request)
    else:
        resource, media_headers, media_body = testbench_utils.parse_multi_part(
            flask.request
        )
        object_name = flask.request.args.get("name", resource.get("name", None))
        if object_name is None:
            raise error_response.ErrorResponse(
                "name not set in Objects: insert", status_code=412
            )
        object_path, blob = testbench_utils.get_object(
            bucket_name, object_name, gcs_object.GcsObject(bucket_name, object_name)
        )
        blob.check_preconditions(flask.request)
        current_version = blob.insert_multipart(
            gcs_url, flask.request, resource, media_headers, media_body
        )
    testbench_utils.insert_object(object_path, blob)
    return testbench_utils.filtered_response(flask.request, current_version.metadata)
コード例 #13
0
    def _insert_revision(self, revision):
        """Insert a new revision that has been initialized and checked.

        :param revision: GcsObjectVersion the new revision to insert.
        :rtype:NoneType
        """
        update = {self.generation: revision}
        bucket = testbench_utils.lookup_bucket(self.bucket_name)
        if not bucket.versioning_enabled():
            self.revisions = update
        else:
            self.revisions.update(update)
コード例 #14
0
def delete_resumable_upload(bucket_name):
    upload_type = flask.request.args.get("uploadType")
    if upload_type != "resumable":
        raise error_response.ErrorResponse(
            "testbench can delete resumable uploadType only", status_code=400)
    upload_id = flask.request.args.get("upload_id")
    if upload_id is None:
        raise error_response.ErrorResponse(
            "missing upload_id in delete_resumable_upload", status_code=400)
    bucket = testbench_utils.lookup_bucket(bucket_name)
    if upload_id not in bucket.resumable_uploads:
        raise error_response.ErrorResponse("upload_id does not exist",
                                           status_code=404)
    bucket.resumable_uploads.pop(upload_id)
    return testbench_utils.filtered_response(flask.request, {})
コード例 #15
0
def buckets_update(bucket_name):
    """Implement the 'Buckets: update' API: update an existing Bucket."""
    base_url = flask.url_for('gcs_index', _external=True)
    insert_magic_bucket(base_url)
    payload = json.loads(flask.request.data)
    name = payload.get('name')
    if name is None:
        raise error_response.ErrorResponse(
            'Missing bucket name in `Buckets: update`', status_code=412)
    if name != bucket_name:
        raise error_response.ErrorResponse(
            'Mismatched bucket name parameter in `Buckets: update`',
            status_code=400)
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    bucket.update_from_metadata(payload)
    return testbench_utils.filtered_response(flask.request, bucket.metadata)
コード例 #16
0
ファイル: testbench.py プロジェクト: tritone/google-cloud-cpp
def objects_list(bucket_name):
    """Implement the 'Objects: list' API: return the objects in a bucket."""
    # Lookup the bucket, if this fails the bucket does not exist, and this
    # function should return an error.
    base_url = flask.url_for("gcs_index", _external=True)
    insert_magic_bucket(base_url)
    _ = testbench_utils.lookup_bucket(bucket_name)
    result = {"next_page_token": "", "items": []}
    versions_parameter = flask.request.args.get("versions")
    all_versions = versions_parameter is not None and bool(versions_parameter)
    for name, o in testbench_utils.all_objects():
        if name.find(bucket_name + "/o") != 0:
            continue
        if o.get_latest() is None:
            continue
        if all_versions:
            for object_version in o.revisions.values():
                result["items"].append(object_version.metadata)
        else:
            result["items"].append(o.get_latest().metadata)
    return testbench_utils.filtered_response(flask.request, result)
コード例 #17
0
def objects_insert(bucket_name):
    """Implement the 'Objects: insert' API.  Insert a new GCS Object."""
    gcs_url = flask.url_for('objects_insert',
                            bucket_name=bucket_name,
                            _external=True).replace('/upload/', '/')
    insert_magic_bucket(gcs_url)

    upload_type = flask.request.args.get('uploadType')
    if upload_type is None:
        raise error_response.ErrorResponse(
            'uploadType not set in Objects: insert', status_code=400)
    if upload_type not in {'multipart', 'media', 'resumable'}:
        raise error_response.ErrorResponse(
            'testbench does not support %s uploadType' % upload_type,
            status_code=400)

    if upload_type == 'resumable':
        bucket = testbench_utils.lookup_bucket(bucket_name)
        upload_url = flask.url_for('objects_insert',
                                   bucket_name=bucket_name,
                                   _external=True)
        return bucket.create_resumable_upload(upload_url, flask.request)

    object_name = flask.request.args.get('name', None)
    if object_name is None:
        raise error_response.ErrorResponse('name not set in Objects: insert',
                                           status_code=412)
    object_path, blob = testbench_utils.get_object(
        bucket_name, object_name, gcs_object.GcsObject(bucket_name,
                                                       object_name))
    blob.check_preconditions(flask.request)
    if upload_type == 'media':
        current_version = blob.insert(gcs_url, flask.request)
    else:
        current_version = blob.insert_multipart(gcs_url, flask.request)
    testbench_utils.insert_object(object_path, blob)
    return testbench_utils.filtered_response(flask.request,
                                             current_version.metadata)
コード例 #18
0
ファイル: gcs_object.py プロジェクト: xhochy/google-cloud-cpp
 def _update_predefined_acl(self, predefined_acl):
     """Update the ACL based on the given request parameter value."""
     if predefined_acl is None:
         predefined_acl = "projectPrivate"
     self.insert_acl(
         testbench_utils.canonical_entity_name("project-owners-123456789"),
         "OWNER")
     bucket = testbench_utils.lookup_bucket(self.bucket_name)
     owner = bucket.metadata.get("owner")
     if owner is None:
         owner_entity = "project-owners-123456789"
     else:
         owner_entity = owner.get("entity")
     if predefined_acl == "authenticatedRead":
         self.insert_acl("allAuthenticatedUsers", "READER")
     elif predefined_acl == "bucketOwnerFullControl":
         self.insert_acl(owner_entity, "OWNER")
     elif predefined_acl == "bucketOwnerRead":
         self.insert_acl(owner_entity, "READER")
     elif predefined_acl == "private":
         self.insert_acl("project-owners", "OWNER")
     elif predefined_acl == "projectPrivate":
         self.insert_acl(
             testbench_utils.canonical_entity_name(
                 "project-editors-123456789"),
             "OWNER",
         )
         self.insert_acl(
             testbench_utils.canonical_entity_name(
                 "project-viewers-123456789"),
             "READER",
         )
     elif predefined_acl == "publicRead":
         self.insert_acl(testbench_utils.canonical_entity_name("allUsers"),
                         "READER")
     else:
         raise error_response.ErrorResponse("Invalid predefinedAcl value",
                                            status_code=400)
コード例 #19
0
def objects_list(bucket_name):
    """Implement the 'Objects: list' API: return the objects in a bucket."""
    # Lookup the bucket, if this fails the bucket does not exist, and this
    # function should return an error.
    base_url = flask.url_for("gcs_index", _external=True)
    insert_magic_bucket(base_url)
    _ = testbench_utils.lookup_bucket(bucket_name)
    result = {"next_page_token": "", "items": [], "prefixes:": []}
    versions_parameter = flask.request.args.get("versions")
    all_versions = versions_parameter is not None and bool(versions_parameter)
    prefixes = set()
    prefix = flask.request.args.get("prefix", "", type(""))
    delimiter = flask.request.args.get("delimiter", "", type(""))
    start_offset = flask.request.args.get("startOffset", "", type(""))
    end_offset = flask.request.args.get("endOffset", "", type(""))
    bucket_link = bucket_name + "/o/"
    for name, o in testbench_utils.all_objects():
        if name.find(bucket_link + prefix) != 0:
            continue
        if o.get_latest() is None:
            continue
        # We assume `delimiter` has only one character.
        if name[len(bucket_link):] < start_offset:
            continue
        if end_offset != "" and name[len(bucket_link):] >= end_offset:
            continue
        delimiter_index = name.find(delimiter, len(bucket_link + prefix))
        if delimiter != "" and delimiter_index > 0:
            # We don't want to include `bucket_link` in the returned prefix.
            prefixes.add(name[len(bucket_link):delimiter_index + 1])
            continue
        if all_versions:
            for object_version in o.revisions.values():
                result["items"].append(object_version.metadata)
        else:
            result["items"].append(o.get_latest().metadata)
    result["prefixes"] = list(prefixes)
    return testbench_utils.filtered_response(flask.request, result)
コード例 #20
0
def bucket_acl_list(bucket_name):
    """Implement the 'BucketAccessControls: list' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    result = {"items": bucket.metadata.get("acl", [])}
    return testbench_utils.filtered_response(flask.request, result)
コード例 #21
0
def bucket_lock_retention_policy(bucket_name):
    """Implement the 'Buckets: lockRetentionPolicy' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.lock_retention_policy(flask.request)
    return testbench_utils.filtered_response(flask.request, bucket.metadata)
コード例 #22
0
def bucket_notification_get(bucket_name, notification_id):
    """Implement the 'Notifications: get' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    notification = bucket.get_notification(notification_id)
    return testbench_utils.filtered_response(flask.request, notification)
コード例 #23
0
def bucket_default_object_acl_get(bucket_name, entity):
    """Implement the 'BucketAccessControls: get' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    acl = bucket.get_default_object_acl(entity)
    return testbench_utils.filtered_response(flask.request, acl)
コード例 #24
0
def bucket_acl_delete(bucket_name, entity):
    """Implement the 'BucketAccessControls: delete' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    bucket.delete_acl(entity)
    return testbench_utils.filtered_response(flask.request, {})
コード例 #25
0
def buckets_delete(bucket_name):
    """Implement the 'Buckets: delete' API."""
    bucket = testbench_utils.lookup_bucket(bucket_name)
    bucket.check_preconditions(flask.request)
    testbench_utils.delete_bucket(bucket_name)
    return testbench_utils.filtered_response(flask.request, {})