This is a first-pass review only.

 - There are a few minor manpage updates and typo fixes that aren't
directly related to this branch, could you separate those out (ask
Colin about bzr interactive :p) and submit separately.

 - That init/main.c hack is horrible :-)  What did __attribute__
((unused)) do to you to make you spurn it so? ;-)

 - init/parse_conf.c - this assert seems unrelated to override
support?  Can you commit it separately?

 - init/parse_job.c - is:

    if (!update)
        nih_free (class);
    return NULL;

   better style? discuss


   stanza_manual - I couldn't work out the reason for this change, the
previous code was clearer I think

 - init/conf.c

   extension defines should maybe go in paths.h?

   toggle_conf_name by style needs to accept a parent as the first
argument and pass to nih_strndup

   conf_reload - removed the ENOENT guard, why?

   conf_source_* - seems to have tab damage?  the indentation changes
(and even style change!) make this diff quite hard to review


Are there debug functions used anywhere?  Or are they for gdb?

Scott

On Wed, Jan 12, 2011 at 4:28 AM, James Hunt <email address hidden> wrote:
> James Hunt has proposed merging lp:~jamesodhunt/upstart/override-support into lp:upstart.
>
> Requested reviews:
>  Scott James Remnant (scott)
>
> For more details, see:
> https://code.launchpad.net/~jamesodhunt/upstart/override-support/+merge/45956
>
> Implemented override feature on blueprint:
>
> https://blueprints.launchpad.net/ubuntu/+spec/packageselection-foundations-n-finish-upstart
>
> Details:
>
>  * Generic
>    - fixed typos.
>    - addition of debug functions useful for gdb sessions (available
>      only in DEBUG build).
>  * init/conf.c:
>      - (toggle_conf_name): New function which convert a conf file
>        name to an override name and vice versa.
>      - (conf_reload): Removed ENOENT check to ensure error thrown if
>        conf files/dirs do not exist.
>      - (conf_reload_path): Now takes an extra override_path parameter.
>      - (is_conf_file/is_conf_file_std/is_conf_file_override): New
>        functions to determine type of given file path.
>      - majority of remaining functions updated to handle override
>        files.
>  * init/man/init.5: Updated to document override file support.
>  * init/man/init.8: Added reference to control-alt-delete(7) man page.
>  * init/parse_conf.c: Added assertion to remind us forcibly to add
>    override-handling code for directories if we ever allow content in
>    'init.conf'.
>  * init/parse_job.c (parse_job): Additional parameter 'update' to
>    allow override files to replace existing Job details.
>  * init/test_conf.c
>      - test_override(): New function.
>      - test_toggle_conf_name(): New function.
>  * init/test_parse_job.c:
>      - Updated for extra parse_job() parameter
>      - added a test feature to test_parse_job() to exercise new
>        parameter to parse_job().
>  * util/man/initctl.8: Clarified what it means to restart a job.
>
> To test:
>
>  make check
> --
> https://code.launchpad.net/~jamesodhunt/upstart/override-support/+merge/45956
> You are requested to review the proposed merge of lp:~jamesodhunt/upstart/override-support into lp:upstart.
>
> === modified file 'init/conf.c'
> --- init/conf.c 2009-07-08 21:05:59 +0000
> +++ init/conf.c 2011-01-12 04:27:54 +0000
> @@ -49,6 +49,17 @@
>  #include "conf.h"
>  #include "errors.h"
>
> +/* File extension for standard configuration files */
> +#define CONF_EXT_STD      ".conf"
> +
> +/* File extension for override files.
> + *
> + * Note that override files are not stored in the ConfSource 'files' hash:
> + * all JobClass information from override files is added to the JobClass for
> + * the corresponding (CONF_EXT_STD) object.
> + */
> +#define CONF_EXT_OVERRIDE ".override"
> +
>
>  /* Prototypes for static functions */
>  static int  conf_source_reload_file    (ConfSource *source)
> @@ -70,9 +81,32 @@
>                                        struct stat *statbuf)
>        __attribute__ ((warn_unused_result));
>
> -static int  conf_reload_path           (ConfSource *source, const char *path)
> -       __attribute__ ((warn_unused_result));
> -
> +static int  conf_reload_path           (ConfSource *source, const char *path,
> +                                       const char *override_path)
> +       __attribute__ ((warn_unused_result));
> +
> +static inline int  is_conf_file        (const char *path)
> +       __attribute__ ((warn_unused_result));
> +
> +#define IS_CONF_EXT_STD(period) \
> +  (!strcmp (period, CONF_EXT_STD))
> +
> +#define IS_CONF_EXT_OVERRIDE(period) \
> +  (!strcmp (period, CONF_EXT_OVERRIDE))
> +
> +/**
> + *
> + * Determine if specified filename has a valid configuration file name
> + * extension.
> + *
> + * @period: pointer to last period in filename.
> + *
> + * Returns: TRUE if extension beyond @period is one of the recognized
> + * types, else FALSE.
> + */
> +#define IS_CONF_EXT(period) \
> +  (IS_CONF_EXT_STD(period) || \
> +   IS_CONF_EXT_OVERRIDE(period))
>
>  /**
>  * conf_sources:
> @@ -85,6 +119,114 @@
>
>
>  /**
> + * is_conf_file_std:
> + * @path: path to check.
> + *
> + * Determine if specified path contains a legitimate
> + * configuration file name.
> + *
> + * Returns: TRUE if @path contains a valid configuration file name,
> + * else FALSE.
> + *
> + **/
> +static inline int
> +is_conf_file_std(const char *path)
> +{
> +  char *ptr = strrchr (path, '.');
> +
> +  if (ptr && IS_CONF_EXT_STD(ptr))
> +    return TRUE;
> +
> +  return FALSE;
> +}
> +
> +/**
> + * is_conf_file_override:
> + * @path: path to check.
> + *
> + * Determine if specified path contains a legitimate
> + * override file name.
> + *
> + * Returns: TRUE if @path contains a valid override file name,
> + * else FALSE.
> + *
> + **/
> +static inline int
> +is_conf_file_override(const char *path)
> +{
> +  char *ptr = strrchr (path, '.');
> +
> +  if (ptr && IS_CONF_EXT_OVERRIDE(ptr))
> +    return TRUE;
> +
> +  return FALSE;
> +}
> +
> +/**
> + * is_conf_file:
> + * @path: path to check.
> + *
> + * Determine if specified path contains a legitimate
> + * configuration file or override file name.
> + *
> + * Returns: TRUE if @path contains a valid configuration
> + * file or override file name, else FALSE.
> + *
> + **/
> +static inline int
> +is_conf_file(const char *path)
> +{
> +  char *ptr = strrchr (path, '.');
> +
> +  if (ptr && IS_CONF_EXT(ptr))
> +    return TRUE;
> +
> +  return FALSE;
> +}
> +
> +/**
> + * Convert a configuration file name to an override file name and vice
> + * versa.
> + *
> + * For example, if @path is "foo.conf", this function will return
> + * "foo.override", whereas if @path is "foo.override", it will return
> + * "foo.conf".
> + *
> + * Note that this function should be static, but isn't to allow the
> + * tests to access it.
> + *
> + * @path: path to a configuration file.
> + *
> + * Returns: newly allocated toggled path, or NULL on error.
> + **/
> +char *
> +toggle_conf_name(const char *path)
> +{
> +  char *new_path;
> +  char *ext;
> +  char *new_ext;
> +  size_t len;
> +
> +  ext = strrchr (path, '.');
> +  if (!ext) {
> +    return NULL;
> +  }
> +
> +  new_ext = IS_CONF_EXT_STD(ext)
> +    ? CONF_EXT_OVERRIDE
> +    : CONF_EXT_STD;
> +
> +  len = strlen(new_ext);
> +
> +  new_path = NIH_MUST (nih_strndup (NULL, path, (ext - path) + len));
> +
> +  memcpy(new_path + (ext - path), new_ext, len);
> +
> +  return new_path;
> +}
> +
> +
> +/**
>  * conf_init:
>  *
>  * Initialise the conf_sources list.
> @@ -232,10 +374,9 @@
>                        NihError *err;
>
>                        err = nih_error_get ();
> -                       if (err->number != ENOENT)
> -                               nih_error ("%s: %s: %s", source->path,
> -                                          _("Unable to load configuration"),
> -                                          err->message);
> +                       nih_error ("%s: %s: %s", source->path,
> +                           _("Unable to load configuration"),
> +                           err->message);
>                        nih_free (err);
>                }
>        }
> @@ -253,7 +394,7 @@
>  * out for editors that rename over the top, etc.
>  *
>  * We then parse the current state of the source.  The flag member is
> - * toggled first, and this is propogated to all new and modified files and
> + * toggled first, and this is propagated to all new and modified files and
>  * items that we find as a result of parsing.  Once done, we scan for
>  * anything with the wrong flag, and delete them.
>  *
> @@ -262,8 +403,8 @@
>  int
>  conf_source_reload (ConfSource *source)
>  {
> -       NihList deleted;
> -       int     ret;
> +       NihList     deleted;
> +       int         ret;
>
>        nih_assert (source != NULL);
>
> @@ -274,15 +415,15 @@
>
>        /* Reload the source itself. */
>        switch (source->type) {
> -       case CONF_FILE:
> -               ret = conf_source_reload_file (source);
> -               break;
> -       case CONF_DIR:
> -       case CONF_JOB_DIR:
> -               ret = conf_source_reload_dir (source);
> -               break;
> -       default:
> -               nih_assert_not_reached ();
> +         case CONF_FILE:
> +           ret = conf_source_reload_file (source);
> +           break;
> +         case CONF_DIR:
> +         case CONF_JOB_DIR:
> +           ret = conf_source_reload_dir (source);
> +           break;
> +         default:
> +           nih_assert_not_reached ();
>        }
>
>        /* Scan for files that have been deleted since the last time we
> @@ -296,16 +437,16 @@
>         */
>        nih_list_init (&deleted);
>        NIH_HASH_FOREACH_SAFE (source->files, iter) {
> -               ConfFile *file = (ConfFile *)iter;
> +         ConfFile *file = (ConfFile *)iter;
>
> -               if (file->flag != source->flag)
> -                       nih_list_add (&deleted, &file->entry);
> +         if (file->flag != source->flag)
> +           nih_list_add (&deleted, &file->entry);
>        }
>        NIH_LIST_FOREACH_SAFE (&deleted, iter) {
> -               ConfFile *file = (ConfFile *)iter;
> +         ConfFile *file = (ConfFile *)iter;
>
> -               nih_info (_("Handling deletion of %s"), file->path);
> -               nih_unref (file, source);
> +         nih_info (_("Handling deletion of %s"), file->path);
> +         nih_unref (file, source);
>        }
>
>        return ret;
> @@ -327,61 +468,85 @@
>  static int
>  conf_source_reload_file (ConfSource *source)
>  {
> -       NihError *err = NULL;
> -
> -       nih_assert (source != NULL);
> -       nih_assert (source->type == CONF_FILE);
> -
> -       if (! source->watch) {
> -               nih_local char *dpath = NULL;
> -               char           *dname;
> -
> -               dpath = NIH_MUST (nih_strdup (NULL, source->path));
> -               dname = dirname (dpath);
> -
> -               source->watch = nih_watch_new (source, dname, FALSE, FALSE,
> -                                              (NihFileFilter)conf_file_filter,
> -                                              (NihCreateHandler)conf_create_modify_handler,
> -                                              (NihModifyHandler)conf_create_modify_handler,
> -                                              (NihDeleteHandler)conf_delete_handler,
> -                                              source);
> -
> -               /* If successful mark the file descriptor close-on-exec,
> -                * otherwise stash the error for comparison with a later
> -                * failure to parse the file.
> -                */
> -               if (source->watch) {
> -                       nih_io_set_cloexec (source->watch->fd);
> -               } else {
> -                       err = nih_error_steal ();
> -               }
> -       }
> -
> -       /* Parse the file itself.  If this fails, then we can discard the
> -        * inotify error, since this one will be better.
> -        */
> -       if (conf_reload_path (source, source->path) < 0) {
> -               if (err)
> -                       nih_free (err);
> -
> -               return -1;
> -       }
> -
> -       /* We were able to parse the file, but were not able to set up an
> -        * inotify watch.  This isn't critical, so we just warn about it,
> -        * unless this is simply that inotify isn't supported, in which case
> -        * we do nothing.
> -        */
> -       if (err) {
> -               if (err->number != ENOSYS)
> -                       nih_warn ("%s: %s: %s", source->path,
> -                                 _("Unable to watch configuration file"),
> -                                 err->message);
> -
> -               nih_free (err);
> -       }
> -
> -       return 0;
> +  NihError *err = NULL;
> +  nih_local char *override_path = NULL;
> +
> +  struct stat statbuf;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (source->type == CONF_FILE);
> +
> +  /* this function should only be called for standard
> +   * configuration files.
> +   */
> +  nih_assert(is_conf_file_std(source->path));
> +
> +  if (! source->watch) {
> +    nih_local char *dpath = NULL;
> +    char           *dname;
> +
> +    dpath = NIH_MUST (nih_strdup (NULL, source->path));
> +    dname = dirname (dpath);
> +
> +    source->watch = nih_watch_new (source, dname, FALSE, FALSE,
> +       (NihFileFilter)conf_file_filter,
> +       (NihCreateHandler)conf_create_modify_handler,
> +       (NihModifyHandler)conf_create_modify_handler,
> +       (NihDeleteHandler)conf_delete_handler,
> +       source);
> +
> +    /* If successful mark the file descriptor close-on-exec,
> +     * otherwise stash the error for comparison with a later
> +     * failure to parse the file.
> +     */
> +    if (source->watch) {
> +      nih_io_set_cloexec (source->watch->fd);
> +    } else {
> +      err = nih_error_steal ();
> +    }
> +  }
> +
> +  /* Parse the file itself.  If this fails, then we can discard the
> +   * inotify error, since this one will be better.
> +   */
> +  if (conf_reload_path (source, source->path, NULL) < 0) {
> +    if (err)
> +      nih_free (err);
> +
> +    return -1;
> +  }
> +
> +  /* We were able to parse the file, but were not able to set up an
> +   * inotify watch.  This isn't critical, so we just warn about it,
> +   * unless this is simply that inotify isn't supported, in which case
> +   * we do nothing.
> +   */
> +  if (err) {
> +    if (err->number != ENOSYS)
> +      nih_warn ("%s: %s: %s", source->path,
> +         _("Unable to watch configuration file"),
> +         err->message);
> +
> +    nih_free (err);
> +  }
> +
> +  override_path = toggle_conf_name(source->path);
> +  if (stat (override_path, &statbuf) != 0)
> +         return 0;
> +
> +  nih_debug ("Updating configuration for %s from %s",
> +                 source->path, override_path);
> +  if (conf_reload_path (source, source->path, override_path) < 0) {
> +         NihError *err;
> +
> +         err = nih_error_get ();
> +         nih_error ("%s: %s: %s", override_path,
> +                         _("Error while reloading configuration file"),
> +                         err->message);
> +         nih_free (err);
> +  }
> +
> +  return 0;
>  }
>
>  /**
> @@ -396,7 +561,7 @@
>  * tree.
>  *
>  * Otherwise we walk the tree ourselves and parse all files that we find,
> - * propogating the value of the flag member to all files so that deletion
> + * propagating the value of the flag member to all files so that deletion
>  * can be detected by the calling function.
>  *
>  * Returns: zero on success, negative value on raised error.
> @@ -404,62 +569,62 @@
>  static int
>  conf_source_reload_dir (ConfSource *source)
>  {
> -       NihError *err = NULL;
> -
> -       nih_assert (source != NULL);
> -       nih_assert (source->type != CONF_FILE);
> -
> -       if (! source->watch) {
> -               source->watch = nih_watch_new (source, source->path,
> -                                              TRUE, TRUE,
> -                                              (NihFileFilter)conf_dir_filter,
> -                                              (NihCreateHandler)conf_create_modify_handler,
> -                                              (NihModifyHandler)conf_create_modify_handler,
> -                                              (NihDeleteHandler)conf_delete_handler,
> -                                              source);
> -
> -               /* If successful, the directory tree will have been walked
> -                * already; so just mark the file descriptor close-on-exec
> -                * and return; otherwise we'll try and walk ourselves, so
> -                * stash the error for comparison.
> -                */
> -               if (source->watch) {
> -                       nih_io_set_cloexec (source->watch->fd);
> -                       return 0;
> -               } else {
> -                       err = nih_error_steal ();
> -               }
> -       }
> -
> -       /* We're either performing a mandatory reload, or we failed to set
> -        * up an inotify watch; walk the directory tree the old fashioned
> -        * way.  If this fails too, then we can discard the inotify error
> -        * since this one will be better.
> -        */
> -       if (nih_dir_walk (source->path, (NihFileFilter)conf_dir_filter,
> -                         (NihFileVisitor)conf_file_visitor, NULL,
> -                         source) < 0) {
> -               if (err)
> -                       nih_free (err);
> -
> -               return -1;
> -       }
> -
> -       /* We were able to walk the directory, but were not able to set up
> -        * an inotify watch.  This isn't critical, so we just warn about it,
> -        * unless this is simply that inotify isn't supported, in which case
> -        * we do nothing.
> -        */
> -       if (err) {
> -               if (err->number != ENOSYS)
> -                       nih_warn ("%s: %s: %s", source->path,
> -                                 _("Unable to watch configuration directory"),
> -                                 err->message);
> -
> -               nih_free (err);
> -       }
> -
> -       return 0;
> +  NihError *err = NULL;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (source->type != CONF_FILE);
> +
> +  if (! source->watch) {
> +    source->watch = nih_watch_new (source, source->path,
> +       TRUE, TRUE,
> +       (NihFileFilter)conf_dir_filter,
> +       (NihCreateHandler)conf_create_modify_handler,
> +       (NihModifyHandler)conf_create_modify_handler,
> +       (NihDeleteHandler)conf_delete_handler,
> +       source);
> +
> +    /* If successful, the directory tree will have been walked
> +     * already; so just mark the file descriptor close-on-exec
> +     * and return; otherwise we'll try and walk ourselves, so
> +     * stash the error for comparison.
> +     */
> +    if (source->watch) {
> +      nih_io_set_cloexec (source->watch->fd);
> +      return 0;
> +    } else {
> +      err = nih_error_steal ();
> +    }
> +  }
> +
> +  /* We're either performing a mandatory reload, or we failed to set
> +   * up an inotify watch; walk the directory tree the old fashioned
> +   * way.  If this fails too, then we can discard the inotify error
> +   * since this one will be better.
> +   */
> +  if (nih_dir_walk (source->path, (NihFileFilter)conf_dir_filter,
> +       (NihFileVisitor)conf_file_visitor, NULL,
> +       source) < 0) {
> +    if (err)
> +      nih_free (err);
> +
> +    return -1;
> +  }
> +
> +  /* We were able to walk the directory, but were not able to set up
> +   * an inotify watch.  This isn't critical, so we just warn about it,
> +   * unless this is simply that inotify isn't supported, in which case
> +   * we do nothing.
> +   */
> +  if (err) {
> +    if (err->number != ENOSYS)
> +      nih_warn ("%s: %s: %s", source->path,
> +         _("Unable to watch configuration directory"),
> +         err->message);
> +
> +    nih_free (err);
> +  }
> +
> +  return 0;
>  }
>
>
> @@ -478,19 +643,19 @@
>  **/
>  static int
>  conf_file_filter (ConfSource *source,
> -                 const char *path,
> -                 int         is_dir)
> +    const char *path,
> +    int         is_dir)
>  {
> -       nih_assert (source != NULL);
> -       nih_assert (path != NULL);
> -
> -       if (! strcmp (source->path, path))
> -               return FALSE;
> -
> -       if (! strcmp (source->watch->path, path))
> -               return FALSE;
> -
> -       return TRUE;
> +  nih_assert (source != NULL);
> +  nih_assert (path != NULL);
> +
> +  if (! strcmp (source->path, path))
> +    return FALSE;
> +
> +  if (! strcmp (source->watch->path, path))
> +    return FALSE;
> +
> +  return TRUE;
>  }
>
>  /**
> @@ -500,33 +665,31 @@
>  * @is_dir: TRUE of @path is a directory.
>  *
>  * This is the file filter used for the jobs directory, we only care
> - * about paths with the ".conf" extension.  Directories that
> - * match the nih_file_ignore() function are also ignored.
> - *
> - * Returns: FALSE if @path ends in ".conf", or is the original source,
> - * TRUE otherwise.
> + * about paths with particular extensions (see IS_CONF_EXT).
> + *
> + * Directories that match the nih_file_ignore() function are also ignored.
> + *
> + * Returns: FALSE if @path ends in ".conf" or ".override",
> + * or is the original source, TRUE otherwise.
>  **/
>  static int
>  conf_dir_filter (ConfSource *source,
> -                const char *path,
> -                int         is_dir)
> +    const char *path,
> +    int         is_dir)
>  {
> -       char *ptr;
> -
> -       nih_assert (source != NULL);
> -       nih_assert (path != NULL);
> -
> -       if (! strcmp (source->path, path))
> -               return FALSE;
> -
> -       if (is_dir)
> -               return nih_file_ignore (NULL, path);
> -
> -       ptr = strrchr (path, '.');
> -       if (ptr && (! strcmp (ptr, ".conf")))
> -               return FALSE;
> -
> -       return TRUE;
> +  nih_assert (source != NULL);
> +  nih_assert (path != NULL);
> +
> +  if (! strcmp (source->path, path))
> +    return FALSE;
> +
> +  if (is_dir)
> +    return nih_file_ignore (NULL, path);
> +
> +  if ( is_conf_file(path) )
> +    return FALSE;
> +
> +  return TRUE;
>  }
>
>  /**
> @@ -545,30 +708,93 @@
>  * After checking that it was a regular file that was changed, we reload it;
>  * we expect this to fail sometimes since the file may be only partially
>  * written.
> -  **/
> + **/
>  static void
>  conf_create_modify_handler (ConfSource  *source,
> -                           NihWatch    *watch,
> -                           const char  *path,
> -                           struct stat *statbuf)
> +    NihWatch    *watch,
> +    const char  *path,
> +    struct stat *statbuf)
>  {
> -       nih_assert (source != NULL);
> -       nih_assert (watch != NULL);
> -       nih_assert (path != NULL);
> -       nih_assert (statbuf != NULL);
> -
> -       if (! S_ISREG (statbuf->st_mode))
> -               return;
> -
> -       if (conf_reload_path (source, path) < 0) {
> -               NihError *err;
> -
> -               err = nih_error_get ();
> -               nih_error ("%s: %s: %s", path,
> -                          _("Error while loading configuration file"),
> -                          err->message);
> -               nih_free (err);
> -       }
> +  ConfFile *file = NULL;
> +  const char *error_path = path;
> +  nih_local char *new_path = NULL;
> +  int ret;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (watch != NULL);
> +  nih_assert (path != NULL);
> +  nih_assert (statbuf != NULL);
> +
> +  /* note that symbolic links are ignored */
> +  if (! S_ISREG (statbuf->st_mode))
> +    return;
> +
> +  new_path = toggle_conf_name(path);
> +  file = (ConfFile *)nih_hash_lookup (source->files, new_path);
> +
> +  if (is_conf_file_override(path)) {
> +    if (! file) {
> +      /* override file has no corresponding conf file */
> +      nih_debug("Ignoring orphan override file %s", path);
> +      return;
> +    }
> +
> +    /* reload conf file */
> +    nih_debug("Loading configuration file %s", new_path);
> +    ret = conf_reload_path (source, new_path, NULL);
> +    if (ret < 0) {
> +      error_path = new_path;
> +      goto error;
> +    }
> +
> +    /* overlay override settings */
> +    nih_debug("Loading override file %s for %s", path, new_path);
> +    ret = conf_reload_path (source, new_path, path);
> +    if (ret < 0) {
> +      error_path = path;
> +      goto error;
> +    }
> +  } else {
> +    nih_debug("Loading configuration and override files for %s", path);
> +
> +    /* load conf file */
> +    nih_debug("Loading configuration file %s", path);
> +    ret = conf_reload_path (source, path, NULL);
> +    if (ret < 0) {
> +           error_path = path;
> +           goto error;
> +    }
> +
> +    /* ensure we ignore directory changes (which won't have overrides. */
> +    if (is_conf_file_std(path)) {
> +           struct stat st;
> +           if (stat (new_path, &st) == 0) {
> +                   /* overlay override settings */
> +                   nih_debug("Loading override file %s for %s", new_path, path);
> +                   ret = conf_reload_path (source, path, new_path);
> +                   if (ret < 0) {
> +                           error_path = new_path;
> +                           goto error;
> +                   }
> +           }
> +
> +    }
> +  }
> +
> +  return;
> +
> +error:
> +  {
> +    NihError *err;
> +
> +    err = nih_error_get ();
> +    nih_error ("%s: %s: %s", error_path,
> +       _("Error while loading configuration file"),
> +       err->message);
> +    nih_free (err);
> +    if (file)
> +           nih_unref (file, source);
> +  }
>  }
>
>  /**
> @@ -584,36 +810,64 @@
>  *
>  * We lookup the file in our hash table, and if we can find it, perform
>  * the usual deletion of it.
> -  **/
> + **/
>  static void
>  conf_delete_handler (ConfSource *source,
> -                    NihWatch   *watch,
> -                    const char *path)
> +    NihWatch   *watch,
> +    const char *path)
>  {
> -       ConfFile *file;
> -
> -       nih_assert (source != NULL);
> -       nih_assert (watch != NULL);
> -       nih_assert (path != NULL);
> -
> -       /* Lookup the file in the source.  If we haven't parsed it, this
> -        * could actually mean that it was the top-level directory itself
> -        * that was deleted, in which case we free the watch, otherwise
> -        * it's probably a directory or something, so just ignore it.
> -        */
> -       file = (ConfFile *)nih_hash_lookup (source->files, path);
> -       if (! file) {
> -               if (! strcmp (watch->path, path)) {
> -                       nih_warn ("%s: %s", source->path,
> -                                 _("Configuration directory deleted"));
> -                       nih_unref (source->watch, source);
> -                       source->watch = NULL;
> -               }
> -
> -               return;
> -       }
> -
> -       nih_unref (file, source);
> +  ConfFile *file;
> +  nih_local char *new_path = NULL;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (watch != NULL);
> +  nih_assert (path != NULL);
> +
> +  /* Lookup the file in the source.  If we haven't parsed it, this
> +   * could actually mean that it was the top-level directory itself
> +   * that was deleted, in which case we free the watch, otherwise
> +   * it's probably a directory or something, so just ignore it.
> +   */
> +  file = (ConfFile *)nih_hash_lookup (source->files, path);
> +  /* Note we have to be careful to consider deletion of directories too.
> +   * This is handled implicitly by the override check which will return
> +   * false if passed a directory in this case.
> +   */
> +  if (! file && ! is_conf_file_override(path)) {
> +    if (! strcmp (watch->path, path)) {
> +      nih_warn ("%s: %s", source->path,
> +         _("Configuration directory deleted"));
> +      nih_unref (source->watch, source);
> +      source->watch = NULL;
> +    }
> +
> +    return;
> +  }
> +
> +  /* non-override files (and directories) are the simple case, so handle
> +   * them and leave.
> +   */
> +  if (! is_conf_file_override(path)) {
> +    nih_unref (file, source);
> +    return;
> +  }
> +
> +  /* if an override file is deleted for which there is a corresponding
> +   * conf file, reload the conf file to remove any modifications
> +   * introduced by the override file.
> +   */
> +  new_path = toggle_conf_name(path);
> +  file = (ConfFile *)nih_hash_lookup (source->files, new_path);
> +
> +  if (file) {
> +         nih_debug ("Reloading configuration for %s on deletion of overide (%s)",
> +                         new_path, path);
> +
> +    if ( conf_reload_path(source, new_path, NULL) < 0 ) {
> +      nih_warn ("%s: %s", new_path,
> +      _("Unable to reload configuration after override deletion"));
> +    }
> +  }
>  }
>
>  /**
> @@ -632,41 +886,86 @@
>  **/
>  static int
>  conf_file_visitor (ConfSource  *source,
> -                  const char  *dirname,
> -                  const char  *path,
> -                  struct stat *statbuf)
> +    const char  *dirname,
> +    const char  *path,
> +    struct stat *statbuf)
>  {
> -       nih_assert (source != NULL);
> -       nih_assert (dirname != NULL);
> -       nih_assert (path != NULL);
> -       nih_assert (statbuf != NULL);
> -
> -       if (! S_ISREG (statbuf->st_mode))
> -               return 0;
> -
> -       if (conf_reload_path (source, path) < 0) {
> -               NihError *err;
> -
> -               err = nih_error_get ();
> -               nih_error ("%s: %s: %s", path,
> -                          _("Error while loading configuration file"),
> -                          err->message);
> -               nih_free (err);
> -       }
> -
> -       return 0;
> +  ConfFile *file = NULL;
> +  nih_local char *new_path = NULL;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (dirname != NULL);
> +  nih_assert (path != NULL);
> +  nih_assert (statbuf != NULL);
> +
> +  /* We assume that CONF_EXT_STD files are visited before
> +   * CONF_EXT_OVERRIDE files. Happily, this assumption is currently
> +   * valid since CONF_EXT_STD comes before CONF_EXT_OVERRIDE if ordered
> +   * alphabetically.
> +   *
> +   * If this were ever to change (for example if we decided to
> +   * rename the CONF_EXT_OVERRIDE files to end in ".abc", say), the logic
> +   * in this function would be erroneous since it would never be possible when
> +   * visiting an override file (before a conf file) to lookup a conf file
> +   * in the hash, since the conf file would not yet have been seen and thus would
> +   * not exist in the hash (yet).
> +   */
> +  nih_assert(CONF_EXT_STD[1] < CONF_EXT_OVERRIDE[1]);
> +
> +  if (! S_ISREG (statbuf->st_mode))
> +    return 0;
> +
> +  if (is_conf_file_std(path)) {
> +    if (conf_reload_path (source, path, NULL) < 0) {
> +      NihError *err;
> +
> +      err = nih_error_get ();
> +      nih_error ("%s: %s: %s", path,
> +                     _("Error while loading configuration file"),
> +                     err->message);
> +      nih_free (err);
> +    }
> +    return 0;
> +  }
> +
> +  new_path = toggle_conf_name(path);
> +  file = (ConfFile *)nih_hash_lookup (source->files, new_path);
> +
> +  if (! file) {
> +    /* we're visiting an override file with an associated conf file that
> +     * has already been loaded, so just overlay the override file. If
> +     * there is no corresponding conf file, we ignore the override file.
> +     */
> +    if (conf_reload_path (source, new_path, path) < 0) {
> +      NihError *err;
> +
> +      err = nih_error_get ();
> +      nih_error ("%s: %s: %s", new_path,
> +                     _("Error while reloading configuration file"),
> +                     err->message);
> +      nih_free (err);
> +    }
> +  }
> +
> +  if (file )
> +         nih_unref (file, source);
> +
> +  return 0;
>  }
>
>
>  /**
>  * conf_reload_path:
>  * @source: configuration source,
> - * @path: path of file to be reloaded.
> + * @path: path of conf file to be reloaded.
> + * @override_path: if TRUE and @path refers to a path associated with @source,
> + * overlay the contents of @path into the existing @source entry for
> + * @path. If FALSE, discard any existing knowledge of @path.
>  *
> - * This function is used to parse the file at @path in the context of the
> - * given configuration @source.  Necessary ConfFile structures are allocated
> - * and attached to @source as appropriate.  CONF_FILE sources always have
> - * a single ConfFile when the file exists.
> + * This function is used to parse the file at @path (or @override_path) in the
> + * context of the given configuration @source.  Necessary ConfFile structures
> + * are allocated and attached to @source as appropriate.  CONF_FILE sources
> + * always have a single ConfFile when the file exists.
>  *
>  * If the file has been parsed before, then the existing item is deleted and
>  * freed if the file fails to load, or after the new item has been parsed.
> @@ -678,120 +977,139 @@
>  **/
>  static int
>  conf_reload_path (ConfSource *source,
> -                 const char *path)
> +    const char *path,
> +    const char *override_path)
>  {
> -       ConfFile       *file;
> -       nih_local char *buf = NULL;
> -       const char     *start, *end;
> -       nih_local char *name = NULL;
> -       size_t          len, pos, lineno;
> -       NihError       *err = NULL;
> -
> -       nih_assert (source != NULL);
> -       nih_assert (path != NULL);
> -
> -       /* Look up the old file in memory, and then free it.  In cases
> -        * of failure, we discard it anyway, so there's no particular reason
> -        * to keep it around anymore.
> -        */
> -       file = (ConfFile *)nih_hash_lookup (source->files, path);
> -       if (file)
> -               nih_unref (file, source);
> -
> -       /* Read the file into memory for parsing, if this fails we don't
> -        * bother creating a new ConfFile structure for it and bail out
> -        * now.
> -        */
> -       buf = nih_file_read (NULL, path, &len);
> -       if (! buf)
> -               return -1;
> -
> -       /* Parse the file, storing the item in a new ConfFile structure. */
> -       file = NIH_MUST (conf_file_new (source, path));
> -
> -       pos = 0;
> -       lineno = 1;
> -
> -       switch (source->type) {
> -       case CONF_FILE:
> -       case CONF_DIR:
> -               /* Simple file of options; usually no item attached to it. */
> -               nih_debug ("Loading configuration from %s", path);
> -               if (parse_conf (file, buf, len, &pos, &lineno) < 0)
> -                       err = nih_error_get ();
> -
> -               break;
> -       case CONF_JOB_DIR:
> -               /* Construct the job name by taking the path and removing
> -                * the directory name from the front and the extension
> -                * from the end.
> -                */
> -               start = path;
> -               if (! strncmp (start, source->path, strlen (source->path)))
> -                       start += strlen (source->path);
> -
> -               while (*start == '/')
> -                       start++;
> -
> -               end = strrchr (start, '.');
> -               if (end && (! strcmp (end, ".conf"))) {
> -                       name = NIH_MUST (nih_strndup (NULL, start, end - start));
> -               } else {
> -                       name = NIH_MUST (nih_strdup (NULL, start));
> -               }
> -
> -               /* Create a new job item and parse the buffer to produce
> -                * the job definition.
> -                */
> -               nih_debug ("Loading %s from %s", name, path);
> -               file->job = parse_job (NULL, name, buf, len, &pos, &lineno);
> -               if (file->job) {
> -                       job_class_consider (file->job);
> -               } else {
> -                       err = nih_error_get ();
> -               }
> -
> -               break;
> -       default:
> -               nih_assert_not_reached ();
> -       }
> -
> -       /* Deal with any parsing errors that occurred; we don't consider
> -        * these to be hard failures, which means we can warn about them
> -        * here and give the path and line number along with the warning.
> -        */
> -       if (err) {
> -               switch (err->number) {
> -               case NIH_CONFIG_EXPECTED_TOKEN:
> -               case NIH_CONFIG_UNEXPECTED_TOKEN:
> -               case NIH_CONFIG_TRAILING_SLASH:
> -               case NIH_CONFIG_UNTERMINATED_QUOTE:
> -               case NIH_CONFIG_UNTERMINATED_BLOCK:
> -               case NIH_CONFIG_UNKNOWN_STANZA:
> -               case PARSE_ILLEGAL_INTERVAL:
> -               case PARSE_ILLEGAL_EXIT:
> -               case PARSE_ILLEGAL_UMASK:
> -               case PARSE_ILLEGAL_NICE:
> -               case PARSE_ILLEGAL_OOM:
> -               case PARSE_ILLEGAL_LIMIT:
> -               case PARSE_EXPECTED_EVENT:
> -               case PARSE_EXPECTED_OPERATOR:
> -               case PARSE_EXPECTED_VARIABLE:
> -               case PARSE_MISMATCHED_PARENS:
> -                       nih_error ("%s:%zi: %s", path, lineno, err->message);
> -                       nih_free (err);
> -                       err = NULL;
> -                       break;
> -               }
> -       }
> -
> -       /* If we had any unknown error from parsing the file, raise it again
> -        * and return an error condition.
> -        */
> -       if (err)
> -               return -1;
> -
> -       return 0;
> +  ConfFile       *file = NULL;
> +  nih_local char *buf = NULL;
> +  const char     *start, *end;
> +  nih_local char *name = NULL;
> +  size_t          len, pos, lineno;
> +  NihError       *err = NULL;
> +  const char     *path_to_load;
> +
> +  nih_assert (source != NULL);
> +  nih_assert (path != NULL);
> +
> +  path_to_load = ( override_path ? override_path : path);
> +
> +  /* If there is no corresponding override file, look up the old
> +   * conf file in memory, and then free it.  In cases of failure,
> +   * we discard it anyway, so there's no particular reason
> +   * to keep it around anymore.
> +   */
> +  file = (ConfFile *)nih_hash_lookup (source->files, path);
> +  if (! override_path && file)
> +    nih_unref (file, source);
> +
> +  /* Read the file into memory for parsing, if this fails we don't
> +   * bother creating a new ConfFile structure for it and bail out
> +   * now.
> +   */
> +  buf = nih_file_read (NULL, path_to_load, &len);
> +  if (! buf)
> +    return -1;
> +
> +  /* Create a new ConfFile structure (if no override_path was specified) */
> +  file = (ConfFile *)nih_hash_lookup (source->files, path);
> +  if (! file)
> +         file = NIH_MUST (conf_file_new (source, path));
> +
> +  pos = 0;
> +  lineno = 1;
> +
> +  switch (source->type) {
> +    case CONF_FILE:
> +    case CONF_DIR:
> +      /* Simple file of options; usually no item attached to it. */
> +      if (override_path) {
> +       nih_debug ("Updating configuration for %s from %s",
> +           path, override_path);
> +      } else {
> +       nih_debug ("Loading configuration from %s %s",
> +           (source->type == CONF_DIR ? "directory" : "file"), path);
> +      }
> +
> +      if (parse_conf (file, buf, len, &pos, &lineno) < 0)
> +       err = nih_error_get ();
> +
> +      break;
> +    case CONF_JOB_DIR:
> +      /* Construct the job name by taking the path and removing
> +       * the directory name from the front and the extension
> +       * from the end.
> +       */
> +      start = path;
> +      if (! strncmp (start, source->path, strlen (source->path)))
> +       start += strlen (source->path);
> +
> +      while (*start == '/')
> +       start++;
> +
> +      end = strrchr (start, '.');
> +      if (end && IS_CONF_EXT(end)) {
> +       name = NIH_MUST (nih_strndup (NULL, start, end - start));
> +      } else {
> +       name = NIH_MUST (nih_strdup (NULL, start));
> +      }
> +
> +      /* Create a new job item and parse the buffer to produce
> +       * the job definition.
> +       */
> +      if (override_path) {
> +       nih_debug ("Updating %s (%s) with %s",
> +           name, path, override_path);
> +      } else {
> +       nih_debug ("Loading %s from %s", name, path);
> +      }
> +      file->job = parse_job (NULL, file->job, name, buf, len, &pos, &lineno);
> +      if (file->job) {
> +       job_class_consider (file->job);
> +      } else {
> +       err = nih_error_get ();
> +      }
> +
> +      break;
> +    default:
> +      nih_assert_not_reached ();
> +  }
> +
> +  /* Deal with any parsing errors that occurred; we don't consider
> +   * these to be hard failures, which means we can warn about them
> +   * here and give the path and line number along with the warning.
> +   */
> +  if (err) {
> +    switch (err->number) {
> +      case NIH_CONFIG_EXPECTED_TOKEN:
> +      case NIH_CONFIG_UNEXPECTED_TOKEN:
> +      case NIH_CONFIG_TRAILING_SLASH:
> +      case NIH_CONFIG_UNTERMINATED_QUOTE:
> +      case NIH_CONFIG_UNTERMINATED_BLOCK:
> +      case NIH_CONFIG_UNKNOWN_STANZA:
> +      case PARSE_ILLEGAL_INTERVAL:
> +      case PARSE_ILLEGAL_EXIT:
> +      case PARSE_ILLEGAL_UMASK:
> +      case PARSE_ILLEGAL_NICE:
> +      case PARSE_ILLEGAL_OOM:
> +      case PARSE_ILLEGAL_LIMIT:
> +      case PARSE_EXPECTED_EVENT:
> +      case PARSE_EXPECTED_OPERATOR:
> +      case PARSE_EXPECTED_VARIABLE:
> +      case PARSE_MISMATCHED_PARENS:
> +       nih_error ("%s:%zi: %s", path_to_load, lineno, err->message);
> +       nih_free (err);
> +       err = NULL;
> +       break;
> +    }
> +  }
> +
> +  /* If we had any unknown error from parsing the file, raise it again
> +   * and return an error condition.
> +   */
> +  if (err)
> +    return -1;
> +
> +  return 0;
>  }
>
>
> @@ -811,38 +1129,38 @@
>  int
>  conf_file_destroy (ConfFile *file)
>  {
> -       nih_assert (file != NULL);
> -
> -       nih_list_destroy (&file->entry);
> -
> -       switch (file->source->type) {
> -       case CONF_FILE:
> -       case CONF_DIR:
> -               break;
> -       case CONF_JOB_DIR:
> -               if (! file->job)
> -                       break;
> -
> -               /* Mark the job to be deleted when it stops, in case
> -                * it cannot be deleted here.
> -                */
> -               file->job->deleted = TRUE;
> -
> -               /* Check whether the job is the current one with that name;
> -                * if it is, try and replace it.  If it wasn't the current
> -                * job, or isn't after replacement, we can free it now.
> -                */
> -               if (job_class_reconsider (file->job)) {
> -                       nih_debug ("Destroyed unused job %s", file->job->name);
> -                       nih_free (file->job);
> -               }
> -
> -               break;
> -       default:
> -               nih_assert_not_reached ();
> -       }
> -
> -       return 0;
> +  nih_assert (file != NULL);
> +
> +  nih_list_destroy (&file->entry);
> +
> +  switch (file->source->type) {
> +    case CONF_FILE:
> +    case CONF_DIR:
> +      break;
> +    case CONF_JOB_DIR:
> +      if (! file->job)
> +       break;
> +
> +      /* Mark the job to be deleted when it stops, in case
> +       * it cannot be deleted here.
> +       */
> +      file->job->deleted = TRUE;
> +
> +      /* Check whether the job is the current one with that name;
> +       * if it is, try and replace it.  If it wasn't the current
> +       * job, or isn't after replacement, we can free it now.
> +       */
> +      if (job_class_reconsider (file->job)) {
> +       nih_debug ("Destroyed unused job %s", file->job->name);
> +       nih_free (file->job);
> +      }
> +
> +      break;
> +    default:
> +      nih_assert_not_reached ();
> +  }
> +
> +  return 0;
>  }
>
>
> @@ -858,26 +1176,171 @@
>  JobClass *
>  conf_select_job (const char *name)
>  {
> -       nih_assert (name != NULL);
> -
> -       conf_init ();
> -
> +  nih_assert (name != NULL);
> +
> +  conf_init ();
> +
> +  NIH_LIST_FOREACH (conf_sources, iter) {
> +    ConfSource *source = (ConfSource *)iter;
> +
> +    if (source->type != CONF_JOB_DIR)
> +      continue;
> +
> +    NIH_HASH_FOREACH (source->files, file_iter) {
> +      ConfFile *file = (ConfFile *)file_iter;
> +
> +      if (! file->job)
> +       continue;
> +
> +      if (! strcmp (file->job->name, name))
> +       return file->job;
> +    }
> +  }
> +
> +  return NULL;
> +}
> +
> +#ifdef DEBUG
> +
> +size_t
> +debug_count_list_entries(const NihList *list)
> +{
> +       size_t i = 0;
>        NIH_LIST_FOREACH (conf_sources, iter) {
> -               ConfSource *source = (ConfSource *)iter;
> -
> -               if (source->type != CONF_JOB_DIR)
> -                       continue;
> -
> -               NIH_HASH_FOREACH (source->files, file_iter) {
> -                       ConfFile *file = (ConfFile *)file_iter;
> -
> -                       if (! file->job)
> -                               continue;
> -
> -                       if (! strcmp (file->job->name, name))
> -                               return file->job;
> -               }
> -       }
> -
> -       return NULL;
> -}
> +         i++;
> +       }
> +       return i;
> +}
> +
> +size_t
> +debug_count_hash_entries(const NihHash *hash)
> +{
> +       size_t i = 0;
> +       NIH_HASH_FOREACH_SAFE(hash, iter) {
> +         i++;
> +       }
> +       return i;
> +}
> +
> +void
> +debug_show_job_class(const JobClass *job)
> +{
> +  int i;
> +  char **env    = (char **)job->env;
> +  char **export = (char **)job->export;
> +
> +  nih_assert(job);
> +
> +  nih_debug("JobClass %p: name='%s', path='%s', task=%d, "
> +      "respawn=%d, console=%x, deleted=%d, debug=%d",
> +      job, job->name, job->path, job->task,
> +      job->respawn, job->console, job->deleted, job->debug);
> +
> +  nih_debug("\tstart_on=%p, stop_on=%p, emits=%p, process=%p",
> +      job->start_on, job->stop_on, job->emits, job->process);
> +
> +  nih_debug("\tauthor='%s', description='%s'",
> +      job->author, job->description);
> +
> +  if (env && *env) {
> +         nih_debug("\tenv:");
> +         i = 0;
> +         while ( *env ) {
> +                 nih_debug("\t\tenv[%d]='%s' (len=%u+1)",
> +                                 i, *env, strlen(*env));
> +                 env++;
> +                 ++i;
> +         }
> +  } else {
> +         nih_debug("\tenv: none.");
> +  }
> +
> +
> +  if (export && *export) {
> +         nih_debug("\texport:");
> +         i = 0;
> +         while ( *export ) {
> +                 nih_debug("\t\tenv[%d]='%s' (len=%u+1)",
> +                                 i, *export, strlen(*export));
> +                 export++;
> +                 ++i;
> +         }
> +  }
> +  else {
> +         nih_debug("\texport: none");
> +  }
> +}
> +
> +void
> +debug_show_job_classes(void)
> +{
> +       nih_debug("job_classes:");
> +
> +       NIH_HASH_FOREACH_SAFE(job_classes, iter) {
> +               JobClass *job = (JobClass *)iter;
> +               debug_show_job_class(job);
> +       }
> +}
> +
> +void
> +debug_show_event(const Event *event)
> +{
> +  nih_assert(event);
> +
> +  nih_debug("Event %p: name='%s', progress=%x, failed=%d, "
> +                 "blockers=%d, blocking=%p",
> +      event, event->name, event->progress, event->failed,
> +      event->blockers, (void *)&event->blocking);
> +}
> +
> +void
> +debug_show_conf_file(const ConfFile *file)
> +{
> +  nih_assert(file);
> +
> +  nih_debug("ConfFile %p: path='%s', source=%p, flag=%x, job=%p",
> +      file, file->path, file->source, file->flag, file->job);
> +
> +  /* Some ConfFile objects won't have any JobClass details, for example,
> +   * the ConfFile object associated with "/etc/init.conf".
> +   */
> +  if (! file->job) {
> +         nih_debug("ConfFile %p: job: no JobClass object.", file);
> +         return;
> +  }
> +
> +  nih_debug("ConfFile %p: job:", file);
> +  debug_show_job_class(file->job);
> +}
> +
> +void
> +debug_show_conf_source(const ConfSource *source)
> +{
> +  nih_assert(source);
> +
> +  nih_debug("ConfSource %p: path='%s', type=%x, flag=%x",
> +      source, source->path, source->type, source->flag);
> +
> +    nih_debug("ConfSource %p files (%d):", source,
> +       debug_count_hash_entries(source->files));
> +
> +    NIH_HASH_FOREACH (source->files, file_iter) {
> +      ConfFile *file = (ConfFile *)file_iter;
> +      debug_show_conf_file(file);
> +    }
> +}
> +
> +void
> +debug_show_conf_sources(void)
> +{
> +  nih_assert(conf_sources);
> +
> +  nih_debug("conf_sources:");
> +
> +  NIH_LIST_FOREACH (conf_sources, iter) {
> +    ConfSource *source = (ConfSource *)iter;
> +    debug_show_conf_source(source);
> +  }
> +}
> +#endif /* DEBUG */
> +
>
> === modified file 'init/conf.h'
> --- init/conf.h 2009-07-09 08:36:52 +0000
> +++ init/conf.h 2011-01-12 04:27:54 +0000
> @@ -124,6 +124,37 @@
>
>  JobClass *  conf_select_job    (const char *name);
>
> +char *toggle_conf_name(const char *path)
> +       __attribute__ ((warn_unused_result, malloc));
> +
> +#ifdef DEBUG
> +
> +size_t
> +debug_count_hash_entries(const NihHash *hash);
> +
> +size_t
> +debug_count_list_entries(const NihList *list);
> +
> +void
> +debug_show_job_class(const JobClass *job);
> +
> +void
> +debug_show_job_classes(void);
> +
> +void
> +debug_show_event(const Event *event);
> +
> +void
> +debug_show_conf_file(const ConfFile *file);
> +
> +void
> +debug_show_conf_source(const ConfSource *source);
> +
> +void
> +debug_show_conf_sources(void);
> +
> +#endif
> +
>  NIH_END_EXTERN
>
>  #endif /* INIT_CONF_H */
>
> === modified file 'init/job_class.c'
> --- init/job_class.c    2010-12-14 15:30:06 +0000
> +++ init/job_class.c    2011-01-12 04:27:54 +0000
> @@ -220,7 +220,7 @@
>        class->chdir = NULL;
>
>        class->deleted = FALSE;
> -       class->debug   = FALSE;
> +       class->debug = FALSE;
>
>        return class;
>
>
> === modified file 'init/job_process.c'
> --- init/job_process.c  2011-01-06 07:37:59 +0000
> +++ init/job_process.c  2011-01-12 04:27:54 +0000
> @@ -116,7 +116,7 @@
>  * characters within the command member, in which case it is executed
>  * directly using exec after splitting on whitespace.
>  *
> - * When exectued with the shell, if the command (which may be an entire
> + * When executed with the shell, if the command (which may be an entire
>  * script) is reasonably small (less than 1KB) it is passed to the
>  * shell using the POSIX-specified -c option.  Otherwise the shell is told
>  * to read commands from one of the special /proc/self/fd/NN devices and NihIo
>
> === modified file 'init/main.c'
> --- init/main.c 2010-12-13 18:15:24 +0000
> +++ init/main.c 2011-01-12 04:27:54 +0000
> @@ -212,6 +212,18 @@
>        nih_log_set_priority (NIH_LOG_DEBUG);
>        nih_debug ("Running as PID %d (PPID %d)",
>                (int)getpid (), (int)getppid ());
> +
> +       /* keep "gcc -Werror" happy by pretending we always somehow use
> +        * the debug routines
> +        */
> +       {
> +         int i = 0;
> +         void (*fp)(void) = debug_show_conf_sources;
> +
> +         if (i) {
> +           fp();
> +         }
> +       }
>  #endif /* DEBUG */
>
>
>
> === modified file 'init/man/init.5'
> --- init/man/init.5     2010-12-14 16:20:38 +0000
> +++ init/man/init.5     2011-01-12 04:27:54 +0000
> @@ -1,42 +1,79 @@
> -.TH init 5 2010-12-14 "Upstart"
> +.TH init 5 2011-01-12 "Upstart"
>  .\"
>  .SH NAME
>  init \- Upstart init daemon job configuration
>  .\"
>  .SH SYNOPSIS
> -.B /etc/init
> +.B /etc/init/
>  .\"
>  .SH DESCRIPTION
>  On startup, the Upstart
>  .BR init (8)
> -daemon reads its job configuration from the
> -.I /etc/init
> -directory, and watches for future changes using
> +daemon reads its job configuration from files in the
> +.I /etc/init/
> +directory, and watches for future changes to these files using
>  .BR inotify (7).
>
> -Files in this directory must end in
> +To be considered by Upstart, files in this directory must have a
> +recognized suffix and may also be present in sub-directories.  There are
> +two recognized suffixes:
> +
> +.IP \(bu 4
> +Files ending in
>  .I .conf
> -and may also be present in sub-directories.
> -
> -Each file defines a single service or task, with the name taken from its
> -relative path within the directory without the extension.  For example a
> -job defined in
> +are called configuration files, or simply "conf files" for short.
> +These are the primary vehicle for specifying a job.
> +.IP \(bu 4
> +Files ending in
> +.I .override
> +are called override files.  If an override file is present, the stanzas
> +it contains take precedence over those equivalently named stanzas in the
> +corresponding configuration file contents for a particular job.
> +The main use for override files is to modify how a job will run without
> +having to modify its configuration file directly.  See the section
> +\fBOverride File Handling\fP below for further details.
> +.P
> +A job can thus be defined by either:
> +.IP \[bu] 2
> +A single configuration file.
> +.IP \[bu]
> +A single configuration file \fBand\fP a single override file.
> +.P
> +Unless explicitly stated otherwise, any reference to a jobs
> +configuration can refer both to a configuration file or an override
> +file.
> +
> +Each configuration file defines the template for a single \fIservice\fP
> +(long-running process or daemon) or \fItask\fP (short-lived process).
> +
> +Note that a configuration file is not itself a job: it is a description
> +of an environmenta job could be run in.  A job is the runtime embodiment
> +of a configuration file.
> +
> +The configuration file name as displayed by Upstart and associated
> +tooling is taken from its relative path within the directory without the
> +extension.  For example a configuration file
>  .I /etc/init/rc-sysinit.conf
>  is named
>  .IR rc-sysinit ,
> -while a job defined in
> +while a configuration file
>  .I /etc/init/net/apache.conf
>  is named
>  .IR net/apache .
> +Since override files only modify the way a configuration file is
> +interpreted, they are not named.
>
> -These files are plain text and should not be executable.
> +Configuration files are plain text and should not be executable.
>  .\"
> -.SS Format
> +.SS Configuration File Format
>  Each line begins with a configuration stanza and continues until either
>  the end of the line or a line containing a closing stanza.  Line breaks
>  within a stanza are permitted within single or double quotes, or if
>  preceeded by a blackslash.
>
> +If a stanza is duplicated, the last occurence will be used. Unrecognized
> +stanzas will generate parse errors, which will stop a job from running.
> +
>  Stanzas and their arguments are delimited by whitespace, which consists
>  of one or more space or tab characters which are otherwise ignored unless
>  placed within single or double quotes.
> @@ -144,10 +181,10 @@
>  such as removing temporary directories.
>
>  .PP
> -All of these processes, including the main process, are optional.  Services
> -without a main process will appear to be running until they are stopped,
> -this is commonly used to define states such as runlevels.  It's quite
> -permissable to have no main process, but to have
> +All of these processes, including the main process, are optional.
> +Services without a main process will appear to be running until they are
> +stopped: this is commonly used to define states such as runlevels.  It
> +is permissable to have no main process, but to have
>  .B pre-start
>  and
>  .B post-stop
> @@ -249,7 +286,7 @@
>  .B stop on
>  stanza defines the set of events that will cause the job to be automatically
>  stopped.  It has the same syntax as
> -.B start on
> +\fBstart on\fP.
>
>  .I VALUE
>  may additionally expand the value of any variable that came from the
> @@ -306,7 +343,8 @@
>  .B env \fIKEY\fR[=\fIVALUE\fR]
>  Defines a default environment variable, the value of which may be overriden
>  by the event or command that starts the job.
> -If no value is given, then the value is taken from the
> +If \'KEY=VALUE\' is specified, the variable KEY is given the value VALUE.
> +If only \'KEY\' is given, then the value is taken from the
>  .BR init (8)
>  daemon's own environment.
>  .\"
> @@ -366,7 +404,7 @@
>  times in
>  .I INTERVAL
>  seconds, it will be considered to be having deeper problems and will
> -be stopped.
> +be stopped. Default COUNT is 10. Default INTERVAL is 5 seconds.
>
>  This only applies to automatic respawns and not the
>  .BR restart (8)
> @@ -385,7 +423,8 @@
>  .SS Instances
>  By default, only one instance of any job is permitted to exist at one
>  time.  Attempting to start a job when it's already starting or running
> -results in an error.
> +results in an error. Note that a job is considered to be running if its
> +pre-start process is running.
>
>  Multiple instances may be permitted by defining the names of those
>  instances.  If an instance with the same name is not already starting
> @@ -561,6 +600,46 @@
>  .B unlimited
>  may be specified for either.
>  .\"
> +.SS Override File Handling
> +Override files allow a jobs environment to be changed without modifying
> +the jobs configuration file. Rules governing override files:
> +
> +.IP \[bu] 2
> +If a job is embodied with only a configuration file, the contents of
> +this file define the job.
> +.IP \[bu]
> +If an override files exists where there is no existing cofiguration
> +file, the override file is ignored.
> +.IP \[bu]
> +If both a configuration file \fBand\fP an override file exist for a job
> +and both files are syntactically correct:
> +.RS
> +.IP \[bu] 2
> +stanzas in the override file will take precedence over stanzas present
> +in the corresponding configuration file.
> +.IP \[bu]
> +stanzas in the override file which are not present in the corresponding
> +configuration file will be honoured when the job runs.
> +.RE
> +.IP \[bu]
> +If both a configuration file and an override file exist for a job and
> +subsequently the override file is deleted, the configuration file is
> +automatically reloaded with the effect that any changes introduced by
> +the override file are undone and the configuration file alone now defines
> +the job.
> +.IP \[bu]
> +If both a configuration file and an override file exist for a job and
> +subsequently the configuration file is deleted, a new instance of the
> +job can no longer be started (since without a corresponding
> +configuration file an override file is ignored).
> +.IP \[bu]
> +If both a configuration file and an override file exist for a job and
> +any of the contents of the override file are invalid, the override file
> +is ignored and only the contents of the configuration file are
> +considered.
> +.P
> +
> +.\"
>  .SS Miscellaneous
>  .TP
>  .B kill timeout \fIINTERVAL
> @@ -568,7 +647,7 @@
>  .I SIGTERM
>  and
>  .I SIGKILL
> -signals when stopping the running job.
> +signals when stopping the running job. Default is 5 seconds.
>  .\"
>  .TP
>  .B expect stop
> @@ -609,6 +688,48 @@
>  is unable to supervise forking processes and will believe them to have
>  stopped as soon as they fork on startup.
>  .\"
> +.SH BUGS
> +The
> +.B and
> +and
> +.B or
> +operators allowed with
> +.B start on
> +and
> +.B stop on
> +do not work intuitively: operands to the right of either operator are
> +only evaluated once and state information is then discarded. This can
> +lead to jobs with complex \fBstart on\fP or \fPstop on\fP conditions
> +not behaving as expected \fIwhen restarted\fP. For example, if a job
> +encodes the following condition:
> +.ti +4
> +.sp 1
> +.nf
> +start on A and (B or C)
> +.fi
> +
> +When 'A' and 'B' become true, the condition is satisfied so the job will
> +be run. However, if the job ends and subsequently 'A' and 'C' become true,
> +the job will \fInot\fP be re-run even though the condtion is satisfied.
> +Avoid using complex conditions with jobs which need to be restarted.
> +.\"
> +.SH AUTHOR
> +Manual page written by Scott James Remnant
> +.RB < <email address hidden> >
> +and James Hunt
> +.RB < <email address hidden> > .
> +.\"
> +.SH REPORTING BUGS
> +Report bugs at
> +.RB < https://launchpad.net/upstart/+bugs >
> +.\"
> +.SH COPYRIGHT
> +Copyright \(co 2010 Canonical Ltd.
> +.br
> +This is free software; see the source for copying conditions.  There is NO
> +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> +
> +.\"
>  .SH SEE ALSO
>  .BR init (8)
>  .BR sh (1)
>
> === modified file 'init/man/init.8'
> --- init/man/init.8     2010-02-04 19:26:17 +0000
> +++ init/man/init.8     2011-01-12 04:27:54 +0000
> @@ -96,12 +96,13 @@
>  warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
>  .\"
>  .SH SEE ALSO
> +.BR control-alt-delete (7)
>  .BR init (5)
>  .BR initctl (8)
> -.BR telinit (8)
>  .BR runlevel (7)
>  .BR startup (7)
>  .BR starting (7)
>  .BR started (7)
>  .BR stopping (7)
>  .BR stopped (7)
> +.BR telinit (8)
>
> === modified file 'init/parse_conf.c'
> --- init/parse_conf.c   2009-06-23 09:29:35 +0000
> +++ init/parse_conf.c   2011-01-12 04:27:54 +0000
> @@ -74,6 +74,12 @@
>        nih_assert (file != NULL);
>        nih_assert (pos != NULL);
>
> +       /* If we update 'stanzas' to allow content in init.conf, this
> +        * function must be updated in a similar manner to parse_job()
> +        * to handle overrides files.
> +        */
> +       nih_assert (sizeof(stanzas) / sizeof(stanzas[0]) == 1);
> +
>        if (nih_config_parse_file (file, len, pos, lineno,
>                                   stanzas, conffile) < 0)
>                return -1;
>
> === modified file 'init/parse_job.c'
> --- init/parse_job.c    2010-12-14 16:37:15 +0000
> +++ init/parse_job.c    2011-01-12 04:27:54 +0000
> @@ -263,6 +263,7 @@
>  /**
>  * parse_job:
>  * @parent: parent object for new job,
> + * @update: If not NULL, update the existing specified JobClass,
>  * @name: name of new job,
>  * @file: file or string to parse,
>  * @len: length of @file,
> @@ -278,10 +279,12 @@
>  * of the returned job are freed, the returned job will also be
>  * freed.
>  *
> - * Returns: new JobClass structure on success, NULL on raised error.
> + * Returns: if @update is NULL, returns new JobClass structure on success, NULL on raised error.
> + * If @update is not NULL, returns @update or NULL on error.
>  **/
>  JobClass *
>  parse_job (const void *parent,
> +          JobClass   *update,
>           const char *name,
>           const char *file,
>           size_t      len,
> @@ -294,12 +297,23 @@
>        nih_assert (file != NULL);
>        nih_assert (pos != NULL);
>
> -       class = job_class_new (parent, name);
> -       if (! class)
> -               nih_return_system_error (NULL);
> +       if (update) {
> +         class = update;
> +         nih_debug("Reusing JobClass %s (%s)",
> +             class->name, class->path);
> +       } else {
> +         nih_debug("Creating new JobClass %s",
> +             name);
> +         class = job_class_new (parent, name);
> +         if (! class)
> +           nih_return_system_error (NULL);
> +       }
>
>        if (nih_config_parse_file (file, len, pos, lineno,
>                                   stanzas, class) < 0) {
> +               if (update)
> +                 return NULL;
> +
>                nih_free (class);
>                return NULL;
>        }
> @@ -1037,10 +1051,10 @@
>        nih_debug ("disregarding start on events for %s",
>                        class->name);
>
> -       if (class->start_on)
> +       if (class->start_on) {
>                nih_unref (class->start_on, class);
> -
> -       class->start_on = NULL;
> +               class->start_on = NULL;
> +       }
>
>        return 0;
>  }
> @@ -1211,7 +1225,7 @@
>  *
>  * Parse an env stanza from @file, extracting a single argument of the form
>  * VAR or VAR=VALUE.  These are stored in the env array, which is increased
> - * in size to accomodate the new value.
> + * in size to accommodate the new value.
>  *
>  * Returns: zero on success, negative value on error.
>  **/
>
> === modified file 'init/parse_job.h'
> --- init/parse_job.h    2009-06-23 09:29:35 +0000
> +++ init/parse_job.h    2011-01-12 04:27:54 +0000
> @@ -27,9 +27,9 @@
>
>  NIH_BEGIN_EXTERN
>
> -JobClass *parse_job (const void *parent, const char *name,
> -                    const char *file, size_t len,
> -                    size_t *pos, size_t *lineno)
> +JobClass *parse_job (const void *parent, JobClass *update,
> +                    const char *name, const char *file,
> +                    size_t len, size_t *pos, size_t *lineno)
>        __attribute__ ((warn_unused_result, malloc));
>
>  NIH_END_EXTERN
>
> === modified file 'init/tests/test_conf.c'
> --- init/tests/test_conf.c      2009-07-08 21:05:59 +0000
> +++ init/tests/test_conf.c      2011-01-12 04:27:54 +0000
> @@ -46,6 +46,50 @@
>  #include "job.h"
>  #include "conf.h"
>
> +/* macro to try and ensure the environment is as pristine as possible
> + * (to avoid follow-on errors caused by not freeing objects in a
> + * previous test, say)
> + */
> +#define TEST_ENSURE_CLEAN_ENV()                                      \
> +{                                                                    \
> +       setvbuf(stdout, NULL, _IONBF, 0);                            \
> +                                                                     \
> +       if (job_classes) {                                           \
> +               TEST_HASH_EMPTY (job_classes);                       \
> +       }                                                            \
> +                                                                     \
> +       if (conf_sources) {                                          \
> +               TEST_LIST_EMPTY (conf_sources);                      \
> +       }                                                            \
> +                                                                     \
> +       if (nih_io_watches) {                                        \
> +               TEST_LIST_EMPTY (nih_io_watches);                    \
> +       }                                                            \
> +                                                                     \
> +       if (nih_timers) {                                            \
> +               TEST_LIST_EMPTY (nih_timers);                        \
> +       }                                                            \
> +                                                                     \
> +       if (events) {                                                \
> +               TEST_LIST_EMPTY (events);                            \
> +       }                                                            \
> +}
> +
> +/* Force an inotify watch update */
> +#define TEST_FORCE_WATCH_UPDATE()                                    \
> +{                                                                    \
> +       int         nfds = 0;                                        \
> +       fd_set      readfds, writefds, exceptfds;                    \
> +                                                                    \
> +       FD_ZERO (&readfds);                                          \
> +       FD_ZERO (&writefds);                                         \
> +       FD_ZERO (&exceptfds);                                        \
> +                                                                    \
> +       nih_debug("calling nih_io_select_fds");                      \
> +       nih_io_select_fds (&nfds, &readfds, &writefds, &exceptfds);  \
> +       nih_debug("calling nih_io_handle_fds");                      \
> +       nih_io_handle_fds (&readfds, &writefds, &exceptfds);         \
> +}
>
>  void
>  test_source_new (void)
> @@ -982,7 +1026,8 @@
>        strcat (filename, "/foo.conf");
>        unlink (filename);
>
> -       rmdir (dirname);
> +       ret = rmdir (dirname);
> +       TEST_EQ (ret, 0);
>
>        nfds = 0;
>        FD_ZERO (&readfds);
> @@ -2270,6 +2315,1127 @@
>        }
>  }
>
> +void
> +test_toggle_conf_name (void)
> +{
> +       char override_ext[] = ".override";
> +       char dirname[PATH_MAX];
> +       char filename[PATH_MAX];
> +       char *f;
> +       char *p;
> +
> +       TEST_FUNCTION_FEATURE ("toggle_conf_name",
> +                       "changing conf to override");
> +
> +       TEST_FILENAME (dirname);
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = toggle_conf_name (filename);
> +       TEST_NE_P (f, NULL);
> +
> +       p = strstr (f, ".override");
> +       TEST_NE_P (p, NULL);
> +       TEST_EQ_P (p, f+strlen (f) - strlen (override_ext));
> +       nih_free (f);
> +
> +       TEST_FEATURE ("changing override to conf");
> +       strcpy (filename, dirname);
> +       strcat (filename, "/bar.override");
> +       f = toggle_conf_name (filename);
> +       TEST_NE_P (f, NULL);
> +
> +       p = strstr (f, ".conf");
> +       TEST_NE_P (p, NULL);
> +       TEST_EQ_P (p, f+strlen (f) - strlen (".conf"));
> +       nih_free (f);
> +}
> +
> +
> +/* FIXME:
> + *
> + * - ensuring that an override specified for:
> + *   - a *file* fails (since you cannot put content into /etc/init.conf
> + *     currently)
> + *   - a directory, you get a NOP since if you have a /etc/init.override,
> + *     you don't want it to apply to all files within directory /etc/init/.
> + */
> +void
> +test_override (void)
> +{
> +       ConfSource *source;
> +       ConfFile   *file;
> +       FILE       *f;
> +       int         ret, fd[4096];
> +       char        dirname[PATH_MAX];
> +       char        filename[PATH_MAX], override[PATH_MAX];
> +       JobClass   *job;
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_GROUP ("override files");
> +
> +       /* Make sure that we have inotify before performing some tests... */
> +       if ((fd[0] = inotify_init ()) < 0) {
> +               printf ("SKIP: inotify not available\n");
> +               goto no_inotify;
> +       }
> +       close (fd[0]);
> +
> +
> +       /* Explicit test of behaviour prior to introduction of override files.
> +        *
> +        * conf with no override before watch:
> +        *   create conf
> +        *   create watch
> +        *   ensure conf loaded
> +        *   update conf
> +        *   ensure conf updated
> +        *   delete conf
> +        *   ensure conf deleted
> +        */
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("with pre-override environment (conf with no override before watch)");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_NE_P (job->start_on, NULL);
> +
> +       /* update conf */
> +       f = fopen (filename, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +
> +       /* delete conf */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       TEST_HASH_EMPTY (job_classes);
> +       TEST_HASH_EMPTY (source->files);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf deleted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       /* Explicit test of behaviour prior to introduction of override files.
> +        *
> +        * conf with no override after watch:
> +        *   create watch
> +        *   create conf
> +        *   ensure conf loaded
> +        *   update conf
> +        *   ensure conf updated
> +        *   delete conf
> +        *   ensure conf deleted
> +        */
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("with pre-override environment (conf with no override after watch)");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* update conf */
> +       f = fopen (filename, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +
> +       /* delete conf */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf deleted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("ensure lone override ignored before watch");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create override */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.override");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       TEST_HASH_EMPTY (source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* update override */
> +       f = fopen (filename, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "author \"me\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       TEST_HASH_EMPTY (source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* delete override */
> +       unlink (filename);
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("ensure lone override ignored after watch");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       strcpy (filename, dirname);
> +       strcat (filename, "/bar.override");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "bar");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* delete override */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure override still not present */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "bar");
> +       TEST_EQ_P (job, NULL);
> +
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create conf, watch, then create/modify/delete override");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       /* ensure conf loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_P ((job->emits)[1], NULL);
> +       TEST_NE_P (job->start_on, NULL);
> +
> +       /* create override */
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +
> +       /* ensure no override in hash */
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       /* modify override */
> +       f = fopen (override, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "emits world\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_STR ((job->emits)[1], "world");
> +
> +       /* delete override */
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reverted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_P ((job->emits)[1], NULL);
> +
> +       nih_free (source);
> +       unlink (filename);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create watch, conf, then create/modify/delete override");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_P ((job->emits)[1], NULL);
> +       TEST_NE_P (job->start_on, NULL);
> +
> +       /* create override */
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +
> +       /* ensure no override in hash */
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       /* modify override */
> +       f = fopen (override, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "emits world\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_STR ((job->emits)[1], "world");
> +
> +       /* delete override */
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reverted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_P ((job->emits)[1], NULL);
> +
> +       nih_free (source);
> +       unlink (filename);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create override, watch, then create/modify/delete conf");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +
> +       /* create override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"bar\"\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       TEST_HASH_EMPTY (source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* create conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fprintf (f, "author \"foo\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* modify conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on wibble\n");
> +       fprintf (f, "emits moo\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reloaded and updated with override */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "moo");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* delete conf */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf object deleted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       TEST_HASH_EMPTY (source->files);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       unlink (override);
> +
> +       /* ensure no conf object still */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       TEST_HASH_EMPTY (source->files);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create watch, override, then create/modify/delete conf");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +
> +       /* create override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"bar\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       TEST_HASH_EMPTY (source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* create conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fprintf (f, "author \"foo\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* modify conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on wibble\n");
> +       fprintf (f, "emits moo\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reloaded and updated with override */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "moo");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* delete conf */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf object deleted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       TEST_HASH_EMPTY (source->files);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       unlink (override);
> +
> +       /* ensure no conf object still */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       TEST_HASH_EMPTY (source->files);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create override, watch, conf, then modify/delete override");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +
> +       /* create override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"bar\"\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure no conf object created */
> +       TEST_HASH_EMPTY (source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +
> +       /* create conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fprintf (f, "author \"foo\"\n");
> +       fclose (f);
> +
> +       /* FIXME: crashes here */
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* modify override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "author \"meh\"\n");
> +       fprintf (f, "env wibble=wobble\n");
> +       fprintf (f, "manual\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reloaded and updated with override */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "meh");
> +       TEST_EQ_STR ((job->env)[0], "wibble=wobble");
> +
> +       /* delete override */
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf object reverted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "foo");
> +       TEST_EQ_P (job->env, NULL);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       unlink (filename);
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create watch, override, conf, then modify/delete override");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* create override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"bar\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* create conf */
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "emits hello\n");
> +       fprintf (f, "author \"foo\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "bar");
> +
> +       /* update override */
> +       f = fopen (override, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "author \"me\"\n");
> +       fprintf (f, "env wibble=wobble\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf reloaded and updated with override */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +
> +       /* should pick up override, *NOT* conf */
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "me");
> +       TEST_EQ_STR ((job->env)[0], "wibble=wobble");
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* delete override */
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR (job->author, "foo");
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_P (job->env, NULL);
> +
> +       unlink (filename);
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FEATURE ("create both files, watch, then modify/delete conf");
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "author \"me\"\n");
> +       fprintf (f, "env foo=bar\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       /* create override */
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"you\"\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_STR (job->author, "you");
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->env)[0], "foo=bar");
> +       TEST_EQ_P (job->export, NULL);
> +
> +       /* modify conf */
> +       f = fopen (filename, "a");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "export foo\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_STR ((job->env)[0], "foo=bar");
> +       TEST_NE_P (job->export, NULL);
> +       TEST_EQ_STR ((job->export)[0], "foo");
> +
> +       /* delete conf */
> +       unlink (filename);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf object deleted */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_EQ_P (file, NULL);
> +       TEST_HASH_EMPTY (source->files);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_EQ_P (job, NULL);
> +       file = (ConfFile *)nih_hash_lookup (source->files, override);
> +       TEST_EQ_P (file, NULL);
> +
> +       unlink (override);
> +       nih_free (source);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +       TEST_FEATURE ("create both files, watch, then modify/delete override");
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "author \"me\"\n");
> +       fprintf (f, "env foo=bar\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       /* create override */
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "author \"you\"\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_STR (job->author, "you");
> +       TEST_EQ_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->env)[0], "foo=bar");
> +       TEST_EQ_P (job->export, NULL);
> +
> +       /* modify override */
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "description \"hello world\"\n");
> +       fprintf (f, "author \"ubuntu\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR (job->author, "ubuntu");
> +       TEST_NE_P (job->description, NULL);
> +       TEST_EQ_STR (job->description, "hello world");
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_NE_P (job->start_on, NULL);
> +
> +       /* delete override */
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf updated */
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_STR ((job->env)[0], "foo=bar");
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_EQ_STR (job->author, "me");
> +       TEST_EQ_P (job->description, NULL);
> +
> +       nih_free (source);
> +       unlink (filename);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +
> +       TEST_FEATURE ("create conf, watch, then create invalid override, delete override");
> +       TEST_ENSURE_CLEAN_ENV();
> +       TEST_FILENAME (dirname);
> +       TEST_EQ (mkdir (dirname, 0755), 0);
> +
> +       /* create conf */
> +       strcpy (filename, dirname);
> +       strcat (filename, "/foo.conf");
> +       f = fopen (filename, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "start on started\n");
> +       fprintf (f, "author \"wibble\"\n");
> +       fprintf (f, "emits hello\n");
> +       fclose (f);
> +
> +       /* create watch */
> +       source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
> +       TEST_NE_P (source, NULL);
> +       ret = conf_source_reload (source);
> +       TEST_EQ (ret, 0);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_NE_P (job->start_on, NULL);
> +
> +       /* create (partially) invalid override (which should be
> +        * fully ignored)
> +        */
> +       strcpy (override, dirname);
> +       strcat (override, "/foo.override");
> +       f = fopen (override, "w");
> +       TEST_NE_P (f, NULL);
> +       fprintf (f, "manual\n");
> +       fprintf (f, "bleaugh!\n");
> +       fprintf (f, "wha...?\n");
> +       fprintf (f, "author \"moo\"\n");
> +       fclose (f);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       unlink (override);
> +
> +       TEST_FORCE_WATCH_UPDATE();
> +
> +       /* ensure conf still loaded */
> +       TEST_HASH_NOT_EMPTY(source->files);
> +       file = (ConfFile *)nih_hash_lookup (source->files, filename);
> +       TEST_NE_P (file, NULL);
> +       job = (JobClass *)nih_hash_lookup (job_classes, "foo");
> +       TEST_NE_P (job, NULL);
> +       TEST_EQ_P (file->job, job);
> +       TEST_EQ_STR ((job->emits)[0], "hello");
> +       TEST_NE_P (job->start_on, NULL);
> +       TEST_EQ_STR (job->author, "wibble");
> +
> +       nih_free (source);
> +       unlink (filename);
> +       TEST_EQ (rmdir (dirname), 0);
> +
> +no_inotify:
> +       /* FIXME */
> +       return;
> +}
>
>  void
>  test_source_reload_file (void)
> @@ -2822,8 +3988,6 @@
>        TEST_HASH_EMPTY (source->files);
>
>        nih_free (source);
> -
> -
>        /* Consume all available inotify instances so that the following
>         * tests run without inotify.
>         */
> @@ -3309,6 +4473,8 @@
>        test_source_reload_conf_dir ();
>        test_source_reload_file ();
>        test_source_reload ();
> +       test_toggle_conf_name ();
> +       test_override ();
>        test_file_destroy ();
>        test_select_job ();
>
>
> === modified file 'init/tests/test_parse_job.c'
> --- init/tests/test_parse_job.c 2010-12-14 16:20:38 +0000
> +++ init/tests/test_parse_job.c 2011-01-12 04:27:54 +0000
> @@ -64,7 +64,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -110,7 +110,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -131,6 +131,45 @@
>
>                nih_free (job);
>        }
> +
> +       TEST_FEATURE ("with non-NULL update parameter (override)");
> +       {
> +               JobClass *tmp = NULL;
> +
> +               strcpy (buf, "start on starting\n");
> +               strcat (buf, "author \"me\"\n");
> +
> +               pos = 0;
> +               lineno = 1;
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
> +                               &pos, &lineno);
> +
> +               TEST_NE_P (job, NULL);
> +               TEST_EQ_STR (job->author, "me");
> +               TEST_NE_P (job->start_on, NULL);
> +
> +               strcat (buf, "author \"you\"\n");
> +               strcat (buf, "manual\n");
> +               strcat (buf, "description \"my description\"\n");
> +
> +               pos = 0;
> +               lineno = 1;
> +               tmp = parse_job (NULL, job, "test", buf, strlen (buf),
> +                               &pos, &lineno);
> +               TEST_NE_P (tmp, NULL);
> +
> +               /* if passed a job, the same object should be returned.
> +                */
> +               TEST_EQ_P (tmp, job);
> +
> +               TEST_EQ_STR (tmp->author, "you");
> +               TEST_EQ_P (tmp->start_on, NULL);
> +               TEST_NE_P (tmp->description, NULL);
> +
> +               TEST_EQ_STR (tmp->description, "my description");
> +
> +               nih_free (job);
> +       }
>  }
>
>  void
> @@ -153,7 +192,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -190,7 +229,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -229,7 +268,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -266,7 +305,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -299,7 +338,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -340,7 +379,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -379,7 +418,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -416,7 +455,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -447,7 +486,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -484,7 +523,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -524,7 +563,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -565,7 +604,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -604,7 +643,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -643,7 +682,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -680,7 +719,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -699,7 +738,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -718,7 +757,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -737,7 +776,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -768,7 +807,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -805,7 +844,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -845,7 +884,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -886,7 +925,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -925,7 +964,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -964,7 +1003,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1001,7 +1040,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1020,7 +1059,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1039,7 +1078,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1058,7 +1097,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1089,7 +1128,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1126,7 +1165,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1166,7 +1205,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1207,7 +1246,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1246,7 +1285,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1285,7 +1324,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1322,7 +1361,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1341,7 +1380,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1360,7 +1399,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1379,7 +1418,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1410,7 +1449,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1447,7 +1486,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1487,7 +1526,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1528,7 +1567,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1567,7 +1606,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1606,7 +1645,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1643,7 +1682,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1662,7 +1701,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1681,7 +1720,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1700,7 +1739,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -1731,7 +1770,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1776,7 +1815,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1828,7 +1867,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1879,7 +1918,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -1942,7 +1981,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -2012,7 +2051,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -2090,7 +2129,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -2170,7 +2209,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -2249,7 +2288,7 @@
>        TEST_ALLOC_FAIL {
>                pos = 0;
>                lineno = 1;
> -               job = parse_job (NULL, "test", buf, strlen (buf),
> +               job = parse_job (NULL, NULL, "test", buf, strlen (buf),
>                                 &pos, &lineno);
>
>                if (test_alloc_failed) {
> @@ -2291,7 +2330,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -2310,7 +2349,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -2329,7 +2368,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -2348,7 +2387,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -2367,7 +2406,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (job, NULL);
>
> @@ -2384,7 +2423,7 @@
>
>        pos = 0;
>        lineno = 1;
> -       job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
> +       job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
>
>        TEST_EQ_P (jo
>