def test_show(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get())
     req = webob.Request.blank("/v3/servers/1")
     req.headers["Content-Type"] = "application/json"
     response = req.get_response(fakes.wsgi_app_v3(init_only=("servers", "os-config-drive")))
     self.assertEqual(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertIn(config_drive.ATTRIBUTE_NAME, res_dict["server"])
Beispiel #2
0
 def test_get_server_by_id_verify_security_groups_json(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get())
     req = webob.Request.blank("/v2/fake/os-create-server-ext/1")
     req.headers["Content-Type"] = "application/json"
     response = req.get_response(fakes.wsgi_app(init_only=("os-create-server-ext", "servers")))
     self.assertEqual(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     expected_security_group = [{"name": "test"}]
     self.assertEqual(res_dict["server"].get("security_groups"), expected_security_group)
Beispiel #3
0
 def test_show_server(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get())
     req = webob.Request.blank("/v3/servers/1")
     req.headers["Content-Type"] = "application/json"
     response = req.get_response(self.app)
     self.assertEqual(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertIn("key_name", res_dict["server"])
     self.assertEqual(res_dict["server"]["key_name"], "")
Beispiel #4
0
 def test_show(self):
     self.stubs.Set(db, 'instance_get',
                     fakes.fake_instance_get())
     self.stubs.Set(db, 'instance_get_by_uuid',
                     fakes.fake_instance_get())
     req = webob.Request.blank('/v2/fake/servers/1')
     req.headers['Content-Type'] = 'application/json'
     response = req.get_response(fakes.wsgi_app(init_only=('servers',)))
     self.assertEquals(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertIn('config_drive', res_dict['server'])
Beispiel #5
0
 def test_show(self):
     self.stubs.Set(db, 'instance_get',
                     fakes.fake_instance_get())
     self.stubs.Set(db, 'instance_get_by_uuid',
                     fakes.fake_instance_get())
     req = webob.Request.blank(self.base_url + '1')
     req.headers['Content-Type'] = 'application/json'
     response = req.get_response(self.app)
     self.assertEqual(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertIn('config_drive', res_dict['server'])
 def test_get_server_by_id_verify_security_groups_json(self):
     self.stubs.Set(db, 'instance_get', fakes.fake_instance_get())
     self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get())
     req = webob.Request.blank('/v2/fake/os-create-server-ext/1')
     req.headers['Content-Type'] = 'application/json'
     response = req.get_response(fakes.wsgi_app(
         init_only=('os-create-server-ext', 'servers')))
     self.assertEquals(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     expected_security_group = [{"name": "test"}]
     self.assertEquals(res_dict['server'].get('security_groups'),
                       expected_security_group)
 def test_show_server(self):
     self.stubs.Set(db, 'instance_get',
                     fakes.fake_instance_get())
     self.stubs.Set(db, 'instance_get_by_uuid',
                     fakes.fake_instance_get())
     req = webob.Request.blank('/v3/servers/1')
     req.headers['Content-Type'] = 'application/json'
     response = req.get_response(self.app)
     self.assertEquals(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertTrue('key_name' in res_dict['server'])
     self.assertEquals(res_dict['server']['key_name'], '')
Beispiel #8
0
 def test_get_server_by_id_verify_security_groups_xml(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get())
     req = webob.Request.blank("/v2/fake/os-create-server-ext/1")
     req.headers["Accept"] = "application/xml"
     response = req.get_response(fakes.wsgi_app(init_only=("os-create-server-ext", "servers")))
     self.assertEqual(response.status_int, 200)
     dom = minidom.parseString(response.body)
     server = dom.childNodes[0]
     sec_groups = server.getElementsByTagName("security_groups")[0]
     sec_group = sec_groups.getElementsByTagName("security_group")[0]
     self.assertEqual("test", sec_group.getAttribute("name"))
 def test_get_server_by_id_verify_security_groups_xml(self):
     self.stubs.Set(db, 'instance_get', fakes.fake_instance_get())
     self.stubs.Set(db, 'instance_get_by_uuid', fakes.fake_instance_get())
     req = webob.Request.blank('/v2/fake/os-create-server-ext/1')
     req.headers['Accept'] = 'application/xml'
     response = req.get_response(fakes.wsgi_app(
         init_only=('os-create-server-ext', 'servers')))
     self.assertEquals(response.status_int, 200)
     dom = minidom.parseString(response.body)
     server = dom.childNodes[0]
     sec_groups = server.getElementsByTagName('security_groups')[0]
     sec_group = sec_groups.getElementsByTagName('security_group')[0]
     self.assertEqual('test', sec_group.getAttribute("name"))
Beispiel #10
0
    def setUp(self):
        super(ServerActionsControllerTest, self).setUp()

        self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get(vm_state=vm_states.ACTIVE, host="fake_host"))
        self.stubs.Set(db, "instance_update_and_get_original", instance_update_and_get_original)

        fakes.stub_out_glance(self.stubs)
        fakes.stub_out_nw_api(self.stubs)
        fakes.stub_out_compute_api_snapshot(self.stubs)
        fake.stub_out_image_service(self.stubs)
        service_class = "nova.image.glance.GlanceImageService"
        self.service = importutils.import_object(service_class)
        self.sent_to_glance = {}
        fakes.stub_out_glanceclient_create(self.stubs, self.sent_to_glance)
        self.flags(allow_instance_snapshots=True, enable_instance_password=True)
        self.uuid = FAKE_UUID
        self.url = "/v2/fake/servers/%s/action" % self.uuid
        self._image_href = "155d900f-4e14-4e4c-a73d-069cbf4541e6"

        class FakeExtManager(object):
            def is_loaded(self, ext):
                return False

        self.controller = servers.Controller(ext_mgr=FakeExtManager())
        self.compute_api = self.controller.compute_api
        self.context = context.RequestContext("fake", "fake")
        self.app = fakes.wsgi_app(init_only=("servers",), fake_auth_context=self.context)
Beispiel #11
0
    def _test_rebuild_preserve_ephemeral(self, value=None):
        def fake_is_loaded(ext):
            return ext == "os-preserve-ephemeral-rebuild"

        self.stubs.Set(self.controller.ext_mgr, "is_loaded", fake_is_loaded)

        return_server = fakes.fake_instance_get(image_ref="2", vm_state=vm_states.ACTIVE, host="fake_host")
        self.stubs.Set(db, "instance_get_by_uuid", return_server)

        body = {"rebuild": {"imageRef": self._image_href}}
        if value is not None:
            body["rebuild"]["preserve_ephemeral"] = value

        req = fakes.HTTPRequest.blank(self.url)
        context = req.environ["nova.context"]

        self.mox.StubOutWithMock(compute_api.API, "rebuild")

        if value is not None:
            compute_api.API.rebuild(
                context,
                mox.IgnoreArg(),
                self._image_href,
                mox.IgnoreArg(),
                preserve_ephemeral=value,
                files_to_inject=None,
            )
        else:
            compute_api.API.rebuild(context, mox.IgnoreArg(), self._image_href, mox.IgnoreArg(), files_to_inject=None)
        self.mox.ReplayAll()

        self.controller._action_rebuild(req, FAKE_UUID, body)
Beispiel #12
0
 def setUp(self):
     super(ServerUsageTest, self).setUp()
     fakes.stub_out_nw_api(self.stubs)
     self.stubs.Set(compute.api.API, 'get', fake_compute_get)
     self.stubs.Set(compute.api.API, 'get_all', fake_compute_get_all)
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, 'instance_get_by_uuid', return_server)
    def setUp(self):
        self.maxDiff = None
        super(ServerActionsControllerTest, self).setUp()

        self.stubs = stubout.StubOutForTesting()
        fakes.stub_out_auth(self.stubs)
        self.stubs.Set(nova.db, 'instance_get_by_uuid',
                fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
                        host='fake_host'))
        self.stubs.Set(nova.db, 'instance_update', instance_update)

        fakes.stub_out_glance(self.stubs)
        fakes.stub_out_nw_api(self.stubs)
        fakes.stub_out_rate_limiting(self.stubs)
        fakes.stub_out_compute_api_snapshot(self.stubs)
        fakes.stub_out_image_service(self.stubs)
        service_class = 'nova.image.glance.GlanceImageService'
        self.service = utils.import_object(service_class)
        self.context = context.RequestContext(1, None)
        self.service.delete_all()
        self.sent_to_glance = {}
        fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
        self.flags(allow_instance_snapshots=True,
                   enable_instance_password=True)
        self.uuid = FAKE_UUID
        self.url = '/v2/fake/servers/%s/action' % self.uuid
        self._image_href = '155d900f-4e14-4e4c-a73d-069cbf4541e6'

        self.controller = servers.Controller()
Beispiel #14
0
 def test_detail_servers(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     req = fakes.HTTPRequest.blank("/v2/fake/servers/detail")
     res = req.get_response(fakes.wsgi_app())
     server_dicts = jsonutils.loads(res.body)["servers"]
     for server_dict in server_dicts:
         self.asserTrue("config_drive" in server_dict)
Beispiel #15
0
 def setUp(self):
     super(ExtendedStatusTest, self).setUp()
     fakes.stub_out_nw_api(self.stubs)
     self.stubs.Set(compute.api.API, "get", fake_compute_get)
     self.stubs.Set(compute.api.API, "get_all", fake_compute_get_all)
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, "instance_get_by_uuid", return_server)
Beispiel #16
0
    def setUp(self):
        super(ServerActionsControllerTest, self).setUp()

        self.stubs.Set(nova.db, 'instance_get_by_uuid',
                       fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
                                               host='fake_host'))
        self.stubs.Set(nova.db, 'instance_update_and_get_original',
                       instance_update)

        fakes.stub_out_glance(self.stubs)
        fakes.stub_out_nw_api(self.stubs)
        fakes.stub_out_rate_limiting(self.stubs)
        fakes.stub_out_compute_api_snapshot(self.stubs)
        nova.tests.image.fake.stub_out_image_service(self.stubs)
        service_class = 'nova.image.glance.GlanceImageService'
        self.service = importutils.import_object(service_class)
        self.sent_to_glance = {}
        fakes.stub_out_glanceclient_create(self.stubs, self.sent_to_glance)
        self.flags(allow_instance_snapshots=True,
                   enable_instance_password=True)
        self.uuid = FAKE_UUID
        self.url = '/v2/fake/servers/%s/action' % self.uuid
        self._image_href = '155d900f-4e14-4e4c-a73d-069cbf4541e6'

        self.controller = servers.Controller()
    def _test_rebuild_preserve_ephemeral(self, value=None):
        return_server = fakes.fake_instance_get(image_ref='2',
                                                vm_state=vm_states.ACTIVE,
                                                host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)

        body = {
            "rebuild": {
                "imageRef": self._image_href,
            },
        }
        if value is not None:
            body['rebuild']['preserve_ephemeral'] = value

        req = fakes.HTTPRequestV3.blank(self.url)
        context = req.environ['nova.context']

        self.mox.StubOutWithMock(compute_api.API, 'rebuild')
        if value is not None:
            compute_api.API.rebuild(context, mox.IgnoreArg(), self._image_href,
                                    mox.IgnoreArg(), preserve_ephemeral=value)
        else:
            compute_api.API.rebuild(context, mox.IgnoreArg(), self._image_href,
                                    mox.IgnoreArg())
        self.mox.ReplayAll()

        self.controller._action_rebuild(req, FAKE_UUID, body=body)
 def test_reboot_hard_with_soft_in_progress_does_not_raise(self):
     body = dict(reboot=dict(type="HARD"))
     req = fakes.HTTPRequestV3.blank(self.url)
     self.stubs.Set(db, 'instance_get_by_uuid',
                    fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
                                     task_state=task_states.REBOOTING))
     self.controller._action_reboot(req, FAKE_UUID, body)
    def setUp(self):
        super(ServerActionsControllerTest, self).setUp()

        CONF.set_override('host', 'localhost', group='glance')
        self.stubs.Set(db, 'instance_get_by_uuid',
                       fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
                                               host='fake_host'))
        self.stubs.Set(db, 'instance_update_and_get_original',
                       instance_update_and_get_original)

        fakes.stub_out_nw_api(self.stubs)
        fakes.stub_out_compute_api_snapshot(self.stubs)
        fake.stub_out_image_service(self.stubs)
        self.flags(allow_instance_snapshots=True,
                   enable_instance_password=True)
        self.uuid = FAKE_UUID
        self.url = '/servers/%s/action' % self.uuid
        self._image_href = '155d900f-4e14-4e4c-a73d-069cbf4541e6'

        ext_info = plugins.LoadedExtensionInfo()
        self.controller = servers.ServersController(extension_info=ext_info)
        self.compute_api = self.controller.compute_api
        self.context = context.RequestContext('fake', 'fake')
        self.app = fakes.wsgi_app_v3(init_only=('servers',),
                                     fake_auth_context=self.context)
Beispiel #20
0
    def _test_create_volume_backed_image_with_metadata_from_volume(self, extra_metadata=None):
        def _fake_id(x):
            return "%s-%s-%s-%s" % (x * 8, x * 4, x * 4, x * 12)

        body = dict(create_image=dict(name="snapshot_of_volume_backed"))
        if extra_metadata:
            body["create_image"]["metadata"] = extra_metadata

        image_service = glance.get_default_image_service()

        def fake_block_device_mapping_get_all_by_instance(context, inst_id, use_slave=False):
            return [
                fake_block_device.FakeDbBlockDeviceDict(
                    {
                        "volume_id": _fake_id("a"),
                        "source_type": "snapshot",
                        "destination_type": "volume",
                        "volume_size": 1,
                        "device_name": "vda",
                        "snapshot_id": 1,
                        "boot_index": 0,
                        "delete_on_termination": False,
                        "no_device": None,
                    }
                )
            ]

        self.stubs.Set(db, "block_device_mapping_get_all_by_instance", fake_block_device_mapping_get_all_by_instance)

        instance = fakes.fake_instance_get(image_ref="", vm_state=vm_states.ACTIVE, root_device_name="/dev/vda")
        self.stubs.Set(db, "instance_get_by_uuid", instance)

        fake_metadata = {"test_key1": "test_value1", "test_key2": "test_value2"}
        volume = dict(
            id=_fake_id("a"), size=1, host="fake", display_description="fake", volume_image_metadata=fake_metadata
        )
        snapshot = dict(id=_fake_id("d"))
        self.mox.StubOutWithMock(self.controller.compute_api, "volume_api")
        volume_api = self.controller.compute_api.volume_api
        volume_api.get(mox.IgnoreArg(), volume["id"]).AndReturn(volume)
        volume_api.get(mox.IgnoreArg(), volume["id"]).AndReturn(volume)
        volume_api.create_snapshot_force(mox.IgnoreArg(), volume["id"], mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(
            snapshot
        )

        req = fakes.HTTPRequestV3.blank(self.url)

        self.mox.ReplayAll()
        response = self.controller._action_create_image(req, FAKE_UUID, body)
        location = response.headers["Location"]
        image_id = location.replace("http://localhost:9292/images/", "")
        image = image_service.show(None, image_id)

        properties = image["properties"]
        self.assertEqual(properties["test_key1"], "test_value1")
        self.assertEqual(properties["test_key2"], "test_value2")
        if extra_metadata:
            for key, val in extra_metadata.items():
                self.assertEqual(properties[key], val)
Beispiel #21
0
 def setUp(self):
     super(ExtendedStatusTestV21, self).setUp()
     fakes.stub_out_nw_api(self.stubs)
     self.stubs.Set(compute.api.API, 'get', fake_compute_get)
     self.stubs.Set(compute.api.API, 'get_all', fake_compute_get_all)
     self._set_flags()
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, 'instance_get_by_uuid', return_server)
Beispiel #22
0
 def test_show(self):
     self.stubs.Set(db, "instance_get", fakes.fake_instance_get())
     req = webob.Request.blank("/v2/fake/servers/1")
     req.headers["Content-Type"] = "application/json"
     response = req.get_response(fakes.wsgi_app())
     self.assertEquals(response.status_int, 200)
     res_dict = jsonutils.loads(response.body)
     self.assertTrue("config_drive" in res_dict["server"])
Beispiel #23
0
 def test_detail_servers(self):
     self.stubs.Set(db, 'instance_get',
                     fakes.fake_instance_get())
     req = fakes.HTTPRequest.blank('/v2/fake/servers/detail')
     res = req.get_response(fakes.wsgi_app(init_only=('servers,')))
     server_dicts = jsonutils.loads(res.body)['servers']
     for server_dict in server_dicts:
         self.asserTrue('config_drive' in server_dict)
 def test_reboot_hard_with_hard_in_progress_raises_conflict(self):
     body = dict(reboot=dict(type="HARD"))
     req = fakes.HTTPRequestV3.blank(self.url)
     self.stubs.Set(db, 'instance_get_by_uuid',
                    fakes.fake_instance_get(vm_state=vm_states.ACTIVE,
                                     task_state=task_states.REBOOTING_HARD))
     self.assertRaises(webob.exc.HTTPConflict,
                       self.controller._action_reboot,
                       req, FAKE_UUID, body)
 def setUp(self):
     super(HideServerAddressesTest, self).setUp()
     fakes.stub_out_nw_api(self.stubs)
     self.flags(
         osapi_compute_extension=[
             'nova.api.openstack.compute.contrib.select_extensions'],
         osapi_compute_ext_list=['Hide_server_addresses'])
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, 'instance_get_by_uuid', return_server)
 def test_detail_servers(self):
     self.stubs.Set(db, "instance_get_all_by_filters", fakes.fake_instance_get_all_by_filters())
     self.stubs.Set(db, "instance_get_by_uuid", fakes.fake_instance_get())
     req = fakes.HTTPRequestV3.blank("/v3/servers/detail")
     res = req.get_response(fakes.wsgi_app_v3(init_only=("servers", "os-config-drive")))
     server_dicts = jsonutils.loads(res.body)["servers"]
     self.assertNotEqual(len(server_dicts), 0)
     for server_dict in server_dicts:
         self.assertIn(config_drive.ATTRIBUTE_NAME, server_dict)
 def setUp(self):
     super(ExtendedServerAttributesTest, self).setUp()
     availability_zones.reset_cache()
     fakes.stub_out_nw_api(self.stubs)
     self.stubs.Set(compute.api.API, "get", fake_compute_get)
     self.stubs.Set(compute.api.API, "get_all", fake_compute_get_all)
     self.stubs.Set(availability_zones, "get_host_availability_zone", fake_get_host_availability_zone)
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, "instance_get_by_uuid", return_server)
Beispiel #28
0
    def test_create_volume_backed_image_with_metadata_from_volume(self):

        def _fake_id(x):
            return '%s-%s-%s-%s' % (x * 8, x * 4, x * 4, x * 12)

        body = dict(create_image=dict(name='snapshot_of_volume_backed'))

        image_service = glance.get_default_image_service()

        def fake_block_device_mapping_get_all_by_instance(context, inst_id,
                                                          use_slave=False):
            return [fake_block_device.FakeDbBlockDeviceDict(
                        {'volume_id': _fake_id('a'),
                         'source_type': 'snapshot',
                         'destination_type': 'volume',
                         'volume_size': 1,
                         'device_name': 'vda',
                         'snapshot_id': 1,
                         'boot_index': 0,
                         'delete_on_termination': False,
                         'no_device': None})]

        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
                       fake_block_device_mapping_get_all_by_instance)

        instance = fakes.fake_instance_get(image_ref='',
                                           vm_state=vm_states.ACTIVE,
                                           root_device_name='/dev/vda')
        self.stubs.Set(db, 'instance_get_by_uuid', instance)

        fake_metadata = {'test_key1': 'test_value1',
                         'test_key2': 'test_value2'}
        volume = dict(id=_fake_id('a'),
                      size=1,
                      host='fake',
                      display_description='fake',
                      volume_image_metadata=fake_metadata)
        snapshot = dict(id=_fake_id('d'))
        self.mox.StubOutWithMock(self.controller.compute_api, 'volume_api')
        volume_api = self.controller.compute_api.volume_api
        volume_api.get(mox.IgnoreArg(), volume['id']).AndReturn(volume)
        volume_api.get(mox.IgnoreArg(), volume['id']).AndReturn(volume)
        volume_api.create_snapshot_force(mox.IgnoreArg(), volume['id'],
               mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(snapshot)

        req = fakes.HTTPRequestV3.blank(self.url)

        self.mox.ReplayAll()
        response = self.controller._action_create_image(req, FAKE_UUID, body)
        location = response.headers['Location']
        image_id = location.replace('http://localhost:9292/images/', '')
        image = image_service.show(None, image_id)

        properties = image['properties']
        self.assertEqual(properties['test_key1'], 'test_value1')
        self.assertEqual(properties['test_key2'], 'test_value2')
 def setUp(self):
     super(ExtendedAvailabilityZoneTestV21, self).setUp()
     availability_zones.reset_cache()
     fakes.stub_out_nw_api(self.stubs)
     self.stubs.Set(compute.api.API, 'get', fake_compute_get)
     self.stubs.Set(compute.api.API, 'get_all', fake_compute_get_all)
     self.stubs.Set(availability_zones, 'get_host_availability_zone',
                    fake_get_host_availability_zone)
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, 'instance_get_by_uuid', return_server)
Beispiel #30
0
    def test_detail_servers(self):
        self.stubs.Set(db, 'instance_get',
                        fakes.fake_instance_get())
        req = fakes.HTTPRequest.blank('/v2/fake/servers/detail')
        res = req.get_response(fakes.wsgi_app())
        server_dicts = jsonutils.loads(res.body)['servers']

        for server_dict in server_dicts:
            self.asserTrue('key_name' in server_dict)
            self.assertEquals(server_dict['key_name'], '')
    def test_rebuild_admin_password(self):
        return_server = fakes.fake_instance_get(image_ref='2',
                vm_state=vm_states.ACTIVE, host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)

        body = {
            "rebuild": {
                "image_ref": self._image_href,
                "admin_password": "******",
            },
        }

        req = fakes.HTTPRequestV3.blank(self.url)
        body = self.controller._action_rebuild(req, FAKE_UUID, body=body).obj

        self.assertEqual(body['server']['image']['id'], '2')
        self.assertEqual(body['server']['admin_password'], 'asdf')
Beispiel #32
0
    def test_rebuild_accepted_with_metadata(self):
        metadata = {'new': 'metadata'}

        return_server = fakes.fake_instance_get(metadata=metadata,
                vm_state=vm_states.ACTIVE, host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)

        body = {
            "rebuild": {
                "imageRef": self._image_href,
                "metadata": metadata,
            },
        }

        req = fakes.HTTPRequest.blank(self.url)
        body = self.controller._action_rebuild(req, FAKE_UUID, body).obj

        self.assertEqual(body['server']['metadata'], metadata)
    def test_rebuild_instance_with_image_href_uses_uuid(self):
        info = dict(image_href_in_call=None)

        def rebuild(self2, context, instance, image_href, *args, **kwargs):
            info['image_href_in_call'] = image_href

        self.stubs.Set(db, 'instance_get',
                fakes.fake_instance_get(vm_state=vm_states.ACTIVE))
        self.stubs.Set(compute_api.API, 'rebuild', rebuild)

        body = {
            'rebuild': {
                'imageRef': self.image_href,
            },
        }

        req = fakes.HTTPRequestV3.blank('/v2/fake/servers/a/action')
        self.controller._action_rebuild(req, FAKE_UUID, body=body)
        self.assertEqual(info['image_href_in_call'], self.image_uuid)
Beispiel #34
0
    def test_rebuild_accepted_minimum(self):
        return_server = fakes.fake_instance_get(image_ref='2',
                vm_state=vm_states.ACTIVE, host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)
        self_href = 'http://localhost/v2/fake/servers/%s' % FAKE_UUID

        body = {
            "rebuild": {
                "imageRef": self._image_href,
            },
        }

        req = fakes.HTTPRequest.blank(self.url)
        robj = self.controller._action_rebuild(req, FAKE_UUID, body)
        body = robj.obj

        self.assertEqual(body['server']['image']['id'], '2')
        self.assertEqual(len(body['server']['adminPass']),
                         CONF.password_length)

        self.assertEqual(robj['location'], self_href)
Beispiel #35
0
    def test_rebuild_admin_pass_pass_disabled(self):
        # run with enable_instance_password disabled to verify adminPass
        # is missing from response. See lp bug 921814
        self.flags(enable_instance_password=False)

        return_server = fakes.fake_instance_get(image_ref='2',
                vm_state=vm_states.ACTIVE, host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)

        body = {
            "rebuild": {
                "imageRef": self._image_href,
                "adminPass": "******",
            },
        }

        req = fakes.HTTPRequest.blank(self.url)
        body = self.controller._action_rebuild(req, FAKE_UUID, body).obj

        self.assertEqual(body['server']['image']['id'], '2')
        self.assertTrue('adminPass' not in body['server'])
Beispiel #36
0
    def test_rebuild_instance_with_image_href_uses_uuid(self):
        info = dict(image_href_in_call=None)

        def rebuild(self2, context, instance, image_href, *args, **kwargs):
            info['image_href_in_call'] = image_href

        self.stubs.Set(db, 'instance_get',
                       fakes.fake_instance_get(vm_state=vm_states.ACTIVE))
        self.stubs.Set(compute_api.API, 'rebuild', rebuild)

        # proper local hrefs must start with 'http://localhost/v2/'
        image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
        image_href = 'http://localhost/v2/fake/images/%s' % image_uuid
        body = {
            'rebuild': {
                'imageRef': image_href,
            },
        }

        req = fakes.HTTPRequest.blank('/v2/fake/servers/a/action')
        self.controller._action_rebuild(req, FAKE_UUID, body)
        self.assertEqual(info['image_href_in_call'], image_uuid)
Beispiel #37
0
    def test_rebuild_accepted_minimum_pass_disabled(self):
        # run with enable_instance_password disabled to verify adminPass
        # is missing from response. See lp bug 921814
        self.flags(enable_instance_password=False)

        return_server = fakes.fake_instance_get(image_ref='2',
                vm_state=vm_states.ACTIVE, host='fake_host')
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)
        self_href = 'http://localhost/v2/fake/servers/%s' % FAKE_UUID

        body = {
            "rebuild": {
                "imageRef": self._image_href,
            },
        }

        req = fakes.HTTPRequest.blank(self.url)
        robj = self.controller._action_rebuild(req, FAKE_UUID, body)
        body = robj.obj

        self.assertEqual(body['server']['image']['id'], '2')
        self.assertTrue("adminPass" not in body['server'])

        self.assertEqual(robj['location'], self_href)
Beispiel #38
0
    def _do_test_create_volume_backed_image(self, extra_properties):
        def _fake_id(x):
            return '%s-%s-%s-%s' % (x * 8, x * 4, x * 4, x * 12)

        body = dict(createImage=dict(name='snapshot_of_volume_backed'))

        if extra_properties:
            body['createImage']['metadata'] = extra_properties

        image_service = nova.image.glance.get_default_image_service()

        bdm = [
            dict(snapshot_id=_fake_id('a'),
                 volume_size=1,
                 device_name='sda1',
                 delete_on_termination=False)
        ]
        props = dict(kernel_id=_fake_id('b'),
                     ramdisk_id=_fake_id('c'),
                     root_device_name='/dev/sda1',
                     block_device_mapping=bdm)
        original_image = dict(properties=props,
                              container_format='ami',
                              status='active',
                              is_public=True)

        image_service.create(None, original_image)

        def fake_block_device_mapping_get_all_by_instance(context, inst_id):
            class BDM(object):
                def __init__(self):
                    self.no_device = None
                    self.values = dict(snapshot_id=_fake_id('a'),
                                       volume_id=_fake_id('d'),
                                       virtual_name=None,
                                       volume_size=1,
                                       device_name='sda1',
                                       delete_on_termination=False)

                def __getattr__(self, name):
                    return self.values.get(name)

                def __getitem__(self, key):
                    return self.values.get(key)

            return [BDM()]

        self.stubs.Set(nova.db, 'block_device_mapping_get_all_by_instance',
                       fake_block_device_mapping_get_all_by_instance)

        instance = fakes.fake_instance_get(image_ref=original_image['id'],
                                           vm_state=vm_states.ACTIVE,
                                           root_device_name='/dev/sda1')
        self.stubs.Set(nova.db, 'instance_get_by_uuid', instance)

        def fake_volume_get(context, volume_id):
            return dict(id=volume_id,
                        size=1,
                        host='fake',
                        display_description='fake')

        self.stubs.Set(nova.db, 'volume_get', fake_volume_get)

        req = fakes.HTTPRequest.blank(self.url)
        response = self.controller._action_create_image(req, FAKE_UUID, body)

        location = response.headers['Location']
        image_id = location.replace('http://localhost/v2/fake/images/', '')
        snapshot = image_service.show(None, image_id)

        self.assertEquals(snapshot['name'], 'snapshot_of_volume_backed')
        properties = snapshot['properties']
        self.assertEquals(properties['kernel_id'], _fake_id('b'))
        self.assertEquals(properties['ramdisk_id'], _fake_id('c'))
        self.assertEquals(properties['root_device_name'], '/dev/sda1')
        bdms = properties['block_device_mapping']
        self.assertEquals(len(bdms), 1)
        self.assertEquals(bdms[0]['device_name'], 'sda1')
        for k in extra_properties.keys():
            self.assertEquals(properties[k], extra_properties[k])
Beispiel #39
0
    def setUp(self):
        """Shared implementation for tests below that create instance."""
        super(ServersControllerCreateTest, self).setUp()

        self.flags(verbose=True, enable_instance_password=True)
        self.instance_cache_num = 0
        self.instance_cache_by_id = {}
        self.instance_cache_by_uuid = {}

        ext_info = plugins.LoadedExtensionInfo()
        self.controller = servers.ServersController(extension_info=ext_info)
        CONF.set_override('extensions_blacklist', 'os-disk-config', 'osapi_v3')
        self.no_disk_config_controller = servers.ServersController(
            extension_info=ext_info)

        def instance_create(context, inst):
            inst_type = flavors.get_flavor_by_flavor_id(3)
            image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
            def_image_ref = 'http://localhost/v3/os-images/%s' % image_uuid
            self.instance_cache_num += 1
            instance = {
                'id': self.instance_cache_num,
                'display_name': inst['display_name'] or 'test',
                'uuid': MANUAL_INSTANCE_UUID,
                'instance_type': dict(inst_type),
                'access_ip_v4': '1.2.3.4',
                'access_ip_v6': 'fead::1234',
                'image_ref': inst.get('image_ref', def_image_ref),
                'user_id': 'fake',
                'project_id': 'fake',
                'reservation_id': inst['reservation_id'],
                "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
                "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
                "user_data": None,
                "progress": 0,
                "fixed_ips": [],
                "task_state": "",
                "vm_state": "",
            }

            self.instance_cache_by_id[instance['id']] = instance
            self.instance_cache_by_uuid[instance['uuid']] = instance
            return instance

        def instance_get(context, instance_id):
            """Stub for compute/api create() pulling in instance after
            scheduling
            """
            return self.instance_cache_by_id[instance_id]

        def instance_update(context, uuid, values):
            instance = self.instance_cache_by_uuid[uuid]
            instance.update(values)
            return instance

        def rpc_call_wrapper(context, topic, msg, timeout=None):
            """Stub out the scheduler creating the instance entry."""
            if (topic == CONF.scheduler_topic
                    and msg['method'] == 'run_instance'):
                request_spec = msg['args']['request_spec']
                num_instances = request_spec.get('num_instances', 1)
                instances = []
                for x in xrange(num_instances):
                    instances.append(
                        instance_create(context,
                                        request_spec['instance_properties']))
                return instances

        def fake_method(*args, **kwargs):
            pass

        def queue_get_for(context, *args):
            return 'network_topic'

        def return_security_group(context, instance_id, security_group_id):
            pass

        fakes.stub_out_rate_limiting(self.stubs)
        fakes.stub_out_key_pair_funcs(self.stubs)
        fake.stub_out_image_service(self.stubs)
        fakes.stub_out_nw_api(self.stubs)
        self.stubs.Set(db, 'instance_add_security_group',
                       return_security_group)
        self.stubs.Set(db, 'instance_system_metadata_update', fake_method)
        self.stubs.Set(db, 'instance_get', instance_get)
        self.stubs.Set(db, 'instance_update', instance_update)
        self.stubs.Set(nova.openstack.common.rpc, 'cast', fake_method)
        self.stubs.Set(nova.openstack.common.rpc, 'call', rpc_call_wrapper)

        return_server = fakes.fake_instance_get()
        return_servers = fakes.fake_instance_get_all_by_filters()
        self.stubs.Set(db, 'instance_get_all_by_filters', return_servers)
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)
        self.stubs.Set(db, 'instance_add_security_group',
                       return_security_group)
Beispiel #40
0
    def _test_create_volume_backed_image_with_metadata_from_volume(
            self, extra_metadata=None):
        def _fake_id(x):
            return '%s-%s-%s-%s' % (x * 8, x * 4, x * 4, x * 12)

        body = dict(create_image=dict(name='snapshot_of_volume_backed'))
        if extra_metadata:
            body['create_image']['metadata'] = extra_metadata

        image_service = glance.get_default_image_service()

        def fake_block_device_mapping_get_all_by_instance(
                context, inst_id, use_slave=False):
            return [
                fake_block_device.FakeDbBlockDeviceDict({
                    'volume_id':
                    _fake_id('a'),
                    'source_type':
                    'snapshot',
                    'destination_type':
                    'volume',
                    'volume_size':
                    1,
                    'device_name':
                    'vda',
                    'snapshot_id':
                    1,
                    'boot_index':
                    0,
                    'delete_on_termination':
                    False,
                    'no_device':
                    None
                })
            ]

        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
                       fake_block_device_mapping_get_all_by_instance)

        instance = fakes.fake_instance_get(image_ref='',
                                           vm_state=vm_states.ACTIVE,
                                           root_device_name='/dev/vda')
        self.stubs.Set(db, 'instance_get_by_uuid', instance)

        fake_metadata = {
            'test_key1': 'test_value1',
            'test_key2': 'test_value2'
        }
        volume = dict(id=_fake_id('a'),
                      size=1,
                      host='fake',
                      display_description='fake',
                      volume_image_metadata=fake_metadata)
        snapshot = dict(id=_fake_id('d'))
        self.mox.StubOutWithMock(self.controller.compute_api, 'volume_api')
        volume_api = self.controller.compute_api.volume_api
        volume_api.get(mox.IgnoreArg(), volume['id']).AndReturn(volume)
        volume_api.get(mox.IgnoreArg(), volume['id']).AndReturn(volume)
        volume_api.create_snapshot_force(mox.IgnoreArg(), volume['id'],
                                         mox.IgnoreArg(),
                                         mox.IgnoreArg()).AndReturn(snapshot)

        req = fakes.HTTPRequestV3.blank(self.url)

        self.mox.ReplayAll()
        response = self.controller._action_create_image(req, FAKE_UUID, body)
        location = response.headers['Location']
        image_id = location.replace('http://localhost:9292/images/', '')
        image = image_service.show(None, image_id)

        properties = image['properties']
        self.assertEqual(properties['test_key1'], 'test_value1')
        self.assertEqual(properties['test_key2'], 'test_value2')
        if extra_metadata:
            for key, val in extra_metadata.items():
                self.assertEqual(properties[key], val)
Beispiel #41
0
    def setUp(self):
        """Shared implementation for tests below that create instance."""
        super(ServersControllerCreateTest, self).setUp()

        self.flags(verbose=True, enable_instance_password=True)
        self.instance_cache_num = 0
        self.instance_cache_by_id = {}
        self.instance_cache_by_uuid = {}

        ext_info = plugins.LoadedExtensionInfo()
        self.controller = servers.ServersController(extension_info=ext_info)
        CONF.set_override('extensions_blacklist', 'os-personality', 'osapi_v3')
        self.no_personality_controller = servers.ServersController(
            extension_info=ext_info)

        def instance_create(context, inst):
            inst_type = flavors.get_flavor_by_flavor_id(3)
            image_uuid = '76fa36fc-c930-4bf3-8c8a-ea2a2420deb6'
            def_image_ref = 'http://localhost/images/%s' % image_uuid
            self.instance_cache_num += 1
            instance = fake_instance.fake_db_instance(
                **{
                    'id': self.instance_cache_num,
                    'display_name': inst['display_name'] or 'test',
                    'uuid': FAKE_UUID,
                    'instance_type': dict(inst_type),
                    'access_ip_v4': '1.2.3.4',
                    'access_ip_v6': 'fead::1234',
                    'image_ref': inst.get('image_ref', def_image_ref),
                    'user_id': 'fake',
                    'project_id': 'fake',
                    'reservation_id': inst['reservation_id'],
                    "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
                    "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
                    "config_drive": None,
                    "progress": 0,
                    "fixed_ips": [],
                    "task_state": "",
                    "vm_state": "",
                    "security_groups": inst['security_groups'],
                })

            self.instance_cache_by_id[instance['id']] = instance
            self.instance_cache_by_uuid[instance['uuid']] = instance
            return instance

        def instance_get(context, instance_id):
            """Stub for compute/api create() pulling in instance after
            scheduling
            """
            return self.instance_cache_by_id[instance_id]

        def instance_update(context, uuid, values):
            instance = self.instance_cache_by_uuid[uuid]
            instance.update(values)
            return instance

        def server_update(context, instance_uuid, params):
            inst = self.instance_cache_by_uuid[instance_uuid]
            inst.update(params)
            return (inst, inst)

        def fake_method(*args, **kwargs):
            pass

        def project_get_networks(context, user_id):
            return dict(id='1', host='localhost')

        def queue_get_for(context, *args):
            return 'network_topic'

        fakes.stub_out_rate_limiting(self.stubs)
        fakes.stub_out_key_pair_funcs(self.stubs)
        fake.stub_out_image_service(self.stubs)
        fakes.stub_out_nw_api(self.stubs)
        self.stubs.Set(uuid, 'uuid4', fake_gen_uuid)
        self.stubs.Set(db, 'instance_add_security_group',
                       return_security_group)
        self.stubs.Set(db, 'project_get_networks', project_get_networks)
        self.stubs.Set(db, 'instance_create', instance_create)
        self.stubs.Set(db, 'instance_system_metadata_update', fake_method)
        self.stubs.Set(db, 'instance_get', instance_get)
        self.stubs.Set(db, 'instance_update', instance_update)
        self.stubs.Set(rpc, 'cast', fake_method)
        self.stubs.Set(db, 'instance_update_and_get_original', server_update)
        self.stubs.Set(rpc, 'queue_get_for', queue_get_for)
        self.stubs.Set(manager.VlanManager, 'allocate_fixed_ip', fake_method)

        return_server = fakes.fake_instance_get()
        return_servers = fakes.fake_instance_get_all_by_filters()
        self.stubs.Set(db, 'instance_get_all_by_filters', return_servers)
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)
        self.stubs.Set(db, 'instance_add_security_group',
                       return_security_group)
        self.stubs.Set(db, 'instance_update_and_get_original', instance_update)
 def setUp(self):
     super(HideServerAddressesTestV21, self).setUp()
     fakes.stub_out_nw_api(self.stubs)
     return_server = fakes.fake_instance_get()
     self.stubs.Set(db, 'instance_get_by_uuid', return_server)
     self._setup_wsgi()
Beispiel #43
0
    def _do_test_create_volume_backed_image(self, extra_properties):
        def _fake_id(x):
            return '%s-%s-%s-%s' % (x * 8, x * 4, x * 4, x * 12)

        body = dict(createImage=dict(name='snapshot_of_volume_backed'))

        if extra_properties:
            body['createImage']['metadata'] = extra_properties

        image_service = glance.get_default_image_service()

        bdm = [
            dict(volume_id=_fake_id('a'),
                 volume_size=1,
                 device_name='vda',
                 delete_on_termination=False)
        ]
        props = dict(kernel_id=_fake_id('b'),
                     ramdisk_id=_fake_id('c'),
                     root_device_name='/dev/vda',
                     block_device_mapping=bdm)
        original_image = dict(properties=props,
                              container_format='ami',
                              status='active',
                              is_public=True)

        image_service.create(None, original_image)

        def fake_block_device_mapping_get_all_by_instance(context, inst_id):
            return [
                dict(volume_id=_fake_id('a'),
                     virtual_name=None,
                     volume_size=1,
                     device_name='vda',
                     snapshot_id=1,
                     delete_on_termination=False,
                     no_device=None)
            ]

        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
                       fake_block_device_mapping_get_all_by_instance)

        instance = fakes.fake_instance_get(image_ref=original_image['id'],
                                           vm_state=vm_states.ACTIVE,
                                           root_device_name='/dev/vda')
        self.stubs.Set(db, 'instance_get_by_uuid', instance)

        volume = dict(id=_fake_id('a'),
                      size=1,
                      host='fake',
                      display_description='fake')
        snapshot = dict(id=_fake_id('d'))
        self.mox.StubOutWithMock(self.controller.compute_api, 'volume_api')
        volume_api = self.controller.compute_api.volume_api
        volume_api.get(mox.IgnoreArg(), volume['id']).AndReturn(volume)
        volume_api.create_snapshot_force(mox.IgnoreArg(), volume,
                                         mox.IgnoreArg(),
                                         mox.IgnoreArg()).AndReturn(snapshot)

        self.mox.ReplayAll()

        req = fakes.HTTPRequest.blank(self.url)
        response = self.controller._action_create_image(req, FAKE_UUID, body)

        location = response.headers['Location']
        image_id = location.replace('http://localhost/v2/fake/images/', '')
        image = image_service.show(None, image_id)

        self.assertEquals(image['name'], 'snapshot_of_volume_backed')
        properties = image['properties']
        self.assertEquals(properties['kernel_id'], _fake_id('b'))
        self.assertEquals(properties['ramdisk_id'], _fake_id('c'))
        self.assertEquals(properties['root_device_name'], '/dev/vda')
        bdms = properties['block_device_mapping']
        self.assertEquals(len(bdms), 1)
        self.assertEquals(bdms[0]['device_name'], 'vda')
        self.assertEquals(bdms[0]['snapshot_id'], snapshot['id'])
        for k in extra_properties.keys():
            self.assertEquals(properties[k], extra_properties[k])