void initialize

(

)

Definition at line 385 of file feeserver.c.

References createLogMessage(), dim_dummy_exit_handler(), dim_error_msg_handler(), dis_add_error_handler(), dis_add_exit_handler, dtq_sleep(), fee_exit_handler(), initMessageStruct(), Memory::malloc(), sprintf(), start(), threadInitializeCE(), time, triggerRestart(), unpublishCharItemList(), unpublishIntItemList(), and unpublishItemList().

Referenced by FloatInfo::FloatInfo(), and main().

                  {
        //-- Declaring variables --
        struct timeval now;
        struct timespec timeout;
        pthread_attr_t attr;
        int nRet;
        int status;
        int initState  = FEE_CE_NOTINIT;
        char* name = 0;
        char* dns = 0;
        bool initOk = true;
        unsigned int envVal = 0;
        char msg[250];
        int restartCount = 0;

        //-- register interrupt handler (CTRL-C)
        // not used yet, causes problems
//      if (signal(SIGINT, interrupt_handler) == SIG_ERR) {
//#             ifdef __DEBUG
//              printf("Unable to register interrupt handler.\n");
//              printf("This is not fatal -> continuing.\n");
//#             endif
//      }

        //-- get name of the server --
        name = getenv("FEE_SERVER_NAME");
        if (name == 0) {
#               ifdef __DEBUG
                printf("No FEE_SERVER_NAME \n");
#               endif
                exit(202);
        }

        serverName = (char*) malloc(strlen(name) + 1);
        if (serverName == 0) {
                //no memory available!
#               ifdef __DEBUG
                printf("no memory available while trying to create server name!\n");
#               endif
                exit(201);
        }
        strcpy(serverName, name);
        serverNameLength = strlen(serverName);

        //-- test, if DIM_DNS_NODE is specified
        dns = getenv("DIM_DNS_NODE");
        if (dns == 0) {
#               ifdef __DEBUG
                printf("No DIM_DNS_NODE specified. \n");
#               endif
                exit(203);
        }

        // set the desired log level, if provided
        if (getenv("FEE_LOG_LEVEL")) {
                sscanf(getenv("FEE_LOG_LEVEL"), "%d", &envVal);
                if ((envVal < 0) || (envVal > MSG_MAX_VAL)) {
#                   ifdef __DEBUG
                        printf("Environmental variable has invalid Log Level, using default instead.\n");
                        fflush(stdout);
#                       endif
                } else {
                        logLevel = envVal | MSG_ALARM;
                }
        }

        // set logWatchDogTimeout, if env variable "FEE_LOGWATCHDOG_TIMEOUT" is set
    if (getenv("FEE_LOGWATCHDOG_TIMEOUT")) {
        sscanf(getenv("FEE_LOGWATCHDOG_TIMEOUT"), "%d", &envVal);
        if ((envVal <= 0) || (envVal > MAX_TIMEOUT)) {
#           ifdef __DEBUG
            printf("Environmental variable has invalid LogWatchDog Timeout, using default instead.\n");
            fflush(stdout);
#           endif
        } else {
            logWatchDogTimeout = envVal;
        }
    }

        // get restart counter
        if (getenv("FEESERVER_RESTART_COUNT")) {
                restartCount = atoi(getenv("FEESERVER_RESTART_COUNT"));
        }

        // Initial printout
#       ifdef __DEBUG
        printf("\n  **  FeeServer version %s  ** \n\n", FEESERVER_VERSION);
        printf("FeeServer name: %s\n", serverName);
        printf("Using DIM_DNS_NODE: %s\n", dns);
#   ifdef __BENCHMARK
    printf(" -> Benchmark version of FeeServer <- \n");
#       endif
        printf("Current log level is: %d (MSG_ALARM (%d) is always on)\n", logLevel, MSG_ALARM);
        printf("Restart Count is: %d; Restart-Env is: %s\n", restartCount, 
                        getenv("FEESERVER_RESTART_COUNT"));
#       endif

        //set dummy exit_handler to disable framework exit command, returns void
        dis_add_exit_handler(&dim_dummy_exit_handler);

        //set error handler to catch DIM framework messages
        dis_add_error_handler(&dim_error_msg_handler);

        // to ensure that signal is in correct state before init procedure
        ceReadySignaled = false;

        // lock mutex
        status = pthread_mutex_lock(&wait_init_mut);
        if (status != 0) {
#               ifdef __DEBUG
                printf("Lock init mutex error: %d\n", status);
                fflush(stdout);
#               endif
                initOk = false;
        } else {
                // initiailisation of thread attribute only if mutex has been locked
                status = pthread_attr_init(&attr);
                if (status != 0) {
#                       ifdef __DEBUG
                        printf("Init attribute error: %d\n", status);
                        fflush(stdout);
#                       endif
                        initOk = false;
                } else {
                        status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
                        if (status != 0) {
#                               ifdef __DEBUG
                                printf("Set attribute error: %d\n", status);
                                fflush(stdout);
#                               endif
                                initOk = false;
                        }
                }
        }

        if (initOk == true) {
                // call only if initOk == true,
                status = pthread_create(&thread_init, &attr, (void*) &threadInitializeCE, 0);
                if (status != 0) {
#                       ifdef __DEBUG
                        printf("Create thread error: %d\n", status);
                        fflush(stdout);
#                       endif
                        initState = FEE_CE_NOTINIT;
                } else {
#                       ifdef __DEBUG // for debugging the time amount the watchdog really waits (START)
                        time_t initStartTime = time(NULL);
#                       endif //__DEBUG

                        // timeout set in ms, should be enough for initialisation; see fee_defines.h for current value
                        status = gettimeofday(&now, 0);
                        if ((status != 0) || (restartCount <= 0)) {
                                // backup solution for detetcting end of init process
#                               ifdef __DEBUG
                                printf("Get time of day error: %d or restartCount <= 0 (%d), using backup solution\n",
                                                status, restartCount);
                                fflush(stdout);
#                               endif
                                // unlock mutex to enable functionality of signalCEReady
                                status = pthread_mutex_unlock(&wait_init_mut);
#                               ifdef __DEBUG
                                if (status != 0) {
                                        printf("Unlock mutex error: %d\n", status);
                                        fflush(stdout);
                                }
#                               endif
                                // sleep init-timeout length
                                usleep((TIMEOUT_INIT_CE_MSEC * 1000)); // sleep the microsec fraction

                                const int sleepFraction = 1; // to check ready signal each second
                                int sleepLoops = TIMEOUT_INIT_CE_SEC / sleepFraction;
                                int cycles = 0;
                                do {
                                        dtq_sleep(sleepFraction);
                                        if (ceReadySignaled) {
                                                break;
                                        }
                                } while ( cycles++ < sleepLoops);
//                              dtq_sleep(TIMEOUT_INIT_CE_SEC);  // old style without check each second

                                if (ceReadySignaled == false) {
                                        status = pthread_cancel(thread_init);
#                                       ifdef __DEBUG
                                        if (status != 0) {
                                                printf("No thread to cancel: %d\n", status);
                                                fflush(stdout);
                                        }
#                                       endif
                                        // start with "the CE is not initialized!"
                                        initState = FEE_CE_NOTINIT;
#                                       ifdef __DEBUG
                                        printf("Timeout in init [sleep]: %d\n", initState);
                                        fflush(stdout);
#                                       endif
                                } else {
                                        if (ceInitState != CE_OK) {
                                                // init failed, but no timeout occured
                                                // (insufficient memory, etc. ... or something else)
#                                               ifdef __DEBUG
                                                printf("Init of CE failed, error: %d\n", ceInitState);
                                                fflush(stdout);
#                                               endif
                                                initState = FEE_CE_NOTINIT;
                                        } else {
                                                // start with "everything is fine"
                                                initState = FEE_OK;
#                                               ifdef __DEBUG
                                                printf("Init OK\n");
                                                fflush(stdout);
#                                               endif
                                        }
                                }
                        } else {
                                timeout.tv_sec = now.tv_sec + TIMEOUT_INIT_CE_SEC;
                                timeout.tv_nsec = (now.tv_usec * 1000) +
                                                (TIMEOUT_INIT_CE_MSEC * 1000000);

                                // wait for finishing "issue" or timeout after the mutex is unlocked
                                // a retcode of 0 means, that pthread_cond_timedwait has returned
                                // with the cond_init signaled
                                status = pthread_cond_timedwait(&init_cond, &wait_init_mut, &timeout);
                                // -- start FeeServer depending on the state of the CE --
                                if (status != 0) {
                                        status = pthread_cancel(thread_init);
#                                       ifdef __DEBUG
                                        if (status != 0) {
                                                printf("No thread to cancel: %d\n", status);
                                                fflush(stdout);
                                        }
#                                       endif
                                        // start with "the CE is not initialized!"
                                        initState = FEE_CE_NOTINIT;
#                                       ifdef __DEBUG
                                        printf("Timeout in init [timed_wait]: %d\n", initState);
                                        fflush(stdout);
#                                       endif
                                } else {
                                        if (ceInitState != CE_OK) {
                                                // init failed, but no timeout occured
                                                // (insufficient memory, etc. ... or something else)
#                                               ifdef __DEBUG
                                                printf("Init of CE failed, error: %d\n", ceInitState);
                                                fflush(stdout);
#                                               endif
                                                initState = FEE_CE_NOTINIT;
                                        } else {
                                                // start with "everything is fine"
                                                initState = FEE_OK;
#                                               ifdef __DEBUG
                                                printf("Init OK\n");
                                                fflush(stdout);
#                                               endif
                                        }
                                }
                        }
#                       ifdef __DEBUG  // for debugging the time amout the watchdog waits (STOP)
                        time_t initStopTime = time(NULL);
                        if (initState != FEE_OK) {
                                printf("Watchdog: CE init tread\n   started %s",
                                                ctime(&initStartTime));
                                printf("   killed  %s\n", ctime(&initStopTime));
                                // don't put this into one printf line -
                                // ctime or printf doe not work correct then, why?
                                fflush(stdout);
                        } else {
                                printf("Watchdog: CE init tread\n   started  %s", 
                                                ctime(&initStartTime));
                                printf("   finished %s\n", ctime(&initStopTime)); 
                                // don't put this into one printf line - 
                                // ctime or printf doe not work correct then, why?
                                fflush(stdout);
                        }
#                       endif //__DEBUG
                }
                // destroy thread attribute
                status = pthread_attr_destroy(&attr);
#               ifdef __DEBUG
                if (status != 0) {
                        printf("Destroy attribute error: %d\n", status);
                        fflush(stdout);
                }
#               endif
        }

        // init message struct -> FeeServer name, version and DNS are also provided
        initMessageStruct();

        if (initState != FEE_OK) {
                // remove all services of Items of ItemList
#               ifdef __DEBUG
                printf("Init failed, unpublishing item list\n");
                fflush(stdout);
#               endif
                unpublishItemList();
                // new since version 0.8.1 -> int channels
                unpublishIntItemList();
        // new since version 0.8.2b -> char channels
        unpublishCharItemList();
        }

        // add div. services and the command channel and then start DIM server
        nRet = start(initState);

        // unlock mutex
        status = pthread_mutex_unlock(&wait_init_mut);
        if (status != 0) {
#               ifdef __DEBUG
                printf("Unlock mutex error: %d\n", status);
                fflush(stdout);
#               endif
                if (nRet == FEE_OK) {
                        createLogMessage(MSG_WARNING, "Unable to unlock init mutex.", 0);
                }
        }

        if (nRet != FEE_OK) {
#               ifdef __DEBUG
                printf("unable to start DIM server, exiting.\n");
                fflush(stdout);
#               endif
                fee_exit_handler(205);
        } else {
#               ifdef __DEBUG
                printf("DIM Server successfully started, ready to accept commands.\n");
                fflush(stdout);
#               endif
        }

#       ifdef __DEBUG
        printf("DEBUG - Init-State: %d, CE-State: %d, Restart-Env: %s, RestartCount: %d.\n",
                                initState, ceInitState, getenv("FEESERVER_RESTART_COUNT"), restartCount);
        fflush(stdout);
#       endif

        // test for failed init of CE and init restart counter,
        // counter counts backwards: only if counter > 0 restart is triggerd
        if ((initState != FEE_OK) && (getenv("FEESERVER_RESTART_COUNT")) &&
                        (restartCount > 0)) {
                msg[sprintf(msg,
                                "Triggering a FeeServer restart to give CE init another try. Restart count (backward counter): %d ",
                                restartCount)] = 0;
                createLogMessage(MSG_WARNING, msg, 0);
#               ifdef __DEBUG
                printf("Triggering a FeeServer restart for another CE init try (backward count: %d).\n",
                                restartCount);
                fflush(stdout);
#               endif
                // small sleep, that DIM is able to send log messages before restart
                dtq_sleep(1);
                // trigger restart to give it another try for the CE to init
                triggerRestart(FEE_EXITVAL_TRY_INIT_RESTART);
                // NOTE this function won't return ...
        }
        // look through watchdog and backup solution about ceInitState and check it again !!!
        // afterwards the following line won't be necessary !!!
        // needed later in information about properties !!!
//      ceInitState = initState;

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function: