File content as of revision 11:9366140ebe5f:

#include "HttpServer.h"

HttpServer::HttpServer() {
    listeningThread = NULL;
    mainThreadId = osThreadGetId();
}

HttpServer::~HttpServer() {
    stop();
}

void HttpServer::httpServerListeningThread(void const *serverInstance) {
    bool stopListening = false;
    osThreadId mainThreadId = ((HttpServer*)serverInstance)->getMainThreadId();
    while (!stopListening) {
        
        
        handleServerAliveRequests(mainThreadId);
    }
}

void HttpServer::handleServerAliveRequests(osThreadId mainThreadId) {
    osEvent event = Thread::signal_wait(STATUS_CHECK_SIGNAL, STATUS_CHECK_NO_BLOCKING);
    if ((event.status == osEventSignal) && (event.value.signals & STATUS_CHECK_SIGNAL)) {
        osSignalSet(mainThreadId, STATUS_CHECK_ACK_SIGNAL);
    }
}

bool HttpServer::start() {
    if (!listeningThread) {
        slaveThreadStatusCounter = 0;
        listeningThread = new Thread(&HttpServer::httpServerListeningThread, this);
    }
    return listeningThread != NULL && listeningThread->get_state() != Thread::Inactive;
}

bool HttpServer::stop() {
    if (listeningThread) {
        listeningThread->signal_set(CLOSE_SIGNAL);
        unsigned short int waitingShutdownAttempts = 0;
        while(waitingShutdownAttempts < WAITING_SHUTDOWN_ATTEMPTS && listeningThread->get_state() != Thread::Inactive) {
            Thread::wait(SHUTDOWN_TIMEOUT_MILLIS);
            waitingShutdownAttempts++;
        }
        return listeningThread->get_state() == Thread::Inactive;
    }
    return true;
}

bool HttpServer::restart() {
    if (stop()) {
        return start();
    } else {
        return false;    
    };
}

bool HttpServer::isAlive() {
    if (listeningThread) {
        listeningThread->signal_set(STATUS_CHECK_SIGNAL);
        osEvent statusAckEvent = Thread::signal_wait(STATUS_CHECK_ACK_SIGNAL, STATUS_CHECK_TIMEOUT_MILLIS);
        if((statusAckEvent.status == osEventSignal) && (statusAckEvent.value.signals & STATUS_CHECK_ACK_SIGNAL)) {
            slaveThreadStatusCounter = 0;
        } else {
            slaveThreadStatusCounter++;    
        }
        if (slaveThreadStatusCounter >= FAULTY_REPORTS_COUNT) {
            return false;    
        }
    }
    return true;
}