application.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
 
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/atomic.h>
#include <promeki/duration.h>
#include <promeki/eventloop.h>
#include <promeki/error.h>
#include <promeki/mutex.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/uniqueptr.h>
#include <promeki/uuid.h>
 
PROMEKI_NAMESPACE_BEGIN
class Thread;
class IODevice;
class DebugServer;
class SocketAddress;
class CpuMonitor;
PROMEKI_NAMESPACE_END
 
PROMEKI_NAMESPACE_BEGIN
 
class Application {
        public:
                Application(int argc, char **argv);
 
                ~Application();
 
                Application(const Application &) = delete;
                Application(Application &&) = delete;
                Application &operator=(const Application &) = delete;
                Application &operator=(Application &&) = delete;
 
                static const StringList &arguments();
 
                static const UUID &appUUID();
 
                static void setAppUUID(const UUID &uuid);
 
                static int64_t pid();
 
                static const String &appName();
 
                static void setAppName(const String &name);
 
                static Thread *mainThread();
 
                static EventLoop *mainEventLoop();
 
                static IODevice *stdinDevice();
 
                static IODevice *stdoutDevice();
 
                static IODevice *stderrDevice();
 
                static void installSignalHandlers();
 
                static void uninstallSignalHandlers();
 
                static bool areSignalHandlersInstalled();
 
                static void installCrashHandler();
 
                static void uninstallCrashHandler();
 
                static bool isCrashHandlerInstalled();
 
                static void refreshCrashHandler();
 
                static void writeTrace(const char *reason = nullptr);
 
                static void quit(int exitCode = 0);
 
                using QuitRequestHandler = Function<bool(int exitCode)>;
 
                static void setQuitRequestHandler(QuitRequestHandler handler);
 
                static bool shouldQuit();
 
                static int exitCode();
 
                static const char *DebugServerEnv;
 
                static Error startDebugServer(const SocketAddress &address);
 
                static Error startDebugServer(uint16_t port);
 
                static void stopDebugServer();
 
                static DebugServer *debugServer();
 
                static Error startCpuMonitor(const Duration &interval);
 
                static void stopCpuMonitor();
 
                static CpuMonitor *cpuMonitor();
 
                static Error startEventLoopMonitors(const Duration &interval,
                                                    EventLoop::ReportFunction fn = {});
 
                static void stopEventLoopMonitors();
 
                static bool eventLoopMonitorsEnabled();
 
                static void installEventLoopMonitorIfEnabled(EventLoop *loop);
 
                int exec();
 
        private:
                struct Data {
                                StringList             arguments;
                                UUID                   appUUID;
                                String                 appName;
                                Thread                *mainThread = nullptr;
                                // Atomic so the signal-watcher thread
                                // can latch a quit request while the
                                // main thread is polling
                                // @ref Application::shouldQuit.
                                Atomic<int>            exitCode{0};
                                Atomic<bool>           shouldQuit{false};
                                QuitRequestHandler     quitHandler;
                                UniquePtr<DebugServer> debugServer;
                                UniquePtr<CpuMonitor>  cpuMonitor;
 
                                // Auto-install hook for new
                                // EventLoops.  Guarded by
                                // elMonitorMutex because
                                // ReportFunction is std::function
                                // and not safe to read across
                                // threads without a barrier; we
                                // copy the trio under the lock at
                                // every read site so the global
                                // mutex is never held while
                                // installMonitor (which takes its
                                // own mutex) runs.
                                bool                      elMonitorEnabled = false;
                                Duration                  elMonitorInterval;
                                EventLoop::ReportFunction elMonitorFn;
                                mutable Mutex             elMonitorMutex;
                };
                static Data &data();
 
                static void maybeStartDebugServerFromEnv();
 
                // The main-thread EventLoop.  Constructed as a member
                // of Application so subsystems installed on the stack
                // immediately after `Application app(argc, argv);`
                // have a ready-made loop to register their I/O
                // sources on.  Declared after the static data accessor
                // so it participates in member init order.
                EventLoop _eventLoop;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE