1# Copyright Martin J. Bligh, Andy Whitcroft, 2007
2#
3# Define the server-side test class
4#
5
6import os, tempfile, logging
7
8from autotest_lib.client.common_lib import log, utils, test as common_test
9
10
11class test(common_test.base_test):
12    disable_sysinfo_install_cache = False
13    host_parameter = None
14
15
16_sysinfo_before_test_script = """\
17import pickle
18from autotest_lib.client.bin import test
19mytest = test.test(job, '', %r)
20job.sysinfo.log_before_each_test(mytest)
21sysinfo_pickle = os.path.join(mytest.outputdir, 'sysinfo.pickle')
22pickle.dump(job.sysinfo, open(sysinfo_pickle, 'w'))
23job.record('GOOD', '', 'sysinfo.before')
24"""
25
26_sysinfo_after_test_script = """\
27import pickle
28from autotest_lib.client.bin import test
29mytest = test.test(job, '', %r)
30# success is passed in so diffable_logdir can decide if or not to collect
31# full log content.
32mytest.success = %s
33sysinfo_pickle = os.path.join(mytest.outputdir, 'sysinfo.pickle')
34if os.path.exists(sysinfo_pickle):
35    job.sysinfo = pickle.load(open(sysinfo_pickle))
36    job.sysinfo.__init__(job.resultdir)
37job.sysinfo.log_after_each_test(mytest)
38job.record('GOOD', '', 'sysinfo.after')
39"""
40
41# this script is ran after _sysinfo_before_test_script and before
42# _sysinfo_after_test_script which means the pickle file exists
43# already and should be dumped with updated state for
44# _sysinfo_after_test_script to pick it up later
45_sysinfo_iteration_script = """\
46import pickle
47from autotest_lib.client.bin import test
48mytest = test.test(job, '', %r)
49sysinfo_pickle = os.path.join(mytest.outputdir, 'sysinfo.pickle')
50if os.path.exists(sysinfo_pickle):
51    job.sysinfo = pickle.load(open(sysinfo_pickle))
52    job.sysinfo.__init__(job.resultdir)
53job.sysinfo.%s(mytest, iteration=%d)
54pickle.dump(job.sysinfo, open(sysinfo_pickle, 'w'))
55job.record('GOOD', '', 'sysinfo.iteration.%s')
56"""
57
58
59def install_autotest_and_run(func):
60    def wrapper(self, mytest):
61        host, at, outputdir = self._install()
62        # TODO(kevcheng): remove when host client install is supported for
63        # ADBHost. crbug.com/543702
64        if not host.is_client_install_supported:
65            logging.debug('host client install not supported, skipping %s:',
66                          func.__name__)
67            return
68
69        try:
70            host.erase_dir_contents(outputdir)
71            func(self, mytest, host, at, outputdir)
72        finally:
73            # the test class can define this flag to make us remove the
74            # sysinfo install files and outputdir contents after each run
75            if mytest.disable_sysinfo_install_cache:
76                self.cleanup(host_close=False)
77
78    return wrapper
79
80
81class _sysinfo_logger(object):
82    def __init__(self, job):
83        self.job = job
84        self.pickle = None
85
86        # for now support a single host
87        self.host = None
88        self.autotest = None
89        self.outputdir = None
90
91        if len(job.machines) != 1:
92            # disable logging on multi-machine tests
93            self.before_hook = self.after_hook = None
94            self.before_iteration_hook = self.after_iteration_hook = None
95
96
97    def _install(self):
98        if not self.host:
99            from autotest_lib.server import hosts, autotest
100            self.host = hosts.create_target_machine(
101                    self.job.machine_dict_list[0])
102            # TODO(kevcheng): remove when host client install is supported for
103            # ADBHost. crbug.com/543702
104            if not self.host.is_client_install_supported:
105                return self.host, None, None
106            try:
107                tmp_dir = self.host.get_tmp_dir(parent="/tmp/sysinfo")
108                self.autotest = autotest.Autotest(self.host)
109                self.autotest.install(autodir=tmp_dir)
110                self.outputdir = self.host.get_tmp_dir()
111            except:
112                # if installation fails roll back the host
113                try:
114                    self.host.close()
115                except:
116                    logging.exception("Unable to close host %s",
117                                      self.host.hostname)
118                self.host = None
119                self.autotest = None
120                raise
121        else:
122            # TODO(kevcheng): remove when host client install is supported for
123            # ADBHost. crbug.com/543702
124            if not self.host.is_client_install_supported:
125                return self.host, None, None
126
127            # if autotest client dir does not exist, reinstall (it may have
128            # been removed by the test code)
129            autodir = self.host.get_autodir()
130            if not autodir or not self.host.path_exists(autodir):
131                self.autotest.install(autodir=autodir)
132
133            # if the output dir does not exist, recreate it
134            if not self.host.path_exists(self.outputdir):
135                self.host.run('mkdir -p %s' % self.outputdir)
136
137        return self.host, self.autotest, self.outputdir
138
139
140    def _pull_pickle(self, host, outputdir):
141        """Pulls from the client the pickle file with the saved sysinfo state.
142        """
143        fd, path = tempfile.mkstemp(dir=self.job.tmpdir)
144        os.close(fd)
145        host.get_file(os.path.join(outputdir, "sysinfo.pickle"), path)
146        self.pickle = path
147
148
149    def _push_pickle(self, host, outputdir):
150        """Pushes the server saved sysinfo pickle file to the client.
151        """
152        if self.pickle:
153            host.send_file(self.pickle,
154                           os.path.join(outputdir, "sysinfo.pickle"))
155            os.remove(self.pickle)
156            self.pickle = None
157
158
159    def _pull_sysinfo_keyval(self, host, outputdir, mytest):
160        """Pulls sysinfo and keyval data from the client.
161        """
162        # pull the sysinfo data back on to the server
163        host.get_file(os.path.join(outputdir, "sysinfo"), mytest.outputdir)
164
165        # pull the keyval data back into the local one
166        fd, path = tempfile.mkstemp(dir=self.job.tmpdir)
167        os.close(fd)
168        host.get_file(os.path.join(outputdir, "keyval"), path)
169        keyval = utils.read_keyval(path)
170        os.remove(path)
171        mytest.write_test_keyval(keyval)
172
173
174    @log.log_and_ignore_errors("pre-test server sysinfo error:")
175    @install_autotest_and_run
176    def before_hook(self, mytest, host, at, outputdir):
177        # run the pre-test sysinfo script
178        at.run(_sysinfo_before_test_script % outputdir,
179               results_dir=self.job.resultdir)
180
181        self._pull_pickle(host, outputdir)
182
183
184    @log.log_and_ignore_errors("pre-test iteration server sysinfo error:")
185    @install_autotest_and_run
186    def before_iteration_hook(self, mytest, host, at, outputdir):
187        # this function is called after before_hook() se we have sysinfo state
188        # to push to the server
189        self._push_pickle(host, outputdir);
190        # run the pre-test iteration sysinfo script
191        at.run(_sysinfo_iteration_script %
192               (outputdir, 'log_before_each_iteration', mytest.iteration,
193                'before'),
194               results_dir=self.job.resultdir)
195
196        # get the new sysinfo state from the client
197        self._pull_pickle(host, outputdir)
198
199
200    @log.log_and_ignore_errors("post-test iteration server sysinfo error:")
201    @install_autotest_and_run
202    def after_iteration_hook(self, mytest, host, at, outputdir):
203        # push latest sysinfo state to the client
204        self._push_pickle(host, outputdir);
205        # run the post-test iteration sysinfo script
206        at.run(_sysinfo_iteration_script %
207               (outputdir, 'log_after_each_iteration', mytest.iteration,
208                'after'),
209               results_dir=self.job.resultdir)
210
211        # get the new sysinfo state from the client
212        self._pull_pickle(host, outputdir)
213
214
215    @log.log_and_ignore_errors("post-test server sysinfo error:")
216    @install_autotest_and_run
217    def after_hook(self, mytest, host, at, outputdir):
218        self._push_pickle(host, outputdir);
219        # run the post-test sysinfo script
220        at.run(_sysinfo_after_test_script % (outputdir, mytest.success),
221               results_dir=self.job.resultdir)
222
223        self._pull_sysinfo_keyval(host, outputdir, mytest)
224
225
226    def cleanup(self, host_close=True):
227        if self.host and self.autotest:
228            try:
229                try:
230                    self.autotest.uninstall()
231                finally:
232                    if host_close:
233                        self.host.close()
234                    else:
235                        self.host.erase_dir_contents(self.outputdir)
236
237            except Exception:
238                # ignoring exceptions here so that we don't hide the true
239                # reason of failure from runtest
240                logging.exception('Error cleaning up the sysinfo autotest/host '
241                                  'objects, ignoring it')
242
243
244def runtest(job, url, tag, args, dargs):
245    """Server-side runtest.
246
247    @param job: A server_job instance.
248    @param url: URL to the test.
249    @param tag: Test tag that will be appended to the test name.
250                See client/common_lib/test.py:runtest
251    @param args: args to pass to the test.
252    @param dargs: key-val based args to pass to the test.
253    """
254
255    disable_before_test_hook = dargs.pop('disable_before_test_sysinfo', False)
256    disable_after_test_hook = dargs.pop('disable_after_test_sysinfo', False)
257    disable_before_iteration_hook = dargs.pop(
258            'disable_before_iteration_sysinfo', False)
259    disable_after_iteration_hook = dargs.pop(
260            'disable_after_iteration_sysinfo', False)
261
262    if not dargs.pop('disable_sysinfo', False):
263        logger = _sysinfo_logger(job)
264        logging_args = [
265            logger.before_hook if not disable_before_test_hook else None,
266            logger.after_hook if not disable_after_test_hook else None,
267            (logger.before_iteration_hook
268                 if not disable_before_iteration_hook else None),
269            (logger.after_iteration_hook
270                 if not disable_after_iteration_hook else None),
271        ]
272    else:
273        logger = None
274        logging_args = [None, None, None, None]
275
276    # add in a hook that calls host.log_kernel if we can
277    def log_kernel_hook(mytest, existing_hook=logging_args[0]):
278        if mytest.host_parameter:
279            host = dargs[mytest.host_parameter]
280            if host:
281                host.log_kernel()
282        # chain this call with any existing hook
283        if existing_hook:
284            existing_hook(mytest)
285    logging_args[0] = log_kernel_hook
286
287    try:
288        common_test.runtest(job, url, tag, args, dargs, locals(), globals(),
289                            *logging_args)
290    finally:
291        if logger:
292            logger.cleanup()
293