From 4f6f1888dba4a31827b0b217e00487071e186e00 Mon Sep 17 00:00:00 2001 From: Josh Durgin Date: Tue, 14 Aug 2012 12:27:48 -0700 Subject: [PATCH] add ability to clone images Given the backend location from Glance, drivers can determine whether they can clone or otherwise efficiently create a volume from the image without downloading all the data from Glance. For now implement cloning for the RBD driver. There's already a Glance backend that stores images as RBD snapshots, so they're ready to be cloned into volumes. Fall back to copying all the data if cloning is not possible. Implements: blueprint efficient-volumes-from-images Signed-off-by: Josh Durgin Conflicts: nova/volume/api.py nova/volume/driver.py This is based on a cherry-pick of cinder commit edc11101cbc06bdce95b10cfd00a4849f6c01b33 Change-Id: I71a8172bd22a5bbf64d4c68631630125fcc7fd34 --- nova/tests/test_rbd.py | 161 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 nova/tests/test_rbd.py diff --git a/nova/tests/test_rbd.py b/nova/tests/test_rbd.py new file mode 100644 index 000000000..8e90f3ae8 --- /dev/null +++ b/nova/tests/test_rbd.py @@ -0,0 +1,161 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2012 Josh Durgin +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from nova import db +from nova import exception +from nova.openstack.common import log as logging +from nova.openstack.common import timeutils +from nova import test +from nova.tests.image import fake as fake_image +from nova.tests.test_volume import DriverTestCase +from nova.volume.driver import RBDDriver + +LOG = logging.getLogger(__name__) + + +class RBDTestCase(test.TestCase): + + def setUp(self): + super(RBDTestCase, self).setUp() + + def fake_execute(*args): + pass + self.driver = RBDDriver(execute=fake_execute) + + def test_good_locations(self): + locations = [ + 'rbd://fsid/pool/image/snap', + 'rbd://%2F/%2F/%2F/%2F', + ] + map(self.driver._parse_location, locations) + + def test_bad_locations(self): + locations = [ + 'rbd://image', + 'http://path/to/somewhere/else', + 'rbd://image/extra', + 'rbd://image/', + 'rbd://fsid/pool/image/', + 'rbd://fsid/pool/image/snap/', + 'rbd://///', + ] + for loc in locations: + self.assertRaises(exception.ImageUnacceptable, + self.driver._parse_location, + loc) + self.assertFalse(self.driver._is_cloneable(loc)) + + def test_cloneable(self): + self.stubs.Set(self.driver, '_get_fsid', lambda: 'abc') + location = 'rbd://abc/pool/image/snap' + self.assertTrue(self.driver._is_cloneable(location)) + + def test_uncloneable_different_fsid(self): + self.stubs.Set(self.driver, '_get_fsid', lambda: 'abc') + location = 'rbd://def/pool/image/snap' + self.assertFalse(self.driver._is_cloneable(location)) + + def test_uncloneable_unreadable(self): + def fake_exc(*args): + raise exception.ProcessExecutionError() + self.stubs.Set(self.driver, '_get_fsid', lambda: 'abc') + self.stubs.Set(self.driver, '_execute', fake_exc) + location = 'rbd://abc/pool/image/snap' + self.assertFalse(self.driver._is_cloneable(location)) + + +class FakeRBDDriver(RBDDriver): + + def _clone(self): + pass + + def _resize(self): + pass + + +class ManagedRBDTestCase(DriverTestCase): + driver_name = "nova.tests.test_rbd.FakeRBDDriver" + + def setUp(self): + super(ManagedRBDTestCase, self).setUp() + fake_image.stub_out_image_service(self.stubs) + + def _clone_volume_from_image(self, expected_status, + clone_works=True): + """Try to clone a volume from an image, and check the status + afterwards""" + def fake_clone_image(volume, image_location): + pass + + def fake_clone_error(volume, image_location): + raise exception.NovaException() + + self.stubs.Set(self.volume.driver, '_is_cloneable', lambda x: True) + if clone_works: + self.stubs.Set(self.volume.driver, 'clone_image', fake_clone_image) + else: + self.stubs.Set(self.volume.driver, 'clone_image', fake_clone_error) + + image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77' + volume_id = 1 + # creating volume testdata + db.volume_create(self.context, {'id': volume_id, + 'updated_at': timeutils.utcnow(), + 'display_description': 'Test Desc', + 'size': 20, + 'status': 'creating', + 'instance_uuid': None, + 'host': 'dummy'}) + try: + if clone_works: + self.volume.create_volume(self.context, + volume_id, + image_id=image_id) + else: + self.assertRaises(exception.NovaException, + self.volume.create_volume, + self.context, + volume_id, + image_id=image_id) + + volume = db.volume_get(self.context, volume_id) + self.assertEqual(volume['status'], expected_status) + finally: + # cleanup + db.volume_destroy(self.context, volume_id) + + def test_clone_image_status_available(self): + """Verify that before cloning, an image is in the available state.""" + self._clone_volume_from_image('available', True) + + def test_clone_image_status_error(self): + """Verify that before cloning, an image is in the available state.""" + self._clone_volume_from_image('error', False) + + def test_clone_success(self): + self.stubs.Set(self.volume.driver, '_is_cloneable', lambda x: True) + self.stubs.Set(self.volume.driver, 'clone_image', lambda a, b: True) + image_id = 'c905cedb-7281-47e4-8a62-f26bc5fc4c77' + self.assertTrue(self.volume.driver.clone_image({}, image_id)) + + def test_clone_bad_image_id(self): + self.stubs.Set(self.volume.driver, '_is_cloneable', lambda x: True) + self.assertFalse(self.volume.driver.clone_image({}, None)) + + def test_clone_uncloneable(self): + self.stubs.Set(self.volume.driver, '_is_cloneable', lambda x: False) + self.assertFalse(self.volume.driver.clone_image({}, 'dne'))