NodeCache.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 "NodeCache.h"
#include "Imports.cpp"

using namespace Gnutella::Bootstrapping;

namespace Gnutella {
namespace Bootstrapping {

QDataStream & operator << (QDataStream &stream,
                           const NodeCache::NodeAvailability &availability)
{
    return stream << static_cast <uchar> (availability);
}

QDataStream & operator >> (QDataStream &stream,
                           NodeCache::NodeAvailability &availability)
{
    uchar ch;
    stream >> ch;
    availability = static_cast <NodeCache::NodeAvailability> (ch);
    return stream;
}

enum Constants
{
    AvailabilityExpiration      = 600,
    MaximalCacheSize            = 2000,
    ShrinkCacheSize             = 1500
};

struct Entry;
typedef QHash <NodeAddress, Entry*>     NodeTable;
typedef QLinkedList <Entry*>            EntryList;
typedef EntryList::iterator             EntryIterator;

// \todo The NodeAddress is already a mamber of NodeInfo. Remove it from entry?
struct Entry
{
    NodeCache::NodeAvailability     availability;
    QDateTime                       timeLastAdded;
    NodeInfo                        nodeInfo;
    EntryIterator                   availabilityListIterator;
    EntryIterator                   completeListIterator;

    Entry() : availability (NodeCache::UnknownAvailability),
              timeLastAdded (QDateTime::currentDateTime()),
              nodeInfo(), availabilityListIterator(), completeListIterator()
    {}
};

class NodeCachePrivate
{
public:
    NodeTable                   nodeTable;
    EntryList                   availabilityList[NodeCache::AvailabilityCount];
    EntryList                   completeList;

    NodeCachePrivate() : nodeTable(), completeList()    {}
    ~NodeCachePrivate()                                 {}
};

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

NodeCache::NodeCache()
 :  d (new NodeCachePrivate())
{
}

NodeCache::~NodeCache()
{
    delete d;
}

NodeSet NodeCache::getNodes (int count, NodeAvailability availability, bool freshNodes)
{
    class AnyNode : public Predicate
    {
    public:
        bool operator() (const NodeInfo &) const { return true; }
    };

    return getNodes (count, availability, freshNodes,
                     static_cast <const Predicate &> (AnyNode()));
}

/*
    The cache must have some size! Question now is whether to have some size per
    HostAvailability, or one size for all hosts in the cache. The problem with the
    latter is that we don't know which hosts to take away (from which availability
    list). Probably the best solution would be to remove the oldiest entries. This
    means we need an additional list that stores the HostInfo * in the correct order
    similar to what we do now with HostInfoList.
*/
void NodeCache::addNode (const NodeInfo &nodeInfo,
                         NodeAvailability availability)
{
    Q_ASSERT (nodeInfo.address != NodeAddress::Null);
qDebug() << "addNode() " << nodeInfo.address.toString() << nodeInfo.vendorCode.toString();

    NodeTable::iterator i = d->nodeTable.find (nodeInfo.address);
    if (i == d->nodeTable.end()) {  // This is a new node.
        if (d->completeList.size() >= MaximalCacheSize) {
            Entry *entry;
            for (int i = d->completeList.size() - ShrinkCacheSize; i > 0; i--) {
                entry = d->completeList.takeLast();
                d->availabilityList[entry->availability].erase (entry->availabilityListIterator);
                int count = d->nodeTable.remove (entry->nodeInfo.address);
                Q_ASSERT (count == 1); // Could be if two different addresses are equal => NodeAddress::operator == bug!
                delete entry;
            }
        }
        Entry *entry                        = new Entry;
        entry->nodeInfo                     = nodeInfo;
        entry->availability                 = availability;
        d->nodeTable.insert (nodeInfo.address, entry);

        EntryList &availabilityList         = d->availabilityList[availability];
        entry->availabilityListIterator     = availabilityList.insert (availabilityList.begin(), entry);
        entry->completeListIterator         = d->completeList.insert (d->completeList.begin(), entry);

        emit nodeAdded(); // \todo Emit only in this case?
    } else { // The host is already in the cache.
        Entry *entry                = *i;
        entry->nodeInfo             = nodeInfo;
        updateNode (nodeInfo.address, availability);
    }
}

void NodeCache::updateNode (const NodeAddress &nodeAddress,
                            NodeAvailability availability)
{
    Q_ASSERT (nodeAddress != NodeAddress::Null);

    NodeTable::iterator i = d->nodeTable.find (nodeAddress);
    if (i != d->nodeTable.end()) {  // This is NOT a new node.
        Entry *entry                = *i;
        QDateTime currentDateTime   = QDateTime::currentDateTime();
        // We overwrite the hostInfo entry if either the entry expired, or we set higher availability.
        bool canOverwrite = availability >= entry->availability
                            || currentDateTime > entry->timeLastAdded.addSecs (AvailabilityExpiration);

        if (canOverwrite) {
            d->availabilityList[entry->availability].erase (entry->availabilityListIterator);
            d->completeList.erase (entry->completeListIterator);

            entry->availability                 = availability;
            entry->timeLastAdded                = currentDateTime;

            EntryList &availabilityList         = d->availabilityList[availability];
            entry->availabilityListIterator     = availabilityList.insert (availabilityList.begin(), entry);
            entry->completeListIterator         = d->completeList.insert (d->completeList.begin(), entry);
        }
    }
}

NodeSet NodeCache::getNodes (int count, NodeAvailability availability, bool freshNodes, const Predicate &pred)
{
    NodeSet nodes;
    EntryList &availabilityList = d->availabilityList[availability];
    EntryIterator i             = availabilityList.begin();
    QDateTime expirationTime    = QDateTime::currentDateTime().addSecs (-AvailabilityExpiration);
    for (; i != availabilityList.end()
            && nodes.size() < count
            && (!freshNodes
                || (*i)->timeLastAdded > expirationTime)
         ; i++)
        if (pred((*i)->nodeInfo))
            nodes.insert ((*i)->nodeInfo.address);
    return nodes;
}

bool NodeCache::loadNodes (const QString &filename)
{
    QFile file (filename);
    if (!file.exists() || !file.open (QIODevice::ReadOnly))
        return false;

    QDataStream stream (&file);
    // \todo Introduce format versioning.
    int count = 0;
    stream >> count;
    // \todo Verify the host is not duplicated due to corrupted file
    // \todo get the end() iterators in advance.
    while (count-- > 0) {
        Entry *entry = new Entry;

        stream >> entry->nodeInfo;
        stream >> entry->timeLastAdded;
        stream >> entry->availability;

        // We now add all as UnknownAvailability
        entry->availability = UnknownAvailability;

        entry->completeListIterator     = d->completeList.insert (d->completeList.end(), entry);
        entry->availabilityListIterator = d->availabilityList[entry->availability].insert (d->availabilityList[entry->availability].end(), entry);
        d->nodeTable.insert (entry->nodeInfo.address, entry);
    }
    return true;
}

bool NodeCache::storeNodes (const QString &filename)
{
    // \todo Do not store the hosts that were unavailable?
    // The list was sordered by access time, which means that
    QFile file (filename);

    if (!file.open (QIODevice::WriteOnly))
        return false;

    QDataStream stream (&file);

    // We now do not store the host that were unavailable.
    stream << d->completeList.count() - d->availabilityList[NodeUnavailable].count();
    EntryIterator i = d->completeList.begin();
    EntryIterator e = d->completeList.end();
    for (; i != e; i++) {
        if ((*i)->availability != NodeUnavailable) {
            stream << (*i)->nodeInfo;
            stream << (*i)->timeLastAdded;
            stream << (*i)->availability;
        }
    }
    return true;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.