SlotAllocator.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-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 "SlotAllocator.h"
#include "HandshakeSession.h"
#include "Imports.cpp"

using namespace Gnutella::Handshaking;

namespace Gnutella {
namespace Handshaking {

enum Constants
{
    TotalHandshakingSlots       = 5,
    TotalUltrapeerSlots         = 2,
    TotalPeerSlots              = 32,
    TotalLeafSlots              = 0,
    BootstrappingThreshold      = 4,
    WellConnectedThreshold      = 24
};

class SlotAllocatorPrivate
{
    REFERENCE_OBJECT (SlotAllocatorPrivate)

public:
    LocalPeer       *localPeer;
    uint            freeHandshakingSlots;
    uint            freeUltrapeerSlots;
    uint            freePeerSlots;
    uint            freeLeafSlots;
    QSignalMapper   destroyedMapper;

    SlotAllocatorPrivate (LocalPeer *localPeer_)
     :  localPeer (localPeer_),
        freeHandshakingSlots (TotalHandshakingSlots),
        freeUltrapeerSlots (TotalUltrapeerSlots),
        freePeerSlots (TotalPeerSlots),
        freeLeafSlots (TotalLeafSlots),
        destroyedMapper()
    {}
};

enum SlotType
{
    HandshakingSlot,
    UltrapeerSlot,
    PeerSlot,
    LeafSlot
};

struct Slot
{
    SlotType type;
};

} // namespace Handshaking;
} // namespace Gnutella;

uint SlotAllocator::freeHandshakingSlots() const
{
    return (p->freeHandshakingSlots > 0) ? p->freeHandshakingSlots : 0;
}

uint SlotAllocator::freeUltrapeerSlots() const
{
    return p->freeUltrapeerSlots;
}

uint SlotAllocator::freePeerSlots() const
{
    return p->freePeerSlots;
}

uint SlotAllocator::freeLeafSlots() const
{
    return p->freeLeafSlots;
}

/*
uint SlotAllocator::usedHandshakingSlots() const
{
    return TotalHandshakingSlots - p->freeHandshakingSlots;
}

uint SlotAllocator::usedUltrapeerSlots() const
{
    return TotalUltrapeerSlots - p->freeUltrapeerSlots;
}

uint SlotAllocator::usedPeerSlots() const
{
    return TotalPeerSlots - p->freePeerSlots;
}

uint SlotAllocator::usedLeafSlots() const
{
    return TotalLeafSlots - p->freeLeafSlots;
}
*/

bool SlotAllocator::isBootstrapping() const
{
    return (TotalPeerSlots - p->freePeerSlots) < BootstrappingThreshold;
}

bool SlotAllocator::isWellConnected() const
{
    return (TotalPeerSlots - p->freePeerSlots) >= WellConnectedThreshold;
}

SlotAllocator::SlotAllocator (LocalPeer *localPeer)
 :  p (new SlotAllocatorPrivate (localPeer))
{
    connect (&p->destroyedMapper, SIGNAL (mapped (QObject *)),
             this, SLOT (freeSlot (QObject *)));
}

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

bool SlotAllocator::hasSlotFor (const NodeInfo &otherNodeInfo) const
{
    if (!p->localPeer->isUltrapeer()) {
        return hasFreeUltrapeerSlots();
    } else {
        if (otherNodeInfo.type == TypeLeaf)
            return hasFreeLeafSlots();
        else
            return hasFreePeerSlots();
    }
}

bool SlotAllocator::allocateSlot (HandshakeSession *session)
{
    qDebug() << "SlotAllocator::allocateSlot (handshakeSession)";

    Q_ASSERT (session != 0);
    p->freeHandshakingSlots--;
    Slot *slot = new Slot;
    slot->type = HandshakingSlot;
    connect (session, SIGNAL (destroyed()), &p->destroyedMapper, SLOT (map()));
    p->destroyedMapper.setMapping (session, reinterpret_cast <QObject *> (slot));

    qDebug() << "SlotAllocator::allocateSlot (handshakeSession) exit";
    return true;
}

bool SlotAllocator::allocateSlot (PacketSession *session)
{
    qDebug() << "SlotAllocator::allocateSlot (packetSession)";

    NodeInfo otherNodeInfo = session->nodeInfo();
    if (!hasSlotFor (otherNodeInfo))
        return false;

    Slot *slot = new Slot;
    if (!p->localPeer->isUltrapeer()) {
        slot->type = UltrapeerSlot;
        Q_ASSERT (p->freeUltrapeerSlots > 0);
        p->freeUltrapeerSlots--;
    } else {
        if (otherNodeInfo.type == TypeLeaf) {
            slot->type = LeafSlot;
            Q_ASSERT (p->freeLeafSlots > 0);
            p->freeLeafSlots--;
        } else {
            slot->type = PeerSlot;
            Q_ASSERT (p->freePeerSlots > 0);
            p->freePeerSlots--;
        }
    }

    connect (session, SIGNAL (destroyed()), &p->destroyedMapper, SLOT (map()));
    p->destroyedMapper.setMapping (session, reinterpret_cast <QObject *> (slot));

    return true;
}

void SlotAllocator::freeSlot (QObject *pointer)
{
    qDebug() << "SlotAllocator::freeSlot";

    Slot *slot = reinterpret_cast <Slot *> (pointer);
    Q_ASSERT (slot != 0);

    switch (slot->type) {
    case HandshakingSlot:
        p->freeHandshakingSlots++;
        emit handshakingSlotFreed();
        break;
    case LeafSlot:
        p->freeLeafSlots++;
        emit leafSlotFreed();
        break;
    case PeerSlot:
        p->freePeerSlots++;
        emit peerSlotFreed();
        break;
    case UltrapeerSlot:
        p->freeUltrapeerSlots++;
        emit ultrapeerSlotFreed();
        break;
    default:
        Q_ASSERT (false);
        break;
    }
    delete slot;

    // Not need to explicitly call removeMapping() now. All signals are
    // automatically disconnected when the sender is being destroyed.
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.