3685840692

Build Type

push

github

Committed by viacheslav.kirichenko

Commit Message

ci: update test matrix

Run Details

749 of 1514 branches covered (49.47%)

Branch coverage included in aggregate %.

2893 of 4242 relevant lines covered (68.2%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.76

/lib/preprocessor.py

import os
import shlex
import signal
import sys
from collections import deque

import yaml
from gevent import socket

from lib.admin_connection import AdminAsyncConnection
from lib.colorer import color_log
from lib.utils import signum
from lib.utils import signame
from lib.utils import integer_types
from lib.utils import string_types


class Namespace(object):
    pass


class LuaPreprocessorException(Exception):
    """ Raised when evaluation of a test-run command failed.

        This exception is displayed as QA notice on the terminal.

        A Lua error is raised in a test code. The raised object is
        a string with given error message.

        All other errors that are raised during a command
        evaluation are considered as show stoppers and lead to
        stop execution of a test. KeyboardInterrupt and
        TarantoolStartError stops testing at all, see
        inspector.py.
    """

    def __init__(self, val):
        super(LuaPreprocessorException, self).__init__()
        self.value = val

    def __str__(self):
        return self.value


class TestState(object):
    def __init__(self, suite_ini, default_server, create_server, params={},
                 **kwargs):
        self.delimiter = ''
        self.suite_ini = suite_ini
        self.environ = Namespace()
        self.operation = False
        self.create_server = create_server
        self.servers = {'default': default_server}
        self.connections = {}
        self.run_params = params
        if default_server is not None:
            self.connections = {'default': default_server.admin}
            # curcon is an array since we may have many connections
            self.curcon = [self.connections['default']]
            nmsp = Namespace()
            setattr(nmsp, 'admin', default_server.admin.uri)
            setattr(nmsp, 'listen', default_server.listen_uri)
            setattr(self.environ, 'default', nmsp)
        # for propagating 'current_test' to non-default servers
        self.default_server_no_connect = kwargs.get(
            'default_server_no_connect')

    def parse_preprocessor(self, string):
        token_store = deque()
        lexer = shlex.shlex(string)
        lexer.commenters = []
        token = lexer.get_token()
        if not token:
            return
        if token == 'setopt':
            option = lexer.get_token()
            if not option:
                raise LuaPreprocessorException(
                    "Wrong token for setopt: expected option name")
            value = lexer.get_token()
            if not value:
                raise LuaPreprocessorException(
                    "Wrong token for setopt: expected option value")
            return self.options(option, value)
        elif token == 'eval':
            name = lexer.get_token()
            expr = lexer.get_token()

            # token format: eval <server name> "<expr>"
            return self.lua_eval(name, expr[1:-1])
        elif token == 'switch':
            server = lexer.get_token()
            return self.switch(server)
        elif token == 'config':
            lexer.get_token()
            return self.run_params
        token_store.append(token)
        token = lexer.get_token()
        if token == 'server':
            stype = token_store.popleft()
            sname = lexer.get_token()
            if not sname:
                raise LuaPreprocessorException(
                    "Wrong token for server: expected name")
            options = {}
            temp = lexer.get_token()
            if not temp:
                pass
            elif temp == 'with':
                while True:
                    k = lexer.get_token()
                    if not k:
                        break
                    v = lexer.get_token()
                    if v == '=':
                        v = lexer.get_token()
                    options[k] = v
                    lexer.get_token()
            else:
                raise LuaPreprocessorException(
                    "Wrong token for server: expected 'with', got {0}".format(
                        repr(temp)))
            return self.server(stype, sname, options)
        elif token == 'connection':
            ctype = token_store.popleft()
            cname = [lexer.get_token()]
            if not cname[0]:
                raise LuaPreprocessorException(
                    "Wrong token for connection: expected name")
            cargs = None
            temp = lexer.get_token()
            if temp == 'to':
                cargs = lexer.get_token()
            elif temp == ',':
                while True:
                    a = lexer.get_token()
                    if not a:
                        break
                    if a == ',':
                        continue
                    cname.append(a)
            elif temp:
                raise LuaPreprocessorException(
                    ("Wrong token for server: expected 'to' or ',', " +
                     "got {0}").format(repr(temp)))
            return self.connection(ctype, cname, cargs)
        elif token == 'filter':
            ftype = token_store.popleft()
            ref = None
            ret = None
            temp = lexer.get_token()
            if temp:
                ref = temp
                if not temp:
                    raise LuaPreprocessorException(
                        "Wrong token for filter: expected filter1")
                if lexer.get_token() != 'to':
                    raise LuaPreprocessorException(
                        ("Wrong token for filter: expected 'to', " +
                         "got {0}").format(repr(temp)))
                temp = lexer.get_token()
                if not temp:
                    raise LuaPreprocessorException(
                        "Wrong token for filter: expected filter2")
                ret = temp
            return self.filter(ftype, ref, ret)
        elif token == 'variable':
            ftype = token_store.popleft()
            ref = lexer.get_token()
            temp = lexer.get_token()
            if temp != 'to':
                raise LuaPreprocessorException(
                    "Wrong token for filter: exptected 'to', got {0}".format(
                        repr(temp)))
            ret = lexer.get_token()
            return self.variable(ftype, ref, ret)
        else:
            raise LuaPreprocessorException(
                "Wrong command: {0}".format(repr(lexer.instream.getvalue())))

    def options(self, key, value):
        if key == 'delimiter':
            self.delimiter = value[1:-1]
        else:
            raise LuaPreprocessorException(
                "Wrong option: {0}".format(repr(key)))

    def server_start(self, ctype, sname, opts):
        if sname not in self.servers:
            raise LuaPreprocessorException(
                'Can\'t start nonexistent server {0}'.format(repr(sname)))
        wait = True
        if 'wait' in opts and opts['wait'] == 'False':
            wait = False
        wait_load = True
        if 'wait_load' in opts and opts['wait_load'] == 'False':
            wait_load = False
        args = []
        if 'args' in opts:
            args = opts['args'][1:-1].split(' ')

        crash_expected = 'crash_expected' in opts and \
            opts['crash_expected'] == 'True'
        crash_occured = False
        try:
            if crash_expected:
                # disable crash detector
                self.servers[sname].crash_expected = True
            self.servers[sname].start(silent=True, rais=True, wait=wait,
                                      wait_load=wait_load, args=args)
        except Exception as e:
            crash_occured = True
            if not (crash_expected and
                    e.__class__.__name__ == 'TarantoolStartError'):
                raise
        if not crash_occured:
            self.connections[sname] = self.servers[sname].admin
            try:
                self.connections[sname]('return true', silent=True)
            except socket.error:
                LuaPreprocessorException(
                    'Can\'t start server {0}'.format(repr(sname)))
        return not crash_occured

    def server_stop(self, ctype, sname, opts):
        if sname not in self.servers:
            raise LuaPreprocessorException(
                'Can\'t stop nonexistent server {0}'.format(repr(sname)))
        if not self.servers[sname].status:
            raise LuaPreprocessorException(
                'Attempt to stop already stopped server {0}'.format(repr(sname)))
        self.connections[sname].disconnect()
        self.connections.pop(sname)
        if 'signal' in opts:
            # convert to an integer if a number is passed, leave a string
            # otherwise
            try:
                signal = int(opts['signal'])
            except ValueError:
                signal = opts['signal']
            self.servers[sname].stop(silent=True, signal=signum(signal))
        else:
            # use default signal
            self.servers[sname].stop(silent=True)

    def server_create(self, ctype, sname, opts):
        if sname in self.servers:
            raise LuaPreprocessorException(
                'Server {0} already exists'.format(repr(sname)))
        temp = self.create_server()
        temp.name = sname
        if 'need_init' in opts:
            temp.need_init = True if opts['need_init'] == 'True' else False
        if 'script' in opts:
            temp.script = opts['script'][1:-1]
        if 'lua_libs' in opts:
            temp.lua_libs = opts['lua_libs'][1:-1].split(' ')
        temp.rpl_master = None
        if 'rpl_master' in opts:
            temp.rpl_master = self.servers[opts['rpl_master']]
        temp.vardir = self.suite_ini['vardir']
        temp.use_unix_sockets_iproto = \
            self.suite_ini['use_unix_sockets_iproto']
        temp.inspector_port = int(self.suite_ini.get(
            'inspector_port', temp.DEFAULT_INSPECTOR
        ))
        if self.default_server_no_connect:
            temp.current_test = self.default_server_no_connect.current_test
        elif self.servers['default']:
            temp.current_test = self.servers['default'].current_test
        temp.install(silent=True)
        self.servers[sname] = temp
        if 'workdir' in opts:
            copy_from = opts['workdir']
            copy_to = self.servers[sname].name
            os.system('rm -rf %s/%s' % (
                self.servers[sname].vardir, copy_to
            ))
            os.system('cp -r %s %s/%s' % (
                copy_from,
                self.servers[sname].vardir,
                copy_to
            ))
        nmsp = Namespace()
        setattr(nmsp, 'admin', temp.admin.uri)
        setattr(nmsp, 'listen', temp.listen_uri)
        if temp.rpl_master:
            setattr(nmsp, 'master', temp.rpl_master.iproto.uri)
        setattr(self.environ, sname, nmsp)
        if 'return_listen_uri' in opts and opts['return_listen_uri'] == 'True':
            return self.servers[sname].listen_uri

    def server_deploy(self, ctype, sname, opts):
        self.servers[sname].install()

    def server_cleanup(self, ctype, sname, opts):
        if sname not in self.servers:
            raise LuaPreprocessorException(
                'Can\'t cleanup nonexistent server {0}'.format(repr(sname)))
        self.servers[sname].cleanup()
        if sname != 'default':
            if hasattr(self.environ, sname):
                delattr(self.environ, sname)
        else:
            self.servers[sname].install(silent=True)

    def server_delete(self, ctype, sname, opts):
        if sname not in self.servers:
            raise LuaPreprocessorException(
                'Can\'t cleanup nonexistent server {0}'.format(repr(sname)))
        self.servers[sname].cleanup()
        if sname != 'default':
            if hasattr(self.environ, sname):
                delattr(self.environ, sname)
            del self.servers[sname]

    def switch(self, server):
        self.lua_eval(server, "env=require('test_run')", silent=True)
        self.lua_eval(
            server, "test_run=env.new()", silent=True
        )
        return self.connection('set', [server, ], None)

    def server_restart(self, ctype, sname, opts):
        # self restart from lua with proxy
        if 'proxy' not in self.servers:
            self.server_create(
                'create', 'proxy', {'script': '"box/proxy.lua"'}
            )
        self.server_start('start', 'proxy', {})
        self.switch('proxy')

        # restart real server and switch back
        self.server_stop(ctype, sname, opts)
        if 'cleanup' in opts:
            self.server_cleanup(ctype, sname, opts)
            self.server_deploy(ctype, sname, opts)
        try:
            self.server_start(ctype, sname, opts)
            self.switch(sname)
        finally:
            # remove proxy
            self.server_stop('stop', 'proxy', {})

    def server_get_iproto_uri(self, ctype, sname, opts):
        return self.servers[sname].iproto.uri

    def server(self, ctype, sname, opts):
        attr = 'server_%s' % ctype
        if hasattr(self, attr):
            return getattr(self, attr)(ctype, sname, opts)
        else:
            raise LuaPreprocessorException(
                'Unknown command for server: %s' % ctype
            )

    def connection(self, ctype, cnames, sname):
        # we always get a list of connections as input here
        cname = cnames[0]
        if ctype == 'create':
            if sname not in self.servers:
                raise LuaPreprocessorException(
                    ('Can\'t create connection to nonexistent server ' +
                     '{0}').format(repr(sname)))
            if cname in self.connections:
                raise LuaPreprocessorException(
                    'Connection {0} already exists'.format(repr(cname)))
            self.connections[cname] = AdminAsyncConnection(
                'localhost', self.servers[sname].admin.port)
            self.connections[cname].connect()
        elif ctype == 'drop':
            if cname not in self.connections:
                raise LuaPreprocessorException(
                    'Can\'t drop nonexistent connection {0}'.format(
                        repr(cname)))
            self.connections[cname].disconnect()
            self.connections.pop(cname)
        elif ctype == 'set':
            for i in cnames:
                if i not in self.connections:
                    raise LuaPreprocessorException(
                        'Can\'t set nonexistent connection {0}'.format(
                            repr(cname)))
            self.curcon = [self.connections[i] for i in cnames]
        else:
            raise LuaPreprocessorException(
                'Unknown command for connection: {0}'.format(repr(ctype)))

    def filter(self, ctype, ref, ret):
        if ctype == 'push':
            sys.stdout.push_filter(ref[1:-1], ret[1:-1])
        elif ctype == 'pop':
            sys.stdout.pop_filter()
        elif ctype == 'clear':
            sys.stdout.clear_all_filters()
        else:
            raise LuaPreprocessorException(
                "Wrong command for filters: {0}".format(repr(ctype)))

    def lua_eval(self, name, expr, silent=True):
        if name not in self.servers:
            raise LuaPreprocessorException('Attempt to evaluate a command on ' +
                                           'the nonexistent server {0}'.format(
                                            repr(name)))
        self.servers[name].admin.reconnect()
        result = self.servers[name].admin(
            '%s%s' % (expr, self.delimiter), silent=silent
        )
        result = yaml.safe_load(result)
        if not result:
            result = []
        return result

    def variable(self, ctype, ref, ret):
        if ctype == 'set':
            self.curcon[0].reconnect()
            result = eval(ret[1:-1], {}, self.environ.__dict__)
            if isinstance(result, integer_types):
                cmd = '{0}={1}'.format(ref, result)
            elif isinstance(result, string_types):
                cmd = '{0}="{1}"'.format(ref, result)
            else:
                raise LuaPreprocessorException(
                    "Wrong result type for variable {0}".format(ref))
            self.curcon[0](cmd, silent=True)
        else:
            raise LuaPreprocessorException(
                "Wrong command for variables: {0}".format(repr(ctype)))

    def __call__(self, string):
        string = string[3:].strip()
        self.parse_preprocessor(string)

    def stop_nondefault(self, signal=signal.SIGTERM):
        names = [k for k in self.servers.keys() if k != 'default']
        color_log('DEBUG: Stop non-default servers using '
                  'signal {} ({}): {}\n'.format(signal, signame(signal),
                                                names), schema='info')
        if sys.stdout.__class__.__name__ == 'FilteredStream':
            sys.stdout.clear_all_filters()
        for k, v in self.servers.items():
            # don't stop the default server
            if k == 'default':
                continue
            v.stop(silent=True, signal=signal)
            if k in self.connections:
                self.connections[k].disconnect()
                self.connections.pop(k)

    def cleanup_nondefault(self):
        names = [k for k in self.servers.keys() if k != 'default']
        color_log('DEBUG: Cleanup non-default servers: {}\n'.format(names),
                  schema='info')
        for k, v in self.servers.items():
            # don't cleanup the default server
            if k == 'default':
                continue
            v.cleanup()

    def kill_current_test(self):
        if self.servers['default']:
            self.servers['default'].kill_current_test()

1	import os	1✔
2	import shlex	1✔
3	import signal	1✔
4	import sys	1✔
5	from collections import deque	1✔
6
7	import yaml	1✔
8	from gevent import socket	1✔
9
10	from lib.admin_connection import AdminAsyncConnection	1✔
11	from lib.colorer import color_log	1✔
12	from lib.utils import signum	1✔
13	from lib.utils import signame	1✔
14	from lib.utils import integer_types	1✔
15	from lib.utils import string_types	1✔
16
17
18	class Namespace(object):	1✔
19	pass	1✔
20
21
22	class LuaPreprocessorException(Exception):	1✔
23	""" Raised when evaluation of a test-run command failed.
24
25	This exception is displayed as QA notice on the terminal.
26
27	A Lua error is raised in a test code. The raised object is
28	a string with given error message.
29
30	All other errors that are raised during a command
31	evaluation are considered as show stoppers and lead to
32	stop execution of a test. KeyboardInterrupt and
33	TarantoolStartError stops testing at all, see
34	inspector.py.
35	"""
36
37	def __init__(self, val):	1✔
38	super(LuaPreprocessorException, self).__init__()	×
39	self.value = val	×
40
41	def __str__(self):	1✔
42	return self.value	×
43
44
45	class TestState(object):	1✔
46	def __init__(self, suite_ini, default_server, create_server, params={},	1✔
47	**kwargs):
48	self.delimiter = ''	1✔
49	self.suite_ini = suite_ini	1✔
50	self.environ = Namespace()	1✔
51	self.operation = False	1✔
52	self.create_server = create_server	1✔
53	self.servers = {'default': default_server}	1✔
54	self.connections = {}	1✔
55	self.run_params = params	1✔
56	if default_server is not None:	1✔
57	self.connections = {'default': default_server.admin}	1✔
58	# curcon is an array since we may have many connections
59	self.curcon = [self.connections['default']]	1✔
60	nmsp = Namespace()	1✔
61	setattr(nmsp, 'admin', default_server.admin.uri)	1✔
62	setattr(nmsp, 'listen', default_server.listen_uri)	1✔
63	setattr(self.environ, 'default', nmsp)	1✔
64	# for propagating 'current_test' to non-default servers
65	self.default_server_no_connect = kwargs.get(	1✔
66	'default_server_no_connect')
67
68	def parse_preprocessor(self, string):	1✔
69	token_store = deque()	1✔
70	lexer = shlex.shlex(string)	1✔
71	lexer.commenters = []	1✔
72	token = lexer.get_token()	1✔
73	if not token:	1!
74	return	×
75	if token == 'setopt':	1✔
76	option = lexer.get_token()	1✔
77	if not option:	1!
78	raise LuaPreprocessorException(	×
79	"Wrong token for setopt: expected option name")
80	value = lexer.get_token()	1✔
81	if not value:	1!
82	raise LuaPreprocessorException(	×
83	"Wrong token for setopt: expected option value")
84	return self.options(option, value)	1✔
85	elif token == 'eval':	1!
86	name = lexer.get_token()	×
87	expr = lexer.get_token()	×
88
89	# token format: eval <server name> "<expr>"
90	return self.lua_eval(name, expr[1:-1])	×
91	elif token == 'switch':	1!
92	server = lexer.get_token()	×
93	return self.switch(server)	×
94	elif token == 'config':	1!
95	lexer.get_token()	×
96	return self.run_params	×
97	token_store.append(token)	1✔
98	token = lexer.get_token()	1✔
99	if token == 'server':	1!
100	stype = token_store.popleft()	1✔
101	sname = lexer.get_token()	1✔
102	if not sname:	1!
103	raise LuaPreprocessorException(	×
104	"Wrong token for server: expected name")
105	options = {}	1✔
106	temp = lexer.get_token()	1✔
107	if not temp:	1✔
108	pass	1✔
109	elif temp == 'with':	1!
110	while True:
111	k = lexer.get_token()	1✔
112	if not k:	1✔
113	break	1✔
114	v = lexer.get_token()	1✔
115	if v == '=':	1!
116	v = lexer.get_token()	1✔
117	options[k] = v	1✔
118	lexer.get_token()	1✔
119	else:
120	raise LuaPreprocessorException(	×
121	"Wrong token for server: expected 'with', got {0}".format(
122	repr(temp)))
123	return self.server(stype, sname, options)	1✔
124	elif token == 'connection':	×
125	ctype = token_store.popleft()	×
126	cname = [lexer.get_token()]	×
127	if not cname[0]:	×
128	raise LuaPreprocessorException(	×
129	"Wrong token for connection: expected name")
130	cargs = None	×
131	temp = lexer.get_token()	×
132	if temp == 'to':	×
133	cargs = lexer.get_token()	×
134	elif temp == ',':	×
135	while True:
136	a = lexer.get_token()	×
137	if not a:	×
138	break	×
139	if a == ',':	×
140	continue	×
141	cname.append(a)	×
142	elif temp:	×
143	raise LuaPreprocessorException(	×
144	("Wrong token for server: expected 'to' or ',', " +
145	"got {0}").format(repr(temp)))
146	return self.connection(ctype, cname, cargs)	×
147	elif token == 'filter':	×
148	ftype = token_store.popleft()	×
149	ref = None	×
150	ret = None	×
151	temp = lexer.get_token()	×
152	if temp:	×
153	ref = temp	×
154	if not temp:	×
155	raise LuaPreprocessorException(	×
156	"Wrong token for filter: expected filter1")
157	if lexer.get_token() != 'to':	×
158	raise LuaPreprocessorException(	×
159	("Wrong token for filter: expected 'to', " +
160	"got {0}").format(repr(temp)))
161	temp = lexer.get_token()	×
162	if not temp:	×
163	raise LuaPreprocessorException(	×
164	"Wrong token for filter: expected filter2")
165	ret = temp	×
166	return self.filter(ftype, ref, ret)	×
167	elif token == 'variable':	×
168	ftype = token_store.popleft()	×
169	ref = lexer.get_token()	×
170	temp = lexer.get_token()	×
171	if temp != 'to':	×
172	raise LuaPreprocessorException(	×
173	"Wrong token for filter: exptected 'to', got {0}".format(
174	repr(temp)))
175	ret = lexer.get_token()	×
176	return self.variable(ftype, ref, ret)	×
177	else:
178	raise LuaPreprocessorException(	×
179	"Wrong command: {0}".format(repr(lexer.instream.getvalue())))
180
181	def options(self, key, value):	1✔
182	if key == 'delimiter':	1!
183	self.delimiter = value[1:-1]	1✔
184	else:
185	raise LuaPreprocessorException(	×
186	"Wrong option: {0}".format(repr(key)))
187
188	def server_start(self, ctype, sname, opts):	1✔
189	if sname not in self.servers:	1!
190	raise LuaPreprocessorException(	×
191	'Can\'t start nonexistent server {0}'.format(repr(sname)))
192	wait = True	1✔
193	if 'wait' in opts and opts['wait'] == 'False':	1!
194	wait = False	×
195	wait_load = True	1✔
196	if 'wait_load' in opts and opts['wait_load'] == 'False':	1!
197	wait_load = False	×
198	args = []	1✔
199	if 'args' in opts:	1!
200	args = opts['args'][1:-1].split(' ')	×
201
202	crash_expected = 'crash_expected' in opts and \	1✔
203	opts['crash_expected'] == 'True'
204	crash_occured = False	1✔
205	try:	1✔
206	if crash_expected:	1!
207	# disable crash detector
208	self.servers[sname].crash_expected = True	×
209	self.servers[sname].start(silent=True, rais=True, wait=wait,	1✔
210	wait_load=wait_load, args=args)
211	except Exception as e:	×
212	crash_occured = True	×
213	if not (crash_expected and	×
214	e.__class__.__name__ == 'TarantoolStartError'):
215	raise	×
216	if not crash_occured:	1!
217	self.connections[sname] = self.servers[sname].admin	1✔
218	try:	1✔
219	self.connections[sname]('return true', silent=True)	1✔
220	except socket.error:	×
221	LuaPreprocessorException(	×
222	'Can\'t start server {0}'.format(repr(sname)))
223	return not crash_occured	1✔
224
225	def server_stop(self, ctype, sname, opts):	1✔
226	if sname not in self.servers:	1!
227	raise LuaPreprocessorException(	×
228	'Can\'t stop nonexistent server {0}'.format(repr(sname)))
229	if not self.servers[sname].status:	1!
230	raise LuaPreprocessorException(	×
231	'Attempt to stop already stopped server {0}'.format(repr(sname)))
232	self.connections[sname].disconnect()	1✔
233	self.connections.pop(sname)	1✔
234	if 'signal' in opts:	1!
235	# convert to an integer if a number is passed, leave a string
236	# otherwise
237	try:	×
238	signal = int(opts['signal'])	×
239	except ValueError:	×
240	signal = opts['signal']	×
241	self.servers[sname].stop(silent=True, signal=signum(signal))	×
242	else:
243	# use default signal
244	self.servers[sname].stop(silent=True)	1✔
245
246	def server_create(self, ctype, sname, opts):	1✔
247	if sname in self.servers:	1!
248	raise LuaPreprocessorException(	×
249	'Server {0} already exists'.format(repr(sname)))
250	temp = self.create_server()	1✔
251	temp.name = sname	1✔
252	if 'need_init' in opts:	1!
253	temp.need_init = True if opts['need_init'] == 'True' else False	×
254	if 'script' in opts:	1!
255	temp.script = opts['script'][1:-1]	1✔
256	if 'lua_libs' in opts:	1!
257	temp.lua_libs = opts['lua_libs'][1:-1].split(' ')	×
258	temp.rpl_master = None	1✔
259	if 'rpl_master' in opts:	1!
260	temp.rpl_master = self.servers[opts['rpl_master']]	1✔
261	temp.vardir = self.suite_ini['vardir']	1✔
262	temp.use_unix_sockets_iproto = \	1✔
263	self.suite_ini['use_unix_sockets_iproto']
264	temp.inspector_port = int(self.suite_ini.get(	1✔
265	'inspector_port', temp.DEFAULT_INSPECTOR
266	))
267	if self.default_server_no_connect:	1!
268	temp.current_test = self.default_server_no_connect.current_test	×
269	elif self.servers['default']:	1!
270	temp.current_test = self.servers['default'].current_test	1✔
271	temp.install(silent=True)	1✔
272	self.servers[sname] = temp	1✔
273	if 'workdir' in opts:	1!
274	copy_from = opts['workdir']	×
275	copy_to = self.servers[sname].name	×
276	os.system('rm -rf %s/%s' % (	×
277	self.servers[sname].vardir, copy_to
278	))
279	os.system('cp -r %s %s/%s' % (	×
280	copy_from,
281	self.servers[sname].vardir,
282	copy_to
283	))
284	nmsp = Namespace()	1✔
285	setattr(nmsp, 'admin', temp.admin.uri)	1✔
286	setattr(nmsp, 'listen', temp.listen_uri)	1✔
287	if temp.rpl_master:	1!
288	setattr(nmsp, 'master', temp.rpl_master.iproto.uri)	1✔
289	setattr(self.environ, sname, nmsp)	1✔
290	if 'return_listen_uri' in opts and opts['return_listen_uri'] == 'True':	1!
291	return self.servers[sname].listen_uri	×
292
293	def server_deploy(self, ctype, sname, opts):	1✔
294	self.servers[sname].install()	×
295
296	def server_cleanup(self, ctype, sname, opts):	1✔
297	if sname not in self.servers:	1!
298	raise LuaPreprocessorException(	×
299	'Can\'t cleanup nonexistent server {0}'.format(repr(sname)))
300	self.servers[sname].cleanup()	1✔
301	if sname != 'default':	1!
302	if hasattr(self.environ, sname):	1!
303	delattr(self.environ, sname)	1✔
304	else:
305	self.servers[sname].install(silent=True)	×
306
307	def server_delete(self, ctype, sname, opts):	1✔
308	if sname not in self.servers:	1!
309	raise LuaPreprocessorException(	×
310	'Can\'t cleanup nonexistent server {0}'.format(repr(sname)))
311	self.servers[sname].cleanup()	1✔
312	if sname != 'default':	1!
313	if hasattr(self.environ, sname):	1!
314	delattr(self.environ, sname)	×
315	del self.servers[sname]	1✔
316
317	def switch(self, server):	1✔
318	self.lua_eval(server, "env=require('test_run')", silent=True)	×
319	self.lua_eval(	×
320	server, "test_run=env.new()", silent=True
321	)
322	return self.connection('set', [server, ], None)	×
323
324	def server_restart(self, ctype, sname, opts):	1✔
325	# self restart from lua with proxy
326	if 'proxy' not in self.servers:	×
327	self.server_create(	×
328	'create', 'proxy', {'script': '"box/proxy.lua"'}
329	)
330	self.server_start('start', 'proxy', {})	×
331	self.switch('proxy')	×
332
333	# restart real server and switch back
334	self.server_stop(ctype, sname, opts)	×
335	if 'cleanup' in opts:	×
336	self.server_cleanup(ctype, sname, opts)	×
337	self.server_deploy(ctype, sname, opts)	×
338	try:	×
339	self.server_start(ctype, sname, opts)	×
340	self.switch(sname)	×
341	finally:
342	# remove proxy
343	self.server_stop('stop', 'proxy', {})	×
344
345	def server_get_iproto_uri(self, ctype, sname, opts):	1✔
346	return self.servers[sname].iproto.uri	×
347
348	def server(self, ctype, sname, opts):	1✔
349	attr = 'server_%s' % ctype	1✔
350	if hasattr(self, attr):	1!
351	return getattr(self, attr)(ctype, sname, opts)	1✔
352	else:
353	raise LuaPreprocessorException(	×
354	'Unknown command for server: %s' % ctype
355	)
356
357	def connection(self, ctype, cnames, sname):	1✔
358	# we always get a list of connections as input here
359	cname = cnames[0]	×
360	if ctype == 'create':	×
361	if sname not in self.servers:	×
362	raise LuaPreprocessorException(	×
363	('Can\'t create connection to nonexistent server ' +
364	'{0}').format(repr(sname)))
365	if cname in self.connections:	×
366	raise LuaPreprocessorException(	×
367	'Connection {0} already exists'.format(repr(cname)))
368	self.connections[cname] = AdminAsyncConnection(	×
369	'localhost', self.servers[sname].admin.port)
370	self.connections[cname].connect()	×
371	elif ctype == 'drop':	×
372	if cname not in self.connections:	×
373	raise LuaPreprocessorException(	×
374	'Can\'t drop nonexistent connection {0}'.format(
375	repr(cname)))
376	self.connections[cname].disconnect()	×
377	self.connections.pop(cname)	×
378	elif ctype == 'set':	×
379	for i in cnames:	×
380	if i not in self.connections:	×
381	raise LuaPreprocessorException(	×
382	'Can\'t set nonexistent connection {0}'.format(
383	repr(cname)))
384	self.curcon = [self.connections[i] for i in cnames]	×
385	else:
386	raise LuaPreprocessorException(	×
387	'Unknown command for connection: {0}'.format(repr(ctype)))
388
389	def filter(self, ctype, ref, ret):	1✔
390	if ctype == 'push':	×
391	sys.stdout.push_filter(ref[1:-1], ret[1:-1])	×
392	elif ctype == 'pop':	×
393	sys.stdout.pop_filter()	×
394	elif ctype == 'clear':	×
395	sys.stdout.clear_all_filters()	×
396	else:
397	raise LuaPreprocessorException(	×
398	"Wrong command for filters: {0}".format(repr(ctype)))
399
400	def lua_eval(self, name, expr, silent=True):	1✔
401	if name not in self.servers:	×
402	raise LuaPreprocessorException('Attempt to evaluate a command on ' +	×
403	'the nonexistent server {0}'.format(
404	repr(name)))
405	self.servers[name].admin.reconnect()	×
406	result = self.servers[name].admin(	×
407	'%s%s' % (expr, self.delimiter), silent=silent
408	)
409	result = yaml.safe_load(result)	×
410	if not result:	×
411	result = []	×
412	return result	×
413
414	def variable(self, ctype, ref, ret):	1✔
415	if ctype == 'set':	×
416	self.curcon[0].reconnect()	×
417	result = eval(ret[1:-1], {}, self.environ.__dict__)	×
418	if isinstance(result, integer_types):	×
419	cmd = '{0}={1}'.format(ref, result)	×
420	elif isinstance(result, string_types):	×
421	cmd = '{0}="{1}"'.format(ref, result)	×
422	else:
423	raise LuaPreprocessorException(	×
424	"Wrong result type for variable {0}".format(ref))
425	self.curcon[0](cmd, silent=True)	×
426	else:
427	raise LuaPreprocessorException(	×
428	"Wrong command for variables: {0}".format(repr(ctype)))
429
430	def __call__(self, string):	1✔
431	string = string[3:].strip()	×
432	self.parse_preprocessor(string)	×
433
434	def stop_nondefault(self, signal=signal.SIGTERM):	1✔
435	names = [k for k in self.servers.keys() if k != 'default']	1✔
436	color_log('DEBUG: Stop non-default servers using '	1✔
437	'signal {} ({}): {}\n'.format(signal, signame(signal),
438	names), schema='info')
439	if sys.stdout.__class__.__name__ == 'FilteredStream':	1!
440	sys.stdout.clear_all_filters()	1✔
441	for k, v in self.servers.items():	1✔
442	# don't stop the default server
443	if k == 'default':	1!
444	continue	1✔
445	v.stop(silent=True, signal=signal)	×
446	if k in self.connections:	×
447	self.connections[k].disconnect()	×
448	self.connections.pop(k)	×
449
450	def cleanup_nondefault(self):	1✔
451	names = [k for k in self.servers.keys() if k != 'default']	1✔
452	color_log('DEBUG: Cleanup non-default servers: {}\n'.format(names),	1✔
453	schema='info')
454	for k, v in self.servers.items():	1✔
455	# don't cleanup the default server
456	if k == 'default':	1!
457	continue	1✔
458	v.cleanup()	×
459
460	def kill_current_test(self):	1✔
461	if self.servers['default']:	×
462	self.servers['default'].kill_current_test()	×

tarantool / test-run / 3685840692

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous