def test_multiple_spots_one_host(self): used1 = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) total1 = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) servers_rp1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=4, memory=1024, disk=20), uuid='server1'), ] rp1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) rp1.preemptible_servers = servers_rp1 rp1.populate = mock.Mock() rps = [rp1] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) projects = [mock.Mock()] expected = (rps, servers_rp1) exp_used = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) actual = self.strategy.get_preemptible_servers(requested, rps, 2, projects) self.assertEqual(expected, actual) self.assertEqual(exp_used, rp1.used_resources) self.assertEqual(2, rp1.reserved_spots) self.assertEqual(0, len(rp1.preemptible_servers))
def test_select_servers_not_enough(self): # In the watermark mode even if the host preemptible resources # are not enough, we will try to free those resources. used1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=50) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=50) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) servers = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=512, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=512, disk=10), uuid='server2'), ] host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) host.preemptible_servers = servers requested = object_fakes.make_resources(vcpu=2, memory=512, disk=40) with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random result = self.strategy.select_servers(host, requested) self.assertEqual(servers, result) self.assertEqual(0, len(host.preemptible_servers))
def test_multiple_spots_multiple_hosts(self): used1 = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) total1 = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) used2 = object_fakes.make_resources(vcpu=4, memory=1792, disk=20) total2 = object_fakes.make_resources(vcpu=8, memory=2048, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) servers_rp1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server2'), ] servers_rp2 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=2, memory=512, disk=10), uuid='server3'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server4'), ] rp1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) rp1.preemptible_servers = servers_rp1 rp1.populate = mock.Mock() rp2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) rp2.preemptible_servers = servers_rp2 rp2.populate = mock.Mock() rps = [rp1, rp2] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) projects = [mock.Mock()] expected = (rps, servers_rp1 + [servers_rp2[0]]) with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random with mock.patch('random.choice') as mocked_choice: mocked_choice.side_effect = rps actual = self.strategy.get_preemptible_servers( requested, rps, 2, projects) self.assertEqual(expected, actual) self.assertEqual(1, rp1.reserved_spots) self.assertEqual(1, rp2.reserved_spots) self.assertEqual(0, len(rp1.preemptible_servers)) self.assertEqual(1, len(rp2.preemptible_servers)) self.assertEqual('server4', rp2.preemptible_servers[0].uuid)
def test_get_preemptible_servers_enough_free_multiple_spots(self): used = object_fakes.make_resources(vcpu=4, memory=1000, disk=20) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) fake_projects = [mock.Mock()] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) sel_hosts, sel_servers = self.strategy.get_preemptible_servers( requested, [host], 2, fake_projects) self.assertEqual([host], sel_hosts) self.assertEqual([], sel_servers)
def test_full_execution(self, spots): used1 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) used2 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total2 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) servers_rp1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server2'), ] servers_rp2 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server3'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server4'), ] rp1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) rp1.preemptible_servers = servers_rp1 rp2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) rp2.preemptible_servers = servers_rp2 rps = [rp1, rp2] expected_result = (rps[:], servers_rp1[:] + servers_rp2[:]) requested = object_fakes.make_resources(disk=50) projects = [mock.Mock()] with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random with mock.patch('random.choice') as mocked_choice: mocked_choice.side_effect = rps result = self.strategy.get_preemptible_servers( requested, rps, 1, projects) self.assertEqual(expected_result, result) self.assertEqual(0, len(rp1.preemptible_servers)) self.assertEqual(0, len(rp2.preemptible_servers))
def test_select_servers_enough_free(self): used1 = object_fakes.make_resources(vcpu=4, memory=1024, disk=25) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=50) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) self.assertEqual([], self.strategy.select_servers(host, requested)) res = object_fakes.make_resources(vcpu=4, memory=1024, disk=25) expected_used = res + requested self.assertEqual(expected_used, host.used_resources) self.assertEqual(1, host.reserved_spots)
def test_addition(self): used = fakes.make_resources(vcpu=8, memory=8000, disk=80) total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab1 = capabilities.Capabilities(used, total) self.assertEqual(80, capab1.usage()) used = fakes.make_resources() total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab2 = capabilities.Capabilities(used, total) self.assertEqual(0, capab2.usage()) capab3 = capab1 + capab2 free = fakes.make_resources(vcpu=12, memory=12000, disk=120) self.assertEqual(40, capab3.usage()) self.assertEqual(free, capab3.free_resources)
def test_get_preemptible_servers_no_combinations(self, mocked_find): mocked_find.return_value = None fake_hosts = [mock.Mock()] fake_projects = [mock.Mock()] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) self.assertRaises(exception.NotEnoughResources, self.strategy.get_preemptible_servers, requested, fake_hosts, 1, fake_projects)
def test_not_enough_resources(self): used1 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) used2 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total2 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) servers_rp1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server2'), ] servers_rp2 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server3'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server4'), ] rp1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) rp1.preemptible_servers = servers_rp1 rp1.populate = mock.Mock() rp2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) rp2.preemptible_servers = servers_rp2 rp2.populate = mock.Mock() rps = [rp1, rp2] requested = object_fakes.make_resources(disk=50) projects = [mock.Mock()] with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random with mock.patch('random.choice') as mocked_choice: mocked_choice.side_effect = rps self.assertRaises(exception.NotEnoughResources, self.strategy.get_preemptible_servers, requested, rps, 1, projects)
def test_find_matching_server_combinations(self): used = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) server1 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=10), uuid='server1', flavor_name='flavor1') server2 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=5), uuid='server2', flavor_name='flavor2') server3 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=2, memory=512, disk=10), uuid='server3', flavor_name='flavor3') servers = [server1, server2, server3] host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) host.preemptible_servers = servers requested = object_fakes.make_resources(vcpu=1, memory=256, disk=5) result = self.strategy.find_matching_server_combinations([host], requested, None) expected_instances = [server2] exepected_leftovers = object_fakes.make_resources() self.assertEqual(expected_instances, result.instances) self.assertEqual(exepected_leftovers, result.leftovers) self.assertEqual(host.uuid, result.provider.uuid)
def test_get_preemptible_servers(self, spots, select): selected_servers = ['server1'] pre1 = object_fakes.make_resources(vcpu=2, memory=512, disk=10) free1 = object_fakes.make_resources(vcpu=2, memory=512, disk=10) selected_hosts = [ mock.Mock(free_resources=free1, preemptible_resources=pre1, disabled=False) ] select.return_value = selected_servers requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) projects = [mock.Mock()] self.assertEqual( (selected_hosts, selected_servers), self.strategy.get_preemptible_servers(requested, selected_hosts, 1, projects)) spots.assert_called_once_with(selected_hosts, 1)
def test_get_preemptible_servers_no_combinations(self, mocked_find): mocked_find.return_value = None fake_hosts = [mock.Mock()] fake_projects = [mock.Mock()] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) # Make sure that in watermark mode even if we don't have enough # resources, no exception is raised. sel_hosts, sel_servers = self.strategy.get_preemptible_servers( requested, fake_hosts, 1, fake_projects) self.assertEqual([], sel_hosts) self.assertEqual([], sel_servers)
def test_find_matching_server_combinations_not_enough(self): used = object_fakes.make_resources(vcpu=7, memory=512, disk=35) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) server1 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=10), uuid='server1') server2 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=5), uuid='server2') server3 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=2, memory=512, disk=10), uuid='server3') servers = [server1, server2, server3] host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) host.preemptible_servers = servers requested = object_fakes.make_resources(vcpu=1, memory=256, disk=35) result = self.strategy.find_matching_server_combinations([host], requested, None) self.assertIsNone(result)
def test_select_servers(self): used1 = object_fakes.make_resources(vcpu=4, memory=1024, disk=25) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=50) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) servers = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=5), uuid='server2'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=2, memory=512, disk=10), uuid='server3') ] host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) host.preemptible_servers = servers requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random self.assertEqual([servers[0], servers[1]], self.strategy.select_servers(host, requested)) self.assertEqual(1, len(host.preemptible_servers)) self.assertEqual('server3', host.preemptible_servers[0].uuid) self.assertEqual(1, host.reserved_spots)
def test_select_servers_not_enough_resources(self): used = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) servers = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=5), uuid='server2'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=2, memory=512, disk=10), uuid='server3') ] host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) host.preemptible_servers = servers requested = object_fakes.make_resources(vcpu=6, memory=512, disk=10) with mock.patch('random.shuffle') as mocked: mocked.side_effect = mocked_random self.assertEqual([], self.strategy.select_servers(host, requested)) self.assertEqual(0, host.reserved_spots) self.assertEqual(3, len(host.preemptible_servers))
def test_get_preemptible_servers(self, mocked_find): used = object_fakes.make_resources(vcpu=7, memory=1800, disk=35) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) server = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=10), uuid='server1') combo = utils.Combination(provider=host, instances=[server], leftovers=object_fakes.make_resources( vcpu=2, memory=256, disk=10)) mocked_find.return_value = combo fake_hosts = [mock.Mock()] fake_projects = [mock.Mock()] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) sel_hosts, sel_servers = self.strategy.get_preemptible_servers( requested, fake_hosts, 1, fake_projects) self.assertEqual([host], sel_hosts) self.assertEqual([server], sel_servers)
def test_find_matching_server_combinations_multiple_hosts(self): used1 = object_fakes.make_resources(vcpu=7, memory=1800, disk=35) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) servers1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=5), uuid='server1'), ] host1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) host1.preemptible_servers = servers1 used2 = object_fakes.make_resources(vcpu=7, memory=1500, disk=35) total2 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) servers2 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=5), uuid='server2'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=2, memory=512, disk=10), uuid='server3') ] host2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) host2.preemptible_servers = servers2 requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) result = self.strategy.find_matching_server_combinations( [host1, host2], requested, None) expected_instances = servers1 exepected_leftovers = object_fakes.make_resources() self.assertEqual(expected_instances, result.instances) self.assertEqual(exepected_leftovers, result.leftovers) self.assertEqual(host1.uuid, result.provider.uuid)
def test_get_preemptible_servers_not_enough(self, mocked_find): used = object_fakes.make_resources(vcpu=7, memory=1800, disk=35) total = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp_capabilities = object_fakes.make_capabilities(used=used, total=total) host = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp_capabilities) server = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=10), uuid='server1') combo = utils.Combination(provider=host, instances=[server], leftovers=object_fakes.make_resources( vcpu=2, memory=256, disk=10)) mocked_find.side_effect = [combo, None] fake_hosts = [mock.Mock()] fake_projects = [mock.Mock()] requested = object_fakes.make_resources(vcpu=2, memory=512, disk=10) # Make sure that in watermark mode even if we don't have enough # resources, no exception is raised. sel_hosts, sel_servers = self.strategy.get_preemptible_servers( requested, fake_hosts, 2, fake_projects) self.assertEqual([host], sel_hosts) self.assertEqual([server], sel_servers)
def test_sort_combinations(self): combo1 = utils.Combination(provider='host1', instances=['server1'], leftovers=object_fakes.make_resources( vcpu=2, memory=256, disk=10)) combo2 = utils.Combination(provider='host2', instances=['server2'], leftovers=object_fakes.make_resources( vcpu=1, memory=512, disk=10)) combo3 = utils.Combination(provider='host3', instances=['server3'], leftovers=object_fakes.make_resources( vcpu=1, memory=512, disk=20)) combinations = [combo1, combo2, combo3] CONF.reaper.vcpu_sorting_priority = 2 CONF.reaper.ram_sorting_priority = 1 CONF.reaper.disk_sorting_priority = 3 result = utils.sort_combinations(combinations) self.assertEqual(combo1, result) CONF.reaper.vcpu_sorting_priority = 1 CONF.reaper.ram_sorting_priority = 2 CONF.reaper.disk_sorting_priority = 3 result = utils.sort_combinations(combinations) self.assertEqual(combo2, result) CONF.reaper.vcpu_sorting_priority = 2 CONF.reaper.ram_sorting_priority = 3 CONF.reaper.disk_sorting_priority = 1 result = utils.sort_combinations(combinations) self.assertEqual(combo2, result)
def make_reaper_request(uuids=None, project=None, resources=None, image=None, event_type=None, aggregates=None): uuids = uuids or ['instance_uuid'] project = project or ['project_id'] resources = resources or object_fakes.make_resources() image = image or "image_uuid" event_type = event_type or reaper_action.ActionEvent.BUILD_REQUEST return reaper_request.ReaperRequest(uuids, project, resources, image, event_type, aggregates=aggregates)
def test_excessive_resources(self): used = fakes.make_resources(vcpu=8, memory=8000, disk=80) total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab = capabilities.Capabilities(used, total) excessive = fakes.make_resources(vcpu=1, memory=1000, disk=10) self.assertEqual(excessive, capab.get_excessive_resources(70)) excessive = fakes.make_resources(vcpu=1, memory=500, disk=5) self.assertEqual(excessive, capab.get_excessive_resources(75)) excessive = fakes.make_resources() self.assertEqual(excessive, capab.get_excessive_resources(90)) used = fakes.make_resources(vcpu=3, memory=6000, disk=80) total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab = capabilities.Capabilities(used, total) excessive = fakes.make_resources(memory=1000, disk=30) self.assertEqual(excessive, capab.get_excessive_resources(50)) excessive = fakes.make_resources(disk=20) self.assertEqual(excessive, capab.get_excessive_resources(60))
def test_capabilities(self): used = fakes.make_resources(vcpu=1, memory=2000, disk=20) total = fakes.make_resources(vcpu=8, memory=8000, disk=80) capab = capabilities.Capabilities(used, total) free = fakes.make_resources(vcpu=7, memory=6000, disk=60) self.assertEqual(free, capab.free_resources) self.assertEqual(25, capab.usage()) used = fakes.make_resources(vcpu=8, memory=8000, disk=80) total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab = capabilities.Capabilities(used, total) free = fakes.make_resources(vcpu=2, memory=2000, disk=20) self.assertEqual(free, capab.free_resources) self.assertEqual(80, capab.usage()) used = fakes.make_resources(memory=4000, disk=60) total = fakes.make_resources(vcpu=10, memory=10000, disk=100) capab = capabilities.Capabilities(used, total) free = fakes.make_resources(vcpu=10, memory=6000, disk=40) self.assertEqual(free, capab.free_resources) self.assertEqual(60, capab.usage())
def test_free_resources(self, mock_allocs, mock_delete): mock_projects = [mock.Mock(id_=1), mock.Mock(id_=2)] system = mock.Mock(preemptible_projects=mock_projects) request = fakes.make_reaper_request() hosts = ['host1'] servers = [mock.Mock(uuid='server1'), mock.Mock(uuid='server2')] # Hack for mock's limitation with the name attribute for server in servers: server.name = server.uuid mocked_return = mock.Mock(return_value=(hosts, servers)) not_found = obj_fakes.make_resources() mock_allocs.return_value = not_found mock_strategy = mock.Mock(get_preemptible_servers=mocked_return) with mock.patch.object(self.reaper, '_load_configured_strategy') as m: m.return_value = mock_strategy self.reaper.free_resources(request, system) mock_delete.assert_has_calls( [mock.call('server1'), mock.call('server2')], any_order=True)
def test_find_matching_server_combinations_not_enough_multiple_hosts(self): used1 = object_fakes.make_resources(vcpu=7, memory=256, disk=35) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) server1 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=10), uuid='server1') servers1 = [server1] host1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) host1.preemptible_servers = servers1 used2 = object_fakes.make_resources(vcpu=7, memory=512, disk=35) total2 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) server2 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=1, memory=256, disk=5), uuid='server2') server3 = object_fakes.make_server( resources=object_fakes.make_resources(vcpu=2, memory=512, disk=10), uuid='server3') servers2 = [server2, server3] host2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) host2.preemptible_servers = servers2 requested = object_fakes.make_resources(vcpu=1, memory=256, disk=35) result = self.strategy.find_matching_server_combinations( [host1, host2], requested, None) self.assertIsNone(result)
def test_get_preemptible_servers(self, spots, select): used1 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total1 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp1_capabilities = object_fakes.make_capabilities(used=used1, total=total1) used2 = object_fakes.make_resources(vcpu=4, memory=1024, disk=20) total2 = object_fakes.make_resources(vcpu=8, memory=2056, disk=40) rp2_capabilities = object_fakes.make_capabilities(used=used2, total=total2) servers_rp1 = [ object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server1'), object_fakes.make_server(resources=object_fakes.make_resources( vcpu=1, memory=256, disk=10), uuid='server2'), ] rp1 = object_fakes.make_resource_provider( uuid='1', name='rp1', capabilities=rp1_capabilities) rp1.preemptible_servers = servers_rp1 rp2 = object_fakes.make_resource_provider( uuid='2', name='rp2', capabilities=rp2_capabilities) requested = object_fakes.make_resources(disk=10) hosts = [rp1, rp2] projects = [mock.Mock()] select.return_value = [servers_rp1[0]] with mock.patch('random.choice') as mocked: mocked.return_value = hosts[0] expected = ([hosts[0]], [servers_rp1[0]]) result = self.strategy.get_preemptible_servers( requested, hosts, 1, projects) self.assertEqual(expected, result) spots.assert_not_called()
def test_wait_until_allocations_are_deleted(self, mock_allocs): server1 = mock.Mock(uuid='uuid1', rp_uuid='rp1_uuid') server2 = mock.Mock(uuid='uuid2', rp_uuid='rp2_uuid') servers = [server1, server2] mock_allocs.side_effect = [ obj_fakes.make_resources(), obj_fakes.make_resources(vcpu=1), obj_fakes.make_resources(), ] self.reaper.wait_until_allocations_are_deleted(servers) self.assertEqual([], servers) servers = [server1, server2] mock_allocs.side_effect = [ obj_fakes.make_resources(), obj_fakes.make_resources(vcpu=1), obj_fakes.make_resources(vcpu=1), obj_fakes.make_resources(vcpu=1), ] with mock.patch('time.time') as mocked_time: mocked_time.side_effect = [1, 1, 1, 1, 100] self.reaper.wait_until_allocations_are_deleted(servers) self.assertEqual([server2], servers)