oc_service.c

Go to the documentation of this file.

#include <oc_service.h>
#include <oc_object.h>
#include <oc_process.h>
#include <oc_string.h>
#include <oc_streamman.h>
#include <oc_intman.h>
#include <oc_processman.h>

#define _________________________________________TYPES_SECTION______________________________________________________________________________

struct Service_t
{
    oC_ObjectControl_t          ObjectControl;
    oC_Process_t                Process;
    oC_Thread_t                 MainThread;
    oC_DefaultString_t          Name;
    oC_Service_MainFunction_t   MainFunction;
    oC_Service_StartFunction_t  StartFunction;
    oC_Service_StopFunction_t   StopFunction;
    oC_MemorySize_t             MainThreadStackSize;
    oC_Process_Priority_t       Priority;
    oC_MemorySize_t             HeapMapSize;
    bool                        Started;
    oC_Service_Context_t        Context;
    oC_Module_RequiredArray_t   RequiredModules;
};

#undef  _________________________________________TYPES_SECTION______________________________________________________________________________

#define _________________________________________PROTOTYPES_SECTION_________________________________________________________________________

static bool         AreRequiredModulesEnabled   ( oC_Service_t Service );
static void         ServiceThread               ( oC_Service_t Service );

#undef  _________________________________________PROTOTYPES_SECTION_________________________________________________________________________



#define _________________________________________GLOBALS_SECTION____________________________________________________________________________

static const oC_Allocator_t Allocator = {
                .Name   = "Service"
};

#undef  _________________________________________GLOBALS_SECTION____________________________________________________________________________



#define _________________________________________INTERFACE_SECTION__________________________________________________________________________

//==========================================================================================================================================
//==========================================================================================================================================
oC_Service_t oC_Service_New( const oC_Service_Registration_t * Registration )
{
    oC_Service_t service = NULL;
    oC_Stream_t  stream  = oC_StreamMan_GetStdErrorStream();

    if(
        oC_SaveIfFalse("Service::New: Registration - "      , isaddresscorrect(Registration)                    , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("Service::New: Name - "              , isaddresscorrect(Registration->Name)              , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("Service::New: Name - "              , strlen(Registration->Name) > 0                    , oC_ErrorCode_StringIsEmpty    )
     && oC_SaveIfFalse("Service::New: StartFunction - "     , isaddresscorrect(Registration->StartFunction)     , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("Service::New: StopFunction - "      , isaddresscorrect(Registration->StopFunction)      , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("Service::New: MainFunction - "      , isaddresscorrect(Registration->MainFunction)      , oC_ErrorCode_WrongAddress     )
        )
    {

        service = kmalloc( sizeof(struct Service_t), &Allocator, AllocationFlags_ZeroFill );

        if(oC_SaveIfFalse("Service::New: Main object - ", service != NULL, oC_ErrorCode_AllocationError))
        {
            oC_User_t user = getcuruser();
            strncpy(service->Name, Registration->Name, sizeof(service->Name));

            user = user == NULL ? getrootuser() : user;

            service->Process                = oC_Process_New( Registration->Priority, service->Name, user, Registration->HeapMapSize, NULL, stream, stream);
            service->MainThread             = oC_Thread_New ( Registration->Priority, Registration->MainThreadStackSize, service->Process, service->Name, (oC_Thread_Function_t)ServiceThread, service );
            service->MainFunction           = Registration->MainFunction;
            service->StartFunction          = Registration->StartFunction;
            service->StopFunction           = Registration->StopFunction;
            service->MainThreadStackSize    = Registration->MainThreadStackSize;
            service->Priority               = Registration->Priority;
            service->HeapMapSize            = Registration->HeapMapSize;
            service->Context                = NULL;
            service->Started                = false;

            memcpy(service->RequiredModules,Registration->RequiredModules,sizeof(service->RequiredModules));

            if(
                oC_SaveIfFalse("Service::New: Process - ", oC_Process_IsCorrect(service->Process)   , oC_ErrorCode_AllocationError )
             && oC_SaveIfFalse("Service::New: Thread - " , oC_Thread_IsCorrect(service->MainThread) , oC_ErrorCode_AllocationError )
                )
            {
                service->ObjectControl = oC_CountObjectControl(service, oC_ObjectId_Service);

                bool allocationLimitSet = oC_Process_SetAllocationLimit(service->Process, Registration->AllocationLimit);
                oC_SaveIfFalse("Service::New: Cannot set allocation limit ", allocationLimitSet, oC_ErrorCode_InternalDataAreDamaged);
            }
        }
    }

    return service;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Service_Delete( oC_Service_t * Service )
{
    bool deleted = false;

    if(
        oC_SaveIfFalse("Service::Delete ", isram(Service)                   , oC_ErrorCode_AddressNotInRam  )
     && oC_SaveIfFalse("Service::Delete ", oC_Service_IsCorrect(*Service)   , oC_ErrorCode_ObjectNotCorrect )
        )
    {
        oC_IntMan_EnterCriticalSection();
        oC_Service_t service        = *Service;
        oC_Process_t process        = service->Process;
        oC_Thread_t  thread         = service->MainThread;
        bool         memoryReleased = kfree(service, AllocationFlags_Default);
        bool         processKilled  = oC_Process_Kill( process );
        bool         threadDeleted  = oC_Thread_Delete(&thread);
        bool         processDeleted = oC_Process_Delete(&process);

        *Service = NULL;

        if(
            oC_SaveIfFalse("Service::Delete: Main object - ", memoryReleased, oC_ErrorCode_ReleaseError         )
         && oC_SaveIfFalse("Service::Delete: Process - "    , processKilled , oC_ErrorCode_CannotKillProcess    )
         && oC_SaveIfFalse("Service::Delete: Thread - "     , threadDeleted , oC_ErrorCode_ReleaseError         )
         && oC_SaveIfFalse("Service::Delete: Process - "    , processDeleted, oC_ErrorCode_ReleaseError         )
            )
        {
            deleted = true;
        }

        oC_IntMan_ExitCriticalSection();
    }

    return deleted;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Service_IsCorrect( oC_Service_t Service )
{
    return isram(Service) && oC_CheckObjectControl(Service, oC_ObjectId_Service, Service->ObjectControl );
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Service_Start( oC_Service_t Service )
{
    oC_ErrorCode_t  errorCode = oC_ErrorCode_ImplementError;
    oC_Stream_t     stream    = oC_StreamMan_GetStdErrorStream();

    if(
        ErrorCondition( oC_Service_IsCorrect(Service)       == true  , oC_ErrorCode_ObjectNotCorrect            )
     && ErrorCondition( oC_Service_IsActive(Service)        == false , oC_ErrorCode_ServiceAlreadyStarted       )
     && ErrorCondition( AreRequiredModulesEnabled(Service)  == true  , oC_ErrorCode_RequiredModuleNotEnabled    )
        )
    {
        if( oC_Process_IsCorrect(Service->Process) == false || oC_Thread_IsCorrect(Service->MainThread) == false )
        {
            Service->Process    = oC_Process_New( Service->Priority, Service->Name, getcuruser(), Service->HeapMapSize, NULL, stream, stream);
            Service->MainThread = oC_Thread_New ( Service->Priority, Service->MainThreadStackSize, Service->Process, Service->Name, (oC_Thread_Function_t)ServiceThread, Service );
        }
        if(
            ErrorCondition( oC_Process_IsCorrect(Service->Process)   , oC_ErrorCode_AllocationError )
         && ErrorCondition( oC_Thread_IsCorrect(Service->MainThread) , oC_ErrorCode_AllocationError )
         && ErrorCode     ( oC_ProcessMan_AddProcess(Service->Process)                              )
         && ErrorCondition( oC_Thread_Run( Service->MainThread )     , oC_ErrorCode_CannotRunThread )
            )
        {
            errorCode = oC_ErrorCode_None;
        }
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_ErrorCode_t oC_Service_Stop( oC_Service_t Service )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        ErrorCondition( oC_Service_IsCorrect(Service) == true  , oC_ErrorCode_ObjectNotCorrect      )
     && ErrorCondition( oC_Service_IsActive(Service)  == true  , oC_ErrorCode_ServiceNotStarted     )
        )
    {
        oC_IntMan_EnterCriticalSection();

        if(
            Service->Started == false
         ||  (
                ErrorCondition( isaddresscorrect(Service->StopFunction), oC_ErrorCode_WrongAddress  )
             && ErrorCode     ( Service->StopFunction( &Service->Context )                          )
                )
            )
        {
            if( ErrorCode( oC_Process_Kill(Service->Process) ) )
            {
                Service->Process    = NULL;
                Service->MainThread = NULL;
                errorCode           = oC_ErrorCode_None;
            }
        }

        oC_IntMan_ExitCriticalSection();
    }

    return errorCode;
}

//==========================================================================================================================================
//==========================================================================================================================================
bool oC_Service_IsActive( oC_Service_t Service )
{
    return oC_Service_IsCorrect(Service) && oC_Process_IsActive(Service->Process);
}

//==========================================================================================================================================
//==========================================================================================================================================
const char * oC_Service_GetName( oC_Service_t Service )
{
    const char * name = "incorrect service";

    if(oC_Service_IsCorrect(Service))
    {
        name = Service->Name;
    }

    return name;
}

//==========================================================================================================================================
//==========================================================================================================================================
oC_Process_t oC_Service_GetProcess( oC_Service_t Service )
{
    oC_Process_t process = NULL;

    if(oC_Service_IsCorrect(Service))
    {
        process = Service->Process;
    }

    return process;
}

#undef  _________________________________________INTERFACE_SECTION__________________________________________________________________________

#define _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________


//==========================================================================================================================================
//==========================================================================================================================================
static bool AreRequiredModulesEnabled( oC_Service_t Service )
{
    bool allEnabled = true;

    oC_ARRAY_FOREACH_IN_ARRAY(Service->RequiredModules,moduleReference)
    {
        if((*moduleReference) > oC_Module_None && (*moduleReference) < oC_Module_NumberOfModules)
        {
            if(oC_Module_IsTurnedOn(*moduleReference) == false)
            {
                kdebuglog( oC_LogType_Info, "Cannot start service %s - module ID = %d is not enabled", Service->Name, *moduleReference );
                allEnabled = false;
                break;
            }
        }
    }

    return allEnabled;
}

//==========================================================================================================================================
//==========================================================================================================================================
static void ServiceThread( oC_Service_t Service )
{
    oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;

    if(
        oC_SaveIfFalse("ServiceThread: Service is not correct - ", oC_Service_IsCorrect(Service)            , oC_ErrorCode_ObjectNotCorrect )
     && oC_SaveIfFalse("ServiceThread: StartFunction - "         , isaddresscorrect(Service->StartFunction) , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("ServiceThread: MainFunction - "          , isaddresscorrect(Service->MainFunction)  , oC_ErrorCode_WrongAddress     )
     && oC_SaveIfFalse("ServiceThread: StopFunction - "          , isaddresscorrect(Service->StopFunction)  , oC_ErrorCode_WrongAddress     )
        )
    {
        if(oC_SaveIfErrorOccur(Service->Name, errorCode = Service->StartFunction( &Service->Context )))
        {
            kdebuglog( oC_LogType_Track , "The service '%s' has been started", Service->Name );
            oC_SaveIfErrorOccur(Service->Name, errorCode = Service->MainFunction (  Service->Context ));
            kdebuglog( oC_ErrorOccur(errorCode) ? oC_LogType_Error : oC_LogType_Track, "The service '%s' has finished with status '%s'", Service->Name, oC_GetErrorString(errorCode));
            oC_SaveIfErrorOccur(Service->Name, errorCode = Service->StopFunction ( &Service->Context ));
            kdebuglog( oC_ErrorOccur(errorCode) ? oC_LogType_Error : oC_LogType_Track, "The service '%s' has been stopped with status: '%s'", Service->Name, oC_GetErrorString(errorCode));
        }
        else
        {
            kdebuglog( oC_LogType_Error, "Cannot start service '%s' because of error '%s'", Service->Name , oC_GetErrorString(errorCode));
        }
    }
}

#undef  _________________________________________LOCAL_FUNCTIONS_SECTION____________________________________________________________________