Differential D498

fix exitcode directive in disposable-develop
ClosedPublic
Actions

Authored by lbrabec on Aug 13 2015, 11:45 AM.

Details

Reviewers
kparal
Maniphest Tasks
T554: exitcode directive broken in disposable-develop
Commits
rLTRN5ca062844922: fix exitcode directive in disposable-develop
Summary

changes in disposable-develop and those in exitcode directive commit were not compatible, this fixes the problem.

Test Plan

py.test

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.
lbrabec retitled this revision from to fix exitcode directive in disposable-develop.Aug 13 2015, 11:45 AM
lbrabec updated this object.
lbrabec edited the test plan for this revision. (Show Details)
lbrabec added a reviewer: kparal.
kparal accepted this revision.Aug 13 2015, 1:57 PM

LGTM

libtaskotron/runner.py
531

You can move this line to line 536 and add

assert task_runner.exitcode in [0, None]
This revision is now accepted and ready to land.Aug 13 2015, 1:57 PM
Closed by commit rLTRN5ca062844922: fix exitcode directive in disposable-develop (authored by Lukas Brabec <lbrabec@redhat.com>). · Explain WhyAug 13 2015, 2:30 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 1310

View Options

libtaskotron/remote_exec.py

Show All 11 Lines
12import socket 12​import socket
13from stat import S_ISDIR 13​from stat import S_ISDIR
14 14​
15import paramiko 15​import paramiko
16 16​
17from .logger import log 17​from .logger import log
18from . import exceptions as exc 18​from . import exceptions as exc
19 19​
20​from libtaskotron.directives import exitcode_directive
21​
20 22​
21# http://stackoverflow.com/questions/11325019 23​# http://stackoverflow.com/questions/11325019
22class Tee(object): 24​class Tee(object):
23 '''Helper class for writing data to different streams.''' 25​ '''Helper class for writing data to different streams.'''
24 26​
25 def __init__(self, *files): 27​ def __init__(self, *files):
26 self._files = list(files) 28​ self._files = list(files)
27 29​
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Line(s)106 def close(self):
107 self.outstream.close() 109​ self.outstream.close()
108 self.sftp.close() 110​ self.sftp.close()
109 self.ssh.close() 111​ self.ssh.close()
110 112​
111 def cmd(self, cmd): 113​ def cmd(self, cmd):
112 '''Execute a command. 114​ '''Execute a command.
113 115​
114 :param str cmd: A command to be executed 116​ :param str cmd: A command to be executed
115 117​ :returns: returncode of the command
116 :raise TaskotronRemoteError: If the command has non-zero return code 118​ :raise TaskotronRemoteError: If the command has non-zero return code and it isn't a code of
119​ exitcode directive failure.
117 ''' 120​ '''
118 121​
119 log.debug('Running command on remote host: %s', cmd) 122​ log.debug('Running command on remote host: %s', cmd)
120 123​
121 stdin, stdout, stderr = self.ssh.exec_command(cmd) 124​ stdin, stdout, stderr = self.ssh.exec_command(cmd)
122 125​
123 # stdout.channel represents channel for both stdout and stderr 126​ # stdout.channel represents channel for both stdout and stderr
124 channel = stdout.channel 127​ channel = stdout.channel
125 while not channel.exit_status_ready(): 128​ while not channel.exit_status_ready():
126 if channel.recv_ready(): 129​ if channel.recv_ready():
127 data = channel.recv(1024) 130​ data = channel.recv(1024)
128 self.outstream.write(data) 131​ self.outstream.write(data)
129 if channel.recv_stderr_ready(): 132​ if channel.recv_stderr_ready():
130 data = channel.recv_stderr(1024) 133​ data = channel.recv_stderr(1024)
131 self.outstream.write(data) 134​ self.outstream.write(data)
132 135​
133 retcode = channel.recv_exit_status() 136​ retcode = channel.recv_exit_status()
134 137​
135 if retcode != 0: 138​ if retcode != 0 and retcode != exitcode_directive.FAILURE:
136 raise exc.TaskotronRemoteError('Command "%s" on %s@%s exited with code %s' % 139​ raise exc.TaskotronRemoteError('Command "%s" on %s@%s exited with code %s' %
137 (cmd, self.username, self.hostname, retcode)) 140​ (cmd, self.username, self.hostname, retcode))
141​ return retcode
138 142​
139 def install_pkgs(self, pkgs): 143​ def install_pkgs(self, pkgs):
140 '''Install packages via yum. 144​ '''Install packages via yum.
141 145​
142 :param list pkgs: A list or a string separated by commas of packages to be installed 146​ :param list pkgs: A list or a string separated by commas of packages to be installed
143 147​
144 :raise TaskotronRemoteError: If the command has non-zero return code 148​ :raise TaskotronRemoteError: If the command has non-zero return code
145 ''' 149​ '''
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines
View Options

libtaskotron/runner.py

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Line(s)43 def __init__(self, task_data, arg_data, uuid_dir):
53 self.uuid_dir = uuid_dir 53​ self.uuid_dir = uuid_dir
54 54​
55 #: run locally or remotely 55​ #: run locally or remotely
56 self.run_remotely = False 56​ self.run_remotely = False
57 #: when running remotely, run directly over ssh, instead of using libvirt 57​ #: when running remotely, run directly over ssh, instead of using libvirt
58 self.direct_ssh = False 58​ self.direct_ssh = False
59 self.user = self.machine = self.port = None 59​ self.user = self.machine = self.port = None
60 self.ssh_privkey = arg_data['ssh_privkey'] or config.get_config().ssh_privkey 60​ 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
62​ #: directive was not used.
63​ self.exitcode = None
61 64​
62 # decide whether to run locally or remotely 65​ # decide whether to run locally or remotely
63 runtask_mode = config.get_config().runtask_mode 66​ runtask_mode = config.get_config().runtask_mode
64 if runtask_mode == config.RuntaskModeName.LOCAL: 67​ if runtask_mode == config.RuntaskModeName.LOCAL:
65 self.run_remotely = False 68​ self.run_remotely = False
66 elif runtask_mode == config.RuntaskModeName.LIBVIRT: 69​ elif runtask_mode == config.RuntaskModeName.LIBVIRT:
67 self.run_remotely = True 70​ self.run_remotely = True
68 else: 71​ else:
Show All 34 Lines105 def _run_locally(self):
103 '''Init environment, instantiate LocalRunner and run it.''' 106​ '''Init environment, instantiate LocalRunner and run it.'''
104 107​
105 filelog_path = os.path.join(self.uuid_dir, 'taskotron.log') 108​ filelog_path = os.path.join(self.uuid_dir, 'taskotron.log')
106 logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True) 109​ logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
107 110​
108 task_runner = LocalRunner(self.task_data, self.arg_data) 111​ task_runner = LocalRunner(self.task_data, self.arg_data)
109 task_runner.prepare_task() 112​ task_runner.prepare_task()
110 task_runner.run() 113​ task_runner.run()
114​ self.exitcode = task_runner.exitcode
111 115​
112 def _run_remotely(self): 116​ def _run_remotely(self):
113 '''Init environment, instantiate RemoteRunner and run it.''' 117​ '''Init environment, instantiate RemoteRunner and run it.'''
114 118​
115 filelog_path = os.path.join(self.uuid_dir, 'taskotron-initiator.log') 119​ filelog_path = os.path.join(self.uuid_dir, 'taskotron-initiator.log')
116 logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True) 120​ logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
117 121​
118 stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log') 122​ stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log')
119 123​
120 if self.direct_ssh: 124​ if self.direct_ssh:
121 log.info("Running task over SSH on machine '%s'...", self.machine) 125​ log.info("Running task over SSH on machine '%s'...", self.machine)
122 else: 126​ else:
123 log.info("Running task on a disposable client using libvirt...") 127​ log.info("Running task on a disposable client using libvirt...")
124 128​
125 log.info("Creating VM for task") 129​ log.info("Creating VM for task")
126 task_vm = vm.TestCloudMachine(self.arg_data['uuid']) 130​ task_vm = vm.TestCloudMachine(self.arg_data['uuid'])
127 task_vm.prepare() 131​ task_vm.prepare()
128 self.machine = task_vm.ipaddr 132​ self.machine = task_vm.ipaddr
129 self.port = 22 133​ self.port = 22
130 self.user = task_vm.username 134​ self.user = task_vm.username
131 135​
132 log.info("Running Task over SSH on machine %s" % task_vm.instancename) 136​ log.info("Running Task over SSH on machine %s" % task_vm.instancename)
133 137​
134 with remote_exec.RemoteExec(self.machine, self.port, self.user, 138​ with remote_exec.RemoteExec(self.machine, self.port, self.user,
135 self.ssh_privkey, stdio_filename) as ssh: 139​ self.ssh_privkey, stdio_filename) as ssh:
136 task_runner = RemoteRunner(ssh, self.task_data, self.arg_data) 140​ task_runner = RemoteRunner(ssh, self.task_data, self.arg_data)
137 try: 141​ try:
138 task_runner.prepare_task() 142​ task_runner.prepare_task()
139 task_runner.run() 143​ task_runner.run()
140 except exc.TaskotronRemoteError, e: 144​ except exc.TaskotronRemoteError, e:
141 log.exception(e) 145​ log.exception(e)
142 146​
143 task_runner.get_output() 147​ task_runner.get_output()
148​ self.exitcode = task_runner.exitcode
144 149​
145 if self.direct_ssh: 150​ if self.direct_ssh:
146 # don't try to run teardown in the direct ssh case 151​ # don't try to run teardown in the direct ssh case
147 return 152​ return
148 153​
149 # only teardown the VM when not in debug mode 154​ # only teardown the VM when not in debug mode
150 # FIXME: implement --no-destroy (per T408) 155​ # FIXME: implement --no-destroy (per T408)
151 if self.arg_data['debug']: 156​ if self.arg_data['debug']:
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Line(s)213 def _render_action(self, action):
222 taskformula.replace_vars_in_action(rendered_action, variables) 227​ taskformula.replace_vars_in_action(rendered_action, variables)
223 228​
224 return rendered_action 229​ return rendered_action
225 230​
226 def _extract_directive_from_action(self, action): 231​ def _extract_directive_from_action(self, action):
227 for key in action: 232​ for key in action:
228 if key not in ['name', 'export']: 233​ if key not in ['name', 'export']:
229 return key 234​ return key
230 raise exc.TaskotronYamlError('no directive found in action %s' % 235​ raise exc.TaskotronYamlError('no directive found in action %s' % str(action))
231 str(action)) ​
232 236​
233 def do_single_action(self, action): 237​ def do_single_action(self, action):
234 '''Execute a single action from the task. See :meth:`do_actions` to see 238​ '''Execute a single action from the task. See :meth:`do_actions` to see
235 how an action looks like. 239​ how an action looks like.
236 240​
237 :param dict action: An action specification parsed from the task formula 241​ :param dict action: An action specification parsed from the task formula
238 ''' 242​ '''
239 directive_name = self._extract_directive_from_action(action) 243​ directive_name = self._extract_directive_from_action(action)
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Line(s)
323 327​
324 328​
325class RemoteRunner(object): 329​class RemoteRunner(object):
326 def __init__(self, ssh, task_data, arg_data): 330​ def __init__(self, ssh, task_data, arg_data):
327 self.ssh = ssh 331​ self.ssh = ssh
328 self.task_data = task_data 332​ self.task_data = task_data
329 self.arg_data = arg_data 333​ self.arg_data = arg_data
330 self.taskdir = config.get_config().client_taskdir 334​ self.taskdir = config.get_config().client_taskdir
335​ #: int exitcode set by exitcode directive. It is always set to value returned by
336​ #: self.ssh.cmd() in the run() method.
337​ self.exitcode = None
331 338​
332 def prepare_task(self): 339​ def prepare_task(self):
333 # FIXME remove this once the vm code is done 340​ # FIXME remove this once the vm code is done
334 self.ssh.install_pkgs('wget') 341​ self.ssh.install_pkgs('wget')
335 self.ssh.cmd('wget -O /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo ' 342​ self.ssh.cmd('wget -O /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo '
336 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/' 343​ 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/'
337 'repo/fedora-21/tflink-taskotron-fedora-21.repo') 344​ 'repo/fedora-21/tflink-taskotron-fedora-21.repo')
338 345​
Show All 30 Lines373 task_cmd = ['cd %s;' % self.taskdir,
369 self.arg_data['type'], 376​ self.arg_data['type'],
370 '-i', 377​ '-i',
371 self.arg_data['item'], # XXX what if item is "; rm -rf /;"? 378​ self.arg_data['item'], # XXX what if item is "; rm -rf /;"?
372 '--uuid', 379​ '--uuid',
373 self.arg_data['uuid'], 380​ self.arg_data['uuid'],
374 '--local', 381​ '--local',
375 os.path.basename(self.arg_data['taskfile'])] 382​ os.path.basename(self.arg_data['taskfile'])]
376 383​
377 self.ssh.cmd(' '.join(task_cmd)) 384​ self.exitcode = self.ssh.cmd(' '.join(task_cmd))
378 385​
379 def get_output(self): 386​ def get_output(self):
380 uuid_dir = os.path.join(config.get_config().artifactsdir, self.arg_data['uuid']) 387​ uuid_dir = os.path.join(config.get_config().artifactsdir, self.arg_data['uuid'])
381 388​
382 # copy artifacts from vm 389​ # copy artifacts from vm
383 try: 390​ try:
384 self.ssh.get_dir(uuid_dir, uuid_dir) 391​ self.ssh.get_dir(uuid_dir, uuid_dir)
385 except exc.TaskotronRemoteError, e: 392​ except exc.TaskotronRemoteError, e:
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Line(s)485def main():
516 # run the task, locally or remotely 523​ # run the task, locally or remotely
517 task_runner = Runner(task_data, arg_data, uuid_dir) 524​ task_runner = Runner(task_data, arg_data, uuid_dir)
518 task_runner.run() 525​ task_runner.run()
519 526​
520 # finalization 527​ # finalization
521 log.info('Execution finished at: %s', 528​ log.info('Execution finished at: %s',
522 datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')) 529​ datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC'))
523 530​
524 if isinstance(task_runner, LocalRunner) and task_runner.exitcode: 531​ if task_runner.exitcode == exitcode_directive.FAILURE:
kparalUnsubmitted
Not Done

You can move this line to line 536 and add

assert task_runner.exitcode in [0, None]
525 # FIXME: implement this even for RemoteRunner? ​
526 log.info("Exiting with exit status %d (this behavior was requested by exitcode directive)" 532​ log.info("Exiting with exit status %d (this behavior was requested by exitcode directive)"
527 % task_runner.exitcode) 533​ % task_runner.exitcode)
528 sys.exit(task_runner.exitcode) 534​ sys.exit(task_runner.exitcode)
535​
536​ # exitcode with value exitcode_directive.FAILURE *should* be set only by exitcode directive
537​ assert task_runner.exitcode in [0, None]
View Options

testing/test_exitcode_directive.py

1# -*- coding: utf-8 -*- 1​# -*- coding: utf-8 -*-
2# Copyright 2009-2014, Red Hat, Inc. 2​# Copyright 2009-2014, Red Hat, Inc.
3# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> 3​# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
4# See the LICENSE file for more details on Licensing 4​# See the LICENSE file for more details on Licensing
5 5​
6from libtaskotron.directives import exitcode_directive 6​from libtaskotron.directives import exitcode_directive
7from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError 7​from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
8​from libtaskotron import runner
9​from libtaskotron import remote_exec
10​from dingus import Dingus
8import pytest 11​import pytest
9 12​
10 13​
11@pytest.mark.usefixtures("setup") 14​@pytest.mark.usefixtures("setup")
12class TestReturncode(object): 15​class TestReturncode(object):
13 16​
14 @pytest.fixture 17​ @pytest.fixture
15 def setup(self): 18​ def setup(self):
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Line(s)80 def test_empty_tap_last(self):
78 self.test_tap = """ 81​ self.test_tap = """
79TAP version 13 82​TAP version 13
801..0 83​1..0
81""" 84​"""
82 self.test_input_data['tap_last'] = self.test_tap 85​ self.test_input_data['tap_last'] = self.test_tap
83 exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data, 86​ exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data,
84 self.test_env_data) 87​ self.test_env_data)
85 assert exitcode == exitcode_directive.SUCCESS 88​ assert exitcode == exitcode_directive.SUCCESS
89​
90​
91​@pytest.mark.usefixtures("setup")
92​class TestRunnerExitcode(object):
93​
94​ @pytest.fixture
95​ def setup(self):
96​ task_data = {}
97​ arg_data = {'local': None, 'libvirt': None, 'ssh': None, 'ssh_privkey': None}
98​ uuid = ""
99​ self.test_runner = runner.Runner(task_data, arg_data, uuid)
100​ self.stub_runner = Dingus()
101​ self.stub_runner.exitcode = exitcode_directive.FAILURE
102​
103​ def test_has_exitcode(self):
104​ assert hasattr(self.test_runner, 'exitcode')
105​
106​ def test_local_propagate(self, monkeypatch):
107​ stub_local = Dingus()
108​ stub_local.return_value = self.stub_runner
109​ monkeypatch.setattr(runner, 'LocalRunner', stub_local)
110​ self.test_runner._run_locally()
111​ assert self.test_runner.exitcode == exitcode_directive.FAILURE
112​
113​ def test_remote_propagate(self, monkeypatch):
114​ stub_remote = Dingus()
115​ stub_remote.return_value = self.stub_runner
116​ monkeypatch.setattr(runner, 'RemoteRunner', stub_remote)
117​ monkeypatch.setattr(remote_exec, 'RemoteExec', Dingus())
118​ # skip the disposable vm creation
119​ self.test_runner.direct_ssh = True
120​ self.test_runner._run_remotely()
121​ assert self.test_runner.exitcode == exitcode_directive.FAILURE
View Options

testing/test_remote_exec.py

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Line(s)137class TestRemoteExec(object):
213 def test_put_dir_not_dir_dont_overwrite(self): 213​ def test_put_dir_not_dir_dont_overwrite(self):
214 assert self.remote.put_dir(STUB_DIR, STUB_DIR, overwrite=False) is None 214​ assert self.remote.put_dir(STUB_DIR, STUB_DIR, overwrite=False) is None
215 215​
216 def test_get_dir_not_dir(self): 216​ def test_get_dir_not_dir(self):
217 with pytest.raises(TaskotronRemoteError): 217​ with pytest.raises(TaskotronRemoteError):
218 self.remote.get_dir(STUB_FILE, STUB_DIR) 218​ self.remote.get_dir(STUB_FILE, STUB_DIR)
219 219​
220 def test_cmd_success(self): 220​ def test_cmd_success(self):
221 assert self.remote.cmd(STUB_CMD_TRUE) is None 221​ assert self.remote.cmd(STUB_CMD_TRUE) == STUB_CMD_TRUE
222 222​
223 def test_cmd_failure(self): 223​ def test_cmd_failure(self):
224 with pytest.raises(TaskotronRemoteError): 224​ with pytest.raises(TaskotronRemoteError):
225 self.remote.cmd(STUB_CMD_FALSE) 225​ self.remote.cmd(STUB_CMD_FALSE)
226 226​
227 def test_install_pkgs_str(self): 227​ def test_install_pkgs_str(self):
228 self.remote.cmd = Dingus() 228​ self.remote.cmd = Dingus()
229 self.remote.install_pkgs('libtaskotron,rpmlint') 229​ self.remote.install_pkgs('libtaskotron,rpmlint')
Show All 19 Lines