Servidor.h

Veure la documentació d'aquest fitxer.

#ifndef _SERVIDOR_H_
#define _SERVIDOR_H_

/*
 * Copyright (c) 2012 Toni Corvera
 *
 * This file is part of TFCWeb.
 *
 * TFCWeb 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 3 of the License, or
 * (at your option) any later version.
 *
 * TFCWeb 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 TFCWeb. If not, see <http://www.gnu.org/licenses/>.
 */

#include "Excepcions.h"
#include "PeticioHTTP.h"
#include "portabilitat.h"
#include "Uri.h"

#include <memory>
#include <sstream>
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/xtime.hpp>

namespace tfc {

// Forward declarations
class Configuracio;
class RespostaHTTP;
class RecursDinamic;
class Ruta;
class UrlHTTP;

class ErrorRebentDades : public ErrorTFC {
public:
    explicit ErrorRebentDades(const std::string & w = "Error rebent dades")
        : ErrorTFC(w)
    {
        // buit
    }
};

class Servidor
{
public:
    typedef boost::asio::ip::tcp::socket socket_t;
    typedef std::shared_ptr<socket_t> socket_ptr;

    Servidor(const Configuracio & c, socket_ptr & s) throw ();
    Servidor(const Servidor & s) throw ()
        : cfg(s.cfg), socket_(s.socket_), buffer_(s.buffer_.str())
    {
        assert( socket_->is_open() );
    }
    ~Servidor();

    // Factoria de sockets
    static socket_ptr crea_socket(boost::asio::io_service & iosrv) {
        return socket_ptr(new socket_t(iosrv));
    }

    void aten() throw (ErrorHTTP);

    //void analitzar_peticio(const PeticioHTTP &); // <- Prototip
    void interpretar_ruta(const Ruta &) const;
//    void enviar_error(const FraseEstat &); // <- Unificat amb envia_resposta
    void tancar_sessio();
    //void carregar_configuracio(const Configuracio &);
    void interpretar_recurs_dinamic(const RecursDinamic &);

    static const std::string& signatura();
private:
    void envia_resposta(TipusPeticioHTTP, tfc::RespostaHTTP &) const
                                                throw (ErrorEscrivintEnSocket);

    PeticioHTTP analitza_peticio() throw (ErrorHTTP);
    void extreu_capsaleres(PeticioHTTP &) throw (ErrorHTTP, ErrorRebentDades);
    void extreu_cos(PeticioHTTP &) throw (ErrorHTTP, ErrorRebentDades);
    typedef std::unique_ptr<RespostaHTTP> resposta_uptr;

    //TODO: TRACE!
    resposta_uptr aten_peticio_lectura(const Uri & u, PeticioHTTP & p) throw (ErrorHTTP);
    resposta_uptr aten_peticio_escriptura(const Uri & u, PeticioHTTP & p) throw (ErrorHTTP);
    resposta_uptr aten_peticio_informacio(const Uri & u, PeticioHTTP & p) throw (ErrorHTTP);
    
    const Configuracio & cfg;
    socket_ptr socket_;

    enum {
        MIDA_BUFFER_LECTURA = 1024,
        // Apache
        // <http://httpd.apache.org/docs/2.0/mod/core.html#timeout>
        // <http://httpd.apache.org/docs/2.0/mod/core.html#keepalivetimeout>
        // Fa servir 300s per peticions i 15s per keep-alive.
        // TFCWeb no fa aquesta distinció, i el timeout és el mateix. Més d'uns
        // pocs segons sembla excessiu per la gran majoria de casos
        TIMEOUT_RECEPCIO = 20*1000 // ms
    };

    // TODO:
    // Possibles implementacions de buffer
    //boost::circular_buffer<char> buffer_real_;
    //boost::asio::mutable_buffers_1 buffer_;

    // Lectura de socket
    size_t llegeix_socket(std::stringstream & buffer,
                          unsigned int timeout_ms = TIMEOUT_RECEPCIO) throw (ErrorRebentDades);
    size_t llegeix_socket(unsigned int timeout_ms = TIMEOUT_RECEPCIO)
                                                    throw (ErrorRebentDades) {
        return llegeix_socket(this->buffer_, timeout_ms);
    }

    size_t omple_buffer(unsigned int timeout_ms = TIMEOUT_RECEPCIO) throw (ErrorRebentDades);
    std::stringstream buffer_;
};

#if 0
class ControladorServei {
public:
    ControladorServei(boost::asio::io_service & iosrv)
    // FIXME: Port
        : acceptador_(iosrv, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 8000))
    {
        using boost::asio::ip::tcp;

    }
private:
    boost::asio::ip::tcp::acceptor acceptador_;
};
#endif

} // ns tfc

#endif // _SERVIDOR_H_

// vim:set ts=4 et ai: //