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 setUp(self):
settings.SKIP_SSH_VALIDATION = True
settings.HELPDESK_ENABLED = True
self.client = AuthClient()
# init models
vm1u1 = mfactory.VirtualMachineFactory(userid=USER1,
name="user1 vm",
pk=1001)
vm1u2 = mfactory.VirtualMachineFactory(userid=USER2,
name="user2 vm1",
pk=1002)
vm2u2 = mfactory.VirtualMachineFactory(userid=USER2,
name="user2 vm2",
pk=1003)
nic1 = mfactory.NetworkInterfaceFactory(machine=vm1u2,
userid=vm1u2.userid,
network__public=False,
network__userid=USER1)
ip2 = mfactory.IPv4AddressFactory(nic__machine=vm1u1,
userid=vm1u1.userid,
network__public=True,
network__userid=None,
address="195.251.222.211")
mfactory.IPAddressLogFactory(address=ip2.address,
server_id=vm1u1.id,
network_id=ip2.network.id,
active=True)
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 setUp(self):
self.user1 = 'user1'
self.user2 = 'user2'
self.vm1 = mfactory.VirtualMachineFactory(userid=self.user1)
self.vm2 = mfactory.VirtualMachineFactory(userid=self.user2)
self.vm3 = mfactory.VirtualMachineFactory(deleted=True,
userid=self.user1)
self.vm4 = mfactory.VirtualMachineFactory(userid=self.user2)
super(ServerAPITest, self).setUp()
def setUp(self):
self.user1 = 'user1'
self.user2 = 'user2'
self.vm1 = mfactory.VirtualMachineFactory(userid=self.user1,
name=u"Hi \u2601")
self.vm2 = mfactory.VirtualMachineFactory(userid=self.user2)
self.vm3 = mfactory.VirtualMachineFactory(deleted=True,
userid=self.user1)
self.vm4 = mfactory.VirtualMachineFactory(userid=self.user2)
def test_vm_holdings(self):
flavor = mfactory.FlavorFactory(cpu=24, ram=8192, disk=20)
mfactory.VirtualMachineFactory(userid="user1", deleted=True)
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user1",
operstate="BUILD")
mfactory.VolumeFactory(userid="user1", size=20, machine=None)
user_holdings = {
"user1": {
"user1": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.cpu": 24,
"cyclades.disk": 20 << 30,
"cyclades.total_ram": 8192 << 20,
"cyclades.ram": 8192 << 20
}
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
holdings = util.get_db_holdings()
self.assertEqual(holdings["user1"], user_holdings["user1"])
mfactory.VirtualMachineFactory(flavor=flavor, userid="user1")
##
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user2",
operstate="STARTED")
mfactory.VolumeFactory(userid="user2", size=30, machine=None)
user_holdings = {
"user2": {
"user2": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.cpu": 24,
"cyclades.disk": 30 << 30,
"cyclades.total_ram": 8192 << 20,
"cyclades.ram": 8192 << 20
}
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user3",
operstate="STOPPED")
user_holdings = {
"user3": {
"user3": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.total_ram": 8589934592
}
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
def test_suspended_vms(self):
"""Test if suspended VMs for a user are displayed properly."""
# The VMs that will be shown at any time to the user are limited by the
# setting below.
start = 1134
end = start + admin_settings.ADMIN_LIMIT_SUSPENDED_VMS_IN_SUMMARY
# Test 1 - Assert that 'None' is displayed when there are no suspended
# VMs.
vms = get_suspended_vms(self.user)
self.assertEqual(vms, 'None')
# Test 2 - Assert that only one href is printed when there is only one
# suspended VM.
mf.VirtualMachineFactory(userid=self.user.uuid,
pk=start,
name='Name{}'.format(start),
suspended=True)
vms = get_suspended_vms(self.user)
self.assertEqual(vms, self.expected_href(start))
# Test 3 - Assert that the hrefs are comma-separated when there are
# more than one suspended VMs, in descending ID order.
#
# Create one more VM, get the list of suspended VMs and split it.
mf.VirtualMachineFactory(userid=self.user.uuid,
pk=(start + 1),
name='Name{}'.format(start + 1),
suspended=True)
vms = get_suspended_vms(self.user).split(', ')
# Asssert that each element of the list (1135, 1134) is displayed
# properly.
for pk in reversed(xrange(start, start + 2)):
i = start + 1 - pk
self.assertEqual(vms[i], self.expected_href(pk))
# Test 4 - Assert that dots ('...') are printed when there are too
# many suspended VMs and that the older VMs are ommited.
#
# Create more VMs than the current limit and split them like before.
for pk in range(start + 2, end + 1):
mf.VirtualMachineFactory(userid=self.user.uuid,
pk=pk,
name='Name{}'.format(pk),
suspended=True)
vms = get_suspended_vms(self.user).split(', ')
# Asssert that each element of the list (1144...1135) is displayed
# properly and that the VM that was created first is ommited and
# replaced with dots ('...').
for pk in reversed(xrange(start, end + 1)):
i = end - pk
if pk == start:
self.assertEqual(vms[i], '...')
else:
self.assertEqual(vms[i], self.expected_href(pk))
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_server_port_forwarding(self):
vm = mfactory.VirtualMachineFactory()
# test None if the server has no public IP
ports = {
22: ("foo", 61000),
80: lambda ip, id, fqdn, user: ("bar", 61001)
}
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"], {})
# Add with public IP
mfactory.IPv4AddressFactory(nic__machine=vm, network__public=True)
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(
server["SNF:port_forwarding"], {
"22": {
"host": "foo",
"port": "61000"
},
"80": {
"host": "bar",
"port": "61001"
}
})
def _port_from_ip(ip, base):
fields = ip.split('.', 4)
return (base + 256 * int(fields[2]) + int(fields[3]))
ports = {
22:
lambda ip, id, fqdn, user: ip and
("gate", _port_from_ip(ip, 10000)) or None
}
vm = mfactory.VirtualMachineFactory()
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"], {})
mfactory.IPv4AddressFactory(nic__machine=vm,
network__public=True,
address="192.168.2.2")
with override_settings(settings, CYCLADES_PORT_FORWARDING=ports):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:port_forwarding"],
{"22": {
"host": "gate",
"port": "10514"
}})
def test_vm_holdings(self):
flavor = mfactory.FlavorFactory(cpu=24,
ram=8192,
disk=20,
disk_template='drbd')
mfactory.VirtualMachineFactory()
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user1",
operstate="BUILD")
user_holdings = {
"user1": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.cpu": 24,
"cyclades.disk": 21474836480,
"cyclades.total_ram": 8589934592,
"cyclades.ram": 8589934592
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
holdings = util.get_db_holdings()
self.assertEqual(holdings["user1"], user_holdings["user1"])
mfactory.VirtualMachineFactory(flavor=flavor, userid="user1")
##
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user2",
operstate="STARTED")
user_holdings = {
"user2": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.cpu": 24,
"cyclades.disk": 21474836480,
"cyclades.total_ram": 8589934592,
"cyclades.ram": 8589934592
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
mfactory.VirtualMachineFactory(flavor=flavor,
userid="user3",
operstate="STOPPED")
user_holdings = {
"user3": {
"cyclades.vm": 1,
"cyclades.total_cpu": 24,
"cyclades.disk": 21474836480,
"cyclades.total_ram": 8589934592
}
}
holdings = util.get_db_holdings(user="******")
self.assertEqual(holdings, user_holdings)
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_server_fqdn(self):
vm = mfactory.VirtualMachineFactory()
# Setting set to None
with override_settings(settings, CYCLADES_SERVERS_FQDN=None):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], None)
# Unformated setting
with override_settings(settings,
CYCLADES_SERVERS_FQDN="vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"], "vm.example.org")
# Formatted settings
with override_settings(
settings, CYCLADES_SERVERS_FQDN="snf-%(id)s.vm.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"],
"snf-%d.vm.example.org" % vm.id)
with override_settings(
settings,
CYCLADES_SERVERS_FQDN="snf-%(id)s.vm-%(id)s.example.org"):
response = self.myget("servers/%d" % vm.id, vm.userid)
server = json.loads(response.content)['server']
self.assertEqual(server["SNF:fqdn"],
"snf-%d.vm-%d.example.org" % (vm.id, vm.id))
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()
self.vm1.operstate = 'STARTED'
self.vm1.save()
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()
self.vm1.operstate = 'STOPPED'
self.vm1.save()
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_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_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_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_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_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_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_error_snapshot(self, pithos_backend, client):
vm = mfactory.VirtualMachineFactory()
disks = [
(0, {"snapshot_info": json.dumps({"snapshot_id":
"test_snapshot_id"})})
]
msg = self.create_msg(operation='OP_INSTANCE_SNAPSHOT',
instance=vm.backend_vm_id,
job_fields={'disks': disks},
status="running")
update_db(client, msg)
self.assertEqual(pithos_backend().update_object_status.mock_calls, [])
msg = self.create_msg(operation='OP_INSTANCE_SNAPSHOT',
instance=vm.backend_vm_id,
job_fields={'disks': disks},
event_time=split_time(time()),
status="error")
update_db(client, msg)
pithos_backend().update_object_status\
.assert_called_once_with("test_snapshot_id", state=-1)
pithos_backend.reset_mock()
msg = self.create_msg(operation='OP_INSTANCE_SNAPSHOT',
instance=vm.backend_vm_id,
job_fields={'disks': disks},
event_time=split_time(time()),
status="success")
update_db(client, msg)
pithos_backend().update_object_status\
.assert_called_once_with("test_snapshot_id", state=1)
def test_stale_building_vm(self, client):
vm = mfactory.VirtualMachineFactory()
vm.state = 'BUILD'
vm.backendjobid = 42
vm.save()
D = {vm.id: 'BUILD'}
G = {}
for status in ['queued', 'waiting', 'running']:
client.return_value.GetJobStatus.return_value = {'status': status}
self.assertEqual(reconciliation.stale_servers_in_db(D, G), set([]))
client.return_value.GetJobStatus\
.assert_called_once_with(vm.backendjobid)
client.reset_mock()
for status in ['success', 'error', 'canceled']:
client.return_value.GetJobStatus.return_value = {'status': status}
self.assertEqual(reconciliation.stale_servers_in_db(D, G), set([]))
client.return_value.GetInstance\
.assert_called_once_with(vm.backend_vm_id)
client.return_value.GetJobStatus\
.assert_called_once_with(vm.backendjobid)
client.reset_mock()
from synnefo.logic.rapi import GanetiApiError
client.return_value.GetJobStatus.side_effect = GanetiApiError('Foo')
self.assertEqual(reconciliation.stale_servers_in_db(D, G),
set([vm.id]))
def test_create_port_private_net(self, mrapi):
net = dbmf.NetworkFactory(public=False)
dbmf.IPv4SubnetFactory(network=net)
dbmf.IPv6SubnetFactory(network=net)
sg1 = dbmf.SecurityGroupFactory()
sg2 = dbmf.SecurityGroupFactory()
vm = dbmf.VirtualMachineFactory(userid=net.userid)
request = {
"port": {
"name": "port1",
"network_id": str(net.id),
"device_id": str(vm.id),
"security_groups": [str(sg1.id), str(sg2.id)]
}
}
mrapi().ModifyInstance.return_value = 42
with override_settings(settings, GANETI_USE_HOTPLUG=False):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 400)
with override_settings(settings, GANETI_USE_HOTPLUG=True):
response = self.post(PORTS_URL,
params=json.dumps(request),
user=net.userid)
self.assertEqual(response.status_code, 201)
def create_virtual_machine(self, operstate=''):
vm = models_factory.VirtualMachineFactory()
if operstate:
vm.operstate = operstate
vm.save()
return vm
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_active_server(self):
"""Test console req for ACTIVE server"""
vm = mfactory.VirtualMachineFactory()
vm.operstate = 'STARTED'
vm.save()
data = json.dumps({'console': {'type': 'vnc'}})
with patch('synnefo.logic.rapi_pool.GanetiRapiClient') as rapi:
rapi().GetInstance.return_value = {
"pnode": "node1",
"network_port": 5055,
"oper_state": True,
"hvparams": {
"serial_console": False
}
}
with patch("synnefo.logic.servers.request_vnc_forwarding") as vnc:
vnc.return_value = {"status": "OK", "source_port": 42}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
data, 'json')
self.assertEqual(response.status_code, 200)
reply = json.loads(response.content)
self.assertEqual(reply.keys(), ['console'])
console = reply['console']
self.assertEqual(console['type'], 'vnc')
self.assertEqual(set(console.keys()),
set(['type', 'host', 'port', 'password']))
def test_not_active_server(self):
"""Test console req for not ACTIVE server returns badRequest"""
vm = mfactory.VirtualMachineFactory(operstate="BUILD")
data = json.dumps({'console': {'type': 'vnc'}})
response = self.mypost('servers/%d/action' % vm.id, vm.userid, data,
'json')
self.assertBadRequest(response)
def test_destroy_build_vm(self, mrapi, mimage):
"""Test building in progress"""
vm = mfactory.VirtualMachineFactory()
mrapi().DeleteInstance.return_value = 2
response = self.mydelete('servers/%d' % vm.id, vm.userid)
self.assertSuccess(response)
mrapi().RemoveInstance.assert_called_once()
def test_actions(self, mrapi, mimage):
actions = ['start', 'shutdown', 'reboot']
vm = mfactory.VirtualMachineFactory()
vm.operstate = "STOPPED"
vm.save()
mrapi().StartupInstance.return_value = 0
mrapi().ShutdownInstance.return_value = 1
mrapi().RebootInstance.return_value = 2
for jobId, action in enumerate(actions):
if action in ["shutdown", "reboot"]:
vm.operstate = "STARTED"
else:
vm.operstate = "STOPPED"
vm.task = None
vm.task_job_id = None
vm.save()
val = {'type': 'HARD'} if action == 'reboot' else {}
request = {action: val}
response = self.mypost('servers/%d/action' % vm.id, vm.userid,
json.dumps(request), 'json')
self.assertEqual(response.status_code, 202)
if action == 'shutdown':
self.assertEqual(
VirtualMachine.objects.get(id=vm.id).task, "STOP")
else:
self.assertEqual(
VirtualMachine.objects.get(id=vm.id).task, action.upper())
self.assertEqual(
VirtualMachine.objects.get(id=vm.id).task_job_id, jobId)
def test_create(self, client):
vm = mfactory.VirtualMachineFactory()
msg = self.create_msg(operation='OP_INSTANCE_CREATE',
instance=vm.backend_vm_id)
update_db(client, msg)
self.assertTrue(client.basic_ack.called)
db_vm = VirtualMachine.objects.get(id=vm.id)
self.assertEqual(db_vm.operstate, 'STARTED')
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()
