def test_invalid_operstate_for_action(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
self.assertRaises(faults.BadRequest, servers.stop, vm)
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
flavor = mfactory.FlavorFactory()
self.assertRaises(faults.BadRequest, servers.resize, vm, flavor)
# Check that connect/disconnect is allowed only in STOPPED vms
# if hotplug is disabled.
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
network = mfactory.NetworkFactory(state="ACTIVE")
with override_settings(settings, GANETI_USE_HOTPLUG=False):
self.assertRaises(faults.BadRequest, servers.connect, vm, network)
self.assertRaises(faults.BadRequest, servers.disconnect, vm,
network)
#test valid
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder():
servers.start(vm)
vm.task = None
vm.task_job_id = None
vm.save()
with mocked_quotaholder():
quotas.accept_resource_serial(vm)
mrapi().RebootInstance.return_value = 1
with mocked_quotaholder():
servers.reboot(vm, "HARD")
def test_stale_server(self, mrapi):
mrapi.GetInstances = []
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
operstate="ERROR")
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertFalse(vm1.deleted)
vm2 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
action="DESTROY",
operstate="ERROR")
with mocked_quotaholder():
self.reconciler.reconcile()
vm2 = VirtualMachine.objects.get(id=vm2.id)
self.assertTrue(vm2.deleted)
vm3 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
action="DESTROY",
operstate="ACTIVE")
with mocked_quotaholder():
self.reconciler.reconcile()
vm3 = VirtualMachine.objects.get(id=vm3.id)
self.assertTrue(vm3.deleted)
def test_reassign_vm(self, mrapi):
volume = mfactory.VolumeFactory()
vm = volume.machine
another_project = "another_project"
with mocked_quotaholder():
vm = servers.reassign(vm.id,
another_project,
False,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
volume = mfactory.VolumeFactory()
volume.index = 0
volume.save()
vm = volume.machine
another_project = "another_project"
with mocked_quotaholder():
vm = servers.reassign(vm.id,
another_project,
True,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, True)
vol = vm.volumes.get(id=volume.id)
self.assertEqual(vol.project, another_project)
self.assertEqual(vol.shared_to_project, True)
def test_stale_server(self, mrapi):
mrapi.GetInstances = []
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
operstate="ERROR")
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertFalse(vm1.deleted)
vm2 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
action="DESTROY",
operstate="ERROR")
with mocked_quotaholder():
self.reconciler.reconcile()
vm2 = VirtualMachine.objects.get(id=vm2.id)
self.assertTrue(vm2.deleted)
vm3 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
action="DESTROY",
operstate="ACTIVE")
with mocked_quotaholder():
self.reconciler.reconcile()
vm3 = VirtualMachine.objects.get(id=vm3.id)
self.assertTrue(vm3.deleted)
def test_reassign_vm_backends(self, mrapi):
volume = mfactory.VolumeFactory()
vm = volume.machine
original_project = vm.project
another_project = "another_project"
with mocked_quotaholder():
servers.reassign(vm, another_project, False)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
backend = vm.backend
backend.public = False
backend.save()
with mocked_quotaholder():
self.assertRaises(faults.BadRequest, servers.reassign, vm,
original_project, False)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
mfactory.ProjectBackendFactory(project=original_project,
backend=backend)
with mocked_quotaholder():
servers.reassign(vm, original_project, False)
self.assertEqual(vm.project, original_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertEqual(vol.project, original_project)
def test_task_after(self, mrapi):
return
vm = mfactory.VirtualMachineFactory()
mrapi().StartupInstance.return_value = 1
mrapi().ShutdownInstance.return_value = 2
mrapi().RebootInstance.return_value = 2
with mocked_quotaholder():
vm.task = None
vm.operstate = "STOPPED"
vm.save()
servers.start(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "START")
self.assertEqual(vm.task_job_id, 1)
with mocked_quotaholder():
vm.task = None
vm.operstate = "STARTED"
vm.save()
servers.stop(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "STOP")
self.assertEqual(vm.task_job_id, 2)
with mocked_quotaholder():
vm.task = None
vm.save()
servers.reboot(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "REBOOT")
self.assertEqual(vm.task_job_id, 3)
def test_reserve_empty_body(self):
"""Test reserve FIP without specifying network."""
request = {"floatingip": {}}
# delete all pools..
IPPoolTable.objects.all().delete()
Subnet.objects.all().delete()
Network.objects.all().delete()
# CASE: no floating IP pool
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
# CASE: Full floating IP pool
mf.NetworkWithSubnetFactory(floating_ip_pool=True,
public=True,
subnet__pool__size=0)
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
# CASE: Available floating IP pool
p1 = mf.NetworkWithSubnetFactory(floating_ip_pool=True,
public=True,
subnet__cidr="192.168.2.0/30",
subnet__pool__size=1)
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertSuccess(response)
floating_ip = json.loads(response.content)["floatingip"]
db_fip = IPAddress.objects.get(id=floating_ip["id"])
self.assertEqual(db_fip.address, floating_ip["floating_ip_address"])
self.assertTrue(db_fip.floating_ip)
# Test that address is reserved
ip_pool = p1.get_ip_pools(locked=False)[0]
self.assertFalse(ip_pool.is_available(db_fip.address))
def test_invalid_operstate_for_action(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
self.assertRaises(faults.BadRequest, servers.stop, vm)
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
flavor = mfactory.FlavorFactory()
self.assertRaises(faults.BadRequest, servers.resize, vm, flavor)
# Check that connect/disconnect is allowed only in STOPPED vms
# if hotplug is disabled.
vm = mfactory.VirtualMachineFactory(operstate="STARTED")
network = mfactory.NetworkFactory(state="ACTIVE")
with override_settings(settings, GANETI_USE_HOTPLUG=False):
self.assertRaises(faults.BadRequest, servers.connect, vm, network)
self.assertRaises(faults.BadRequest, servers.disconnect, vm, network)
# test valid
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder():
servers.start(vm)
vm.task = None
vm.task_job_id = None
vm.save()
with mocked_quotaholder():
quotas.accept_resource_serial(vm)
mrapi().RebootInstance.return_value = 1
with mocked_quotaholder():
servers.reboot(vm, "HARD")
def test_start_shutdown(self):
from synnefo.logic import backend
self.vm1 = mfactory.VirtualMachineFactory(userid=USER1)
pk = self.vm1.pk
r = self.client.post(reverse('helpdesk-vm-shutdown', args=(pk,)))
self.assertEqual(r.status_code, 403)
r = self.client.post(reverse('helpdesk-vm-shutdown', args=(pk,)),
data={'token': '0001'})
self.assertEqual(r.status_code, 403)
backend.shutdown_instance = shutdown = mock.Mock()
shutdown.return_value = 1
self.vm1.operstate = 'STARTED'
self.vm1.save()
with mocked_quotaholder():
r = self.client.post(reverse('helpdesk-vm-shutdown', args=(pk,)),
data={'token': '0001'}, user_token='0001')
self.assertEqual(r.status_code, 302)
self.assertTrue(shutdown.called)
self.assertEqual(len(shutdown.mock_calls), 1)
backend.startup_instance = startup = mock.Mock()
startup.return_value = 2
self.vm1.operstate = 'STOPPED'
self.vm1.save()
with mocked_quotaholder():
r = self.client.post(reverse('helpdesk-vm-start', args=(pk,)),
data={'token': '0001'}, user_token='0001')
self.assertEqual(r.status_code, 302)
self.assertTrue(startup.called)
self.assertEqual(len(startup.mock_calls), 1)
def test_reserve_empty_body(self):
"""Test reserve FIP without specifying network."""
request = {"floatingip": {}}
# delete all pools..
IPPoolTable.objects.all().delete()
Subnet.objects.all().delete()
Network.objects.all().delete()
# CASE: no floating IP pool
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
# CASE: Full floating IP pool
mf.NetworkWithSubnetFactory(floating_ip_pool=True, public=True,
subnet__pool__size=0)
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertConflict(response)
# CASE: Available floating IP pool
p1 = mf.NetworkWithSubnetFactory(floating_ip_pool=True, public=True,
subnet__cidr="192.168.2.0/30",
subnet__pool__size=1)
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertSuccess(response)
floating_ip = json.loads(response.content)["floatingip"]
db_fip = IPAddress.objects.get(id=floating_ip["id"])
self.assertEqual(db_fip.address, floating_ip["floating_ip_address"])
self.assertTrue(db_fip.floating_ip)
# Test that address is reserved
ip_pool = p1.get_ip_pools()[0]
self.assertFalse(ip_pool.is_available(db_fip.address))
def test_start_shutdown(self):
self.vm1 = mfactory.VirtualMachineFactory(userid=USER1)
pk = self.vm1.pk
r = self.client.post(reverse('helpdesk-vm-shutdown', args=(pk, )))
self.assertEqual(r.status_code, 403)
r = self.client.post(reverse('helpdesk-vm-shutdown', args=(pk, )),
data={'token': '0001'})
self.assertEqual(r.status_code, 403)
self.vm1.operstate = 'STARTED'
self.vm1.save()
with patch("synnefo.logic.backend.shutdown_instance") as shutdown:
shutdown.return_value = 1
with mocked_quotaholder():
r = self.client.post(reverse('helpdesk-vm-shutdown',
args=(pk, )),
data={'token': '0001'},
user_token='0001')
self.assertEqual(r.status_code, 302)
self.assertTrue(shutdown.called)
self.assertEqual(len(shutdown.mock_calls), 1)
self.vm1.operstate = 'STOPPED'
self.vm1.save()
with patch("synnefo.logic.backend.startup_instance") as startup:
startup.return_value = 2
with mocked_quotaholder():
r = self.client.post(reverse('helpdesk-vm-start', args=(pk, )),
data={'token': '0001'},
user_token='0001')
self.assertEqual(r.status_code, 302)
self.assertTrue(startup.called)
self.assertEqual(len(startup.mock_calls), 1)
def test_building_vm(self, mrapi):
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
backendjobid=1,
operstate="BUILD")
for status in ["queued", "waiting", "running"]:
mrapi().GetJobs.return_value = [{"id": "1", "status": status,
"end_ts": None}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertFalse(vm1.deleted)
self.assertEqual(vm1.operstate, "BUILD")
mrapi().GetJobs.return_value = [{"id": "1", "status": "error",
"end_ts": [44123, 1]}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertFalse(vm1.deleted)
self.assertEqual(vm1.operstate, "ERROR")
for status in ["success", "canceled"]:
vm1.operstate = "BUILD"
vm1.deleted = False
vm1.save()
mrapi().GetJobs.return_value = [{"id": "1", "status": status,
"end_ts": [44123, 1]}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertFalse(vm1.deleted)
self.assertEqual(vm1.operstate, "ERROR")
def test_reassign_vm_backends(self, mrapi):
volume = mfactory.VolumeFactory()
vm = volume.machine
original_project = vm.project
another_project = "another_project"
with mocked_quotaholder():
vm = servers.reassign(vm.id, another_project, False,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
backend = vm.backend
backend.public = False
backend.save()
with mocked_quotaholder():
self.assertRaises(faults.Forbidden, servers.reassign, vm.id,
original_project, False,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
mfactory.ProjectBackendFactory(project=original_project,
backend=backend)
with mocked_quotaholder():
vm = servers.reassign(vm.id, original_project, False,
credentials=self.credentials)
self.assertEqual(vm.project, original_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertEqual(vol.project, original_project)
def test_reassign_vm(self, mrapi):
volume = mfactory.VolumeFactory()
vm = volume.machine
another_project = "another_project"
with mocked_quotaholder():
vm = servers.reassign(vm.id, another_project, False,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, False)
vol = vm.volumes.get(id=volume.id)
self.assertNotEqual(vol.project, another_project)
volume = mfactory.VolumeFactory()
volume.index = 0
volume.save()
vm = volume.machine
another_project = "another_project"
with mocked_quotaholder():
vm = servers.reassign(vm.id, another_project, True,
credentials=self.credentials)
self.assertEqual(vm.project, another_project)
self.assertEqual(vm.shared_to_project, True)
vol = vm.volumes.get(id=volume.id)
self.assertEqual(vol.project, another_project)
self.assertEqual(vol.shared_to_project, True)
def test_task_after(self, mrapi):
return
vm = mfactory.VirtualMachineFactory()
mrapi().StartupInstance.return_value = 1
mrapi().ShutdownInstance.return_value = 2
mrapi().RebootInstance.return_value = 2
with mocked_quotaholder():
vm.task = None
vm.operstate = "STOPPED"
vm.save()
servers.start(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "START")
self.assertEqual(vm.task_job_id, 1)
with mocked_quotaholder():
vm.task = None
vm.operstate = "STARTED"
vm.save()
servers.stop(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "STOP")
self.assertEqual(vm.task_job_id, 2)
with mocked_quotaholder():
vm.task = None
vm.save()
servers.reboot(vm.id, credentials=self.credentials)
self.assertEqual(vm.task, "REBOOT")
self.assertEqual(vm.task_job_id, 3)
def test_create(self, mrapi):
flavor = mfactory.FlavorFactory()
kwargs = {
"userid": "test",
"name": "test_vm",
"password": "******",
"flavor": flavor,
"image": {
"id": "foo",
"backend_id": "foo",
"format": "diskdump",
"checksum": "test_checksum",
"metadata": "{}",
},
"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(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_checksum", "foo": "mpaz", "lala": "lolo", "size": 1024},
)
def test_commission(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
# Still pending
vm.serial = mfactory.QuotaHolderSerialFactory(serial=200,
resolved=False,
pending=True)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
with self.assertRaises(quotas.ResolveError):
servers.start(vm.id, credentials=self.credentials)
# Not pending, rejct
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=400,
resolved=False,
pending=False,
accept=False)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm.id, credentials=self.credentials)
m.resolve_commissions.assert_called_once_with([],
[serial.serial])
self.assertTrue(m.issue_one_commission.called)
# Not pending, accept
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=600,
resolved=False,
pending=False,
accept=True)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm.id, credentials=self.credentials)
m.resolve_commissions.assert_called_once_with([serial.serial],
[])
self.assertTrue(m.issue_one_commission.called)
mrapi().StartupInstance.side_effect = ValueError
vm.task = None
vm.serial = None
vm.save()
# Test reject if Ganeti erro
with mocked_quotaholder() as m:
try:
servers.start(vm.id, credentials=self.credentials)
except Exception:
(accept, reject), kwargs = m.resolve_commissions.call_args
self.assertEqual(accept, [])
self.assertEqual(len(reject), 1)
self.assertEqual(kwargs, {})
else:
raise AssertionError("Starting a server should raise an"
" exception.")
def test_remove(self, client):
vm = mfactory.VirtualMachineFactory(flavor__cpu=1, flavor__ram=128)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=1)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=3)
# Also create a NIC
ip = mfactory.IPv4AddressFactory(nic__machine=vm)
nic = ip.nic
with transaction.atomic():
nic.network.get_ip_pools()[0].reserve(nic.ipv4_address)
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm.backend_vm_id)
with mocked_quotaholder() as m:
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
# Check that nics are deleted
self.assertFalse(db_vm.nics.all())
with transaction.atomic():
self.assertTrue(nic.network.get_ip_pools()[0].is_available(ip.address))
# Check that volumes are deleted
self.assertFalse(db_vm.volumes.filter(deleted=False))
# Check quotas
name, args, kwargs = m.mock_calls[0]
for (userid, res), value in args[1].items():
if res == 'cyclades.disk':
self.assertEqual(value, -4 << 30)
elif res == 'cyclades.cpu':
self.assertEqual(value, -1)
elif res == 'cyclades.ram':
self.assertEqual(value, -128 << 20)
vm2 = mfactory.VirtualMachineFactory()
fp1 = mfactory.IPv4AddressFactory(nic__machine=vm2, floating_ip=True,
network__floating_ip_pool=True)
network = fp1.network
nic1 = mfactory.NetworkInterfaceFactory(machine=vm2)
fp1.nic = nic1
fp1.save()
with transaction.atomic():
pool = network.get_ip_pools()[0]
pool.reserve(fp1.address)
pool.save()
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm2.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
self.assertEqual(2, client.basic_ack.call_count)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
self.assertEqual(IPAddress.objects.get(id=fp1.id).nic, None)
with transaction.atomic():
pool = network.get_ip_pools()[0]
# Test that floating ips are not released
self.assertFalse(pool.is_available(fp1.address))
def test_commission(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
# Still pending
vm.serial = mfactory.QuotaHolderSerialFactory(serial=200,
resolved=False,
pending=True)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
with self.assertRaises(quotas.ResolveError):
servers.start(vm.id, credentials=self.credentials)
# Not pending, rejct
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=400,
resolved=False,
pending=False,
accept=False)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm.id, credentials=self.credentials)
m.resolve_commissions.assert_called_once_with([], [serial.serial])
self.assertTrue(m.issue_one_commission.called)
# Not pending, accept
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=600,
resolved=False,
pending=False,
accept=True)
vm.save()
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm.id, credentials=self.credentials)
m.resolve_commissions.assert_called_once_with([serial.serial], [])
self.assertTrue(m.issue_one_commission.called)
mrapi().StartupInstance.side_effect = ValueError
vm.task = None
vm.serial = None
vm.save()
# Test reject if Ganeti erro
with mocked_quotaholder() as m:
try:
servers.start(vm.id, credentials=self.credentials)
except Exception:
(accept, reject), kwargs = m.resolve_commissions.call_args
self.assertEqual(accept, [])
self.assertEqual(len(reject), 1)
self.assertEqual(kwargs, {})
else:
raise AssertionError("Starting a server should raise an"
" exception.")
def test_reserve_with_address(self):
request = {
"floatingip": {
"floating_network_id": self.pool.id,
"floating_ip_address": "192.168.2.10"
}
}
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertSuccess(response)
ip = floating_ips.get()
self.assertEqual(
json.loads(response.content)["floatingip"], {
"instance_id": None,
"floating_ip_address": "192.168.2.10",
"fixed_ip_address": None,
"id": str(ip.id),
"port_id": None,
"deleted": False,
"user_id": "test_user",
"tenant_id": "test_user",
"shared_to_project": False,
"floating_network_id": str(self.pool.id)
})
# Already reserved
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertFault(response, 409, "conflict")
# Used by instance
with transaction.atomic():
self.pool.reserve_address("192.168.2.20")
request = {
"floatingip": {
"floating_network_id": self.pool.id,
"floating_ip_address": "192.168.2.20"
}
}
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertFault(response, 409, "conflict")
# Address out of pool
request = {
"floatingip": {
"floating_network_id": self.pool.id,
"floating_ip_address": "192.168.3.5"
}
}
with mocked_quotaholder():
response = self.post(URL, "test_user", json.dumps(request), "json")
self.assertBadRequest(response)
def test_remove(self, client):
vm = mfactory.VirtualMachineFactory(flavor__cpu=1, flavor__ram=128)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=1)
mfactory.VolumeFactory(userid=vm.userid, machine=vm, size=3)
# Also create a NIC
ip = mfactory.IPv4AddressFactory(nic__machine=vm)
nic = ip.nic
nic.network.get_ip_pools()[0].reserve(nic.ipv4_address)
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm.backend_vm_id)
with mocked_quotaholder() as m:
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
# Check that nics are deleted
self.assertFalse(db_vm.nics.all())
self.assertTrue(nic.network.get_ip_pools()[0].is_available(ip.address))
# Check that volumes are deleted
self.assertFalse(db_vm.volumes.filter(deleted=False))
# Check quotas
name, args, kwargs = m.mock_calls[0]
for (userid, res), value in args[1].items():
if res == 'cyclades.disk':
self.assertEqual(value, -4 << 30)
elif res == 'cyclades.cpu':
self.assertEqual(value, -1)
elif res == 'cyclades.ram':
self.assertEqual(value, -128 << 20)
vm2 = mfactory.VirtualMachineFactory()
fp1 = mfactory.IPv4AddressFactory(nic__machine=vm2, floating_ip=True,
network__floating_ip_pool=True)
network = fp1.network
nic1 = mfactory.NetworkInterfaceFactory(machine=vm2)
fp1.nic = nic1
fp1.save()
pool = network.get_ip_pools()[0]
pool.reserve(fp1.address)
pool.save()
msg = self.create_msg(operation='OP_INSTANCE_REMOVE',
instance=vm2.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
client.basic_ack.assert_called_once()
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'DESTROYED')
self.assertTrue(db_vm.deleted)
self.assertEqual(IPAddress.objects.get(id=fp1.id).nic, None)
pool = network.get_ip_pools()[0]
# Test that floating ips are not released
self.assertFalse(pool.is_available(fp1.address))
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 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,
"size": "41242",
"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 test_pending_task(self, mrapi):
vm = mfactory.VirtualMachineFactory(task="REBOOT", task_job_id=1)
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(task="BUILD", task_job_id=1)
self.assertRaises(faults.BuildInProgress, servers.start, vm)
# Assert always succeeds
vm = mfactory.VirtualMachineFactory(task="BUILD", task_job_id=1)
mrapi().DeleteInstance.return_value = 1
with mocked_quotaholder():
servers.destroy(vm)
vm = mfactory.VirtualMachineFactory(task="REBOOT", task_job_id=1)
with mocked_quotaholder():
servers.destroy(vm)
def test_pending_task(self, mrapi):
vm = mfactory.VirtualMachineFactory(task="REBOOT", task_job_id=1)
self.assertRaises(faults.BadRequest, servers.start, vm)
vm = mfactory.VirtualMachineFactory(task="BUILD", task_job_id=1)
self.assertRaises(faults.BuildInProgress, servers.start, vm)
# Assert always succeeds
vm = mfactory.VirtualMachineFactory(task="BUILD", task_job_id=1)
mrapi().DeleteInstance.return_value = 1
with mocked_quotaholder():
servers.destroy(vm)
vm = mfactory.VirtualMachineFactory(task="REBOOT", task_job_id=1)
with mocked_quotaholder():
servers.destroy(vm)
def test_delete(self):
"""Test if the delete action succeeds/fails properly."""
# Create a floating IP and force-attach it to a NIC instance.
vm = mfactory.VirtualMachineFactory()
nic = mfactory.NetworkInterfaceFactory(network=self.network,
machine=vm)
with mocked_quotaholder():
ip = ips.create_floating_ip(self.credentials,
network_id=self.network.id)
ip.nic = nic
ip.save()
# Test 1 - Check if we can delete an IP attached to a VM.
#
# The validate function and the action should both fail with the
# following message.
expected_msg = "IP '{}' is used by server '{}'".format(ip.id, vm.id)
# Verify that the validate function fails in silent mode.
res, msg = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertFalse(res)
self.assertEqual(msg, expected_msg)
# Verify that the validate function fails in non-silent mode.
with self.assertRaises(faults.Conflict) as cm:
ips.validate_ip_action(ip, "DELETE", silent=False)
self.assertEqual(cm.exception.message, expected_msg)
# Verify that the delete action fails with exception.
with mocked_quotaholder():
with self.assertRaises(faults.Conflict) as cm:
ips.delete_floating_ip(ip.id, self.credentials)
self.assertEqual(cm.exception.message, expected_msg)
# Test 2 - Check if we can delete a free IP.
#
# Force-detach IP from NIC.
ip.nic = None
ip.save()
# Verify that the validate function passes in silent mode.
res, _ = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertTrue(res)
# Verify that the delete action succeeds.
with mocked_quotaholder():
ips.delete_floating_ip(ip.id, self.credentials)
with self.assertRaises(ObjectDoesNotExist):
IPAddress.objects.get(id=ip.id)
def test_delete(self):
"""Test if the delete action succeeds/fails properly."""
# Create a floating IP and force-attach it to a NIC instance.
vm = mfactory.VirtualMachineFactory()
nic = mfactory.NetworkInterfaceFactory(network=self.network,
machine=vm)
with mocked_quotaholder():
ip = ips.create_floating_ip(
self.credentials, network_id=self.network.id)
ip.nic = nic
ip.save()
# Test 1 - Check if we can delete an IP attached to a VM.
#
# The validate function and the action should both fail with the
# following message.
expected_msg = "IP '{}' is used by server '{}'".format(ip.id, vm.id)
# Verify that the validate function fails in silent mode.
res, msg = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertFalse(res)
self.assertEqual(msg, expected_msg)
# Verify that the validate function fails in non-silent mode.
with self.assertRaises(faults.Conflict) as cm:
ips.validate_ip_action(ip, "DELETE", silent=False)
self.assertEqual(cm.exception.message, expected_msg)
# Verify that the delete action fails with exception.
with mocked_quotaholder():
with self.assertRaises(faults.Conflict) as cm:
ips.delete_floating_ip(ip.id, self.credentials)
self.assertEqual(cm.exception.message, expected_msg)
# Test 2 - Check if we can delete a free IP.
#
# Force-detach IP from NIC.
ip.nic = None
ip.save()
# Verify that the validate function passes in silent mode.
res, _ = ips.validate_ip_action(ip, "DELETE", silent=True)
self.assertTrue(res)
# Verify that the delete action succeeds.
with mocked_quotaholder():
ips.delete_floating_ip(ip.id, self.credentials)
with self.assertRaises(ObjectDoesNotExist):
IPAddress.objects.get(id=ip.id)
def test_create(self):
"""Test if a floating IP is created properly."""
with mocked_quotaholder():
ip = ips.create_floating_ip(
self.credentials, network_id=self.network.id)
self.assertEqual(len(self.network.ips.all()), 1)
self.assertEqual(self.network.ips.all()[0], ip)
def test_error_opcode(self, rapi, client):
# Mock getting network, because code will lookup if network exists
# in backend
rapi().GetNetwork.return_value = {}
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
network = mfactory.NetworkFactory()
mfactory.BackendNetworkFactory(network=network,
operstate="ACTIVE")
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE",
network=network)
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_remove(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
for old_state in ['success', 'canceled', 'error']:
for flavor in Network.FLAVORS.keys():
bn.operstate = old_state
bn.save()
net = bn.network
net.state = 'ACTIVE'
net.flavor = flavor
if flavor == 'PHYSICAL_VLAN':
net.link = allocate_resource('bridge')
if flavor == 'MAC_FILTERED':
net.mac_prefix = allocate_resource('mac_prefix')
net.save()
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id)
.exists())
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'DELETED', flavor)
self.assertTrue(db_net.deleted)
if flavor == 'PHYSICAL_VLAN':
pool = BridgePoolTable.get_pool()
self.assertTrue(pool.is_available(net.link))
if flavor == 'MAC_FILTERED':
pool = MacPrefixPoolTable.get_pool()
self.assertTrue(pool.is_available(net.mac_prefix))
def test_detach(self, mrapi):
"""Test the detach functionality."""
# Fail to detach a non-detachable volume
vol = mf.VolumeFactory(volume_type=self.file_vt,
machine=self.file_vm,
userid=self.userid,
status="IN_USE")
message = "Volume type '{}' is not detachable".format(
self.file_vt.disk_template)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach a volume that has never been attached to any server
vol = mf.VolumeFactory(userid=self.userid,
volume_type=self.archip_vt,
machine=None)
message = "Volume is already detached"
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach a volume that is not in use
vol = mf.VolumeFactory(userid=self.userid, volume_type=self.archip_vt)
vol.machine = self.archip_vm
vol.status = "CREATING"
vol.save()
message = "Cannot detach volume while volume is in '{}' status".format(
vol.status)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach the root volume of a vm
vol.status = "IN_USE"
vol.index = 0
vol.save()
message = "Cannot detach the root volume of server {}.".format(
self.archip_vm)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Detach a volume from a server
vol.userid = self.userid
vol.index = 1
vol.save()
mrapi().ModifyInstance.return_value = 42
with mocked_quotaholder() as m:
volumes.detach(vol.id, self.credentials)
# Assert that the VM has just one volume, the volume has an appropriate
# status and that no commission was sent.
self.assertEqual(self.archip_vm.volumes.all().count(), 1)
vol = Volume.objects.get(pk=vol.id)
self.assertEqual(vol.status, "DETACHING")
self.assertNoCommission(m)
# Assert that Ganeti was instructed to keep the disks and that the
# ModifyInstance command corresponds to the target volume and server.
gnt_args = self.get_ganeti_args(mrapi)
self.assertIn("keep_disks", gnt_args)
disk_args = self.get_ganeti_disk_args(mrapi)
self.assertEqual(disk_args[0], "remove")
self.assertEqual(disk_args[1], vol.backend_volume_uuid)
self.assertEqual(disk_args[2], {})
def test_delete_attached(self, mrapi):
# Test that we cannot delete root volume
vm = mf.VirtualMachineFactory(userid=self.userid)
vol = mf.VolumeFactory(machine=vm,
userid=self.userid,
status="IN_USE",
index=0,
size=self.size)
self.assertRaises(faults.BadRequest,
volumes.delete,
vol.id,
credentials=self.credentials)
# We can delete everything else
vol.index = 1
vol.save()
mrapi().ModifyInstance.return_value = 42
with mocked_quotaholder() as m:
volumes.delete(vol.id, credentials=self.credentials)
vol = Volume.objects.get(id=vol.id)
self.assertEqual(vol.backendjobid, 42)
args, kwargs = mrapi().ModifyInstance.call_args
expected_commission = {
(self.userid, "cyclades.disk"): -(self.size << 30)
}
self.assertCommissionEqual(m, expected_commission)
self.assertEqual(vol.status, "DELETING")
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(kwargs["disks"][0],
("remove", vol.backend_volume_uuid, {}))
def test_create(self):
"""Test if a floating IP is created properly."""
with mocked_quotaholder():
ip = ips.create_floating_ip(self.credentials,
network_id=self.network.id)
self.assertEqual(len(self.network.ips.all()), 1)
self.assertEqual(self.network.ips.all()[0], ip)
def test_error_opcode(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE")
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
client.basic_ack.assert_called_once()
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_unrescue_stopped_unrescued_vm(self):
"""Test unrescue a VM that is not in rescue mode"""
with mocked_quotaholder():
self.vm.operstate = "STOPPED"
self.vm.rescue = False
with self.assertRaises(faults.BadRequest):
servers.unrescue(self.vm, credentials=self.credentials)
def test_error_opcode(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE")
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
client.basic_ack.assert_called_once()
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_error_opcode(self, rapi, client):
# Mock getting network, because code will lookup if network exists
# in backend
rapi().GetNetwork.return_value = {}
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
network = mfactory.NetworkFactory()
mfactory.BackendNetworkFactory(network=network,
operstate="ACTIVE")
for state, _ in Network.OPER_STATES:
bn = mfactory.BackendNetworkFactory(operstate="ACTIVE",
network=network)
bn.operstate = state
bn.save()
network = bn.network
network.state = state
network.save()
for opcode, _ in BackendNetwork.BACKEND_OPCODES:
if opcode in ['OP_NETWORK_REMOVE', 'OP_NETWORK_ADD']:
continue
msg = self.create_msg(operation=opcode,
network=bn.network.backend_id,
status='error',
add_reserved_ips=[],
remove_reserved_ips=[],
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
db_bnet = BackendNetwork.objects.get(id=bn.id)
self.assertEqual(bn.operstate, db_bnet.operstate)
self.assertEqual(bn.network.state, db_bnet.network.state)
def test_delete_attached(self, mrapi):
# Test that we cannot delete root volume
vm = mf.VirtualMachineFactory(userid=self.userid)
vol = mf.VolumeFactory(machine=vm, userid=self.userid, status="IN_USE",
index=0, size=self.size)
self.assertRaises(faults.BadRequest,
volumes.delete,
vol.id, credentials=self.credentials)
# We can delete everything else
vol.index = 1
vol.save()
mrapi().ModifyInstance.return_value = 42
with mocked_quotaholder() as m:
volumes.delete(vol.id, credentials=self.credentials)
vol = Volume.objects.get(id=vol.id)
self.assertEqual(vol.backendjobid, 42)
args, kwargs = mrapi().ModifyInstance.call_args
expected_commission = {(self.userid, "cyclades.disk"):
- (self.size << 30)}
self.assertCommissionEqual(m, expected_commission)
self.assertEqual(vol.status, "DELETING")
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(kwargs["disks"][0], ("remove",
vol.backend_volume_uuid, {}))
def test_unsynced_flavor(self, mrapi):
flavor1 = mfactory.FlavorFactory(cpu=2,
ram=1024,
disk=1,
volume_type__disk_template="drbd")
flavor2 = mfactory.FlavorFactory(cpu=4,
ram=2048,
disk=1,
volume_type__disk_template="drbd")
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
flavor=flavor1,
operstate="STARTED")
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 2048,
"minmem": 2048,
"vcpus": 4},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"disk.names": [],
"disk.uuids": [],
"nic.ips": [],
"nic.names": [],
"nic.macs": [],
"nic.networks.names": [],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.flavor, flavor2)
self.assertEqual(vm1.operstate, "STARTED")
def test_unsynced_rescue_with_different_image(self, mrapi):
ganeti_image = mfactory.RescueImageFactory(
location="gnt-test.iso", location_type=RescueImage.FILETYPE_FILE)
cyclades_image = mfactory.RescueImageFactory(
location="snf-test.iso", location_type=RescueImage.FILETYPE_FILE)
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
rescue=True,
rescue_image=cyclades_image,
operstate="STOPPED")
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 1024,
"minmem": 1024,
"vcpus": 4},
"hvparams": {
"cdrom_image_path": os.path.join(settings.RESCUE_IMAGE_PATH,
"gnt-test.iso"),
"boot_order": "cdrom"
},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"disk.names": [],
"disk.uuids": [],
"nic.ips": [],
"nic.names": [],
"nic.macs": [],
"nic.networks.names": [],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.rescue, True)
self.assertEqual(vm1.rescue_image, ganeti_image)
def test_unsynced_nics(self, mrapi):
network1 = mfactory.NetworkWithSubnetFactory(
subnet__cidr="10.0.0.0/24", subnet__gateway="10.0.0.2")
network2 = mfactory.NetworkWithSubnetFactory(
subnet__cidr="192.168.2.0/24", subnet__gateway="192.168.2.2")
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
operstate="STOPPED")
subnet = network1.subnets.get(ipversion=4)
ip = mfactory.IPv4AddressFactory(nic__machine=vm1, network=network1,
subnet=subnet,
address="10.0.0.3")
nic = ip.nic
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 2048,
"minmem": 2048,
"vcpus": 4},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"nic.names": [nic.backend_uuid],
"nic.ips": ["192.168.2.5"],
"nic.macs": ["aa:00:bb:cc:dd:ee"],
"nic.networks.names": [network2.backend_id],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.operstate, "STARTED")
nic = vm1.nics.all()[0]
self.assertEqual(nic.network, network2)
self.assertEqual(nic.ipv4_address, "192.168.2.5")
self.assertEqual(nic.mac, "aa:00:bb:cc:dd:ee")
def test_delete(self, mrapi):
# We can not deleted detached volumes
vol = mf.VolumeFactory(machine=None, status="AVAILABLE")
self.assertRaises(faults.BadRequest,
volumes.delete,
vol)
vm = mf.VirtualMachineFactory(userid=vol.userid)
# Also we cannot delete root volume
vol.index = 0
vol.machine = vm
vol.status = "IN_USE"
vol.save()
self.assertRaises(faults.BadRequest,
volumes.delete,
vol)
# We can delete everything else
vol.index = 1
mrapi().ModifyInstance.return_value = 42
with mocked_quotaholder():
volumes.delete(vol)
self.assertEqual(vol.backendjobid, 42)
args, kwargs = mrapi().ModifyInstance.call_args
self.assertEqual(kwargs["instance"], vm.backend_vm_id)
self.assertEqual(kwargs["disks"][0], ("remove",
vol.backend_volume_uuid, {}))
def test_release(self):
ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
with mocked_quotaholder():
response = self.delete(URL + "/%s" % ip.id, ip.userid)
self.assertSuccess(response)
ips_after = floating_ips.filter(id=ip.id)
self.assertEqual(len(ips_after), 0)
def test_unsynced_flavor(self, mrapi):
flavor1 = mfactory.FlavorFactory(cpu=2, ram=1024, disk=1,
disk_template="drbd")
flavor2 = mfactory.FlavorFactory(cpu=4, ram=2048, disk=1,
disk_template="drbd")
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
flavor=flavor1,
operstate="STARTED")
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 2048,
"minmem": 2048,
"vcpus": 4},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"nic.ips": [],
"nic.names": [],
"nic.macs": [],
"nic.networks.names": [],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.flavor, flavor2)
self.assertEqual(vm1.operstate, "STARTED")
def test_unrescue_stopped_unrescued_vm(self):
"""Test unrescue a VM that is not in rescue mode"""
with mocked_quotaholder():
self.vm.operstate = "STOPPED"
self.vm.rescue = False
with self.assertRaises(faults.BadRequest):
servers.unrescue(self.vm, credentials=self.credentials)
def test_unrescue_started_vm(self):
"""Test unrescue a started VM"""
with mocked_quotaholder():
self.vm.task = None
self.vm.operstate = "STARTED"
with self.assertRaises(faults.BadRequest):
servers.unrescue(self.vm, credentials=self.credentials)
def test_release(self):
ip = mf.IPv4AddressFactory(userid="user1", floating_ip=True, nic=None)
with mocked_quotaholder():
response = self.delete(URL + "/%s" % ip.id, ip.userid)
self.assertSuccess(response)
ips_after = floating_ips.filter(id=ip.id)
self.assertEqual(len(ips_after), 0)
def test_unrescue_started_vm(self):
"""Test unrescue a started VM"""
with mocked_quotaholder():
self.vm.task = None
self.vm.operstate = "STARTED"
with self.assertRaises(faults.BadRequest):
servers.unrescue(self.vm, credentials=self.credentials)
def test_unsynced_unrescue(self, mrapi):
rescue_image = mfactory.RescueImageFactory(location="known.iso")
vm1 = mfactory.VirtualMachineFactory(backend=self.backend,
deleted=False,
rescue=True,
rescue_image=rescue_image,
operstate="STOPPED")
mrapi().GetInstances.return_value =\
[{"name": vm1.backend_vm_id,
"beparams": {"maxmem": 1024,
"minmem": 1024,
"vcpus": 4},
"hvparams": {"cdrom_image_path": "",
"boot_order": "disk"},
"oper_state": True,
"mtime": time(),
"disk.sizes": [],
"disk.names": [],
"disk.uuids": [],
"nic.ips": [],
"nic.names": [],
"nic.macs": [],
"nic.networks.names": [],
"tags": []}]
with mocked_quotaholder():
self.reconciler.reconcile()
vm1 = VirtualMachine.objects.get(id=vm1.id)
self.assertEqual(vm1.rescue, False)
self.assertEqual(vm1.rescue_image, None)
def test_remove(self, client):
mfactory.MacPrefixPoolTableFactory()
mfactory.BridgePoolTableFactory()
bn = mfactory.BackendNetworkFactory(operstate='ACTIVE')
for old_state in ['success', 'canceled', 'error']:
for flavor in Network.FLAVORS.keys():
bn.operstate = old_state
bn.save()
net = bn.network
net.state = 'ACTIVE'
net.flavor = flavor
if flavor == 'PHYSICAL_VLAN':
net.link = allocate_resource('bridge')
if flavor == 'MAC_FILTERED':
net.mac_prefix = allocate_resource('mac_prefix')
net.save()
msg = self.create_msg(operation='OP_NETWORK_REMOVE',
network=net.backend_id,
cluster=bn.backend.clustername)
with mocked_quotaholder():
update_network(client, msg)
self.assertTrue(client.basic_ack.called)
self.assertFalse(BackendNetwork.objects.filter(id=bn.id)
.exists())
db_net = Network.objects.get(id=net.id)
self.assertEqual(db_net.state, 'DELETED', flavor)
self.assertTrue(db_net.deleted)
if flavor == 'PHYSICAL_VLAN':
pool = BridgePoolTable.get_pool()
self.assertTrue(pool.is_available(net.link))
if flavor == 'MAC_FILTERED':
pool = MacPrefixPoolTable.get_pool()
self.assertTrue(pool.is_available(net.mac_prefix))
def test_create_server_wrong_flavor(self, mrapi):
# Test with a flavor that does not exist
request = deepcopy(self.request)
request["server"]["flavorRef"] = 42
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(request), "json")
self.assertItemNotFound(response)
# Test with an flavor that is not allowed
flavor = mfactory.FlavorFactory(allow_create=False)
request["server"]["flavorRef"] = flavor.id
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost("servers", "test_user", json.dumps(request), "json")
self.assertEqual(response.status_code, 403)
def test_rescue_stopped_rescued_vm(self):
"""Test rescue a stopped VM while in rescue mode"""
with mocked_quotaholder():
self.vm.task = None
self.vm.operstate = "STOPPED"
self.vm.rescue = True
with self.assertRaises(faults.BadRequest):
servers.rescue(self.vm, credentials=self.credentials)
def test_action_in_building_vm(self, mrapi, mimage):
"""Test building in progress"""
vm = mfactory.VirtualMachineFactory(operstate="BUILD")
request = {"start": {}}
with mocked_quotaholder():
response = self.mypost("servers/%d/action" % vm.id, vm.userid, json.dumps(request), "json")
self.assertEqual(response.status_code, 409)
self.assertFalse(mrapi.mock_calls)
def test_rescue_stopped_rescued_vm(self):
"""Test rescue a stopped VM while in rescue mode"""
with mocked_quotaholder():
self.vm.task = None
self.vm.operstate = "STOPPED"
self.vm.rescue = True
with self.assertRaises(faults.BadRequest):
servers.rescue(self.vm, credentials=self.credentials)
def test_commission(self, mrapi):
vm = mfactory.VirtualMachineFactory(operstate="STOPPED")
# Still pending
vm.serial = mfactory.QuotaHolderSerialFactory(serial=200,
resolved=False,
pending=True)
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
with self.assertRaises(quotas.ResolveError):
servers.start(vm)
# Not pending, rejct
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=400,
resolved=False,
pending=False,
accept=False)
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm)
m.resolve_commissions.assert_called_once_with([], [serial.serial])
self.assertTrue(m.issue_one_commission.called)
# Not pending, accept
vm.task = None
vm.serial = mfactory.QuotaHolderSerialFactory(serial=600,
resolved=False,
pending=False,
accept=True)
serial = vm.serial
mrapi().StartupInstance.return_value = 1
with mocked_quotaholder() as m:
servers.start(vm)
m.resolve_commissions.assert_called_once_with([serial.serial], [])
self.assertTrue(m.issue_one_commission.called)
mrapi().StartupInstance.side_effect = ValueError
vm.task = None
vm.serial = None
# Test reject if Ganeti erro
with mocked_quotaholder() as m:
try:
servers.start(vm)
except:
m.resolve_commissions\
.assert_called_once_with([], [vm.serial.serial])
def test_action_in_building_vm(self, mrapi, mimage):
"""Test building in progress"""
vm = mfactory.VirtualMachineFactory(operstate="BUILD")
request = {'start': {}}
with mocked_quotaholder():
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 409)
self.assertFalse(mrapi.mock_calls)
def test_detach(self, mrapi):
"""Test the detach functionality."""
# Fail to detach a non-detachable volume
vol = mf.VolumeFactory(volume_type=self.file_vt, machine=self.file_vm,
userid=self.userid, status="IN_USE")
message = "Volume type '{}' is not detachable".format(
self.file_vt.disk_template)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach a volume that has never been attached to any server
vol = mf.VolumeFactory(userid=self.userid, volume_type=self.archip_vt,
machine=None)
message = "Volume is already detached"
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach a volume that is not in use
vol = mf.VolumeFactory(userid=self.userid, volume_type=self.archip_vt)
vol.machine = self.archip_vm
vol.status = "CREATING"
vol.save()
message = "Cannot detach volume while volume is in '{}' status".format(
vol.status)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Fail to detach the root volume of a vm
vol.status = "IN_USE"
vol.index = 0
vol.save()
message = "Cannot detach the root volume of server {}.".format(
self.archip_vm)
with self.assertRaisesMessage(faults.BadRequest, message):
volumes.detach(vol.id, self.credentials)
# Detach a volume from a server
vol.userid = self.userid
vol.index = 1
vol.save()
mrapi().ModifyInstance.return_value = 42
with mocked_quotaholder() as m:
volumes.detach(vol.id, self.credentials)
# Assert that the VM has just one volume, the volume has an appropriate
# status and that no commission was sent.
self.assertEqual(self.archip_vm.volumes.all().count(), 1)
vol = Volume.objects.get(pk=vol.id)
self.assertEqual(vol.status, "DETACHING")
self.assertNoCommission(m)
# Assert that Ganeti was instructed to keep the disks and that the
# ModifyInstance command corresponds to the target volume and server.
gnt_args = self.get_ganeti_args(mrapi)
self.assertIn("keep_disks", gnt_args)
disk_args = self.get_ganeti_disk_args(mrapi)
self.assertEqual(disk_args[0], "remove")
self.assertEqual(disk_args[1], vol.backend_volume_uuid)
self.assertEqual(disk_args[2], {})
def test_stop(self, client):
vm = mfactory.VirtualMachineFactory()
msg = self.create_msg(operation='OP_INSTANCE_SHUTDOWN',
instance=vm.backend_vm_id)
with mocked_quotaholder():
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'STOPPED')
def test_create_server_wrong_flavor(self, mrapi):
# Test with a flavor that does not exist
request = deepcopy(self.request)
request["server"]["flavorRef"] = 42
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(request), 'json')
self.assertItemNotFound(response)
# Test with an flavor that is not allowed
flavor = mfactory.FlavorFactory(allow_create=False)
request["server"]["flavorRef"] = flavor.id
with override_settings(settings, **self.network_settings):
with mocked_quotaholder():
response = self.mypost('servers', 'test_user',
json.dumps(request), 'json')
self.assertEqual(response.status_code, 403)
