projects/mde: mde/scheduler/Init.d comparison

comparison mde/scheduler/Init.d @ 29:f985c28c0ec9

A new GUI widget plus changes to the init system. GUI: Implemented a GridWidget to layout several sub-widgets. Improved log messages about init functions. Moved all dynamic-library loading into a separate init stage. committer: Diggory Hardy <diggory.hardy@gmail.com>

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Sat, 12 Apr 2008 14:10:13 +0100
parents	b5fadd8d930b
children	467c74d4804d

comparison

equal deleted inserted replaced

-:b5fadd8d930b
+:f985c28c0ec9
 version (SwitchAppender) {  // My own variation, currently just a test
 import tango.util.log.SwitchingFileAppender : SwitchingFileAppender;
 } else {
 import tango.util.log.RollingFileAppender : RollingFileAppender;
 }
+// Derelict imports
+import derelict.opengl.gl;
+import derelict.sdl.sdl;
+//import derelict.freetype.ft;
+import derelict.util.exception;
 /**
 * Static CTOR
 *
 * This should handle a minimal amount of functionality where useful. For instance, configuring the
 private static Logger logger;
 static this() {
 logger = Log.getLogger ("mde.scheduler.Init.Init");
 }
-/** CTOR − initialisation
+/** this() − initialisation
 *
 * Runs general initialisation code, in a threaded manner where this isn't difficult.
+* If any init fails, cleanup is still handled by ~this().
 *
-* If any init fails, it must run necessary cleanup first since the DTOR cannot(?) be run. */
+* Init order: 1. Pre-init (loads components needed by most init functions). 2. Dynamic library
+* loading (load any dynamic libraries first, so that if loading fails nothing else need be
+* done). 3. Init functions (threaded functions handling the rest of initialisation).
+*/
 /* In a single-threaded function this could be done with:
 * scope(failure) cleanup;
 * This won't work with a threaded init function since any threads completing succesfully will
 * not clean-up, and a fixed list of clean-up functions cannot be used since clean-up functions
 * must not run where the initialisation functions have failed.
 // Now re-set the logging level:
 Log.getRootLogger.setLevel (cast(Log.Level) miscOpts.logLevel, true);  // set the stored log level
 //END Pre-init
+debug logger.trace ("Init: pre-init done");
+//BEGIN Load dynamic libraries
+/* Can be done by init functions but much neater to do here.
+* Also means that init functions aren't run if a library fails to load. */
+try {
+DerelictSDL.load();
+DerelictGL.load();
+//DerelictFT.load();
+} catch (DerelictException de) {
+logger.fatal ("Loading dynamic library failed:");
+logger.fatal (de.msg);
+throw new InitException ("Loading dynamic libraries failed (see above).");
+return;
+}
+//END Load dynamic libraries
+debug logger.trace ("Init: dynamic libraries loaded");
 //BEGIN Init (stages init2, init4)
 /* Call init functions.
 *
 * Current method is to try using threads, and on failure assume no threads were actually
 private static {
 /* The following three functions, runStage*, each run all functions in a stage in some order,
 * catching any exceptions thrown by the functions (although this isn't guaranteed for threads),
 * and throw an InitStageException on initFailure. */
-const UFE = "Unhandled exception from Init function:";
+const LOG_IF_MSG = "Init function ";
+const LOG_CF_MSG = "Cleanup function ";
+const LOG_F_START = " - running";
+const LOG_F_END = " - completed";
+const LOG_F_FAIL = " - failed: ";
 /* Runs all functions consecutively, first-to-last.
 * If any function fails, halts immediately. */
 void runStageForward (InitStage s) {
 foreach (func; s.funcs) {
 if (initFailure) break;
 try {
-func();
+debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_START);
+func.func();
+debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_END);
 } catch (Exception e) {
-logger.fatal (UFE);
+logger.fatal (LOG_IF_MSG ~ func.name ~ LOG_F_FAIL ~
-logger.fatal (e.msg);
+((e.msg is null || e.msg == "") ? "(no failure message)" : e.msg) );
 setInitFailure();
 }
 }
 /* Runs all functions consecutively, last-to-first.
 * If any function fails, continue until all have been run. */
 void runStageReverse (InitStage s) {
 foreach_reverse (func; s.funcs) {
 try {
-func();
+debug logger.trace (LOG_CF_MSG ~ func.name ~ LOG_F_START);
+func.func();
+debug logger.trace (LOG_CF_MSG ~ func.name ~ LOG_F_END);
 } catch (Exception e) {
-logger.fatal (UFE);
+logger.fatal (LOG_CF_MSG ~ func.name ~ LOG_F_FAIL ~
-logger.fatal (e.msg);
+((e.msg is null || e.msg == "") ? "(no failure message)" : e.msg) );
 setInitFailure();
 }
 }
 if (initFailure) throw new InitStageException;    // Problem running; abort and cleanup from here.
 if (!miscOpts.useThreads) return true;  // Use unthreaded route instead
 ThreadGroup tg;
 try {                           // creating/starting threads could fail
 tg = new ThreadGroup;
-foreach (func; s.funcs) tg.create(func);  // Start all threads
+foreach (func; s.funcs) {   // Start all threads
+debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_START);
+tg.create(func.func);
+debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_END);
+}
 } catch (ThreadException e) {   // Problem with threading; try without threads
 logger.error ("Caught ThreadException while trying to create threads:");
 logger.error (e.msg);
-logger.info ("Will disable threads and continue.");
+logger.info ("Will disable threads and continue, assuming no threads were created.");
 Options.setBool("misc", "useThreads", false);   // Disable threads entirely
 return true;                // Try again without threads
 }

Mercurial > projects > mde

comparison mde/scheduler/Init.d @ 29:f985c28c0ec9