def test_or_lab_controller(self):
lc1 = data_setup.create_labcontroller(fqdn=u'lab1')
lc2 = data_setup.create_labcontroller(fqdn=u'lab2')
lc3 = data_setup.create_labcontroller(fqdn=u'lab3')
included = data_setup.create_system()
included.lab_controller = lc1
excluded = data_setup.create_system()
excluded.lab_controller = lc3
self.check_filter("""
<hostRequires>
<or>
<hostlabcontroller op="=" value="lab1"/>
<hostlabcontroller op="=" value="lab2"/>
</or>
</hostRequires>
""",
present=[included], absent=[excluded])
self.check_filter("""
<hostRequires>
<or>
<labcontroller op="=" value="lab1"/>
<labcontroller op="=" value="lab2"/>
</or>
</hostRequires>
""",
present=[included], absent=[excluded])
def setUpClass(cls):
# Each distro needs to have a tree in some lab controller, otherwise it
# won't show up in search results.
data_setup.create_labcontroller()
cls.distro_one_name = data_setup.unique_name(u'nametest%s')
cls.distro_one_osmajor = u'osmajortest1'
cls.distro_one_osminor = u'1'
cls.distro_one_tags = None
cls.distro_one = data_setup.create_distro(name=cls.distro_one_name,
osmajor=cls.distro_one_osmajor, osminor = cls.distro_one_osminor,
tags =cls.distro_one_tags)
data_setup.create_distro_tree(distro=cls.distro_one)
# Two days in the future
cls.distro_one.date_created = datetime.utcnow() + timedelta(days=2)
cls.distro_two_name = data_setup.unique_name(u'nametest%s')
cls.distro_two_osmajor = u'osmajortest2'
cls.distro_two_osminor = u'2'
cls.distro_two_tags = None
cls.distro_two = data_setup.create_distro(name=cls.distro_two_name,
osmajor=cls.distro_two_osmajor, osminor = cls.distro_two_osminor,
tags =cls.distro_two_tags)
data_setup.create_distro_tree(distro=cls.distro_two)
cls.distro_three_name = data_setup.unique_name(u'nametest%s')
cls.distro_three_osmajor = u'osmajortest3'
cls.distro_three_osminor = u'3'
cls.distro_three_tags = None
cls.distro_three = data_setup.create_distro(name=cls.distro_three_name,
osmajor=cls.distro_three_osmajor, osminor = cls.distro_three_osminor,
tags =cls.distro_three_tags)
data_setup.create_distro_tree(distro=cls.distro_three)
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller()
self.lc.user.password = u"logmein"
self.lc2 = data_setup.create_labcontroller()
self.lc2.user.password = u"logmein"
self.server = self.get_server()
def test_list_systems_lc_disabled(self):
with session.begin():
lc1 = data_setup.create_labcontroller()
lc2 = data_setup.create_labcontroller()
system1 = data_setup.create_system(fqdn=data_setup.unique_name(u'aaaa%s.testdata'))
system1.lab_controller = lc1
system2 = data_setup.create_system(fqdn=data_setup.unique_name(u'aaaa%s.testdata'))
system2.lab_controller = lc2
# set lc2 to disabled
lc2.disabled = True
out = run_client(['bkr', 'system-list'])
systems = out.splitlines()
self.assertIn(system1.fqdn, systems)
self.assertIn(system2.fqdn, systems)
out = run_client(['bkr', 'system-list', '--free'])
systems = out.splitlines()
self.assertIn(system1.fqdn, systems)
self.assertNotIn(system2.fqdn, systems)
out = run_client(['bkr', 'system-list', '--available'])
systems = out.splitlines()
self.assertIn(system1.fqdn, systems)
self.assertIn(system2.fqdn, systems)
def setupClass(cls):
data_setup.create_labcontroller()
cls.distro_one_name = data_setup.unique_name(u'nametest%s')
cls.distro_one_osmajor = u'osmajortest1'
cls.distro_one_osminor = u'1'
cls.distro_one_variant = u'myvariant'
cls.distro_one_tag = [u'MYTAG']
cls.distro_one = data_setup.create_distro(name=cls.distro_one_name,
osmajor=cls.distro_one_osmajor, osminor = cls.distro_one_osminor,
tags =cls.distro_one_tag)
cls.distro_tree_one = data_setup.create_distro_tree(distro=cls.distro_one,
variant=cls.distro_one_variant)
# Two days in the future
cls.distro_two_name = data_setup.unique_name(u'nametest%s')
cls.distro_two_osmajor = u'osmajortest2'
cls.distro_two_osminor = u'2'
cls.distro_two = data_setup.create_distro(name=cls.distro_two_name,
osmajor=cls.distro_two_osmajor, osminor = cls.distro_two_osminor,)
cls.distro_tree_two = data_setup.create_distro_tree(distro=cls.distro_two)
cls.distro_tree_two.date_created = datetime.utcnow() + timedelta(days=2)
cls.distro_three_name = data_setup.unique_name(u'nametest%s')
cls.distro_three_osmajor = u'osmajortest3'
cls.distro_three_osminor = u'3'
cls.distro_three = data_setup.create_distro(name=cls.distro_three_name,
osmajor=cls.distro_three_osmajor, osminor = cls.distro_three_osminor,)
cls.distro_tree_three = data_setup.create_distro_tree(distro=cls.distro_three)
def setUp(self):
with session.begin():
data_setup.create_labcontroller(fqdn=u'lab-devel.rhts.eng.bos.redhat.com')
self.selenium = self.get_selenium()
self.selenium.start()
self.condition_report = 'never being fixed'
logged_in = self.login()
def setupClass(cls):
data_setup.create_labcontroller()
cls.distro_one_name = data_setup.unique_name(u"nametest%s")
cls.distro_one_osmajor = u"osmajortest1"
cls.distro_one_osminor = u"1"
cls.distro_one_variant = u"myvariant"
cls.distro_one_tag = [u"MYTAG"]
cls.distro_one = data_setup.create_distro(
name=cls.distro_one_name,
osmajor=cls.distro_one_osmajor,
osminor=cls.distro_one_osminor,
tags=cls.distro_one_tag,
)
cls.distro_tree_one = data_setup.create_distro_tree(distro=cls.distro_one, variant=cls.distro_one_variant)
# Two days in the future
cls.distro_two_name = data_setup.unique_name(u"nametest%s")
cls.distro_two_osmajor = u"osmajortest2"
cls.distro_two_osminor = u"2"
cls.distro_two = data_setup.create_distro(
name=cls.distro_two_name, osmajor=cls.distro_two_osmajor, osminor=cls.distro_two_osminor
)
cls.distro_tree_two = data_setup.create_distro_tree(distro=cls.distro_two)
cls.distro_tree_two.date_created = datetime.utcnow() + timedelta(days=2)
cls.distro_three_name = data_setup.unique_name(u"nametest%s")
cls.distro_three_osmajor = u"osmajortest3"
cls.distro_three_osminor = u"3"
cls.distro_three = data_setup.create_distro(
name=cls.distro_three_name, osmajor=cls.distro_three_osmajor, osminor=cls.distro_three_osminor
)
cls.distro_tree_three = data_setup.create_distro_tree(distro=cls.distro_three)
def setUp(self):
self.page_size = 20
with session.begin():
self.lc = data_setup.create_labcontroller()
other_lc = data_setup.create_labcontroller()
for _ in range(self.page_size + 5):
other_lc.record_activity(service=u'testdata',
field=u'nothing', action=u'nothing')
self.browser = self.get_browser()
def test_no_quotes(self):
with session.begin():
data_setup.create_labcontroller(fqdn=u'imhoff.bkr')
b = self.browser
login(b)
b.get(get_server_base() + 'csv/csv_import')
b.find_element_by_name('csv_file').send_keys(
pkg_resources.resource_filename(self.__module__, 'bz787519.csv'))
b.find_element_by_name('csv_file').submit()
self.failUnless(is_text_present(self.browser, "No Errors"))
def setUp(self):
with session.begin():
self.owner = data_setup.create_user(password=u'password')
self.lc1 = data_setup.create_labcontroller(fqdn=u'bz704399.example.invalid')
self.lc2 = data_setup.create_labcontroller()
self.s1 = data_setup.create_system(lab_controller=self.lc1, loaned=self.owner)
self.s2 = data_setup.create_system(lab_controller=self.lc2, loaned=self.owner)
self.browser = self.get_browser()
login(self.browser, user=self.owner.user_name, password=u'password')
def setUp(self):
with session.begin():
self.user = data_setup.create_user(password=u'password')
self.system = data_setup.create_system(
lab_controller=data_setup.create_labcontroller())
self.system.loaned = self.user
self.another_system = data_setup.create_system(
lab_controller=data_setup.create_labcontroller())
self.another_system.loaned = self.user
self.browser = self.get_browser()
login(self.browser, user=self.user.user_name, password=u'password')
def test_change_fqdn(self):
with session.begin():
lc = data_setup.create_labcontroller()
another_lc = data_setup.create_labcontroller()
new_fqdn = data_setup.unique_name(u'lab%s.testdata.invalid')
run_client(['bkr', 'labcontroller-modify',
'--fqdn', new_fqdn,
lc.fqdn])
with session.begin():
session.refresh(lc)
self.assertEquals(lc.fqdn, new_fqdn)
def setup_package():
assert os.path.exists(CONFIG_FILE), 'Config file %s must exist' % CONFIG_FILE
load_config(configfile=CONFIG_FILE)
log_to_stream(sys.stdout, level=logging.DEBUG)
from bkr.inttest import data_setup
if not 'BEAKER_SKIP_INIT_DB' in os.environ:
data_setup.setup_model()
with session.begin():
data_setup.create_labcontroller() #always need a labcontroller
data_setup.create_task(name=u'/distribution/install', requires=
u'make gcc nfs-utils wget procmail redhat-lsb ntp '
u'@development-tools @development-libs @development '
u'@desktop-platform-devel @server-platform-devel '
u'libxml2-python expect pyOpenSSL'.split())
data_setup.create_task(name=u'/distribution/reservesys',
requires=u'emacs vim-enhanced unifdef sendmail'.split())
data_setup.create_distro()
if not os.path.exists(turbogears.config.get('basepath.rpms')):
os.mkdir(turbogears.config.get('basepath.rpms'))
setup_slapd()
turbogears.testutil.make_app(Root)
turbogears.testutil.start_server()
if 'BEAKER_SERVER_BASE_URL' not in os.environ:
# need to start the server ourselves
# Usual pkg_resources ugliness is needed to ensure gunicorn doesn't
# import pkg_resources before we get a chance to specify our
# requirements in bkr.server.wsgi
processes.extend([
Process('gunicorn', args=[sys.executable, '-c',
'__requires__ = ["CherryPy < 3.0"]; import pkg_resources; ' \
'from gunicorn.app.wsgiapp import run; run()',
'--bind', ':%s' % turbogears.config.get('server.socket_port'),
'--workers', '8', '--access-logfile', '-', '--preload',
'bkr.server.wsgi:application'],
listen_port=turbogears.config.get('server.socket_port')),
])
processes.extend([
Process('slapd', args=['slapd', '-d0', '-F/tmp/beaker-tests-slapd-config',
'-hldap://127.0.0.1:3899/'],
listen_port=3899, stop_signal=signal.SIGINT),
])
try:
for process in processes:
process.start()
except:
for process in processes:
process.stop()
raise
def test_cannot_change_fqdn_to_duplicate(self):
with session.begin():
lc = data_setup.create_labcontroller()
other_lc = data_setup.create_labcontroller()
b = self.browser
b.get(get_server_base() + "labcontrollers/edit?id=%s" % lc.id)
b.find_element_by_name("fqdn").clear()
b.find_element_by_name("fqdn").send_keys(other_lc.fqdn)
b.find_element_by_id("form").submit()
self.assertEquals(
b.find_element_by_xpath('//input[@name="fqdn"]/following-sibling::span').text, "FQDN is not unique"
)
def test_change_fqdn_being_used_by_another_lab_controller(self):
with session.begin():
lc = data_setup.create_labcontroller()
another_lc = data_setup.create_labcontroller()
new_fqdn = data_setup.unique_name(u'lab%s.testdata.invalid')
try:
run_client(['bkr', 'labcontroller-modify',
'--fqdn', another_lc.fqdn,
lc.fqdn])
self.fail('Must error out')
except ClientError as e:
self.assertIn('FQDN %s already in use' % another_lc.fqdn,
e.stderr_output)
def setup_package():
log.info('Loading test configuration from %s', CONFIG_FILE)
assert os.path.exists(CONFIG_FILE), 'Config file %s must exist' % CONFIG_FILE
update_config(configfile=CONFIG_FILE, modulename='bkr.server.config')
# Override loaded logging config, in case we are using the server's config file
# (we really always want our tests' logs to go to stdout, not /var/log/beaker/)
log_to_stream(sys.stdout, level=logging.NOTSET)
from bkr.inttest import data_setup
if not 'BEAKER_SKIP_INIT_DB' in os.environ:
data_setup.setup_model()
with session.begin():
data_setup.create_labcontroller() #always need a labcontroller
data_setup.create_task(name=u'/distribution/install', requires=
u'make gcc nfs-utils wget procmail redhat-lsb ntp '
u'@development-tools @development-libs @development '
u'@desktop-platform-devel @server-platform-devel '
u'libxml2-python expect pyOpenSSL'.split())
data_setup.create_task(name=u'/distribution/reservesys',
requires=u'emacs vim-enhanced unifdef sendmail'.split())
data_setup.create_distro()
if not os.path.exists(turbogears.config.get('basepath.rpms')):
os.mkdir(turbogears.config.get('basepath.rpms'))
setup_slapd()
turbogears.testutil.make_app(Root)
turbogears.testutil.start_server()
if 'BEAKER_SERVER_BASE_URL' not in os.environ:
# need to start the server ourselves
# (this only works from the IntegrationTests dir of a Beaker checkout)
processes.extend([
Process('beaker', args=['../Server/start-server.py', CONFIG_FILE],
listen_port=turbogears.config.get('server.socket_port'),
stop_signal=signal.SIGINT)
])
processes.extend([
Process('slapd', args=['slapd', '-d0', '-F/tmp/beaker-tests-slapd-config',
'-hldap://127.0.0.1:3899/'],
listen_port=3899, stop_signal=signal.SIGINT),
])
try:
for process in processes:
process.start()
except:
for process in processes:
process.stop()
raise
def setUp(cls):
# Create two unique labs
lab1 = data_setup.create_labcontroller(fqdn=u'lab_%d' %
int(time.time() * 1000))
lab2 = data_setup.create_labcontroller(fqdn=u'lab_%d' %
int(time.time() * 1000))
# Create two distros and only put one in each lab.
cls.distro_tree1 = data_setup.create_distro_tree()
cls.distro_tree2 = data_setup.create_distro_tree()
session.flush()
cls.distro_tree1.lab_controller_assocs = [LabControllerDistroTree(
lab_controller=lab2, url=u'http://notimportant')]
cls.distro_tree2.lab_controller_assocs = [LabControllerDistroTree(
lab_controller=lab1, url=u'http://notimportant')]
# Create a user
user = data_setup.create_user()
# Create two systems but only put them in lab1.
system1 = data_setup.create_system(owner=user)
system2 = data_setup.create_system(owner=user)
system1.lab_controller = lab1
system2.lab_controller = lab1
session.flush()
# Create two jobs, one requiring distro_tree1 and one requiring distro_tree2
job = '''
<job>
<whiteboard>%s</whiteboard>
<recipeSet>
<recipe>
<distroRequires>
<distro_name op="=" value="%s" />
</distroRequires>
<hostRequires/>
<task name="/distribution/install" role="STANDALONE">
<params/>
</task>
</recipe>
</recipeSet>
</job>
'''
xmljob1 = XmlJob(xmltramp.parse(job % (cls.distro_tree1.distro.name,
cls.distro_tree1.distro.name)))
xmljob2 = XmlJob(xmltramp.parse(job % (cls.distro_tree2.distro.name,
cls.distro_tree2.distro.name)))
cls.job1 = Jobs().process_xmljob(xmljob1, user)
cls.job2 = Jobs().process_xmljob(xmljob2, user)
def test_filtering_by_lab_controller(self):
with session.begin():
distro_tree_in = data_setup.create_distro_tree()
distro_tree_out = data_setup.create_distro_tree()
good_lc = data_setup.create_labcontroller()
bad_lc = data_setup.create_labcontroller()
distro_tree_in.lab_controller_assocs.append(LabControllerDistroTree(
lab_controller=good_lc, url=u'http://notimportant'))
distro_tree_out.lab_controller_assocs.append(LabControllerDistroTree(
lab_controller=bad_lc, url=u'http://notimportant'))
output = run_client(['bkr', 'distro-trees-list', '--format=json', '--labcontroller', good_lc.fqdn])
trees = json.loads(output)
self.assert_(any(distro_tree_in.id == tree['distro_tree_id'] for tree in trees))
self.assert_(not any(distro_tree_out.id == tree['distro_tree_id'] for tree in trees))
def test_filtering_by_lab_controller(self):
with session.begin():
good_lc = data_setup.create_labcontroller()
bad_lc = data_setup.create_labcontroller()
distro_tree_in = data_setup.create_distro_tree()
distro_tree_out = data_setup.create_distro_tree()
session.flush()
distro_tree_in.lab_controller_assocs[:] = [LabControllerDistroTree(
lab_controller=good_lc, url=u'http://notimportant')]
distro_tree_out.lab_controller_assocs[:] = [LabControllerDistroTree(
lab_controller=bad_lc, url=u'http://notimportant')]
distro_trees = self.server.distrotrees.filter({'labcontroller': good_lc.fqdn})
self.assert_(distro_tree_in.id in [d['distro_tree_id'] for d in distro_trees], distro_trees)
self.assert_(distro_tree_out.id not in [d['distro_tree_id'] for d in distro_trees], distro_trees)
def setup_package():
global lc_fqdn, _daemons_running_externally
conf = get_conf()
if not 'BEAKER_LABCONTROLLER_HOSTNAME' in os.environ:
# Need to start the lab controller daemons ourselves
with session.begin():
user = data_setup.create_user(user_name=conf.get('USERNAME').decode('utf8'), password=conf.get('PASSWORD'))
lc = data_setup.create_labcontroller(fqdn=u'localhost', user=user)
processes.extend([
Process('beaker-proxy',
args=['python', '../LabController/src/bkr/labcontroller/main.py',
'-c', config_file, '-f'],
listen_port=8000,
stop_signal=signal.SIGTERM),
Process('beaker-provision',
args=['python', '../LabController/src/bkr/labcontroller/provision.py',
'-c', config_file, '-f'],
stop_signal=signal.SIGTERM),
Process('beaker-watchdog',
args=['python', '../LabController/src/bkr/labcontroller/watchdog.py',
'-c', config_file, '-f'],
stop_signal=signal.SIGTERM),
])
lc_fqdn = u'localhost'
else:
_daemons_running_externally = True
# We have been passed a space seperated list of LCs
lab_controllers = os.environ.get('BEAKER_LABCONTROLLER_HOSTNAME').decode('utf8')
lab_controllers_list = lab_controllers.split()
# Just get the last one, it shouldn't matter to us
lab_controller = lab_controllers_list.pop()
# Make sure that the LC is in the DB
data_setup.create_labcontroller(fqdn=lab_controller)
lc_fqdn = lab_controller
# Clear out any existing job logs, so that they are registered correctly
# when first created.
# If we've been passed a remote hostname for the LC, we assume it's been
# freshly provisioned and the dir will already be empty.
shutil.rmtree(conf.get('CACHEPATH'), ignore_errors=True)
try:
for process in processes:
process.start()
except:
for process in processes:
process.stop()
raise
def test_cannot_change_username_to_duplicate(self):
# Changing an LC's username to an existing user account is okay, but
# you can't change it to a user account that is already being used by
# another LC.
with session.begin():
lc = data_setup.create_labcontroller()
other_lc = data_setup.create_labcontroller()
b = self.browser
b.get(get_server_base() + 'labcontrollers/edit?id=%s' % lc.id)
b.find_element_by_name('lusername').clear()
b.find_element_by_name('lusername').send_keys(other_lc.user.user_name)
b.find_element_by_id('form').submit()
self.assertEquals(b.find_element_by_xpath(
'//input[@name="lusername"]/following-sibling::span').text,
'Username is in use by a different lab controller')
def setUp(self):
self.browser = self.get_browser()
with session.begin():
self.lc = data_setup.create_labcontroller()
self.distro_tree = data_setup.create_distro_tree(
osmajor=u'RedHatEnterpriseLinux6',
lab_controllers=[self.lc])
def test_peer_roles(self):
with session.begin():
dt = data_setup.create_distro_tree()
lc = data_setup.create_labcontroller()
systems = [
data_setup.create_system(fqdn=u'server.peer-roles.invalid', lab_controller=lc),
data_setup.create_system(fqdn=u'clientone.peer-roles.invalid', lab_controller=lc),
data_setup.create_system(fqdn=u'clienttwo.peer-roles.invalid', lab_controller=lc),
]
job = data_setup.create_job_for_recipes([
data_setup.create_recipe(distro_tree=dt, role=u'SERVERS'),
data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
])
job.recipesets[0].recipes[0].tasks[0].role = None
# Normally you wouldn't use the same role name with different
# meaning at the task level, because that would just get
# confusing... but it is possible
job.recipesets[0].recipes[1].tasks[0].role = u'SERVERS'
job.recipesets[0].recipes[2].tasks[0].role = u'CLIENTTWO'
for i in range(3):
data_setup.mark_recipe_running(job.recipesets[0].recipes[i], system=systems[i])
self.server.auth.login_password(self.lc.user.user_name, u'logmein')
expected = {
'SERVERS': ['server.peer-roles.invalid', 'clientone.peer-roles.invalid'],
'CLIENTS': ['clientone.peer-roles.invalid', 'clienttwo.peer-roles.invalid'],
'None': ['server.peer-roles.invalid'],
'CLIENTTWO': ['clienttwo.peer-roles.invalid'],
}
for i in range(3):
self.assertEquals(self.server.recipes.tasks.peer_roles(
job.recipesets[0].recipes[i].tasks[0].id),
expected)
def test_role_fqdns_not_duplicated(self):
with session.begin():
dt = data_setup.create_distro_tree()
lc = data_setup.create_labcontroller()
systems = [
data_setup.create_system(fqdn=u'server.bz951283', lab_controller=lc),
data_setup.create_system(fqdn=u'client.bz951283', lab_controller=lc),
]
job = data_setup.create_job_for_recipes([
data_setup.create_recipe(distro_tree=dt, role=u'SERVERS'),
data_setup.create_recipe(distro_tree=dt, role=u'CLIENTS'),
])
# same roles on the tasks as on the recipes
job.recipesets[0].recipes[0].tasks[0].role = u'SERVERS'
job.recipesets[0].recipes[1].tasks[0].role = u'CLIENTS'
for i in range(2):
data_setup.mark_recipe_running(job.recipesets[0].recipes[i], system=systems[i])
self.server.auth.login_password(self.lc.user.user_name, u'logmein')
expected = {
'SERVERS': ['server.bz951283'],
'CLIENTS': ['client.bz951283'],
}
for i in range(2):
self.assertEquals(self.server.recipes.tasks.peer_roles(
job.recipesets[0].recipes[i].tasks[0].id),
expected)
def setUp(self):
with session.begin():
self.lab_controller = data_setup.create_labcontroller()
self.system_owner = data_setup.create_user()
self.unprivileged_user = data_setup.create_user(password=u'password')
self.system = data_setup.create_system(lab_controller=self.lab_controller,
owner=self.system_owner, status=u'Automated', arch=u'i386')
self.distro_tree = data_setup.create_distro_tree(
lab_controllers=[self.lab_controller])
self.system.provisions[self.distro_tree.arch] = Provision(
arch=self.distro_tree.arch, ks_meta=u'some_ks_meta_var=1',
kernel_options=u'some_kernel_option=1',
kernel_options_post=u'some_kernel_option=2')
self.system.provisions[self.distro_tree.arch]\
.provision_families[self.distro_tree.distro.osversion.osmajor] = \
ProvisionFamily(osmajor=self.distro_tree.distro.osversion.osmajor,
ks_meta=u'some_ks_meta_var=2', kernel_options=u'some_kernel_option=3',
kernel_options_post=u'some_kernel_option=4')
self.system.provisions[self.distro_tree.arch]\
.provision_families[self.distro_tree.distro.osversion.osmajor]\
.provision_family_updates[self.distro_tree.distro.osversion] = \
ProvisionFamilyUpdate(osversion=self.distro_tree.distro.osversion,
ks_meta=u'some_ks_meta_var=3', kernel_options=u'some_kernel_option=5',
kernel_options_post=u'some_kernel_option=6')
self.browser = self.get_browser()
def test_distro_and_system_overrides_recipe(self):
with session.begin():
lc = data_setup.create_labcontroller()
i386_distro = self._create_i386_distro(lc)
system1 = data_setup.create_system(lab_controller=lc, arch=u'x86_64')
system2 = data_setup.create_system(lab_controller=lc, arch=u'i386')
system2.provisions[system2.arch[0]] = Provision(arch=system2.arch[0],
kernel_options_post='usshopper')
recipe = self._create_recipe(system1)
# recipe uses system1 + x86_64 distro. We pass in system2 and i386
# distro, so we should pick up the provision options of system2 + i386
distro_tree_id = i386_distro.trees[0].id
kickstart = self._run_create_kickstart(['--recipe-id', str(recipe.id),
'--system', system2.fqdn,
'--distro-tree-id', str(distro_tree_id),])
# Make sure we are using the tree from --distro-tree-id
self.assertIn('url=http://lab.test-kickstart.example.com/distros/'
'RHEL-6.3/Workstation/i386/os/', kickstart)
self.assertIn('usshopper', kickstart)
# Make sure we are using system2
self.assertIn(system2.fqdn, kickstart)
self.assertNotIn(system1.fqdn, kickstart)
def setUp(self):
self.selenium = self.get_selenium()
self.password = '******'
# create users
self.user_1 = data_setup.create_user(password=self.password)
self.user_2 = data_setup.create_user(password=self.password)
self.user_3 = data_setup.create_user(password=self.password)
# create admin users
self.admin_1 = data_setup.create_user(password=self.password)
self.admin_1.groups.append(Group.by_name(u'admin'))
self.admin_2 = data_setup.create_user(password=self.password)
self.admin_2.groups.append(Group.by_name(u'admin'))
# create systems
self.system_1 = data_setup.create_system(shared=True)
self.system_2 = data_setup.create_system(shared=True)
self.system_3 = data_setup.create_system(shared=False,
owner=self.user_3)
# create group and add users/systems to it
self.group_1 = data_setup.create_group()
self.user_3.groups.append(self.group_1)
self.admin_2.groups.append(self.group_1)
self.system_2.groups.append(self.group_1)
lc = data_setup.create_labcontroller()
self.system_1.lab_controller = lc
self.system_2.lab_controller = lc
self.system_3.lab_controller = lc
self.selenium.start()
def test_can_return_manual_reservation_when_automated(self):
with session.begin():
user = data_setup.create_user(password='******')
system = data_setup.create_system(owner=user, status=SystemStatus.manual)
b = self.browser
login(b, user=user.user_name, password="******")
# Take
b.get(get_server_base() + 'view/%s' % system.fqdn)
b.find_element_by_link_text('Take').click()
b.find_element_by_xpath('//div[contains(@class, "system-quick-usage")]'
'//span[@class="label" and text()="Reserved"]')
# toggle status to Automated
with session.begin():
system.lab_controller = data_setup.create_labcontroller()
system.status = SystemStatus.automated
# Attempt to return
b.get(get_server_base() + 'view/%s' % system.fqdn)
b.find_element_by_link_text('Return').click()
b.find_element_by_xpath('//div[contains(@class, "system-quick-usage")]'
'//span[@class="label" and text()="Idle"]')
def setUp(self):
with session.begin():
self.lab_controller = data_setup.create_labcontroller()
self.lab_controller.user.password = u'logmein'
self.server = self.get_server()
self.server.auth.login_password(self.lab_controller.user.user_name,
u'logmein')
def test_new_power_settings(self):
with session.begin():
lc = data_setup.create_labcontroller()
system = data_setup.create_system(lab_controller=lc,
with_power=False)
b = self.browser
login(b)
self.go_to_system_view(system=system, tab='Power Settings')
tab = b.find_element_by_id('power-settings')
BootstrapSelect(tab.find_element_by_name('power_type'))\
.select_by_visible_text('virsh')
tab.find_element_by_name('power_address').send_keys \
('qemu+ssh:10.10.10.10')
tab.find_element_by_name('power_user').send_keys('root')
tab.find_element_by_name('power_id').send_keys(system.fqdn)
tab.find_element_by_tag_name('form').submit()
# check activity records
power_fields_changed = {'power_type': 'virsh',
'power_address': 'qemu+ssh:10.10.10.1',
'power_user': '******',
'power_id': system.fqdn,
'power_quiescent_period': 5}
with session.begin():
session.refresh(system)
for activity in system.activity:
self.assertEquals(activity.new_value,
power_fields_changed[activity])
def test_broken_system_notification_off(self):
with session.begin():
owner = data_setup.create_user(email_address=u'*****@*****.**',
notify_broken_system=False)
lc = data_setup.create_labcontroller()
system = data_setup.create_system(
fqdn=u'home-two',
owner=owner,
lender=u"Aunty Jane's Dodgy Shop",
location=u'shed out the front',
lab_controller=lc,
vendor=u'Acorn',
arch=u'i386')
system.arch.append(Arch.by_name(u'x86_64'))
data_setup.configure_system_power(system,
power_type=u'drac',
address=u'pdu3.home-one',
power_id=u'42')
with session.begin():
bkr.server.mail.broken_system_notify(system,
reason="It's not a tarp!")
self.assertEqual(len(self.mail_capture.captured_mails), 0)
def test_action_buttons(self):
""" Check that the right action buttons appear in the right circumstances. """
with session.begin():
user = data_setup.create_user(password=u'asdflol')
no_access = data_setup.create_system(shared=False)
lc1 = data_setup.create_labcontroller()
borrowable = data_setup.create_system(lab_controller=lc1)
borrowable.custom_access_policy.add_rule(
SystemPermission.loan_self, user=user)
borrowable_but_loaned = data_setup.create_system()
borrowable_but_loaned.loaned = data_setup.create_user()
borrowable_but_loaned.custom_access_policy.add_rule(
SystemPermission.loan_self, user=user)
borrowed = data_setup.create_system()
borrowed.loaned = user
# "stealable" means loaned to someone else but you have perms to return their loan
stealable = data_setup.create_system()
stealable.loaned = data_setup.create_user()
stealable.custom_access_policy.add_rule(
SystemPermission.loan_any, user=user)
manual = data_setup.create_system(status=SystemStatus.manual, shared=True)
taken = data_setup.create_system(status=SystemStatus.manual, shared=True)
taken.reserve_manually(user=user, service=u'testdata')
login(self.browser, user=user.user_name, password='******')
self.go_to_system_view(no_access)
self.assertEquals(self.action_button_labels(), ['Request Loan'])
self.go_to_system_view(borrowable_but_loaned)
self.assertEquals(self.action_button_labels(), ['Schedule Reservation'])
self.go_to_system_view(borrowable)
self.assertEquals(self.action_button_labels(), ['Borrow'])
self.go_to_system_view(borrowed)
self.assertEquals(self.action_button_labels(), ['Take', 'Return Loan'])
self.go_to_system_view(stealable)
self.assertEquals(self.action_button_labels(), ['Return Loan'])
self.go_to_system_view(manual)
self.assertEquals(self.action_button_labels(), ['Take'])
self.go_to_system_view(taken)
self.assertEquals(self.action_button_labels(), ['Return'])
def setUp(self):
self.lab_controller = data_setup.create_labcontroller()
self.distro_tree = data_setup.create_distro_tree(
osmajor=u'Fedora20',
arch=u'i386',
lab_controllers=[self.lab_controller])
self.usable_system = data_setup.create_system(
arch=u'i386',
owner=User.by_user_name(data_setup.ADMIN_USER),
status=u'Manual',
shared=True)
data_setup.configure_system_power(self.usable_system,
power_type=u'drac',
address=u'nowhere.example.com',
user=u'teh_powz0r',
password=u'onoffonoff',
power_id=u'asdf')
self.usable_system.lab_controller = self.lab_controller
self.usable_system.user = data_setup.create_user(password=u'password')
self.usable_system.provisions[self.distro_tree.arch] = Provision(
arch=self.distro_tree.arch,
kernel_options='ksdevice=eth0 console=ttyS0')
self.server = self.get_server()
def test_filtering_by_lab_controller(self):
with session.begin():
self.distro_tree_x86_64.lab_controller_assocs[:] = [LabControllerDistroTree(
lab_controller=self.lc, url=u'http://whatever')]
other_lc = data_setup.create_labcontroller()
self.distro_tree_i386.lab_controller_assocs[:] = [LabControllerDistroTree(
lab_controller=other_lc, url=u'http://whatever')]
login(self.browser)
b = self.browser
b.get(get_server_base() + 'reserveworkflow/')
Select(b.find_element_by_name('osmajor'))\
.select_by_visible_text(self.distro.osversion.osmajor.osmajor)
Select(b.find_element_by_name('distro')).select_by_visible_text(self.distro.name)
Select(b.find_element_by_name('distro_tree_id')).select_by_visible_text(
'%s Server i386' % self.distro.name)
b.find_element_by_xpath(
'//label[contains(string(.), "Any system from lab:")]'
'/input[@type="radio"]').click()
Select(b.find_element_by_name('lab')).select_by_visible_text(self.lc.fqdn)
b.find_element_by_xpath('//button[text()="Submit job"]').click()
self.assertIn('%s Server i386 is not available on %s'
% (self.distro.name, self.lc.fqdn),
b.find_element_by_class_name('alert-error').text)
def test_distro_overrides_recipe(self):
with session.begin():
lc = data_setup.create_labcontroller()
system1 = data_setup.create_system(lab_controller=lc,
arch=u'x86_64')
i386_distro = self._create_i386_distro(lc)
osmajor = i386_distro.osversion.osmajor
io = OSMajorInstallOptions.lazy_create(osmajor_id=osmajor.id,
arch_id=Arch.by_name('i386').id)
io.ks_meta = 'lang=en_UK.UTF-8'
session.expire(osmajor, ['install_options_by_arch'])
recipe = self._create_recipe(system1)
distro_tree_id = i386_distro.trees[0].id
kickstart = self._run_create_kickstart(['--recipe-id', str(recipe.id),
'--distro-tree-id', str(distro_tree_id),])
# Make sure we are using the tree from --distro-tree-id
self.assertIn('url=http://lab.test-kickstart.example.com/distros/'
'RHEL-6.3/Workstation/i386/os/', kickstart)
self.assertNotIn('url=http://lab.test-kickstart.invalid/distros/'
'RHEL-6.2/Server/x86_64/os/', kickstart)
self.assertIn('lang en_UK.UTF-8', kickstart)
self.assertNotIn('lang en_US.UTF-8', kickstart)
def setUpClass(cls):
with session.begin():
# ensure we have lots of systems
for cores in [1, 2, 3]:
for vendor, model, status, type, reserved_since, user in zip(
[u'Acer', u'Dell', u'HP'],
[u'slow model', u'fast model', u'big model'],
[u'Automated', u'Manual', u'Removed'],
[u'Machine', u'Prototype'], [
datetime.datetime(2012, 10, 31, 23, 0, 0),
datetime.datetime(2015, 1, 1, 6, 0, 0),
datetime.datetime(2020, 1, 6, 10, 0, 0),
], [data_setup.create_user() for _ in range(3)]):
system = data_setup.create_system(vendor=vendor,
model=model,
status=status,
type=type)
system.cpu = Cpu(cores=cores)
system.user = user
system.lab_controller = data_setup.create_labcontroller()
data_setup.create_manual_reservation(system,
reserved_since,
user=user)
def test_labcontroller(self):
# Add
with session.begin():
lc = data_setup.create_labcontroller()
distro_tree = data_setup.create_distro_tree()
b = self.browser
login(b)
go_to_distro_tree_view(b, distro_tree)
b.find_element_by_xpath("//select[@id='lab_controller_id']/"
"option[normalize-space(text())='%s']" % lc.fqdn).click()
b.find_element_by_xpath("//input[@id='url']"). \
send_keys('http://blah.com')
b.find_element_by_name('lab_controller_add_form').submit()
# A trailing '/' is added automatically if it's not present. RHBZ#912242
self.assertEqual(
b.find_element_by_class_name('flash').text,
'Added %s http://blah.com/' % lc.fqdn)
# Delete
delete_and_confirm(b, "//td[preceding-sibling::td/a[@href='http://blah.com/']]/form")
self.assertEqual(
b.find_element_by_class_name('flash').text,
'Deleted %s http://blah.com/' % lc.fqdn)
def setupClass(cls):
with session.begin():
cls.owner_email_address = data_setup.unique_name(
u'*****@*****.**')
cls.system_owner = data_setup.create_user(
email_address=cls.owner_email_address)
cls.system_fqdn = data_setup.unique_name('ncc1701d%s')
cls.system = data_setup.create_system(fqdn=cls.system_fqdn,
owner=cls.system_owner)
cls.lc_name = data_setup.unique_name(u'testing_for_mail%s')
lc = data_setup.create_labcontroller(cls.lc_name)
cls.system.lab_controller = lc
lender = u'amd'
location = u'bne'
vendor = u'intel'
cls.system.lender = lender
cls.system.location = location
cls.system.vendor = vendor
cls.reporter_email_address = data_setup.unique_name(
u'*****@*****.**')
cls.problem_reporter = data_setup.create_user(
password=u'password',
display_name=data_setup.unique_name('Crusher Lady%s'),
email_address=cls.reporter_email_address)
def setUp(self):
with session.begin():
self.user = data_setup.create_user(password=u'password')
self.lc = data_setup.create_labcontroller()
self.distro_tree = data_setup.create_distro_tree()
def setUp(self):
self.browser = self.get_browser()
with session.begin():
self.lc = data_setup.create_labcontroller()
self.distro_tree = data_setup.create_distro_tree(
lab_controllers=[self.lc])
def setUp(self):
with session.begin():
self.system = data_setup.create_system(
lab_controller=data_setup.create_labcontroller())
self.browser = self.get_browser()
def setUp(self):
self.lab_controller = data_setup.create_labcontroller()
def test_cancel_while_scheduling(self):
# This test simulates a user cancelling their job at the same time as
# beakerd is scheduling it. beakerd assigns a system and creates
# a watchdog and sets the recipe status to Waiting, then it's
# overwritten by another transaction setting the status to Cancelled.
with session.begin():
lab_controller = data_setup.create_labcontroller()
system = data_setup.create_system(shared=True,
lab_controller=lab_controller)
distro_tree = data_setup.create_distro_tree(
osmajor=u'Fedora20', lab_controllers=[lab_controller])
job = data_setup.create_job(distro_tree=distro_tree)
job.recipesets[0].recipes[0]._host_requires = (u"""
<hostRequires>
<hostname op="=" value="%s" />
</hostRequires>
""" % system.fqdn)
beakerd.process_new_recipes()
beakerd.update_dirty_jobs()
with session.begin():
job = Job.by_id(job.id)
system = System.query.get(system.id)
self.assertEquals(job.status, TaskStatus.processed)
self.assertEquals(job.recipesets[0].recipes[0].systems, [system])
# Two "concurrent" transactions, in the first one beakerd has
# scheduled the recipe and is about to commit...
class ScheduleThread(Thread):
def __init__(self, **kwargs):
super(ScheduleThread, self).__init__(**kwargs)
self.ready_evt = Event()
self.continue_evt = Event()
def run(self):
session.begin()
recipeset = Job.by_id(job.id).recipesets[0]
assert recipeset.status == TaskStatus.processed
self.ready_evt.set()
self.continue_evt.wait()
try:
beakerd.queue_processed_recipeset(recipeset.id)
assert False, 'should raise'
except StaleTaskStatusException:
pass # expected
session.rollback()
# ... and in the second transaction the user is cancelling the recipe.
class CancelThread(Thread):
def __init__(self, **kwargs):
super(CancelThread, self).__init__(**kwargs)
self.ready_evt = Event()
self.continue_evt = Event()
def run(self):
session.begin()
recipe = Job.by_id(job.id).recipesets[0].recipes[0]
assert not recipe.watchdog
assert not recipe.resource
recipe.recipeset.cancel()
self.ready_evt.set()
self.continue_evt.wait()
session.commit()
sched_thread = ScheduleThread()
cancel_thread = CancelThread()
sched_thread.start()
cancel_thread.start()
sched_thread.ready_evt.wait()
cancel_thread.ready_evt.wait()
sched_thread.continue_evt.set()
cancel_thread.continue_evt.set()
sched_thread.join()
cancel_thread.join()
with session.begin():
session.expire_all()
job.update_status()
self.assertEquals(job.status, TaskStatus.cancelled)
self.assertEquals(job.recipesets[0].recipes[0].watchdog, None)
self.assertEquals(system.open_reservation, None)
def create_lab_controller():
return data_setup.create_labcontroller(fqdn=u'lab.test-kickstart.invalid')
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller(
fqdn='lab.ipxescript.httptest')
def setUp(self):
self.browser = self.get_browser()
with session.begin():
self.lc = data_setup.create_labcontroller()
self.distro_tree = data_setup.create_distro_tree(
osmajor=u'RedHatEnterpriseLinux6', lab_controllers=[self.lc])
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller()
def setUp(self):
self.lc = data_setup.create_labcontroller()
self.removed_lc = data_setup.create_labcontroller()
self.removed_lc.removed = datetime.utcnow()
def setUp(self):
self.lab_controller = data_setup.create_labcontroller()
self.server = self.get_server()
def test_cee_ops_provided_queries(self):
# CEE Ops is a team within Red Hat who relies heavily on Beaker. These
# queries are used by their tooling to integrate with Beaker's
# inventory. The queries are covered here in our test suite so that
# they will know if any Beaker schema changes will affect these
# queries.
cee_users = data_setup.create_group(group_name=u'cee-users')
cee_user = data_setup.create_user(user_name=u'billybob')
cee_users.add_member(cee_user)
# Create a system which has been manually reserved
reserved_system = data_setup.create_system(fqdn=u'gsslab.reserved',
status='Manual')
data_setup.create_manual_reservation(reserved_system,
user=cee_user,
start=datetime.datetime(
2016, 1, 1, 0, 0))
# Create a system which is loaned out
loaned_system = data_setup.create_system(fqdn=u'gsslab.loaned',
status='Manual')
data_setup.create_system_loan(loaned_system,
user=cee_user,
start=datetime.datetime(
2016, 1, 2, 0, 0))
# Create a system which has been provisioned with RHEL7.1
provisioned_system = data_setup.create_system(
fqdn=u'gsslab.provisioned',
status='Automated',
lab_controller=data_setup.create_labcontroller())
recipe = data_setup.create_recipe(distro_name=u'RHEL-7.1',
variant=u'Server')
data_setup.create_job_for_recipes([recipe], owner=cee_user)
data_setup.mark_recipe_complete(recipe, system=provisioned_system)
# Create a non-CEE system which has been provisioned 20 times
noncee_provisioned_system = data_setup.create_system(
fqdn=u'noncee.provisioned',
status='Automated',
lab_controller=data_setup.create_labcontroller())
for _ in range(20):
recipe = data_setup.create_recipe()
data_setup.create_job_for_recipes([recipe], owner=cee_user)
data_setup.mark_recipe_complete(recipe,
system=noncee_provisioned_system)
session.flush()
rows = self.execute_reporting_query('cee/all-systems').fetchall()
self.assertEqual(len(rows), 3)
rows = self.execute_reporting_query('cee/reserved-systems').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'gsslab.reserved')
self.assertEqual(rows[0].start_time,
datetime.datetime(2016, 1, 1, 0, 0))
rows = self.execute_reporting_query('cee/loaned-systems').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'gsslab.loaned')
rows = self.execute_reporting_query(
'cee/loaned-systems-by-date').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'gsslab.loaned')
self.assertEqual(rows[0].loan_date,
datetime.datetime(2016, 1, 2, 0, 0))
rows = self.execute_reporting_query('cee/system-provisions').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'gsslab.provisioned')
self.assertEqual(rows[0].count, 1)
rows = self.execute_reporting_query(
'cee/system-reservations').fetchall()
self.assertEqual(len(rows), 2)
self.assertEqual(rows[0].fqdn, u'gsslab.provisioned')
self.assertEqual(rows[0].count, 1)
self.assertEqual(rows[1].fqdn, u'gsslab.reserved')
self.assertEqual(rows[1].count, 1)
rows = self.execute_reporting_query(
'cee/system-distrotrees').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'gsslab.provisioned')
self.assertEqual(rows[0].operatingsystem, u'RHEL-7.1 Server i386')
rows = self.execute_reporting_query(
'cee/provisions-by-distrotree').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].operatingsystem, u'RHEL-7.1 Server i386')
self.assertEqual(rows[0].count, 1)
rows = self.execute_reporting_query(
'cee/provisions-by-user').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].user_name, u'billybob')
self.assertEqual(rows[0].count, 21)
rows = self.execute_reporting_query(
'cee/non-cee-provisions-by-user').fetchall()
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0].fqdn, u'noncee.provisioned')
self.assertEqual(rows[0].count, 20)
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller()
self.orig_VirtManager = dynamic_virt.VirtManager
dynamic_virt.VirtManager = DummyVirtManager
DummyVirtManager.lab_controller = self.lc
def test_system_reserved_notification_on(self):
with session.begin():
owner = data_setup.create_user(
email_address=u'*****@*****.**')
system = data_setup.create_system(
fqdn=u'funcooker.ge.invalid',
lab_controller=data_setup.create_labcontroller())
distro_tree = data_setup.create_distro_tree(
distro_name=u'MicrowaveOS-20141016.0',
variant=u'ThreeHeats',
arch=u'x86_64')
job = data_setup.create_running_job(
owner=owner,
system=system,
distro_tree=distro_tree,
whiteboard=u'Chain Reaction of Mental Anguish',
recipe_whiteboard=u'Christmas Attack Zone')
recipe = job.recipesets[0].recipes[0]
mail_capture_thread.start_capturing()
with session.begin():
bkr.server.mail.reservesys_notify(job.recipesets[0].recipes[0])
captured_mails = mail_capture_thread.stop_capturing()
self.assertEqual(len(captured_mails), 1)
sender, rcpts, raw_msg = captured_mails[0]
self.assertEqual(rcpts, [owner.email_address])
msg = email.message_from_string(raw_msg)
self.assertEqual(msg['To'], owner.email_address)
self.assertEqual(msg['Subject'],
'[Beaker System Reserved] funcooker.ge.invalid')
self.assertEqual(msg['X-Beaker-Notification'], 'system-reservation')
expected_mail_body = u"""\
** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
This System is reserved by [email protected]
To return this system early, you can click on 'Release System' against this recipe
from the Web UI. Ensure you have your logs off the system before returning to
Beaker.
%(base)srecipes/%(recipeid)s
For ssh, kvm, serial and power control operations please look here:
%(base)sview/funcooker.ge.invalid
For the default root password, see:
%(base)sprefs
Beaker Test information:
HOSTNAME=funcooker.ge.invalid
JOBID=%(jobid)s
RECIPEID=%(recipeid)s
DISTRO=MicrowaveOS-20141016.0 ThreeHeats x86_64
ARCHITECTURE=x86_64
Job Whiteboard: Chain Reaction of Mental Anguish
Recipe Whiteboard: Christmas Attack Zone
** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **""" \
% dict(base=get_server_base(), recipeid=recipe.id, jobid=job.id)
actual_mail_body = msg.get_payload(decode=True)
self.assertEqual(actual_mail_body, expected_mail_body)
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller()
self.lc.user.password = u'logmein'
self.server = self.get_server()
def setup_package():
global lc_fqdn, _daemons_running_externally
conf = get_conf()
if not 'BEAKER_LABCONTROLLER_HOSTNAME' in os.environ:
# Need to start the lab controller daemons ourselves
with session.begin():
user = data_setup.create_user(
user_name=conf.get('USERNAME').decode('utf8'),
password=conf.get('PASSWORD'))
lc = data_setup.create_labcontroller(fqdn=u'localhost', user=user)
processes.extend([
Process('beaker-proxy',
args=[
'python',
'../LabController/src/bkr/labcontroller/main.py', '-c',
config_file, '-f'
],
listen_port=8000,
stop_signal=signal.SIGTERM),
Process('beaker-provision',
args=[
'python',
'../LabController/src/bkr/labcontroller/provision.py',
'-c', config_file, '-f'
],
stop_signal=signal.SIGTERM),
Process('beaker-watchdog',
args=[
'python',
'../LabController/src/bkr/labcontroller/watchdog.py',
'-c', config_file, '-f'
],
stop_signal=signal.SIGTERM),
])
lc_fqdn = u'localhost'
else:
_daemons_running_externally = True
# We have been passed a space seperated list of LCs
lab_controllers = os.environ.get(
'BEAKER_LABCONTROLLER_HOSTNAME').decode('utf8')
lab_controllers_list = lab_controllers.split()
# Just get the last one, it shouldn't matter to us
lab_controller = lab_controllers_list.pop()
# Make sure that the LC is in the DB
data_setup.create_labcontroller(fqdn=lab_controller)
lc_fqdn = lab_controller
# Clear out any existing job logs, so that they are registered correctly
# when first created.
# If we've been passed a remote hostname for the LC, we assume it's been
# freshly provisioned and the dir will already be empty.
shutil.rmtree(conf.get('CACHEPATH'), ignore_errors=True)
try:
for process in processes:
process.start()
except:
for process in processes:
process.stop()
raise
def setUp(self):
self.lc_fqdn = u'lab.domain.com'
with session.begin():
lc = data_setup.create_labcontroller(fqdn=self.lc_fqdn)
def setUp(self):
with session.begin():
self.lc = data_setup.create_labcontroller()
DummyVirtManager.lab_controller = self.lc