Beesnest/DcEnginesSet.cpp

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest 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 2 of the License, or
(at your option) any later version.

Beesnest 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 Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

/**
 * DcEnginesSet.cpp: implementation of the CdcEnginesSet class.
 * for documentation see the header file.
 */
#include "DcEnginesSet.h"

void CdcEnginesSet::Login ()
{
    if (nEngineTimeLimit > 0)
    {   /* Start the release thread. */
        isReleseThreadGo = new volatile bool (true);    /* Signal to thread to Go. */
        poLimitMutex  = new CdcMutex ();
        /* That is because I start this thread in every login. */
        oReleaseThread.CloseThread ();
        oReleaseThread.MakeThread (DcReleaseEngine, (void*) this);
        oReleaseThread.SetPriority (DC_TP_LOW);
    }
}


void CdcEnginesSet::Logout ()
{
    if (nEngineTimeLimit > 0 && isReleseThreadGo)
        *isReleseThreadGo = false;  /* Signal to thread to exit. */
    if (poLimitMutex) poLimitMutex->Lock ();
    for (CdcEnginesSet::t_engines_map::iterator pos = mEngines.begin ();
         pos != mEngines.end (); ++pos)
        if (pos->second)
        {
            mEngines.erase (pos);
            if (pos->second->pEngine)
                delete (pos->second->pEngine);
            delete pos->second;
        }
    if (poLimitMutex) poLimitMutex->Unlock ();
}


IdcEngine* CdcEnginesSet::GetEngine (const CdcString& name)
{
    IdcEngine* peng = NULL;
    oMutex.Lock ();
    /* Try to find in the Engines map. */
    CdcEnginesSet::t_engines_map::iterator itr =
        mEngines.find (name);
    if (itr != mEngines.end () && itr->second != NULL)
    {   /* Found an engine. */
        peng = itr->second->pEngine;
        delete (itr->second);   /* The engine is still alive!!! */
        mEngines.erase (itr);
    }
    oMutex.Unlock ();
    return peng;
}

bool CdcEnginesSet::PutEngine (const CdcString& name, IdcEngine* peng)
{
    oMutex.Lock ();
    bool ret = false;
    /* Try to find in the Engines map. */
    CdcEnginesSet::t_engines_map::iterator itr =
        mEngines.find (name);
    if (itr == mEngines.end () && peng)
    {   /* Engine doesn't exist yet. */
        peng->Stored ();    /* Signal "Stored" to engine. */
        mEngines[name] = new CdcEngineNode (peng);
        ret = true;
    }
    oMutex.Unlock ();
    return ret;
}

int DcReleaseEngine (void* pParam)
{
    CdcEnginesSet* pThis = (CdcEnginesSet*)pParam;
    if (pThis == NULL) return 1;   /* if pParam is not valid. */
    volatile bool* pRun = pThis->isReleseThreadGo;
    CdcMutex* pMutex = pThis->poLimitMutex;
    int time_limit = pThis->nEngineTimeLimit;
    while (*pRun)
    {   /* Wait for 10 sec between cycles. */
        Sleep (10000);
        pMutex->Lock ();
        if (*pRun == false) break;
        CdcHttpTime now = CdcHttpTime::GetCurrentTime ();
        for (CdcEnginesSet::t_engines_map::iterator pos =
            pThis->mEngines.begin (); pos != pThis->mEngines.end (); ++pos)
            if (pos->second != NULL &&
                now - pos->second->tStartIdle > time_limit)
            {   /* Release engine . */
                pThis->oMutex.Lock ();
                if (pos->second->pEngine)
                    delete (pos->second->pEngine);
                delete (pos->second);
                pThis->mEngines.erase (pos);
                pThis->oMutex.Unlock ();
                break;  /* I release just one in each loop. */
            }
        pMutex->Unlock ();
    }
    delete pRun;    /* That was allocated by the class. */
    delete pMutex;
    return 0;
}