Differential D603

Destroy VM when execution is aborted
ClosedPublic
Actions

Authored by mkrizek on Sep 29 2015, 11:25 AM.

Details

Reviewers
lbrabec
kparal
tflink
jskladan
Maniphest Tasks
T408: refine formula syntax from PoC
T592: ctrl+c doesn't stop and destroy the VM
Commits
rLTRNb228cf21dfd8: Destroy VM when execution is aborted
Summary

Also add --no-destroy cli option

Test Plan

Tests amended. Run few tasks to check if vms are (not) being destroyed.

Diff Detail

Repository
rLTRN libtaskotron
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.
mkrizek retitled this revision from to Destroy VM when execution is aborted.Sep 29 2015, 11:25 AM
mkrizek updated this object.
mkrizek edited the test plan for this revision. (Show Details)
mkrizek added reviewers: tflink, kparal, jskladan, lbrabec.
tflink accepted this revision.Sep 30 2015, 6:53 AM

Not sure I understand why the uuid_dir change is grouped in with this one but it makes sense.

Works well for me locally.

This revision is now accepted and ready to land.Sep 30 2015, 6:53 AM
mkrizek added a comment.Sep 30 2015, 7:26 AM
In D603#11425, @tflink wrote:

Not sure I understand why the uuid_dir change is grouped in with this one but it makes sense.

Works well for me locally.

The reason being that if we failed before creating RemoteRunner (e.g. on connecting to the machine), we would get tb (keyerror on 'artifactsdir') on:

# finalization
log.info('Execution finished at: %s. Task artifacts were saved in: %s',
         datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC'),
	​ task_runner.arg_data['artifactsdir'])
kparal requested changes to this revision.Sep 30 2015, 9:07 AM

Please note this interacts heavily with D550 handled by @lbrabec. One of these diffs will need to take the other one into account.

libtaskotron/runner.py
123–124

Your approach here is to stop remote execution in case of keyboard interrupt or a remote error, clean up, and then continue execution as if nothing has happened (it can even return 0 as an exit code). Is there a reason for that?

I would rather do this:

  1. the whole remote execution code should be wrapped in try-finally
  2. in the finally block, there should be the cleanup code (minion teardown)
  3. during teardown, we need to expect that it might not finish successfully (e.g. if there was an error during minion spawning, there might be nothing to tear down). We should definitely log all issues, we might even consider raising those issues (maybe only in cases when there was no issue during remote execution). I don't know the best practices here, would be interesting to find out.
  4. if there was an error during remote execution, don't suppress them, but re-raise them (that will happen automatically if there's no except block). that will ensure that no unnecessary code will get executed afterwards and that we will exit a non-zero status.
  5. if we want to go real fancy, you can wrap the main function, catch the keyboard interrupt signal, and print a pretty message into the console instead of a traceback before exiting with a non-zero status
129

Please get rid of debug here. I see no reason to avoid teardown when running in debug mode. That was a temporary measure before --no-destroy was implemented. Now we have it and don't need to keep the hack around.

424

"do not destroy disposable client at the end of task execution" might be clearer

500–501

In D550 I recommended Lukas to move this line to process_args(). I think it fits there.

This revision now requires changes to proceed.Sep 30 2015, 9:07 AM
tflink added a comment.Sep 30 2015, 2:45 PM
In D603#11436, @kparal wrote:

Please note this interacts heavily with D550 handled by @lbrabec. One of these diffs will need to take the other one into account.

True but that's been stalled for a while and I'm not sure it's worth waiting for unless it picks up momentum again.

mkrizek updated this revision to Diff 1572.Sep 30 2015, 4:17 PM
  • Address issues from the review
tflink accepted this revision.Sep 30 2015, 4:38 PM
tflink added inline comments.
libtaskotron/runner.py
151

trivial nit: "or when --no-destroy"

500–501

shall we handle that in D550, then?

mkrizek added inline comments.Oct 1 2015, 5:50 AM
libtaskotron/runner.py
151

Ah, will fix that before commiting, thanks.

500–502

I moved only this "args['artifactsdir'] = os.path.join(config.get_config().artifactsdir, args['uuid'])" there. Does it make sense to move also the makedirs there? (I think it's fine as it is)

jskladan accepted this revision.Oct 2 2015, 10:15 AM
kparal accepted this revision.Oct 2 2015, 10:55 AM
kparal added inline comments.
libtaskotron/runner.py
123–124

Looks good now, thanks.

500–502

It's fine as it is. You could have even ignored my comment - I got confused by all those uuid changes, but it would be fine to move that line as part of D550. Whatever you prefer.

This revision is now accepted and ready to land.Oct 2 2015, 10:55 AM
Closed by commit rLTRNb228cf21dfd8: Destroy VM when execution is aborted (authored by mkrizek). · Explain WhyOct 2 2015, 12:50 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 1581

View Options

libtaskotron/runner.py

Show All 34 Lines
35 35​
36 36​
37class Runner(): 37​class Runner():
38 '''Runner class that decides whether the task should be run locally or remotely, 38​ '''Runner class that decides whether the task should be run locally or remotely,
39 intializes variables (such as logger and ssh), instantiates Local or Remote Runner 39​ intializes variables (such as logger and ssh), instantiates Local or Remote Runner
40 and runs the task. 40​ and runs the task.
41 ''' 41​ '''
42 42​
43 def __init__(self, task_data, arg_data, uuid_dir): 43​ def __init__(self, task_data, arg_data):
44 '''Create a new instance. 44​ '''Create a new instance.
45 45​
46 :param dict task_data: data loaded from task formula 46​ :param dict task_data: data loaded from task formula
47 :param dict arg_data: data from command line arguments 47​ :param dict arg_data: data from command line arguments
48 :param str uuid_dir: path to artifacts directory ​
49 ''' 48​ '''
50 49​
51 self.task_data = task_data 50​ self.task_data = task_data
52 self.arg_data = arg_data 51​ self.arg_data = arg_data
53 self.uuid_dir = uuid_dir ​
54 52​
55 #: run locally or remotely 53​ #: run locally or remotely
56 self.run_remotely = False 54​ self.run_remotely = False
57 #: when running remotely, run directly over ssh, instead of using libvirt 55​ #: when running remotely, run directly over ssh, instead of using libvirt
58 self.direct_ssh = False 56​ self.direct_ssh = False
59 self.user = self.machine = self.port = None 57​ self.user = self.machine = self.port = None
60 self.ssh_privkey = arg_data['ssh_privkey'] or config.get_config().ssh_privkey 58​ self.ssh_privkey = arg_data['ssh_privkey'] or config.get_config().ssh_privkey
61 #: int exitcode set by exitcode directive. If executed locally, it is None if exitcode 59​ #: int exitcode set by exitcode directive. If executed locally, it is None if exitcode
Show All 38 Lines96 def run(self):
100 if self.run_remotely: 98​ if self.run_remotely:
101 self._run_remotely() 99​ self._run_remotely()
102 else: 100​ else:
103 self._run_locally() 101​ self._run_locally()
104 102​
105 def _run_locally(self): 103​ def _run_locally(self):
106 '''Init environment, instantiate LocalRunner and run it.''' 104​ '''Init environment, instantiate LocalRunner and run it.'''
107 105​
108 filelog_path = os.path.join(self.uuid_dir, 'taskotron.log') 106​ filelog_path = os.path.join(self.arg_data['artifactsdir'], 'taskotron.log')
109 logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True) 107​ logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
110 108​
111 task_runner = LocalRunner(self.task_data, self.arg_data) 109​ task_runner = LocalRunner(self.task_data, self.arg_data)
112 task_runner.prepare_task() 110​ task_runner.prepare_task()
113 task_runner.run() 111​ task_runner.run()
114 self.exitcode = task_runner.exitcode 112​ self.exitcode = task_runner.exitcode
115 113​
116 def _run_remotely(self): 114​ def _run_remotely(self):
117 '''Init environment, instantiate RemoteRunner and run it.''' 115​ '''Init environment, instantiate RemoteRunner and run it.'''
118 116​
119 filelog_path = os.path.join(self.uuid_dir, 'taskotron-initiator.log') 117​ filelog_path = os.path.join(self.arg_data['artifactsdir'], 'taskotron-initiator.log')
120 logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True) 118​ logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
121 119​
122 stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log') 120​ stdio_filename = os.path.join(self.arg_data['artifactsdir'], 'taskotron-stdio.log')
123 121​
124 if self.direct_ssh: 122​ try:
125 log.info("Running task over SSH on machine '%s'...", self.machine) 123​ if self.direct_ssh:
126 else: 124​ log.info("Running task over SSH on machine '%s'...", self.machine)
kparalUnsubmitted
Not Done

Your approach here is to stop remote execution in case of keyboard interrupt or a remote error, clean up, and then continue execution as if nothing has happened (it can even return 0 as an exit code). Is there a reason for that?

I would rather do this:

  1. the whole remote execution code should be wrapped in try-finally
  2. in the finally block, there should be the cleanup code (minion teardown)
  3. during teardown, we need to expect that it might not finish successfully (e.g. if there was an error during minion spawning, there might be nothing to tear down). We should definitely log all issues, we might even consider raising those issues (maybe only in cases when there was no issue during remote execution). I don't know the best practices here, would be interesting to find out.
  4. if there was an error during remote execution, don't suppress them, but re-raise them (that will happen automatically if there's no except block). that will ensure that no unnecessary code will get executed afterwards and that we will exit a non-zero status.
  5. if we want to go real fancy, you can wrap the main function, catch the keyboard interrupt signal, and print a pretty message into the console instead of a traceback before exiting with a non-zero status
kparalUnsubmitted
Not Done

Looks good now, thanks.

127 log.info("Running task on a disposable client using libvirt...") 125​ else:
128 126​ log.info("Running task on a disposable client using libvirt...")
129 log.info("Creating VM for task") ​
130 task_vm = vm.TestCloudMachine(self.arg_data['uuid']) ​
131 task_vm.prepare() ​
132 self.machine = task_vm.ipaddr ​
133 self.port = 22 ​
134 self.user = task_vm.username ​
135 ​
136 log.info("Running Task over SSH on machine %s" % task_vm.instancename) ​
137 ​
138 task_vm.wait_for_port(self.port) ​
139 ​
140 with remote_exec.RemoteExec(self.machine, self.port, self.user, ​
141 self.ssh_privkey, stdio_filename) as ssh: ​
142 task_runner = RemoteRunner(ssh, self.task_data, self.arg_data) ​
143 try: ​
144 task_runner.prepare_task() ​
145 task_runner.run() ​
146 except exc.TaskotronRemoteError, e: ​
147 log.exception(e) ​
148 ​
149 task_runner.get_output() ​
150 self.exitcode = task_runner.exitcode ​
151 ​
152 if self.direct_ssh: ​
153 # don't try to run teardown in the direct ssh case ​
154 return ​
155 127​
156 # only teardown the VM when not in debug mode 128​ log.info("Creating VM for task")
157 # FIXME: implement --no-destroy (per T408) 129​ task_vm = vm.TestCloudMachine(self.arg_data['uuid'])
kparalUnsubmitted
Not Done

Please get rid of debug here. I see no reason to avoid teardown when running in debug mode. That was a temporary measure before --no-destroy was implemented. Now we have it and don't need to keep the hack around.

158 if self.arg_data['debug']: 130​ task_vm.prepare()
159 log.info("debug mode was set from command line, not tearing VM " 131​ self.machine = task_vm.ipaddr
160 "down for task {}".format(self.arg_data['uuid'])) 132​ self.port = 22
161 else: 133​ self.user = task_vm.username
162 try: 134​
163 task_vm.teardown() 135​ log.info("Running Task over SSH on machine %s" % task_vm.instancename)
164 except exc.TaskotronRemoteError, e: 136​
165 log.error("Hit problem during teardown of VM for " 137​ task_vm.wait_for_port(self.port)
166 "task {}".format(self.arg_data['uuid'])) 138​
167 log.error(e) 139​ with remote_exec.RemoteExec(self.machine, self.port, self.user,
140​ self.ssh_privkey, stdio_filename) as ssh:
141​ task_runner = RemoteRunner(ssh, self.task_data, self.arg_data)
142​ try:
143​ task_runner.prepare_task()
144​ task_runner.run()
145​ except exc.TaskotronRemoteError, e:
146​ log.exception(e)
147​
148​ task_runner.get_output()
149​ self.exitcode = task_runner.exitcode
150​ finally:
151​ # don't run teardown in the direct ssh case or when --no-destroy
tflinkUnsubmitted
Not Done

trivial nit: "or when --no-destroy"

mkrizekAuthorUnsubmitted
Not Done

Ah, will fix that before commiting, thanks.

152​ if self.arg_data['no_destroy']:
153​ log.info("--no-destroy mode was set from command line, not tearing VM "
154​ "down for task %s" % self.arg_data['uuid'])
155​ elif not self.direct_ssh:
156​ try:
157​ task_vm.teardown()
158​ except exc.TaskotronRemoteError, e:
159​ log.error("Hit problem during teardown of VM for task %s" %
160​ self.arg_data['uuid'])
161​ log.exception(e)
168 162​
169 163​
170class LocalRunner(object): 164​class LocalRunner(object):
171 def __init__(self, task_data, arg_data, workdir=None): 165​ def __init__(self, task_data, arg_data, workdir=None):
172 self.task_data = task_data 166​ self.task_data = task_data
173 self.arg_data = arg_data 167​ self.arg_data = arg_data
174 self.working_data = {} 168​ self.working_data = {}
175 self.directives = {} 169​ self.directives = {}
176 self.workdir = workdir 170​ self.workdir = workdir
177 #: int exitcode set by exitcode directive, is None if exitcode directive was not used 171​ #: int exitcode set by exitcode directive, is None if exitcode directive was not used
178 self.exitcode = None 172​ self.exitcode = None
179 173​
180 def run(self): 174​ def run(self):
181 self._validate_input() 175​ self._validate_input()
182 176​
183 if not self.workdir: # create temporary workdir if needed 177​ if not self.workdir: # create temporary workdir if needed
184 self.workdir = tempfile.mkdtemp(prefix="task-", 178​ self.workdir = tempfile.mkdtemp(prefix="task-",
185 dir=config.get_config().tmpdir) 179​ dir=config.get_config().tmpdir)
186 log.debug("Current workdir: %s", self.workdir) 180​ log.debug("Current workdir: %s", self.workdir)
187 self.arg_data['workdir'] = self.workdir 181​ self.arg_data['workdir'] = self.workdir
188 self.arg_data['checkname'] = self.task_data['name'] 182​ self.arg_data['checkname'] = self.task_data['name']
189 self.arg_data['artifactsdir'] = os.path.join(config.get_config().artifactsdir, ​
190 self.arg_data['uuid']) ​
191 183​
192 # override variable values 184​ # override variable values
193 for var, val in self.arg_data['override']: 185​ for var, val in self.arg_data['override']:
194 log.debug("Overriding variable %s, new value: %s", var, val) 186​ log.debug("Overriding variable %s, new value: %s", var, val)
195 self.arg_data[var] = eval(val, {}, {}) 187​ self.arg_data[var] = eval(val, {}, {})
196 188​
197 self.do_actions() 189​ self.do_actions()
198 190​
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Line(s)231 def do_single_action(self, action):
249 log.debug("Executing directive: %s", directive_name) 241​ log.debug("Executing directive: %s", directive_name)
250 self._load_directive(directive_name) 242​ self._load_directive(directive_name)
251 243​
252 directive_object = self.directives[directive_name] 244​ directive_object = self.directives[directive_name]
253 directive_classname = directive_object.directive_class 245​ directive_classname = directive_object.directive_class
254 246​
255 directive_callable = getattr(directive_object, directive_classname)() 247​ directive_callable = getattr(directive_object, directive_classname)()
256 248​
257 output = directive_callable.process(rendered_action[directive_name], 249​ output = directive_callable.process(rendered_action[directive_name], self.arg_data)
258 self.arg_data) ​
259 250​
260 if 'export' in action: 251​ if 'export' in action:
261 self.working_data[action['export']] = output 252​ self.working_data[action['export']] = output
262 log.debug("Variable ${%s} was exported with value:\n%s" % 253​ log.debug("Variable ${%s} was exported with value:\n%s" % (action['export'], output))
263 (action['export'], output)) ​
264 254​
265 # unable to use isinstance() due to dynamically loaded directives 255​ # unable to use isinstance() due to dynamically loaded directives
266 if directive_classname == exitcode_directive.directive_class: 256​ if directive_classname == exitcode_directive.directive_class:
267 # set exitcode if was None or overwrite previous SUCCESS with FAILURE (not vice versa) 257​ # set exitcode if was None or overwrite previous SUCCESS with FAILURE (not vice versa)
268 if not self.exitcode or output != exitcode_directive.SUCCESS: 258​ if not self.exitcode or output != exitcode_directive.SUCCESS:
269 log.info("Setting exitcode to %s" % output) 259​ log.info("Setting exitcode to %s" % output)
270 self.exitcode = output 260​ self.exitcode = output
271 261​
272 def do_actions(self): 262​ def do_actions(self):
273 '''Sequentially run all actions for a task. An 'action' is a single step 263​ '''Sequentially run all actions for a task. An 'action' is a single step
274 under the ``actions:`` key. An example action looks like:: 264​ under the ``actions:`` key. An example action looks like::
275 265​
276 - name: download rpms from koji 266​ - name: download rpms from koji
277 koji: 267​ koji:
278 action: download 268​ action: download
279 koji_build: $koji_build 269​ koji_build: $koji_build
280 arch: $arch 270​ arch: $arch
281 ''' 271​ '''
282 if 'actions' not in self.task_data or not self.task_data['actions']: 272​ if 'actions' not in self.task_data or not self.task_data['actions']:
283 raise exc.TaskotronYamlError("At least one task should be specified" 273​ raise exc.TaskotronYamlError("At least one task should be specified in input formula")
284 " in input formula") ​
285 274​
286 for action in self.task_data['actions']: 275​ for action in self.task_data['actions']:
287 self.do_single_action(action) 276​ self.do_single_action(action)
288 277​
289 def _validate_input(self): 278​ def _validate_input(self):
290 if 'input' not in self.task_data: 279​ if 'input' not in self.task_data:
291 return 280​ return
292 281​
Show All 39 Lines320class RemoteRunner(object):
332 def __init__(self, ssh, task_data, arg_data): 321​ def __init__(self, ssh, task_data, arg_data):
333 self.ssh = ssh 322​ self.ssh = ssh
334 self.task_data = task_data 323​ self.task_data = task_data
335 self.arg_data = arg_data 324​ self.arg_data = arg_data
336 self.taskdir = config.get_config().client_taskdir 325​ self.taskdir = config.get_config().client_taskdir
337 #: int exitcode set by exitcode directive. It is always set to value returned by 326​ #: int exitcode set by exitcode directive. It is always set to value returned by
338 #: self.ssh.cmd() in the run() method. 327​ #: self.ssh.cmd() in the run() method.
339 self.exitcode = None 328​ self.exitcode = None
340 self.arg_data['artifactsdir'] = os.path.join(config.get_config().artifactsdir, ​
341 self.arg_data['uuid']) ​
342 329​
343 def prepare_task(self): 330​ def prepare_task(self):
344 # FIXME remove this once the vm code is done 331​ # FIXME remove this once the vm code is done
345 self.ssh.cmd('curl -o /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo ' 332​ self.ssh.cmd('curl -o /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo '
346 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/' 333​ 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/'
347 'repo/fedora-21/tflink-taskotron-fedora-21.repo') 334​ 'repo/fedora-21/tflink-taskotron-fedora-21.repo')
348 self.ssh.cmd('curl -o /etc/yum.repos.d/tflink-taskotron-disposable-fedora-f21.repo ' 335​ self.ssh.cmd('curl -o /etc/yum.repos.d/tflink-taskotron-disposable-fedora-f21.repo '
349 'https://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron-disposable/' 336​ 'https://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron-disposable/'
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Line(s)412 help="make the task run locally on this very machine (the default "
428 "package dependencies, destructive tasks allowed, etc).") 415​ "package dependencies, destructive tasks allowed, etc).")
429 parser.add_argument('--libvirt', action='store_true', 416​ parser.add_argument('--libvirt', action='store_true',
430 help="make the task run remotely in a disposable client spawned using " 417​ help="make the task run remotely in a disposable client spawned using "
431 "libvirt (the default behavior for production profile).") 418​ "libvirt (the default behavior for production profile).")
432 parser.add_argument("--ssh", metavar='user@machine[:port]', 419​ parser.add_argument("--ssh", metavar='user@machine[:port]',
433 help="make the task run on a remote machine over ssh") 420​ help="make the task run on a remote machine over ssh")
434 parser.add_argument("--ssh-privkey", metavar="</path/to/private.key>", 421​ parser.add_argument("--ssh-privkey", metavar="</path/to/private.key>",
435 help="path to private key for remote connections over ssh") 422​ help="path to private key for remote connections over ssh")
423​ parser.add_argument("--no-destroy", action="store_true",
424​ help="do not destroy disposable client at the end of task execution")
kparalUnsubmitted
Not Done

"do not destroy disposable client at the end of task execution" might be clearer

436 425​
437 return parser 426​ return parser
438 427​
439 428​
440def check_args(parser, args): 429​def check_args(parser, args):
441 """ Check if passed args doesn't have conflicts and have proper format. In case of error, this 430​ """ Check if passed args doesn't have conflicts and have proper format. In case of error, this
442 function prints error message and exits the program. 431​ function prints error message and exits the program.
443 432​
Show All 30 Lines445def process_args(args):
474 # still list at the end of process_args() - for better testability 463​ # still list at the end of process_args() - for better testability
475 override = [] 464​ override = []
476 for var in args['override']: 465​ for var in args['override']:
477 name = var.split('=')[0] 466​ name = var.split('=')[0]
478 value = var.split('=')[1] 467​ value = var.split('=')[1]
479 override.append((name, value)) 468​ override.append((name, value))
480 args['override'] = override 469​ args['override'] = override
481 470​
471​ args['artifactsdir'] = os.path.join(config.get_config().artifactsdir, args['uuid'])
472​
482 return args 473​ return args
483 474​
484 475​
485def main(): 476​def main():
486 # Preliminary initialization of logging, so all messages before regular 477​ # Preliminary initialization of logging, so all messages before regular
487 # initialization can be logged to stream. 478​ # initialization can be logged to stream.
488 logger.init_prior_config() 479​ logger.init_prior_config()
489 480​
Show All 11 Lines
501 492​
502 arg_data = process_args(vars(args)) 493​ arg_data = process_args(vars(args))
503 arg_data['taskfile'] = args.task[0] 494​ arg_data['taskfile'] = args.task[0]
504 495​
505 # initialize logging 496​ # initialize logging
506 level_stream = logging.DEBUG if args.debug else None 497​ level_stream = logging.DEBUG if args.debug else None
507 logger.init(level_stream=level_stream) 498​ logger.init(level_stream=level_stream)
508 499​
509 # create dir for artifacts 500​ # create dir for artifacts
510 uuid_dir = os.path.join(config.get_config().artifactsdir, arg_data['uuid']) ​
511 try: 501​ try:
kparalUnsubmitted
Not Done

In D550 I recommended Lukas to move this line to process_args(). I think it fits there.

tflinkUnsubmitted
Not Done

shall we handle that in D550, then?

512 file_utils.makedirs(uuid_dir) 502​ file_utils.makedirs(arg_data['artifactsdir'])
mkrizekAuthorUnsubmitted
Not Done

I moved only this "args['artifactsdir'] = os.path.join(config.get_config().artifactsdir, args['uuid'])" there. Does it make sense to move also the makedirs there? (I think it's fine as it is)

kparalUnsubmitted
Not Done

It's fine as it is. You could have even ignored my comment - I got confused by all those uuid changes, but it would be fine to move that line as part of D550. Whatever you prefer.

513 log.info("Task artifacts will be saved in: %s", uuid_dir) 503​ log.info("Task artifacts will be saved in: %s", arg_data['artifactsdir'])
514 except OSError: 504​ except OSError:
515 log.error("Can't create artifacts directory %s", uuid_dir) 505​ log.error("Can't create artifacts directory %s", arg_data['artifactsdir'])
516 raise 506​ raise
517 507​
518 # parse task formula 508​ # parse task formula
519 task_data = taskformula.parse_yaml_from_file(arg_data['taskfile']) 509​ task_data = taskformula.parse_yaml_from_file(arg_data['taskfile'])
520 if not task_data: 510​ if not task_data:
521 raise exc.TaskotronYamlError('Input file should not be empty') 511​ raise exc.TaskotronYamlError('Input file should not be empty')
522 512​
523 # run the task, locally or remotely 513​ # run the task, locally or remotely
524 task_runner = Runner(task_data, arg_data, uuid_dir) 514​ task_runner = Runner(task_data, arg_data)
525 task_runner.run() 515​ task_runner.run()
526 516​
527 # finalization 517​ # finalization
528 log.info('Execution finished at: %s. Task artifacts were saved in: %s', 518​ log.info('Execution finished at: %s. Task artifacts were saved in: %s',
529 datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC'), 519​ datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC'),
530 task_runner.arg_data['artifactsdir']) 520​ task_runner.arg_data['artifactsdir'])
531 521​
532 if task_runner.exitcode == exitcode_directive.FAILURE: 522​ if task_runner.exitcode == exitcode_directive.FAILURE:
533 log.info("Exiting with exit status %d (this behavior was requested by exitcode directive)" 523​ log.info("Exiting with exit status %d (this behavior was requested by exitcode directive)"
534 % task_runner.exitcode) 524​ % task_runner.exitcode)
535 sys.exit(task_runner.exitcode) 525​ sys.exit(task_runner.exitcode)
536 526​
537 # exitcode with value exitcode_directive.FAILURE *should* be set only by exitcode directive 527​ # exitcode with value exitcode_directive.FAILURE *should* be set only by exitcode directive
538 assert task_runner.exitcode in [0, None] 528​ assert task_runner.exitcode in [0, None]
View Options

testing/test_exitcode_directive.py

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Line(s)
70 70​
71 71​
72@pytest.mark.usefixtures("setup") 72​@pytest.mark.usefixtures("setup")
73class TestRunnerExitcode(object): 73​class TestRunnerExitcode(object):
74 74​
75 @pytest.fixture 75​ @pytest.fixture
76 def setup(self): 76​ def setup(self):
77 task_data = {} 77​ task_data = {}
78 arg_data = {'local': None, 'libvirt': None, 'ssh': None, 'ssh_privkey': None} 78​ arg_data = {'local': None,
79 uuid = "" 79​ 'libvirt': None,
80 self.test_runner = runner.Runner(task_data, arg_data, uuid) 80​ 'ssh': None,
81​ 'ssh_privkey': None,
82​ 'no_destroy': None}
83​ arg_data['artifactsdir'] = '/dir'
84​
85​ self.test_runner = runner.Runner(task_data, arg_data)
81 self.stub_runner = Dingus() 86​ self.stub_runner = Dingus()
82 self.stub_runner.exitcode = exitcode_directive.FAILURE 87​ self.stub_runner.exitcode = exitcode_directive.FAILURE
83 88​
84 def test_has_exitcode(self): 89​ def test_has_exitcode(self):
85 assert hasattr(self.test_runner, 'exitcode') 90​ assert hasattr(self.test_runner, 'exitcode')
86 91​
87 def test_local_propagate(self, monkeypatch): 92​ def test_local_propagate(self, monkeypatch):
88 stub_local = Dingus() 93​ stub_local = Dingus()
Show All 14 Lines
View Options

testing/test_runner.py

Show First 20 Lines • Show All 394 Lines • ▼ Show 20 Line(s)384 def test_runner_render_multi_variable(self):
395 test_runner.working_data[ref_var2name] = ref_var2 395​ test_runner.working_data[ref_var2name] = ref_var2
396 396​
397 test_rendered_action = test_runner._render_action(ref_action) 397​ test_rendered_action = test_runner._render_action(ref_action)
398 398​
399 assert (test_rendered_action['dummy']['msg'] == '--foo %s --bar %s' % 399​ assert (test_rendered_action['dummy']['msg'] == '--foo %s --bar %s' %
400 (ref_var1, ref_var2)) 400​ (ref_var1, ref_var2))
401 401​
402 402​
403​@pytest.mark.usefixtures('setup')
403class TestLocalRunnerProcessArgs(): 404​class TestLocalRunnerProcessArgs():
404 405​
406​ @pytest.fixture
407​ def setup(self, monkeypatch):
408​ self.ref_uuid = '20150930_153933_359680'
409​ self.ref_artifactsdir = '/dir/'
410​ self.stub_config = Dingus()
411​ self.stub_get_config = Dingus()
412​
413​ self.stub_get_config.return_value = self.stub_config
414​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
415​ self.stub_config.artifactsdir = self.ref_artifactsdir
416​
405 def test_process_args_koji_build(self): 417​ def test_process_args_koji_build(self):
406 ref_input = { 'arch': ['x86_64'], 418​ ref_input = { 'arch': ['x86_64'],
407 'item': 'foo-1.2-3.fc99', 419​ 'item': 'foo-1.2-3.fc99',
408 'type': 'koji_build', 420​ 'type': 'koji_build',
409 'task': 'sometask.yml', 421​ 'task': 'sometask.yml',
410 'override': []} 422​ 'override': [],
423​ 'uuid': self.ref_uuid}
411 424​
412 ref_args = copy.deepcopy(ref_input) 425​ ref_args = copy.deepcopy(ref_input)
413 ref_args['koji_build'] = 'foo-1.2-3.fc99' 426​ ref_args['koji_build'] = 'foo-1.2-3.fc99'
427​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
414 428​
415 test_args = runner.process_args(ref_input) 429​ test_args = runner.process_args(ref_input)
416 430​
417 assert test_args == ref_args 431​ assert test_args == ref_args
418 432​
419 def test_process_args_bodhi_id(self): 433​ def test_process_args_bodhi_id(self):
420 ref_input = { 'arch': ['x86_64'], 434​ ref_input = { 'arch': ['x86_64'],
421 'item': 'foo-1.2-3.fc99', 435​ 'item': 'foo-1.2-3.fc99',
422 'type': 'bodhi_id', 436​ 'type': 'bodhi_id',
423 'task': 'sometask.yml', 437​ 'task': 'sometask.yml',
424 'override': []} 438​ 'override': [],
439​ 'uuid': self.ref_uuid}
425 440​
426 ref_args = copy.deepcopy(ref_input) 441​ ref_args = copy.deepcopy(ref_input)
427 ref_args['bodhi_id'] = 'foo-1.2-3.fc99' 442​ ref_args['bodhi_id'] = 'foo-1.2-3.fc99'
443​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
428 444​
429 test_args = runner.process_args(ref_input) 445​ test_args = runner.process_args(ref_input)
430 446​
431 assert test_args == ref_args 447​ assert test_args == ref_args
432 448​
433 def test_process_args_koji_tag(self): 449​ def test_process_args_koji_tag(self):
434 ref_input = { 'arch': ['x86_64'], 450​ ref_input = { 'arch': ['x86_64'],
435 'item': 'dist-fc99-updates', 451​ 'item': 'dist-fc99-updates',
436 'type': 'koji_tag', 452​ 'type': 'koji_tag',
437 'task': 'sometask.yml', 453​ 'task': 'sometask.yml',
438 'override': []} 454​ 'override': [],
455​ 'uuid': self.ref_uuid}
439 456​
440 ref_args = copy.deepcopy(ref_input) 457​ ref_args = copy.deepcopy(ref_input)
441 ref_args['koji_tag'] = 'dist-fc99-updates' 458​ ref_args['koji_tag'] = 'dist-fc99-updates'
459​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
442 460​
443 test_args = runner.process_args(ref_input) 461​ test_args = runner.process_args(ref_input)
444 462​
445 assert test_args == ref_args 463​ assert test_args == ref_args
446 464​
447 def test_process_args_compose(self): 465​ def test_process_args_compose(self):
448 ref_input = { 'arch': [''], 466​ ref_input = { 'arch': [''],
449 'item': 'rawhide', 467​ 'item': 'rawhide',
450 'type': 'compose', 468​ 'type': 'compose',
451 'task': 'sometask.yml', 469​ 'task': 'sometask.yml',
452 'override': []} 470​ 'override': [],
471​ 'uuid': self.ref_uuid}
453 472​
454 ref_args = copy.deepcopy(ref_input) 473​ ref_args = copy.deepcopy(ref_input)
455 ref_args['compose'] = 'rawhide' 474​ ref_args['compose'] = 'rawhide'
475​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
456 476​
457 test_args = runner.process_args(ref_input) 477​ test_args = runner.process_args(ref_input)
458 478​
459 assert test_args == ref_args 479​ assert test_args == ref_args
460 480​
461 def test_process_args_koji_tag_multiple_arches(self): 481​ def test_process_args_koji_tag_multiple_arches(self):
462 ref_input = { 'arch': ['x86_64', 'i386', 'noarch'], 482​ ref_input = { 'arch': ['x86_64', 'i386', 'noarch'],
463 'item': 'dist-fc99-updates', 483​ 'item': 'dist-fc99-updates',
464 'type': 'koji_tag', 484​ 'type': 'koji_tag',
465 'task': 'sometask.yml', 485​ 'task': 'sometask.yml',
466 'override': []} 486​ 'override': [],
487​ 'uuid': self.ref_uuid}
467 488​
468 ref_args = copy.deepcopy(ref_input) 489​ ref_args = copy.deepcopy(ref_input)
469 ref_args['koji_tag'] = 'dist-fc99-updates' 490​ ref_args['koji_tag'] = 'dist-fc99-updates'
491​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
470 492​
471 test_args = runner.process_args(ref_input) 493​ test_args = runner.process_args(ref_input)
472 494​
473 assert test_args == ref_args 495​ assert test_args == ref_args
474 496​
475 def test_process_args_no_arch(self): 497​ def test_process_args_no_arch(self):
476 ref_input = { 'type': 'invalid', 498​ ref_input = { 'type': 'invalid',
477 'arch': None, 499​ 'arch': None,
478 'override': []} 500​ 'override': [],
501​ 'uuid': self.ref_uuid}
479 ref_args = copy.deepcopy(ref_input) 502​ ref_args = copy.deepcopy(ref_input)
480 ref_args['arch'] = ['noarch'] 503​ ref_args['arch'] = ['noarch']
504​ ref_args['artifactsdir'] = self.ref_artifactsdir+self.ref_uuid
481 505​
482 test_args = runner.process_args(ref_input) 506​ test_args = runner.process_args(ref_input)
483 assert test_args == ref_args 507​ assert test_args == ref_args
484 508​
485 509​
486class TestLocalRunnerCheckOverride(): 510​class TestLocalRunnerCheckOverride():
487 511​
488 def test_override_existing(self): 512​ def test_override_existing(self):
Show All 39 Lines547 def setup(self, monkeypatch):
528 552​
529 self.stub_get_config.return_value = self.stub_config 553​ self.stub_get_config.return_value = self.stub_config
530 monkeypatch.setattr(rpm_utils, 'install', self.install_stub) 554​ monkeypatch.setattr(rpm_utils, 'install', self.install_stub)
531 monkeypatch.setattr(rpm_utils, 'is_installed', self.is_installed_stub) 555​ monkeypatch.setattr(rpm_utils, 'is_installed', self.is_installed_stub)
532 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 556​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
533 557​
534 self.test_runner = runner.LocalRunner({}, {'local': False, 'ssh': None}) 558​ self.test_runner = runner.LocalRunner({}, {'local': False, 'ssh': None})
535 559​
536 def test_devel_profile_installed(self, monkeypatch): 560​ def test_devel_profile_installed(self):
537 self.is_installed_stub.return_value = True 561​ self.is_installed_stub.return_value = True
538 self.stub_config.profile = 'devel' 562​ self.stub_config.profile = 'devel'
539 563​
540 self.test_runner.prepare_task() 564​ self.test_runner.prepare_task()
541 565​
542 assert len(self.install_stub.calls()) == 0 and len(self.is_installed_stub.calls()) == 1 566​ assert len(self.install_stub.calls()) == 0 and len(self.is_installed_stub.calls()) == 1
543 567​
544 def test_devel_profile_not_installed(self, monkeypatch): 568​ def test_devel_profile_not_installed(self):
545 self.is_installed_stub.return_value = False 569​ self.is_installed_stub.return_value = False
546 self.stub_config.profile = 'devel' 570​ self.stub_config.profile = 'devel'
547 571​
548 with pytest.raises(exc.TaskotronError): 572​ with pytest.raises(exc.TaskotronError):
549 self.test_runner.prepare_task() 573​ self.test_runner.prepare_task()
550 574​
551 assert len(self.install_stub.calls()) == 0 and len(self.is_installed_stub.calls()) == 1 575​ assert len(self.install_stub.calls()) == 0 and len(self.is_installed_stub.calls()) == 1
552 576​
553 def test_prod_profile(self, monkeypatch): 577​ def test_prod_profile(self):
554 self.is_installed_stub.return_value = True 578​ self.is_installed_stub.return_value = True
555 self.stub_config.profile = 'production' 579​ self.stub_config.profile = 'production'
556 580​
557 self.test_runner.prepare_task() 581​ self.test_runner.prepare_task()
558 582​
559 assert len(self.install_stub.calls()) == 1 and len(self.is_installed_stub.calls()) == 0 583​ assert len(self.install_stub.calls()) == 1 and len(self.is_installed_stub.calls()) == 0
560 584​
561 585​
562@pytest.mark.usefixtures('setup') 586​@pytest.mark.usefixtures('setup')
563class TestRunner(): 587​class TestRunner():
564 588​
565 @pytest.fixture 589​ @pytest.fixture
566 def setup(self, monkeypatch): 590​ def setup(self, monkeypatch):
567 self.stub_local = Dingus() 591​ self.stub_local = Dingus()
568 self.stub_remote = Dingus() 592​ self.stub_remote = Dingus()
569 self.uuid_dir = '/something/totally/random' ​
570 monkeypatch.setattr(runner.Runner, '_run_locally', self.stub_local) 593​ monkeypatch.setattr(runner.Runner, '_run_locally', self.stub_local)
571 monkeypatch.setattr(runner.Runner, '_run_remotely', self.stub_remote) 594​ monkeypatch.setattr(runner.Runner, '_run_remotely', self.stub_remote)
572 595​
573 self.stub_get_config = Dingus() 596​ self.stub_get_config = Dingus()
574 self.stub_config_local = Dingus() 597​ self.stub_config_local = Dingus()
575 self.stub_config_local.runtask_mode = config.RuntaskModeName.LOCAL 598​ self.stub_config_local.runtask_mode = config.RuntaskModeName.LOCAL
576 self.stub_config_remote = Dingus() 599​ self.stub_config_remote = Dingus()
577 self.stub_config_remote.runtask_mode = config.RuntaskModeName.LIBVIRT 600​ self.stub_config_remote.runtask_mode = config.RuntaskModeName.LIBVIRT
578 601​
579 self.empty_args = {'local': None, 'libvirt': None, 'ssh': None, 'ssh_privkey': None} 602​ self.empty_args = {'local': None, 'libvirt': None, 'ssh': None, 'ssh_privkey': None,
603​ 'artifactsdir': '/dir'}
580 self.fake_taskdata = {'environment': {'rpm': ['foo', 'bar']}} 604​ self.fake_taskdata = {'environment': {'rpm': ['foo', 'bar']}}
581 605​
582 def test_local_no_cli(self, monkeypatch): 606​ def test_local_no_cli(self, monkeypatch):
583 '''run locally with local runmode in config and no override from cli''' 607​ '''run locally with local runmode in config and no override from cli'''
584 ref_inputdata = self.empty_args.copy() 608​ ref_inputdata = self.empty_args.copy()
585 self.stub_get_config.return_value = self.stub_config_local 609​ self.stub_get_config.return_value = self.stub_config_local
586 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 610​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
587 611​
588 test_runner = runner.Runner(self.fake_taskdata, ref_inputdata, self.uuid_dir) 612​ test_runner = runner.Runner(self.fake_taskdata, ref_inputdata)
589 assert test_runner.run_remotely is False 613​ assert test_runner.run_remotely is False
590 614​
591 test_runner.run() 615​ test_runner.run()
592 assert len(self.stub_local.calls()) == 1 and len(self.stub_remote.calls()) == 0 616​ assert len(self.stub_local.calls()) == 1 and len(self.stub_remote.calls()) == 0
593 617​
594 def test_remote_no_cli(self, monkeypatch): 618​ def test_remote_no_cli(self, monkeypatch):
595 '''run remotely with remote runmode in config and no override from cli''' 619​ '''run remotely with remote runmode in config and no override from cli'''
596 ref_inputdata = self.empty_args.copy() 620​ ref_inputdata = self.empty_args.copy()
597 self.stub_get_config.return_value = self.stub_config_remote 621​ self.stub_get_config.return_value = self.stub_config_remote
598 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 622​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
599 623​
600 test_runner = runner.Runner(self.fake_taskdata, ref_inputdata, self.uuid_dir) 624​ test_runner = runner.Runner(self.fake_taskdata, ref_inputdata)
601 assert test_runner.run_remotely is True 625​ assert test_runner.run_remotely is True
602 assert test_runner.direct_ssh is False 626​ assert test_runner.direct_ssh is False
603 627​
604 test_runner.run() 628​ test_runner.run()
605 assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1 629​ assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1
606 630​
607 def test_remote_override_local(self, monkeypatch): 631​ def test_remote_override_local(self, monkeypatch):
608 '''run locally with remote runmode in config and local override from cli''' 632​ '''run locally with remote runmode in config and local override from cli'''
609 ref_inputdata = self.empty_args.copy() 633​ ref_inputdata = self.empty_args.copy()
610 ref_inputdata.update({'local': True}) 634​ ref_inputdata.update({'local': True})
611 self.stub_get_config.return_value = self.stub_config_remote 635​ self.stub_get_config.return_value = self.stub_config_remote
612 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 636​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
613 637​
614 test_runner = runner.Runner(self.fake_taskdata, ref_inputdata, self.uuid_dir) 638​ test_runner = runner.Runner(self.fake_taskdata, ref_inputdata)
615 assert test_runner.run_remotely is False 639​ assert test_runner.run_remotely is False
616 640​
617 test_runner.run() 641​ test_runner.run()
618 assert len(self.stub_local.calls()) == 1 and len(self.stub_remote.calls()) == 0 642​ assert len(self.stub_local.calls()) == 1 and len(self.stub_remote.calls()) == 0
619 643​
620 def test_local_override_ssh(self, monkeypatch): 644​ def test_local_override_ssh(self, monkeypatch):
621 '''run remotely with local runmode in config and ssh override from cli''' 645​ '''run remotely with local runmode in config and ssh override from cli'''
622 ref_inputdata = self.empty_args.copy() 646​ ref_inputdata = self.empty_args.copy()
623 ref_inputdata.update({'ssh': 'david@HAL9000'}) 647​ ref_inputdata.update({'ssh': 'david@HAL9000'})
624 self.stub_get_config.return_value = self.stub_config_local 648​ self.stub_get_config.return_value = self.stub_config_local
625 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 649​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
626 650​
627 test_runner = runner.Runner(self.fake_taskdata, ref_inputdata, self.uuid_dir) 651​ test_runner = runner.Runner(self.fake_taskdata, ref_inputdata)
628 assert test_runner.run_remotely is True 652​ assert test_runner.run_remotely is True
629 assert test_runner.direct_ssh is True 653​ assert test_runner.direct_ssh is True
630 654​
631 test_runner.run() 655​ test_runner.run()
632 assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1 656​ assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1
633 657​
634 def test_local_override_libvirt(self, monkeypatch): 658​ def test_local_override_libvirt(self, monkeypatch):
635 '''run remotely with local runmode in config and libvirt override from cli''' 659​ '''run remotely with local runmode in config and libvirt override from cli'''
636 ref_inputdata = self.empty_args.copy() 660​ ref_inputdata = self.empty_args.copy()
637 ref_inputdata.update({'libvirt': True}) 661​ ref_inputdata.update({'libvirt': True})
638 self.stub_get_config.return_value = self.stub_config_local 662​ self.stub_get_config.return_value = self.stub_config_local
639 monkeypatch.setattr(config, 'get_config', self.stub_get_config) 663​ monkeypatch.setattr(config, 'get_config', self.stub_get_config)
640 664​
641 test_runner = runner.Runner(self.fake_taskdata, ref_inputdata, self.uuid_dir) 665​ test_runner = runner.Runner(self.fake_taskdata, ref_inputdata)
642 assert test_runner.run_remotely is True 666​ assert test_runner.run_remotely is True
643 assert test_runner.direct_ssh is False 667​ assert test_runner.direct_ssh is False
644 668​
645 test_runner.run() 669​ test_runner.run()
646 assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1 670​ assert len(self.stub_local.calls()) == 0 and len(self.stub_remote.calls()) == 1
647 671​
648 672​
649class TestRunnerLocalRunner(): 673​class TestRunnerLocalRunner():
650 def test_local_runner_used(self, monkeypatch): 674​ def test_local_runner_used(self, monkeypatch):
651 ref_inputdata = {'local': True, 'ssh': None, 'ssh_privkey': None} 675​ ref_inputdata = {'local': True, 'ssh': None, 'ssh_privkey': None, 'artifactsdir': '/dir'}
652 ref_taskdata = {'environment': {'rpm': ['foo', 'bar']}} 676​ ref_taskdata = {'environment': {'rpm': ['foo', 'bar']}}
653 677​
654 uuid_dir = '/something/totally/random' ​
655 stub_local_runner = Dingus() 678​ stub_local_runner = Dingus()
656 monkeypatch.setattr(runner, 'LocalRunner', stub_local_runner) 679​ monkeypatch.setattr(runner, 'LocalRunner', stub_local_runner)
657 680​
658 test_runner = runner.Runner(ref_taskdata, ref_inputdata, uuid_dir) 681​ test_runner = runner.Runner(ref_taskdata, ref_inputdata)
659 682​
660 test_runner.run() 683​ test_runner.run()
661 684​
662 # check that LocalRunner was instantiated 685​ # check that LocalRunner was instantiated
663 assert len(stub_local_runner.calls()) == 1 686​ assert len(stub_local_runner.calls()) == 1
664 687​
665 def test_local_runner_properly_used(self, monkeypatch): 688​ def test_local_runner_properly_used(self, monkeypatch):
666 ref_inputdata = {'local': True, 'ssh': None, 'ssh_privkey': None} 689​ ref_inputdata = {'local': True, 'ssh': None, 'ssh_privkey': None, 'artifactsdir': '/dir'}
667 ref_taskdata = {'environment': {'rpm': ['foo', 'bar']}} 690​ ref_taskdata = {'environment': {'rpm': ['foo', 'bar']}}
668 691​
669 uuid_dir = '/something/totally/random' ​
670 stub_local_runner_object = Dingus() 692​ stub_local_runner_object = Dingus()
671 stub_local_runner = Dingus() 693​ stub_local_runner = Dingus()
672 stub_local_runner.return_value = stub_local_runner_object 694​ stub_local_runner.return_value = stub_local_runner_object
673 monkeypatch.setattr(runner, 'LocalRunner', stub_local_runner) 695​ monkeypatch.setattr(runner, 'LocalRunner', stub_local_runner)
674 696​
675 test_runner = runner.Runner(ref_taskdata, ref_inputdata, uuid_dir) 697​ test_runner = runner.Runner(ref_taskdata, ref_inputdata)
676 698​
677 test_runner.run() 699​ test_runner.run()
678 700​
679 methods_called = [call[0] for call in stub_local_runner_object.calls()] 701​ methods_called = [call[0] for call in stub_local_runner_object.calls()]
680 702​
681 assert len(methods_called) == 2 703​ assert len(methods_called) == 2
682 assert 'prepare_task' in methods_called and 'run' in methods_called 704​ assert 'prepare_task' in methods_called and 'run' in methods_called
683 705​
684 706​
685@pytest.mark.usefixtures('setup') 707​@pytest.mark.usefixtures('setup')
686class TestCheckArgs(): 708​class TestCheckArgs():
687 709​
688 @pytest.fixture 710​ @pytest.fixture
689 def setup(self): 711​ def setup(self):
690 self.empty_args = {'local': None, 'libvirt': None, 'ssh': None} 712​ self.empty_args = {'local': None, 'libvirt': None, 'ssh': None}
691 713​
692 def test_runmode_exclusive(self, monkeypatch): 714​ def test_runmode_exclusive(self):
693 '''allow only single runmode selection''' 715​ '''allow only single runmode selection'''
694 ref_inputdata_bad = [{'local': True, 'ssh': 'user@machine'}, 716​ ref_inputdata_bad = [{'local': True, 'ssh': 'user@machine'},
695 {'local': True, 'libvirt': True}, 717​ {'local': True, 'libvirt': True},
696 {'libvirt': True, 'ssh': 'user@machine'}, 718​ {'libvirt': True, 'ssh': 'user@machine'},
697 {'local': True, 'ssh': 'user@machine', 'libvirt': True}] 719​ {'local': True, 'ssh': 'user@machine', 'libvirt': True}]
698 ref_inputdata_good = [{'local': True}, 720​ ref_inputdata_good = [{'local': True},
699 {'ssh': 'user@machine'}, 721​ {'ssh': 'user@machine'},
700 {'libvirt': True}, 722​ {'libvirt': True},
Show All 12 Lines734 for ref_inputdata in ref_inputdata_good:
713 stub_error = Dingus() 735​ stub_error = Dingus()
714 stub_parser = Dingus() 736​ stub_parser = Dingus()
715 stub_parser.error = stub_error 737​ stub_parser.error = stub_error
716 args = self.empty_args.copy() 738​ args = self.empty_args.copy()
717 args.update(ref_inputdata) 739​ args.update(ref_inputdata)
718 runner.check_args(stub_parser, args) 740​ runner.check_args(stub_parser, args)
719 assert len(stub_error.calls()) == 0 741​ assert len(stub_error.calls()) == 0
720 742​
721 def test_ssh_bad_usermachine(self, monkeypatch): 743​ def test_ssh_bad_usermachine(self):
722 '''fail on invalid user@machine[:port] specifier''' 744​ '''fail on invalid user@machine[:port] specifier'''
723 ref_inputdata = {'ssh': 'user#machine'} 745​ ref_inputdata = {'ssh': 'user#machine'}
724 746​
725 stub_error = Dingus() 747​ stub_error = Dingus()
726 stub_parser = Dingus() 748​ stub_parser = Dingus()
727 stub_parser.error = stub_error 749​ stub_parser.error = stub_error
728 args = self.empty_args 750​ args = self.empty_args
729 args.update(ref_inputdata) 751​ args.update(ref_inputdata)
730 runner.check_args(stub_parser, args) 752​ runner.check_args(stub_parser, args)
731 753​
732 assert len(stub_error.calls()) == 1 754​ assert len(stub_error.calls()) == 1