ConnectionKeeper.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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.

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

*/

#include "Qt.h"
#include "ConnectionKeeper.h"
#include "NodeCache.h"
#include "NodeCacheFilters.h"
#include "UdpHostCache.h"
#include "Imports.cpp"

using namespace Gnutella::Bootstrapping;

namespace Gnutella {
namespace Bootstrapping {

enum Constants
{
    UdpPingTimeout      = 2000,
    UdpPingTries        = 5,
    UdpPingsPerTry      = 10
};

static const float HighUptimeThreshold  = 0.7;

class ConnectionKeeperPrivate
{
    REFERENCE_OBJECT (ConnectionKeeperPrivate)

public:
    LocalPeer       *localPeer;
    UdpHostCache    *udpHostCache;
    SlotAllocator   *slotAllocator;
    NodeCache       *nodeCache;
    bool            isBootstrapping;
    QTimer          bootstrappingTimer;
    QDateTime       bootstrappingStart;

    NodeSet         getBootstrapNodes (int count);
    NodeSet         getConnectNodes (int count);

    ConnectionKeeperPrivate (LocalPeer *localPeer_)
     :  localPeer (localPeer_),
        udpHostCache (localPeer_->udpHostCache()),
        slotAllocator (localPeer->slotAllocator()),
        nodeCache (localPeer->nodeCache()),
        isBootstrapping (false),
        bootstrappingTimer(), bootstrappingStart()
    {}

};

} // namespace Bootstrapping;
} // namespace Gnutella;

NodeSet ConnectionKeeperPrivate::getBootstrapNodes (int count)
{
    NodeCache::NodeAvailability availability = NodeCache::UnknownAvailability;
    NodeSet nodes;
    if (count == 0)
        return nodes;
    // Create a predicate object
    HighUptimeHost highUptimeHost (uint(HighUptimeThreshold *
                                        DailyUptime::MaximalUptime));
    nodes += nodeCache->getNodes (count - nodes.count(), availability, true,
                                  highUptimeHost);
    nodes += nodeCache->getNodes (count - nodes.count(), availability, true);
    nodes += nodeCache->getNodes (count - nodes.count(), availability, false,
                                  highUptimeHost);
    nodes += nodeCache->getNodes (count - nodes.count(), availability, false);
    return nodes;
}

NodeSet ConnectionKeeperPrivate::getConnectNodes (int count)
{
    NodeSet nodes;
    NodeCache::NodeAvailability availability = NodeCache::UnknownAvailability;
    if (count == 0)
        return nodes;
    if (localPeer->isUltrapeer())
        nodes += nodeCache->getNodes (count - nodes.count(), availability,
                                        true, HasUltrapeerSlots());
    else
        nodes += nodeCache->getNodes (count - nodes.count(), availability,
                                        true, HasLeafSlots());
    nodes += nodeCache->getNodes (count - nodes.count(), availability, true);
    return nodes;
}

ConnectionKeeper::ConnectionKeeper (LocalPeer *localPeer)
 :  p (new ConnectionKeeperPrivate (localPeer))
{
    connect (&p->bootstrappingTimer,    SIGNAL (timeout()),
             this,                      SLOT (bootstrap()));
}

ConnectionKeeper::~ConnectionKeeper()
{
    delete p;
}

void ConnectionKeeper::bootstrap()
{
    if (!p->slotAllocator->isBootstrapping()) {
        p->isBootstrapping = false;
        p->bootstrappingTimer.stop();
        return;
    }

    if (p->isBootstrapping == false) {
        p->isBootstrapping = true;
        p->bootstrappingStart = QDateTime::currentDateTime();
        p->bootstrappingTimer.start (UdpPingTimeout);
        // Try both over TCP and UDP. UDP might not be working for some nodes:
        keepConnection(); // Try TCP connections. UDP pinging is done below.
    }

    QDateTime now = QDateTime::currentDateTime();
    if (now < p->bootstrappingStart.addMSecs (UdpPingTries * UdpPingTimeout)) {
        connect (p->nodeCache,  SIGNAL (nodeAdded()),
                 this,          SLOT (keepConnection()),
                 Qt::QueuedConnection);
        doUdpPinging();
    } else {
        // After some time we discontinue sending out UDP pings and try
        // querying a UHC.
        // \todo Wait longer before issuing another UHC query! Hostname lookup
        // may take a few seconds.
        // \todo An empty chace could cause doUhcQuery to be called too often!
        // It is called from keepConnection() and doUdpPinging().
        keepConnection();
        doUhcQuery();
    }
    // \todo Add GWebCache support? Possible after completing the HTTP classes.
}

void ConnectionKeeper::keepConnection()
{
    int count = p->slotAllocator->freeHandshakingSlots();
    if (count <= 0) {
        /*  We need to listen to the signal only while bootstrapping from UHC.
            The lack of free handshaking slots indicates we have some node
            addresses now. If none works, we will query a UHC again.    */
        disconnect (p->nodeCache,   SIGNAL (nodeAdded()),
                    this,           SLOT (keepConnection()));
        return;
    }

    // Let the rest of the slots for incomming connections!
    if (p->localPeer->isUltrapeer() && p->slotAllocator->isWellConnected())
        return;

    if (!p->localPeer->isUltrapeer() && !p->slotAllocator->hasFreeUltrapeerSlots())
        return;

    NodeSet nodes;
    nodes += p->getConnectNodes (count - nodes.count());
    nodes += p->getBootstrapNodes (count - nodes.count());

    foreach (NodeAddress nodeAddress, nodes) {
        p->localPeer->connectToPeer (nodeAddress.hostAddress().toString(),
                                     nodeAddress.hostPort());
    }
    if (nodes.count() == 0) {
        /*  \todo Seems like the nodeCache got empty!
            - If we have some connections than we will get some new pongs.
            Just have to wait, connect the signal from NodeCache::nodeAdded()
            Run a timer, if no new nodes in a while, do bootstrapping?
            - Should we change the avilability of all nodes in the cache to
            unavailable, so that we can keep trying?
        */
        doUhcQuery();
        return;
    }
}

void ConnectionKeeper::doUdpPinging()
{
    int count = UdpPingsPerTry;
    // \todo Make sure after disconnectFromNetwork() all node cache entries are set to UnknownAvailability for optimal results:

    NodeSet nodes;
    nodes = p->getBootstrapNodes (count);
qDebug() << "bootstrap nodes:" << nodes.count();
    foreach (NodeAddress nodeAddress, nodes) {
        //p->localPeer->connectToPeer (nodeAddress.hostAddress().toString(), nodeAddress.hostPort());
        // We set NodeBusy, so that the nodeAddresses not get dropped after
        // disconnect and we do not try them twice.
        p->nodeCache->updateNode (nodeAddress, NodeCache::NodeBusy);
        p->udpHostCache->queryNode (nodeAddress);
    }
    // Empty NodeCache, query UHC:
    if (nodes.count() == 0) {
        doUhcQuery();
        return;
    }
}

void ConnectionKeeper::doUhcQuery()
{
    connect (p->nodeCache,  SIGNAL (nodeAdded()),
             this,          SLOT (keepConnection()),
             Qt::QueuedConnection);
    p->udpHostCache->queryCache();
    return;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.