def test_ignore_attempted_hosts_filter_fail(self):
# Node was already tried.
filt_cls = self.class_map['IgnoreAttemptedHostsFilter']()
host = fakes.FakeHostState('host1', {})
attempted = dict(num_attempts=2, hosts=['host1'])
filter_properties = dict(retry=attempted)
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_ignore_attempted_hosts_filter_pass(self):
# Node not previously tried.
filt_cls = self.class_map['IgnoreAttemptedHostsFilter']()
host = fakes.FakeHostState('host1', {})
attempted = dict(num_attempts=2, hosts=['host2'])
filter_properties = dict(retry=attempted)
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def test_json_filter_unknown_operator_raises(self):
filt_cls = self.class_map['JsonFilter']()
raw = ['!=', 1, 2]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
host = fakes.FakeHostState('host1',
{'capabilities': {
'enabled': True
}})
self.assertRaises(KeyError, filt_cls.host_passes, host,
filter_properties)
def test_json_filter_passes_with_no_query(self):
filt_cls = self.class_map['JsonFilter']()
filter_properties = {
'resource_type': {
'memory_mb': 1024,
'root_gb': 200,
'ephemeral_gb': 0
}
}
capabilities = {'enabled': True}
host = fakes.FakeHostState('host1', {
'free_ram_mb': 0,
'free_disk_mb': 0,
'capabilities': capabilities
})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def _do_test_type_filter_extra_specs(self, ecaps, especs, passes):
filt_cls = self.class_map['CapabilitiesFilter']()
capabilities = {'enabled': True}
capabilities.update(ecaps)
service = {'disabled': False}
filter_properties = {
'resource_type': {
'name': 'fake_type',
'extra_specs': especs
}
}
host = fakes.FakeHostState(
'host1', {
'free_capacity_gb': 1024,
'capabilities': capabilities,
'service': service
})
assertion = self.assertTrue if passes else self.assertFalse
assertion(filt_cls.host_passes(host, filter_properties))
def test_json_filter_fails_on_disk(self):
filt_cls = self.class_map['JsonFilter']()
filter_properties = {
'resource_type': {
'memory_mb': 1024,
'root_gb': 200,
'ephemeral_gb': 0
},
'scheduler_hints': {
'query': self.json_query
}
}
capabilities = {'enabled': True}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 1024,
'free_disk_mb': (200 * 1024) - 1,
'capabilities': capabilities
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_json_filter_empty_filters_pass(self):
filt_cls = self.class_map['JsonFilter']()
host = fakes.FakeHostState('host1',
{'capabilities': {
'enabled': True
}})
raw = []
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
raw = {}
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def test_json_filter_unknown_variable_ignored(self):
filt_cls = self.class_map['JsonFilter']()
host = fakes.FakeHostState('host1',
{'capabilities': {
'enabled': True
}})
raw = ['=', '$........', 1, 1]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
raw = ['=', '$foo', 2, 2]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def test_json_filter_fails_on_service_disabled(self):
filt_cls = self.class_map['JsonFilter']()
json_query = jsonutils.dumps([
'and', ['>=', '$free_ram_mb', 1024],
['>=', '$free_disk_mb', 200 * 1024], ['not', '$service.disabled']
])
filter_properties = {
'resource_type': {
'memory_mb': 1024,
'local_gb': 200
},
'scheduler_hints': {
'query': json_query
}
}
capabilities = {'enabled': True}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 1024,
'free_disk_mb': 200 * 1024,
'capabilities': capabilities
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_json_filter_invalid_num_arguments_fails(self):
filt_cls = self.class_map['JsonFilter']()
host = fakes.FakeHostState('host1',
{'capabilities': {
'enabled': True
}})
raw = ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', [
'in',
]]]]]]]]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
raw = ['>', 1]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_availability_zone_filter_empty(self):
filt_cls = self.class_map['AvailabilityZoneFilter']()
service = {'availability_zone': 'nova'}
request = {}
host = fakes.FakeHostState('host1', {'service': service})
self.assertTrue(filt_cls.host_passes(host, request))
def test_availability_zone_filter_different(self):
filt_cls = self.class_map['AvailabilityZoneFilter']()
service = {'availability_zone': 'nova'}
request = self._make_zone_request('bad')
host = fakes.FakeHostState('host1', {'service': service})
self.assertFalse(filt_cls.host_passes(host, request))
def test_json_filter_basic_operators(self):
filt_cls = self.class_map['JsonFilter']()
host = fakes.FakeHostState('host1',
{'capabilities': {
'enabled': True
}})
# (operator, arguments, expected_result)
ops_to_test = [
['=', [1, 1], True],
['=', [1, 2], False],
['<', [1, 2], True],
['<', [1, 1], False],
['<', [2, 1], False],
['>', [2, 1], True],
['>', [2, 2], False],
['>', [2, 3], False],
['<=', [1, 2], True],
['<=', [1, 1], True],
['<=', [2, 1], False],
['>=', [2, 1], True],
['>=', [2, 2], True],
['>=', [2, 3], False],
['in', [1, 1], True],
['in', [1, 1, 2, 3], True],
['in', [4, 1, 2, 3], False],
['not', [True], False],
['not', [False], True],
['or', [True, False], True],
['or', [False, False], False],
['and', [True, True], True],
['and', [False, False], False],
['and', [True, False], False],
# Nested ((True or False) and (2 > 1)) == Passes
['and', [['or', True, False], ['>', 2, 1]], True]
]
for (op, args, expected) in ops_to_test:
raw = [op] + args
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertEqual(expected,
filt_cls.host_passes(host, filter_properties))
# This results in [False, True, False, True] and if any are True
# then it passes...
raw = ['not', True, False, True, False]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
# This results in [False, False, False] and if any are True
# then it passes...which this doesn't
raw = ['not', True, True, True]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_json_filter_happy_day(self):
"""Test json filter more thoroughly."""
filt_cls = self.class_map['JsonFilter']()
raw = [
'and', '$capabilities.enabled',
['=', '$capabilities.opt1', 'match'],
[
'or',
[
'and', ['<', '$free_ram_mb', 30],
['<', '$free_disk_mb', 300]
],
[
'and', ['>', '$free_ram_mb', 30],
['>', '$free_disk_mb', 300]
]
]
]
filter_properties = {
'scheduler_hints': {
'query': jsonutils.dumps(raw),
},
}
# Passes
capabilities = {'enabled': True, 'opt1': 'match'}
service = {'disabled': False}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 10,
'free_disk_mb': 200,
'capabilities': capabilities,
'service': service
})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
# Passes
capabilities = {'enabled': True, 'opt1': 'match'}
service = {'disabled': False}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 40,
'free_disk_mb': 400,
'capabilities': capabilities,
'service': service
})
self.assertTrue(filt_cls.host_passes(host, filter_properties))
# Fails due to capabilities being disabled
capabilities = {'enabled': False, 'opt1': 'match'}
service = {'disabled': False}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 40,
'free_disk_mb': 400,
'capabilities': capabilities,
'service': service
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
# Fails due to being exact memory/disk we don't want
capabilities = {'enabled': True, 'opt1': 'match'}
service = {'disabled': False}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 30,
'free_disk_mb': 300,
'capabilities': capabilities,
'service': service
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
# Fails due to memory lower but disk higher
capabilities = {'enabled': True, 'opt1': 'match'}
service = {'disabled': False}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 20,
'free_disk_mb': 400,
'capabilities': capabilities,
'service': service
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
# Fails due to capabilities 'opt1' not equal
capabilities = {'enabled': True, 'opt1': 'no-match'}
service = {'enabled': True}
host = fakes.FakeHostState(
'host1', {
'free_ram_mb': 20,
'free_disk_mb': 400,
'capabilities': capabilities,
'service': service
})
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_ignore_attempted_hosts_filter_disabled(self):
# Test case where re-scheduling is disabled.
filt_cls = self.class_map['IgnoreAttemptedHostsFilter']()
host = fakes.FakeHostState('host1', {})
filter_properties = {}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
