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)
