Exemplo n.º 1
0
    def _doUploadFile(self, oSrcFile, sSrcFilename, sDescription, sKind,
                      sMime):
        """ Uploads the given file to the test manager. """

        # Prepare header and url.
        dHeader = dict(self._dHttpHeader)
        dHeader['Content-Type'] = 'application/octet-stream'
        self._writeOutput('%s: _doUploadFile: sHeader=%s' % (
            utils.getTimePrefix(),
            dHeader,
        ))
        oSrcFile.seek(0, 2)
        self._writeOutput('%s: _doUploadFile: size=%d' % (
            utils.getTimePrefix(),
            oSrcFile.tell(),
        ))
        oSrcFile.seek(0)

        from common import constants
        sUrl = self._sTmServerPath + '&' \
             + self._fnUrlEncode({ constants.tbreq.UPLOAD_PARAM_NAME: os.path.basename(sSrcFilename),
                                   constants.tbreq.UPLOAD_PARAM_DESC: sDescription,
                                   constants.tbreq.UPLOAD_PARAM_KIND: sKind,
                                   constants.tbreq.UPLOAD_PARAM_MIME: sMime,
                                   constants.tbreq.ALL_PARAM_ACTION:  constants.tbreq.UPLOAD,
                                })

        # Retry loop.
        secStart = utils.timestampSecond()
        while True:
            try:
                oConn = self._fnTmConnect()
                oConn.request('POST', sUrl, oSrcFile.read(), dHeader)
                fRc = self._processTmStatusResponse(oConn,
                                                    '_doUploadFile',
                                                    fClose=True)
                oConn.close()
                if fRc is not None:
                    return fRc
            except:
                logXcpt('warning: exception during UPLOAD request')

            if utils.timestampSecond(
            ) - secStart >= self.kcSecTestManagerRetryTimeout:
                self._writeOutput('%s: _doUploadFile: Timed out.' %
                                  (utils.getTimePrefix(), ))
                break
            try:
                oSrcFile.seek(0)
            except:
                logXcpt()
                break
            self._writeOutput('%s: _doUploadFile: Retrying...' %
                              (utils.getTimePrefix(), ))
            time.sleep(2)

        return False
Exemplo n.º 2
0
def logAllStacks(cFrames=None):
    """
    Logs the stacks of all python threads.
    """
    sTsPrf = utils.getTimePrefix()
    sCaller = utils.getCallerName()
    g_oLock.acquire()

    cThread = 0
    for idThread, oStack in sys._current_frames().items():  # >=2.5, a bit ugly - pylint: disable=W0212
        try:
            if cThread > 0:
                g_oReporter.log(1, '', sCaller, sTsPrf)
            g_oReporter.log(1, 'Thread %s (%#x)' % (idThread, idThread),
                            sCaller, sTsPrf)
            try:
                asInfo = traceback.format_stack(oStack, cFrames)
            except:
                g_oReporter.log(1, '  Stack formatting failed w/ exception',
                                sCaller, sTsPrf)
            else:
                for sInfo in asInfo:
                    asLines = sInfo.splitlines()
                    for sLine in asLines:
                        g_oReporter.log(1, sLine, sCaller, sTsPrf)
        except:
            pass
        cThread += 1

    g_oLock.release()
    return None
Exemplo n.º 3
0
def logAllStacks(cFrames = None):
    """
    Logs the stacks of all python threads.
    """
    sTsPrf  = utils.getTimePrefix();
    sCaller = utils.getCallerName();
    g_oLock.acquire();

    cThread = 0;
    for idThread, oStack in sys._current_frames().items(): # >=2.5, a bit ugly - pylint: disable=W0212
        try:
            if cThread > 0:
                g_oReporter.log(1, '', sCaller, sTsPrf);
            g_oReporter.log(1, 'Thread %s (%#x)' % (idThread, idThread), sCaller, sTsPrf);
            try:
                asInfo = traceback.format_stack(oStack, cFrames);
            except:
                g_oReporter.log(1, '  Stack formatting failed w/ exception', sCaller, sTsPrf);
            else:
                for sInfo in asInfo:
                    asLines = sInfo.splitlines();
                    for sLine in asLines:
                        g_oReporter.log(1, sLine, sCaller, sTsPrf);
        except:
            pass;
        cThread += 1;

    g_oLock.release();
    return None;
Exemplo n.º 4
0
def addLogFile(sFilename, sKind, sDescription='', sAltName=None):
    """
    Adds the specified log file to the report if the file exists.

    The sDescription is a free form description of the log file.

    The sKind parameter is for adding some machine parsable hint what kind of
    log file this really is.

    Returns True on success, False on failure (no ENOENT errors are logged).
    """
    sTsPrf = utils.getTimePrefix()
    sCaller = utils.getCallerName()
    fRc = False
    if sAltName is None:
        sAltName = sFilename

    try:
        oSrcFile = utils.openNoInherit(sFilename, 'rb')
    except IOError, oXcpt:
        if oXcpt.errno != errno.ENOENT:
            logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind))
        else:
            logXcpt('addLogFile(%s,%s,%s) IOError' %
                    (sFilename, sDescription, sKind))
def log(sMessage, sCaller = None, sTsPrf = None):
    """
    Print out a message and flush stdout
    """
    if sTsPrf is None: sTsPrf = utils.getTimePrefix();
    print('[%s] %s' % (sTsPrf, sMessage,));
    sys.stdout.flush();
    _ = sCaller;
def log(sMessage, sCaller = None, sTsPrf = None):
    """
    Print out a message and flush stdout
    """
    if sTsPrf is None: sTsPrf = utils.getTimePrefix();
    print('[%s] %s' % (sTsPrf, sMessage,));
    sys.stdout.flush();
    _ = sCaller;
Exemplo n.º 7
0
def logXcptWorker(iLevel, fIncErrors, sPrefix="", sText=None, cFrames=1):
    """
    Log an exception, optionally with a preceeding message and more than one
    call frame.
    """
    g_oLock.acquire();
    if fIncErrors:
        g_oReporter.testIncErrors();

    ## @todo skip all this if iLevel is too high!

    # Try get exception info.
    sTsPrf = utils.getTimePrefix();
    try:
        oType, oValue, oTraceback = sys.exc_info();
    except:
        oType = oValue = oTraceback = None;
    if oType is not None:

        # Try format the info
        try:
            rc      = 0;
            sCaller = utils.getCallerName(oTraceback.tb_frame);
            if sText is not None:
                rc = g_oReporter.log(iLevel, "%s%s" % (sPrefix, sText), sCaller, sTsPrf);
            asInfo = [];
            try:
                asInfo = asInfo + traceback.format_exception_only(oType, oValue);
                if cFrames is not None and cFrames <= 1:
                    asInfo = asInfo + traceback.format_tb(oTraceback, 1);
                else:
                    asInfo.append('Traceback:')
                    asInfo = asInfo + traceback.format_tb(oTraceback, cFrames);
                    asInfo.append('Stack:')
                    asInfo = asInfo + traceback.format_stack(oTraceback.tb_frame.f_back, cFrames);
            except:
                g_oReporter.log(0, 'internal-error: Hit exception #2! %s' % (traceback.format_exc()), sCaller, sTsPrf);

            if len(asInfo) > 0:
                # Do the logging.
                for sItem in asInfo:
                    asLines = sItem.splitlines();
                    for sLine in asLines:
                        rc = g_oReporter.log(iLevel, '%s%s' % (sPrefix, sLine), sCaller, sTsPrf);

            else:
                g_oReporter.log(iLevel, 'No exception info...', sCaller, sTsPrf);
                rc = -3;
        except:
            g_oReporter.log(0, 'internal-error: Hit exception! %s' % (traceback.format_exc()), None, sTsPrf);
            rc = -2;
    else:
        g_oReporter.log(0, 'internal-error: No exception! %s'
                      % (utils.getCallerName(iFrame=3)), utils.getCallerName(iFrame=3), sTsPrf);
        rc = -1;

    g_oLock.release();
    return rc;
def log2(sMessage, sCaller = None, sTsPrf = None):
    """
    Debug logging, will later be disabled by default.
    """
    if True:
        if sTsPrf is None: sTsPrf = utils.getTimePrefix();
        print('[%s] %s' % (sTsPrf, sMessage,));
        sys.stdout.flush()
        _ = sCaller;
def log2(sMessage, sCaller = None, sTsPrf = None):
    """
    Debug logging, will later be disabled by default.
    """
    if True:
        if sTsPrf is None: sTsPrf = utils.getTimePrefix();
        print('[%s] %s' % (sTsPrf, sMessage,));
        sys.stdout.flush()
        _ = sCaller;
Exemplo n.º 10
0
def log2(sText):
    """Log level 2: Writes the specfied text to the log."""
    g_oLock.acquire();
    try:
        rc = g_oReporter.log(2, sText, utils.getCallerName(), utils.getTimePrefix());
    except:
        rc = -1;
    g_oLock.release();
    return rc;
Exemplo n.º 11
0
    def _doUploadFile(self, oSrcFile, sSrcFilename, sDescription, sKind, sMime):
        """ Uploads the given file to the test manager. """

        # Prepare header and url.
        dHeader = dict(self._dHttpHeader);
        dHeader['Content-Type'] = 'application/octet-stream';
        self._writeOutput('%s: _doUploadFile: sHeader=%s' % (utils.getTimePrefix(), dHeader,));
        oSrcFile.seek(0, 2);
        self._writeOutput('%s: _doUploadFile: size=%d' % (utils.getTimePrefix(), oSrcFile.tell(),));
        oSrcFile.seek(0);

        from common import constants;
        sUrl = self._sTmServerPath + '&' \
             + self._fnUrlEncode({ constants.tbreq.UPLOAD_PARAM_NAME: os.path.basename(sSrcFilename),
                                   constants.tbreq.UPLOAD_PARAM_DESC: sDescription,
                                   constants.tbreq.UPLOAD_PARAM_KIND: sKind,
                                   constants.tbreq.UPLOAD_PARAM_MIME: sMime,
                                   constants.tbreq.ALL_PARAM_ACTION:  constants.tbreq.UPLOAD,
                                });

        # Retry loop.
        secStart = utils.timestampSecond();
        while True:
            try:
                oConn = self._fnTmConnect();
                oConn.request('POST', sUrl, oSrcFile.read(), dHeader);
                fRc = self._processTmStatusResponse(oConn, '_doUploadFile', fClose = True);
                oConn.close();
                if fRc is not None:
                    return fRc;
            except:
                logXcpt('warning: exception during UPLOAD request');

            if utils.timestampSecond() - secStart >= self.kcSecTestManagerRetryTimeout:
                self._writeOutput('%s: _doUploadFile: Timed out.' % (utils.getTimePrefix(),));
                break;
            try: oSrcFile.seek(0);
            except:
                logXcpt();
                break;
            self._writeOutput('%s: _doUploadFile: Retrying...' % (utils.getTimePrefix(), ));
            time.sleep(2);

        return False;
Exemplo n.º 12
0
def log2(sText):
    """Log level 2: Writes the specfied text to the log."""
    g_oLock.acquire()
    try:
        rc = g_oReporter.log(2, sText, utils.getCallerName(),
                             utils.getTimePrefix())
    except:
        rc = -1
    g_oLock.release()
    return rc
Exemplo n.º 13
0
def log2(sMessage, sCaller=None, sTsPrf=None):
    """
    Debug logging, will later be disabled by default.
    """
    if True is True:  # pylint: disable=comparison-with-itself
        if sTsPrf is None: sTsPrf = utils.getTimePrefix()
        print('[%s] %s' % (
            sTsPrf,
            sMessage,
        ))
        sys.stdout.flush()
        _ = sCaller
def _logXcptWorker(fnLogger, sPrefix = '', sText = None, cFrames = 1, fnLogger1 = log):
    """
    Log an exception, optionally with a preceeding message and more than one
    call frame.
    """
    ## @todo skip all this if iLevel is too high!

    # Try get exception info.
    sTsPrf = utils.getTimePrefix();
    try:
        oType, oValue, oTraceback = sys.exc_info();
    except:
        oType = oValue = oTraceback = None;
    if oType is not None:

        # Try format the info
        try:
            rc      = 0;
            sCaller = utils.getCallerName(oTraceback.tb_frame);
            if sText is not None:
                rc = fnLogger('%s%s' % (sPrefix, sText), sCaller, sTsPrf);
            asInfo = [];
            try:
                asInfo = asInfo + traceback.format_exception_only(oType, oValue);
                if cFrames is not None and cFrames <= 1:
                    asInfo = asInfo + traceback.format_tb(oTraceback, 1);
                else:
                    asInfo.append('Traceback:')
                    asInfo = asInfo + traceback.format_tb(oTraceback, cFrames);
                    asInfo.append('Stack:')
                    asInfo = asInfo + traceback.format_stack(oTraceback.tb_frame.f_back, cFrames);
            except:
                fnLogger1('internal-error: Hit exception #2! %s' % (traceback.format_exc()), sCaller, sTsPrf);

            if len(asInfo) > 0:
                # Do the logging.
                for sItem in asInfo:
                    asLines = sItem.splitlines();
                    for sLine in asLines:
                        rc = fnLogger('%s%s' % (sPrefix, sLine), sCaller, sTsPrf);

            else:
                fnLogger('No exception info...', sCaller, sTsPrf);
                rc = -3;
        except:
            fnLogger1('internal-error: Hit exception! %s' % (traceback.format_exc()), None, sTsPrf);
            rc = -2;
    else:
        fnLogger1('internal-error: No exception! %s' % (utils.getCallerName(iFrame=3)), utils.getCallerName(iFrame=3), sTsPrf);
        rc = -1;

    return rc;
Exemplo n.º 15
0
def fatal(sText):
    """
    Writes a fatal error to the log.

    This will add an error to the current test.

    Always returns False for the convenience of methods returning boolean
    success indicators.
    """
    g_oLock.acquire();
    g_oReporter.testIncErrors();
    try:
        g_oReporter.log(0, 'fatal error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
    except:
        pass
    g_oLock.release();
    return False;
Exemplo n.º 16
0
    def _processTmStatusResponse(self, oConn, sOperation, fClose = True):
        """
        Processes HTTP reponse from the test manager.
        Returns True, False or None.  None should be retried, the others not.
        May raise exception on HTTP issue (retry ok).
        """
        import httplib;
        from common import constants;

        # Read the response and (optionally) close the connection.
        oResponse = oConn.getresponse();
        try:
            sRspBody  = oResponse.read();
        except httplib.IncompleteRead, oXcpt:
            self._writeOutput('%s: %s: Warning: httplib.IncompleteRead: %s [expected %s, got %s]'
                              % (utils.getTimePrefix(), sOperation, oXcpt, oXcpt.expected, len(oXcpt.partial),));
            sRspBody = oXcpt.partial;
Exemplo n.º 17
0
def errorTimeout(sText):
    """
    Flags the current test as having timed out and writes the specified message to the log.

    This will add an error to the current test.

    Always returns False for the convenience of methods returning boolean
    success indicators.
    """
    g_oLock.acquire();
    g_oReporter.testSetTimedOut();
    try:
        g_oReporter.log(0, 'timeout-error: %s' % (sText), utils.getCallerName(), utils.getTimePrefix());
    except:
        pass;
    g_oLock.release();
    return False;
Exemplo n.º 18
0
 def write(self, sText):
     """file.write"""
     if isinstance(sText, array.array):
         try:
             sText = sText.tostring();
         except:
             pass;
     g_oLock.acquire();
     try:
         sTsPrf  = utils.getTimePrefix();
         sCaller = utils.getCallerName();
         asLines = sText.splitlines();
         for sLine in asLines:
             g_oReporter.log(0, '%s: %s' % (self.sPrefix, sLine), sCaller, sTsPrf);
     except:
         traceback.print_exc();
     g_oLock.release();
     return None;
Exemplo n.º 19
0
def errorTimeout(sText):
    """
    Flags the current test as having timed out and writes the specified message to the log.

    This will add an error to the current test.

    Always returns False for the convenience of methods returning boolean
    success indicators.
    """
    g_oLock.acquire()
    g_oReporter.testSetTimedOut()
    try:
        g_oReporter.log(0, 'timeout-error: %s' % (sText),
                        utils.getCallerName(), utils.getTimePrefix())
    except:
        pass
    g_oLock.release()
    return False
Exemplo n.º 20
0
def fatal(sText):
    """
    Writes a fatal error to the log.

    This will add an error to the current test.

    Always returns False for the convenience of methods returning boolean
    success indicators.
    """
    g_oLock.acquire()
    g_oReporter.testIncErrors()
    try:
        g_oReporter.log(0, 'fatal error: %s' % (sText), utils.getCallerName(),
                        utils.getTimePrefix())
    except:
        pass
    g_oLock.release()
    return False
Exemplo n.º 21
0
 def write(self, sText):
     """file.write"""
     if isinstance(sText, array.array):
         try:
             sText = sText.tostring()
         except:
             pass
     g_oLock.acquire()
     try:
         sTsPrf = utils.getTimePrefix()
         sCaller = utils.getCallerName()
         asLines = sText.splitlines()
         for sLine in asLines:
             g_oReporter.log(0, '%s: %s' % (self.sPrefix, sLine), sCaller,
                             sTsPrf)
     except:
         traceback.print_exc()
     g_oLock.release()
     return None
Exemplo n.º 22
0
def addLogFile(sFilename, sKind, sDescription = '', sAltName = None):
    """
    Adds the specified log file to the report if the file exists.

    The sDescription is a free form description of the log file.

    The sKind parameter is for adding some machine parsable hint what kind of
    log file this really is.

    Returns True on success, False on failure (no ENOENT errors are logged).
    """
    sTsPrf  = utils.getTimePrefix();
    sCaller = utils.getCallerName();
    fRc     = False;
    if sAltName is None:
        sAltName = sFilename;

    try:
        oSrcFile = utils.openNoInherit(sFilename, 'rb');
    except IOError, oXcpt:
        if oXcpt.errno != errno.ENOENT:
            logXcpt('addLogFile(%s,%s,%s)' % (sFilename, sDescription, sKind));
        else:
            logXcpt('addLogFile(%s,%s,%s) IOError' % (sFilename, sDescription, sKind));
Exemplo n.º 23
0
    def _processTmStatusResponse(self, oConn, sOperation, fClose=True):
        """
        Processes HTTP reponse from the test manager.
        Returns True, False or None.  None should be retried, the others not.
        May raise exception on HTTP issue (retry ok).
        """
        import httplib
        from common import constants

        # Read the response and (optionally) close the connection.
        oResponse = oConn.getresponse()
        try:
            sRspBody = oResponse.read()
        except httplib.IncompleteRead, oXcpt:
            self._writeOutput(
                '%s: %s: Warning: httplib.IncompleteRead: %s [expected %s, got %s]'
                % (
                    utils.getTimePrefix(),
                    sOperation,
                    oXcpt,
                    oXcpt.expected,
                    len(oXcpt.partial),
                ))
            sRspBody = oXcpt.partial
Exemplo n.º 24
0
 def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
     """Called by the file wrapper write method for test pipes."""
     return self.log(0, 'raw xml%s: %s' % (oFileWrapper.sPrefix, sRawXml), sCaller, utils.getTimePrefix());
Exemplo n.º 25
0
 def subXmlWrite(self, oFileWrapper, sRawXml, sCaller):
     """Called by the file wrapper write method for test pipes."""
     return self.log(0, 'raw xml%s: %s' % (oFileWrapper.sPrefix, sRawXml),
                     sCaller, utils.getTimePrefix())
Exemplo n.º 26
0
class RemoteReporter(ReporterBase):
    """
    Reporter that talks to the test manager server.
    """

    ## The XML sync min time (seconds).
    kcSecXmlFlushMin = 30
    ## The XML sync max time (seconds).
    kcSecXmlFlushMax = 120
    ## The XML sync idle time before flushing (seconds).
    kcSecXmlFlushIdle = 5
    ## The XML sync line count threshold.
    kcLinesXmlFlush = 512

    ## The retry timeout.
    kcSecTestManagerRetryTimeout = 120
    ## The request timeout.
    kcSecTestManagerRequestTimeout = 30

    def __init__(self):
        ReporterBase.__init__(self)
        self.sTestManagerUrl = os.environ.get('TESTBOX_MANAGER_URL')
        self.sTestBoxUuid = os.environ.get('TESTBOX_UUID')
        self.idTestBox = int(os.environ.get('TESTBOX_ID'))
        self.idTestSet = int(os.environ.get('TESTBOX_TEST_SET_ID'))
        self._asXml = []
        self._secTsXmlFlush = utils.timestampSecond()
        self._secTsXmlLast = self._secTsXmlFlush
        self._fXmlFlushing = False
        self.oOutput = sys.stdout
        # Hack for __del__ output.
        self.fFlushEachLine = True
        self.fDebugXml = 'TESTDRIVER_REPORTER_DEBUG_XML' in os.environ

        # Prepare the TM connecting.
        import urlparse
        import httplib
        import urllib
        from common import constants

        self._fnUrlEncode = urllib.urlencode
        self._fnUrlParseQs = urlparse.parse_qs
        self._oParsedTmUrl = urlparse.urlparse(self.sTestManagerUrl)
        if     sys.version_info[0] >= 3 \
           or (sys.version_info[0] == 2 and sys.version_info[1] >= 6):
            if self._oParsedTmUrl.scheme == 'https':  # pylint: disable=E1101
                self._fnTmConnect = lambda: httplib.HTTPSConnection(
                    self._oParsedTmUrl.hostname,
                    timeout=self.kcSecTestManagerRequestTimeout)
            else:
                self._fnTmConnect = lambda: httplib.HTTPConnection(
                    self._oParsedTmUrl.hostname,
                    timeout=self.kcSecTestManagerRequestTimeout)
        else:
            if self._oParsedTmUrl.scheme == 'https':  # pylint: disable=E1101
                self._fnTmConnect = lambda: httplib.HTTPSConnection(
                    self._oParsedTmUrl.hostname)
            else:
                self._fnTmConnect = lambda: httplib.HTTPConnection(
                    self._oParsedTmUrl.hostname)
        self._dHttpHeader = \
        {
            'Content-Type':     'application/x-www-form-urlencoded; charset=utf-8',
            'User-Agent':       'TestDriverReporter/%s.0 (%s, %s)' % (__version__, utils.getHostOs(), utils.getHostArch(),),
            'Accept':           'text/plain,application/x-www-form-urlencoded',
            'Accept-Encoding':  'identity',
            'Cache-Control':    'max-age=0',
            #'Connection':       'keep-alive',
        }

        dParams = {
            constants.tbreq.ALL_PARAM_TESTBOX_UUID: self.sTestBoxUuid,
            constants.tbreq.ALL_PARAM_TESTBOX_ID: self.idTestBox,
            constants.tbreq.RESULT_PARAM_TEST_SET_ID: self.idTestSet,
        }
        self._sTmServerPath = '/%s/testboxdisp.py?%s' \
                            % ( self._oParsedTmUrl.path.strip('/'), # pylint: disable=E1101
                                urllib.urlencode(dParams), )

    def __del__(self):
        """Flush pending log messages?"""
        if len(self._asXml) > 0:
            self._xmlDoFlush(self._asXml, fRetry=True, fDtor=True)

    def _writeOutput(self, sText):
        """ Does the actual writing and flushing. """
        print >> self.oOutput, sText.encode('ascii', 'replace')
        if self.fFlushEachLine: self.oOutput.flush()
        return None

    #
    # Talking to TM.
    #

    def _processTmStatusResponse(self, oConn, sOperation, fClose=True):
        """
        Processes HTTP reponse from the test manager.
        Returns True, False or None.  None should be retried, the others not.
        May raise exception on HTTP issue (retry ok).
        """
        import httplib
        from common import constants

        # Read the response and (optionally) close the connection.
        oResponse = oConn.getresponse()
        try:
            sRspBody = oResponse.read()
        except httplib.IncompleteRead, oXcpt:
            self._writeOutput(
                '%s: %s: Warning: httplib.IncompleteRead: %s [expected %s, got %s]'
                % (
                    utils.getTimePrefix(),
                    sOperation,
                    oXcpt,
                    oXcpt.expected,
                    len(oXcpt.partial),
                ))
            sRspBody = oXcpt.partial
        if fClose is True:
            try:
                oConn.close()
            except:
                pass

        # Check the content type.
        sContentType = oResponse.getheader('Content-Type')
        if sContentType is not None and sContentType == 'application/x-www-form-urlencoded; charset=utf-8':

            # Parse the body and check the RESULT parameter.
            dResponse = self._fnUrlParseQs(sRspBody, strict_parsing=True)
            sResult = dResponse.get(constants.tbresp.ALL_PARAM_RESULT, None)
            if isinstance(sResult, list):
                sResult = sResult[0] if len(
                    sResult) == 1 else '%d results' % (len(sResult), )

            if sResult is not None:
                if sResult == constants.tbresp.STATUS_ACK:
                    return True
                if sResult == constants.tbresp.STATUS_NACK:
                    self._writeOutput('%s: %s: Failed (%s). (dResponse=%s)' % (
                        utils.getTimePrefix(),
                        sOperation,
                        sResult,
                        dResponse,
                    ))
                return False

            self._writeOutput('%s: %s: Failed - dResponse=%s' % (
                utils.getTimePrefix(),
                sOperation,
                dResponse,
            ))
        else:
            self._writeOutput('%s: %s: Unexpected Content-Type: %s' % (
                utils.getTimePrefix(),
                sOperation,
                sContentType,
            ))
            self._writeOutput('%s: %s: Body: %s' % (
                utils.getTimePrefix(),
                sOperation,
                sRspBody,
            ))
        return None
Exemplo n.º 27
0
def logXcptWorker(iLevel, fIncErrors, sPrefix="", sText=None, cFrames=1):
    """
    Log an exception, optionally with a preceeding message and more than one
    call frame.
    """
    g_oLock.acquire()
    if fIncErrors:
        g_oReporter.testIncErrors()

    ## @todo skip all this if iLevel is too high!

    # Try get exception info.
    sTsPrf = utils.getTimePrefix()
    try:
        oType, oValue, oTraceback = sys.exc_info()
    except:
        oType = oValue = oTraceback = None
    if oType is not None:

        # Try format the info
        try:
            rc = 0
            sCaller = utils.getCallerName(oTraceback.tb_frame)
            if sText is not None:
                rc = g_oReporter.log(iLevel, "%s%s" % (sPrefix, sText),
                                     sCaller, sTsPrf)
            asInfo = []
            try:
                asInfo = asInfo + traceback.format_exception_only(
                    oType, oValue)
                if cFrames is not None and cFrames <= 1:
                    asInfo = asInfo + traceback.format_tb(oTraceback, 1)
                else:
                    asInfo.append('Traceback:')
                    asInfo = asInfo + traceback.format_tb(oTraceback, cFrames)
                    asInfo.append('Stack:')
                    asInfo = asInfo + traceback.format_stack(
                        oTraceback.tb_frame.f_back, cFrames)
            except:
                g_oReporter.log(
                    0, 'internal-error: Hit exception #2! %s' %
                    (traceback.format_exc()), sCaller, sTsPrf)

            if len(asInfo) > 0:
                # Do the logging.
                for sItem in asInfo:
                    asLines = sItem.splitlines()
                    for sLine in asLines:
                        rc = g_oReporter.log(iLevel, '%s%s' % (sPrefix, sLine),
                                             sCaller, sTsPrf)

            else:
                g_oReporter.log(iLevel, 'No exception info...', sCaller,
                                sTsPrf)
                rc = -3
        except:
            g_oReporter.log(
                0,
                'internal-error: Hit exception! %s' % (traceback.format_exc()),
                None, sTsPrf)
            rc = -2
    else:
        g_oReporter.log(
            0, 'internal-error: No exception! %s' %
            (utils.getCallerName(iFrame=3)), utils.getCallerName(iFrame=3),
            sTsPrf)
        rc = -1

    g_oLock.release()
    return rc