SingleTrackerRequestSession.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 "SingleTrackerRequestSession.h"
#include "TrackerRequestUrlCreator.h"
#include "TrackerResponseParser.h"
#include "Imports.cpp"


SingleTrackerRequestSession::SingleTrackerRequestSession (
                    HttpRequestSession *httpRequestSession,
                    Uri announceUrl,
                    TrackerRequestSessionStatus *trackerRequestSessionStatus)
    : httpRequestSession_ (httpRequestSession),
      announceUrl_ (announceUrl),
      status_ (trackerRequestSessionStatus),
      state_ (Closed)
{
}


SingleTrackerRequestSession::~SingleTrackerRequestSession()
{
}


void SingleTrackerRequestSession::open()
{
    Q_ASSERT (state_ == Closed);

    httpRequestSession_->open (announceUrl_);
}


void SingleTrackerRequestSession::sendRequest (
                                        const TrackerRequest &trackerRequest)
{
    Q_ASSERT (state_ == Established);

    httpRequestSession_->get (TrackerRequestUrlCreator::createRequestUrl (
        trackerRequest));
    state_ = RequestSent;
}


void SingleTrackerRequestSession::close()
{
    if (state_ != Closed && state_ != Closing) {
        state_ = Closing;
        status_->trackerRequestSessionClosing (this);
        httpRequestSession_->close();
    }
}


void SingleTrackerRequestSession::abort()
{
    if (state_ != Closed) {
        httpRequestSession_->abort();
        state_ = Closed;
        status_->trackerRequestSessionClosed (this);
    }
}


void SingleTrackerRequestSession::httpRequestSessionEstablished()
{
    Q_ASSERT (state_ == Closed);

    state_ = Established;
    status_->trackerRequestSessionEstablished (this);
}


void SingleTrackerRequestSession::httpRequestSessionError (
                                                    const QString &errorMessage)
{
    status_->trackerRequestSessionError (this,
        createHttpRequestSessionErrorMessage (errorMessage));
}


void SingleTrackerRequestSession::httpRequestSessionResponseHeaderRecieved (
                                        const ResponseHeader &responseHeader)
{
    Q_ASSERT (state_ == RequestSent);

    if (!httpRequestSucceeded (responseHeader)) {
        status_->trackerRequestSessionError (this, createHttpErrorMessage (
            responseHeader));
        state_ = Established;
        return;
    }

    state_ = ResponseHeaderRecieved;
}


void SingleTrackerRequestSession::httpRequestSessionResponseBodyRecieved (
                                            const QByteArray &rawResponseBody)
{
    Q_ASSERT (state_ == ResponseHeaderRecieved);

    TrackerResponse trackerResponse;
    bool parsedOk = TrackerResponseParser::parseAndLoadTrackerResponse (
        rawResponseBody, trackerResponse);
    if (!parsedOk) {
        status_->trackerRequestSessionError (this, createTrackerErrorMessage (
            "Tracker response could not be parsed"));
        return;
    } else if (!trackerResponse.failureReason().isEmpty()) {
        status_->trackerRequestSessionError (this, createTrackerErrorMessage (
            trackerResponse.failureReason()));
        return;
    }

    state_ = Established;
    status_->trackerRequestSessionResponseRecieved (this, trackerResponse);
}


void SingleTrackerRequestSession::httpRequestSessionClosing()
{
    Q_ASSERT (state_ != Closing && state_ != Closed);

    state_ = Closing;
}


void SingleTrackerRequestSession::httpRequestSessionClosed()
{
    state_ = Closed;
    status_->trackerRequestSessionClosed (this);
}


bool SingleTrackerRequestSession::httpRequestSucceeded (
                                        const ResponseHeader &responseHeader)
{
    return responseHeader.statusCode() >= FirstSuccessfulHttpStatusCode &&
        responseHeader.statusCode() < FirstHttpStatusCodePastSuccessfulCodes;
}


QString SingleTrackerRequestSession::createHttpRequestSessionErrorMessage (
    const QString &errorMessage)
{
    return QString ("HTTP request session error: ") + errorMessage;
}


QString SingleTrackerRequestSession::createHttpErrorMessage (
                                        const ResponseHeader &responseHeader)
{
    return QString ("HTTP error: ") + QString (QByteArray::number (
        responseHeader.statusCode()) + " " + responseHeader.reasonPhrase());
}


QString SingleTrackerRequestSession::createTrackerErrorMessage (
                                const QString &failureReason)
{
    return QString ("Tracker error: ") + failureReason;
}

// Static constants definitions
const int SingleTrackerRequestSession::FirstSuccessfulHttpStatusCode          = 200;
const int SingleTrackerRequestSession::FirstHttpStatusCodePastSuccessfulCodes = 300;

Copyright © 2006 Peter Dimov.
Powered by Doxygen.