Attachment #5949 for bug #34593

View | Details | Raw Unified | Return to bug 34593
Collapse All | Expand All




            print("Created process with pid '%s' was not terminated, "
                  "forcing kill" % self.Proc.pid)
            self.Proc.kill()
            _pid, exit_status, _res_usage = wait4(self.Proc.pid, WNOHANG)
            if exit_status != 9:
                print("The exit status while force kill is '%s' "
                      "instead of 'SIGKILL' code 9." % exit_status)

            pid = self.create_process()
            if self.query_process_exists(pid):
                self.make_kill_request('SIGTERM', [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if exit_status != 15:
                    utils.fail("Process exit status is '%s' instead of "
                               "'SIGTERM' code 15." % exit_status)

            pid = self.create_process()
            if self.query_process_exists(pid):
                self.make_kill_request('SIGKILL', [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if exit_status != 9:
                    utils.fail("Process exit status is '%s' instead of "
                               "'SIGKILL' code 9." % exit_status)
- 
--
.../test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing   | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)




                    if 'python' in result['command']:
                        return True
            except KeyError as exc:
                utils.fail("Failed to find key '%s' in"
                           "the 'top/query' request respone from UMC: %r"
                           % (exc, result))

    def force_process_kill(self):
        """
- 
--
.../60_umc-system/22_umc-service-proc-killing      | 22 +++++++++++-----------
1 file changed, 11 insertions(+), 11 deletions(-)




from TestUMCSystemModule import TestUMCSystem

from psutil import Process
from os import wait4, WNOHANG, WTERMSIG
import signal

from univention.config_registry import ConfigRegistry
import univention.testing.utils as utils

                  "forcing kill" % self.Proc.pid)
            self.Proc.kill()
            _pid, exit_status, _res_usage = wait4(self.Proc.pid, WNOHANG)
            if WTERMSIG(exit_status) != signal.SIGKILL:
                print("The exit status while force kill is 0x%x "
                      "instead of 'SIGKILL'(%d)." % (exit_status, signal.SIGKILL))

    def create_process(self):
        """

            if self.query_process_exists(pid):
                self.make_kill_request('SIGTERM', [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if WTERMSIG(exit_status) != signal.SIGTERM:
                    utils.fail("Process exit status is 0x%x instead of "
                               "SIGTERM(%d)." % (exit_status, signal.SIGTERM))
                if self.query_process_exists(pid):
                    utils.fail("Process did not terminate after request "
                               "with 'SIGTERM' signal")

            if self.query_process_exists(pid):
                self.make_kill_request('SIGKILL', [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if WTERMSIG(exit_status) != signal.SIGKILL:
                    utils.fail("Process exit status is 0x%x instead of "
                               "SIGKILL(%d)." % (exit_status, signal.SIGKILL))
                if self.query_process_exists(pid):
                    utils.fail("Process did not terminate after request "
                               "with 'SIGKILL' signal")
- 
--
.../60_umc-system/22_umc-service-proc-killing      | 49 +++++++++-------------
1 file changed, 19 insertions(+), 30 deletions(-)




        self.Proc = Process(pid)
        return pid

    def test(self, signame):
        print "Testing UMC process killing with signal '%s'" % signame
        signum = getattr(signal, signame)
        process killing functionality.
        """
        self.get_ucr_credentials()
        self.create_connection_authenticate()

        # case 1: killing process using signal 'SIGTERM'
        try:
            print "Testing UMC process killing with 'SIGTERM' signal"
            pid = self.create_process()
            if self.query_process_exists(pid):
                self.make_kill_request(signame, [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if WTERMSIG(exit_status) != signum:
                    utils.fail("Process exit status is 0x%x instead of "
                               "%s(%d)." % (exit_status, signame, signum))
                if self.query_process_exists(pid):
                    utils.fail("Process did not terminate after request "
                               "with signal %s" % (signame))
            else:
                utils.fail("The process is not running right after creation")
        finally:
            self.force_process_kill()

    def main(self):
        """
        Method to start the test of the UMC backend
        process killing functionality.
        """
        self.get_ucr_credentials()
        self.create_connection_authenticate()

        # case 1: killing process using signal 'SIGTERM'
        self.test('SIGTERM')

        # case 2: killing process using signal 'SIGKILL'
        self.test('SIGKILL')
            print "Testing UMC process killing with 'SIGKILL' signal"
            pid = self.create_process()
            if self.query_process_exists(pid):
                self.make_kill_request('SIGKILL', [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if WTERMSIG(exit_status) != signal.SIGKILL:
                    utils.fail("Process exit status is 0x%x instead of "
                               "SIGKILL(%d)." % (exit_status, signal.SIGKILL))
                if self.query_process_exists(pid):
                    utils.fail("Process did not terminate after request "
                               "with 'SIGKILL' signal")
            else:
                utils.fail("The process is not running right after creation")
        finally:
            self.force_process_kill()


if __name__ == '__main__':
- 
--
.../60_umc-system/22_umc-service-proc-killing      | 22 +++++++++++++---------
1 file changed, 13 insertions(+), 9 deletions(-)




from TestUMCSystemModule import TestUMCSystem

from psutil import Process
from os import wait4, WNOHANG, WTERMSIG, fork
import signal
from time import sleep

from univention.config_registry import ConfigRegistry
import univention.testing.utils as utils

        for result in request_result:
            try:
                if result['pid'] == pid:
                    if sys.executable in result['command']:
                        return True
            except KeyError as exc:
                utils.fail("Failed to find key '%s' in"

                print("The exit status while force kill is 0x%x "
                      "instead of 'SIGKILL'(%d)." % (exit_status, signal.SIGKILL))

    def create_process(self, ignore_sigterm=False):
        """
        Initiates a simple test process that should be killed after.
        Creates a psutil Process class to check running state
        before terminating. Also returns process id (pid).
        """
        pid = fork()
        if pid:  # parent
            self.Proc = Process(pid)
            return pid
        else:  # child under test
            if ignore_sigterm:
                signal.signal(signal.SIGTERM, signal.SIG_IGN)
            sleep(30)
            sys.exit(0)

    def test(self, signame):
        print "Testing UMC process killing with signal '%s'" % signame
- 
--
.../ucs-test/tests/60_umc-system/22_umc-service-proc-killing | 12 ++++++++----
1 file changed, 8 insertions(+), 4 deletions(-)




                utils.fail("Failed to find key '%s' in"
                           "the 'top/query' request respone from UMC: %r"
                           % (exc, result))
        return False

    def force_process_kill(self):
        """

            sleep(30)
            sys.exit(0)

    def test(self, signame, ignore_signal=False):
        print "Testing UMC process killing with signal '%s'" % signame
        signum = getattr(signal, signame)
        try:
            pid = self.create_process(ignore_signal)
            if self.query_process_exists(pid):
                self.make_kill_request(signame, [pid])
                _pid, exit_status, _res_usage = wait4(pid, WNOHANG)
                if ignore_signal != (WTERMSIG(exit_status) != signum):
                    utils.fail("Process exit status is 0x%x instead of "
                               "%s(%d)." % (exit_status, signame, signum))
                if ignore_signal != self.query_process_exists(pid):
                    utils.fail("Process did not terminate after request "
                               "with signal %s" % (signame))
            else:

        # case 2: killing process using signal 'SIGKILL'
        self.test('SIGKILL')

        # case 3: killing unwilling process using signal 'SIGTERM'
        self.test('SIGTERM', ignore_signal=True)


if __name__ == '__main__':
    TestUMC = TestUMCProcessKilling()
- 

Return to bug 34593

Lines 65-71 class TestUMCProcessKilling(TestUMCSystem): Link Here

(-)a/branches/ucs-3.2/ucs-3.2-2/test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing (-5 / +3 lines)
65	print("Created process with pid '%s' was not terminated, "	65	print("Created process with pid '%s' was not terminated, "
66	"forcing kill" % self.Proc.pid)	66	"forcing kill" % self.Proc.pid)
67	self.Proc.kill()	67	self.Proc.kill()
68	exit_status = wait4(self.Proc.pid, WNOHANG)[1]	68	_pid, exit_status, _res_usage = wait4(self.Proc.pid, WNOHANG)
69	if exit_status != 9:	69	if exit_status != 9:
70	print("The exit status while force kill is '%s' "	70	print("The exit status while force kill is '%s' "
71	"instead of 'SIGKILL' code 9." % exit_status)	71	"instead of 'SIGKILL' code 9." % exit_status)
Lines 97-103 class TestUMCProcessKilling(TestUMCSystem): Link Here
97	pid = self.create_process()	97	pid = self.create_process()
98	if self.query_process_exists(pid):	98	if self.query_process_exists(pid):
99	self.make_kill_request('SIGTERM', [pid])	99	self.make_kill_request('SIGTERM', [pid])
100	exit_status = wait4(pid, WNOHANG)[1]	100	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
101	if exit_status != 15:	101	if exit_status != 15:
102	utils.fail("Process exit status is '%s' instead of "	102	utils.fail("Process exit status is '%s' instead of "
103	"'SIGTERM' code 15." % exit_status)	103	"'SIGTERM' code 15." % exit_status)
Lines 115-121 class TestUMCProcessKilling(TestUMCSystem): Link Here
115	pid = self.create_process()	115	pid = self.create_process()
116	if self.query_process_exists(pid):	116	if self.query_process_exists(pid):
117	self.make_kill_request('SIGKILL', [pid])	117	self.make_kill_request('SIGKILL', [pid])
118	exit_status = wait4(pid, WNOHANG)[1]	118	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
119	if exit_status != 9:	119	if exit_status != 9:
120	utils.fail("Process exit status is '%s' instead of "	120	utils.fail("Process exit status is '%s' instead of "
121	"'SIGKILL' code 9." % exit_status)	121	"'SIGKILL' code 9." % exit_status)
122	-
123	--
124	.../test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing \| 6 +++---	122	.../test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing \| 6 +++---
125	1 file changed, 3 insertions(+), 3 deletions(-)	123	1 file changed, 3 insertions(+), 3 deletions(-)

Lines 53-61 class TestUMCProcessKilling(TestUMCSystem): Link Here

(-)a/branches/ucs-3.2/ucs-3.2-2/test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing (-5 / +3 lines)
53	if 'python' in result['command']:	53	if 'python' in result['command']:
54	return True	54	return True
55	except KeyError as exc:	55	except KeyError as exc:
56	utils.fail("Failed to find 'pid' or 'command' keys in"	56	utils.fail("Failed to find key '%s' in"
57	"the 'top/query' request respone from UMC: %s"	57	"the 'top/query' request respone from UMC: %r"
58	% result)	58	% (exc, result))
59		59
60	def force_process_kill(self):	60	def force_process_kill(self):
61	"""	61	"""
62	-
63	--
64	.../60_umc-system/22_umc-service-proc-killing \| 22 +++++++++++-----------	62	.../60_umc-system/22_umc-service-proc-killing \| 22 +++++++++++-----------
65	1 file changed, 11 insertions(+), 11 deletions(-)	63	1 file changed, 11 insertions(+), 11 deletions(-)

Lines 83-131 class TestUMCProcessKilling(TestUMCSystem): Link Here

(-)a/branches/ucs-3.2/ucs-3.2-2/test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing (-32 / +19 lines)
83	self.Proc = Process(pid)	83	self.Proc = Process(pid)
84	return pid	84	return pid
85		85
86	def main(self):	86	def test(self, signame):
87	"""	87	print "Testing UMC process killing with signal '%s'" % signame
88	Method to start the test of the UMC backend	88	signum = getattr(signal, signame)
89	process killing functionality.
90	"""
91	self.get_ucr_credentials()
92	self.create_connection_authenticate()
93
94	# case 1: killing process using signal 'SIGTERM'
95	try:	89	try:
96	print "Testing UMC process killing with 'SIGTERM' signal"
97	pid = self.create_process()	90	pid = self.create_process()
98	if self.query_process_exists(pid):	91	if self.query_process_exists(pid):
99	self.make_kill_request('SIGTERM', [pid])	92	self.make_kill_request(signame, [pid])
100	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)	93	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
101	if WTERMSIG(exit_status) != signal.SIGTERM:	94	if WTERMSIG(exit_status) != signum:
102	utils.fail("Process exit status is 0x%x instead of "	95	utils.fail("Process exit status is 0x%x instead of "
103	"SIGTERM(%d)." % (exit_status, signal.SIGTERM))	96	"%s(%d)." % (exit_status, signame, signum))
104	if self.query_process_exists(pid):	97	if self.query_process_exists(pid):
105	utils.fail("Process did not terminate after request "	98	utils.fail("Process did not terminate after request "
106	"with 'SIGTERM' signal")	99	"with signal %s" % (signame))
107	else:	100	else:
108	utils.fail("The process is not running right after creation")	101	utils.fail("The process is not running right after creation")
109	finally:	102	finally:
110	self.force_process_kill()	103	self.force_process_kill()
111		104
		105	def main(self):
		106	"""
		107	Method to start the test of the UMC backend
		108	process killing functionality.
		109	"""
		110	self.get_ucr_credentials()
		111	self.create_connection_authenticate()
		112
		113	# case 1: killing process using signal 'SIGTERM'
		114	self.test('SIGTERM')
		115
112	# case 2: killing process using signal 'SIGKILL'	116	# case 2: killing process using signal 'SIGKILL'
113	try:	117	self.test('SIGKILL')
114	print "Testing UMC process killing with 'SIGKILL' signal"
115	pid = self.create_process()
116	if self.query_process_exists(pid):
117	self.make_kill_request('SIGKILL', [pid])
118	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
119	if WTERMSIG(exit_status) != signal.SIGKILL:
120	utils.fail("Process exit status is 0x%x instead of "
121	"SIGKILL(%d)." % (exit_status, signal.SIGKILL))
122	if self.query_process_exists(pid):
123	utils.fail("Process did not terminate after request "
124	"with 'SIGKILL' signal")
125	else:
126	utils.fail("The process is not running right after creation")
127	finally:
128	self.force_process_kill()
129		118
130		119
131	if __name__ == '__main__':	120	if __name__ == '__main__':
132	-
133	--
134	.../60_umc-system/22_umc-service-proc-killing \| 22 +++++++++++++---------	121	.../60_umc-system/22_umc-service-proc-killing \| 22 +++++++++++++---------
135	1 file changed, 13 insertions(+), 9 deletions(-)	122	1 file changed, 13 insertions(+), 9 deletions(-)

Lines 8-15 sys.path.insert(0, '.') Link Here

(-)a/branches/ucs-3.2/ucs-3.2-2/test/ucs-test/tests/60_umc-system/22_umc-service-proc-killing (-13 / +11 lines)
8	from TestUMCSystemModule import TestUMCSystem	8	from TestUMCSystemModule import TestUMCSystem
9		9
10	from psutil import Process	10	from psutil import Process
11	from os import wait4, WNOHANG	11	from os import wait4, WNOHANG, WTERMSIG
12	from subprocess import Popen	12	import signal
13		13
14	from univention.config_registry import ConfigRegistry	14	from univention.config_registry import ConfigRegistry
15	import univention.testing.utils as utils	15	import univention.testing.utils as utils
Lines 66-74 class TestUMCProcessKilling(TestUMCSystem): Link Here
66	"forcing kill" % self.Proc.pid)	66	"forcing kill" % self.Proc.pid)
67	self.Proc.kill()	67	self.Proc.kill()
68	_pid, exit_status, _res_usage = wait4(self.Proc.pid, WNOHANG)	68	_pid, exit_status, _res_usage = wait4(self.Proc.pid, WNOHANG)
69	if exit_status != 9:	69	if WTERMSIG(exit_status) != signal.SIGKILL:
70	print("The exit status while force kill is '%s' "	70	print("The exit status while force kill is 0x%x "
71	"instead of 'SIGKILL' code 9." % exit_status)	71	"instead of 'SIGKILL'(%d)." % (exit_status, signal.SIGKILL))
72		72
73	def create_process(self):	73	def create_process(self):
74	"""	74	"""
Lines 98-106 class TestUMCProcessKilling(TestUMCSystem): Link Here
98	if self.query_process_exists(pid):	98	if self.query_process_exists(pid):
99	self.make_kill_request('SIGTERM', [pid])	99	self.make_kill_request('SIGTERM', [pid])
100	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)	100	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
101	if exit_status != 15:	101	if WTERMSIG(exit_status) != signal.SIGTERM:
102	utils.fail("Process exit status is '%s' instead of "	102	utils.fail("Process exit status is 0x%x instead of "
103	"'SIGTERM' code 15." % exit_status)	103	"SIGTERM(%d)." % (exit_status, signal.SIGTERM))
104	if self.query_process_exists(pid):	104	if self.query_process_exists(pid):
105	utils.fail("Process did not terminate after request "	105	utils.fail("Process did not terminate after request "
106	"with 'SIGTERM' signal")	106	"with 'SIGTERM' signal")
Lines 116-124 class TestUMCProcessKilling(TestUMCSystem): Link Here
116	if self.query_process_exists(pid):	116	if self.query_process_exists(pid):
117	self.make_kill_request('SIGKILL', [pid])	117	self.make_kill_request('SIGKILL', [pid])
118	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)	118	_pid, exit_status, _res_usage = wait4(pid, WNOHANG)
119	if exit_status != 9:	119	if WTERMSIG(exit_status) != signal.SIGKILL:
120	utils.fail("Process exit status is '%s' instead of "	120	utils.fail("Process exit status is 0x%x instead of "
121	"'SIGKILL' code 9." % exit_status)	121	"SIGKILL(%d)." % (exit_status, signal.SIGKILL))
122	if self.query_process_exists(pid):	122	if self.query_process_exists(pid):
123	utils.fail("Process did not terminate after request "	123	utils.fail("Process did not terminate after request "
124	"with 'SIGKILL' signal")	124	"with 'SIGKILL' signal")
125	-
126	--
127	.../60_umc-system/22_umc-service-proc-killing \| 49 +++++++++-------------	125	.../60_umc-system/22_umc-service-proc-killing \| 49 +++++++++-------------
128	1 file changed, 19 insertions(+), 30 deletions(-)	126	1 file changed, 19 insertions(+), 30 deletions(-)