def test_hypervisor(self): from synnefo.db.models import snf_settings kvm_backend = mfact.BackendFactory(hypervisor="kvm") xen_pvm_backend = mfact.BackendFactory(hypervisor="xen-pvm") xen_hvm_backend = mfact.BackendFactory(hypervisor="xen-hvm") with override_settings(snf_settings, GANETI_USE_HOTPLUG=True): self.assertTrue(kvm_backend.use_hotplug()) self.assertFalse(xen_pvm_backend.use_hotplug()) self.assertFalse(xen_hvm_backend.use_hotplug()) with override_settings(snf_settings, GANETI_USE_HOTPLUG=False): self.assertFalse(kvm_backend.use_hotplug()) self.assertFalse(xen_pvm_backend.use_hotplug()) self.assertFalse(xen_hvm_backend.use_hotplug()) kwargs = {"os": "snf-image+default", "hvparams": {"kvm": {"foo1": "mpaz1"}, "xen-pvm": {"foo2": "mpaz2"}, "xen-hvm": {"foo3": "mpaz3"}}} with override_settings(snf_settings, GANETI_CREATEINSTANCE_KWARGS=kwargs): self.assertEqual(kvm_backend.get_create_params(), {"os": "snf-image+default", "hvparams": {"foo1": "mpaz1"}}) self.assertEqual(xen_pvm_backend.get_create_params(), {"os": "snf-image+default", "hvparams": {"foo2": "mpaz2"}}) self.assertEqual(xen_hvm_backend.get_create_params(), {"os": "snf-image+default", "hvparams": {"foo3": "mpaz3"}}) with override_settings(snf_settings, GANETI_CREATEINSTANCE_KWARGS={}): self.assertEqual(kvm_backend.get_create_params(), {"hvparams": {}})
def test_create_backend_network(self): len_backends = len(Backend.objects.all()) back = mfact.BackendFactory() self.net.create_backend_network(backend=back) BackendNetwork.objects.get(network=self.net, backend=back) back1 = mfact.BackendFactory() back2 = mfact.BackendFactory() self.net.create_backend_network() BackendNetwork.objects.get(network=self.net, backend=back1) BackendNetwork.objects.get(network=self.net, backend=back2) self.assertEqual(len(BackendNetwork.objects.filter(network=self.net)), len_backends + 3)
def test_unique_index(self): """Test that each backend gets a unique index""" backends = [self.backend] for i in xrange(0, 14): backends.append(mfact.BackendFactory()) indexes = map(lambda x: x.index, backends) self.assertEqual(len(indexes), len(set(indexes)))
def test_invalid_mac(self): network = mfact.NetworkFactory(mac_prefix='zz:bb:c') backend = mfact.BackendFactory() self.assertRaises(utils.InvalidMacAddress, mfact.BackendNetworkFactory, network=network, backend=backend)
def test_delete_active_backend(self): """Test that a backend with non-deleted VMS is not deleted""" backend = mfact.BackendFactory() vm = mfact.VirtualMachineFactory(backend=backend) self.assertRaises(IntegrityError, backend.delete, ()) vm.backend = None vm.save() backend.delete()
def setUp(self): self.allocators = [cls() for cls in AllocatorBase.__subclasses__()] self.backend = models_factory.BackendFactory() flavor = models_factory.FlavorFactory() disk = flavor.disk * 1024 ram = flavor.ram cpu = flavor.cpu self.vm = {'ram': ram, 'disk': disk, 'cpu': cpu}
def test_create_server(self, mrapi, mimage): """Test if the create server call returns the expected response if a valid request has been speficied.""" mimage.return_value = { 'location': 'pithos://foo', 'checksum': '1234', "id": 1, "name": "test_image", 'disk_format': 'diskdump' } mrapi().CreateInstance.return_value = 12 flavor = mfactory.FlavorFactory() # Create public network and backend network = mfactory.NetworkFactory(public=True) backend = mfactory.BackendFactory() mfactory.BackendNetworkFactory(network=network, backend=backend) request = { "server": { "name": "new-server-test", "userid": "test_user", "imageRef": 1, "flavorRef": flavor.id, "metadata": { "My Server Name": "Apache1" }, "personality": [] } } with mocked_quotaholder(): response = self.mypost('servers', 'test_user', json.dumps(request), 'json') self.assertEqual(response.status_code, 202) mrapi().CreateInstance.assert_called_once() api_server = json.loads(response.content)['server'] self.assertEqual(api_server['status'], "BUILD") self.assertEqual(api_server['progress'], 0) self.assertEqual(api_server['metadata'], {"My Server Name": "Apache1"}) self.assertTrue('adminPass' in api_server) db_vm = VirtualMachine.objects.get(userid='test_user') self.assertEqual(api_server['name'], db_vm.name) self.assertEqual(api_server['status'], db_vm.operstate) # Test drained flag in Network: network.drained = True network.save() with mocked_quotaholder(): response = self.mypost('servers', 'test_user', json.dumps(request), 'json') self.assertEqual(response.status_code, 503, "serviceUnavailable")
def setUp(self, mrapi): self.backend = mfactory.BackendFactory() log = logging.getLogger() options = { "fix_unsynced": True, "fix_stale": True, "fix_orphans": True, "fix_unsynced_nics": True, "fix_unsynced_flavors": True } self.reconciler = reconciliation.BackendReconciler(self.backend, options=options, logger=log)
def setUp(self): self.flavor = mfactory.FlavorFactory() self.backend = mfactory.BackendFactory() self.request = { "server": { "name": u"Server in the \u2601", "userid": "test_user", "imageRef": 1, "flavorRef": self.flavor.id, "metadata": { u"Meta \u2601": u"Meta in the \u2601" }, "personality": [] } } # Create dummy public IPv6 network sub6 = mfactory.IPv6SubnetFactory(network__public=True) self.net6 = sub6.network self.network_settings = { "CYCLADES_DEFAULT_SERVER_NETWORKS": [], "CYCLADES_FORCED_SERVER_NETWORKS": ["SNF:ANY_PUBLIC_IPV6"] }
def test_create(self, mrapi): flavor = mfactory.FlavorFactory() kwargs = { "userid": "test", "name": "test_vm", "password": "******", "flavor": flavor, "image_id": "safs", "networks": [], "metadata": { "foo": "bar" }, "personality": [], } # no backend! mfactory.BackendFactory(offline=True) self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs) self.assertEqual(models.VirtualMachine.objects.count(), 0) mfactory.IPv4SubnetFactory(network__public=True) mfactory.IPv6SubnetFactory(network__public=True) backend = mfactory.BackendFactory() # error in nics req = deepcopy(kwargs) req["networks"] = [{"uuid": 42}] self.assertRaises(faults.ItemNotFound, servers.create, **req) self.assertEqual(models.VirtualMachine.objects.count(), 0) # error in enqueue. check the vm is deleted and resources released mrapi().CreateInstance.side_effect = Exception("ganeti is down") with mocked_quotaholder(): servers.create(**kwargs) vm = models.VirtualMachine.objects.get() self.assertFalse(vm.deleted) self.assertEqual(vm.operstate, "ERROR") for nic in vm.nics.all(): self.assertEqual(nic.state, "ERROR") # test ext settings: req = deepcopy(kwargs) ext_flavor = mfactory.FlavorFactory( volume_type__disk_template="ext_archipelago", disk=1) req["flavor"] = ext_flavor mrapi().CreateInstance.return_value = 42 backend.disk_templates = ["ext"] backend.save() osettings = { "GANETI_DISK_PROVIDER_KWARGS": { "archipelago": { "foo": "mpaz", "lala": "lolo" } } } with mocked_quotaholder(): with override_settings(settings, **osettings): vm = servers.create(**req) name, args, kwargs = mrapi().CreateInstance.mock_calls[-1] self.assertEqual( kwargs["disks"][0], { "provider": "archipelago", "origin": "test_mapfile", "origin_size": 1000, "name": vm.volumes.all()[0].backend_volume_uuid, "foo": "mpaz", "lala": "lolo", "size": 1024 })
def test_backend_number(self): """Test that no more than 16 backends are created""" for i in xrange(0, 14): mfact.BackendFactory() self.assertRaises(Exception, mfact.BackendFactory, ())
def setUp(self): self.backend = mfact.BackendFactory()
def test_mac_prefix(self): network = mfact.NetworkFactory(mac_prefix='aa:bb:c') backend = mfact.BackendFactory() bnet = mfact.BackendNetworkFactory(network=network, backend=backend) self.assertTrue(backend.index < 10) self.assertEqual(bnet.mac_prefix, 'aa:bb:c%s' % backend.index)
def setUp(self): self.backend = mfactory.BackendFactory() log = logging.getLogger() self.reconciler = reconciliation.NetworkReconciler(logger=log, fix=True)
def test_create(self, mrapi): flavor = mfactory.FlavorFactory() kwargs = { "credentials": self.credentials, "name": "test_vm", "password": "******", "flavor": flavor, "image_id": "safs", "networks": [], "metadata": { "foo": "bar" }, "personality": [], } # no backend! mfactory.BackendFactory(offline=True) self.assertRaises(faults.ServiceUnavailable, servers.create, **kwargs) self.assertEqual(models.VirtualMachine.objects.count(), 0) mfactory.IPv4SubnetFactory(network__public=True) mfactory.IPv6SubnetFactory(network__public=True) backend = mfactory.BackendFactory() # error in nics req = deepcopy(kwargs) req["networks"] = [{"uuid": 42}] self.assertRaises(faults.ItemNotFound, servers.create, **req) self.assertEqual(models.VirtualMachine.objects.count(), 0) # error in enqueue. check the vm is deleted and resources released mrapi().CreateInstance.side_effect = Exception("ganeti is down") with mocked_quotaholder(): servers.create(**kwargs) vm = models.VirtualMachine.objects.get() self.assertFalse(vm.deleted) self.assertEqual(vm.operstate, "ERROR") for nic in vm.nics.all(): self.assertEqual(nic.state, "ERROR") # test ext settings: req = deepcopy(kwargs) vlmt = mfactory.VolumeTypeFactory(disk_template='ext_archipelago') # Generate 4 specs. 2 prefixed with GNT_EXTP_VOLTYPESPEC_PREFIX # and 2 with an other prefix that should be omitted volume_type_specs = [ mfactory.VolumeTypeSpecsFactory(volume_type=vlmt, key='%sbar' % GNT_EXTP_VOLTYPESPEC_PREFIX), mfactory.VolumeTypeSpecsFactory(volume_type=vlmt, key='%sfoo' % GNT_EXTP_VOLTYPESPEC_PREFIX), mfactory.VolumeTypeSpecsFactory(volume_type=vlmt, key='other-prefx-baz'), mfactory.VolumeTypeSpecsFactory(volume_type=vlmt, key='another-prefix-biz'), ] gnt_prefixed_specs = filter( lambda s: s.key.startswith(GNT_EXTP_VOLTYPESPEC_PREFIX), volume_type_specs) ext_flavor = mfactory.FlavorFactory(volume_type=vlmt, disk=1) req["flavor"] = ext_flavor mrapi().CreateInstance.return_value = 42 backend.disk_templates = ["ext"] backend.save() osettings = { "GANETI_DISK_PROVIDER_KWARGS": { "archipelago": { "foo": "mpaz", "lala": "lolo" } } } with mocked_quotaholder(): with override_settings(settings, **osettings): with patch( 'synnefo.logic.backend_allocator.update_backends_disk_templates' # noqa E265 ) as update_disk_templates_mock: # Check that between the `get_available_backends` call # and the `update_backend_disk_templates` call # the backend doesn't change. update_disk_templates_mock.return_value = [backend] vm = servers.create(**req) update_disk_templates_mock.assert_called_once_with([backend]) name, args, kwargs = mrapi().CreateInstance.mock_calls[-1] disk_kwargs = { "provider": "archipelago", "origin": "test_mapfile", "origin_size": 1000, "name": vm.volumes.all()[0].backend_volume_uuid, "foo": "mpaz", "lala": "lolo", "size": 1024 } disk_kwargs.update({ spec.key[len(GNT_EXTP_VOLTYPESPEC_PREFIX):]: spec.value for spec in gnt_prefixed_specs }) self.assertEqual(kwargs["disks"][0], disk_kwargs)