llapp.h

Go to the documentation of this file.

#ifndef LL_LLAPP_H
#define LL_LLAPP_H

#include <map>
#include "llapr.h"
#include "llrun.h"
#include "llsd.h"

// Forward declarations
class LLErrorThread;
class LLApp;


typedef void (*LLAppErrorHandler)();
typedef void (*LLAppChildCallback)(int pid, bool exited, int status);

#if !LL_WINDOWS
extern S32 LL_SMACKDOWN_SIGNAL;
extern S32 LL_HEARTBEAT_SIGNAL;

// Clear all of the signal handlers (which we want to do for the child process when we fork
void clear_signals();

class LLChildInfo
{
public:
        LLChildInfo() : mGotSigChild(FALSE), mCallback(NULL) {}
        BOOL mGotSigChild;
        LLAppChildCallback mCallback;
};
#endif

class LLApp
{
        friend class LLErrorThread;
public:
        typedef enum e_app_status
        {
                APP_STATUS_RUNNING,             // The application is currently running - the default status
                APP_STATUS_QUITTING,    // The application is currently quitting - threads should listen for this and clean up
                APP_STATUS_STOPPED,             // The application is no longer running - tells the error thread it can exit
                APP_STATUS_ERROR                // The application had a fatal error occur - tells the error thread to run
        } EAppStatus;


        LLApp();
        virtual ~LLApp();

        static LLApp* instance();

        enum OptionPriority
        {
                PRIORITY_RUNTIME_OVERRIDE,
                PRIORITY_COMMAND_LINE,
                PRIORITY_SPECIFIC_CONFIGURATION,
                PRIORITY_GENERAL_CONFIGURATION,
                PRIORITY_DEFAULT,
                PRIORITY_COUNT
        };

        LLSD getOption(const std::string& name) const;

        bool parseCommandOptions(int argc, char** argv);

        bool setOptionData(OptionPriority level, LLSD data);

        LLSD getOptionData(OptionPriority level);



        //
        // Main application logic
        //
        virtual bool init() = 0;                        // Override to do application initialization

        //
        // cleanup()
        //
        // It's currently assumed that the cleanup() method will only get
        // called from the main thread or the error handling thread, as it will
        // likely do thread shutdown, among other things.
        //
        virtual bool cleanup() = 0;                     // Override to do application cleanup

        //
        // mainLoop()
        //
        // Runs the application main loop.  It's assumed that when you exit
        // this method, the application is in one of the cleanup states, either QUITTING or ERROR
        //
        virtual bool mainLoop() = 0; // Override for the application main loop.  Needs to at least gracefully notice the QUITTING state and exit.


        //
        // Application status
        //
        static void setQuitting();      // Set status to QUITTING, the app is now shutting down
        static void setStopped();       // Set status to STOPPED, the app is done running and should exit
        static void setError();         // Set status to ERROR, the error handler should run
        static bool isStopped();
        static bool isRunning();
        static bool isQuitting();
        static bool isError();
        static bool isExiting(); // Either quitting or error (app is exiting, cleanly or not)
#if !LL_WINDOWS
        static U32  getSigChildCount();
        static void incSigChildCount();
#endif
        static int getPid();

        //
        // Error handling methods
        //
        void setErrorHandler(LLAppErrorHandler handler);
        void setSyncErrorHandler(LLAppErrorHandler handler);

#if !LL_WINDOWS
        //
        // Child process handling (Unix only for now)
        //
        // Set a callback to be run on exit of a child process
        // WARNING!  This callback is run from the signal handler due to the extreme crappiness of
        // Linux threading requiring waitpid() to be called from the thread that spawned the process.
        // At some point I will make this more behaved, but I'm not going to fix this right now - djs
        void setChildCallback(pid_t pid, LLAppChildCallback callback);

    // The child callback to run if no specific handler is set
        void setDefaultChildCallback(LLAppChildCallback callback); 
        
    // Fork and do the proper signal handling/error handling mojo
        // WARNING: You need to make sure your signal handling callback is correct after
        // you fork, because not all threads are duplicated when you fork!
        pid_t fork(); 
#endif

        LLRunner& getRunner() { return mRunner; }

public:
        typedef std::map<std::string, std::string> string_map;
        string_map mOptionMap;  // Contains all command-line options and arguments in a map

protected:

        static void setStatus(EAppStatus status);               // Use this to change the application status.
        static EAppStatus sStatus; // Reflects current application status
        static BOOL sErrorThreadRunning; // Set while the error thread is running

#if !LL_WINDOWS
        static LLAtomicU32* sSigChildCount; // Number of SIGCHLDs received.
        typedef std::map<pid_t, LLChildInfo> child_map; // Map key is a PID
        static child_map sChildMap;
        static LLAppChildCallback sDefaultChildCallback;
#endif

        void stepFrame();

private:
        void setupErrorHandling();              // Do platform-specific error-handling setup (signals, structured exceptions)

        static void runErrorHandler(); // run shortly after we detect an error, ran in the relatively robust context of the LLErrorThread - preferred.
        static void runSyncErrorHandler(); // run IMMEDIATELY when we get an error, ran in the context of the faulting thread.

        // *NOTE: On Windows, we need a routine to reset the structured
        // exception handler when some evil driver has taken it over for
        // their own purposes
        typedef int(*signal_handler_func)(int signum);
        static LLAppErrorHandler sErrorHandler;
        static LLAppErrorHandler sSyncErrorHandler;

        // Default application threads
        LLErrorThread* mThreadErrorp;           // Waits for app to go to status ERROR, then runs the error callback

        // This is the application level runnable scheduler.
        LLRunner mRunner;


        // The application options.
        LLSD mOptions;


private:
        // the static application instance if it was created.
        static LLApp* sApplication;


#if !LL_WINDOWS
        friend void default_unix_signal_handler(int signum, siginfo_t *info, void *);
#endif

public:
        static BOOL sLogInSignal;
};

#endif // LL_LLAPP_H

---