def __init__(self, parameters, job_id):
super(LxcProtocol, self).__init__(parameters, job_id)
self.system_timeout = Timeout('system', LAVA_LXC_TIMEOUT)
self.persistence = parameters['protocols'][self.name].get('persist',
False)
if self.persistence:
self.lxc_name = parameters['protocols'][self.name]['name']
else:
self.lxc_name = '-'.join(
[parameters['protocols'][self.name]['name'], str(job_id)])
self.lxc_dist = parameters['protocols'][self.name]['distribution']
self.lxc_release = parameters['protocols'][self.name]['release']
self.lxc_arch = parameters['protocols'][self.name].get('arch', None)
self.lxc_template = parameters['protocols'][self.name].get(
'template', 'download')
self.lxc_mirror = parameters['protocols'][self.name].get('mirror',
None)
self.lxc_security_mirror = parameters['protocols'][self.name].get(
'security_mirror', None)
self.verbose = parameters['protocols'][self.name].get('verbose', False)
self.fastboot_reboot = parameters.get('reboot_to_fastboot', True)
self.custom_lxc_path = False
if LXC_PATH != lxc_path(parameters['dispatcher']):
self.custom_lxc_path = True
self.logger = logging.getLogger('dispatcher')
def setUp(self):
super(TestTimeout, self).setUp()
self.parameters = {
"job_name":
"fakejob",
'timeouts': {
'job': {
'seconds': 3
}
},
"actions": [{
'deploy': {
'namespace': 'common',
'failure_retry': 3
},
'boot': {
'namespace': 'common',
'failure_retry': 4
},
'test': {
'namespace': 'common',
'failure_retry': 5
}
}]
}
self.fakejob = TestTimeout.FakeJob(self.parameters)
# copy of the _timeout function from parser.
if 'timeouts' in self.parameters:
if 'job' in self.parameters['timeouts']:
duration = Timeout.parse(self.parameters['timeouts']['job'])
self.fakejob.timeout = Timeout(self.parameters['job_name'],
duration)
def __init__(self, parameters, job_id):
super(XnbdProtocol, self).__init__(parameters, job_id)
# timeout in utils.constants, default 10000
self.system_timeout = Timeout('system', XNBD_SYSTEM_TIMEOUT)
self.logger = logging.getLogger('dispatcher')
self.parameters = parameters
self.port = None
def __init__(self, parameters, job_id):
self.logger = logging.getLogger("dispatcher")
self.poll_timeout = Timeout(self.name)
self.parameters = None
self.__errors__ = []
self.parameters = parameters
self.configured = False
self.job_id = job_id
def __init__(self):
super().__init__()
self.timeout = Timeout(self.name,
600,
exception=self.timeout_exception)
self.boot_params = None
self.tool_prompts = None
self.tool_flags = None
def test_action_complete(self):
self.assertIsNotNone(self.fakejob.timeout)
seconds = 2
pipeline = TestTimeout.FakePipeline(job=self.fakejob)
action = TestTimeout.SafeAction()
action.timeout = Timeout(action.name, duration=seconds)
pipeline.add_action(action)
self.fakejob.pipeline = pipeline
self.fakejob.device = TestTimeout.FakeDevice()
self.fakejob.run()
def test_check_char(self):
shell = ShellCommand("%s\n" % 'ls',
Timeout('fake', 30),
logger=logging.getLogger())
if shell.exitstatus:
raise JobError("%s command exited %d: %s" %
('ls', shell.exitstatus, shell.readlines()))
connection = ShellSession(self.job, shell)
self.assertFalse(hasattr(shell, 'check_char'))
self.assertTrue(hasattr(connection, 'check_char'))
self.assertIsNotNone(connection.check_char)
def test_multi_deploy(self):
self.assertIsNotNone(self.parsed_data)
job = Job(4212, self.parsed_data, None)
job.timeout = Timeout("Job", Timeout.parse({"minutes": 2}))
pipeline = Pipeline(job=job)
device = TestMultiDeploy.FakeDevice()
self.assertIsNotNone(device)
job.device = device
job.logger = DummyLogger()
job.pipeline = pipeline
counts = {}
for action_data in self.parsed_data["actions"]:
for name in action_data:
counts.setdefault(name, 1)
parameters = action_data[name]
test_deploy = TestMultiDeploy.TestDeploy(
pipeline, parameters, job)
self.assertEqual({}, test_deploy.action.data)
counts[name] += 1
# check that only one action has the example set
self.assertEqual(
["nowhere"],
[
detail["deploy"]["example"]
for detail in self.parsed_data["actions"]
if "example" in detail["deploy"]
],
)
self.assertEqual(
["faked", "valid"],
[
detail["deploy"]["parameters"]
for detail in self.parsed_data["actions"]
if "parameters" in detail["deploy"]
],
)
self.assertIsInstance(pipeline.actions[0],
TestMultiDeploy.TestDeployAction)
self.assertIsInstance(pipeline.actions[1],
TestMultiDeploy.TestDeployAction)
self.assertIsInstance(pipeline.actions[2],
TestMultiDeploy.TestDeployAction)
job.validate()
self.assertEqual([], job.pipeline.errors)
job.run()
self.assertNotEqual(pipeline.actions[0].data,
{"fake-deploy": pipeline.actions[0].parameters})
self.assertEqual(pipeline.actions[1].data,
{"fake-deploy": pipeline.actions[2].parameters})
# check that values from previous DeployAction run actions have been cleared
self.assertEqual(pipeline.actions[2].data,
{"fake-deploy": pipeline.actions[2].parameters})
def test_action_timeout(self):
"""
Testing timeouts does mean that the tests do nothing until the timeout happens,
so the total length of time to run the tests has to increase...
"""
self.assertIsNotNone(self.fakejob.timeout)
seconds = 2
pipeline = TestTimeout.FakePipeline(job=self.fakejob)
action = TestTimeout.FakeAction()
action.timeout = Timeout(action.name, duration=seconds)
pipeline.add_action(action)
self.fakejob.pipeline = pipeline
self.fakejob.device = TestTimeout.FakeDevice()
with self.assertRaises(JobError):
self.fakejob.run()
def __init__(self, parameters, job_id):
super(MultinodeProtocol, self).__init__(parameters, job_id)
self.blocks = 4 * 1024
# how long between polls (in seconds)
self.system_timeout = Timeout('system', LAVA_MULTINODE_SYSTEM_TIMEOUT)
self.settings = None
self.sock = None
self.base_message = None
self.logger = logging.getLogger('dispatcher')
self.delayed_start = False
params = parameters['protocols'][self.name]
if 'request' in params and 'lava-start' == params['request'] and 'expect_role' in params:
if params['expect_role'] != params['role']:
self.delayed_start = True
self.system_timeout.duration = Timeout.parse(params['timeout'])
else:
self.errors = "expect_role must not match the role declaring lava_start"
self.logger.warning(self.errors)
def __init__(self, expect_final=True):
super(BootloaderCommandsAction, self).__init__()
self.params = None
self.timeout = Timeout(self.name, BOOTLOADER_DEFAULT_CMD_TIMEOUT)
self.method = ""
self.expect_final = expect_final
def _timeouts(self, data, job): # pylint: disable=no-self-use
if 'job' in data.get('timeouts', {}):
duration = Timeout.parse(data['timeouts']['job'])
job.timeout = Timeout('job', duration)
def _timeouts(self, data, job): # pylint: disable=no-self-use
if "job" in data.get("timeouts", {}):
duration = Timeout.parse(data["timeouts"]["job"])
job.timeout = Timeout("job", duration)
def _timeouts(self, data, job):
if "job" in data.get("timeouts", {}):
duration = Timeout.parse(data["timeouts"]["job"])
job.timeout = Timeout("job", duration)
def __init__(self):
super(DDAction, self).__init__()
self.timeout = Timeout(self.name, 600)
self.boot_params = None
self.tool_prompts = None
self.tool_flags = None
def _timeouts(self, data, job):
if data.get('timeouts', None) is not None:
if 'job' in data['timeouts']:
duration = Timeout.parse(data['timeouts']['job'])
job.timeout = Timeout(data['job_name'], duration)