networks.cpp

Last change: 2008-02-03 This is the source code of KCeasy。

/*
This file is part of KCeasy (http://www.kceasy.com)
Copyright (C) 2002-2004 Markus Kern <[e-mail]>

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 2
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.
*/
//---------------------------------------------------------------------------
#pragma hdrstop
#include "Networks.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

namespace KCeasyEngine {

// Note: Resolution is limited by TIMER_FUNC_INTERVAL in engine.cpp
// interval for stats update if not all networks connected
static const unsigned int STATS_UPDATE_CONNECTING = 4*1000;
// interval for stats update if all networks connected
static const unsigned int STATS_UPDATE_CONNECTED = 20*1000;


// class TNetwork
// public
bool TNetwork::IsConnected()
{
    // guess connect state based on stats
    return (Users > 0 || Files > 0 || Size > 0);
}

// private
TNetwork::TNetwork(const string& NetName)
:   Algos(NULL),
    Users(0),
    Size(0),
    Files(0),
    Name(NetName)
{
    Algos = new THashAlgoSet();

    // HACK: this will be provided by giFT in the future
    if(NetName == "OpenFT") {
        Algos->AddAlgo("MD5", HASHENC_BASE16);
    } else if(NetName == "Gnutella") {
        Algos->AddAlgo("SHA1", HASHENC_BASE32);
    } else if(NetName == "FastTrack") {
        Algos->AddAlgo("kzhash", HASHENC_BASE16);
        Algos->AddAlgo("FTH", HASHENC_BASE64);
    } else if(NetName == "Ares") {
        Algos->AddAlgo("SHA1", HASHENC_BASE32);
    }
}

TNetwork::~TNetwork()
{
    delete Algos;
}

// class TNetworks
// private

TNetworks::TNetworks(TEngine* ParentEngine)
:   Engine(ParentEngine),
    TotalUsers(0),
    TotalSize(0),
    TotalFiles(0),
    TotalConnected(0)
{

}

TNetworks::~TNetworks()
{
    Reset();
}

void TNetworks::Reset()
{
    Lock();
    while(!Networks.empty()) {
        delete Networks.front();
        Networks.pop_front();
    }
    Release();

    TotalUsers = TotalSize = TotalFiles = 0;
    TotalConnected = 0;
}

void TNetworks::CalculateTotals()
{
    Lock();
    TotalUsers = TotalSize = TotalFiles = 0;
    TotalConnected = 0;
    for(TNetworkIterator itr = Networks.begin();itr != Networks.end(); ++itr) {
        TotalUsers += (*itr)->GetUsers();
        TotalSize += (*itr)->GetSize();
        TotalFiles += (*itr)->GetFiles();
        TotalConnected += (*itr)->IsConnected() ? 1 : 0;
    }
    Release();
}

bool TNetworks::ProcessStats(TGiftCommand *Cmd)
{
    if(Cmd->Name != "STATS")
        return false;

    Lock();
    for(map<string,TGiftCommand>::iterator itr=Cmd->Nodes.begin();itr!=Cmd->Nodes.end();++itr) {
        if((*itr).second.Name == "giFT")
            continue;
        // see if we already have the network in out list
        TNetworkIterator nitr = Networks.begin();
        while(nitr != Networks.end() && (*nitr)->Name != (*itr).second.Name)
            ++nitr;
        // if not insert new network
        if(nitr == Networks.end())
            nitr = Networks.insert(Networks.end(),new TNetwork((*itr).second.Name));
        // update stats
        (*nitr)->Users = string_to_int((*itr).second.GetNode("users").Value);
        (*nitr)->Size = string_to_float((*itr).second.GetNode("size").Value);
        (*nitr)->Files = string_to_int((*itr).second.GetNode("files").Value);
    }
    CalculateTotals();
    Release();
    // notify UI
    Engine->SendCallback(CbcNetworksUpdate,(void*)this,NULL);

    return true;
}


// public

void TNetworks::Update()
{
    if(!Engine || !Engine->IsOnline())
        return;
    Engine->QueueCommand(new TGiftCommand("STATS"));
    LastUpdate = ::GetTickCount();
}

// called periodically by engine thread
bool TNetworks::UpdateIfNecessary()
{
    int Delta = ::GetTickCount() - LastUpdate;
    bool Connected = AllConnected();

    Lock();
    if((!Connected && Delta > STATS_UPDATE_CONNECTING) ||
       (Connected && Delta > STATS_UPDATE_CONNECTED))
    {
        Update();
        Release();
        return true;
    }

    Release();
    return false;
}

TNetwork* TNetworks::GetNetwork(string Name)
{
    Lock();
    for(TNetworkIterator itr = GetBegin(); itr != GetEnd(); ++itr) {
        if((*itr)->GetName() == Name) {
            Release();
            return (*itr);
        }
    }

    Release();
    return NULL;
}

} // namespace KCeasyEngine