reporter.py@ 56971

Last change on this file since 56971 was 56721, checked in by vboxsync, 9 years ago
only two , three prefixing is used elsewhere.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 46.2 KB

Line
1	# -- coding: utf-8 --
2	# $Id: reporter.py 56721 2015-07-01 06:10:52Z vboxsync $
3	# pylint: disable=C0302
4
5	"""
6	Testdriver reporter module.
7	"""
8
9	__copyright__ = \
10	"""
11	Copyright (C) 2010-2015 Oracle Corporation
12
13	This file is part of VirtualBox Open Source Edition (OSE), as
14	available from http://www.virtualbox.org. This file is free software;
15	you can redistribute it and/or modify it under the terms of the GNU
16	General Public License (GPL) as published by the Free Software
17	Foundation, in version 2 as it comes in the "COPYING" file of the
18	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20
21	The contents of this file may alternatively be used under the terms
22	of the Common Development and Distribution License Version 1.0
23	(CDDL) only, as it comes in the "COPYING.CDDL" file of the
24	VirtualBox OSE distribution, in which case the provisions of the
25	CDDL are applicable instead of those of the GPL.
26
27	You may elect to license modified versions of this file under the
28	terms and conditions of either the GPL or the CDDL or both.
29	"""
30	__version__ = "$Revision: 56721 $"
31
32
33	# Standard Python imports.
34	import array
35	import datetime
36	import errno
37	import os
38	import os.path
39	import sys
40	import time
41	import threading
42	import traceback
43
44	# Validation Kit imports.
45	from common import utils;
46
47	## test reporter instance
48	g_oReporter = None;
49	g_sReporterName = None;
50	g_oLock = threading.Lock();
51
52
53
54	class PythonLoggingStream(object):
55	"""
56	Python logging => testdriver/reporter.py stream.
57	"""
58
59	def write(self, sText):
60	"""Writes python log message to our stream."""
61	if g_oReporter != None:
62	sText = sText.rstrip("\r\n");
63	#g_oReporter.log(0, 'python: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
64	return True;
65
66	def flush(self):
67	"""Flushes the stream."""
68	return True;
69
70
71	class ReporterBase(object):
72	"""
73	Base class for the reporters.
74	"""
75
76	def __init__(self):
77	self.iVerbose = 1;
78	self.iDebug = 0;
79	self.cErrors = 0;
80	self.fTimedOut = False; # Once set, it trickles all the way up.
81	self.atTests = [];
82	self.sName = os.path.splitext(os.path.basename(sys.argv[0]))[0];
83
84	# Hook into the python logging.
85	import logging;
86	logging.basicConfig(stream = PythonLoggingStream(),
87	level = logging.DEBUG,
88	format = '%(name)-12s %(levelname)-8s %(message)s');
89	#
90	# Introspection and configuration.
91	#
92
93	def isLocal(self):
94	"""Is this a local reporter?"""
95	return False;
96
97	def incVerbosity(self):
98	"""Increases the verbosity level."""
99	self.iVerbose += 1;
100
101	def incDebug(self):
102	"""Increases the debug level."""
103	self.iDebug += 1;
104
105	#
106	# Generic logging.
107	#
108
109	def log(self, iLevel, sText, sCaller, sTsPrf):
110	"""
111	Writes the specfied text to the log if iLevel is less or requal
112	to iVerbose.
113	"""
114	_ = iLevel; _ = sText; _ = sCaller; _ = sTsPrf;
115	return 0;
116
117	#
118	# XML output from the reporter.
119	#
120
121	def _xmlEscAttr(self, sValue):
122	"""Escapes an XML attribute value."""
123	sValue = sValue.replace('&', '&');
124	sValue = sValue.replace('<', '<');
125	sValue = sValue.replace('>', '>');
126	#sValue = sValue.replace('\'', ''');
127	sValue = sValue.replace('"', '"');
128	sValue = sValue.replace('\n', '&#xA');
129	sValue = sValue.replace('\r', '&#xD');
130	return sValue;
131
132	def _xmlWrite(self, asText, fIndent = True):
133	"""XML output function for the reporter."""
134	_ = asText; _ = fIndent;
135	return None;
136
137	def xmlFlush(self, fRetry = False, fForce = False):
138	"""Flushes XML output if buffered."""
139	_ = fRetry; _ = fForce;
140	return None;
141
142	#
143	# XML output from child.
144	#
145
146	def subXmlStart(self, oFileWrapper):
147	"""Called by the file wrapper when the first bytes are written to the test pipe."""
148	_ = oFileWrapper;
149	return None;
150
151	def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
152	"""Called by the file wrapper write method for test pipes."""
153	return self.log(0, 'raw xml%s: %s' % (oFileWrapper.sPrefix, sRawXml), sCaller, utils.getTimePrefix());
154
155	def subXmlEnd(self, oFileWrapper):
156	"""Called by the file wrapper __del__ method for test pipes."""
157	_ = oFileWrapper;
158	return None;
159
160	#
161	# File output.
162	#
163
164	def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
165	"""
166	Adds the file to the report.
167	Returns True on success, False on failure.
168	"""
169	_ = oSrcFile; _ = sSrcFilename; _ = sAltName; _ = sDescription; _ = sKind; _ = sCaller; _ = sTsPrf;
170	return True;
171
172	#
173	# Test reporting
174	#
175
176	def _testGetFullName(self):
177	"""
178	Mangles the test names in atTest into a single name to make it easier
179	to spot where we are.
180	"""
181	sName = '';
182	for t in self.atTests:
183	if sName != '':
184	sName += ', ';
185	sName += t[0];
186	return sName;
187
188	def testIncErrors(self):
189	"""Increates the error count."""
190	self.cErrors += 1;
191	return self.cErrors;
192
193	def testSetTimedOut(self):
194	"""Sets time out indicator for the current test and increases the error counter."""
195	self.fTimedOut = True;
196	self.cErrors += 1;
197	return None;
198
199	def testStart(self, sName, sCaller):
200	""" Starts a new test, may be nested. """
201	(sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
202	self._xmlWrite([ '<Test timestamp="%s" name="%s">' % (sTsIso, self._xmlEscAttr(sName),), ]);
203	self.atTests.append((sName, self.cErrors, self.fTimedOut));
204	self.fTimedOut = False;
205	return self.log(1, ' %-50s: TESTING' % (self._testGetFullName()), sCaller, sTsPrf);
206
207	def testValue(self, sName, sValue, sUnit, sCaller):
208	""" Reports a benchmark value or something simiarlly useful. """
209	(sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
210	self._xmlWrite([ '<Value timestamp="%s" name="%s" unit="%s" value="%s"/>'
211	% (sTsIso, self._xmlEscAttr(sName), self._xmlEscAttr(sUnit), self._xmlEscAttr(sValue)), ]);
212	return self.log(0, '** %-48s: %12s %s' % (sName, sValue, sUnit), sCaller, sTsPrf);
213
214	def testFailure(self, sDetails, sCaller):
215	""" Reports a failure. """
216	(sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
217	self.cErrors = self.cErrors + 1;
218	self._xmlWrite([ '<FailureDetails timestamp="%s" text="%s"/>' % (sTsIso, self._xmlEscAttr(sDetails),), ]);
219	return self.log(0, sDetails, sCaller, sTsPrf);
220
221	def testDone(self, fSkipped, sCaller):
222	"""
223	Marks the current test as DONE, pops it and maks the next test on the
224	stack current.
225	Returns (name, errors).
226	"""
227	(sTsPrf, sTsIso) = utils.getTimePrefixAndIsoTimestamp();
228	sFullName = self._testGetFullName();
229
230	# safe pop
231	if len(self.atTests) <= 0:
232	self.log(0, 'testDone on empty test stack!', sCaller, sTsPrf);
233	return ('internal error', 0);
234	fTimedOut = self.fTimedOut;
235	sName, cErrorsStart, self.fTimedOut = self.atTests.pop();
236
237	# log + xml.
238	cErrors = self.cErrors - cErrorsStart;
239	if cErrors == 0:
240	if fSkipped is not True:
241	self._xmlWrite([ ' <Passed timestamp="%s"/>' % (sTsIso,), '</Test>' ],);
242	self.log(1, '** %-50s: PASSED' % (sFullName,), sCaller, sTsPrf);
243	else:
244	self._xmlWrite([ ' <Skipped timestamp="%s"/>' % (sTsIso,), '</Test>' ]);
245	self.log(1, '** %-50s: SKIPPED' % (sFullName,), sCaller, sTsPrf);
246	elif fTimedOut:
247	self._xmlWrite([ ' <TimedOut timestamp="%s" errors="%d"/>' % (sTsIso, cErrors), '</Test>' ]);
248	self.log(0, '** %-50s: TIMED-OUT - %d errors' % (sFullName, cErrors), sCaller, sTsPrf);
249	else:
250	self._xmlWrite([ ' <Failed timestamp="%s" errors="%d"/>' % (sTsIso, cErrors), '</Test>' ]);
251	self.log(0, '** %-50s: FAILED - %d errors' % (sFullName, cErrors), sCaller, sTsPrf);
252
253	# Flush buffers when reaching the last test.
254	if len(self.atTests) == 0:
255	self.xmlFlush(fRetry = True);
256
257	return (sName, cErrors);
258
259	def testErrorCount(self):
260	"""
261	Returns the number of errors accumulated by the current test.
262	"""
263	cTests = len(self.atTests);
264	if cTests <= 0:
265	return self.cErrors;
266	return self.cErrors - self.atTests[cTests - 1][1];
267
268	def testCleanup(self, sCaller):
269	"""
270	Closes all open test as failed.
271	Returns True if no open tests, False if there were open tests.
272	"""
273	if len(self.atTests) == 0:
274	return True;
275	for _ in range(len(self.atTests)):
276	self.testFailure('Test not closed by test drver', sCaller)
277	self.testDone(False, sCaller);
278	return False;
279
280
281
282	class LocalReporter(ReporterBase):
283	"""
284	Local reporter instance.
285	"""
286
287	def __init__(self):
288	ReporterBase.__init__(self);
289	self.oLogFile = None;
290	self.oXmlFile = None;
291	self.fXmlOk = True;
292	self.iSubXml = 0;
293	self.iOtherFile = 0;
294	self.fnGetIsoTimestamp = utils.getIsoTimestamp; # Hack to get a timestamp in __del__.
295	self.oStdErr = sys.stderr; # Hack for __del__ output.
296
297	#
298	# Figure the main log directory.
299	#
300	try:
301	import user;
302	self.sDefLogDir = os.path.abspath(os.path.join(user.home, "VBoxTestLogs"));
303	except:
304	self.sDefLogDir = os.path.abspath("VBoxTestLogs");
305	try:
306	sLogDir = os.path.abspath(os.environ.get('TESTBOX_REPORTER_LOG_DIR', self.sDefLogDir));
307	if not os.path.isdir(sLogDir):
308	os.makedirs(sLogDir, 0750);
309	except:
310	sLogDir = self.sDefLogDir;
311	if not os.path.isdir(sLogDir):
312	os.makedirs(sLogDir, 0750);
313
314	#
315	# Make a subdirectory for this test run.
316	#
317	sTs = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%S.log');
318	self.sLogDir = sLogDir = os.path.join(sLogDir, '%s-%s' % (sTs, self.sName));
319	try:
320	os.makedirs(self.sLogDir, 0750);
321	except:
322	self.sLogDir = '%s-%s' % (self.sLogDir, os.getpid());
323	os.makedirs(self.sLogDir, 0750);
324
325	#
326	# Open the log file and write a header.
327	#
328	sLogName = os.path.join(self.sLogDir, 'testsuite.log');
329	sTsIso = utils.getIsoTimestamp();
330	self.oLogFile = utils.openNoInherit(sLogName, "w");
331	self.oLogFile.write(('Created log file at %s.\nRunning: %s' % (sTsIso, sys.argv)).encode('utf-8'));
332
333	#
334	# Open the xml log file and write the mandatory introduction.
335	#
336	# Note! This is done here and not in the base class because the remote
337	# logger doesn't really need this. It doesn't need the outer
338	# test wrapper either.
339	#
340	sXmlName = os.path.join(self.sLogDir, 'testsuite.xml');
341	self.oXmlFile = utils.openNoInherit(sXmlName, "w");
342	self._xmlWrite([ '<?xml version="1.0" encoding="UTF-8" ?>',
343	'<Test timestamp="%s" name="%s">' % (sTsIso, self._xmlEscAttr(self.sName),), ],
344	fIndent = False);
345
346	def __del__(self):
347	"""Ends and completes the log files."""
348	try: sTsIso = self.fnGetIsoTimestamp();
349	except Exception, oXcpt:
350	sTsIso = str(oXcpt);
351
352	if self.oLogFile is not None:
353	try:
354	self.oLogFile.write(('\nThe End %s\n' % (sTsIso,)).encode('utf-8'));
355	self.oLogFile.close();
356	except: pass;
357	self.oLogFile = None;
358
359	if self.oXmlFile is not None:
360	self._closeXml(sTsIso);
361	self.oXmlFile = None;
362
363	def _closeXml(self, sTsIso):
364	"""Closes the XML file."""
365	if self.oXmlFile is not None:
366	# pop the test stack
367	while len(self.atTests) > 0:
368	sName, cErrorsStart, self.fTimedOut = self.atTests.pop();
369	self._xmlWrite([ '<End timestamp="%s" errors="%d"/>' % (sTsIso, self.cErrors - cErrorsStart,),
370	'</%s>' % (sName,), ]);
371
372	# The outer one is not on the stack.
373	self._xmlWrite([ ' <End timestamp="%s"/>' % (sTsIso,),
374	'</Test>', ], fIndent = False);
375	try:
376	self.oXmlFile.close();
377	self.oXmlFile = None;
378	except:
379	pass;
380
381	def _xmlWrite(self, asText, fIndent = True):
382	"""Writes to the XML file."""
383	for sText in asText:
384	if fIndent:
385	sIndent = ''.ljust((len(self.atTests) + 1) * 2);
386	sText = sIndent + sText;
387	sText += '\n';
388
389	try:
390	self.oXmlFile.write(sText.encode('utf-8'));
391	except:
392	if self.fXmlOk:
393	traceback.print_exc();
394	self.fXmlOk = False;
395	return False;
396	return True;
397
398	#
399	# Overridden methods.
400	#
401
402	def isLocal(self):
403	"""Is this a local reporter?"""
404	return True;
405
406	def log(self, iLevel, sText, sCaller, sTsPrf):
407	if iLevel <= self.iVerbose:
408	# format it.
409	if self.iDebug > 0:
410	sLogText = '%s %30s: %s' % (sTsPrf, sCaller, sText);
411	else:
412	sLogText = '%s %s' % (sTsPrf, sText);
413
414	# output it.
415	sAscii = sLogText.encode('ascii', 'replace');
416	if self.iDebug == 0:
417	print >> self.oStdErr, '%s: %s' % (self.sName, sAscii)
418	else:
419	print >> self.oStdErr, '%s' % (sAscii)
420	sLogText += '\n';
421	try:
422	self.oLogFile.write(sLogText.encode('utf-8'));
423	except:
424	pass;
425	return 0;
426
427	def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
428	# Figure the destination filename.
429	iOtherFile = self.iOtherFile;
430	self.iOtherFile += 1;
431	sDstFilename = os.path.join(self.sLogDir, 'other-%d-%s.log' \
432	% (iOtherFile, os.path.splitext(os.path.basename(sSrcFilename))[0]));
433	self.log(0, '** Other log file: %s - %s (%s)' % (sDstFilename, sDescription, sSrcFilename), sCaller, sTsPrf);
434
435	# Open the destination file and copy over the data.
436	fRc = True;
437	try:
438	oDstFile = utils.openNoInherit(sDstFilename, 'w');
439	except Exception, oXcpt:
440	self.log(0, 'error opening %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
441	else:
442	while True:
443	try:
444	abBuf = oSrcFile.read(65536);
445	except Exception, oXcpt:
446	fRc = False;
447	self.log(0, 'error reading %s: %s' % (sSrcFilename, oXcpt), sCaller, sTsPrf);
448	else:
449	try:
450	oDstFile.write(abBuf);
451	except Exception, oXcpt:
452	fRc = False;
453	self.log(0, 'error writing %s: %s' % (sDstFilename, oXcpt), sCaller, sTsPrf);
454	else:
455	if len(abBuf) > 0:
456	continue;
457	break;
458	oDstFile.close();
459
460	# Leave a mark in the XML log.
461	self._xmlWrite('<LogFile timestamp="%s" filename="%s" source="%s" kind="%s" ok="%s">%s</LogFile>\n'
462	% (utils.getIsoTimestamp(), self._xmlEscAttr(os.path.basename(sDstFilename)), self._xmlEscAttr(sSrcFilename), \
463	self._xmlEscAttr(sKind), fRc, self._xmlEscAttr(sDescription)) );
464	_ = sAltName;
465	return fRc;
466
467	def subXmlStart(self, oFileWrapper):
468	# Open a new file and just include it from the main XML.
469	iSubXml = self.iSubXml;
470	self.iSubXml += 1;
471	sSubXmlName = os.path.join(self.sLogDir, 'sub-%d.xml' % (iSubXml,));
472	try:
473	oFileWrapper.oSubXmlFile = utils.openNoInherit(sSubXmlName, "w");
474	except:
475	errorXcpt('open(%s)' % oFileWrapper.oSubXmlName);
476	oFileWrapper.oSubXmlFile = None;
477	else:
478	self._xmlWrite('<Include timestamp="%s" filename="%s"/>\n'
479	% (utils.getIsoTimestamp(), self._xmlEscAttr(os.path.basename(sSubXmlName))));
480	return None;
481
482	def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
483	if oFileWrapper.oSubXmlFile is not None:
484	try:
485	oFileWrapper.oSubXmlFile.write(sRawXml);
486	except:
487	pass;
488	if sCaller is None: pass; # pychecker - NOREF
489	return None;
490
491	def subXmlEnd(self, oFileWrapper):
492	if oFileWrapper.oSubXmlFile is not None:
493	try:
494	oFileWrapper.oSubXmlFile.close();
495	oFileWrapper.oSubXmlFile = None;
496	except:
497	pass;
498	return None;
499
500
501
502	class RemoteReporter(ReporterBase):
503	"""
504	Reporter that talks to the test manager server.
505	"""
506
507
508	## The XML sync min time (seconds).
509	kcSecXmlFlushMin = 30;
510	## The XML sync max time (seconds).
511	kcSecXmlFlushMax = 120;
512	## The XML sync idle time before flushing (seconds).
513	kcSecXmlFlushIdle = 5;
514	## The XML sync line count threshold.
515	kcLinesXmlFlush = 512;
516
517	## The retry timeout.
518	kcSecTestManagerRetryTimeout = 120;
519	## The request timeout.
520	kcSecTestManagerRequestTimeout = 30;
521
522
523	def __init__(self):
524	ReporterBase.__init__(self);
525	self.sTestManagerUrl = os.environ.get('TESTBOX_MANAGER_URL');
526	self.sTestBoxUuid = os.environ.get('TESTBOX_UUID');
527	self.idTestBox = int(os.environ.get('TESTBOX_ID'));
528	self.idTestSet = int(os.environ.get('TESTBOX_TEST_SET_ID'));
529	self._asXml = [];
530	self._secTsXmlFlush = utils.timestampSecond();
531	self._secTsXmlLast = self._secTsXmlFlush;
532	self._fXmlFlushing = False;
533	self.oOutput = sys.stdout; # Hack for __del__ output.
534	self.fFlushEachLine = True;
535	self.fDebugXml = 'TESTDRIVER_REPORTER_DEBUG_XML' in os.environ;
536
537	# Prepare the TM connecting.
538	import urlparse;
539	import httplib;
540	import urllib;
541	from common import constants;
542
543	self._fnUrlEncode = urllib.urlencode;
544	self._fnUrlParseQs = urlparse.parse_qs;
545	self._oParsedTmUrl = urlparse.urlparse(self.sTestManagerUrl);
546
547	if sys.version_info[0] >= 3 \
548	or (sys.version_info[0] == 2 and sys.version_info[1] >= 6):
549	if self._oParsedTmUrl.scheme == 'https': # pylint: disable=E1101
550	self._fnTmConnect = lambda: httplib.HTTPSConnection(self._oParsedTmUrl.hostname,
551	timeout = self.kcSecTestManagerRequestTimeout);
552	else:
553	self._fnTmConnect = lambda: httplib.HTTPConnection( self._oParsedTmUrl.hostname,
554	timeout = self.kcSecTestManagerRequestTimeout);
555	else:
556	if self._oParsedTmUrl.scheme == 'https': # pylint: disable=E1101
557	self._fnTmConnect = lambda: httplib.HTTPSConnection(self._oParsedTmUrl.hostname);
558	else:
559	self._fnTmConnect = lambda: httplib.HTTPConnection( self._oParsedTmUrl.hostname);
560	self._dHttpHeader = \
561	{
562	'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
563	'User-Agent': 'TestDriverReporter/%s.0 (%s, %s)' % (__version__, utils.getHostOs(), utils.getHostArch(),),
564	'Accept': 'text/plain,application/x-www-form-urlencoded',
565	'Accept-Encoding': 'identity',
566	'Cache-Control': 'max-age=0',
567	#'Connection': 'keep-alive',
568	};
569
570	dParams = {
571	constants.tbreq.ALL_PARAM_TESTBOX_UUID: self.sTestBoxUuid,
572	constants.tbreq.ALL_PARAM_TESTBOX_ID: self.idTestBox,
573	constants.tbreq.RESULT_PARAM_TEST_SET_ID: self.idTestSet,
574	};
575	self._sTmServerPath = '/%s/testboxdisp.py?%s' \
576	% ( self._oParsedTmUrl.path.strip('/'), # pylint: disable=E1101
577	urllib.urlencode(dParams), );
578
579	def __del__(self):
580	"""Flush pending log messages?"""
581	if len(self._asXml) > 0:
582	self._xmlDoFlush(self._asXml, fRetry = True, fDtor = True);
583
584	def _writeOutput(self, sText):
585	""" Does the actual writing and flushing. """
586	print >> self.oOutput, sText.encode('ascii', 'replace');
587	if self.fFlushEachLine: self.oOutput.flush();
588	return None;
589
590	#
591	# Talking to TM.
592	#
593
594	def _processTmStatusResponse(self, oConn, sOperation, fClose = True):
595	"""
596	Processes HTTP reponse from the test manager.
597	Returns True, False or None. None should be retried, the others not.
598	May raise exception on HTTP issue (retry ok).
599	"""
600	import httplib;
601	from common import constants;
602
603	# Read the response and (optionally) close the connection.
604	oResponse = oConn.getresponse();
605	try:
606	sRspBody = oResponse.read();
607	except httplib.IncompleteRead, oXcpt:
608	self._writeOutput('%s: %s: Warning: httplib.IncompleteRead: %s [expected %s, got %s]'
609	% (utils.getTimePrefix(), sOperation, oXcpt, oXcpt.expected, len(oXcpt.partial),));
610	sRspBody = oXcpt.partial;
611	if fClose is True:
612	try: oConn.close();
613	except: pass;
614
615	# Check the content type.
616	sContentType = oResponse.getheader('Content-Type');
617	if sContentType is not None and sContentType == 'application/x-www-form-urlencoded; charset=utf-8':
618
619	# Parse the body and check the RESULT parameter.
620	dResponse = self._fnUrlParseQs(sRspBody, strict_parsing = True);
621	sResult = dResponse.get(constants.tbresp.ALL_PARAM_RESULT, None);
622	if isinstance(sResult, list):
623	sResult = sResult[0] if len(sResult) == 1 else '%d results' % (len(sResult),);
624
625	if sResult is not None:
626	if sResult == constants.tbresp.STATUS_ACK:
627	return True;
628	if sResult == constants.tbresp.STATUS_NACK:
629	self._writeOutput('%s: %s: Failed (%s). (dResponse=%s)'
630	% (utils.getTimePrefix(), sOperation, sResult, dResponse,));
631	return False;
632
633	self._writeOutput('%s: %s: Failed - dResponse=%s' % (utils.getTimePrefix(), sOperation, dResponse,));
634	else:
635	self._writeOutput('%s: %s: Unexpected Content-Type: %s' % (utils.getTimePrefix(), sOperation, sContentType,));
636	self._writeOutput('%s: %s: Body: %s' % (utils.getTimePrefix(), sOperation, sRspBody,));
637	return None;
638
639	def _doUploadFile(self, oSrcFile, sSrcFilename, sDescription, sKind, sMime):
640	""" Uploads the given file to the test manager. """
641
642	# Prepare header and url.
643	dHeader = dict(self._dHttpHeader);
644	dHeader['Content-Type'] = 'application/octet-stream';
645	self._writeOutput('%s: _doUploadFile: sHeader=%s' % (utils.getTimePrefix(), dHeader,));
646	oSrcFile.seek(0, 2);
647	self._writeOutput('%s: _doUploadFile: size=%d' % (utils.getTimePrefix(), oSrcFile.tell(),));
648	oSrcFile.seek(0);
649
650	from common import constants;
651	sUrl = self._sTmServerPath + '&' \
652	+ self._fnUrlEncode({ constants.tbreq.UPLOAD_PARAM_NAME: os.path.basename(sSrcFilename),
653	constants.tbreq.UPLOAD_PARAM_DESC: sDescription,
654	constants.tbreq.UPLOAD_PARAM_KIND: sKind,
655	constants.tbreq.UPLOAD_PARAM_MIME: sMime,
656	constants.tbreq.ALL_PARAM_ACTION: constants.tbreq.UPLOAD,
657	});
658
659	# Retry loop.
660	secStart = utils.timestampSecond();
661	while True:
662	try:
663	oConn = self._fnTmConnect();
664	oConn.request('POST', sUrl, oSrcFile.read(), dHeader);
665	fRc = self._processTmStatusResponse(oConn, '_doUploadFile', fClose = True);
666	oConn.close();
667	if fRc is not None:
668	return fRc;
669	except:
670	logXcpt('warning: exception during UPLOAD request');
671
672	if utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
673	self._writeOutput('%s: _doUploadFile: Timed out.' % (utils.getTimePrefix(),));
674	break;
675	try: oSrcFile.seek(0);
676	except:
677	logXcpt();
678	break;
679	self._writeOutput('%s: _doUploadFile: Retrying...' % (utils.getTimePrefix(), ));
680	time.sleep(2);
681
682	return False;
683
684	def _xmlDoFlush(self, asXml, fRetry = False, fDtor = False):
685	"""
686	The code that does the actual talking to the server.
687	Used by both xmlFlush and __del__.
688	"""
689	secStart = utils.timestampSecond();
690	while True:
691	fRc = None;
692	try:
693	# Post.
694	from common import constants;
695	sPostBody = self._fnUrlEncode({constants.tbreq.XML_RESULT_PARAM_BODY: '\n'.join(asXml),});
696	oConn = self._fnTmConnect();
697	oConn.request('POST',
698	self._sTmServerPath + ('&%s=%s' % (constants.tbreq.ALL_PARAM_ACTION, constants.tbreq.XML_RESULTS)),
699	sPostBody,
700	self._dHttpHeader);
701
702	fRc = self._processTmStatusResponse(oConn, '_xmlDoFlush', fClose = True);
703	if fRc is True:
704	if self.fDebugXml:
705	self._writeOutput('_xmlDoFlush:\n%s' % ('\n'.join(asXml),));
706	return (None, False);
707	if fRc is False:
708	self._writeOutput('_xmlDoFlush: Failed - we should abort the test, really.');
709	return (None, True);
710	except Exception, oXcpt:
711	if not fDtor:
712	logXcpt('warning: exception during XML_RESULTS request');
713	else:
714	self._writeOutput('warning: exception during XML_RESULTS request: %s' % (oXcpt,));
715
716	if fRetry is not True \
717	or utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
718	break;
719	time.sleep(2);
720
721	return (asXml, False);
722
723
724	#
725	# Overridden methods.
726	#
727
728	def isLocal(self):
729	return False;
730
731	def log(self, iLevel, sText, sCaller, sTsPrf):
732	if iLevel <= self.iVerbose:
733	if self.iDebug > 0:
734	sLogText = '%s %30s: %s' % (sTsPrf, sCaller, sText);
735	else:
736	sLogText = '%s %s: %s' % (sTsPrf, self.sName, sText);
737	self._writeOutput(sLogText);
738	return 0;
739
740	def addLogFile(self, oSrcFile, sSrcFilename, sAltName, sDescription, sKind, sCaller, sTsPrf):
741	fRc = True;
742	if sKind in [ 'text', 'log', ] or sKind.startswith('log/'):
743	self.log(0, '* Uploading "%s" - KIND: "%s" - DESC: "%s" *'
744	% (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
745	g_oLock.release();
746	self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'text/plain');
747	g_oLock.acquire();
748	elif sKind.startswith('screenshot/'):
749	self.log(0, '* Uploading "%s" - KIND: "%s" - DESC: "%s" *'
750	% (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
751	g_oLock.release();
752	self._doUploadFile(oSrcFile, sAltName, sDescription, sKind, 'image/png');
753	g_oLock.acquire();
754	else:
755	self.log(0, '* UNKNOWN FILE "%s" - KIND "%s" - DESC "%s" *'
756	% (sSrcFilename, sKind, sDescription), sCaller, sTsPrf);
757	return fRc;
758
759	def xmlFlush(self, fRetry = False, fForce = False):
760	"""
761	Flushes the XML back log. Called with the lock held, may leave it
762	while communicating with the server.
763	"""
764	if not self._fXmlFlushing:
765	asXml = self._asXml;
766	self._asXml = [];
767	if len(asXml) > 0 or fForce is True:
768	self._fXmlFlushing = True;
769
770	g_oLock.release();
771	(asXml, fIncErrors) = self._xmlDoFlush(asXml, fRetry = fRetry);
772	g_oLock.acquire();
773
774	if fIncErrors:
775	self.testIncErrors();
776
777	self._fXmlFlushing = False;
778	if asXml is None:
779	self._secTsXmlFlush = utils.timestampSecond();
780	else:
781	self._asXml = asXml + self._asXml;
782	return True;
783
784	self._secTsXmlFlush = utils.timestampSecond();
785	return False;
786
787	def _xmlFlushIfNecessary(self):
788	"""Flushes the XML back log if necessary."""
789	tsNow = utils.timestampSecond();
790	cSecs = tsNow - self._secTsXmlFlush;
791	cSecsLast = tsNow - self._secTsXmlLast;
792	self._secTsXmlLast = tsNow;
793
794	# Absolute flush thresholds.
795	if cSecs >= self.kcSecXmlFlushMax:
796	return self.xmlFlush();
797	if len(self._asXml) >= self.kcLinesXmlFlush:
798	return self.xmlFlush();
799
800	# Flush if idle long enough.
801	if cSecs >= self.kcSecXmlFlushMin \
802	and cSecsLast >= self.kcSecXmlFlushIdle:
803	return self.xmlFlush();
804
805	return False;
806
807	def _xmlWrite(self, asText, fIndent = True):
808	"""XML output function for the reporter."""
809	self._asXml += asText;
810	self._xmlFlushIfNecessary();
811	_ = fIndent; # No pretty printing, thank you.
812	return None;
813
814	def subXmlStart(self, oFileWrapper):
815	oFileWrapper.sXmlBuffer = '';
816	return None;
817
818	def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
819	oFileWrapper.sXmlBuffer += sRawXml;
820	_ = sCaller;
821	return None;
822
823	def subXmlEnd(self, oFileWrapper):
824	sRawXml = oFileWrapper.sXmlBuffer;
825	## @todo should validate the document here and maybe auto terminate things. Adding some hints to have the server do
826	# this instead.
827	g_oLock.acquire();
828	self._asXml += [ '<PushHint testdepth="%d"/>' % (len(self.atTests),),
829	sRawXml,
830	'<PopHint testdepth="%d"/>' % (len(self.atTests),),];
831	self._xmlFlushIfNecessary();
832	g_oLock.release();
833	return None;
834
835
836	#
837	# Helpers
838	#
839
840	def logXcptWorker(iLevel, fIncErrors, sPrefix="", sText=None, cFrames=1):
841	"""
842	Log an exception, optionally with a preceeding message and more than one
843	call frame.
844	"""
845	g_oLock.acquire();
846	if fIncErrors:
847	g_oReporter.testIncErrors();
848
849	## @todo skip all this if iLevel is too high!
850
851	# Try get exception info.
852	sTsPrf = utils.getTimePrefix();
853	try:
854	oType, oValue, oTraceback = sys.exc_info();
855	except:
856	oType = oValue = oTraceback = None;
857	if oType is not None:
858
859	# Try format the info
860	try:
861	rc = 0;
862	sCaller = utils.getCallerName(oTraceback.tb_frame);
863	if sText is not None:
864	rc = g_oReporter.log(iLevel, "%s%s" % (sPrefix, sText), sCaller, sTsPrf);
865	asInfo = [];
866	try:
867	asInfo = asInfo + traceback.format_exception_only(oType, oValue);
868	if cFrames is not None and cFrames <= 1:
869	asInfo = asInfo + traceback.format_tb(oTraceback, 1);
870	else:
871	asInfo.append('Traceback:')
872	asInfo = asInfo + traceback.format_tb(oTraceback, cFrames);
873	asInfo.append('Stack:')
874	asInfo = asInfo + traceback.format_stack(oTraceback.tb_frame.f_back, cFrames);
875	except:
876	g_oReporter.log(0, '** internal-error: Hit exception #2! %s' % (traceback.format_exc()), sCaller, sTsPrf);
877
878	if len(asInfo) > 0:
879	# Do the logging.
880	for sItem in asInfo:
881	asLines = sItem.splitlines();
882	for sLine in asLines:
883	rc = g_oReporter.log(iLevel, '%s%s' % (sPrefix, sLine), sCaller, sTsPrf);
884
885	else:
886	g_oReporter.log(iLevel, 'No exception info...', sCaller, sTsPrf);
887	rc = -3;
888	except:
889	g_oReporter.log(0, '** internal-error: Hit exception! %s' % (traceback.format_exc()), None, sTsPrf);
890	rc = -2;
891	else:
892	g_oReporter.log(0, '** internal-error: No exception! %s'
893	% (utils.getCallerName(iFrame=3)), utils.getCallerName(iFrame=3), sTsPrf);
894	rc = -1;
895
896	g_oLock.release();
897	return rc;
898
899	#
900	# The public Classes
901	#
902	class FileWrapper(object):
903	""" File like class for TXS EXEC and similar. """
904	def __init__(self, sPrefix):
905	self.sPrefix = sPrefix;
906
907	def read(self, cb):
908	"""file.read"""
909	_ = cb;
910	return "";
911
912	def write(self, sText):
913	"""file.write"""
914	if isinstance(sText, array.array):
915	try:
916	sText = sText.tostring();
917	except:
918	pass;
919	g_oLock.acquire();
920	try:
921	sTsPrf = utils.getTimePrefix();
922	sCaller = utils.getCallerName();
923	asLines = sText.splitlines();
924	for sLine in asLines:
925	g_oReporter.log(0, '%s: %s' % (self.sPrefix, sLine), sCaller, sTsPrf);
926	except:
927	traceback.print_exc();
928	g_oLock.release();
929	return None;
930
931	class FileWrapperTestPipe(object):
932	""" File like class for the test pipe (TXS EXEC and similar). """
933	def __init__(self):
934	self.sPrefix = '';
935	self.fStarted = False;
936	self.fClosed = False;
937
938	def __del__(self):
939	self.close();
940
941	def close(self):
942	""" file.close """
943	if self.fStarted is True and self.fClosed is False:
944	self.fClosed = True;
945	try: g_oReporter.subXmlEnd(self);
946	except:
947	try: traceback.print_exc();
948	except: pass;
949	return True;
950
951	def read(self, cb = None):
952	"""file.read"""
953	_ = cb;
954	return "";
955
956	def write(self, sText):
957	"""file.write"""
958	# lazy start.
959	if self.fStarted is not True:
960	try:
961	g_oReporter.subXmlStart(self);
962	except:
963	traceback.print_exc();
964	self.fStarted = True;
965
966	if isinstance(sText, array.array):
967	try:
968	sText = sText.tostring();
969	except:
970	pass;
971	try:
972	g_oReporter.subXmlWrite(self, sText, utils.getCallerName());
973	except:
974	traceback.print_exc();
975	return None;
976
977
978	#
979	# The public APIs.
980	#
981
982	def log(sText):
983	"""Writes the specfied text to the log."""
984	g_oLock.acquire();
985	try:
986	rc = g_oReporter.log(1, sText, utils.getCallerName(), utils.getTimePrefix());
987	except:
988	rc = -1;
989	g_oLock.release();
990	return rc;
991
992	def logXcpt(sText=None, cFrames=1):
993	"""
994	Log an exception, optionally with a preceeding message and more than one
995	call frame.
996	"""
997	return logXcptWorker(1, False, "", sText, cFrames);
998
999	def log2(sText):
1000	"""Log level 2: Writes the specfied text to the log."""
1001	g_oLock.acquire();
1002	try:
1003	rc = g_oReporter.log(2, sText, utils.getCallerName(), utils.getTimePrefix());
1004	except:
1005	rc = -1;
1006	g_oLock.release();
1007	return rc;
1008
1009	def log2Xcpt(sText=None, cFrames=1):
1010	"""
1011	Log level 2: Log an exception, optionally with a preceeding message and
1012	more than one call frame.
1013	"""
1014	return logXcptWorker(2, False, "", sText, cFrames);
1015
1016	def maybeErr(fIsError, sText):
1017	""" Maybe error or maybe normal log entry. """
1018	if fIsError is True:
1019	return error(sText);
1020	return log(sText);
1021
1022	def maybeErrXcpt(fIsError, sText=None, cFrames=1):
1023	""" Maybe error or maybe normal log exception entry. """
1024	if fIsError is True:
1025	return errorXcpt(sText, cFrames);
1026	return logXcpt(sText, cFrames);
1027
1028	def maybeLog(fIsNotError, sText):
1029	""" Maybe error or maybe normal log entry. """
1030	if fIsNotError is not True:
1031	return error(sText);
1032	return log(sText);
1033
1034	def maybeLogXcpt(fIsNotError, sText=None, cFrames=1):
1035	""" Maybe error or maybe normal log exception entry. """
1036	if fIsNotError is not True:
1037	return errorXcpt(sText, cFrames);
1038	return logXcpt(sText, cFrames);
1039
1040	def error(sText):
1041	"""
1042	Writes the specfied error message to the log.
1043
1044	This will add an error to the current test.
1045
1046	Always returns False for the convenience of methods returning boolean
1047	success indicators.
1048	"""
1049	g_oLock.acquire();
1050	g_oReporter.testIncErrors();
1051	try:
1052	g_oReporter.log(0, '** error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
1053	except:
1054	pass;
1055	g_oLock.release();
1056	return False;
1057
1058	def errorXcpt(sText=None, cFrames=1):
1059	"""
1060	Log an error caused by an exception. If sText is given, it will preceed
1061	the exception information. cFrames can be used to display more stack.
1062
1063	This will add an error to the current test.
1064
1065	Always returns False for the convenience of methods returning boolean
1066	success indicators.
1067	"""
1068	logXcptWorker(0, True, '** error: ', sText, cFrames);
1069	return False;
1070
1071	def errorTimeout(sText):
1072	"""
1073	Flags the current test as having timed out and writes the specified message to the log.
1074
1075	This will add an error to the current test.
1076
1077	Always returns False for the convenience of methods returning boolean
1078	success indicators.
1079	"""
1080	g_oLock.acquire();
1081	g_oReporter.testSetTimedOut();
1082	try:
1083	g_oReporter.log(0, '** timeout-error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
1084	except:
1085	pass;
1086	g_oLock.release();
1087	return False;
1088
1089	def fatal(sText):
1090	"""
1091	Writes a fatal error to the log.
1092
1093	This will add an error to the current test.
1094
1095	Always returns False for the convenience of methods returning boolean
1096	success indicators.
1097	"""
1098	g_oLock.acquire();
1099	g_oReporter.testIncErrors();
1100	try:
1101	g_oReporter.log(0, '** fatal error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
1102	except:
1103	pass
1104	g_oLock.release();
1105	return False;
1106
1107	def fatalXcpt(sText=None, cFrames=1):
1108	"""
1109	Log a fatal error caused by an exception. If sText is given, it will
1110	preceed the exception information. cFrames can be used to display more
1111	stack.
1112
1113	This will add an error to the current test.
1114
1115	Always returns False for the convenience of methods returning boolean
1116	success indicators.
1117	"""
1118	logXcptWorker(0, True, "** fatal error: ", sText, cFrames);
1119	return False;
1120
1121	def addLogFile(sFilename, sKind, sDescription = '', sAltName = None):
1122	"""
1123	Adds the specified log file to the report if the file exists.
1124
1125	The sDescription is a free form description of the log file.
1126
1127	The sKind parameter is for adding some machine parsable hint what kind of
1128	log file this really is.
1129
1130	Returns True on success, False on failure (no ENOENT errors are logged).
1131	"""
1132	sTsPrf = utils.getTimePrefix();
1133	sCaller = utils.getCallerName();
1134	fRc = False;
1135	if sAltName is None:
1136	sAltName = sFilename;
1137
1138	try:
1139	oSrcFile = utils.openNoInherit(sFilename, 'rb');
1140	except IOError, oXcpt:
1141	if oXcpt.errno != errno.ENOENT:
1142	logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind));
1143	else:
1144	logXcpt('addLogFile(%s,%s,%s) IOError' % (sFilename, sDescription, sKind));
1145	except:
1146	logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind));
1147	else:
1148	g_oLock.acquire();
1149	fRc = g_oReporter.addLogFile(oSrcFile, sFilename, sAltName, sDescription, sKind, sCaller, sTsPrf);
1150	g_oLock.release();
1151	oSrcFile.close();
1152	return fRc;
1153
1154	def isLocal():
1155	"""Is this a local reporter?"""
1156	return g_oReporter.isLocal()
1157
1158	def incVerbosity():
1159	"""Increases the verbosity level."""
1160	return g_oReporter.incVerbosity()
1161
1162	def incDebug():
1163	"""Increases the debug level."""
1164	return g_oReporter.incDebug()
1165
1166	def getErrorCount():
1167	"""
1168	Get the current error count for the entire test run.
1169	"""
1170	g_oLock.acquire();
1171	cErrors = g_oReporter.cErrors;
1172	g_oLock.release();
1173	return cErrors;
1174
1175
1176	#
1177	# Test reporting, a bit similar to RTTestI*.
1178	#
1179
1180	def testStart(sName):
1181	"""
1182	Starts a new test (pushes it).
1183	"""
1184	g_oLock.acquire();
1185	rc = g_oReporter.testStart(sName, utils.getCallerName());
1186	g_oLock.release();
1187	return rc;
1188
1189	def testValue(sName, sValue, sUnit):
1190	"""
1191	Reports a benchmark value or something simiarlly useful.
1192	"""
1193	g_oLock.acquire();
1194	rc = g_oReporter.testValue(sName, str(sValue), sUnit, utils.getCallerName());
1195	g_oLock.release();
1196	return rc;
1197
1198	def testFailure(sDetails):
1199	"""
1200	Reports a failure.
1201	We count these calls and testDone will use them to report PASSED or FAILED.
1202
1203	Returns False so that a return False line can be saved.
1204	"""
1205	g_oLock.acquire();
1206	g_oReporter.testFailure(sDetails, utils.getCallerName());
1207	g_oLock.release();
1208	return False;
1209
1210	def testFailureXcpt(sDetails = ''):
1211	"""
1212	Reports a failure with exception.
1213	We count these calls and testDone will use them to report PASSED or FAILED.
1214
1215	Returns False so that a return False line can be saved.
1216	"""
1217	# Extract exception info.
1218	try:
1219	oType, oValue, oTraceback = sys.exc_info();
1220	except:
1221	oType = oValue, oTraceback = None;
1222	if oType is not None:
1223	sCaller = utils.getCallerName(oTraceback.tb_frame);
1224	sXcpt = ' '.join(traceback.format_exception_only(oType, oValue));
1225	else:
1226	sCaller = utils.getCallerName();
1227	sXcpt = 'No exception at %s' % (sCaller,);
1228
1229	# Use testFailure to do the work.
1230	g_oLock.acquire();
1231	if sDetails == '':
1232	g_oReporter.testFailure('Exception: %s' % (sXcpt,), sCaller);
1233	else:
1234	g_oReporter.testFailure('%s: %s' % (sDetails, sXcpt), sCaller);
1235	g_oLock.release();
1236	return False;
1237
1238	def testDone(fSkipped = False):
1239	"""
1240	Completes the current test (pops it), logging PASSED / FAILURE.
1241
1242	Returns a tuple with the name of the test and its error count.
1243	"""
1244	g_oLock.acquire();
1245	rc = g_oReporter.testDone(fSkipped, utils.getCallerName());
1246	g_oLock.release();
1247	return rc;
1248
1249	def testErrorCount():
1250	"""
1251	Gets the error count of the current test.
1252
1253	Returns the number of errors.
1254	"""
1255	g_oLock.acquire();
1256	cErrors = g_oReporter.testErrorCount();
1257	g_oLock.release();
1258	return cErrors;
1259
1260	def testCleanup():
1261	"""
1262	Closes all open tests with a generic error condition.
1263
1264	Returns True if no open tests, False if something had to be closed with failure.
1265	"""
1266	g_oLock.acquire();
1267	fRc = g_oReporter.testCleanup(utils.getCallerName());
1268	g_oReporter.xmlFlush(fRetry = False, fForce = True);
1269	g_oLock.release();
1270	return fRc;
1271
1272
1273	#
1274	# Sub XML stuff.
1275	#
1276
1277	def addSubXmlFile(sFilename):
1278	"""
1279	Adds a sub-xml result file to the party.
1280	"""
1281	fRc = False;
1282	try:
1283	oSrcFile = utils.openNoInherit(sFilename, 'r');
1284	except IOError, oXcpt:
1285	if oXcpt.errno != errno.ENOENT:
1286	logXcpt('addSubXmlFile(%s)' % (sFilename,));
1287	except:
1288	logXcpt('addSubXmlFile(%s)' % (sFilename,));
1289	else:
1290	try:
1291	oWrapper = FileWrapperTestPipe()
1292	oWrapper.write(oSrcFile.read());
1293	oWrapper.close();
1294	except:
1295	logXcpt('addSubXmlFile(%s)' % (sFilename,));
1296	oSrcFile.close();
1297
1298	return fRc;
1299
1300
1301	#
1302	# Other useful debugging tools.
1303	#
1304
1305	def logAllStacks(cFrames = None):
1306	"""
1307	Logs the stacks of all python threads.
1308	"""
1309	sTsPrf = utils.getTimePrefix();
1310	sCaller = utils.getCallerName();
1311	g_oLock.acquire();
1312
1313	cThread = 0;
1314	for idThread, oStack in sys._current_frames().items(): # >=2.5, a bit ugly - pylint: disable=W0212
1315	try:
1316	if cThread > 0:
1317	g_oReporter.log(1, '', sCaller, sTsPrf);
1318	g_oReporter.log(1, 'Thread %s (%#x)' % (idThread, idThread), sCaller, sTsPrf);
1319	try:
1320	asInfo = traceback.format_stack(oStack, cFrames);
1321	except:
1322	g_oReporter.log(1, ' Stack formatting failed w/ exception', sCaller, sTsPrf);
1323	else:
1324	for sInfo in asInfo:
1325	asLines = sInfo.splitlines();
1326	for sLine in asLines:
1327	g_oReporter.log(1, sLine, sCaller, sTsPrf);
1328	except:
1329	pass;
1330	cThread += 1;
1331
1332	g_oLock.release();
1333	return None;
1334
1335	def checkTestManagerConnection():
1336	"""
1337	Checks the connection to the test manager.
1338
1339	Returns True if the connection is fine, False if not, None if not remote
1340	reporter.
1341
1342	Note! This as the sideeffect of flushing XML.
1343	"""
1344	g_oLock.acquire();
1345	fRc = g_oReporter.xmlFlush(fRetry = False, fForce = True);
1346	g_oLock.release();
1347	return fRc;
1348
1349	def flushall():
1350	"""
1351	Flushes all output streams, both standard and logger related.
1352	"""
1353	try: sys.stdout.flush();
1354	except: pass;
1355	try: sys.stderr.flush();
1356	except: pass;
1357
1358	# Note! Current no logger specific streams to flush.
1359
1360	return True;
1361
1362
1363	#
1364	# Module initialization.
1365	#
1366
1367	def _InitReporterModule():
1368	"""
1369	Instantiate the test reporter.
1370	"""
1371	global g_oReporter, g_sReporterName
1372
1373	g_sReporterName = os.getenv("TESTBOX_REPORTER", "local");
1374	if g_sReporterName == "local":
1375	g_oReporter = LocalReporter();
1376	elif g_sReporterName == "remote":
1377	g_oReporter = RemoteReporter();
1378	else:
1379	print >> sys.stderr, os.path.basename(__file__) + ": Unknown TESTBOX_REPORTER value: '" + g_sReporterName + "'";
1380	raise Exception("Unknown TESTBOX_REPORTER value '" + g_sReporterName + "'");
1381
1382	if __name__ != "checker": # pychecker avoidance.
1383	_InitReporterModule();
1384

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ValidationKit/testdriver/reporter.py@ 56971

Download in other formats: