async def test_kill_non_existing_vm(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(tested.vms) == 1 with pytest.raises(Exception): await tested.destroy_vm("nonexisting") assert len(tested.vms) == 1
async def test_start_stop_machine(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await alloc.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(alloc.vms) == 1 assert 'sasha-vm-0' in alloc.vms await manager.stop_vm(alloc.vms["sasha-vm-0"]) mock_libvirt.poweroff_vm.assert_called_once() start_count = mock_libvirt.start_vm.call_count await manager.start_vm(alloc.vms["sasha-vm-0"]) assert mock_libvirt.start_vm.call_count == start_count + 1
async def test_create_machine_and_restore_machine(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(2) macs = _generate_macs(2) manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_image_store.clone_qcow.return_value = "/tmp/image.qcow" mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") old_allocator = allocator.Allocator(copy.copy(macs), copy.copy(gpu1), manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await old_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(old_allocator.vms) == 1 assert 'sasha-vm-0' in old_allocator.vms old_vm_info = await manager.info(old_allocator.vms['sasha-vm-0']) # Get json with which machine was created vm_def = mock_libvirt.define_vm.call_args.args[0] vm_metadata_to_restore = _emulate_libvirt_xml_dump_and_load(vm_def) mock_libvirt.load_lab_vms.return_value = [vm_metadata_to_restore] # Now recreate the allocator tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.restore_vms() sasha_vm = tested.vms['sasha-vm-0'] assert len(tested.vms) == 1 assert 'sasha-vm-0' in tested.vms assert str(sasha_vm.sol_port) in tested.sol_used_ports for pci in sasha_vm.pcis: assert pci.full_address not in [ pci.full_address for pci in tested.gpus_list ] vm_macs = [net['macaddress'] for net in sasha_vm.net_ifaces] for mac in vm_macs: assert mac not in tested.mac_addresses restored_vm_info = await manager.info(old_allocator.vms['sasha-vm-0']) assert restored_vm_info == old_vm_info
async def test_allocate_machine_no_gpus(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpus = [] macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) tested = allocator.Allocator(macs, gpus, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", base_image_size=None, memory_gb=1, networks=["bridge"], num_cpus=2, num_gpus=0) assert len(tested.vms) == 1 vm = tested.vms['sasha-vm-0'] _verify_vm_valid(tested, vm, expected_vm_name="sasha-vm-0", expected_base_image="/home/sasha_king.qcow", expected_gpus=[], expected_mem=1, expected_networks=[{ "mac": macs[0], "type": "bridge", "source": "eth0" }], num_cpus=2) mock_image_store.clone_qcow.assert_called_with("sasha_image1", "sasha-vm-0", None) # # FIXME: add assertion on call mock_libvirt.define_vm.assert_called() # Now destroy the VM await tested.destroy_vm("sasha-vm-0") assert len(tested.vms) == 0 assert tested.gpus_list == [] assert tested.mac_addresses == macs mock_image_store.delete_qcow.assert_called_with("/home/sasha_king.qcow") mock_libvirt.kill_by_name.assert_called_with("sasha-vm-0")
async def test_allocate_more_vms_than_we_can(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpus = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) tested = allocator.Allocator(macs, gpus, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=0) assert len(tested.vms) == 1 with pytest.raises(NotEnoughResourceException): await tested.allocate_vm("sasha_image2", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=0) assert len(tested.vms) == 1 # Now destroy the VM await tested.destroy_vm("sasha-vm-0") assert len(tested.vms) == 0 assert tested.gpus_list == gpus assert tested.mac_addresses == macs # Now we can allocate more await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=0) assert len(tested.vms) == 1
async def test_vm_info(mock_libvirt, mock_image_store, aiohttp_client, loop, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") mock_libvirt.dhcp_lease_info.return_value = { '52:54:00:8d:c0:07': ['192.168.122.186', '192.168.122.187'], '52:54:00:8d:c0:08': ['192.168.122.188'] } mock_cloud_init.generate_iso.return_value = "/tmp/iso_path" mock_libvirt.status.return_value = 'on' mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") manager = vm_manager.VMManager(loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=1000) with mock.patch("socket.socket"): await alloc.allocate_vm("sasha_image1", memory_gb=1, base_image_size=20, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(alloc.vms) == 1 assert 'sasha-vm-0' in alloc.vms app = web.Application() rest.HyperVisor(alloc, image_store, app) client = await aiohttp_client(app) resp = await client.get("/vms/sasha-vm-0") vm = await resp.json() assert vm == { 'info': { 'name': 'sasha-vm-0', 'disks': [], 'status': 'on', 'dhcp': { '52:54:00:8d:c0:07': ['192.168.122.186', '192.168.122.187'], '52:54:00:8d:c0:08': ['192.168.122.188'] } } }
async def test_machine_info(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(2) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") mock_libvirt.dhcp_lease_info.return_value = { '52:54:00:8d:c0:07': ['192.168.122.186'], '52:54:00:8d:c0:08': ['192.168.122.187'] } mock_libvirt.status.return_value = "on" manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await alloc.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["isolated", "isolated"], num_cpus=2, num_gpus=1, disks=[{ "type": "ssd", "size": 10, "fs": "ext4" }, { "type": "hdd", "size": 5, "fs": "ext4" }]) assert len(alloc.vms) == 1 assert 'sasha-vm-0' in alloc.vms vm_info = await manager.info(alloc.vms['sasha-vm-0']) mock_libvirt.dhcp_lease_info.assert_called_once_with("sasha-vm-0") mock_libvirt.status.assert_called_once_with("sasha-vm-0") assert len(vm_info['disks']) == 2 assert vm_info['status'] == 'on' assert vm_info['dhcp'] == { '52:54:00:8d:c0:07': ['192.168.122.186'], '52:54:00:8d:c0:08': ['192.168.122.187'] }
async def test_free_resources_on_destroy_or_exception(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(2) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") mock_cloud_init.generate_iso.return_value = "my_iso.iso" tested_allocator = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) assert tested_allocator.sol_used_ports == [] vm1 = await tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1) assert tested_allocator.sol_used_ports == [5000] assert len(tested_allocator.gpus_list) == len(gpu1) - 1 assert len(tested_allocator.mac_addresses) == len(macs) - 1 await tested_allocator.destroy_vm(vm1.name) assert tested_allocator.sol_used_ports == [] assert len(tested_allocator.gpus_list) == len(gpu1) assert len(tested_allocator.mac_addresses) == len(macs) with mock.patch.object(vm.VM, '__init__', Exception("boom!")): try: await tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1) except: pass assert tested_allocator.sol_used_ports == [] assert len(tested_allocator.gpus_list) == len(gpu1) assert len(tested_allocator.mac_addresses) == len(macs)
async def test_restore_machine_fail_to_restore_network_timeout_success( event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(2) macs = _generate_macs(2) mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_image_store.clone_qcow.return_value = "/tmp/image.qcow" old_allocator = allocator.Allocator(copy.copy(macs), copy.copy(gpu1), manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await old_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(old_allocator.vms) == 1 assert 'sasha-vm-0' in old_allocator.vms old_vm_info = await manager.info(old_allocator.vms['sasha-vm-0']) # Get json with which machine was created vm_def = mock_libvirt.define_vm.call_args.args[0].json # Now set load to return same json mock_libvirt.load_lab_vms.return_value = [munch.Munch(vm_def)] # Now recreate the allocator mock_dhcp_handler.reallocate_ip = mock.AsyncMock( side_effect=TimeoutError("Failed to allocate ip")) tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.restore_vms() assert len(tested.vms) == 1 assert 'sasha-vm-0' in tested.vms restored_vm_info = await manager.info(old_allocator.vms['sasha-vm-0']) assert restored_vm_info == old_vm_info
async def test_load_vm_info(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): tested = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) vm_images = [{"serial": "s1", "device_name": "dev1", "image" : "image", "type" : "hdd", "size" : 10}] machine = dict(name="name", num_cpus=1, memsize=1, net_ifaces=[], sol_port=2, base_image='image', disks=vm_images) mock_libvirt.load_lab_vms.return_value = [machine, machine] vms = await tested.load_vms_data() assert len(vms) == 2 assert vms[0] == machine assert vms[1] == machine
async def test_network_info_not_failing(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): tested = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_libvirt.dhcp_lease_info.side_effect = Exception("exception") mock_libvirt.status.return_value = "on" vm_images = [{"serial": "s1", "device_name": "dev1", "image" : "image", "type" : "hdd", "size" : 10}] machine = vm.VM(name="name", num_cpus=1, memsize=1, net_ifaces=[], sol_port=2, base_image='image', disks=vm_images) info = await tested.info(machine) assert info['status'] == 'on'
async def test_restore_machine_fail_to_restore_network( event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(2) macs = _generate_macs(2) mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_image_store.clone_qcow.return_value = "/tmp/image.qcow" old_allocator = allocator.Allocator(copy.copy(macs), copy.copy(gpu1), manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await old_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(old_allocator.vms) == 1 assert 'sasha-vm-0' in old_allocator.vms # Get json with which machine was created vm_def = mock_libvirt.define_vm.call_args.args[0] vm_metadata_to_restore = _emulate_libvirt_xml_dump_and_load(vm_def) mock_libvirt.load_lab_vms.return_value = [vm_metadata_to_restore] # Now recreate the allocator mock_dhcp_handler.reallocate_ip = mock.AsyncMock( side_effect=Exception("Failed to allocate ip")) tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.restore_vms() assert len(tested.vms) == 0 # We still must have all resources that allocator was initializes with assert tested.mac_addresses == macs assert tested.gpus_list == gpu1
async def test_vm_allocate(mock_libvirt, mock_image_store, aiohttp_client, loop, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") mock_cloud_init.generate_iso.return_value = "/tmp/iso_path" mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") manager = vm_manager.VMManager(loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=1000) # Note that here we need to hack it in order not to bind to real port alloc._reserve_free_port = lambda x: x app = web.Application() rest.HyperVisor(alloc, image_store, app) client = await aiohttp_client(app) resp = await client.post("/vms", json={ "base_image": "base.qcow", "ram": 100, "num_cpus": 1, "networks": ['bridge'], "num_gpus": 1, "disks": [] }) assert resp.status == 200 assert len(alloc.vms) == 1 assert 'sasha-vm-0' in alloc.vms
async def test_delete_machines_on_start(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(2) manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) existing_vms = [ vm.VM(name="name1", num_cpus=1, memsize=1, net_ifaces=[], sol_port=2, base_image='image').json, vm.VM(name="name2", num_cpus=11, memsize=11, net_ifaces=[], sol_port=22, base_image='image').json ] mock_libvirt.load_lab_vms.return_value = existing_vms await alloc.delete_all_dangling_vms() # Now lets make sure libvirt was called to destory vms mock_libvirt.kill_by_name.assert_has_calls( [mock.call("name1"), mock.call("name2")])
async def test_allocate_machine_happy_case(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") mock_cloud_init.generate_iso.return_value = "my_iso.iso" tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(tested.vms) == 1 vm = tested.vms['sasha-vm-0'] _verify_vm_valid(tested, vm, expected_vm_name="sasha-vm-0", expected_base_image="/home/sasha_king.qcow", expected_gpus=gpu1, expected_mem=1, expected_networks=[{ "mac": macs[0], "type": "bridge", "source": "eth0", "ip": "1.1.1.1" }], num_cpus=2, base_image_size=10) mock_cloud_init.generate_iso.assert_called_with(vm) mock_dhcp_handler.allocate_ip.assert_called() mock_image_store.clone_qcow.assert_called_with("sasha_image1", "sasha-vm-0", 10) mock_libvirt.define_vm.assert_called() # Now destroy the VM await tested.destroy_vm("sasha-vm-0") assert len(tested.vms) == 0 assert tested.gpus_list == gpu1 assert tested.mac_addresses == macs mock_image_store.delete_qcow.assert_called_with("/home/sasha_king.qcow") mock_libvirt.kill_by_name.assert_called_with("sasha-vm-0") mock_dhcp_handler.deallocate_ip.assert_called_once() await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks="bridge", num_cpus=2, num_gpus=1) assert len(tested.vms) == 1 await tested.destroy_vm("sasha-vm-0") assert len(tested.vms) == 0
async def test_concurrent_allocation_and_free_resources( event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(2) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") mock_cloud_init.generate_iso.return_value = "my_iso.iso" tested_allocator = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) # check that creating too many vms concurrently will cause a problem: with pytest.raises(NotEnoughResourceException): await asyncio.gather( tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1), tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1), tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1), tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1), tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1), tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1)) assert len(tested_allocator.vms) == 1 await tested_allocator.destroy_vm("sasha-vm-0") assert len(tested_allocator.vms) == 0 assert tested_allocator.gpus_list == gpu1 assert set(tested_allocator.mac_addresses) == set(macs) with mock.patch.object(vm.VM, '__init__', Exception("boom!")): with pytest.raises(Exception): await tested_allocator.allocate_vm("sasha_image1", memory_gb=1, base_image_size=10, networks=["bridge"], num_cpus=2, num_gpus=1)
async def test_vm_list(mock_libvirt, mock_image_store, aiohttp_client, loop, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") mock_libvirt.status.return_value = 'on' mock_cloud_init.generate_iso.return_value = "/tmp/iso_path" mock_dhcp_handler.allocate_ip = mock.AsyncMock(return_value="1.1.1.1") manager = vm_manager.VMManager(loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) alloc = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=1000) with mock.patch("uuid.uuid4") as uuid4: uuid4.return_value = "uuid" with mock.patch("socket.socket"): await alloc.allocate_vm("sasha_image1", base_image_size=20, memory_gb=1, networks=["bridge"], num_cpus=2, num_gpus=1) assert len(alloc.vms) == 1 assert 'sasha-vm-0' in alloc.vms app = web.Application() rest.HyperVisor(alloc, image_store, app) client = await aiohttp_client(app) resp = await client.get("/vms") vms = await resp.json() assert vms == { 'vms': [{ 'name': 'sasha-vm-0', "uuid": "uuid", 'num_cpus': 2, 'memsize': 1, 'net_ifaces': [{ 'ip': '1.1.1.1', 'macaddress': '00:00:00:00:00:00', 'mode': 'bridge', 'source': 'eth0' }], 'pcis': ["0:0:0.0"], "api_version": "v1", "base_image": "sasha_image1", 'base_image_size': 20, 'image': '/home/sasha_king.qcow', 'disks': [], 'status': 'on', "sol_port": 1000, 'cloud_init_iso': '/tmp/iso_path', 'allocation_id': None, 'requestor': None, 'password': '******', 'user': '******' }] }
_check_kvm_ok() _setup_macvlan_device(args.paravirt_net_device) vmm = libvirt_wrapper.LibvirtWrapper(args.qemu_uri) _check_network_interface_up(args.paravirt_net_device) _check_libvirt_network_is_up(vmm, args.private_net) storage = image_store.ImageStore(loop, base_qcow_path=args.images_dir, run_qcow_path=args.run_dir, ssd_path=args.ssd_dir, hdd_path=args.hdd_dir) gpu_pci_devices = config['pci'] _vfio_bind_pci_devices(config['pci']) ndb_driver = libstorage.NBDProvisioner() ndb_driver.initialize() vm_boot_init = cloud_init.CloudInit(args.run_dir) bridged_dhcp = dhcp_handlers.DHCPRequestor(args.paravirt_net_device, loop) nat_dhcp = dhcp_handlers.LibvirtDHCPAllocator(loop, vmm, args.private_net) dhcp_client = dhcp_handlers.DHCPManager(handlers={'bridge': bridged_dhcp, 'isolated' : nat_dhcp}) manager = vm_manager.VMManager(loop, vmm, storage, ndb_driver, vm_boot_init, dhcp_client) allocator = allocator.Allocator(mac_addresses=config['macs'], gpus_list=gpu_pci_devices, vm_manager=manager, server_name=args.server_name, max_vms=args.max_vms, private_network=args.private_net, paravirt_device=args.paravirt_net_device, sol_base_port=args.sol_port) if args.vms_restore: loop.run_until_complete(allocator.restore_vms()) else: loop.run_until_complete(allocator.delete_all_dangling_vms()) app = web.Application() app["info"] = dict(alias=f'{args.server_name}-hypervisor', rm_type='hypervisor', endpoint=f'{ip.get_ip()}:{args.port}') if args.provisioner is not None: app["provisioner_address"] = args.provisioner app.on_startup.append(start_daemons) rest.HyperVisor(allocator, storage, app)
async def test_allocate_multiple(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpus = _generate_device(10) macs = _generate_macs(10) mock_image_store.clone_qcow = mock.AsyncMock( side_effect=["1.qcow", "2.qcow"]) manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) tested = allocator.Allocator(macs, gpus, manager, "sasha", max_vms=3, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge"], num_cpus=2, num_gpus=2) assert len(tested.vms) == 1 # Lets verify that we have 8 gpus and 9 nics left in pool assert len(tested.gpus_list) == 8 assert len(tested.mac_addresses) == 9 await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["bridge", "isolated"], num_cpus=2, num_gpus=3) assert len(tested.vms) == 2 # Lets verify that we have 8 gpus and 9 nics left in pool assert len(tested.gpus_list) == 5 assert len(tested.mac_addresses) == 7 # Now lets exaust gpus with pytest.raises(NotEnoughResourceException): await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=[], num_cpus=2, num_gpus=6) assert len(tested.vms) == 2 assert len(tested.gpus_list) == 5 assert len(tested.mac_addresses) == 7 # Lets exaust macs with pytest.raises(NotEnoughResourceException): await tested.allocate_vm("sasha_image1", memory_gb=1, base_image_size=None, networks=["isolated"] * 8, num_cpus=2, num_gpus=0) assert len(tested.vms) == 2 assert len(tested.gpus_list) == 5 assert len(tested.mac_addresses) == 7
async def test_allocate_machine_with_disks(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler): gpu1 = _generate_device(1) macs = _generate_macs(1) mock_image_store.clone_qcow = mock.AsyncMock( return_value="/home/sasha_king.qcow") mock_image_store.create_qcow = mock.AsyncMock( side_effect=["/home/disk1.qcow", "/home/disk2.qcow"]) manager = vm_manager.VMManager(event_loop, mock_libvirt, mock_image_store, mock_nbd_provisioner, mock_cloud_init, mock_dhcp_handler) tested = allocator.Allocator(macs, gpu1, manager, "sasha", max_vms=1, paravirt_device="eth0", sol_base_port=5000) await tested.allocate_vm("sasha_image1", base_image_size=None, memory_gb=1, networks=["bridge"], num_cpus=2, num_gpus=1, disks=[{ "type": "ssd", "size": 10, "fs": "xfs" }, { "type": "hdd", "size": 5, "fs": "ext4" }]) assert len(tested.vms) == 1 vm = tested.vms['sasha-vm-0'] ssd = _find_disks_by_type(vm, "ssd")[0] hdd = _find_disks_by_type(vm, "hdd")[0] _verify_vm_valid(tested, vm, expected_vm_name="sasha-vm-0", expected_base_image="/home/sasha_king.qcow", expected_gpus=gpu1, expected_mem=1, expected_networks=[{ "mac": macs[0], "type": "bridge", "source": "eth0" }], num_cpus=2, disks=[ssd, hdd]) provision_calls = [ call(ssd['image'], 'xfs', ssd['serial']), call(hdd['image'], 'ext4', hdd['serial']) ] mock_nbd_provisioner.provision_disk.assert_has_calls(provision_calls, any_order=True) mock_image_store.clone_qcow.assert_called_with("sasha_image1", "sasha-vm-0", None) mock_libvirt.define_vm.assert_called() # Now destroy the VM await tested.destroy_vm("sasha-vm-0") assert len(tested.vms) == 0 assert tested.gpus_list == gpu1 assert tested.mac_addresses == macs # One for boot, one for ssd one for hdd assert mock_image_store.delete_qcow.call_count == 3 deleted_images = set( [call[0][0] for call in mock_image_store.delete_qcow.call_args_list]) assert deleted_images == set( ["/home/sasha_king.qcow", "/home/disk1.qcow", "/home/disk2.qcow"]) mock_libvirt.kill_by_name.assert_called_with("sasha-vm-0")