{
  /* The main configuration file.
   */
  * = {
    /* Common section for any/all hosts
     */
    * = {
    };
    Control = {
      /* Section for the Control server on any master host.
       */
    };
    Feep = {
      /* Section for the process Feep on any/all hosts.
       */
    };
    Foo = {
      /* Section for the process Foo on any/all hosts.
       */
    };
  };
  localhost = {
    /* Section for the host named localhost
     */
    * = {
      /* Common section for any/all processes on localhost.
       */
    };
    Bar = {
      /* Section for process Bar on localhost
       */
    };
    Foo = {
      /* Section for process Foo on localhost
       */
    };
    Command = {
      /* Section for Command server on localhost
       * The 'Launch' dictionary specifies what programs may be launched.
       */
      Launch = {
        /* Specifications of how to launch individual programs:
         *
         * Disabled = (boolean) Whether this program can be launched
         * Prog = (string)      The name (or full path) of the executable
         * Home = (string)      The subdirectory the program is started up in
	 *			(relative to the user home directory) and the
	 *			subdirectory in which debug logs are stored.
	 *			Equivalent to using -HomeDirectory in Args.
         * Args = (array)       The arguments supplied to the program
         * Auto = (boolean)     Whether the program is started automatically
         * Time = (integer)     How many seconds after a crash until the
         *                      automatic restart (defaults to 0; fast)
         * AddE = (dictionary)  key/value pairs added to the environment
         * SetE = (dictionary)  key/value pairs to be used as environment
         * Deps = (array)       Names of other processes needed by this one
         * KeepStandardOutput = (boolean)    Don't close stdout
         * KeepStandardError = (boolean)     Don't close stderr
	 *
	 * ValgrindPath = (string)	Run under valgrind (unless empty)
	 * ValgrindArgs = (array)	Run under valgrind using these args
	 *
	 * PingTime = (integer)	If greater than zero, this is the ping delay in
	 *			seconds (otherwise the default of 240 is used,
	 *			or as specified by the CommandPingTime default).
	 *			When a process has been unresponsive to the
	 *			Command server for this number of seconds, that
	 *			process is considered to be hung.
	 * HungTime = (integer)	If greater than zero this the interval after
	 *			which an apparently hung process has a restart
	 *			scheduled.  If/when the restart is scheduled
	 *			either the HungTool or gcore is executed
	 *			to save information about the hung process.
	 * HungTool = (string)	The name of a tool or script to be executed
	 *			after HungTime in order to gather information
	 *			about the hung process.  It's arguments will
	 *			be the process name and the process ID.
	 * QuitTime = (integer)	If greater than zero this the interval before
	 *			a process is forcibly killed if it is stopping
	 *			or restarting too slowly.  The default (used
	 *			if this is not specified and greater than zero)
	 *			is 120 seconds (or as specified by the
	 *			CommandQuitTime default).
	 *
	 * If a process hangs and is configured to auto-restart when hung:
	 * The total time taken is (PingTime + HungTime + StopTime)
	 * After PingTime seconds of unresponsiveness an alarm is raised.
	 * Then after HungTime seconds restart is initiated and HungTool runs.
	 * Then after StopTime seconds the process is forcibly killed.
         *
         * If the system is running with encrypted Distributed Objects then
         * child processes may be launched with specific TLS options (rather
         * than inheriting the configuration of the Command server) by adding
         * ClientOptionsForTLS = {dictionary};
         * to specify the options used when the child connects to another
         * process (eg when the child registers with the Command server) and
         * ServerOptionsForTLS = {dictionary};
         * to specify the options used when another process connects to the
         * child process.
         * If the child is supposed to use the same options in both cases,
         * a single OptionsForTLS dictionary may be used instead.
         * The contents of the dictionary are TLS configuration keys and
         * values as per the gnustep-base documentation:
         * GSTLSCAFile GSTLSCertificateFile GSTLSCertificateKeyFile
         * GSTLSCertificateKeyPassword GSTLSDebug GSTLSPriority
         * GSTLSRemoteHosts GSTLSRevokeFile GSTLSServerName GSTLSVerify
         */
	Foo = {
	  Prog = "/usr/GNUstep/Local/Tools/Foo";	// Full path to binary
	  Home = "Test";				// Directory to run in
	  Args = ("-Debug", "YES");			// Args to launch with
	  Auto = NO;					// Auto-launch?
          KeepStandardOutput = YES;                     // Don't close stdout
          KeepStandardError = YES;                      // Don't close stderr
	};
	Bar = {
	  Prog = "Bar";                         	// Name of binary
	  Home = "Test";				// Directory to run in
	  Args = ("-Debug", "YES");			// Args to launch with
	  Auto = YES;					// Auto-launch?
          Deps = (Foo);                                 // if Foo is running
	};
	Feep = {
	  Prog = "Feep";                         	// RName of binary
	  Home = "Test";				// Subdirectory
	  Auto = YES;					// Auto-launch?
          Time = 30;            // Interval for relaunching after crash
	};
      };

      /* Specify launch order ... Feep first, Bar second
       * Processes not listed here are launched in lexicographical order
       * after any processes which are listed.
       */
      LaunchOrder = (
        Feep,                                   // Launch Feep first
        Bar                                     // Launch Bar second
      );

      /* Specify how many tasks the Command server may have launching
       * concurrently (default is 20).  You may want to set this to a
       * lower value in order to reduce load when the system start up.
       */
      LaunchLimit = 20;

      /* Specify whether, when the Command server starts, launching of
       * tasks should be suspended (as if the 'suspend' command had been
       * sent to it from the Console).
       * By default this is NO.
       */
      LaunchStartSuspended = NO;

      /* Optionally specify an alternative default environment for launched
       * processes.  If this is not set then the environment in which the
       * Command server was launched is used.
       *  SetE = {
       *  };
       */

      /* Optionally specify additions to the default environment for launched
       * processes.  This is typically used to modify the information that
       * comes from the environment the Command server was launched in.
       *  AddE = {
       *  };
       */

      /* Configure all tasks to be run under valgrind specifying the path
       * to the process, which may be overridden on a per-process basis
       * in the Launch config.  Setting ValgrindPath to an empty string
       * in the launch config ensures that the process is NOT launched
       * under valgrind.  
       * ValgrindArgs = (...);
       * ValgrindPath = "...";
       */
    };
  };
  /* Section specific for the Control server itself.
   */
  "" = {
  };
}