tfcweb.cc

Veure la documentació d'aquest fitxer.

/*
 * 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 "Configuracio.h"
#include "debug.h"
#include "Excepcions.h"
#include "Log.h"
#include "portabilitat.h"
#include "Recurs.h"
#include "Servidor.h"
#include "ThreadPool.h"

#include <clocale>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <functional>
#include <string>
#include <boost/asio.hpp>
#include <boost/assign.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>
#include <boost/thread.hpp>
#include <boost/unordered_map.hpp>

using namespace boost;
using namespace boost::asio::ip;
using namespace boost::filesystem;
using namespace std;
using namespace tfc;

namespace popt = boost::program_options;

namespace {
    const size_t BUFSIZE = 256;

    ThreadPool * pPool = 0;

    // XXX: G++ 4.4 té problemes si la classe es defineix dins el cos de main()
    struct Executor {
        Configuracio & cfg;
        Servidor::socket_ptr sock;
        Executor(Configuracio & c, Servidor::socket_ptr & s) : cfg(c), sock(s) {}
        void operator()() {
            log() << NivellDebug
                  << "Servint petició en fil " << this_thread::get_id() << commit;
            try {
                // Salvaguarda: Intentem evitar sortir en casos no previstos
                //              A la pràctica no ho aconseguirem sempre perquè si es llença
                //              una excepció no declarada en la signatura s'abortarà
                Servidor servidor(cfg, sock);
                servidor.aten();
                servidor.tancar_sessio();
            }
            catch (const std::exception & e) {
                cerr << "Error no previst: " << e.what() << endl;
            }
            catch (...) {
                cerr << "Error intern desconegut [" << FITXER_I_LINIA_ << "]" << endl;
            }
            log() << NivellDebug
                  << "(" << this_thread::get_id() << "): Sessió finalitzada" << commit;
        }
    };
} // ns anònim

// Veure també http://www.boost.org/doc/libs/1_49_0/doc/html/boost_asio/example/http/server/server.cpp

void signal_callback_posix(int signum) {
    static boost::unordered_map<int, string> noms_senyals = boost::assign::map_list_of
            ( SIGINT, "SIGINT" )
            ( SIGTERM, "SIGTERM" )
#ifdef SIGUSR1
            ( SIGUSR1, "SIGUSR1" )
#endif
    ;

    cerr << "> Sortida: senyal " << noms_senyals[signum] << " rebuda" << endl;
    if (0 != pPool) {
        pPool->termina();
    }
    ::exit(1);
}

int main(int argc, char * argv[], char * envp[]) {
    tfc::portabilitat::init();
    //  2: Petició d'interrupció, normalment per l'usuari (CTRL+C)
    ::signal(SIGINT, signal_callback_posix);
    // 15: Petició de finalització, p.e. `$ kill`.
    // El senyal KILL (9) no es pot capturar
    ::signal(SIGTERM, signal_callback_posix);
#ifdef SIGUSR1
    ::signal(SIGUSR1, signal_callback_posix);
#endif

    // Interfície cap al sistema de xarxa de l'SO
    asio::io_service io_service;
#if 0
    // Gestió de senyals
    asio::signal_set senyals(io_service, SIGINT, SIGTERM);
#   ifdef SIGUSR1
    senyals.add(SIGUSR1);
#   endif
    senyals.async_wait(signal_callback);
    io_service.run();
#endif

    // Sortir en rebre senyal USR1
    // FIXME: Portabilitat ::signal(SIGUSR1, signal_callback);

    cerr << "Servidor Web (TFC primavera 2012) v" VERSION "\n"
            "  Alumne: " AUTHOR " <" PACKAGE_BUGREPORT ">\n" << endl;

    try {
        // Inicialització del logging
        Log::singleton().associa(std::cerr, NIVELL_MES_VERBOS);
        Log::singleton().associa(path("errors.log"), NivellError);

        Configuracio cfg(argc, argv);
        // POST: Configuració carregada correctament
        assert( filesystem::is_directory(cfg.arrel()) ); // INVARIANT
        log() << cfg << commit;

        log() << "Iniciant thread pool..." << commit;
        ThreadPool pool(cfg.fils());
        pPool =& pool; // XXX: cal?

        log() << "> Obrint servei (port " << cfg.port() << ")..." << commit;
        // FIXME: ipv6 ?? <- Millores futures?
        tcp::acceptor acceptador(io_service, tcp::endpoint(tcp::v4(), cfg.port()));
        // FIXME: throws: ??
        log() << " + Escoltant en " << acceptador.local_endpoint() << commit;

        tfc::debug::init(pool);

        while (true) {
            try { // Bloc try independent per a cada connexió
                // TODO: Timeouts!
                Servidor::socket_ptr psocket = Servidor::crea_socket(io_service);
                log() << NivellInfo << "> Esperant connexió..." << commit;
                acceptador.accept(*psocket);
                //boost::asio::ip::tcp::socket so;
                //cerr << "Sock: " << so.;
                log() << NivellInfo << " + Connexió establerta "
                                    << psocket->local_endpoint() << " <-> "
                                    << psocket->remote_endpoint() << commit;
#ifdef THREADS_A_PETICIO
                boost::thread(Executor(cfg, psocket));
#else
                pool.programa(Executor(cfg, psocket));
#endif
            }
#if 0 // Durant proves
            catch (const boost::system::system_error & e) { // estén std::exception
                cerr << "Error no previst (Boost): " << e.what() << endl;
            }
#endif
            catch (const std::exception & e) {
                cerr << "Error no previst: " << e.what() << endl;
            }
        }
        acceptador.cancel(); // XXX: Innecessari?
        acceptador.close();
    }
    catch (const ErrorOpcions & e) {
        cerr << e.what() << endl;
        return e.codi();
    }
    catch (const AjudaDemanada & e) {
        // Sortida correcta, s'ha demanat el missatge d'ajuda explícitament
        cout << e.what() << endl;
        return EX_OK;
    }
    catch (const VersioDemanada &) {
        // Sortida correcta, s'ha demanat la informació de versions
        cout << "Entorn de compilació:"
                "\n Compilador          : " TFC_COMPILADOR
                "\n Sistema operatiu    : " TFC_SO
                "\n Arquitectura de CPU : " TFC_ARQUITECTURA
                "\n Data de compilació  : " __DATE__
                "\n Biblioteques Boost  : " TFC_BOOST
                "\n zlib                : " ZLIB_VERSION
             << endl;
        return EX_OK;
    }
    catch (const ErrorLogNoValid & e) { // No s'ha pogut obrir el log
        cerr << "Error de log: " << e.what() << endl;
        return EX_NOPERM;
    }
    catch (const std::exception & e) { // excepció base de la llibreria estàndard
        cerr << "Error intern: " << e.what() << endl;
        return EX_SOFTWARE;
    }
    catch (...) {
        cerr << "Error intern desconegut [" << FITXER_I_LINIA_ << "]" << endl;
        return EX_SOFTWARE;
    }

    return EX_OK;
}

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