Service.cpp

Go to the documentation of this file.

/*
 * Service.cpp
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program 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.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <HSEP/Service.h>
#include <HSEP/LoggerTool.h>

#include <sys/types.h> // umask
#include <sys/stat.h>  // umask
#include <unistd.h>    // fork
#include <signal.h>

namespace HSEP {

    bool ServiceThread::prepare() {

        bool vResult = false;
        string vLogFileStr("/var/log/"+aName+".log");

        aServiceLogPtr = new fstream(vLogFileStr.c_str(),fstream::out);

        string vMessage = "Service "+aName+"(";

        if (aServiceLogPtr->bad()) {
            vMessage.append("can't open particular log file - ");
            vMessage.append(to_string(aServiceLogPtr->flags()));
            vMessage.append(")");
            LoggerTool::send(LT_SYSTEMERROR,vMessage);
            delete aServiceLogPtr;
            aServiceLogPtr = nullptr;
        }
        else {
            vResult = true;
        }
        return vResult;

    } // ServiceThread::prepare


    void ServiceThread::dispose() {

        if (aServiceLogPtr) {
            aServiceLogPtr->close();
            delete aServiceLogPtr;
        }

        string vMessage = "Service "+aName+"(finishing)";
        LoggerTool::send(LT_SYSTEMERROR,vMessage);

    } // ServiceThread::dispose

    void ServiceThread::log(string pData) {

        ExclusiveScope vScope(&aMutex);
        (*aServiceLogPtr) << pData << endl;

    } // ServiceThread::log

    ServiceThread::ServiceThread(
        string     pName
    ) : Thread("ServiceThread") {
        aName          = pName;
        aServiceLogPtr = nullptr;
    } // ServiceThread constructor

    ServiceThread::~ServiceThread() {
    } // ServiceThread destructor

    ServiceThread* Service::aThreadInstance = nullptr;

    Service::Service(
        string                pName,
        ServiceThreadFactory& pServiceThreadFactoryRef
    ) {

        aName = pName;

        string vMessage = "Service "+pName+"(";
        aPid = fork();

        if (0 > aPid) {
            vMessage.append("main fork failed -");
            vMessage.append(to_string(errno));
            vMessage.append(")");
            LoggerTool::send(LT_SYSTEMERROR,vMessage);
            exit(EXIT_FAILURE);
        }
        else if (0 < aPid) {
            // The forked process is already running, we can die
            vMessage.append("child dispatched)");
            LoggerTool::send(LT_SYSTEMINFO,vMessage);
            exit(EXIT_SUCCESS);
        }

        aSid = setsid();

        if (0 > aSid) {
            vMessage.append("new session failed - ");
            vMessage.append(to_string(errno));
            vMessage.append(")");
            LoggerTool::send(LT_SYSTEMERROR,vMessage);
            exit(EXIT_FAILURE);
        }

        if (0 > chdir("/")) {
            vMessage.append("can't change to root directory - ");
            vMessage.append(to_string(errno));
            vMessage.append(")");
            LoggerTool::send(LT_SYSTEMERROR,vMessage);
            exit(EXIT_FAILURE);
        }
        umask(0);

        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);

        aTerminate = false;

        // Take note.  This thread is create within the forked instance.
        // If the thread is created before the constructor, it will belong
        // to the original process and will die with it, so the service won't
        // have any functionality.
        //
        aThreadInstance = pServiceThreadFactoryRef.createPtr();;
        aThreadInstance->dispatch();

        LoggerTool::send(LT_SYSTEMINFO,"main thread dispatched");

    } // Service constructor

    Service::~Service() {

        string vMessage("Service "+aName+"(finished)");
        LoggerTool::send(LT_SYSTEMINFO,vMessage);

    } // Service destructor

    void TerminateHandler(int pSignal) {

        if (SIGTERM == pSignal) {

            LoggerTool::send(LT_SYSTEMINFO,"Signal SIGTERM Received");

            //Service::aThreadInstance->log("SIGTERM Received");
            Service::aThreadInstance->finish();
            Service::aThreadInstance->join();

            delete Service::aThreadInstance;

            LoggerTool::send(LT_SYSTEMINFO,"Process thread Finished - Closing service");

            sleep(1);

            exit(EXIT_SUCCESS);
        }

    } // TerminateHandler

    bool Service::_continue() {
        ExclusiveScope(&this->aTermMutex); // G++ can't locate the aTermMutex instance without the "this->"
        return !aTerminate;
    } // Service::_continue

    int Service::body() {

        int vResult = 0;

        struct sigaction vAction; // this is because there are two different sigactions,
                                  // the struct and the function
        struct sigaction vOldAction;
        sigset_t vSignalSet;

        sigemptyset(&vSignalSet);
        sigaddset(&vSignalSet,SIGTERM);

        vAction.sa_handler = TerminateHandler;
        vAction.sa_mask = vSignalSet;

        if (sigaction(SIGTERM,&vAction,&vOldAction) < 0) {
            string vMessage = "Service "+aName+"(terminate handler failed -";
               vMessage.append(to_string(errno));
               vMessage.append(")");
            LoggerTool::send(LT_SYSTEMERROR,vMessage);
               exit(EXIT_FAILURE);
        }

        while (_continue()) {
            sleep(1);
        }

        sigaction(SIGTERM,&vOldAction,nullptr);

        return vResult;
    }

    void Service::finish() {
        ExclusiveScope(&this->aTermMutex); // G++ can't locate the aTermMutex instance without the "this->"
        aTerminate = true;
    } // Service::finish

} // HSEP namespace