hbservercontainer.cxx

Vovida 社区开源的 SIP 协议源码

    }
    for (vector < Data > ::iterator i = itsCDRList.begin();
            i != itsCDRList.end(); ++i)
    {
        listofServers->push_back(*i);
    }
}


/**
 * Get List of Active Servers of a certain type  
 * @param  type  the type of server to search for   
 * @param  listofServers  list of all servers in container that matches the type.  
 */
void
HBServerContainer::getListofActive( const ServerType type, Sptr < vector < Data > > & listofServers )
{
    /// function not used in heartbeat server at this time
}


/**
 * Add a server object that send messages to snmp.   
 * @param  key  Server's address   
 * @param  serverType  type of server.  
 */
void
HBServerContainer::addServerWithSnmp( const Data& key,
                                      const ServerType serverType )
{
    cpLog( LOG_DEBUG, "HBServerContainer::addServerWithSnmp %s",
           convertToString(serverType) );

    /// create a Server with 'new'
    Sptr < ServerWithSnmp > server = new ServerWithSnmp(serverType);

    WriteLockHelper tableHelper(tableLock);

    /// insert the Server in the map
    //serverList.insert(pair< Sptr<Data>, Sptr<Server> >(key, server));
    serverList[key] = server;

}


/**
 * Deal with a heartbeat event from the given server
 * @param  key  Server who sent the heartbeat
 * @return  True if server is recognized, false if not
 */
bool
HBServerContainer::processHeartbeat( const Data& key)
{
    Sptr < Server > serverPtr;

    if (search( key, serverPtr) )
    {
        ReadLockHelper tableHelper(tableLock);

        //cpLog(LOG_DEBUG, "Server found");
        Sptr < ServerWithSnmp > serverWithSnmpPtr;

        /// print data contained in the server object
        switch (serverPtr->getType() )
        {
            case SERVER_JS:
            case SERVER_FS:
            case SERVER_MS:
            case SERVER_RS:
            case SERVER_POS:
            case SERVER_CDR:
            {
                serverWithSnmpPtr.dynamicCast(serverPtr);
                serverWithSnmpPtr->processHeartbeat(key);
            }
            break;
            default:
            break;
        };

        displayServer(*serverPtr);
        return true;
    }
    else
    {
        return false;
    }
}


/**
 * Check all servers to see if they are still actively heartbeating
 */
void
HBServerContainer::doHouseKeeping()
{
    Data serverId;
    Sptr < Server > serverPtr;

    cpLog( LOG_DEBUG_HB, "");
    cpLog( LOG_DEBUG_HB, "****** do HouseKeeping *****");

    ReadLockHelper tableHelper(tableLock);

    if ( !serverList.empty() )
    {
        Sptr < ServerWithSnmp > serverWithSnmpPtr;

        for ( TableIter i = serverList.begin(); i != serverList.end(); ++i)
        {
            serverId = i->first;
            serverPtr = i->second;
            //cpLog( LOG_DEBUG, "%s", serverId.logData() );
            if ( serverPtr->getStatus() != Inactive )
                cpLog( LOG_DEBUG_HB, "%s", serverId.logData() );
            switch (serverPtr->getType() )
            {
                case SERVER_JS:
                case SERVER_FS:
                case SERVER_MS:
                case SERVER_RS:
                case SERVER_POS:
                case SERVER_CDR:
                {
                    serverWithSnmpPtr.dynamicCast(serverPtr);
                    serverWithSnmpPtr->doHouseKeeping(serverId);
                }
                break;
                default:
                break;
            }
        }
    }
    else
    {
        cpLog( LOG_DEBUG_HB, "nothing in server container");
    }

    cpLog( LOG_DEBUG_HB, "****** finished HouseKeeping *****");
    cpLog( LOG_DEBUG_HB, "");
}


/**
 * A change was made to the RS's in the provisioning server. 
 * Delete the stored RS server list and recreate it with the new data.
 */
void
HBServerContainer::updateRSsFromPS()
{

    {
        WriteLockHelper rsHelper(rsLock);

        /// delete all RSs in Server Container
        for (vector < Data > ::iterator i = itsRSList.begin();
                i < itsRSList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete RS: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear RSList
        itsRSList.clear();
    }

    /// reconfigure RSs from scratch
    configRedirectServers();

    displayLists();
}


/**
 * A change was made to the MS's in the provisioning server. 
 * Delete the stored MS server list and recreate it with the new data.
 */
void
HBServerContainer::updateMSsFromPS()
{

    {
        WriteLockHelper msHelper(msLock);

        /// delete all MSs in Server Container
        for (vector < Data > ::iterator i = itsMSList.begin();
                i < itsMSList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete MS: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear MSList
        itsMSList.clear();
    }

    /// reconfigure MSs from scratch
    configMarshalServers();

    displayLists();
}


/**
 * A change was made to the FS's in the provisioning server. 
 * Delete the stored FS server list and recreate it with the new data.
 */
void
HBServerContainer::updateFSsFromPS()
{

    {
        WriteLockHelper fsHelper(fsLock);

        /// delete all FSs in Server Container
        for (vector < Data > ::iterator i = itsFSList.begin();
                i < itsFSList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete FS: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear FSList
        itsFSList.clear();
    }

    /// reconfigure FSs from scratch
    configFeatureServers();

    displayLists();
}


/**
 * A change was made to the JS's in the provisioning server. 
 * Delete the stored JS server list and recreate it with the new data.
 */
void
HBServerContainer::updateJSsFromPS()
{

    {
        WriteLockHelper jsHelper(jsLock);

        /// delete all JSs in Server Container
        for (vector < Data > ::iterator i = itsJSList.begin();
                i < itsJSList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete JS: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear JSList
        itsJSList.clear();
    }

    /// reconfigure JSs from scratch
    configJtapiServers();

    displayLists();
}


/**
 * A change was made to the POS's in the provisioning server. 
 * Delete the stored POS server list and recreate it with the new data.
 */
void
HBServerContainer::updatePOSsFromPS()
{

    {
        WriteLockHelper posHelper(posLock);

        for (vector < Data > ::iterator i = itsPOSList.begin();
                i < itsPOSList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete POS: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear POSList
        itsPOSList.clear();
    }

    /// reconfigure POSs from scratch
    configPolicyServers();

    displayLists();
}


/**
 * A change was made to the CDR's in the provisioning server. 
 * Delete the stored CDR server list and recreate it with the new data.
 */
void
HBServerContainer::updateCDRsFromPS()
{

    {
        WriteLockHelper cdrHelper(cdrLock);

        for (vector < Data > ::iterator i = itsCDRList.begin();
                i < itsCDRList.end(); ++i)
        {
            cpLog( LOG_DEBUG, "delete CDR: %s", i->logData() );
            Data server(*i);
            /// delete from Server Container
            remove(server);
        }

        /// clear CDRList
        itsPOSList.clear();
    }

    /// reconfigure CDRs from scratch
    configCdrServers();

    displayLists();
}


/**
 * A change was made to the Global Config Parms Data on the provisioning server. 
 * Delete the stored parameter(s) and replace it with new values.
 */
void
HBServerContainer::updateHBParmsFromPS()
{
    cpLog( LOG_DEBUG, "updating Heartbeat Parms in RSServerContainer");

    ProvisionInterface& pif = ProvisionInterface::instance();
    try
    {
        WriteLockHelper tableHelper(tableLock);

        /// get pointer to global config object
        VGlobalConfigData globalConfigData;
        pif.getConfigData(globalConfigData);

        int newValue = globalConfigData.getMaxMissedHB();
        int oldValue = serverList.begin()->second->getMaxMissedHB();
        cpLog( LOG_DEBUG, "maxMissedHB old:%d new: %d", oldValue, newValue );

        if (( !serverList.empty() ) && ( oldValue != newValue ))
        {
            Data serverId;
            Sptr < Server > serverPtr;

            for ( TableIter i = serverList.begin(); i != serverList.end(); ++i)
            {
                serverId = i->first;
                serverPtr = i->second;
                serverPtr->setMaxMissedHB( newValue );
            }
        }
    }
    catch (VIoException& e)
    {
        cpLog(LOG_ALERT, "Failed to get data from Provisioning Server, reason %s", e.getDescription().c_str());
    }
    catch (VException& e)
    {
        cpLog(LOG_ALERT, "Failed to connect to Provisioning Server, reason %s", e.getDescription().c_str());
    }
}


/**
 * Display lists of server by type.
 */
void
HBServerContainer::displayLists()
{
    ReadLockHelper jsHelper(jsLock);
    ReadLockHelper fsHelper(fsLock);
    ReadLockHelper msHelper(msLock);
    ReadLockHelper rsHelper(rsLock);
    ReadLockHelper posHelper(posLock);
    ReadLockHelper cdrHelper(cdrLock);

    cpLog( LOG_DEBUG, "----------- Jtapi Servers ---------");
    for (vector < Data > ::iterator i = itsJSList.begin();
            i < itsJSList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "JS: %s", i->logData() );
    }

    cpLog( LOG_DEBUG, "----------- Feature Servers ---------");
    for (vector < Data > ::iterator i = itsFSList.begin();
            i < itsFSList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "FS: %s", i->logData() );
    }

    cpLog( LOG_DEBUG, "----------- Marshal Servers ---------");
    for (vector < Data > ::iterator i = itsMSList.begin();
            i < itsMSList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "MS: %s", i->logData() );
    }

    cpLog( LOG_DEBUG, "----------- Redirect Servers --------");
    for (vector < Data > ::iterator i = itsRSList.begin();
            i < itsRSList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "RS: %s", i->logData() );
    }

    cpLog( LOG_DEBUG, "----------- Policy Servers --------");
    for (vector < Data > ::iterator i = itsPOSList.begin();
            i < itsPOSList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "POS: %s", i->logData() );
    }

    cpLog( LOG_DEBUG, "----------- Cdr Servers --------");
    for (vector < Data > ::iterator i = itsCDRList.begin();
            i < itsCDRList.end(); ++i)
    {
        cpLog( LOG_DEBUG, "CDR: %s", i->logData() );
    }
}


/**
 * The Provisioning Server is notifying us of a change in RS's.
 */
void
updateHBRedirectServers(const string& data, const string& fileName, bool)
{
    /// update RS list
    HBServerContainer::instance().updateRSsFromPS();
}



/**
 * The Provisioning Server is notifying us of a change in MS's.
 */
void
updateHBMarshalServers(const string& data, const string& fileName, bool)
{
    /// update MS list
    HBServerContainer::instance().updateMSsFromPS();
}



/**
 * The Provisioning Server is notifying us of a change in FS's.
 */
void
updateHBFeatureServers(const string& data, const string& fileName, bool)
{
    /// update FS list
    HBServerContainer::instance().updateFSsFromPS();
}


/**
 * The Provisioning Server is notifying us of a change in JS's.
 */
void
updateHBJtapiServers(const string& data, const string& fileName, bool)
{
    /// update JS list
    HBServerContainer::instance().updateJSsFromPS();
}

/**
 * The Provisioning Server is notifying us of a change in POS's.
 */
void
updateHBPolicyServers(const string& data, const string& fileName, bool)
{
    /// update POS list
    HBServerContainer::instance().updatePOSsFromPS();
}

/**
 * The Provisioning Server is notifying us of a change in CDR's.
 */
void
updateHBCdrServers(const string& data, const string& fileName, bool)
{
    /// update CDR list
    HBServerContainer::instance().updateCDRsFromPS();
}

/**
 * The Provisioning Server is notifying us of a change in Heartbeat Parms.
 */
void
updateHBHeartbeatParms(const string& data, const string& fileName, bool)
{
    /// update Heartbeat Parms
    HBServerContainer::instance().updateHBParmsFromPS();
}

// End of File