TransferSessionImpl.h

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

*/

#ifndef PROTOCOLS__BIT_TORRENT__TRANSFERS__TRANSFER_SESSION_IMPL_H
#define PROTOCOLS__BIT_TORRENT__TRANSFERS__TRANSFER_SESSION_IMPL_H

#include "Imports.h"
#include "PacketSession.h"
#include "TransferSession.h"
#include "TransferSessionStatus.h"

namespace Protocols {
namespace BitTorrent {
namespace Transfers {

class IntegerResetStopwatch
{
    CALITKO_MOCKABLE

public:
    virtual                 ~IntegerResetStopwatch() {}
    virtual void            reset() = 0;
    virtual qint64          elapsedSeconds() const = 0;
};

struct Handshake // \ŧodo : public Data
{
    enum ProtocolVersion
    {
        ProtocolVersion1            = 0,
        ProtocolVersionUnknown      = 1
    };

    typedef QByteArray PeerId; // \todo reuse the FixedSizeByteArray declaration?

    ProtocolVersion protocolVersion;
    bool            hasFastExtension; // extension bit 62
    PeerId          peerId;
    int             numberPieces; // \todo use Torrent instead? It would contain InfoHash and other data

    Handshake (ProtocolVersion v, bool f, const PeerId &p, int n)
    : protocolVersion (v), hasFastExtension (f), peerId (p), numberPieces (n) {}
};


class TransferSessionImpl : public TransferSession, public SessionStatus
{
    CALITKO_TESTABLE
    REFERENCE_OBJECT (TransferSessionImpl)

public:
                TransferSessionImpl (Session *, const Handshake &,
                                     IntegerResetStopwatch *downloadStopwatch,
                                     IntegerResetStopwatch *uploadStopwatch,
                                     TransferSessionStatus *);

    // Interface TransferSession implementation:
    void        sendPacket (const Packet &);
    void        close();

    bool        areWeChoked() const;
    bool        areWeInterested() const;
    bool        areWeSnubbed() const;
    bool        areWeSeeder() const;
    bool        isPeerChoked() const;
    bool        isPeerInterested() const;
    bool        isPeerSnubbed() const;
    bool        isPeerSeeder() const;

    qint64      totalDownloaded() const;
    qint64      totalUploaded() const;
    qint64      currentDownloadSpeed() const;
    qint64      currentUploadSpeed() const;

    QBitArray   peerPiecesAvailable() const;
    QBitArray   wePiecesAvailable() const;

    // Interface SessionStatus implementation:
    void        sessionReceivedData (Session *, const Data &);
    void        sessionSendingData (Session *, const Data &);
    void        sessionClosing (Session *);
    void        sessionClosed (Session *);

private:
    void        receivedChoke (const Choke &);
    void        receivedUnchoke (const Unchoke &);
    void        receivedInterested (const Interested &);
    void        receivedNotInterested (const NotInterested &);
    void        receivedPiece (const Piece &);
    void        receivedBitField (const BitField &);
    void        receivedHaveAll (const HaveAll &);
    void        receivedHaveNone (const HaveNone &);
    void        receivedHave (const Have &);
    void        receivedUnhandled (const PacketBase &);

    void        sentChoke (const Choke &);
    void        sentUnchoke (const Unchoke &);
    void        sentInterested (const Interested &);
    void        sentNotInterested (const NotInterested &);
    void        sentPiece (const Piece &);
    void        sentBitField (const BitField &);
    void        sentHaveAll (const HaveAll &);
    void        sentHaveNone (const HaveNone &);
    void        sentHave (const Have &);
    void        sentUnhandled (const PacketBase &);

    void            updateDownloadSpeed (int pieceLength) const;
    void            updateUploadSpeed (int pieceLength) const;
    static void     shiftList (QList <qint64> &list, qint64 count);
    static qint64   calculateAverage (const QList <qint64> &list);
    static void     setPiecesAvailable (QBitArray &piecesAvailable,
                                        const QByteArray &bitField);
    void            unregisterBitFieldHaveAllHaveNoneReceiveHandlers();
    void            unregisterBitFieldHaveAllHaveNoneSendHandlers();

private:
    typedef ObjectDispatcher <PacketBase> PacketDispatcher;

    static const int        SpeedMovingAverageDuration = 20;
    static const int        SnubbedTimeout = 20;

    Session                 *session_;
    Handshake               handshake_;
    TransferSessionStatus   *status_;
    PacketDispatcher        inPacketDispatcher_;
    PacketDispatcher        outPacketDispatcher_;

    bool                    areWeChoked_;
    bool                    areWeInterested_;
    bool                    areWeSeeder_;
    bool                    isPeerChoked_;
    bool                    isPeerInterested_;
    bool                    isPeerSeeder_;

    qint64                  totalDownloaded_;
    qint64                  totalUploaded_;
    IntegerResetStopwatch   *downloadStopwatch_;
    IntegerResetStopwatch   *uploadStopwatch_;
    mutable QList <qint64>  downloadHistory_;
    mutable QList <qint64>  uploadHistory_;

    QBitArray               peerPiecesAvailable_;
    QBitArray               wePiecesAvailable_;
};

} // namespace Transfers
} // namespace BitTorrent
} // namespace Protocols

#endif // PROTOCOLS__BIT_TORRENT__TRANSFERS__TRANSFER_SESSION_IMPL_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.