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)
