fmtlog.cpp

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

/*****************************************************************************/
/* Software Testing Automation Framework (STAF)                              */
/* (C) Copyright IBM Corp. 2001, 2004                                        */
/*                                                                           */
/* This software is licensed under the Common Public License (CPL) V1.0.     */
/*****************************************************************************/

#include "STAF.h"
#include "STAFString.h"
#include "STAF_iostream.h"
#include "STAF_fstream.h"
#include "STAFTimestamp.h"
#include "STAFUtil.h"
#include "STAFCommandParser.h"
#include "STAFFileSystem.h"

// XXX: This utility steals ALL of its functionality from STAFLogService.cpp.
//      These structures and functions should be moved to a separate header so
//      that they can be shared by the service and this utility.  It would
//      probably also be a good idea to move this utility into the services/log
//      directory.

// Type definitions

struct LogRecord
{
    LogRecord() : recordFormatID(0), date(0), secondsPastMidnight(0),
                  logLevel(0), handle(0)
    { /* Do Nothing */ }

    LogRecord(unsigned int aDate, unsigned int seconds, unsigned int level,
              const STAFString &aMachine, const STAFString &aHandleName,
              STAFHandle_t aHandle, const STAFString(&aUser),
              const STAFString(&aEndpoint), const STAFString &aMessage)
        : recordFormatID(0), date(aDate), secondsPastMidnight(seconds),
          logLevel(level), machine(aMachine), handleName(aHandleName),
        handle(aHandle), user(aUser), endpoint(aEndpoint), message(aMessage)
    { /* Do Nothing */ }

    unsigned int recordFormatID;
    unsigned int date;
    unsigned int secondsPastMidnight;
    unsigned int logLevel;
    STAFString machine;
    STAFString handleName;
    STAFHandle_t handle;
    STAFString user;
    STAFString endpoint;
    STAFString message;
};

enum ReadLogRecordRC
{
    kReadLogOk = 0,
    kReadLogEndOfFile = 1,
    kReadLogInvalidFormat = 2
};


// Prototypes

void printUsage();
void readUIntFromFile(istream &input, unsigned int &data,
                     unsigned int length = 4);
void readStringFromFile(istream &input, STAFString &inString);
unsigned int readLogRecordFromFile(istream &input, LogRecord &logRecord);
void writeLogRecordToString(STAFString &output, const LogRecord &logRecord,
                            const STAFString &separator,
                            const STAFString &endOfLine,
                            bool levelAsBits = false);
STAFString &convertLogLevelToString(unsigned int logLevel,
                                    bool levelAsBits = false);


// Some global variables

static STAFString sSpace(kUTF8_SPACE);
static STAFString sOldSep(kUTF8_VBAR);
static unsigned int sCurrRecordFormatID = 4;

static STAFString sFATALPretty("Fatal");
static STAFString sERRORPretty("Error");
static STAFString sWARNINGPretty("Warning");
static STAFString sINFOPretty("Info");
static STAFString sTRACEPretty("Trace");
static STAFString sTRACE2Pretty("Trace2");
static STAFString sTRACE3Pretty("Trace3");
static STAFString sDEBUGPretty("Debug");
static STAFString sDEBUG2Pretty("Debug2");
static STAFString sDEBUG3Pretty("Debug3");
static STAFString sSTARTPretty("Start");
static STAFString sSTOPPretty("Stop");
static STAFString sPASSPretty("Pass");
static STAFString sFAILPretty("Fail");
static STAFString sSTATUSPretty("Status");
static STAFString sUSER1Pretty("User1");
static STAFString sUSER2Pretty("User2");
static STAFString sUSER3Pretty("User3");
static STAFString sUSER4Pretty("User4");
static STAFString sUSER5Pretty("User5");
static STAFString sUSER6Pretty("User6");
static STAFString sUSER7Pretty("UseR7");
static STAFString sUSER8Pretty("User8");
static STAFString sUNKNOWNPretty("Unknown");

static STAFString sFATALBits  ("00000000000000000000000000000001");
static STAFString sERRORBits  ("00000000000000000000000000000010");
static STAFString sWARNINGBits("00000000000000000000000000000100");
static STAFString sINFOBits   ("00000000000000000000000000001000");
static STAFString sTRACEBits  ("00000000000000000000000000010000");
static STAFString sTRACE2Bits ("00000000000000000000000000100000");
static STAFString sTRACE3Bits ("00000000000000000000000001000000");
static STAFString sDEBUGBits  ("00000000000000000000000010000000");
static STAFString sDEBUG2Bits ("00000000000000000000000100000000");
static STAFString sDEBUG3Bits ("00000000000000000000001000000000");
static STAFString sSTARTBits  ("00000000000000000000010000000000");
static STAFString sSTOPBits   ("00000000000000000000100000000000");
static STAFString sPASSBits   ("00000000000000000001000000000000");
static STAFString sFAILBits   ("00000000000000000010000000000000");
static STAFString sSTATUSBits ("00000000000000000100000000000000");
static STAFString sUSER1Bits  ("00000001000000000000000000000000");
static STAFString sUSER2Bits  ("00000010000000000000000000000000");
static STAFString sUSER3Bits  ("00000100000000000000000000000000");
static STAFString sUSER4Bits  ("00001000000000000000000000000000");
static STAFString sUSER5Bits  ("00010000000000000000000000000000");
static STAFString sUSER6Bits  ("00100000000000000000000000000000");
static STAFString sUSER7Bits  ("01000000000000000000000000000000");
static STAFString sUSER8Bits  ("10000000000000000000000000000000");
static STAFString sUNKNOWNBits("00000000000000000000000000000000");

static STAFString sSlash(kUTF8_SLASH);
static STAFString sColon(kUTF8_COLON);
static const STAFString sSpecSeparator(sColon + sSlash + sSlash);
static const STAFString sUnauthenticatedUser = "none" +
    sSpecSeparator + "anonymous";

// Begin main

int main(int argc, char **argv)
{
    if (argc < 2)
    {
        printUsage();
        return 1;
    }

    STAFString input;

    for (int i = 1; i < argc; ++i)
        input += sSpace + argv[i];

    STAFCommandParser parser;

    parser.addOption("FORMAT", 1, STAFCommandParser::kValueNotAllowed);
    parser.addOption("LOGFILE", 1, STAFCommandParser::kValueRequired);
    parser.addOption("NEWFILE", 1, STAFCommandParser::kValueRequired);
    parser.addOption("LEVELBITSTRING", 1, STAFCommandParser::kValueNotAllowed);
    parser.addOption("FIELDSEP", 1, STAFCommandParser::kValueRequired);
    parser.addOption("HELP", 1, STAFCommandParser::kValueNotAllowed);
    parser.addOptionGroup("FORMAT HELP", 1, 1);
    parser.addOptionNeed("FORMAT", "LOGFILE");
    parser.addOptionNeed("LOGFILE", "NEWFILE");

    STAFCommandParseResultPtr parsedResult = parser.parse(input);

    if (parsedResult->rc != 0)
    {
        cout << parsedResult->errorBuffer << endl;
        return parsedResult->rc;
    }

    if (parsedResult->optionTimes("HELP") != 0)
    {
        printUsage();
        return 1;
    }

    STAFString fieldSep(kUTF8_VBAR);

    if (parsedResult->optionTimes("FIELDSEP") != 0)
        fieldSep = parsedResult->optionValue("FIELDSEP");

    bool levelAsBits = (parsedResult->optionTimes("LEVELBITSTRING") != 0);

    // We use a blank end of line so that we don't have to figure out
    // what the appropriate thing really is.  We will just use "endl"

    STAFString endOfLine;
    STAFString infileName = parsedResult->optionValue("LOGFILE");
    STAFString outfileName = parsedResult->optionValue("NEWFILE");

    fstream infile(infileName.toCurrentCodePage()->buffer(),
                   ios::in | STAF_ios_binary);
    if (!infile)
    {
        cout << "Error opening Log File, " << infileName << endl;
        return 1;
    }

    fstream outfile(outfileName.toCurrentCodePage()->buffer(),
                    ios::out | STAF_ios_binary);
    if (!outfile)
    {
        cout << "Error opening Output File, " << outfileName << endl;
        return 1;
    }

    // Get the log file's entry and lock it

    STAFFSPath logfilePath(infileName);
    STAFFSEntryPtr logfileEntry;

    try
    {
        logfileEntry = logfilePath.getEntry();
    }
    catch (STAFException &se)
    {
        cout << "Error getting entry for Log File, " << infileName << endl;
        cout << "Error code: " << se.getErrorCode() << endl;
        cout << "Reason    : " << se.getText() << endl;
        return 1;
    }

    STAFFSEntryRLock logfileLock(logfileEntry);

    // Read each record

    unsigned int totalRecords = 0;
    LogRecord logRecord;

    while (!infile.eof())
    {
        // First, get the information from the log record

        unsigned int status = readLogRecordFromFile(infile, logRecord);

        if (status == kReadLogEndOfFile)
        {
            // Finish up with whatever needs to be done
            continue;
        }
        else if (status == kReadLogInvalidFormat)
        {
            cout << "Encountered unknown log record format." << endl
                 << "Exiting!" << endl;

            return 1;
        }

        ++totalRecords;

        STAFString recordString;

        writeLogRecordToString(recordString, logRecord, fieldSep, endOfLine,
                               levelAsBits);

        outfile << recordString << endl;
    }

    cout << "Formatted " << totalRecords << " record(s) to " << outfileName
         << endl;

    return 0;
}

void printUsage()
{