backup.git - Gitblit

//  CTraceServer.cpp
 
//  defines the CTraceServer class
 
#include "stdafx.h"
#include <time.h>
#include <io.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <sys/stat.h>
#include "CTraceServer.h"
 
CTraceServer::CTraceServer() {
    traceFileName = "";
    traceFileNumber = 0;
    fpTraceFile = NULL;
    initialized = false;
    traceThreadStartedEvent = NULL;
    traceThread = NULL;
    traceThreadID = 0;
    traceThreadStartedEvent = CreateEvent(NULL, TRUE, FALSE, "TraceThreadEvent");
    InitializeCriticalSection(&m_csTraceMutex);
}
 
CTraceServer::~CTraceServer() {
    if (traceThreadStartedEvent)
        CloseHandle(traceThreadStartedEvent);
    traceThreadStartedEvent = NULL;
    DeleteCriticalSection(&m_csTraceMutex);
}
 
int
CTraceServer::initialize() {
    bool l_initialized;
    int returnCode = 0;
    EnterCriticalSection(&m_csTraceMutex);
    l_initialized = initialized;
    initialized = true;
    LeaveCriticalSection(&m_csTraceMutex);
 
    if (l_initialized) {
        WaitForSingleObject(traceThreadStartedEvent, INFINITE);
    }
    else {
        bufferMisses = 0;
        // open trace file
        if (!openFirstTraceFile()) {
            returnCode = -10;
        }
        else {
            // initialize trace buffers
            bufferQ.erase(bufferQ.begin(), bufferQ.end());
            for (int i=0; i<NUM_TRACE_BUFFERS; i++) {
                char *buffer = new char[TRACE_BUFFER_SIZE];
                if (buffer != NULL) {
                    bufferQ.push_back(buffer);
                }
            }
            traceThread = CreateThread(NULL, 0, TraceThread, this, 0, &traceThreadID);
            WaitForSingleObject(traceThreadStartedEvent, INFINITE);
        }
    }
    return returnCode;
}
 
int
CTraceServer::uninitialize() {
    bool l_initialized;
    int returnCode = 0;
    EnterCriticalSection(&m_csTraceMutex);
    l_initialized = initialized;
    initialized = false;
    LeaveCriticalSection(&m_csTraceMutex);
 
    if (!l_initialized) {
        return 0;
    }
 
    // wait for the file print thread to stop. this way it will return all trace buffers to the free list
    ResetEvent(traceThreadStartedEvent);
    PostThreadMessage(traceThreadID, WM_QUIT, 1234, 5678);
    WaitForSingleObject(traceThreadStartedEvent, INFINITE);
    traceThreadID = 0;
    // free trace buffers
    int buffersFreed = 0;
    int nullBuffers  = 0;
    EnterCriticalSection(&m_csTraceMutex);
    while (bufferQ.size() > 0) {
        char *buffer = bufferQ.front();
        bufferQ.pop_front();
        if (buffer) {
            delete [] (buffer);
            buffersFreed++;
        }
        else
            nullBuffers++;
    }
    LeaveCriticalSection(&m_csTraceMutex);
    fprintf(fpTraceFile, "TRACER : freed %d buffers(%d null buffers) & %d buffer misses\n", buffersFreed, nullBuffers, bufferMisses);
 
    // close trace file
    if (fpTraceFile) {
        fflush(fpTraceFile);
        fclose(fpTraceFile);
        fpTraceFile = NULL;
    }
    _chmod(traceFileName.c_str(), _S_IREAD);
    CloseHandle(traceThread);
    traceThread = NULL;
    return 0;
}
 
DWORD
CTraceServer::getTraceThreadID() {
    WaitForSingleObject(traceThreadStartedEvent, INFINITE);
    return traceThreadID;
}
 
char *
CTraceServer::getTraceBuffer() {
    char *buffer = NULL;
    EnterCriticalSection(&m_csTraceMutex);
    if (bufferQ.size() > 0) {
        buffer = bufferQ.front();
        bufferQ.pop_front();
    }
    LeaveCriticalSection(&m_csTraceMutex);
    if (buffer) {
        buffer[TRACE_BUFFER_SIZE - 1] = '\n';
    }
    else {
        bufferMisses++;
    }
    return buffer;
}
 
 
void
CTraceServer::freeTraceBuffer(char *traceBuffer) {
    if (traceBuffer) {
        EnterCriticalSection(&m_csTraceMutex);
        bufferQ.push_back(traceBuffer);
        LeaveCriticalSection(&m_csTraceMutex);
    }
}
 
 
string
CTraceServer::makeTraceFileName(int traceFileNum) {
    char fileName[100];
    sprintf(fileName, "TraceFile_%04d.txt", traceFileNum);
    std::string newFile(fileName);
    return newFile;
}
 
bool
CTraceServer::openFirstTraceFile() {
    // find out the last trace file that was created. open the one after that
    int lastTraceFileNumber = -1;
    struct _stat lastTraceFileStats;
    lastTraceFileStats.st_mtime = 0;
    for (int i=0; i<NUM_TRACE_FILES; i++) {
        string fileName = makeTraceFileName(i);
        struct _stat fileStats;
        if (_stat(fileName.c_str(), &fileStats) == 0) {
            if (fileStats.st_mtime >= lastTraceFileStats.st_mtime) {
                lastTraceFileStats = fileStats;
                lastTraceFileNumber = i;
            }
        }
    }
    if (lastTraceFileNumber < 0)
        traceFileNumber = 1;
    else
        traceFileNumber = lastTraceFileNumber;
    traceFileName   = makeTraceFileName(traceFileNumber);
    _chmod(traceFileName.c_str(), _S_IREAD | _S_IWRITE);    // in case the file exists and is read-only, change perms
    fpTraceFile     = fopen(traceFileName.c_str(), "ac");
    if (fpTraceFile == NULL)
        return false;
    return true;
}
 
bool
CTraceServer::changeTraceFile() {
    bool result = true;
    if (fpTraceFile) 
        fclose(fpTraceFile);
    _chmod(traceFileName.c_str(), _S_IREAD);
    traceFileNumber = (traceFileNumber + 1) % NUM_TRACE_FILES;
    traceFileName = makeTraceFileName(traceFileNumber);
    _chmod(traceFileName.c_str(), _S_IREAD | _S_IWRITE);    // in case the file exists and is read-only, change perms
    fpTraceFile = fopen(traceFileName.c_str(), "wc");
    if (!fpTraceFile)
        result = false;
    return result;
}
 
int
CTraceServer::trace(char *traceBuffer) {
    int returnValue(0);
    if (PostThreadMessage(traceThreadID, WM_USER, (WPARAM)traceBuffer, 0) == 0) { // that means error happened
        returnValue = (int)GetLastError();
        freeTraceBuffer(traceBuffer);
    }
    return returnValue;
}
 
 
DWORD WINAPI
CTraceServer::TraceThread(LPVOID pParams) {
    CTraceServer *traceServer = (CTraceServer *)pParams;
    return traceServer->doTraceThread();
}
 
 
void
CTraceServer::printTime() 
{
    time_t currentTime_t;
    time(&currentTime_t);
    struct tm *currentTm = localtime(&currentTime_t);
    fprintf(fpTraceFile, "\n------------ %s", asctime(currentTm));
}
 
DWORD
CTraceServer::doTraceThread() {
    DWORD resultCode = 0;
    int cnt = 0;
    MSG traceMsg;
    DWORD lastTime = 0;
    BOOL postResult;
    HANDLE thisThread = GetCurrentThread();
    SetThreadPriority(thisThread, THREAD_PRIORITY_IDLE);
    PeekMessage(&traceMsg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
    while(true) {
        postResult = PostThreadMessage(traceThreadID, WM_USER, 0, 0);
        if (postResult != 0)
            break;
        DWORD lastError = GetLastError();
        Sleep(100);
    }
    GetMessage(&traceMsg, NULL, 0, WM_USER);
    printTime();
    SetEvent(traceThreadStartedEvent);
    int flushTimer(0);
    bool needsFlush(false);
    while(true) {
        BOOL result = PeekMessage(&traceMsg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
        if (result != 0 || !needsFlush) {   // there are messages, or we do not need flush. so wait for next message
            result = GetMessage(&traceMsg, NULL, 0, WM_USER);
            if (result == 0) {
                // means WM_QUIT message received
                if ((int)(traceMsg.wParam) == 1234 && (int)(traceMsg.lParam) == 5678) {
                    fprintf(fpTraceFile, "Got WM_QUIT message : stopping thread\n");
                    printTime();
                    fflush(fpTraceFile);
                    SetEvent(traceThreadStartedEvent);
                    resultCode = 0;
                    break;
                }
                else
                    fprintf(fpTraceFile, "Got WM_QUIT message\n");
            }
            else if (result == -1) {    // error happened in GetMessage
                printTime();
                fprintf(fpTraceFile, "Error in GetMessage in the tracer thread. Return value 0x%x %d\n", result, result);
            }
            else {  // normal trace message
                char *buffer = (char *)(traceMsg.wParam);
                if (abs(traceMsg.time - lastTime) > TIMESTAMP_INTERVAL) {
                    lastTime = traceMsg.time;
                    printTime();
                }
                struct timeb currentTime_b;
                ftime(&currentTime_b);
                time_t currentTime_t = currentTime_b.time;
                struct tm *currentTm = localtime(&currentTime_t);
                fprintf(fpTraceFile, "%02u:%02u:%02u.%03u : %s", currentTm->tm_hour, currentTm->tm_min, currentTm->tm_sec, currentTime_b.millitm, buffer);
                needsFlush = true;
                freeTraceBuffer(buffer);
                cnt = (cnt + 1)%10;
                if (!cnt) {
                    if (ftell(fpTraceFile) > MAX_TRACEFILE_SIZE) {
                        printTime();
                        if (!changeTraceFile()) {
                            resultCode = -20;
                            break;
                        }
                    }
                }
            }
        }
        else {  // no messages in queue and we need flush
            fflush(fpTraceFile);
            needsFlush = false;
        }
    }
    return resultCode;
}