staflogservice.cpp

Software Testing Automation Framework (STAF)的开发代码

        data.fLogRecordClass->addKey("timestamp",  "Date-Time");
        data.fLogRecordClass->addKey("level",      "Level");
        data.fLogRecordClass->addKey("message",    "Message");

        // Construct the map class for the marshalled QUERY LONG log-record
        // output

        data.fLogRecordLongClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/LogRecordLong");

        data.fLogRecordLongClass->addKey("recordNumber", "Record #");
        data.fLogRecordLongClass->setKeyProperty(
            "recordNumber", "display-short-name", "R#"); 
        data.fLogRecordLongClass->addKey("timestamp",  "Date-Time");
        data.fLogRecordLongClass->addKey("machine",    "Machine");
        data.fLogRecordLongClass->addKey("handle",     "Handle");
        data.fLogRecordLongClass->setKeyProperty(
            "handle", "display-short-name", "H#"); 
        data.fLogRecordLongClass->addKey("handleName", "Handle Name");
        data.fLogRecordLongClass->setKeyProperty(
            "handleName", "display-short-name", "Name"); 
        data.fLogRecordLongClass->addKey("user",       "User");
        data.fLogRecordLongClass->addKey("endpoint",   "Endpoint");
        data.fLogRecordLongClass->addKey("level",      "Level");
        data.fLogRecordLongClass->addKey("message",    "Message");

        // Construct the map class for the marshalled QUERY STATS output

        data.fQueryStatsClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/QueryStats");

        data.fQueryStatsClass->addKey("fatal",   sFATALPretty);
        data.fQueryStatsClass->addKey("error",   sERRORPretty);
        data.fQueryStatsClass->addKey("warning", sWARNINGPretty);
        data.fQueryStatsClass->addKey("info",    sINFOPretty);
        data.fQueryStatsClass->addKey("trace",   sTRACEPretty);
        data.fQueryStatsClass->addKey("trace2",  sTRACE2Pretty);
        data.fQueryStatsClass->addKey("trace3",  sTRACE3Pretty);
        data.fQueryStatsClass->addKey("debug",   sDEBUGPretty);
        data.fQueryStatsClass->addKey("debug2",  sDEBUG2Pretty);
        data.fQueryStatsClass->addKey("debug3",  sDEBUG3Pretty);
        data.fQueryStatsClass->addKey("start",   sSTARTPretty);
        data.fQueryStatsClass->addKey("stop",    sSTOPPretty);
        data.fQueryStatsClass->addKey("pass",    sPASSPretty);
        data.fQueryStatsClass->addKey("fail",    sFAILPretty);
        data.fQueryStatsClass->addKey("status",  sSTATUSPretty);
        data.fQueryStatsClass->addKey("user1",   sUSER1Pretty);
        data.fQueryStatsClass->addKey("user2",   sUSER2Pretty);
        data.fQueryStatsClass->addKey("user3",   sUSER3Pretty);
        data.fQueryStatsClass->addKey("user4",   sUSER4Pretty);
        data.fQueryStatsClass->addKey("user5",   sUSER5Pretty);
        data.fQueryStatsClass->addKey("user6",   sUSER6Pretty);
        data.fQueryStatsClass->addKey("user7",   sUSER7Pretty);
        data.fQueryStatsClass->addKey("user8",   sUSER8Pretty);

        // Construct the map class for the marshalled PURGE request output

        data.fPurgeStatsClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/PurgeStats");

        data.fPurgeStatsClass->addKey("purgedRecords", "Purged Records");
        data.fPurgeStatsClass->addKey("totalRecords",  "Total Records");
        
        // Construct the map class for the marshalled LIST SETTINGS output
        // for local logging

        data.fListLocalSettingsClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/LocalSettings");

        data.fListLocalSettingsClass->addKey("loggingMode", "Logging Mode");
        data.fListLocalSettingsClass->addKey("directory",   "Directory");
        data.fListLocalSettingsClass->addKey("maxRecordSize",
                                             "Max Record Size");
        data.fListLocalSettingsClass->addKey("defaultMaxQueryRecords",
                                             "Default Max Query Records");
        data.fListLocalSettingsClass->addKey("resolveMessage",
                                             "Resolve Message");
        data.fListLocalSettingsClass->addKey("resolveMessageVar",
                                             "Resolve Message Var");

        // Construct the map class for the marshalled LIST SETTINGS output
        // for remote logging

        data.fListRemoteSettingsClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/RemoteSettings");

        data.fListRemoteSettingsClass->addKey("loggingMode", "Logging Mode");
        data.fListRemoteSettingsClass->addKey("remoteLogServer",
                                              "Remote Log Server");
        data.fListRemoteSettingsClass->addKey("remoteLogService",
                                              "Remote Log Service");

        // Construct map class for marshalled LIST logs/machines/handles output

        data.fListLogsClass = STAFMapClassDefinition::create(
            "STAF/Service/Log/ListLogs");

        data.fListLogsClass->addKey("logName",   "Log Name");
        data.fListLogsClass->addKey("timestamp", "Date-Time");
        data.fListLogsClass->addKey("upperSize", "U-Size");
        data.fListLogsClass->addKey("size",      "L-Size");
        
        // Set service handle

        *pServiceHandle = new LogServiceData(data);

        return kSTAFOk;
    }
    catch (STAFException &e)
    { *pErrorBuffer = getExceptionString(e,
                      "STAFLogService.cpp: STAFServiceConstruct").adoptImpl();
    }
    catch (...)
    {
        STAFString error("STAFLogService.cpp: STAFServiceConstruct: Caught "
                         "unknown exception in STAFServiceAcceptRequest()");
        *pErrorBuffer = error.adoptImpl();
    }

    return kSTAFUnknownError;
}


STAFRC_t STAFServiceInit(STAFServiceHandle_t serviceHandle,
                         void *pInitInfo, unsigned int initLevel,
                         STAFString_t *pErrorBuffer)
{
    STAFRC_t retCode = kSTAFUnknownError;

    try
    {
        if (initLevel != 30) return kSTAFInvalidAPILevel;

        LogServiceData *pData =
            reinterpret_cast<LogServiceData *>(serviceHandle);
        
        STAFServiceInitLevel30 *pInfo =
            reinterpret_cast<STAFServiceInitLevel30 *>(pInitInfo);

        retCode = STAFHandle::create(pData->fName, pData->fHandle);
        
        if (retCode != kSTAFOk)
            return retCode;

        STAFCommandParseResultPtr parsedResult =
            pData->fParmsParser->parse(pInfo->parms);

        if (parsedResult->rc != kSTAFOk)
        {
            *pErrorBuffer = parsedResult->errorBuffer.adoptImpl();
            return parsedResult->rc;
        }

        if (parsedResult->optionTimes(sENABLEREMOTELOGGING) != 0)
        {
            pData->fRLogMode = 1;

            STAFResultPtr serverResult = resolveOpLocal(pData, parsedResult,
                                                        sREMOTELOGSERVER);
            if (serverResult->rc != kSTAFOk)
            {
                *pErrorBuffer = serverResult->result.adoptImpl();
                return serverResult->rc;
            }

            pData->fRemoteLogServer = serverResult->result;

            STAFResultPtr serviceResult = resolveOpLocal(pData, parsedResult,
                                                         sREMOTELOGSERVICE);
            if (serviceResult->rc != kSTAFOk)
            {
                *pErrorBuffer = serviceResult->result.adoptImpl();
                return serviceResult->rc;
            }

            if (serviceResult->result.length() != 0)
                pData->fRemoteLogService = serviceResult->result;
        }

        STAFResultPtr dirResult = resolveOpLocal(pData, parsedResult,
                                                 sDIRECTORY);
        if (dirResult->rc != kSTAFOk)
        {
            *pErrorBuffer = dirResult->result.adoptImpl();
            return dirResult->rc;
        }

        STAFFSPath logPath;

        if (dirResult->result.length() == 0)
        {
            logPath.setRoot(pInfo->writeLocation);
            logPath.addDir("service");
            logPath.addDir(pData->fShortName.toLowerCase());
            pData->fRoot = logPath.asString();
        }
        else
        {
            pData->fRoot = dirResult->result;
            logPath.setRoot(pData->fRoot);
        }

        // Create the log data directory if it doesn't already exist to
        // verify the log data directory name.

        if (!logPath.exists())
        {
            try
            {
                STAFFSEntryPtr logdir = 
                    logPath.createDirectory(kSTAFFSCreatePath);
            }
            catch (...)
            { 
                STAFString error("STAFLogService.cpp: STAFServiceInit: "
                                 "Invalid Log Directory: " + pData->fRoot);
                cout << error << endl;
                *pErrorBuffer = error.adoptImpl();
                return kSTAFServiceConfigurationError;
            }
        }
        
        if (parsedResult->optionTimes(sMAXRECORDSIZE) != 0)
        {
            STAFResultPtr maxResult = resolveOpLocal(pData, parsedResult,
                                                     sMAXRECORDSIZE);

            if (maxResult->rc != kSTAFOk)
            {
                *pErrorBuffer = maxResult->result.adoptImpl();
                return maxResult->rc;
            }

            if (!maxResult->result.isDigits())
            {
                STAFString error(
                    "MAXRECORDSIZE value (" + maxResult->result +
                    ") is not an integer");
                *pErrorBuffer = error.adoptImpl();
                return kSTAFServiceConfigurationError;
            }

            pData->fMaxRecordSize = maxResult->result.asUInt();
        }

        if (parsedResult->optionTimes(sDEFAULTMAXQUERYRECORDS) != 0)
        {
            STAFResultPtr maxResult = resolveOpLocal(
                pData, parsedResult, sDEFAULTMAXQUERYRECORDS);

            if (maxResult->rc != kSTAFOk)
            {
                *pErrorBuffer = maxResult->result.adoptImpl();
                return maxResult->rc;
            }

            if (!maxResult->result.isDigits())
            {
                STAFString error(
                    "DEFAULTMAXQUERYRECORDS value (" + maxResult->result +
                    ") is not an integer");
                *pErrorBuffer = error.adoptImpl();
                return kSTAFServiceConfigurationError;
            }

            pData->fDefaultMaxQueryRecords = maxResult->result.asUInt();
        }

        if (parsedResult->optionTimes(sRESOLVEMESSAGE) != 0)
            pData->fDefaultResolveMessage = 1;
        else if (parsedResult->optionTimes(sNORESOLVEMESSAGE) != 0)
            pData->fDefaultResolveMessage = 0;

        if (parsedResult->optionTimes(sENABLERESOLVEMESSAGEVAR) != 0)
            pData->fUseResolveMessageVar = 1;
        else if (parsedResult->optionTimes(sDISABLERESOLVEMESSAGEVAR) != 0)
            pData->fUseResolveMessageVar = 0;

        // Get the default authenticator

        STAFResultPtr resResult = pData->fHandle->submit(
            sLocal, sVar, sDefAuthString);

        if (resResult->rc != kSTAFOk)
        {
            *pErrorBuffer = resResult->result.adoptImpl();
            return resResult->rc;
        }

        pData->fDefaultAuthenticator = resResult->result;
        
        // Get the machine name for the local machine

        resResult = pData->fHandle->submit(
            sLocal, sVar, sResMachineString);

        if (resResult->rc != kSTAFOk)
        {
            *pErrorBuffer = resResult->result.adoptImpl();
            return resResult->rc;
        }

        pData->fLocalMachineName = resResult->result;

        // Register help for the error codes for this service

        registerHelpData(pData, kSTAFLogInvalidLevel,
            STAFString("Invalid level"),
            STAFString("An invalid level was specified"));

        STAFString invalidDirMessage("The STAF/Service/");

        invalidDirMessage += pData->fShortName;
        invalidDirMessage += "/Directory variable in the STAF configuration "
                             "file is invalid";

        registerHelpData(pData, kSTAFLogInvalidFileFormat,
            STAFString("Invalid file format"),
            STAFString("An invalid/unknown record format was encountered "
                       "while reading the log file"));

        registerHelpData(pData, kSTAFLogPurgeFailure,
            STAFString("Unable to purge all log records"),
            STAFString("Your PURGE criteria selected every record in the log "
                       "file.  Use DELETE if you really want to delete every "
                       "record.  Or, modify your PURGE criteria."));

        registerHelpData(pData, kSTAFLogExceededDefaultMaxRecords,
            STAFString("Exceeded default maximum query records"),
            STAFString("Your query criteria selected more records than "