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()