src/main/ServerLogger.cpp

Go to the documentation of this file.

#include <ctime>
#include <sstream>
#include <iostream>
#include <fstream>
#include <cerrno>
#include <csignal>
#include <cstring>

#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "ServerLogger.h"
#include "functions.h"

void ServerLogger::operator()() {
        while (true) { //evil l00p ]:->
                saveLogs();
                usleep(1000 * interval);
        }
}

ServerLogger::ServerLogger(unsigned ninterval, std::string ndirectory) {

        pthread_mutex_init(&mutex, NULL);

        interval = ninterval;
        directory = ndirectory;
        reqId = 1;

        time_t now;
        now = time(NULL);
        struct tm *ts;
        ts = localtime(&now);
        char buf[80];
        strftime(buf, sizeof(buf), "%Y-%m-%d %H.%M.%S", ts);
        dumpToFile = false;

        if (mkdir(directory.c_str(), S_IREAD | S_IWRITE | S_IRGRP | S_IROTH | S_IXUSR | S_IXGRP | S_IXOTH) == -1) {
                if (errno == EEXIST) {
                        dumpToFile = true;
                }
        } else {
                dumpToFile = true;
        }

        if (dumpToFile) {
                fileName = directory + "//";
                fileName += buf;

                std::ofstream * of = new std::ofstream(fileName.c_str(), std::ios::out);

                //of->open(fileName.c_str(), ios::out);
                if (of) {
                        output = of;
                } else {
                        dumpToFile = false;
                        output = &std::cout;
                }
        } else {
                output = &std::cout;
        }

        int ret;
        if ((ret = pthread_create(&threadID, NULL, ServerLoggerThread, this))) {
                fprintf(stderr, "Server:\tduring starting logger: pthread_create: %s\n", strerror(ret));
                exit(1);
        }
}

ServerLogger::~ServerLogger() {

        pthread_kill(threadID, SIGUSR1);

        output->flush();
        if (dumpToFile) {
                delete output;
        }

}

void ServerLogger::saveLogs() {

        //      std::cout<<"save logow do pliku"<<std::endl;

        MUTEX_LOCK(mutex);
        std::queue<std::string> copy = logBuffer;
        while (!logBuffer.empty()) {
                logBuffer.pop();
        }
        MUTEX_UNLOCK(mutex);

        while (!copy.empty()) {

                std::string log = copy.front();

                *output << log;
                output -> flush();

                copy.pop();
        }

        //      std::cout<<"koniec save logow do pliku"<<std::endl;
}

void ServerLogger::logNewConnection(const std::string& ip, unsigned port) {
        //      std::cout<<"logNewConnection"<<std::endl;
        std::ostringstream portStr;
        portStr << port;
        MUTEX_LOCK(mutex);
        logBuffer.push("NEW CONNECTION FROM: " + ip + ":" + portStr.str() + "\n");
        MUTEX_UNLOCK(mutex);
}
void ServerLogger::logConnectionRemoved(const std::string& ip, unsigned port) {
        //      std::cout<<"logConnectionRemoved"<<std::endl;
        std::ostringstream portStr;
        portStr << port;
        MUTEX_LOCK(mutex);
        logBuffer.push("REMOVED CONNECTION: " + ip + ":" + portStr.str() + "\n");
        MUTEX_UNLOCK(mutex);
}
void ServerLogger::logWaitingForNewRequest() {
        //      std::cout<<"logWaitingForNewRequest"<<std::endl;
        MUTEX_LOCK(mutex);
        logBuffer.push("WAITING FOR NEW REQUEST\n");
        MUTEX_UNLOCK(mutex);
}
long long ServerLogger::logRequestStart(std::vector<std::string> fields) {
        //      std::cout<<"logRequestStart"<<std::endl;
        MUTEX_LOCK(mutex);
        std::string req = "";
        for (unsigned i = 0; i < fields.size(); i++)
                req += fields[i] + "|";
        long long reqAct = reqId++;
        std::ostringstream idStr;
        idStr << reqAct;
        logBuffer.push("STARTED PROCESSING REQUEST: ID=" + idStr.str() + " REQ=" + req + "\n");
        MUTEX_UNLOCK(mutex);
        return reqAct;
}

long long ServerLogger::logRequestStart(std::vector<std::string> fields, std::string object) {
        //      std::cout<<"logRequestStart"<<std::endl;
        MUTEX_LOCK(mutex);
        std::string req = "";
        for (unsigned i = 0; i < fields.size(); i++)
                req += fields[i] + "|";
        req += object + "|";
        long long reqAct = reqId++;
        std::ostringstream idStr;
        idStr << reqAct;
        logBuffer.push("STARTED PROCESSING REQUEST: ID=" + idStr.str() + " REQ=" + req + "\n");
        MUTEX_UNLOCK(mutex);
        return reqAct;
}

void ServerLogger::logRequestPerformed(long long id) {
        //      std::cout<<"logRequestPerformed"<<std::endl;
        MUTEX_LOCK(mutex);
        std::ostringstream idStr;
        idStr << id;
        logBuffer.push("PROCESSED REQUEST ID=" + idStr.str() + "\n");
        MUTEX_UNLOCK(mutex);
}
void ServerLogger::logReplySent(long long id) {
        //      std::cout<<"logReplySent"<<std::endl;
        MUTEX_LOCK(mutex);
        std::ostringstream idStr;
        idStr << id;
        logBuffer.push("SENT REPLY TO REQUEST ID=" + idStr.str() + "\n");
        MUTEX_UNLOCK(mutex);
}
void ServerLogger::logConnectionTimeout() {
        //      std::cout<<"logReplySent"<<std::endl;
        MUTEX_LOCK(mutex);
        logBuffer.push("CONNECTION TIMED OUT\n");
        MUTEX_UNLOCK(mutex);
}

void ServerLogger::logSocketError() {
        MUTEX_LOCK(mutex);
        logBuffer.push("TERRIBLE SOCKET ERROR\n");
        logBuffer.push(std::string(strerror(errno)) + "\n");
        MUTEX_UNLOCK(mutex);
}

void * ServerLoggerThread(void * arg) {

        ServerLogger * l = (ServerLogger *) arg;

        l->operator ()();

        return NULL;

}

//void Logger::push(Log log) {
//      log.time = Cache::getActualTime();
//      MUTEX_LOCK(mutex);
//      logBuffer.push(log);
//      MUTEX_UNLOCK(mutex);
//}

---