DB.cpp

Go to the documentation of this file.

/*
 * DB.cpp
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <HSEP/DirTool.h>
#include <HSEP/FileTool.h>
#include <HSEP/ErrorCode.h>

#include <HSEPData/DB.h>
#include <HSEPData/DBStatementCatalog.h>

#include <dlfcn.h>
#include <sys/types.h>
#include <errno.h>
#include <string.h>
#include <iostream>
#include <fstream>

using namespace std;
using namespace HSEP;

typedef HSEPData::DBEnvironment* (*createEnvironmentType)();

namespace HSEPData {

    DB* DB::aInstance = nullptr;

    DB::DB(string& pConfigPathRef, string& pQueryPathRef, string& pDriverPathRef) : HSEPObject("DB") {

        DB::aInstance = this;

        aDBDrvLibraries = new DBDrvLibDictionary();
        aEnvironments   = new DBEnvironmentQueueMap();

        DBStatementCatalog::init(pQueryPathRef);

        ErrorCode vErrorCode = EC::NotCatalogedError;

        loadDrivers(pDriverPathRef);
        vErrorCode = loadInstances(pConfigPathRef);

        //TODO: evaluate loadDrivers and loadInstances before deciding to setValid ...

        if (EC::OK == vErrorCode) {
            setValid();
        }

    } // DB constructor

    DB::~DB() {

        unloadInstances();

        DBStatementCatalog::destroy();

        delete aEnvironments;
        delete aDBDrvLibraries;

    } // DB destructor

    void DB::loadDrivers(string& pDriverPathRef) {

        // In the next version, must use a DriverSet instead of a particular
        // coding for loading the database drivers.
        //
        // In fact, the DriverSet was derived from this coding and made
        // generic, but by now it already superseded this function.
        //

        aDBDrvLibraries->clear();

        StringArray vFileNames;

        string vPrefix("libHSEPDataDrv");
        size_t vPrefixLen = vPrefix.length();

        if (EC::OK==DirTool::traverse(vFileNames,pDriverPathRef,vPrefix.c_str())) {

            vFileNames.forEach([&](string* pFileName){

                string vFilePath = pDriverPathRef;
                vFilePath.append("/");
                vFilePath.append(*pFileName);

                size_t vSize = pFileName->size();

                // must be smaller than vSize ... so, vSize is a safe length
                char* vTypeName = (char*)malloc(vSize+1);
                memset(vTypeName,0,vSize+1);

                strncpy(vTypeName,pFileName->c_str()+vPrefixLen,vSize-vPrefixLen-3); // quit the first part (libHSEPDataDrv) and the ".so"

                DBDrvLib* vLibrary = new DBDrvLib(vFilePath);

                if (vLibrary->valid()) {
                    aDBDrvLibraries->put(vTypeName,vLibrary);
                } // if (vLibrary->isValid())
                else {
                    cerr << "Loading library " << vTypeName << " " << vLibrary->lastErrorRef() << endl;
                    //delete vLibrary;
                }
                free(vTypeName);

            });

        } // if (DirTool::traverse(vFileNames,pDriverPath,"libBWDataDrv"))

    } // DB::loadDrivers

    ErrorCode DB::loadInstances(string& pConfigPathRef) {

        ErrorCode vResult = EC::NotCatalogedError;

        aEnvironments->clear();

        StringArray vFileNames;
        bool        vFailed = false;

        if (EC::OK==DirTool::traverse(vFileNames,pConfigPathRef,"db")) {

            vFileNames.forEach([&](string* pFileName) {

                StringDictionary   vDBConfig;
                string             vFileName(pConfigPathRef);

                vFileName.append("/");
                vFileName.append(*pFileName);

                fstream vFile;

                vFile.open(vFileName,ios::in); // take care, normally this is read-only

                if (!vFile.fail()) {

                    FileTool::retrieve(vDBConfig,vFile);

                    string& vDBType     = vDBConfig.ref("DBType");
                    string& vConnString = vDBConfig.ref("ConnString");
                    string& vUser       = vDBConfig.ref("User");
                    string& vPassword   = vDBConfig.ref("Password");
                    string& vSchema     = vDBConfig.ref("Schema");

                    bool    vHasSyncTo  = vDBConfig.has("SyncTo");
                    string  vSyncTo;
                    string  vSyncPath;

                    if (vHasSyncTo) {
                        vSyncTo   = string(vDBConfig.ref("SyncTo"));
                        vSyncPath = string(vDBConfig.ref("SyncPath"));
                    }

                    int vInstances = stoi(vDBConfig.ref("Instances"));

                    (*aEnvironments)[*pFileName] = new DBEnvironmentQueue();

                    for (int vIdx=0; vIdx< vInstances; vIdx++) {

                        DBDrvLib& vLibrary = aDBDrvLibraries->ref(vDBType);

                        DBEnvironment* vEnvironment = vLibrary.getEnvironmentPtr(
                            vConnString,
                            vUser,
                            vPassword,
                            vSchema
                        );

                        if (nullptr != vEnvironment) {

                            vEnvironment->addID(vIdx);

                            if (vHasSyncTo) {
                                vEnvironment->addSyncTo(vSyncTo);
                                vEnvironment->addSyncPath(vSyncPath);
                            }
                            (*aEnvironments)[*pFileName]->addEnvironment(vEnvironment);

                        }
                        else {
                            setLastError(vLibrary.lastErrorRef());
                            vFailed = true;
                            break;
                        }

                    } // for (int vIdx=0; vIdx< vInstances; vIdx++) {
                }
                else {
                    vFailed = true;
                    cerr << "ERR:" << to_string(errno) << endl;
                    vResult = EC::CantReadDBConfFile;
                }

            });

            if (!vFailed) {
                vResult = EC::OK;
            }

        } // if (EC::OK==DirTool::traverse(vFileNames,pConfigPathRef,"db"))

        return vResult;

    } // DB::loadInstances

    void DB::unloadDrivers() {
        // not necessary, the corresponding Dictionary clean the contents
    } // DB::unloadDrivers

    void DB::unloadInstances() {

        DBEnvironmentQueueMapIterator vEnvIterator;
        for (vEnvIterator = aEnvironments->begin() ; vEnvIterator != aEnvironments->end() ; vEnvIterator++) {
            delete vEnvIterator->second;
            vEnvIterator->second = nullptr;
        }

    } // DB::unloadInstances


    DBEnvironment* DB::getEnvironmentPtr(string& pEnvironmentTypeRef) {

        DBEnvironmentQueue* vQueue = (*aEnvironments)[pEnvironmentTypeRef];
        if (!vQueue) {
            return nullptr;
        }
        return vQueue->getEnvironmentPtr();

    } // DB::getEnvironment

    void DB::releaseEnvironment(string& pEnvironmentTypeRef, DBEnvironment* pEnvironmentPtr) {

        DBEnvironmentQueue* vQueue = (*aEnvironments)[pEnvironmentTypeRef];
        vQueue->releaseEnvironment(pEnvironmentPtr);

    } // DB::releaseEnvironment

} // HSEPData namespace