def get_managed_vms_names(): result = [] if VmManager: opts = BackendConfigReader().read() vmm = VmManager(opts, log) result.extend(vmd.vm_name.lower() for vmd in vmm.get_all_vm()) return result
def get_managed_vms(): result = {} if VmManager: opts = BackendConfigReader().read() vmm = VmManager(opts, log) for vmd in vmm.get_all_vm(): result[vmd.vm_name.lower()] = { 'unused': vmd.state == VmStates.READY, } return result
class TestManager(object): def setup_method(self, method): self.opts = Munch( redis_db=9, redis_port=7777, ssh=Munch(transport="ssh"), build_groups_count=2, build_groups={ GID1: { "name": "base", "archs": ["i386", "x86_64"], "max_vm_per_user": 3, }, GID2: { "name": "arm", "archs": [ "armV7", ] } }, fedmsg_enabled=False, sleeptime=0.1, do_sign=True, timeout=1800, # destdir=self.tmp_dir_path, results_baseurl="/tmp", ) self.vm_ip = "127.0.0.1" self.vm_name = "localhost" self.vm2_ip = "127.0.0.2" self.vm2_name = "localhost2" self.ownername = "bob" self.rc = get_redis_connection(self.opts) self.ps = None self.log_msg_list = [] self.vmm = VmManager(self.opts) self.vmm.log = MagicMock() self.pid = 12345 def teardown_method(self, method): keys = self.vmm.rc.keys("*") if keys: self.vmm.rc.delete(*keys) def test_manager_setup(self): vmm = VmManager(self.opts) assert GID1 in vmm.vm_groups assert GID2 in vmm.vm_groups assert len(vmm.vm_groups) == 2 def test_add_vm_to_pool(self): self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) with pytest.raises(VmError): self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vm_list = self.vmm.get_all_vm_in_group(GID1) vm = self.vmm.get_vm_by_name(self.vm_name) assert len(vm_list) == 1 assert vm_list[0].__dict__ == vm.__dict__ assert vm.vm_ip == self.vm_ip assert vm.vm_name == self.vm_name assert vm.group == GID1 def test_mark_vm_check_failed(self, mc_time): self.vmm.start_vm_termination = types.MethodType(MagicMock(), self.vmm) self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd = self.vmm.get_vm_by_name(self.vm_name) vmd.store_field(self.rc, "state", VmStates.CHECK_HEALTH) vmd.store_field(self.rc, "last_health_check", 12345) self.vmm.mark_vm_check_failed(self.vm_name) assert vmd.get_field(self.rc, "state") == VmStates.CHECK_HEALTH_FAILED states = [ VmStates.GOT_IP, VmStates.IN_USE, VmStates.READY, VmStates.TERMINATING ] for state in states: vmd.store_field(self.rc, "state", state) self.vmm.mark_vm_check_failed(self.vm_name) assert vmd.get_field(self.rc, "state") == state def test_acquire_vm_no_vm_after_server_restart(self, mc_time): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.READY) # undefined both last_health_check and server_start_timestamp mc_time.time.return_value = 0.1 with pytest.raises(NoVmAvailable): self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) # only server start timestamp is defined mc_time.time.return_value = 1 self.vmm.mark_server_start() with pytest.raises(NoVmAvailable): self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) # only last_health_check defined self.rc.delete(KEY_SERVER_INFO) vmd.store_field(self.rc, "last_health_check", 0) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) # both defined but last_health_check < server_start_time self.vmm.mark_server_start() with pytest.raises(NoVmAvailable): self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) # and finally last_health_check > server_start_time vmd.store_field(self.rc, "last_health_check", 2) vmd_res = self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) assert vmd.vm_name == vmd_res.vm_name def test_acquire_vm_extra_kwargs(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) kwargs = { "task_id": "20-fedora-20-x86_64", "build_id": "20", "chroot": "fedora-20-x86_64" } vmd_got = self.vmm.acquire_vm([GID1], self.ownername, self.pid, SANDBOX, **kwargs) for k, v in kwargs.items(): assert vmd_got.get_field(self.rc, k) == v def test_another_owner_cannot_acquire_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) vmd.store_field(self.vmm.rc, "bound_to_user", "foo") vmd.store_field(self.vmm.rc, "sandbox", SANDBOX) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) vm = self.vmm.acquire_vm(groups=[GID1], ownername="foo", pid=self.pid, sandbox=SANDBOX) assert vm.vm_name == self.vm_name def test_different_sandbox_cannot_acquire_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) vmd.store_field(self.vmm.rc, "bound_to_user", "foo") vmd.store_field(self.vmm.rc, "sandbox", "sandboxA") with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(groups=[GID1], ownername="foo", pid=self.pid, sandbox="sandboxB") vm = self.vmm.acquire_vm(groups=[GID1], ownername="foo", pid=self.pid, sandbox="sandboxA") assert vm.vm_name == self.vm_name def test_acquire_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd_alt = self.vmm.add_vm_to_pool(self.vm_ip, "vm_alt", GID1) vmd2 = self.vmm.add_vm_to_pool(self.vm2_ip, self.vm2_name, GID2) vmd.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.rc, "state", VmStates.READY) vmd2.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) vmd_alt.store_field(self.rc, "last_health_check", 2) vmd2.store_field(self.rc, "last_health_check", 2) vmd_alt.store_field(self.vmm.rc, "bound_to_user", self.ownername) vmd_alt.store_field(self.vmm.rc, "sandbox", SANDBOX) vmd_got_first = self.vmm.acquire_vm([GID1, GID2], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_first.vm_name == "vm_alt" vmd_got_second = self.vmm.acquire_vm([GID1, GID2], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_second.vm_name == self.vm_name with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) vmd_got_third = self.vmm.acquire_vm(groups=[GID1, GID2], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_third.vm_name == self.vm2_name def test_acquire_vm_per_user_limit(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() max_vm_per_user = self.opts.build_groups[GID1]["max_vm_per_user"] vmd_list = [] for idx in range(max_vm_per_user + 1): vmd = self.vmm.add_vm_to_pool("127.0.{}.1".format(idx), "vm_{}".format(idx), GID1) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) vmd_list.append(vmd) for idx in range(max_vm_per_user): self.vmm.acquire_vm([GID1], self.ownername, idx, SANDBOX) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm([GID1], self.ownername, 42, SANDBOX) def test_acquire_only_ready_state(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd_main = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd_main.store_field(self.rc, "last_health_check", 2) for state in [ VmStates.IN_USE, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.TERMINATING, VmStates.CHECK_HEALTH_FAILED ]: vmd_main.store_field(self.rc, "state", state) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) def test_acquire_and_release_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd_main = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd_alt = self.vmm.add_vm_to_pool(self.vm_ip, "vm_alt", GID1) vmd_main.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.vmm.rc, "bound_to_user", self.ownername) vmd_alt.store_field(self.vmm.rc, "sandbox", SANDBOX) vmd_main.store_field(self.rc, "last_health_check", 2) vmd_alt.store_field(self.rc, "last_health_check", 2) vmd_got_first = self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_first.vm_name == "vm_alt" self.vmm.release_vm("vm_alt") vmd_got_again = self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_again.vm_name == "vm_alt" vmd_got_another = self.vmm.acquire_vm(groups=[GID1], ownername=self.ownername, pid=self.pid, sandbox=SANDBOX) assert vmd_got_another.vm_name == self.vm_name def test_release_only_in_use(self): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) for state in [ VmStates.READY, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.TERMINATING, VmStates.CHECK_HEALTH_FAILED ]: vmd.store_field(self.rc, "state", state) assert not self.vmm.release_vm(self.vm_name) def rcv_from_ps_message_bus(self): # don't forget to subscribe self.ps rcv_msg_list = [] for i in range(10): msg = self.ps.get_message() if msg: rcv_msg_list.append(msg) time.sleep(0.01) return rcv_msg_list def test_start_vm_termination(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() # print(rcv_msg_list) assert len(rcv_msg_list) == 1 msg = rcv_msg_list[0] assert msg["type"] == "message" data = json.loads(msg["data"]) assert data["topic"] == EventTopics.VM_TERMINATION_REQUEST assert data["vm_name"] == self.vm_name def test_start_vm_termination_2(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name, allowed_pre_state=VmStates.TERMINATING) rcv_msg_list = self.rcv_from_ps_message_bus() # print(rcv_msg_list) assert len(rcv_msg_list) == 1 msg = rcv_msg_list[0] assert msg["type"] == "message" data = json.loads(msg["data"]) assert data["topic"] == EventTopics.VM_TERMINATION_REQUEST assert data["vm_name"] == self.vm_name def test_start_vm_termination_fail(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 vmd.store_field(self.rc, "state", VmStates.READY) self.vmm.start_vm_termination(self.vm_name, allowed_pre_state=VmStates.IN_USE) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 assert vmd.get_field(self.rc, "state") == VmStates.READY vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 assert vmd.get_field(self.rc, "state") == VmStates.TERMINATING def test_remove_vm_from_pool_only_terminated(self): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, GID1) for state in [ VmStates.IN_USE, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.READY, VmStates.CHECK_HEALTH_FAILED ]: vmd.store_field(self.vmm.rc, "state", state) with pytest.raises(VmError): self.vmm.remove_vm_from_pool(self.vm_name) vmd.store_field(self.vmm.rc, "state", VmStates.TERMINATING) self.vmm.remove_vm_from_pool(self.vm_name) assert self.vmm.rc.scard(KEY_VM_POOL.format(group=GID1)) == 0 def test_get_vms(self, capsys): vmd_1 = self.vmm.add_vm_to_pool(self.vm_ip, "a1", GID1) vmd_2 = self.vmm.add_vm_to_pool(self.vm_ip, "a2", GID1) vmd_3 = self.vmm.add_vm_to_pool(self.vm_ip, "b1", 1) vmd_4 = self.vmm.add_vm_to_pool(self.vm_ip, "b2", 1) vmd_5 = self.vmm.add_vm_to_pool(self.vm_ip, "b3", 1) assert set(v.vm_name for v in self.vmm.get_all_vm_in_group(0)) == set( ["a1", "a2"]) assert set(v.vm_name for v in self.vmm.get_all_vm_in_group(1)) == set( ["b1", "b2", "b3"]) assert set(v.vm_name for v in self.vmm.get_all_vm()) == set( ["a1", "a2", "b1", "b2", "b3"]) vmd_1.store_field(self.rc, "state", VmStates.GOT_IP) vmd_2.store_field(self.rc, "state", VmStates.GOT_IP) vmd_3.store_field(self.rc, "state", VmStates.GOT_IP) vmd_4.store_field(self.rc, "state", VmStates.READY) vmd_5.store_field(self.rc, "state", VmStates.IN_USE) vmd_list = self.vmm.get_vm_by_group_and_state_list( group=None, state_list=[VmStates.GOT_IP, VmStates.IN_USE]) assert set(v.vm_name for v in vmd_list) == set(["a1", "a2", "b1", "b3"]) vmd_list = self.vmm.get_vm_by_group_and_state_list( group=1, state_list=[VmStates.READY]) assert set(v.vm_name for v in vmd_list) == set(["b2"]) self.vmm.info() def test_look_up_vms_by_ip(self, capsys): self.vmm.add_vm_to_pool(self.vm_ip, "a1", GID1) r1 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r1) == 1 assert r1[0].vm_name == "a1" self.vmm.add_vm_to_pool(self.vm_ip, "a2", GID1) r2 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r2) == 2 r2 = sorted(r2, key=lambda vmd: vmd.vm_name) assert r2[0].vm_name == "a1" assert r2[1].vm_name == "a2" self.vmm.add_vm_to_pool("127.1.1.111", "b1", 1) r3 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r3) == 2 r3 = sorted(r3, key=lambda vmd: vmd.vm_name) assert r3[0].vm_name == "a1" assert r3[1].vm_name == "a2" def test_mark_server_start(self, mc_time): assert self.rc.hget(KEY_SERVER_INFO, "server_start_timestamp") is None for i in range(100): val = 100 * i + 0.12345 mc_time.time.return_value = val self.vmm.mark_server_start() assert self.rc.hget(KEY_SERVER_INFO, "server_start_timestamp") == "{}".format(val)
class TestManager(object): def setup_method(self, method): self.opts = Munch( redis_db=9, redis_port=7777, ssh=Munch( transport="ssh" ), build_groups_count=1, build_groups={ 0: { "name": "base", "archs": ["i386", "x86_64"], "max_vm_per_user": 3, } }, fedmsg_enabled=False, sleeptime=0.1, do_sign=True, timeout=1800, # destdir=self.tmp_dir_path, results_baseurl="/tmp", ) self.queue = Queue() self.vm_ip = "127.0.0.1" self.vm_name = "localhost" self.group = 0 self.username = "******" self.rc = get_redis_connection(self.opts) self.ps = None self.log_msg_list = [] self.callback = TestCallback() self.queue = Queue() self.vmm = VmManager(self.opts) self.vmm.log = MagicMock() self.pid = 12345 def teardown_method(self, method): keys = self.vmm.rc.keys("*") if keys: self.vmm.rc.delete(*keys) @pytest.fixture def f_second_group(self): self.opts.build_groups_count = 2 self.opts.build_groups[1] = { "name": "arm", "archs": ["armV7",] } def test_add_vm_to_pool(self): self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vm_list = self.vmm.get_all_vm_in_group(self.group) vm = self.vmm.get_vm_by_name(self.vm_name) assert len(vm_list) == 1 assert vm_list[0].__dict__ == vm.__dict__ assert self.group in self.vmm.vm_groups assert len(self.vmm.vm_groups) == 1 with pytest.raises(VmError): self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) def test_mark_vm_check_failed(self, mc_time): self.vmm.start_vm_termination = types.MethodType(MagicMock(), self.vmm) self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd = self.vmm.get_vm_by_name(self.vm_name) vmd.store_field(self.rc, "state", VmStates.CHECK_HEALTH) vmd.store_field(self.rc, "last_health_check", 12345) self.vmm.mark_vm_check_failed(self.vm_name) assert vmd.get_field(self.rc, "state") == VmStates.CHECK_HEALTH_FAILED states = [VmStates.GOT_IP, VmStates.IN_USE, VmStates.READY, VmStates.TERMINATING] for state in states: vmd.store_field(self.rc, "state", state) self.vmm.mark_vm_check_failed(self.vm_name) assert vmd.get_field(self.rc, "state") == state def test_acquire_vm_no_vm_after_server_restart(self, mc_time): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd.store_field(self.rc, "state", VmStates.READY) # undefined both last_health_check and server_start_timestamp with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(0, self.username, 42) # only server start timestamp is defined mc_time.time.return_value = 1 self.vmm.mark_server_start() with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(0, self.username, 42) # only last_health_check defined self.rc.delete(KEY_SERVER_INFO) vmd.store_field(self.rc, "last_health_check", 0) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(0, self.username, 42) # both defined but last_health_check < server_start_time self.vmm.mark_server_start() with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(0, self.username, 42) # and finally last_health_check > server_start_time vmd.store_field(self.rc, "last_health_check", 2) vmd_res = self.vmm.acquire_vm(0, self.username, 42) assert vmd.vm_name == vmd_res.vm_name def test_acquire_vm_extra_kwargs(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) kwargs = { "task_id": "20-fedora-20-x86_64", "build_id": "20", "chroot": "fedora-20-x86_64" } vmd_got = self.vmm.acquire_vm(self.group, self.username, self.pid, **kwargs) for k, v in kwargs.items(): assert vmd_got.get_field(self.rc, k) == v def test_acquire_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd_main = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd_alt = self.vmm.add_vm_to_pool(self.vm_ip, "alternative", self.group) vmd_main.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.vmm.rc, "bound_to_user", self.username) vmd_main.store_field(self.rc, "last_health_check", 2) vmd_alt.store_field(self.rc, "last_health_check", 2) vmd_got_first = self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) assert vmd_got_first.vm_name == "alternative" vmd_got_second = self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) assert vmd_got_second.vm_name == self.vm_name with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) def test_acquire_vm_per_user_limit(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() max_vm_per_user = self.opts.build_groups[0]["max_vm_per_user"] acquired_vmd_list = [] for idx in range(max_vm_per_user + 1): vmd = self.vmm.add_vm_to_pool("127.0.{}.1".format(idx), "vm_{}".format(idx), self.group) vmd.store_field(self.rc, "state", VmStates.READY) vmd.store_field(self.rc, "last_health_check", 2) acquired_vmd_list.append(vmd) for idx in range(max_vm_per_user): vmd = self.vmm.acquire_vm(0, self.username, idx) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(0, self.username, 42) acquired_vmd_list[-1].store_field(self.rc, "state", VmStates.READY) self.vmm.acquire_vm(0, self.username, 42) def test_acquire_only_ready_state(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd_main = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd_main.store_field(self.rc, "last_health_check", 2) for state in [VmStates.IN_USE, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.TERMINATING, VmStates.CHECK_HEALTH_FAILED]: vmd_main.store_field(self.rc, "state", state) with pytest.raises(NoVmAvailable): self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) def test_acquire_and_release_vm(self, mc_time): mc_time.time.return_value = 0 self.vmm.mark_server_start() vmd_main = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd_alt = self.vmm.add_vm_to_pool(self.vm_ip, "alternative", self.group) vmd_main.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.rc, "state", VmStates.READY) vmd_alt.store_field(self.vmm.rc, "bound_to_user", self.username) vmd_main.store_field(self.rc, "last_health_check", 2) vmd_alt.store_field(self.rc, "last_health_check", 2) vmd_got_first = self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) assert vmd_got_first.vm_name == "alternative" self.vmm.release_vm("alternative") vmd_got_again = self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) assert vmd_got_again.vm_name == "alternative" vmd_got_another = self.vmm.acquire_vm(group=self.group, username=self.username, pid=self.pid) assert vmd_got_another.vm_name == self.vm_name def test_release_only_in_use(self): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) for state in [VmStates.READY, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.TERMINATING, VmStates.CHECK_HEALTH_FAILED]: vmd.store_field(self.rc, "state", state) assert not self.vmm.release_vm(self.vm_name) def rcv_from_ps_message_bus(self): # don't forget to subscribe self.ps rcv_msg_list = [] for i in range(10): msg = self.ps.get_message() if msg: rcv_msg_list.append(msg) time.sleep(0.01) return rcv_msg_list def test_start_vm_termination(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() # print(rcv_msg_list) assert len(rcv_msg_list) == 1 msg = rcv_msg_list[0] assert msg["type"] == "message" data = json.loads(msg["data"]) assert data["topic"] == EventTopics.VM_TERMINATION_REQUEST assert data["vm_name"] == self.vm_name def test_start_vm_termination_2(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name, allowed_pre_state=VmStates.TERMINATING) rcv_msg_list = self.rcv_from_ps_message_bus() # print(rcv_msg_list) assert len(rcv_msg_list) == 1 msg = rcv_msg_list[0] assert msg["type"] == "message" data = json.loads(msg["data"]) assert data["topic"] == EventTopics.VM_TERMINATION_REQUEST assert data["vm_name"] == self.vm_name def test_start_vm_termination_fail(self): self.ps = self.vmm.rc.pubsub(ignore_subscribe_messages=True) self.ps.subscribe(PUBSUB_MB) vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 vmd.store_field(self.rc, "state", VmStates.READY) self.vmm.start_vm_termination(self.vm_name, allowed_pre_state=VmStates.IN_USE) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 assert vmd.get_field(self.rc, "state") == VmStates.READY vmd.store_field(self.rc, "state", VmStates.TERMINATING) self.vmm.start_vm_termination(self.vm_name) rcv_msg_list = self.rcv_from_ps_message_bus() assert len(rcv_msg_list) == 0 assert vmd.get_field(self.rc, "state") == VmStates.TERMINATING def test_remove_vm_from_pool_only_terminated(self): vmd = self.vmm.add_vm_to_pool(self.vm_ip, self.vm_name, self.group) for state in [VmStates.IN_USE, VmStates.GOT_IP, VmStates.CHECK_HEALTH, VmStates.READY, VmStates.CHECK_HEALTH_FAILED]: vmd.store_field(self.vmm.rc, "state", state) with pytest.raises(VmError): self.vmm.remove_vm_from_pool(self.vm_name) vmd.store_field(self.vmm.rc, "state", VmStates.TERMINATING) self.vmm.remove_vm_from_pool(self.vm_name) assert self.vmm.rc.scard(KEY_VM_POOL.format(group=self.group)) == 0 def test_get_vms(self, f_second_group, capsys): vmd_1 = self.vmm.add_vm_to_pool(self.vm_ip, "a1", self.group) vmd_2 = self.vmm.add_vm_to_pool(self.vm_ip, "a2", self.group) vmd_3 = self.vmm.add_vm_to_pool(self.vm_ip, "b1", 1) vmd_4 = self.vmm.add_vm_to_pool(self.vm_ip, "b2", 1) vmd_5 = self.vmm.add_vm_to_pool(self.vm_ip, "b3", 1) assert set(v.vm_name for v in self.vmm.get_all_vm_in_group(0)) == set(["a1", "a2"]) assert set(v.vm_name for v in self.vmm.get_all_vm_in_group(1)) == set(["b1", "b2", "b3"]) assert set(v.vm_name for v in self.vmm.get_all_vm()) == set(["a1", "a2", "b1", "b2", "b3"]) vmd_1.store_field(self.rc, "state", VmStates.GOT_IP) vmd_2.store_field(self.rc, "state", VmStates.GOT_IP) vmd_3.store_field(self.rc, "state", VmStates.GOT_IP) vmd_4.store_field(self.rc, "state", VmStates.READY) vmd_5.store_field(self.rc, "state", VmStates.IN_USE) vmd_list = self.vmm.get_vm_by_group_and_state_list(group=None, state_list=[VmStates.GOT_IP, VmStates.IN_USE]) assert set(v.vm_name for v in vmd_list) == set(["a1", "a2", "b1", "b3"]) vmd_list = self.vmm.get_vm_by_group_and_state_list(group=1, state_list=[VmStates.READY]) assert set(v.vm_name for v in vmd_list) == set(["b2"]) self.vmm.info() def test_look_up_vms_by_ip(self, f_second_group, capsys): self.vmm.add_vm_to_pool(self.vm_ip, "a1", self.group) r1 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r1) == 1 assert r1[0].vm_name == "a1" self.vmm.add_vm_to_pool(self.vm_ip, "a2", self.group) r2 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r2) == 2 r2 = sorted(r2, key=lambda vmd: vmd.vm_name) assert r2[0].vm_name == "a1" assert r2[1].vm_name == "a2" self.vmm.add_vm_to_pool("127.1.1.111", "b1", 1) r3 = self.vmm.lookup_vms_by_ip(self.vm_ip) assert len(r3) == 2 r3 = sorted(r3, key=lambda vmd: vmd.vm_name) assert r3[0].vm_name == "a1" assert r3[1].vm_name == "a2" def test_mark_server_start(self, mc_time): assert self.rc.hget(KEY_SERVER_INFO, "server_start_timestamp") is None for i in range(100): val = 100 * i + 0.12345 mc_time.time.return_value = val self.vmm.mark_server_start() assert self.rc.hget(KEY_SERVER_INFO, "server_start_timestamp") == "{}".format(val)