def by_name(self,input,*args,**kw):
if 'anywhere' in kw:
search = Key.list_by_name(input,find_anywhere=True)
else:
search = Key.list_by_name(input)
keys = [elem.key_name for elem in search]
return dict(matches=keys)
def save(self, **kw):
if kw["id"]:
key = Key.by_id(kw["id"])
key.key_name = kw["key_name"]
else:
key = Key(key_name=kw["key_name"])
session.add(key)
if "numeric" in kw:
key.numeric = kw["numeric"]
flash(_(u"OK"))
redirect(".")
def test_closing_script_tag_escaped_in_search_bar(self):
with session.begin():
Key.lazy_create(key_name=u'</script>')
b = self.browser
b.get(get_server_base())
b.find_element_by_link_text('Show Search Options').click()
wait_for_animation(b, '#searchform')
Select(b.find_element_by_name('systemsearch-0.table'))\
.select_by_visible_text('Key/Value')
Select(b.find_element_by_name('systemsearch-0.keyvalue'))\
.select_by_visible_text('</script>')
def test_closing_script_tag_escaped_in_search_bar(self):
with session.begin():
Key.lazy_create(key_name=u'</script>')
b = self.browser
b.get(get_server_base())
b.find_element_by_link_text('Show Search Options').click()
wait_for_animation(b, '#searchform')
Select(b.find_element_by_name('systemsearch-0.table'))\
.select_by_visible_text('Key/Value')
Select(b.find_element_by_name('systemsearch-0.keyvalue'))\
.select_by_visible_text('</script>')
def save(self, **kw):
if kw['id']:
key = Key.by_id(kw['id'])
key.key_name = kw['key_name']
else:
key = Key(key_name=kw['key_name'])
session.add(key)
if 'numeric' in kw:
key.numeric = kw['numeric']
flash( _(u"OK") )
redirect(".")
def save(self, **kw):
if kw['id']:
key = Key.by_id(kw['id'])
key.key_name = kw['key_name']
else:
if Key.query.filter_by(key_name=kw['key_name']).first():
flash(u"Key Type exists: %s" % kw['key_name'])
redirect(".")
key = Key(key_name=kw['key_name'])
session.add(key)
key.numeric = kw['numeric']
flash(_(u"OK"))
redirect(".")
def save(self, **kw):
if kw["id"]:
key = Key.by_id(kw["id"])
key.key_name = kw["key_name"]
else:
if Key.query.filter_by(key_name=kw["key_name"]).first():
flash(u"Key Type exists: %s" % kw["key_name"])
redirect(".")
key = Key(key_name=kw["key_name"])
session.add(key)
key.numeric = kw["numeric"]
flash(_(u"OK"))
redirect(".")
def test_by_multiple_key_values(self):
with session.begin():
self.system = data_setup.create_system()
self.system.key_values_string.append(Key_Value_String(
Key.by_name(u'CPUMODEL'), 'foocodename'))
self.system.key_values_string.append(Key_Value_String(
Key.by_name(u'HVM'), '1'))
self.system.key_values_int.append(Key_Value_Int(
Key.by_name(u'DISKSPACE'), '1024'))
b = self.browser
perform_search(b, [('Key/Value', 'HVM', 'is', '1'),
('Key/Value', 'CPUMODEL', 'is', 'foocodename'),
('Key/Value', 'DISKSPACE', 'greater than', '1000')])
check_system_search_results(b, present=[self.system],
absent=[self.another_system])
def edit(self, **kw):
values = []
if kw.get("id"):
key = Key.by_id(kw["id"])
values = dict(id=key.id, key_name=key.key_name, numeric=key.numeric)
return dict(form=self.form, action="./save", options={}, value=values)
def test_existing_keys_are_untouched(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.extend([
Key_Value_String(Key.by_name(u'PCIID'), '1022:2000'), # this one gets deleted
Key_Value_String(Key.by_name(u'HVM'), '0'), # this one gets updated
Key_Value_String(Key.by_name(u'VENDOR'), 'Bob'), # this one should not be touched
])
self.server.legacypush(system.fqdn, {'PCIID': [], 'HVM': True})
with session.begin():
session.refresh(system)
self.assertEquals(len(system.key_values_string), 2, system.key_values_string)
self.assertEquals(system.key_values_string[0].key.key_name, u'VENDOR')
self.assertEquals(system.key_values_string[0].key_value, u'Bob')
self.assertEquals(system.key_values_string[1].key.key_name, u'HVM')
self.assertEquals(system.key_values_string[1].key_value, u'1')
def test_by_key_value_is_not(self):
with session.begin():
self.another_system.key_values_string.append(Key_Value_String(
Key.by_name(u'CPUMODEL'), 'foocodename'))
b = self.browser
perform_search(b, [('Key/Value', 'CPUMODEL', 'is not', 'foocodename')],
search_url=u'mine')
check_system_search_results(b, present=[self.system],
absent=[self.another_system])
def _from_csv(cls,system,data,csv_type,log):
"""
Import data from CSV file into System Objects
"""
if 'key' in data and data['key']:
try:
key = Key.by_name(data['key'])
except InvalidRequestError:
log.append('%s: Invalid Key %s ' % (system.fqdn, data['key']))
return False
else:
log.append('%s: Key must not be blank!' % system.fqdn)
return False
if 'key_value' in data and data['key_value']:
if key.numeric:
system_key_values = system.key_values_int
try:
key_value = Key_Value_Int.by_key_value(system,
key,
data['key_value'])
except InvalidRequestError:
key_value = Key_Value_Int(key=key,
key_value=data['key_value'])
else:
system_key_values = system.key_values_string
try:
key_value = Key_Value_String.by_key_value(system,
key,
data['key_value'])
except InvalidRequestError:
key_value = Key_Value_String(key=key,
key_value=data['key_value'])
else:
log.append('%s: Key Value must not be blank!' % system.fqdn)
return False
deleted = False
if 'deleted' in data:
deleted = smart_bool(data['deleted'])
if deleted:
if key_value in system_key_values:
system.record_activity(user=identity.current.user, service=u'CSV',
action=u'Removed', field=u'Key/Value',
old=u'%s/%s' % (data['key'],data['key_value']), new=u'')
system_key_values.remove(key_value)
if not key_value.id:
session.expunge(key_value)
else:
if key_value not in system_key_values:
system.record_activity(user=identity.current.user, service=u'CSV',
action=u'Added', field=u'Key/Value', old=u'',
new=u'%s/%s' % (data['key'],data['key_value']))
system_key_values.append(key_value)
session.add(key_value)
return True
def test_by_key_value_is_on_removed_systems_page(self):
with session.begin():
system = data_setup.create_system()
removed_system = data_setup.create_system(status=SystemStatus.removed)
removed_system.key_values_string.append(Key_Value_String(
Key.by_name(u'CPUMODEL'), 'foocodename'))
# Key Value search from "Removed Systems"
b = self.browser
perform_search(b, [('Key/Value', 'CPUMODEL', 'is', 'foocodename')],
search_url='removed')
check_system_search_results(b, present=[removed_system],
absent=[system])
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u"MODULE")
with_module = data_setup.create_system()
with_module.key_values_string.extend(
[Key_Value_String(module_key, u"cciss"), Key_Value_String(module_key, u"kvm")]
)
without_module = data_setup.create_system()
out = run_client(["bkr", "list-systems", "--xml-filter", '<key_value key="MODULE" />'])
returned_systems = out.splitlines()
self.assert_(with_module.fqdn in returned_systems, returned_systems)
self.assert_(without_module.fqdn not in returned_systems, returned_systems)
def test_system_activity_shows_changes(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.extend([
Key_Value_String(Key.by_name(u'PCIID'), '1022:2000'),
Key_Value_String(Key.by_name(u'PCIID'), '80ee:beef'),
])
self.server.legacypush(system.fqdn,
{'PCIID': ['80ee:cafe', '80ee:beef']})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].field_name, u'Key/Value')
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].old_value, None)
self.assertEquals(system.activity[0].new_value, u'PCIID/80ee:cafe')
self.assertEquals(system.activity[1].field_name, u'Key/Value')
self.assertEquals(system.activity[1].service, u'XMLRPC')
self.assertEquals(system.activity[1].action, u'Removed')
self.assertEquals(system.activity[1].old_value, u'PCIID/1022:2000')
self.assertEquals(system.activity[1].new_value, None)
def setUpClass(cls):
cls.browser = cls.get_browser()
login(cls.browser)
cls.system_one_details = { 'fqdn' : u'a1',
'type' : u'Machine',
'arch' : u'i386',
'status' : u'Automated',
'owner' : data_setup.create_user(),}
cls.system_one = data_setup.create_system(**cls.system_one_details)
cls.system_one.loaned = data_setup.create_user()
cls.system_one.numa = Numa(nodes=2)
cls.system_one.key_values_string.append(Key_Value_String(
Key.by_name(u'CPUMODEL'), 'foocodename'))
cls.system_one.key_values_string.append(Key_Value_String(
Key.by_name(u'HVM'), '1'))
cls.system_one.cpu = Cpu(flags=['flag1', 'flag2'])
cls.system_one.key_values_int.append(Key_Value_Int(
Key.by_name(u'DISKSPACE'), '1024'))
cls.system_one.key_values_int.append(Key_Value_Int(
Key.by_name(u'MEMORY'), '4096'))
cls.system_two_details = { 'fqdn' : u'a2',
'type' : u'Prototype',
'arch' : u'x86_64',
'status' : u'Manual',
'owner' : data_setup.create_user(),}
cls.system_two = data_setup.create_system(**cls.system_two_details)
cls.system_two.key_values_int.append(Key_Value_Int(
Key.by_name(u'DISKSPACE'), '900'))
cls.system_two.key_values_string.append(Key_Value_String(
Key.by_name(u'HVM'), '1'))
device_class = DeviceClass.lazy_create(device_class='class_type')
device1 = Device.lazy_create(vendor_id = '0000',
device_id = '0000',
subsys_vendor_id = '2223',
subsys_device_id = '2224',
bus = '0000',
driver = '0000',
device_class_id = device_class.id,
description = 'blah')
cls.system_two.devices.append(device1)
cls.system_three_details = { 'fqdn' : u'a3',
'type' : u'Laptop',
'arch' : u'ia64',
'status' : u'Removed',
'owner' : data_setup.create_user(),}
cls.system_three = data_setup.create_system(**cls.system_three_details)
cls.system_three.numa = Numa(nodes=1)
device2 = Device.lazy_create(vendor_id = '0000',
device_id = '0000',
subsys_vendor_id = '1111',
subsys_device_id = '1112',
bus = '0000',
driver = '0000',
device_class_id = device_class.id,
description = 'blah')
cls.system_three.devices.append(device2)
def test_key_present(self):
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_module = data_setup.create_system()
self.check_filter("""
<hostRequires>
<key_value key="MODULE" op="==" />
</hostRequires>
""",
present=[with_module], absent=[without_module])
def test_key_present(self):
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_module = data_setup.create_system()
self.check_filter("""
<hostRequires>
<key_value key="MODULE" op="==" />
</hostRequires>
""",
present=[with_module], absent=[without_module])
def edit(self, **kw):
values = []
if kw.get('id'):
key = Key.by_id(kw['id'])
values = dict(id=key.id,
key_name=key.key_name,
numeric=key.numeric)
return dict(
form=self.form,
action='./save',
options={},
value=values,
)
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_module = data_setup.create_system()
feed_url = urljoin(get_server_base(), '?' + urlencode({
'tg_format': 'atom', 'list_tgp_order': '-date_modified',
'xmlsearch': '<key_value key="MODULE" />'}))
feed = lxml.etree.parse(urlopen(feed_url)).getroot()
self.assert_(self.feed_contains_system(feed, with_module.fqdn))
self.assert_(not self.feed_contains_system(feed, without_module.fqdn))
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_module = data_setup.create_system()
out = run_client(['bkr', 'system-list',
'--xml-filter', '<key_value key="MODULE" />'])
returned_systems = out.splitlines()
self.assert_(with_module.fqdn in returned_systems, returned_systems)
self.assert_(without_module.fqdn not in returned_systems,
returned_systems)
def test_multiple_xml_filters(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
matching = data_setup.create_system()
matching.cpu = Cpu(vendor=u'GenuineIntel', family=6, model=47, model_name=u'Intel')
matching.key_values_string.append(
Key_Value_String(module_key, u'cciss'))
nonmatching = data_setup.create_system()
out = run_client(['bkr', 'system-list',
'--xml-filter', '<not><lender value="shark"/></not>',
'--xml-filter', '<key_value key="MODULE" value="cciss"/>',
'--host-filter', 'INTEL__WESTMERE'])
returned_systems = out.splitlines()
self.assertIn(matching.fqdn, returned_systems)
self.assertNotIn(nonmatching.fqdn, returned_systems)
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')
])
without_module = data_setup.create_system()
out = run_client([
'bkr', 'list-systems', '--xml-filter', '<key_value key="MODULE" />'
])
returned_systems = out.splitlines()
self.assert_(with_module.fqdn in returned_systems, returned_systems)
self.assert_(without_module.fqdn not in returned_systems,
returned_systems)
def edit(self,**kw):
values = []
if kw.get('id'):
key = Key.by_id(kw['id'])
values = dict(
id = key.id,
key_name = key.key_name,
numeric = key.numeric
)
return dict(
form = self.form,
action = './save',
options = {},
value = values,
)
def test_uncheck_numeric_keytype(self):
with session.begin():
key = Key(data_setup.unique_name(u'FOOBAR%s'), numeric=1)
session.add(key)
b = self.browser
login(b)
b.get(get_server_base() + 'keytypes/')
b.find_element_by_link_text('F').click()
b.find_element_by_link_text(key.key_name).click()
b.find_element_by_name('numeric').click()
b.find_element_by_id('keytypes').submit()
with session.begin():
session.refresh(key)
self.assertEqual(key.numeric, False)
def test_multiple_xml_filters(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
matching = data_setup.create_system()
matching.cpu = Cpu(family=6, model=47, model_name=u'Intel')
matching.key_values_string.append(
Key_Value_String(module_key, u'cciss'))
nonmatching = data_setup.create_system()
out = run_client([
'bkr', 'list-systems', '--xml-filter',
'<not><lender value="shark"/></not>', '--xml-filter',
'<key_value key="MODULE" value="cciss"/>', '--host-filter',
'INTEL__WESTMERE'
])
returned_systems = out.splitlines()
self.assertIn(matching.fqdn, returned_systems)
self.assertNotIn(nonmatching.fqdn, returned_systems)
def test_by_key_value_is(self):
with session.begin():
self.system.key_values_string.append(Key_Value_String(
Key.by_name(u'CPUMODEL'), 'foocodename'))
b = self.browser
b.get(get_server_base())
b.find_element_by_link_text('Show Search Options').click()
wait_for_animation(b, '#searchform')
Select(b.find_element_by_name('systemsearch-0.table'))\
.select_by_visible_text('Key/Value')
Select(b.find_element_by_name('systemsearch-0.keyvalue'))\
.select_by_visible_text('CPUMODEL')
Select(b.find_element_by_name('systemsearch-0.operation'))\
.select_by_visible_text('is')
b.find_element_by_name('systemsearch-0.value').send_keys('foocodename')
b.find_element_by_id('searchform').submit()
check_system_search_results(b, present=[self.system],
absent=[self.another_system])
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u"MODULE")
with_module = data_setup.create_system()
with_module.key_values_string.extend(
[Key_Value_String(module_key, u"cciss"), Key_Value_String(module_key, u"kvm")]
)
without_module = data_setup.create_system()
feed_url = urljoin(
get_server_base(),
"?"
+ urlencode(
{"tg_format": "atom", "list_tgp_order": "-date_modified", "xmlsearch": '<key_value key="MODULE" />'}
),
)
feed = lxml.etree.parse(urlopen(feed_url)).getroot()
self.assert_(self.feed_contains_system(feed, with_module.fqdn))
self.assert_(not self.feed_contains_system(feed, without_module.fqdn))
def test_key_notequal(self):
module_key = Key.by_name(u'MODULE')
with_cciss = data_setup.create_system()
with_cciss.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_cciss = data_setup.create_system()
without_cciss.key_values_string.extend([
Key_Value_String(module_key, u'ida'),
Key_Value_String(module_key, u'kvm')])
self.check_filter("""
<hostRequires>
<and>
<key_value key="MODULE" op="!=" value="cciss"/>
</and>
</hostRequires>
""",
present=[without_cciss], absent=[with_cciss])
def test_key_notequal(self):
module_key = Key.by_name(u'MODULE')
with_cciss = data_setup.create_system()
with_cciss.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')])
without_cciss = data_setup.create_system()
without_cciss.key_values_string.extend([
Key_Value_String(module_key, u'ida'),
Key_Value_String(module_key, u'kvm')])
self.check_filter("""
<hostRequires>
<and>
<key_value key="MODULE" op="!=" value="cciss"/>
</and>
</hostRequires>
""",
present=[without_cciss], absent=[with_cciss])
def test_xml_filter(self):
with session.begin():
module_key = Key.by_name(u'MODULE')
with_module = data_setup.create_system()
with_module.key_values_string.extend([
Key_Value_String(module_key, u'cciss'),
Key_Value_String(module_key, u'kvm')
])
without_module = data_setup.create_system()
feed_url = urljoin(
get_server_base(),
'?' + urlencode({
'tg_format': 'atom',
'list_tgp_order': '-date_modified',
'xmlsearch': '<key_value key="MODULE" />'
}))
feed = lxml.etree.parse(urlopen(feed_url)).getroot()
self.assert_(self.feed_contains_system(feed, with_module.fqdn))
self.assert_(not self.feed_contains_system(feed, without_module.fqdn))
def test_bools_are_coerced_to_ints(self):
with session.begin():
system = data_setup.create_system()
system.key_values_string.append(
Key_Value_String(Key.by_name(u'HVM'), '0'))
self.server.legacypush(system.fqdn, {'HVM': False})
with session.begin():
session.refresh(system)
self.assertEquals(len(system.activity), 0) # nothing has changed, yet
self.server.legacypush(system.fqdn, {'HVM': True})
with session.begin():
session.refresh(system)
self.assertEquals(system.activity[0].field_name, u'Key/Value')
self.assertEquals(system.activity[0].service, u'XMLRPC')
self.assertEquals(system.activity[0].action, u'Added')
self.assertEquals(system.activity[0].old_value, None)
self.assertEquals(system.activity[0].new_value, u'HVM/1')
def test_keyvalue_does_not_cause_duplicate_rows(self):
system = data_setup.create_system()
disk_key = Key.by_name(u'DISK')
system.key_values_int.extend([
Key_Value_Int(disk_key, 30718),
Key_Value_Int(disk_key, 140011),
Key_Value_Int(disk_key, 1048570)])
session.flush()
filter = """
<hostRequires>
<and>
<system><name op="=" value="%s" /></system>
<key_value key="DISK" op=">" value="9000" />
</and>
</hostRequires>
""" % system.fqdn
query = XmlHost.from_string(filter).apply_filter(System.query)
self.assertEquals(len(query.all()), 1)
# with the bug this count comes out as 3 instead of 1,
# which doesn't sound so bad...
# but when it's 926127 instead of 278, that's bad
self.assertEquals(query.count(), 1)
def filter(self, joins):
key = self.get_xml_attr('key', unicode, None)
op = self.op_table[self.get_xml_attr('op', unicode, '==')]
value = self.get_xml_attr('value', unicode, None)
try:
_key = Key.by_name(key)
except NoResultFound:
return (joins, None)
if op not in ('__eq__', '__ne__') and not value:
# makes no sense, discard
return (joins, None)
if _key.numeric:
key_value_cls = Key_Value_Int
collection = System.key_values_int
else:
key_value_cls = Key_Value_String
collection = System.key_values_string
# <key_value key="THING" op="==" /> -- must have key with any value
# <key_value key="THING" op="==" value="VALUE" /> -- must have key with given value
# <key_value key="THING" op="!=" /> -- must not have key
# <key_value key="THING" op="!=" value="VALUE" /> -- must not have key with given value
if op == '__ne__' and value is None:
query = not_(collection.any(key_value_cls.key == _key))
elif op == '__ne__':
query = not_(
collection.any(
and_(key_value_cls.key == _key,
key_value_cls.key_value == value)))
elif op == '__eq__' and value is None:
query = collection.any(key_value_cls.key == _key)
elif op == '__eq__':
query = collection.any(
and_(key_value_cls.key == _key,
key_value_cls.key_value == value))
else:
query = collection.any(
and_(key_value_cls.key == _key,
getattr(key_value_cls.key_value, op)(value)))
return (joins, query)
def test_keyvalue_does_not_cause_duplicate_rows(self):
system = data_setup.create_system()
disk_key = Key.by_name(u'DISK')
system.key_values_int.extend([
Key_Value_Int(disk_key, 30718),
Key_Value_Int(disk_key, 140011),
Key_Value_Int(disk_key, 1048570)])
session.flush()
filter = """
<hostRequires>
<and>
<system><name op="=" value="%s" /></system>
<key_value key="DISK" op=">" value="9000" />
</and>
</hostRequires>
""" % system.fqdn
query = XmlHost.from_string(filter).apply_filter(System.query)
self.assertEquals(len(query.all()), 1)
# with the bug this count comes out as 3 instead of 1,
# which doesn't sound so bad...
# but when it's 926127 instead of 278, that's bad
self.assertEquals(query.count(), 1)
def test_remove_key_value(self):
with session.begin():
self.system.key_values_int.append(
Key_Value_Int(Key.by_name(u'NR_DISKS'), 100))
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Key/Values')
b.find_element_by_xpath(
'//td[normalize-space(preceding-sibling::td[1]/text())'
'="NR_DISKS" and '
'normalize-space(text())="100"]')
delete_and_confirm(b, '//tr[normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"]')
self.assertEquals(b.find_element_by_class_name('flash').text,
'removed NR_DISKS/100')
b.find_element_by_xpath('//div[@id="keys" and not(.//tr['
'normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"])]')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def filter(self, joins):
key = self.get_xml_attr('key', unicode, None)
op = self.op_table[self.get_xml_attr('op', unicode, '==')]
value = self.get_xml_attr('value', unicode, None)
try:
_key = Key.by_name(key)
except NoResultFound:
return (joins, None)
if op not in ('__eq__', '__ne__') and not value:
# makes no sense, discard
return (joins, None)
if _key.numeric:
key_value_cls = Key_Value_Int
collection = System.key_values_int
else:
key_value_cls = Key_Value_String
collection = System.key_values_string
# <key_value key="THING" op="==" /> -- must have key with any value
# <key_value key="THING" op="==" value="VALUE" /> -- must have key with given value
# <key_value key="THING" op="!=" /> -- must not have key
# <key_value key="THING" op="!=" value="VALUE" /> -- must not have key with given value
if op == '__ne__' and value is None:
query = not_(collection.any(key_value_cls.key == _key))
elif op == '__ne__':
query = not_(collection.any(and_(
key_value_cls.key == _key,
key_value_cls.key_value == value)))
elif op == '__eq__' and value is None:
query = collection.any(key_value_cls.key == _key)
elif op == '__eq__':
query = collection.any(and_(
key_value_cls.key == _key,
key_value_cls.key_value == value))
else:
query = collection.any(and_(
key_value_cls.key == _key,
getattr(key_value_cls.key_value, op)(value)))
return (joins, query)
def test_remove_key_value(self):
with session.begin():
self.system.key_values_int.append(
Key_Value_Int(Key.by_name(u'NR_DISKS'), 100))
orig_date_modified = self.system.date_modified
b = self.browser
login(b)
self.go_to_system_view(tab='Key/Values')
b.find_element_by_xpath(
'//td[normalize-space(preceding-sibling::td[1]/text())'
'="NR_DISKS" and '
'normalize-space(text())="100"]')
delete_and_confirm(
b, '//tr[normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"]')
self.assertEquals(
b.find_element_by_class_name('flash').text, 'removed NR_DISKS/100')
b.find_element_by_xpath('//div[@id="keys" and not(.//tr['
'normalize-space(td[1]/text())="NR_DISKS" and '
'normalize-space(td[2]/text())="100"])]')
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def test_remove_key_value(self):
with session.begin():
self.system.key_values_int.append(Key_Value_Int(Key.by_name(u"NR_DISKS"), 100))
orig_date_modified = self.system.date_modified
self.login()
sel = self.selenium
self.go_to_system_view()
sel.click('//ul[@class="tabbernav"]//a[text()="Key/Values"]')
self.assertEquals(
sel.get_xpath_count(
"//td[normalize-space(preceding-sibling::td[1]/text())"
'="NR_DISKS" and '
'normalize-space(text())="100"]'
),
1,
)
sel.click( # delete link inside cell in row with NR_DISKS 100
'//table[@class="list"]//td['
'normalize-space(preceding-sibling::td[2]/text())="NR_DISKS" and '
'normalize-space(preceding-sibling::td[1]/text())="100"'
']//a[text()="Delete ( - )"]'
)
sel.click("//button[@type='button' and text()='Yes']")
sel.wait_for_page_to_load("30000")
self.assertEquals(sel.get_text("css=.flash"), "removed NR_DISKS/100")
self.assertEquals(
sel.get_xpath_count(
"//td[normalize-space(preceding-sibling::td[1]/text())"
'="NR_DISKS" and '
'normalize-space(text())="100"]'
),
0,
)
with session.begin():
session.refresh(self.system)
self.assert_(self.system.date_modified > orig_date_modified)
def setUpClass(cls):
cls.system_one_details = {
'fqdn': u'a1',
'type': u'Machine',
'arch': u'i386',
'status': u'Automated',
'owner': data_setup.create_user(),
}
cls.system_one = data_setup.create_system(**cls.system_one_details)
cls.system_one.loaned = data_setup.create_user()
cls.system_one.numa = Numa(nodes=2)
cls.system_one.key_values_string.append(
Key_Value_String(Key.by_name(u'CPUMODEL'), 'foocodename'))
cls.system_one.key_values_string.append(
Key_Value_String(Key.by_name(u'HVM'), '1'))
cls.system_one.cpu = Cpu(flags=['flag1', 'flag2'])
cls.system_one.key_values_int.append(
Key_Value_Int(Key.by_name(u'DISKSPACE'), '1024'))
cls.system_one.key_values_int.append(
Key_Value_Int(Key.by_name(u'MEMORY'), '4096'))
cls.system_two_details = {
'fqdn': u'a2',
'type': u'Prototype',
'arch': u'x86_64',
'status': u'Manual',
'owner': data_setup.create_user(),
}
cls.system_two = data_setup.create_system(**cls.system_two_details)
cls.system_two.key_values_int.append(
Key_Value_Int(Key.by_name(u'DISKSPACE'), '900'))
cls.system_two.key_values_string.append(
Key_Value_String(Key.by_name(u'HVM'), '1'))
device_class = DeviceClass.lazy_create(device_class='class_type')
device1 = Device.lazy_create(vendor_id='0000',
device_id='0000',
subsys_vendor_id='2223',
subsys_device_id='2224',
bus='0000',
driver='0000',
device_class_id=device_class.id,
description='blah')
cls.system_two.devices.append(device1)
cls.system_three_details = {
'fqdn': u'a3',
'type': u'Laptop',
'arch': u'ia64',
'status': u'Automated',
'owner': data_setup.create_user(),
}
cls.system_three = data_setup.create_system(**cls.system_three_details)
cls.system_three.numa = Numa(nodes=1)
device2 = Device.lazy_create(vendor_id='0000',
device_id='0000',
subsys_vendor_id='1111',
subsys_device_id='1112',
bus='0000',
driver='0000',
device_class_id=device_class.id,
description='blah')
cls.system_three.devices.append(device2)
cls.system_four_details = {
'status': u'Removed',
}
cls.system_four = data_setup.create_system(**cls.system_four_details)
cls.system_four.key_values_string.append(
Key_Value_String(Key.by_name(u'CPUMODEL'), 'foocodename'))
def populate_db(user_name=None, password=None, user_display_name=None,
user_email_address=None):
logger.info('Populating tables with pre-defined values if necessary')
session.begin()
try:
admin = Group.by_name(u'admin')
except InvalidRequestError:
admin = Group(group_name=u'admin', display_name=u'Admin')
session.add(admin)
try:
lab_controller = Group.by_name(u'lab_controller')
except InvalidRequestError:
lab_controller = Group(group_name=u'lab_controller',
display_name=u'Lab Controller')
session.add(lab_controller)
# Setup User account
if user_name:
user = User.lazy_create(user_name=user_name.decode('utf8'))
if password:
user.password = password.decode('utf8')
if user_display_name:
user.display_name = user_display_name.decode('utf8')
if user_email_address:
user.email_address = user_email_address.decode('utf8')
# Ensure the user is in the 'admin' group as an owner.
# Flush for lazy_create.
session.flush()
user_group_assoc = UserGroup.lazy_create(
user_id=user.user_id, group_id=admin.group_id)
user_group_assoc.is_owner = True
# Create distro_expire perm if not present
try:
_ = Permission.by_name(u'distro_expire')
except NoResultFound:
distro_expire_perm = Permission(u'distro_expire')
session.add(distro_expire_perm)
# Create proxy_auth perm if not present
try:
_ = Permission.by_name(u'proxy_auth')
except NoResultFound:
proxy_auth_perm = Permission(u'proxy_auth')
session.add(proxy_auth_perm)
# Create tag_distro perm if not present
try:
_ = Permission.by_name(u'tag_distro')
except NoResultFound:
tag_distro_perm = Permission(u'tag_distro')
admin.permissions.append(tag_distro_perm)
# Create stop_task perm if not present
try:
_ = Permission.by_name(u'stop_task')
except NoResultFound:
stop_task_perm = Permission(u'stop_task')
lab_controller.permissions.append(stop_task_perm)
admin.permissions.append(stop_task_perm)
# Create secret_visible perm if not present
try:
_ = Permission.by_name(u'secret_visible')
except NoResultFound:
secret_visible_perm = Permission(u'secret_visible')
lab_controller.permissions.append(secret_visible_perm)
admin.permissions.append(secret_visible_perm)
# Create change_prio perm if not present
try:
_ = Permission.by_name(u'change_prio')
except NoResultFound:
change_prio_perm = Permission(u'change_prio')
session.add(change_prio_perm)
# Setup Hypervisors Table
if Hypervisor.query.count() == 0:
for h in [u'KVM', u'Xen', u'HyperV', u'VMWare']:
session.add(Hypervisor(hypervisor=h))
# Setup kernel_type Table
if KernelType.query.count() == 0:
for type in [u'default', u'highbank', u'imx', u'omap', u'tegra']:
session.add(KernelType(kernel_type=type, uboot=False))
for type in [u'mvebu']:
session.add(KernelType(kernel_type=type, uboot=True))
# Setup base Architectures
if Arch.query.count() == 0:
for arch in [u'i386', u'x86_64', u'ia64', u'ppc', u'ppc64', u'ppc64le',
u's390', u's390x', u'armhfp', u'aarch64', u'arm']:
session.add(Arch(arch))
# Setup base power types
if PowerType.query.count() == 0:
for power_type in [u'apc_snmp', u'apc_snmp_then_etherwake',
u'bladecenter', u'bladepap', u'drac', u'ether_wake', u'hyper-v',
u'ilo', u'integrity', u'ipmilan', u'ipmitool', u'lpar', u'rsa',
u'virsh', u'wti']:
session.add(PowerType(power_type))
# Setup key types
if Key.query.count() == 0:
session.add(Key(u'DISKSPACE', True))
session.add(Key(u'COMMENT'))
session.add(Key(u'CPUFAMILY', True))
session.add(Key(u'CPUFLAGS'))
session.add(Key(u'CPUMODEL'))
session.add(Key(u'CPUMODELNUMBER', True))
session.add(Key(u'CPUSPEED', True))
session.add(Key(u'CPUVENDOR'))
session.add(Key(u'DISK', True))
session.add(Key(u'FORMFACTOR'))
session.add(Key(u'HVM'))
session.add(Key(u'MEMORY', True))
session.add(Key(u'MODEL'))
session.add(Key(u'MODULE'))
session.add(Key(u'NETWORK'))
session.add(Key(u'NR_DISKS', True))
session.add(Key(u'NR_ETH', True))
session.add(Key(u'NR_IB', True))
session.add(Key(u'PCIID'))
session.add(Key(u'PROCESSORS', True))
session.add(Key(u'RTCERT'))
session.add(Key(u'SCRATCH'))
session.add(Key(u'STORAGE'))
session.add(Key(u'USBID'))
session.add(Key(u'VENDOR'))
session.add(Key(u'XENCERT'))
session.add(Key(u'NETBOOT_METHOD'))
if RetentionTag.query.count() == 0:
session.add(RetentionTag(tag=u'scratch', is_default=1, expire_in_days=30))
session.add(RetentionTag(tag=u'60days', needs_product=False, expire_in_days=60))
session.add(RetentionTag(tag=u'120days', needs_product=False, expire_in_days=120))
session.add(RetentionTag(tag=u'active', needs_product=True))
session.add(RetentionTag(tag=u'audit', needs_product=True))
config_items = [
# name, description, numeric
(u'root_password', u'Plaintext root password for provisioned systems', False),
(u'root_password_validity', u"Maximum number of days a user's root password is valid for",
True),
(u'guest_name_prefix', u'Prefix for names of dynamic guests in OpenStack', False),
(u'guest_private_network', u'Network address in CIDR format for private networks'
' of dynamic guests in OpenStack.', False),
]
for name, description, numeric in config_items:
ConfigItem.lazy_create(name=name, description=description, numeric=numeric)
if ConfigItem.by_name(u'root_password').current_value() is None:
ConfigItem.by_name(u'root_password').set(u'beaker', user=admin.users[0])
if ConfigItem.by_name(u'guest_private_network').current_value() is None:
ConfigItem.by_name(u'guest_private_network').set(u'192.168.10.0/24',
user=admin.users[0])
session.commit()
session.close()
logger.info('Pre-defined values populated')
def remove(self, **kw):
remove = Key.by_id(kw['id'])
session.delete(remove)
flash( _(u"%s Deleted") % remove.key_name )
raise redirect(".")
