ClientHttpSessionFactory.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 "ClientHttpSessionFactory.h"
#include "ConcreteProtocol.h"
#include "DataSerializer.h"
#include "CompositeSingleHostClientHttpSession.h"
#include "Imports.cpp"


ClientHttpSessionFactory::ClientHttpSessionFactory (TransportFactory
                                                        *transportFactory)
 :  transportFactory_ (transportFactory)
{
}


ClientHttpSessionFactory::~ClientHttpSessionFactory()
{
    if (!establishingSessions_.empty())
        qDebug() << "Destroying ClientHttpSession while some sessions "
                    "are still being established! LEAKING MEMORY";
    if (!sessions_.empty())
        qDebug() << "Destroying ClientHttpSession before all established "
                    "sessions are destroyed! LEAKING MEMORY";
/*  foreach (EstablishingSession *session, establishingSessions_)
        delete session;
    establishingSessions_.clear();

    // \todo in which order to destroy transport and session?
    // if transport's dtor does not invoke anything on its status (session in
    // this case), then it is better to delete transport after session
    foreach (ClientHttpSession *session, sessions_.keys())
        delete session;
    foreach (Transport *transport, sessions_.values())
        transportFactory_->destroyTransport (transport);
    sessions_.clear();*/
}


ClientHttpSession *
ClientHttpSessionFactory::createSession (Transport *transport,
                                         ClientHttpSessionStatus *status)
{
    auto_ptr <ClientHttpSession> session
        (new CompositeSingleHostClientHttpSession (transport,
                                                   status));
    sessions_.insert (session.get(), transport);
    return session.release();
}


void ClientHttpSessionFactory::createSession (const Uri &uri,
                                ClientHttpSessionStatus *sessionStatus,
                                ClientHttpSessionFactoryStatus *factoryStatus)
{
    Uri transportUri = makeTransportUri (uri);
    if (transportUri == Uri()) {
        factoryStatus->clientHttpSessionFactoryFailed (uri);
    } else {
        auto_ptr <EstablishingSession> session (new EstablishingSession);
        session->uri = uri;
        session->sessionStatus = sessionStatus;
        session->factoryStatus = factoryStatus;
        establishingSessions_.insert (transportUri, session.get());
        session.release();
        transportFactory_->createTransport (transportUri, this);
    }
}


void ClientHttpSessionFactory::destroySession (ClientHttpSession *session)
{
    Q_ASSERT (session != 0);
    Q_ASSERT (sessions_.contains (session));
    Transport *transport = sessions_.take (session);
    // \todo transport may call status->abort() thus jumping in session
    transportFactory_->destroyTransport (transport);
    delete session;
}


void
ClientHttpSessionFactory::transportFactorySucceeded (const Uri &transportUri,
                                                     Transport *transport)
{
    Q_ASSERT (establishingSessions_.contains (transportUri));
    Q_ASSERT (transport != 0);
    auto_ptr <EstablishingSession> session;
    session.reset (establishingSessions_.take (transportUri));
    ClientHttpSession *httpSession = createSession (transport,
                                                    session->sessionStatus);
    session->factoryStatus->clientHttpSessionFactorySucceeded (session->uri,
                                                               httpSession);
}


void ClientHttpSessionFactory::transportFactoryFailed (const Uri &transportUri)
{
    Q_ASSERT (establishingSessions_.contains (transportUri));
    auto_ptr <EstablishingSession> session;
    session.reset (establishingSessions_.take (transportUri));
    session->factoryStatus->clientHttpSessionFactoryFailed (session->uri);
}


Uri ClientHttpSessionFactory::makeTransportUri (const Uri &uri)
{
    Uri res;
    if (uri.scheme() == "http")
        return makeTcpUriFromHttpUri (uri);
    //else if (uri.scheme() == "https")
    //  return makeTcpUriFromHttpsUri (uri);
    else
        return Uri();
}


Uri ClientHttpSessionFactory::makeTcpUriFromHttpUri (const Uri &uri)
{
    Uri res;
    res.setScheme ("tcp");
    // Set host and port:
    if (uri.port().isEmpty())
        res.setAuthority (QByteArray(), uri.host(), "80");
    else
        res.setAuthority (QByteArray(), uri.host(), uri.port());
    // Set read buffer (rb) and write buffer (wb) sizes:
    res.appendQueryItem ("rb", "8192");
    res.appendQueryItem ("wb", "8192");
    return res;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.