src/main/Cache.cpp

Go to the documentation of this file.

#include "Cache.h"

#include "exceptions.h"

#include "functions.h"

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>

Cache::Cache(const string& configurationDirectory) throw (Exception) {

        loadConfFile(configurationDirectory + "/config.cfg");
        loadUserConfFile(configurationDirectory + "/users.cfg");

        logger.setParameters(config);
        logger.logLoadConfig(configurationDirectory, config.logLevel);

        gc = new GarbageCollector(this, config.GCInterval);
}

Cache::~Cache() {
        for (map<string, User *>::iterator i = users.begin(); i != users.end(); ++i) {
                cout << "Deleting " << i->first << endl;
                delete i->second;
        }

        delete gc;

}

void Cache::reloadConfig(const string& configurationDirectory) {
        loadConfFile(configurationDirectory + "/config.cfg");
        gc->setInterval(config.GCInterval);
        logger.logLoadConfig(configurationDirectory, config.logLevel);
        logger.setParameters(config);
}

User * Cache::login(const string& name) {
        logger.logLogin(name);
        return users[name];
}

void Cache::loadConfFile(const string& confFilename) throw (Exception) {

        ifstream file(confFilename.c_str());

        if (!file) {
                throw FileNotFound(confFilename);
        }

        Settings newConfig;
        bool assigned[7] = { 0, 0, 0, 0, 0, 0, 0 };
        int index;

        const int bufferSize = 128;
        char buffer[bufferSize];

        int line = 0;

        while (file.getline(buffer, bufferSize)) {

                ++line;

                string s = removeBlanks(string(buffer));

                if (s.length() == 0) {
                        continue;
                }

                if (!s.compare(0, 9, "logLevel=")) {

                        index = 0;
                        newConfig.logLevel = extractValue(s, 9, confFilename, line);

                } else if (!s.compare(0, 11, "numThreads=")) {

                        index = 1;
                        newConfig.numThreads = extractValue(s, 11, confFilename, line);

                } else if (!s.compare(0, 11, "GCInterval=")) {

                        index = 2;
                        newConfig.GCInterval = extractValue(s, 11, confFilename, line);

                } else if (!s.compare(0, 12, "maxCapacity=")) {

                        index = 3;
                        newConfig.maxCapacity = extractValue(s, 12, confFilename, line);

                } else if (!s.compare(0, 12, "logInterval=")) {

                        index = 4;
                        newConfig.logInterval = extractValue(s, 12, confFilename, line);

                } else if (!s.compare(0, 16, "logBufferLength=")) {

                        index = 5;
                        newConfig.logBufferLength = extractValue(s, 16, confFilename, line);

                } else if (!s.compare(0, 13, "logDirectory=")) {

                        index = 6;
                        newConfig.logDirectory = s.substr(13);

                } else {
                        throw ConfigParseException("Config parse error", confFilename, line);
                }

                if (assigned[index]) {
                        throw ConfigSemanticException("Double variable definition", confFilename, line);
                }
                assigned[index] = 1;

        }

        if (!file.eof() && file.fail()) {
                throw IOException(confFilename);
        }

        cout << "Cache: \tconfiguration read from: " << confFilename << endl;
        config = newConfig;

}

void Cache::loadUserConfFile(const string& confFilename) throw (Exception) {

#if 1
        string login = SINGLE_USER;
        User * user = new User(this, login, 0);
        users[login] = user;
        cout << "Cache: \tuser registered: " << login << endl;
#else
        ifstream file(confFilename.c_str());

        if (!file) {
                throw FileNotFound(confFilename);
        }

        const int bufferSize = 128;
        char buffer[bufferSize];

        int line = 0;
        bool lastReadQuota = 1;
        string login;

        while (file.getline(buffer, bufferSize)) {

                ++line;

                string s = removeBlanks(string(buffer));

                if (s.length() == 0) {
                        continue;
                }

                if (lastReadQuota) {

                        if (s.find("=") != string::npos) {
                                throw ConfigParseException("Illegal character in username: \"=\"", confFilename, line);
                        }

                        lastReadQuota = 0;
                        login = s;

                } else {

                        lastReadQuota = 1;

                        if (!s.compare(0, 6, "quota=")) {

                                int quota = extractValue(s, 6, confFilename, line);

                                if (quota <= 0) {
                                        throw ConfigSemanticException("Quota seems to be too small", confFilename, line);
                                }

                                User * user = new User(this, login, quota);
                                users[login] = user;
                                cout << "Cache: \tuser registered: " << login << endl; // << " with quota of " << quota << endl;

                        } else {
                                throw ConfigParseException("Config parse error", confFilename, line);
                        }

                }

        }

        if (!file.eof() && file.fail()) {
                throw IOException(confFilename);
        }

        if (!lastReadQuota) {

                throw ConfigSemanticException("No user config specified", confFilename, line);

        }

        cout << "Cache: \tuser configuration read from: " << confFilename << endl;
#endif

}

---