Ejemplo n.º 1
0
    def test_image_member_find(self):
        TENANT1 = utils.generate_uuid()
        TENANT2 = utils.generate_uuid()
        fixtures = [
            {'member': TENANT1, 'image_id': UUID1},
            {'member': TENANT1, 'image_id': UUID2},
            {'member': TENANT2, 'image_id': UUID1},
        ]
        for f in fixtures:
            self.db_api.image_member_create(self.context, copy.deepcopy(f))

        def _simplify(output):
            return

        def _assertMemberListMatch(list1, list2):
            _simple = lambda x: set([(o['member'], o['image_id']) for o in x])
            self.assertEqual(_simple(list1), _simple(list2))

        output = self.db_api.image_member_find(self.context, member=TENANT1)
        _assertMemberListMatch([fixtures[0], fixtures[1]], output)

        output = self.db_api.image_member_find(self.context, image_id=UUID1)
        _assertMemberListMatch([fixtures[0], fixtures[2]], output)

        output = self.db_api.image_member_find(self.context,
                                               member=TENANT2,
                                               image_id=UUID1)
        _assertMemberListMatch([fixtures[2]], output)

        output = self.db_api.image_member_find(self.context,
                                               member=TENANT2,
                                               image_id=utils.generate_uuid())
        _assertMemberListMatch([], output)
Ejemplo n.º 2
0
    def test_image_get_all_owned(self):
        TENANT1 = utils.generate_uuid()
        ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
        UUIDX = utils.generate_uuid()
        self.db_api.image_create(ctxt1, {
            'id': UUIDX,
            'status': 'queued',
            'owner': TENANT1
        })

        TENANT2 = utils.generate_uuid()
        ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
        UUIDY = utils.generate_uuid()
        self.db_api.image_create(ctxt2, {
            'id': UUIDY,
            'status': 'queued',
            'owner': TENANT2
        })

        # NOTE(bcwaldon): the is_public=True flag indicates that you want
        # to get all images that are public AND those that are owned by the
        # calling context
        images = self.db_api.image_get_all(ctxt1, filters={'is_public': True})
        image_ids = [image['id'] for image in images]
        expected = [UUIDX, UUID3, UUID2, UUID1]
        self.assertEqual(sorted(expected), sorted(image_ids))
Ejemplo n.º 3
0
    def test_image_member_find(self):
        TENANT1 = utils.generate_uuid()
        TENANT2 = utils.generate_uuid()
        fixtures = [
            {'member': TENANT1, 'image_id': UUID1},
            {'member': TENANT1, 'image_id': UUID2},
            {'member': TENANT2, 'image_id': UUID1},
        ]
        for f in fixtures:
            self.db_api.image_member_create(self.context, copy.deepcopy(f))

        def _simplify(output):
            return

        def _assertMemberListMatch(list1, list2):
            _simple = lambda x: set([(o['member'], o['image_id']) for o in x])
            self.assertEqual(_simple(list1), _simple(list2))

        output = self.db_api.image_member_find(self.context, member=TENANT1)
        _assertMemberListMatch([fixtures[0], fixtures[1]], output)

        output = self.db_api.image_member_find(self.context, image_id=UUID1)
        _assertMemberListMatch([fixtures[0], fixtures[2]], output)

        output = self.db_api.image_member_find(self.context,
                                               member=TENANT2,
                                               image_id=UUID1)
        _assertMemberListMatch([fixtures[2]], output)

        output = self.db_api.image_member_find(self.context,
                                               member=TENANT2,
                                               image_id=utils.generate_uuid())
        _assertMemberListMatch([], output)
Ejemplo n.º 4
0
 def test_image_get_not_owned(self):
     TENANT1 = utils.generate_uuid()
     TENANT2 = utils.generate_uuid()
     ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
     ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
     image = self.db_api.image_create(
             ctxt1, {'status': 'queued', 'owner': TENANT1})
     self.assertRaises(exception.Forbidden,
                       self.db_api.image_get, ctxt2, image['id'])
Ejemplo n.º 5
0
 def test_image_get_not_owned(self):
     TENANT1 = utils.generate_uuid()
     TENANT2 = utils.generate_uuid()
     ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
     ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
     image = self.db_api.image_create(
             ctxt1, {'status': 'queued', 'owner': TENANT1})
     self.assertRaises(exception.Forbidden,
                       self.db_api.image_get, ctxt2, image['id'])
Ejemplo n.º 6
0
    def test_multitenant(self):
        """Ensure an image is properly configured when using multitenancy."""
        fake_swift_admin = 'd2f68325-8e2c-4fb1-8c8b-89de2f3d9c4a'
        self.config(
            swift_store_multi_tenant=True,
        )

        swift_store_user = self.swift_config['swift_store_user']
        tenant_name, username = swift_store_user.split(':')
        tenant_id, auth_token, service_catalog = keystone_authenticate(
                self.swift_config['swift_store_auth_address'],
                self.swift_config['swift_store_auth_version'],
                tenant_name,
                username,
                self.swift_config['swift_store_key'])

        context = glance.context.RequestContext(
                tenant=tenant_id,
                service_catalog=service_catalog,
                auth_tok=auth_token)
        store = self.get_store(context=context)

        image_id = utils.generate_uuid()
        image_data = StringIO.StringIO('XXX')
        uri, _, _ = store.add(image_id, image_data, 3)

        location = glance.store.location.Location(
                self.store_name,
                store.get_store_location_class(),
                uri=uri,
                image_id=image_id)

        read_tenant = utils.generate_uuid()
        write_tenant = utils.generate_uuid()
        store.set_acls(location,
                       public=False,
                       read_tenants=[read_tenant],
                       write_tenants=[write_tenant])

        container_name = location.store_location.container
        container, _ = swift_get_container(self.swift_client, container_name)
        self.assertEqual(read_tenant, container.get('x-container-read'))
        self.assertEqual(write_tenant, container.get('x-container-write'))

        store.set_acls(location, public=True, read_tenants=[read_tenant])

        container_name = location.store_location.container
        container, _ = swift_get_container(self.swift_client, container_name)
        self.assertEqual('.r:*', container.get('x-container-read'))
        self.assertEqual('', container.get('x-container-write', ''))

        (get_iter, get_size) = store.get(location)
        self.assertEqual('3', get_size)
        self.assertEqual('XXX', ''.join(get_iter))

        store.delete(location)
Ejemplo n.º 7
0
    def test_multitenant(self):
        """Ensure an image is properly configured when using multitenancy."""
        fake_swift_admin = 'd2f68325-8e2c-4fb1-8c8b-89de2f3d9c4a'
        self.config(swift_store_multi_tenant=True, )

        swift_store_user = self.swift_config['swift_store_user']
        tenant_name, username = swift_store_user.split(':')
        tenant_id, auth_token, service_catalog = keystone_authenticate(
            self.swift_config['swift_store_auth_address'],
            self.swift_config['swift_store_auth_version'], tenant_name,
            username, self.swift_config['swift_store_key'])

        context = glance.context.RequestContext(
            tenant=tenant_id,
            service_catalog=service_catalog,
            auth_tok=auth_token)
        store = self.get_store(context=context)

        image_id = utils.generate_uuid()
        image_data = StringIO.StringIO('XXX')
        uri, _, _ = store.add(image_id, image_data, 3)

        location = glance.store.location.Location(
            self.store_name,
            store.get_store_location_class(),
            uri=uri,
            image_id=image_id)

        read_tenant = utils.generate_uuid()
        write_tenant = utils.generate_uuid()
        store.set_acls(location,
                       public=False,
                       read_tenants=[read_tenant],
                       write_tenants=[write_tenant])

        container_name = location.store_location.container
        container, _ = swift_get_container(self.swift_client, container_name)
        self.assertEqual(read_tenant, container.get('x-container-read'))
        self.assertEqual(write_tenant, container.get('x-container-write'))

        store.set_acls(location, public=True, read_tenants=[read_tenant])

        container_name = location.store_location.container
        container, _ = swift_get_container(self.swift_client, container_name)
        self.assertEqual('.r:*', container.get('x-container-read'))
        self.assertEqual('', container.get('x-container-write', ''))

        (get_iter, get_size) = store.get(location)
        self.assertEqual('3', get_size)
        self.assertEqual('XXX', ''.join(get_iter))

        store.delete(location)
Ejemplo n.º 8
0
 def test_image_member_delete(self):
     TENANT1 = utils.generate_uuid()
     fixture = {'member': TENANT1, 'image_id': UUID1, 'can_share': True}
     member = self.db_api.image_member_create(self.context, fixture)
     self.assertEqual(1, len(self.db_api.image_member_find(self.context)))
     member = self.db_api.image_member_delete(self.context, member['id'])
     self.assertEqual(0, len(self.db_api.image_member_find(self.context)))
Ejemplo n.º 9
0
    def test_get_remote_image(self):
        """Get an image that was created externally to Glance

        Rather than depending on local configuration to build
        a connetion to Swift, we depend on the URI of the image.
        """
        image_id = utils.generate_uuid()
        container_name = self.swift_config['swift_store_container']
        swift_put_object(self.swift_client,
                         container_name,
                         image_id,
                         'XXX')

        #NOTE(bcwaldon): This is a hack until we find a better way to
        # build this URL
        auth_url = self.swift_config['swift_store_auth_address']
        auth_url = urlparse.urlparse(auth_url)
        user = urllib.quote(self.swift_config['swift_store_user'])
        key = self.swift_config['swift_store_key']
        netloc = ''.join(('%s:%s' % (user, key), '@', auth_url.netloc))
        path = os.path.join(auth_url.path, container_name, image_id)

        # This is an auth url with /<CONTAINER>/<OBJECT> on the end
        faux_obj_url = 'swift+http://%s%s' % (netloc, path)

        store = self.get_store()
        location = glance.store.location.Location(
                self.store_name,
                store.get_store_location_class(),
                uri=faux_obj_url)
        (get_iter, get_size) = store.get(location)
        self.assertEqual('3', get_size)
        self.assertEqual('XXX', ''.join(get_iter))
Ejemplo n.º 10
0
 def test_create_with_id(self):
     request = test_utils.FakeRequest()
     image_id = utils.generate_uuid()
     request.body = json.dumps({'id': image_id})
     output = self.deserializer.create(request)
     expected = {'image': {'id': image_id}}
     self.assertEqual(expected, output)
Ejemplo n.º 11
0
    def test_get(self):
        """Test a "normal" retrieval of an image in chunks"""
        # First add an image...
        image_id = utils.generate_uuid()
        file_contents = "chunk00000remainder"
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        location, size, checksum = self.store.add(image_id,
                                                  image_file,
                                                  len(file_contents))

        # Now read it back...
        uri = "file:///%s/%s" % (self.test_dir, image_id)
        loc = get_location_from_uri(uri)
        (image_file, image_size) = self.store.get(loc)

        expected_data = "chunk00000remainder"
        expected_num_chunks = 2
        data = ""
        num_chunks = 0

        for chunk in image_file:
            num_chunks += 1
            data += chunk
        self.assertEqual(expected_data, data)
        self.assertEqual(expected_num_chunks, num_chunks)
Ejemplo n.º 12
0
    def test_get(self):
        """Test a "normal" retrieval of an image in chunks"""
        # First add an image...
        image_id = utils.generate_uuid()
        file_contents = "chunk00000remainder"
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        location, size, checksum = self.store.add(image_id, image_file,
                                                  len(file_contents))

        # Now read it back...
        uri = "file:///%s/%s" % (self.test_dir, image_id)
        loc = get_location_from_uri(uri)
        (image_file, image_size) = self.store.get(loc)

        expected_data = "chunk00000remainder"
        expected_num_chunks = 2
        data = ""
        num_chunks = 0

        for chunk in image_file:
            num_chunks += 1
            data += chunk
        self.assertEqual(expected_data, data)
        self.assertEqual(expected_num_chunks, num_chunks)
Ejemplo n.º 13
0
    def test_add(self):
        """Test that we can add an image via the filesystem backend"""
        ChunkedFile.CHUNKSIZE = 1024
        expected_image_id = utils.generate_uuid()
        expected_file_size = 1024 * 5  # 5K
        expected_file_contents = "*" * expected_file_size
        expected_checksum = hashlib.md5(expected_file_contents).hexdigest()
        expected_location = "file://%s/%s" % (self.test_dir,
                                              expected_image_id)
        image_file = StringIO.StringIO(expected_file_contents)

        location, size, checksum = self.store.add(expected_image_id,
                                                  image_file,
                                                  expected_file_size)

        self.assertEquals(expected_location, location)
        self.assertEquals(expected_file_size, size)
        self.assertEquals(expected_checksum, checksum)

        uri = "file:///%s/%s" % (self.test_dir, expected_image_id)
        loc = get_location_from_uri(uri)
        (new_image_file, new_image_size) = self.store.get(loc)
        new_image_contents = ""
        new_image_file_size = 0

        for chunk in new_image_file:
            new_image_file_size += len(chunk)
            new_image_contents += chunk

        self.assertEquals(expected_file_contents, new_image_contents)
        self.assertEquals(expected_file_size, new_image_file_size)
Ejemplo n.º 14
0
 def test_create_with_id(self):
     request = unit_test_utils.get_fake_request()
     image_id = utils.generate_uuid()
     request.body = json.dumps({'id': image_id})
     output = self.deserializer.create(request)
     expected = {'image': {'id': image_id, 'properties': {}}}
     self.assertEqual(expected, output)
Ejemplo n.º 15
0
def _image_member_format(image_id, tenant_id, can_share):
    return {
        'id': utils.generate_uuid(),
        'image_id': image_id,
        'member': tenant_id,
        'can_share': can_share,
    }
Ejemplo n.º 16
0
def _image_member_format(image_id, tenant_id, can_share):
    return {
        'id': utils.generate_uuid(),
        'image_id': image_id,
        'member': tenant_id,
        'can_share': can_share,
    }
    def test_add(self):
        """Test that we can add an image via the s3 backend"""
        expected_image_id = utils.generate_uuid()
        expected_s3_size = FIVE_KB
        expected_s3_contents = "*" * expected_s3_size
        expected_checksum = hashlib.md5(expected_s3_contents).hexdigest()
        expected_location = format_s3_location(S3_CONF['s3_store_access_key'],
                                               S3_CONF['s3_store_secret_key'],
                                               S3_CONF['s3_store_host'],
                                               S3_CONF['s3_store_bucket'],
                                               expected_image_id)
        image_s3 = StringIO.StringIO(expected_s3_contents)

        location, size, checksum = self.store.add(expected_image_id, image_s3,
                                                  expected_s3_size)

        self.assertEquals(expected_location, location)
        self.assertEquals(expected_s3_size, size)
        self.assertEquals(expected_checksum, checksum)

        loc = get_location_from_uri(expected_location)
        (new_image_s3, new_image_size) = self.store.get(loc)
        new_image_contents = StringIO.StringIO()
        for chunk in new_image_s3:
            new_image_contents.write(chunk)
        new_image_s3_size = new_image_contents.len

        self.assertEquals(expected_s3_contents, new_image_contents.getvalue())
        self.assertEquals(expected_s3_size, new_image_s3_size)
Ejemplo n.º 18
0
    def test_add(self):
        """Test that we can add an image via the s3 backend"""
        expected_image_id = utils.generate_uuid()
        expected_s3_size = FIVE_KB
        expected_s3_contents = "*" * expected_s3_size
        expected_checksum = hashlib.md5(expected_s3_contents).hexdigest()
        expected_location = format_s3_location(
            S3_CONF['s3_store_access_key'],
            S3_CONF['s3_store_secret_key'],
            S3_CONF['s3_store_host'],
            S3_CONF['s3_store_bucket'],
            expected_image_id)
        image_s3 = StringIO.StringIO(expected_s3_contents)

        location, size, checksum = self.store.add(expected_image_id,
                                                  image_s3,
                                                  expected_s3_size)

        self.assertEquals(expected_location, location)
        self.assertEquals(expected_s3_size, size)
        self.assertEquals(expected_checksum, checksum)

        loc = get_location_from_uri(expected_location)
        (new_image_s3, new_image_size) = self.store.get(loc)
        new_image_contents = StringIO.StringIO()
        for chunk in new_image_s3:
            new_image_contents.write(chunk)
        new_image_s3_size = new_image_contents.len

        self.assertEquals(expected_s3_contents, new_image_contents.getvalue())
        self.assertEquals(expected_s3_size, new_image_s3_size)
Ejemplo n.º 19
0
 def test_generate_uuid_format(self):
     """Check the format of a uuid"""
     uuid = utils.generate_uuid()
     self.assertTrue(isinstance(uuid, basestring))
     self.assertTrue(len(uuid), 36)
     # make sure there are 4 dashes
     self.assertTrue(len(uuid.replace('-', '')), 36)
Ejemplo n.º 20
0
    def test_lifecycle(self):
        """Add, get and delete an image"""
        store = self.get_store()

        image_id = utils.generate_uuid()
        image_data = StringIO.StringIO('XXX')
        image_checksum = 'bc9189406be84ec297464a514221406d'
        uri, add_size, add_checksum = store.add(image_id, image_data, 3)

        self.assertEqual(3, add_size)
        self.assertEqual(image_checksum, add_checksum)

        store = self.get_store()
        location = glance.store.location.Location(
            self.store_name,
            store.get_store_location_class(),
            uri=uri,
            image_id=image_id)

        (get_iter, get_size) = store.get(location)
        self.assertEqual('3', get_size)
        self.assertEqual('XXX', ''.join(get_iter))

        store.delete(location)

        self.assertRaises(exception.NotFound, store.get, location)
Ejemplo n.º 21
0
    def test_add(self):
        """Test that we can add an image via the filesystem backend"""
        ChunkedFile.CHUNKSIZE = 1024
        expected_image_id = utils.generate_uuid()
        expected_file_size = 1024 * 5  # 5K
        expected_file_contents = "*" * expected_file_size
        expected_checksum = hashlib.md5(expected_file_contents).hexdigest()
        expected_location = "file://%s/%s" % (stubs.FAKE_FILESYSTEM_ROOTDIR,
                                              expected_image_id)
        image_file = StringIO.StringIO(expected_file_contents)

        location, size, checksum = self.store.add(expected_image_id,
                                                  image_file,
                                                  expected_file_size)

        self.assertEquals(expected_location, location)
        self.assertEquals(expected_file_size, size)
        self.assertEquals(expected_checksum, checksum)

        uri = "file:///tmp/glance-tests/%s" % expected_image_id
        loc = get_location_from_uri(uri)
        (new_image_file, new_image_size) = self.store.get(loc)
        new_image_contents = ""
        new_image_file_size = 0

        for chunk in new_image_file:
            new_image_file_size += len(chunk)
            new_image_contents += chunk

        self.assertEquals(expected_file_contents, new_image_contents)
        self.assertEquals(expected_file_size, new_image_file_size)
Ejemplo n.º 22
0
    def test_lifecycle(self):
        """Add, get and delete an image"""
        store = self.get_store()

        image_id = utils.generate_uuid()
        image_data = StringIO.StringIO('XXX')
        image_checksum = 'bc9189406be84ec297464a514221406d'
        uri, add_size, add_checksum = store.add(image_id, image_data, 3)

        self.assertEqual(3, add_size)
        self.assertEqual(image_checksum, add_checksum)

        store = self.get_store()
        location = glance.store.location.Location(
                self.store_name,
                store.get_store_location_class(),
                uri=uri,
                image_id=image_id)

        (get_iter, get_size) = store.get(location)
        self.assertEqual('3', get_size)
        self.assertEqual('XXX', ''.join(get_iter))

        store.delete(location)

        self.assertRaises(exception.NotFound, store.get, location)
Ejemplo n.º 23
0
 def test_index_with_invalid_marker(self):
     fake_uuid = utils.generate_uuid()
     request = unit_test_utils.get_fake_request()
     self.assertRaises(webob.exc.HTTPBadRequest,
                       self.controller.index,
                       request,
                       marker=fake_uuid)
Ejemplo n.º 24
0
 def test_generate_uuid_format(self):
     """Check the format of a uuid"""
     uuid = utils.generate_uuid()
     self.assertTrue(isinstance(uuid, basestring))
     self.assertTrue(len(uuid), 36)
     # make sure there are 4 dashes
     self.assertTrue(len(uuid.replace('-', '')), 36)
Ejemplo n.º 25
0
 def test_index(self):
     marker = utils.generate_uuid()
     path = "/images?limit=1&marker=%s" % marker
     request = unit_test_utils.get_fake_request(path)
     expected = {"limit": 1, "marker": marker, "sort_key": "created_at", "sort_dir": "desc", "filters": {}}
     output = self.deserializer.index(request)
     self.assertEqual(output, expected)
Ejemplo n.º 26
0
 def test_image_member_delete(self):
     TENANT1 = utils.generate_uuid()
     fixture = {'member': TENANT1, 'image_id': UUID1, 'can_share': True}
     member = self.db_api.image_member_create(self.context, fixture)
     self.assertEqual(1, len(self.db_api.image_member_find(self.context)))
     member = self.db_api.image_member_delete(self.context, member['id'])
     self.assertEqual(0, len(self.db_api.image_member_find(self.context)))
Ejemplo n.º 27
0
 def test_index_with_non_default_is_public_filter(self):
     image = {"id": utils.generate_uuid(), "owner": TENANT3, "name": "3", "is_public": False}
     self.db.image_create(None, image)
     path = "/images?visibility=private"
     request = unit_test_utils.get_fake_request(path)
     output = self.controller.index(request, filters={"is_public": False})
     self.assertEqual(2, len(output["images"]))
Ejemplo n.º 28
0
 def test_create_with_id(self):
     request = test_utils.FakeRequest()
     image_id = utils.generate_uuid()
     request.body = json.dumps({'id': image_id})
     output = self.deserializer.create(request)
     expected = {'image': {'id': image_id, 'properties': {}}}
     self.assertEqual(expected, output)
Ejemplo n.º 29
0
 def test_create_with_id(self):
     request = test_utils.FakeRequest()
     image_id = utils.generate_uuid()
     request.body = json.dumps({'id': image_id, 'name': 'image-1'})
     output = self.deserializer.create(request)
     self.assertEqual(output,
                      {'image': {'id': image_id, 'name': 'image-1'}})
Ejemplo n.º 30
0
 def test_index_with_marker_not_found(self):
     fake_uuid = utils.generate_uuid()
     path = '/images'
     request = unit_test_utils.get_fake_request(path)
     self.assertRaises(webob.exc.HTTPBadRequest,
                       self.controller.index,
                       request,
                       marker=fake_uuid)
Ejemplo n.º 31
0
 def test_index_with_many_filter(self):
     name = "My Little Image"
     instance_id = utils.generate_uuid()
     path = "/images?name=%(name)s&id=%(instance_id)s" % locals()
     request = unit_test_utils.get_fake_request(path)
     output = self.deserializer.index(request)
     self.assertEqual(output["filters"]["name"], name)
     self.assertEqual(output["filters"]["id"], instance_id)
Ejemplo n.º 32
0
 def test_image_member_delete(self):
     TENANT1 = utils.generate_uuid()
     fixture = {'member': TENANT1, 'image_id': UUID1}
     member = self.db_api.image_member_create(self.context, fixture)
     member = self.db_api.image_member_delete(self.context, member)
     self.assertNotEqual(None, member['deleted_at'])
     self.assertTrue(isinstance(member['deleted_at'], datetime.datetime))
     self.assertTrue(member['deleted'])
Ejemplo n.º 33
0
 def test_image_member_delete(self):
     TENANT1 = utils.generate_uuid()
     fixture = {'member': TENANT1, 'image_id': UUID1}
     member = self.db_api.image_member_create(self.context, fixture)
     member = self.db_api.image_member_delete(self.context, member)
     self.assertNotEqual(None, member['deleted_at'])
     self.assertTrue(isinstance(member['deleted_at'], datetime.datetime))
     self.assertTrue(member['deleted'])
Ejemplo n.º 34
0
 def test_index_with_many_filter(self):
     name = 'My Little Image'
     instance_id = utils.generate_uuid()
     path = '/images?name=%(name)s&id=%(instance_id)s' % locals()
     request = unit_test_utils.get_fake_request(path)
     output = self.deserializer.index(request)
     self.assertEqual(output['filters']['name'], name)
     self.assertEqual(output['filters']['id'], instance_id)
Ejemplo n.º 35
0
 def test_index_with_many_filter(self):
     name = 'My Little Image'
     instance_id = utils.generate_uuid()
     path = '/images?name=%(name)s&id=%(instance_id)s' % locals()
     request = unit_test_utils.get_fake_request(path)
     output = self.deserializer.index(request)
     self.assertEqual(output['filters']['name'], name)
     self.assertEqual(output['filters']['id'], instance_id)
 def test_create(self):
     fixture = {
         'image_id': test_utils.UUID1,
         'member': utils.generate_uuid(),
         'can_share': True,
     }
     req = test_utils.FakeRequest()
     output = self.controller.create(req, fixture)
     self.assertEqual(fixture, output)
Ejemplo n.º 37
0
 def test_index(self):
     marker = utils.generate_uuid()
     path = '/images?limit=1&marker=%s' % marker
     request = unit_test_utils.get_fake_request(path)
     expected = {'limit': 1,
                 'marker': marker,
                 'sort_key': 'created_at',
                 'sort_dir': 'desc'}
     output = self.deserializer.index(request)
     self.assertEqual(output, expected)
Ejemplo n.º 38
0
    def test_image_get_all_owned(self):
        TENANT1 = utils.generate_uuid()
        ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
        UUIDX = utils.generate_uuid()
        self.db_api.image_create(ctxt1, {'id': UUIDX,
                                         'status': 'queued',
                                         'owner': TENANT1})

        TENANT2 = utils.generate_uuid()
        ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
        UUIDY = utils.generate_uuid()
        self.db_api.image_create(ctxt2, {'id': UUIDY,
                                         'status': 'queued',
                                         'owner': TENANT2})

        images = self.db_api.image_get_all(ctxt1)
        image_ids = [image['id'] for image in images]
        expected = [UUIDX, UUID3, UUID2, UUID1]
        self.assertEqual(sorted(expected), sorted(image_ids))
Ejemplo n.º 39
0
 def test_get_remote_image(self):
     """Get an image that was created externally to Glance"""
     image_id = utils.generate_uuid()
     image_uri = self.stash_image(image_id, 'XXX')
     store = self.get_store()
     location = glance.store.location.Location(
         self.store_name, store.get_store_location_class(), uri=image_uri)
     (get_iter, get_size) = store.get(location)
     self.assertEqual('3', get_size)
     self.assertEqual('XXX', ''.join(get_iter))
Ejemplo n.º 40
0
    def test_image_get_all_owned(self):
        TENANT1 = utils.generate_uuid()
        ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
        UUIDX = utils.generate_uuid()
        self.db_api.image_create(ctxt1,
                {'id': UUIDX, 'status': 'queued', 'owner': TENANT1})

        TENANT2 = utils.generate_uuid()
        ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
        UUIDY = utils.generate_uuid()
        self.db_api.image_create(ctxt2,
                {'id': UUIDY, 'status': 'queued', 'owner': TENANT2})

        # NOTE(bcwaldon): the is_public=True flag indicates that you want
        # to get all images that are public AND those that are owned by the
        # calling context
        images = self.db_api.image_get_all(ctxt1, filters={'is_public': True})
        image_ids = [image['id'] for image in images]
        expected = [UUIDX, UUID3, UUID2, UUID1]
        self.assertEqual(sorted(expected), sorted(image_ids))
Ejemplo n.º 41
0
    def test_show_deleted_properties(self):
        """ Ensure that the api filters out deleted image properties. """

        # get the image properties into the odd state
        image = {"id": utils.generate_uuid(), "status": "active", "properties": {"poo": "bear"}}
        self.db.image_create(None, image)
        self.db.image_update(None, image["id"], {"properties": {"yin": "yang"}}, purge_props=True)

        request = unit_test_utils.get_fake_request()
        output = self.controller.show(request, image["id"])
        self.assertEqual(output["properties"], {"yin": "yang"})
Ejemplo n.º 42
0
 def test_index_with_non_default_is_public_filter(self):
     image = {
         'id': utils.generate_uuid(),
         'owner': TENANT3,
         'name': '3',
         'is_public': False
     }
     self.db.image_create(None, image)
     path = '/images?visibility=private'
     request = unit_test_utils.get_fake_request(path)
     output = self.controller.index(request, filters={'is_public': False})
     self.assertEqual(2, len(output['images']))
Ejemplo n.º 43
0
 def test_get_remote_image(self):
     """Get an image that was created externally to Glance"""
     image_id = utils.generate_uuid()
     image_uri = self.stash_image(image_id, 'XXX')
     store = self.get_store()
     location = glance.store.location.Location(
             self.store_name,
             store.get_store_location_class(),
             uri=image_uri)
     (get_iter, get_size) = store.get(location)
     self.assertEqual('3', get_size)
     self.assertEqual('XXX', ''.join(get_iter))
Ejemplo n.º 44
0
 def test_index_with_non_default_is_public_filter(self):
     image = {
         'id': utils.generate_uuid(),
         'owner': TENANT3,
         'name': '3',
         'is_public': False
     }
     self.db.image_create(None, image)
     path = '/images?visibility=private'
     request = unit_test_utils.get_fake_request(path)
     output = self.controller.index(request, filters={'is_public': False})
     self.assertEqual(2, len(output['images']))
Ejemplo n.º 45
0
 def test_index(self):
     marker = utils.generate_uuid()
     path = '/images?limit=1&marker=%s' % marker
     request = unit_test_utils.get_fake_request(path)
     expected = {
         'limit': 1,
         'marker': marker,
         'sort_key': 'created_at',
         'sort_dir': 'desc',
         'filters': {}
     }
     output = self.deserializer.index(request)
     self.assertEqual(output, expected)
Ejemplo n.º 46
0
    def test_image_member_create(self):
        memberships = self.db_api.image_member_find(self.context)
        #NOTE(bcwaldon): we do this magic to translate sqlalchemy models
        # into something usable.
        memberships = [(m['member'], m['image_id']) for m in memberships]
        self.assertEqual([], memberships)

        TENANT1 = utils.generate_uuid()
        self.db_api.image_member_create(self.context,
                                        {'member': TENANT1, 'image_id': UUID1})

        memberships = self.db_api.image_member_find(self.context)
        memberships = [(m['member'], m['image_id']) for m in memberships]
        self.assertEqual([(TENANT1, UUID1)], memberships)
Ejemplo n.º 47
0
 def test_create(self):
     member = utils.generate_uuid()
     fixture = {
         'member': member,
         'can_share': True,
     }
     expected = {
         'image_id': test_utils.UUID1,
         'member': member,
         'can_share': True,
         'deleted': False,
     }
     req = test_utils.FakeRequest()
     output = self.controller.create(req, test_utils.UUID1, fixture)
     self.assertEqual(expected, output)
Ejemplo n.º 48
0
    def _do_test_add_failure(self, errno, exception):
        ChunkedFile.CHUNKSIZE = 1024
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        def fake_IO_Error(size):
            e = IOError()
            e.errno = errno
            raise e

        self.stubs.Set(image_file, 'read', fake_IO_Error)
        self.assertRaises(exception, self.store.add, image_id, image_file, 0)
Ejemplo n.º 49
0
    def _do_test_add_failure(self, errno, exception):
        ChunkedFile.CHUNKSIZE = 1024
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        def fake_IO_Error(size):
            e = IOError()
            e.errno = errno
            raise e

        self.stubs.Set(image_file, "read", fake_IO_Error)
        self.assertRaises(exception, self.store.add, image_id, image_file, 0)
Ejemplo n.º 50
0
    def test_add_already_existing(self):
        """
        Tests that adding an image with an existing identifier
        raises an appropriate exception
        """
        ChunkedFile.CHUNKSIZE = 1024
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        location, size, checksum = self.store.add(image_id, image_file, file_size)
        image_file = StringIO.StringIO("nevergonnamakeit")
        self.assertRaises(exception.Duplicate, self.store.add, image_id, image_file, 0)
Ejemplo n.º 51
0
    def test_image_member_create(self):
        memberships = self.db_api.image_member_find(self.context)
        #NOTE(bcwaldon): we do this magic to translate sqlalchemy models
        # into something usable.
        memberships = [(m['member'], m['image_id']) for m in memberships]
        self.assertEqual([], memberships)

        TENANT1 = utils.generate_uuid()
        self.db_api.image_member_create(self.context, {
            'member': TENANT1,
            'image_id': UUID1
        })

        memberships = self.db_api.image_member_find(self.context)
        memberships = [(m['member'], m['image_id']) for m in memberships]
        self.assertEqual([(TENANT1, UUID1)], memberships)
Ejemplo n.º 52
0
    def test_add_already_existing(self):
        """
        Tests that adding an image with an existing identifier
        raises an appropriate exception
        """
        ChunkedFile.CHUNKSIZE = 1024
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        location, size, checksum = self.store.add(image_id, image_file,
                                                  file_size)
        image_file = StringIO.StringIO("nevergonnamakeit")
        self.assertRaises(exception.Duplicate, self.store.add, image_id,
                          image_file, 0)
Ejemplo n.º 53
0
    def test_image_paginate(self):
        """Paginate through a list of images using limit and marker"""
        extra_uuids = [utils.generate_uuid() for i in range(2)]
        extra_images = [build_image_fixture(id=_id) for _id in extra_uuids]
        self.create_images(extra_images)

        # Reverse uuids to match default sort of created_at
        extra_uuids.reverse()

        page = self.db_api.image_get_all(self.context, limit=2)
        self.assertEquals(extra_uuids, [i['id'] for i in page])
        last = page[-1]['id']

        page = self.db_api.image_get_all(self.context, limit=2, marker=last)
        self.assertEquals([UUID3, UUID2], [i['id'] for i in page])

        page = self.db_api.image_get_all(self.context, limit=2, marker=UUID2)
        self.assertEquals([UUID1], [i['id'] for i in page])
Ejemplo n.º 54
0
    def test_add_storage_full(self):
        """
        Tests that adding an image without enough space on disk
        raises an appropriate exception
        """
        ChunkedFile.CHUNKSIZE = 1024
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        def fake_IO_Error(size):
            raise IOError

        self.stubs.Set(image_file, 'read', fake_IO_Error)
        self.assertRaises(exception.StorageFull, self.store.add, image_id,
                          image_file, 0)
Ejemplo n.º 55
0
    def test_image_member_create(self):
        memberships = self.db_api.image_member_find(self.context)
        self.assertEqual([], memberships)

        TENANT1 = utils.generate_uuid()
        self.db_api.image_member_create(self.context, {
            'member': TENANT1,
            'image_id': UUID1
        })

        memberships = self.db_api.image_member_find(self.context)
        self.assertEqual(1, len(memberships))
        actual = memberships[0]
        actual.pop('id')
        expected = {
            'member': TENANT1,
            'image_id': UUID1,
            'can_share': False,
        }
        self.assertEqual(expected, actual)
Ejemplo n.º 56
0
    def test_delete(self):
        """
        Test we can delete an existing image in the filesystem store
        """
        # First add an image
        image_id = utils.generate_uuid()
        file_size = 1024 * 5  # 5K
        file_contents = "*" * file_size
        location = "file://%s/%s" % (self.test_dir, image_id)
        image_file = StringIO.StringIO(file_contents)

        location, size, checksum = self.store.add(image_id, image_file,
                                                  file_size)

        # Now check that we can delete it
        uri = "file:///%s/%s" % (self.test_dir, image_id)
        loc = get_location_from_uri(uri)
        self.store.delete(loc)

        self.assertRaises(exception.NotFound, self.store.get, loc)
    def test_add_host_variations(self):
        """
        Test that having http(s):// in the s3serviceurl in config
        options works as expected.
        """
        variations = [
            'http://localhost:80', 'http://localhost', 'http://localhost/v1',
            'http://localhost/v1/', 'https://localhost',
            'https://localhost:8080', 'https://localhost/v1',
            'https://localhost/v1/', 'localhost', 'localhost:8080/v1'
        ]
        for variation in variations:
            expected_image_id = utils.generate_uuid()
            expected_s3_size = FIVE_KB
            expected_s3_contents = "*" * expected_s3_size
            expected_checksum = \
                    hashlib.md5(expected_s3_contents).hexdigest()
            new_conf = S3_CONF.copy()
            new_conf['s3_store_host'] = variation
            expected_location = format_s3_location(
                new_conf['s3_store_access_key'],
                new_conf['s3_store_secret_key'], new_conf['s3_store_host'],
                new_conf['s3_store_bucket'], expected_image_id)
            image_s3 = StringIO.StringIO(expected_s3_contents)

            self.store = Store(test_utils.TestConfigOpts(new_conf))
            location, size, checksum = self.store.add(expected_image_id,
                                                      image_s3,
                                                      expected_s3_size)

            self.assertEquals(expected_location, location)
            self.assertEquals(expected_s3_size, size)
            self.assertEquals(expected_checksum, checksum)

            loc = get_location_from_uri(expected_location)
            (new_image_s3, new_image_size) = self.store.get(loc)
            new_image_contents = new_image_s3.getvalue()
            new_image_s3_size = len(new_image_s3)

            self.assertEquals(expected_s3_contents, new_image_contents)
            self.assertEquals(expected_s3_size, new_image_s3_size)
Ejemplo n.º 58
0
def build_image_fixture(**kwargs):
    default_datetime = datetime.datetime.now()
    image = {
        'id': utils.generate_uuid(),
        'name': 'fake image #2',
        'status': 'active',
        'disk_format': 'vhd',
        'container_format': 'ovf',
        'is_public': True,
        'created_at': default_datetime,
        'updated_at': default_datetime,
        'deleted_at': None,
        'deleted': False,
        'checksum': None,
        'min_disk': 5,
        'min_ram': 256,
        'size': 19,
        'location': "file:///tmp/glance-tests/2",
        'properties': {},
    }
    image.update(kwargs)
    return image
Ejemplo n.º 59
0
    def test_image_member_update(self):
        TENANT1 = utils.generate_uuid()
        member = self.db_api.image_member_create(self.context, {
            'member': TENANT1,
            'image_id': UUID1
        })
        member_id = member.pop('id')

        expected = {'member': TENANT1, 'image_id': UUID1, 'can_share': False}
        self.assertEqual(expected, member)

        member = self.db_api.image_member_update(self.context, member_id,
                                                 {'can_share': True})

        member.pop('id')
        expected = {'member': TENANT1, 'image_id': UUID1, 'can_share': True}
        self.assertEqual(expected, member)

        members = self.db_api.image_member_find(self.context,
                                                member=TENANT1,
                                                image_id=UUID1)
        member = members[0]
        member.pop('id')
        self.assertEqual(expected, member)