Beesnest/DcAdaptersSet.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
*/

/**
 * DcAdaptersSet.cpp: implementation of the CdcAdaptersSet class.
 * for documentation see the header file.
 */

#include "DcAdaptersSet.h"

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


void CdcAdaptersSet::Logout ()
{
    isLoggedIn = false;
    if (isReleseThreadGo) *isReleseThreadGo = false;    /* Signal to thread to exit. */
    if (poLimitMutex) poLimitMutex->Lock ();        /* So limit thread doesn't run. */
    for (CdcAdaptersSet::t_adapters_map::iterator pos = mAdapters.begin ();
         pos != mAdapters.end (); ++pos)
        ReleaseAdapter ((*pos).first, true);    /* Release just if adapter is free. */
    if (poLimitMutex) poLimitMutex->Unlock ();
}


uint CdcAdaptersSet::GetAdapter (BufferHolder name)
{
    if (!isLoggedIn) return 0;
    uint AID = 0;
    CdcString s_name (name);
    oMutex.Lock ();
    /* Try to find in the Adapters List. */
    for (CdcAdaptersSet::t_adapters_map::iterator pos =
        mAdapters.begin (); pos != mAdapters.end (); ++pos)
        if (pos->second != NULL && pos->second->sName == s_name)
        {   /* Found un adapter. */
            if (pos->second->isFree)
            {   /* Mark as taken and return its AID. */
                pos->second->isFree = false;
                oMutex.Unlock ();
                return pos->second->nAID;
            }
            else if (pos->second->isMultiEngine == false)
            {   /* This adapter is taken and not multi-engine - return 0. */
                oMutex.Unlock ();
                return 0;
            }
        }
    /* Adapter is not in map, or it is multi-engine - get from bank. */
    IdcAdapter* padapter;
    AID = CdcAdaptersBank::GetAdapterPointer (s_name, &padapter);
    if (AID > 0 && padapter != NULL)
    {   /* Inser new adapter to map. */
        CdcAdapterNode* pnode = new CdcAdapterNode;
        if (pnode != NULL)
        {
            pnode->pAdapter = padapter;
            pnode->nValidSeconds = CdcParameters::ToInt (CdcParameters::
                GetParam ("Adapters->" + s_name + "->Sec-To-Logout"));
            pnode->isMultiEngine = pnode->pAdapter->IsMultiUse () &&
                CdcParameters::GetParam ("Adapters->" + s_name + "->Multi-Engine")
                == "yes";
            pnode->isStorable = !pnode->isMultiEngine && CdcParameters::GetParam
                ("Adapters->" + s_name + "->Storable") == "yes";
            pnode->isFree = false;
            pnode->sName = s_name;
            pnode->nAID = AID;
            mAdapters [AID] = pnode;
        }
    }
    oMutex.Unlock ();
    return AID;
}


void CdcAdaptersSet::ReleaseAdapter (uint AID, bool check_free)
{
    oMutex.Lock ();
    t_adapters_map::iterator itr = mAdapters.find (AID);
    if (itr != mAdapters.end () && itr->second != NULL &&
        (!check_free || itr->second->isFree))
    {
        CdcAdaptersBank::ReleaseAdapter (itr->second->sName);   /* Mark adapter
                                            as free in Bank, if relevant. */
        mAdapters.erase (AID);
        /* Here I delete the adapter that was allocated by Adapter Bank. */
        delete itr->second->pAdapter;
        delete itr->second;
    }
    oMutex.Unlock ();
}

void CdcAdaptersSet::AdapterDone (uint AID)
{
    oMutex.Lock ();
    t_adapters_map::iterator itr = mAdapters.find (AID);
    if (itr != mAdapters.end () && itr->second != NULL)
    {
        itr->second->isFree = true;
        if (itr->second->isStorable)
            itr->second->tStartIdle = CdcHttpTime::GetCurrentTime ();
        else
        {
            oMutex.Unlock ();
            ReleaseAdapter (AID);
            return;
        }
    }
    oMutex.Unlock ();
}


BufferHolder CdcAdaptersSet::Read (unsigned int AID, BufferHolder address)
    throw (BufferHolder)
{
    t_adapters_map::iterator itr = mAdapters.find (AID);
    if (itr != mAdapters.end () && itr->second != NULL)
        return itr->second->pAdapter->Read (address);
    return BufferHolder (EMPTY_STR.c_str ());
}

bool CdcAdaptersSet::Write (uint AID, BufferHolder address, BufferHolder value)
     throw (BufferHolder)
{
    t_adapters_map::iterator itr = mAdapters.find (AID);
    if (itr != mAdapters.end () && itr->second != NULL)
        return itr->second->pAdapter->Write (address, value);
    return false;
}


int DcRelease (void* pParam)
{
    CdcAdaptersSet* pThis = (CdcAdaptersSet*)pParam;
    if (pThis == NULL) return 1;   /* if pParam is not valid. */
    volatile bool* pRun = pThis->isReleseThreadGo;
    CdcMutex* pMutex = pThis->poLimitMutex;
    while (*pRun)
    {
        Sleep (10000);
        pMutex->Lock ();
        if (*pRun == false) break;  /* That will release the mutex as well. */
        CdcHttpTime now = CdcHttpTime::GetCurrentTime ();
        for (CdcAdaptersSet::t_adapters_map::iterator pos =
            pThis->mAdapters.begin (); pos != pThis->mAdapters.end (); ++pos)
            if (pos->second != NULL &&
                pos->second->isFree &&
                pos->second->nValidSeconds > 0 &&
                now - pos->second->tStartIdle > pos->second->nValidSeconds)
            {   /* Release adapter (if it free). */
                pThis->ReleaseAdapter (pos->first, true);
                break;  /* I release just one in each loop. */
            }
        pMutex->Unlock ();
    }
    delete pRun;    /* That was allocated by the class. */
    delete pMutex;  /* That was allocated by the class. */
    return 0;
}