diff --git a/modules/ksb/BuildContext.pm b/modules/ksb/BuildContext.pm
index 600ad58..8ef5a43 100644
--- a/modules/ksb/BuildContext.pm
+++ b/modules/ksb/BuildContext.pm
@@ -1,1031 +1,1038 @@
 package ksb::BuildContext 0.35;
 
 # Class: BuildContext
 #
 # This contains the information needed about the build context, e.g.  list of
 # modules, what phases each module is in, the various options, etc.
 
 use 5.014;
 use warnings;
 no if $] >= 5.018, 'warnings', 'experimental::smartmatch';
 
 use Carp 'confess';
 use File::Basename; # dirname
 use IO::File;
 use POSIX qw(strftime);
 use Errno qw(:POSIX);
 use JSON::PP;
 
 # We derive from ksb::Module so that BuildContext acts like the 'global'
 # ksb::Module, with some extra functionality.
 # TODO: Derive from OptionsBase directly and remove getOption override
 use parent qw(ksb::Module);
 
 use ksb::Debug;
 use ksb::Util;
 use ksb::PhaseList;
 use ksb::Module;
 use ksb::Module::BranchGroupResolver;
 use ksb::Updater::KDEProjectMetadata 0.20;
 use ksb::Version qw(scriptVersion);
 use ksb::StatusView;
 use ksb::KDEProjectsReader 0.50;
 
 use File::Temp qw(tempfile);
 use File::Spec; # rel2abs
 
 my @DefaultPhases = qw/update build install/;
 my @rcfiles = ("./kdesrc-buildrc", "$ENV{HOME}/.kdesrc-buildrc");
 my $LOCKFILE_NAME = '.kdesrc-lock';
 
 # The # will be replaced by the directory the rc File is stored in.
 my $PERSISTENT_FILE_NAME = '#/.kdesrc-build-data';
 
 my $SCRIPT_VERSION = scriptVersion();
 
 # Should be used for internal state that shouldn't be exposed as a hidden
 # cmdline option, or has other cmdline switches (e.g. debug/verbose handling).
 my %internalGlobalOptions = (
     "async"                => 1,
     "build-system-only"    => "",
     "build-when-unchanged" => 1, # Safe default
     "checkout-only"        => "",
     "colorful-output"      => 1, # Use color by default.
     "debug-level"          => ksb::Debug::INFO,
     "filter-out-phases"    => '',
     "git-desired-protocol" => 'git', # protocol to grab from kde-projects
     "git-repository-base"  => {}, # Base path template for use multiple times.
     "ignore-modules"       => '', # See also: use-modules, kde-projects
     "include-dependencies" => 0,  # Recursively include kde-projects module deps?
     "manual-build"         => "",
     "manual-update"        => "",
     "niceness"             => "10",
     "no-svn"               => "",  # TODO: Rename to no-src
     "prefix"               => "", # Override installation prefix.
     "pretend"              => "",
     "reconfigure"          => "",
     "refresh-build"        => "",
     "repository"           => '',     # module's git repo
     "revision"             => '', # Only useful for Subversion modules at cmdline
     "set-env"              => { }, # Hash of environment vars to set
     "ssh-identity-file"    => '', # If set, is passed to ssh-add.
     "use-modules"          => "",
 );
 
 # Holds boolean flags that could be altered from cmdline.
 our %defaultGlobalFlags = (
     "delete-my-patches"          => 0, # Should only be set from cmdline
     "delete-my-settings"         => 0, # Should only be set from cmdline
     "disable-agent-check"        => 0, # If true we don't check on ssh-agent
     "disable-snapshots"          => 1, # 2016-07-31 Temp. disabled until kde.org fixed to supply snapshots
     "ignore-kde-structure"       => 0, # Whether to use kde dir structure like extragear/network
     "install-after-build"        => 1,
     "install-environment-driver" => 1, # Setup ~/.config/kde-env-*.sh for login scripts
     "install-session-driver"     => 0, # Above, + ~/.xsession
     "purge-old-logs"             => 1,
     "run-tests"                  => 0,  # 1 = make test, upload = make Experimental
     "stop-on-failure"            => 0,
     "use-clean-install"          => 0,
     "use-idle-io-priority"       => 0,
     "use-stable-kde"             => 0,
 );
 
 # Holds other cmdline-accessible options that aren't simply binary flags.
 our %defaultGlobalOptions = (
     "binpath"              => '',
     "branch"               => "",
     "branch-group"         => "", # Overrides branch, uses JSON data.
     "build-dir"            => "build",
     "cmake-options"        => "",
     "configure-flags"      => "",
     "custom-build-command" => '',
     "cxxflags"             => "-pipe",
     "dest-dir"             => '${MODULE}', # single quotes used on purpose!
     "do-not-compile"       => "",
     "http-proxy"           => '', # Proxy server to use for HTTP.
     "kdedir"               => "$ENV{HOME}/kde",
     "kde-languages"        => "",
     "libpath"              => "",
     "log-dir"              => "log",
     "make-install-prefix"  => "",  # Some people need sudo
     "make-options"         => "",
     "module-base-path"     => "",  # Used for tags and branches
     "override-build-system"=> "",
     "override-url"         => "",
     "persistent-data-file" => "",
     "qtdir"                => "",
     "remove-after-install" => "none", # { none, builddir, all }
     "source-dir"           => "$ENV{HOME}/kdesrc",
     "svn-server"           => "svn://anonsvn.kde.org/home/kde",
     "tag"                  => "",
 );
 
 sub new
 {
     my ($class, @args) = @_;
 
     # It is very important to use the ksb::Module:: syntax instead of ksb::Module->,
     # otherwise you can't pass $class and have it used as the classname.
     my $self = ksb::Module::new($class, undef, 'global');
     my %newOpts = (
         modules => [],
         context => $self, # Fix link to buildContext (i.e. $self)
         build_options => {
             global => {
                 %internalGlobalOptions,
                 %defaultGlobalFlags,
                 %defaultGlobalOptions,
             },
             # Module options are stored under here as well, keyed by module->name()
         },
         # This one replaces ksb::Module::{phases}
         phases  => ksb::PhaseList->new(@DefaultPhases),
         errors  => {
             # A map from module *names* (as in modules[] above) to the
             # phase name at which they failed.
         },
         logPaths=> {
             # Holds a hash table of log path bases as expanded by
             # getSubdirPath (e.g. [source-dir]/log) to the actual log dir
             # *this run*, with the date and unique id added. You must still
             # add the module name to use.
         },
         rcFiles => [@rcfiles],
         rcFile  => undef,
         env     => { },
         persistent_options => { }, # These are kept across multiple script runs
         ignore_list => [ ], # List of KDE project paths to ignore completely
         kde_projects_metadata     => undef, # Enumeration of kde-projects
         kde_dependencies_metadata => undef, # Dependency resolution of kde-projects
         logical_module_resolver   => undef, # For branch-group option
         status_view => ksb::StatusView->new(),
         projects_db => undef, # See getProjectDataReader
     );
 
     # Merge all new options into our self-hash.
     @{$self}{keys %newOpts} = values %newOpts;
     $self->{options} = $self->{build_options}{global};
 
     assert_isa($self, 'ksb::Module');
     assert_isa($self, 'ksb::BuildContext');
 
     return $self;
 }
 
 # Gets the ksb::PhaseList for this context, and optionally sets it first to
 # the ksb::PhaseList passed in.
 sub phases
 {
     my ($self, $phases) = @_;
 
     if ($phases) {
         confess("Invalid type, expected PhaseList")
             unless $phases->isa('ksb::PhaseList');
         $self->{phases} = $phases;
     }
     return $self->{phases};
 }
 
 sub addModule
 {
     my ($self, $module) = @_;
     Carp::confess("No module to push") unless $module;
 
     my $path;
     if (list_has($self->{modules}, $module)) {
         debug("Skipping duplicate module ", $module->name());
     }
     # TODO: Shouldn't this support all modules, not just 'proj' modules?
     elsif ($module->scmType() eq 'proj' &&
            ($path = $module->fullProjectPath()) &&
         # See if the name matches any given in the ignore list.
            any(sub { $path =~ /(^|\/)$_($|\/)/ }, $self->{ignore_list}))
     {
         debug("Skipping ignored module $module");
     }
     else {
         debug("Adding $module to module list");
         push @{$self->{modules}}, $module;
     }
 }
 
 # Returns a listref of the modules to build
 sub moduleList
 {
     my $self = shift;
     return $self->{modules};
 }
 
 # Adds a list of modules to ignore processing on completely.
 # Parameters should simply be a list of KDE project paths to ignore,
 # e.g. 'extragear/utils/kdesrc-build'. Partial paths are acceptable, matches
 # are determined by comparing the path provided to the suffix of the full path
 # of modules being compared.  See KDEProjectsReader::_projectPathMatchesWildcardSearch
 #
 # Existing items on the ignore list are not removed.
 sub addToIgnoreList
 {
     my $self = shift;
     push @{$self->{ignore_list}}, @_;
-
-    debug ("Set context ignore list to ", join(', ', @_));
 }
 
 sub setupOperatingEnvironment
 {
     my $self = shift;
     # Set the process priority
     POSIX::nice(int $self->getOption('niceness'));
 
     # Set the IO priority if available.
     if ($self->getOption('use-idle-io-priority')) {
         # -p $$ is our PID, -c3 is idle priority
         # 0 return value means success
         if (safe_system('ionice', '-c3', '-p', $$) != 0) {
             warning (" b[y[*] Unable to lower I/O priority, continuing...");
         }
     }
 
     # Get ready for logged output.
     ksb::Debug::setLogFile($self->getLogDirFor($self) . '/build-log');
 
     # Propagate HTTP proxy through environment unless overridden.
     if ((my $proxy = $self->getOption('http-proxy')) &&
         !defined $ENV{'http_proxy'})
     {
         $self->queueEnvironmentVariable('http_proxy', $proxy);
     }
 }
 
 # Clears the list of environment variables to set for log_command runs.
 sub resetEnvironment
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
-
     $self->{env} = { };
 }
 
 # Adds an environment variable and value to the list of environment
 # variables to apply for the next subprocess execution.
 #
 # Note that these changes are /not/ reflected in the current environment,
 # so if you are doing something that requires that kind of update you
 # should do that yourself (but remember to have some way to restore the old
 # value if necessary).
 #
 # In order to keep compatibility with the old 'setenv' sub, no action is
 # taken if the value is not equivalent to boolean true.
 sub queueEnvironmentVariable
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my ($key, $value) = @_;
 
     return unless $value;
 
     debug ("\tQueueing g[$key] to be set to y[$value]");
     $self->{env}->{$key} = $value;
 }
 
 # Applies all changes queued by queueEnvironmentVariable to the actual
 # environment irretrievably. Use this before exec()'ing another child, for
 # instance.
 sub commitEnvironmentChanges
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     while (my ($key, $value) = each %{$self->{env}}) {
         $ENV{$key} = $value;
         debug ("\tSetting environment variable g[$key] to g[b[$value]");
     }
 }
 
 # Adds the given library paths to the path already given in an environment
 # variable. In addition, detected "system paths" are stripped to ensure
 # that we don't inadvertently re-add a system path to be promoted over the
 # custom code we're compiling (for instance, when a system Qt is used and
 # installed to /usr).
 #
 # If the environment variable to be modified has already been queued using
 # queueEnvironmentVariable, then that (queued) value will be modified and
 # will take effect with the next forked subprocess.
 #
 # Otherwise, the current environment variable value will be used, and then
 # queued. Either way the current environment will be unmodified afterward.
 #
 # First parameter is the name of the environment variable to modify
 # All remaining paramters are prepended to the current environment path, in
 # the order given. (i.e. param1, param2, param3 ->
 # param1:param2:param3:existing)
 sub prependEnvironmentValue
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my ($envName, @items) = @_;
     my @curPaths = split(':', $self->{env}->{$envName} // $ENV{$envName} // '');
 
     # Filter out entries to add that are already in the environment from
     # the system.
     for my $path (grep { list_has(\@curPaths, $_) } (@items) ) {
         debug ("\tNot prepending y[$path] to y[$envName] as it appears " .
               "to already be defined in y[$envName].");
     }
 
     @items = grep { not list_has(\@curPaths, $_); } (@items);
 
     my $envValue = join(':', @items, @curPaths);
 
     $envValue =~ s/^:*//;
     $envValue =~ s/:*$//; # Remove leading/trailing colons
     $envValue =~ s/:+/:/; # Remove duplicate colons
 
     $self->queueEnvironmentVariable($envName, $envValue);
 }
 
 # Tries to take the lock for our current base directory, which currently is
 # what passes for preventing people from accidentally running kdesrc-build
 # multiple times at once.  The lock is based on the base directory instead
 # of being global to allow for motivated and/or brave users to properly
 # configure kdesrc-build to run simultaneously with different
 # configurations.
 #
 # Return value is a boolean success flag.
 sub takeLock
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $baseDir = $self->baseConfigDirectory();
     my $lockfile = "$baseDir/$LOCKFILE_NAME";
 
     $! = 0; # Force reset to non-error status
     sysopen LOCKFILE, $lockfile, O_WRONLY | O_CREAT | O_EXCL;
     my $errorCode = $!; # Save for later testing.
 
     if ($errorCode == EEXIST)
     {
         # Path already exists, read the PID and see if it belongs to a
         # running process.
         open (my $pidFile, "<", $lockfile) or do
         {
             # Lockfile is there but we can't open it?!?  Maybe a race
             # condition but I have to give up somewhere.
             warning (" WARNING: Can't open or create lockfile r[$lockfile]");
             return 1;
         };
 
         my $pid = <$pidFile>;
         close $pidFile;
 
         if ($pid)
         {
             # Recent kdesrc-build; we wrote a PID in there.
             chomp $pid;
 
             # See if something's running with this PID.
             if (kill(0, $pid) == 1)
             {
                 # Something *is* running, likely kdesrc-build.  Don't use error,
                 # it'll scan for $!
                 print ksb::Debug::colorize(" r[*y[*r[*] kdesrc-build appears to be running.  Do you want to:\n");
                 print ksb::Debug::colorize("  (b[Q])uit, (b[P])roceed anyways?: ");
 
                 my $choice = <STDIN> // '';
                 chomp $choice;
 
                 if (lc $choice ne 'p')
                 {
                     say ksb::Debug::colorize(" y[*] kdesrc-build run canceled.");
                     return 0;
                 }
 
                 # We still can't grab the lockfile, let's just hope things
                 # work out.
                 note (" y[*] kdesrc-build run in progress by user request.");
                 return 1;
             }
 
             # If we get here, then the program isn't running (or at least not
             # as the current user), so allow the flow of execution to fall
             # through below and unlink the lockfile.
         } # pid
 
         # No pid found, optimistically assume the user isn't running
         # twice.
         warning (" y[WARNING]: stale kdesrc-build lockfile found, deleting.");
         unlink $lockfile;
 
         sysopen (LOCKFILE, $lockfile, O_WRONLY | O_CREAT | O_EXCL) or do {
             error (" r[*] Still unable to lock $lockfile, proceeding anyways...");
             return 1;
         };
 
         # Hope the sysopen worked... fall-through
     }
     elsif ($errorCode == ENOTTY)
     {
         # Stupid bugs... normally sysopen will return ENOTTY, not sure who's to blame between
         # glibc and Perl but I know that setting PERLIO=:stdio in the environment "fixes" things.
         ; # pass
     }
     elsif ($errorCode != 0) # Some other error occurred.
     {
         warning (" r[*]: Error $errorCode while creating lock file (is $baseDir available?)");
         warning (" r[*]: Continuing the script for now...");
 
         # Even if we fail it's generally better to allow the script to proceed
         # without being a jerk about things, especially as more non-CLI-skilled
         # users start using kdesrc-build to build KDE.
         return 1;
     }
 
     say LOCKFILE "$$";
     close LOCKFILE;
 
     return 1;
 }
 
 # Releases the lock obtained by takeLock.
 sub closeLock
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $baseDir = $self->baseConfigDirectory();
     my $lockFile = "$baseDir/$LOCKFILE_NAME";
 
     unlink ($lockFile) or warning(" y[*] Failed to close lock: $!");
 }
 
 # This subroutine accepts a Module parameter, and returns the log directory
 # for it. You can also pass a BuildContext (including this one) to get the
 # default log directory.
 #
 # As part of setting up what path to use for the log directory, the
 # 'latest' symlink will also be setup to point to the returned log
 # directory.
 sub getLogDirFor
 {
     my ($self, $module) = @_;
 
     my $baseLogPath = $module->getSubdirPath('log-dir');
     my $logDir;
 
     if (!exists $self->{logPaths}{$baseLogPath}) {
         # No log dir made for this base, do so now.
         my $id = '01';
         my $date = strftime "%F", localtime; # ISO 8601 date
         $id++ while -e "$baseLogPath/$date-$id";
         $self->{logPaths}{$baseLogPath} = "$baseLogPath/$date-$id";
     }
 
     $logDir = $self->{logPaths}{$baseLogPath};
-    return $logDir if pretending();
+    super_mkdir($logDir);
+
+    # global logs go to basedir directly
+    $logDir .= "/$module" unless $module->isa('ksb::BuildContext');
+
+    return $logDir;
+}
+
+# Constructs the appropriate full path to a log file based on the given
+# basename (including extensions). Use this instead of getLogDirFor when you
+# actually intend to create a log, as this function will also adjust the
+# 'latest' symlink properly.
+sub getLogPathFor
+{
+    my ($self, $module, $path) = @_;
 
-    super_mkdir($logDir) unless -e $logDir;
+    my $baseLogPath = $module->getSubdirPath('log-dir');
+    my $logDir = $self->getLogDirFor($module);
 
-    # No symlink munging or module-name-adding is needed for the default
-    # log dir.
-    return $logDir if $module->isa('ksb::BuildContext');
+    # We create this here to avoid needless empty module directories everywhere
+    super_mkdir($logDir);
 
-    # Add a symlink to the latest run for this module.  'latest' itself is
-    # a directory under the default log directory that holds module
-    # symlinks, pointing to the last log directory run for that module.  We
-    # do need to be careful of modules that have multiple directory names
-    # though (like extragear/foo).
+    # Add a symlink to the latest run for this module. 'latest' itself is
+    # a directory under the base log directory that holds symlinks mapping
+    # each module name to the specific log directoy most recently used.
 
     my $latestPath = "$baseLogPath/latest";
 
     # Handle stuff like playground/utils or KDE/kdelibs
     my ($moduleName, $modulePath) = fileparse($module->name());
     $latestPath .= "/$modulePath" if $module->name() =~ m(/);
 
     super_mkdir($latestPath);
 
-    my $symlinkTarget = "$logDir/$moduleName";
     my $symlink = "$latestPath/$moduleName";
 
-    if (-l $symlink and readlink($symlink) ne $symlinkTarget)
+    if (-l $symlink and readlink($symlink) ne $logDir)
     {
         unlink($symlink);
-        symlink($symlinkTarget, $symlink);
+        symlink($logDir, $symlink);
     }
     elsif(not -e $symlink)
     {
         # Create symlink initially if we've never done it before.
-        symlink($symlinkTarget, $symlink);
+        symlink($logDir, $symlink);
     }
 
-    super_mkdir($symlinkTarget);
-    return $symlinkTarget;
+    return "$logDir/$path";
 }
 
 # Returns rc file in use. Call loadRcFile first.
 sub rcFile
 {
     my $self = shift;
     return $self->{rcFile};
 }
 
 # Forces the rc file to be read from to be that given by the first
 # parameter.
 sub setRcFile
 {
     my ($self, $file) = @_;
     $self->{rcFiles} = [$file];
     $self->{rcFile} = undef;
 }
 
 # Returns an open filehandle to the user's chosen rc file.  Use setRcFile
 # to choose a file to load before calling this function, otherwise
 # loadRcFile will search the default search path.  After this function is
 # called, rcFile() can be used to determine which file was loaded.
 #
 # If unable to find or open the rc file an exception is raised. Empty rc
 # files are supported however.
 sub loadRcFile
 {
     my $self = shift;
     my @rcFiles = @{$self->{rcFiles}};
     my $fh;
 
     for my $file (@rcFiles)
     {
         if (open ($fh, '<', "$file"))
         {
             $self->{rcFile} = File::Spec->rel2abs($file);
             return $fh;
         }
     }
 
     # No rc found, check if we can use default.
     if (scalar @rcFiles == 1)
     {
         # This can only happen if the user uses --rc-file, so if we fail to
         # load the file, we need to fail to load at all.
         my $failedFile = $rcFiles[0];
 
         error (<<EOM);
 Unable to open config file $failedFile
 
 Script stopping here since you specified --rc-file on the command line to
 load $failedFile manually.  If you wish to run the script with no configuration
 file, leave the --rc-file option out of the command line.
 
 If you want to force an empty rc file, use --rc-file /dev/null
 
 EOM
         croak_runtime("Missing $failedFile");
     }
 
     # If no configuration but no --rc-file option was used, warn the user
     # and fail, as there are too many possible modes of using kdesrc-build
     # for kdesrc-buildrc-sample to be appropriate.
 
     error (<<EOM);
 b[No configuration file is present.]
 
 kdesrc-build requires a configuration file to select which KDE software modules
 to build, what options to build them with, the path to install to, etc.
 
 kdesrc-build looks for its configuration in the file `kdesrc-buildrc' in
 whatever directory kdesrc-build is run from.
 
 If no such file exists, kdesrc-build tries to use `~/.kdesrc-buildrc' (note the
 leading `.')
 
 A sample configuration suitable for KDE 4 software is included at the file
 `kdesrc-buildrc-sample' which can be copied to the correct location and then
 edited.
 
 KDE Frameworks 5 users can use the `kdesrc-buildrc-kf5-sample' file which can
 be copied to the correct location and then edited.
 
 In either case b[once the configuration file is setup to your liking], you
 should run:
 b[kdesrc-build --metadata-only]
 
 to download needed information about the KDE source repositories and then:
 b[kdesrc-build --pretend]
 
 to preview what kdesrc-build will do.
 EOM
     croak_runtime("No configuration available");
 }
 
 # Returns the base directory that holds the configuration file. This is
 # typically used as the directory base for other necessary kdesrc-build
 # execution files, such as the persistent data store and lock file.
 #
 # The RC file must have been found and loaded first, obviously.
 sub baseConfigDirectory
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $rcfile = $self->rcFile() or
         croak_internal("Call to baseConfigDirectory before loadRcFile");
 
     return dirname($rcfile);
 }
 
 sub modulesInPhase
 {
     my ($self, $phase) = @_;
     my @list = grep { list_has([$_->phases()->phases()], $phase) } (@{$self->moduleList()});
     return @list;
 }
 
 # Searches for a module with a name that matches the provided parameter,
 # and returns its ksb::Module object. Returns undef if no match was found.
 # As a special-case, returns the BuildContext itself if the name passed is
 # 'global', since the BuildContext also is a (in the "is-a" OOP sense)
 # ksb::Module, specifically the 'global' one.
 sub lookupModule
 {
     my ($self, $moduleName) = @_;
 
     return $self if $moduleName eq 'global';
 
     my @options = grep { $_->name() eq $moduleName } (@{$self->moduleList()});
     return undef unless @options;
 
     if (scalar @options > 1) {
         croak_internal("Detected 2 or more $moduleName ksb::Module objects");
     }
 
     return $options[0];
 }
 
 sub markModulePhaseFailed
 {
     my ($self, $phase, $module) = @_;
     assert_isa($module, 'ksb::Module');
 
     $self->{errors}->{$module->name()} = $phase;
 }
 
 # Returns a list (i.e. not a reference to, but a real list) of Modules that failed to
 # complete the given phase.
 sub failedModulesInPhase
 {
     my ($self, $phase) = @_;
 
     my @failures = grep {
         ($self->{errors}->{$_->name()} // '') eq $phase
     } (@{$self->moduleList()});
 
     return @failures;
 }
 
 # Returns a list of modules that had a failure of some sort, in the order the modules
 # are listed in our current module list.
 sub listFailedModules
 {
     my $self = shift;
     my @modules = @{$self->moduleList()};
 
     # grepping for failures instead of returning error list directly maintains ordering
     @modules = grep {
         exists $self->{errors}->{$_->name()}
     } (@modules);
 
     return @modules;
 }
 
 # OVERRIDE: Our immediate parent class Module overrides this, but we actually
 # want the OptionsBase version to be used instead, until we break the recursive
 # use of Module's own getOption calls on our getOption.
 sub getOption
 {
     &ksb::OptionsBase::getOption;
 }
 
 # OVERRIDE: Overrides OptionsBase::setOption to handle some global-only options.
 sub setOption
 {
     my ($self, %options) = @_;
 
     # Special-case handling
     my $repoOption = 'git-repository-base';
     if (exists $options{$repoOption}) {
         my $value = $options{$repoOption};
         my ($repo, $url) = ($value =~ /^([a-zA-Z0-9_-]+)\s+(.+)$/);
 
         # This will be a hash reference instead of a scalar
         $value = $self->getOption($repoOption) || { };
 
         if (!$repo || !$url) {
             die ksb::BuildException::Config->new($repoOption,
                 "Invalid git-repository-base setting: $value");
         }
 
         $value->{$repo} = $url;
         delete $options{$repoOption};
     }
 
     # Actually set options.
     $self->SUPER::setOption(%options);
 
     # Automatically respond to various global option changes.
     while (my ($key, $value) = each %options) {
         my $normalizedKey = $key;
         $normalizedKey =~ s/^#//; # Remove sticky key modifier.
         given ($normalizedKey) {
             when ('colorful-output') { ksb::Debug::setColorfulOutput($value); }
             when ('debug-level')     { ksb::Debug::setDebugLevel($value); }
             when ('pretend')         { ksb::Debug::setPretending($value); }
         }
     }
 }
 
 #
 # Persistent option handling
 #
 
 # Returns the name of the file to use for persistent data.
 # Supports expanding '#' at the beginning of the filename to the directory
 # containing the rc-file in use, but only for the default name at this
 # point.
 sub persistentOptionFileName
 {
     my $self = shift;
     my $filename = $self->getOption('persistent-data-file');
 
     if (!$filename) {
         $filename = $PERSISTENT_FILE_NAME;
         my $dir = $self->baseConfigDirectory();
         $filename =~ s/^#/$dir/;
     }
     else {
         # Tilde-expand
         $filename =~ s/^~\//$ENV{HOME}\//;
     }
 
     return $filename;
 }
 
 # Reads in all persistent options from the file where they are kept
 # (.kdesrc-build-data) for use in the program.
 #
 # The directory used is the same directory that contains the rc file in use.
 sub loadPersistentOptions
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     my $fh = IO::File->new($self->persistentOptionFileName(), '<');
 
     return unless $fh;
 
     # $persistent_data should be a JSON object which we can store directly as a
     # hash.
     my $persistent_data;
     {
         local $/ = undef; # Read in whole file with <> operator.
         $persistent_data = <$fh>;
     }
 
     my $persistent_options;
 
     eval { $persistent_options = decode_json($persistent_data); };
     if ($@) {
         # Apparently wasn't JSON, try falling back to old format for compat.
         # Previously, this was a Perl code which, when evaluated would give
         # us a hash called persistent_options which we can then merge into our
         # persistent options.
         # TODO: Remove compat code after 2018-06-30
         eval $persistent_data; # Runs Perl code read from file
         if ($@)
         {
             # Failed.
             error ("Failed to read persistent module data: r[b[$@]");
             return;
         }
     }
 
     # We need to keep persistent data with the context instead of with the
     # applicable modules since otherwise we might forget to write out
     # persistent data for modules we didn't build in this run. So, we just
     # store it all.
     # Layout of this data:
     #  $self->persistent_options = {
     #    'module-name' => {
     #      option => value,
     #      # foreach option/value pair
     #    },
     #    # foreach module
     #  }
     $persistent_options = {} if ref $persistent_options ne 'HASH';
     $self->{persistent_options} = $persistent_options;
 }
 
 # Writes out the persistent options to the file .kdesrc-build-data.
 #
 # The directory used is the same directory that contains the rc file in use.
 sub storePersistentOptions
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
     return if pretending();
 
     my $fh = IO::File->new($self->persistentOptionFileName(), '>');
     my $json = JSON::PP->new->ascii->pretty;
 
     if (!$fh)
     {
         error ("Unable to save persistent module data: b[r[$!]");
         return;
     }
 
     my $encodedJSON = $json->encode($self->{persistent_options});
     print $fh $encodedJSON;
     undef $fh; # Closes the file
 }
 
 # Returns the value of a "persistent" option (normally read in as part of
 # startup), or undef if there is no value stored.
 #
 # First parameter is the module name to get the option for, or 'global' if
 # not for a module.
 #     Note that unlike setOption/getOption, no inheritance is done at this
 #     point so if an option is present globally but not for a module you
 #     must check both if that's what you want.
 # Second parameter is the name of the value to retrieve (i.e. the key)
 sub getPersistentOption
 {
     my ($self, $moduleName, $key) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     # We must check at each level of indirection to avoid
     # "autovivification"
     return unless exists $persistent_opts->{$moduleName};
     return unless exists $persistent_opts->{$moduleName}{$key};
 
     return $persistent_opts->{$moduleName}{$key};
 }
 
 # Clears a persistent option if set (for a given module and option-name).
 #
 # First parameter is the module name to get the option for, or 'global' for
 # the global options.
 # Second parameter is the name of the value to clear.
 # No return value.
 sub unsetPersistentOption
 {
     my ($self, $moduleName, $key) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     if (exists $persistent_opts->{$moduleName} &&
         exists $persistent_opts->{$moduleName}->{$key})
     {
         delete $persistent_opts->{$moduleName}->{$key};
     }
 }
 
 # Sets a "persistent" option which will be read in for a module when
 # kdesrc-build starts up and written back out at (normal) program exit.
 #
 # First parameter is the module name to set the option for, or 'global'.
 # Second parameter is the name of the value to set (i.e. key)
 # Third parameter is the value to store, which must be a scalar.
 sub setPersistentOption
 {
     my ($self, $moduleName, $key, $value) = @_;
     my $persistent_opts = $self->{persistent_options};
 
     # Initialize empty hash ref if nothing defined for this module.
     $persistent_opts->{$moduleName} //= { };
 
     $persistent_opts->{$moduleName}{$key} = $value;
 }
 
 # Returns the ksb::Module (which has a 'metadata' scm type) that is used for
 # kde-build-metadata, so that other modules that need it can call into it if
 # necessary.
 #
 # Also may return undef if the metadata is unavailable or has not yet
 # been set by setKDEDependenciesMetadataModule (this method does not
 # automatically create the needed module).
 sub getKDEDependenciesMetadataModule
 {
     my $self = shift;
     return $self->{kde_dependencies_metadata};
 }
 
 # Returns the ksb::Module (which has a 'metadata' scm type) that is used for
 # kde-project metadata, so that other modules that need it can call into it if
 # necessary.
 #
 # Also may return undef if the metadata is unavailable or has not yet
 # been set by setKDEProjectsMetadataModule (this method does not
 # automatically create the needed module).
 sub getKDEProjectsMetadataModule
 {
     my $self = shift;
     return $self->{kde_projects_metadata};
 }
 
 # Call this method to force this build context to pull in the kde-build-metadata
 # module. This is a one-time action, subsequent calls to this method
 # are ignored. Use getKDEDependenciesMetadataModule to see if this build context is
 # using a metadata module.
 #
 # This method should be called before setModuleList.
 sub setKDEDependenciesMetadataModuleNeeded
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     return if defined $self->{kde_dependencies_metadata};
 
     my $metadata = ksb::ModuleSet::KDEProjects::getDependenciesModule($self);
 
     debug ("Introducing dependency metadata into the build");
     assert_isa($metadata->scm(), 'ksb::Updater::KDEProjectMetadata');
 
     $self->{kde_dependencies_metadata} = $metadata;
     return;
 }
 
 # Call this method to force this build context to pull in the
 # sysadmin/repo-metadata module. This is a one-time action,
 # subsequent calls to this method are ignored. Use
 # getKDEProjectsMetadataModule to see if this build context is using
 # a metadata module.
 #
 # This method should be called before setModuleList.
 sub setKDEProjectsMetadataModuleNeeded
 {
     my $self = assert_isa(shift, 'ksb::BuildContext');
 
     return if defined $self->{kde_projects_metadata};
 
     my $metadata = ksb::ModuleSet::KDEProjects::getProjectMetadataModule($self);
 
     debug ("Introducing project enumeration metadata into the build");
     assert_isa($metadata->scm(), 'ksb::Updater::KDEProjectMetadata');
 
     $self->{kde_projects_metadata} = $metadata;
     return;
 }
 
 # Returns a KDEProjectsReader module, which has already read in the database and
 # is ready to be queried. Note that exceptions can be thrown in the process
 # of downloading and parsing the database information, so be ready for that.
 sub getProjectDataReader
 {
     my $self = shift;
 
     return $self->{projects_db} if $self->{projects_db};
 
     my $projectDatabaseModule = $self->getKDEProjectsMetadataModule() or
         croak_runtime("kde-projects repository information could not be downloaded: $!");
 
     my $protocol = $self->getOption('git-desired-protocol') || 'git';
     if (!list_has(['git', 'http', 'https'], $protocol)) {
         error (" b[y[*] Invalid b[git-desired-protocol] $protocol");
         error (" b[y[*] Try setting this option to 'git' if you're not using a proxy");
         croak_runtime ("Invalid git-desired-protocol: $protocol");
     }
 
     $self->{projects_db} = ksb::KDEProjectsReader->new($projectDatabaseModule, $protocol);
     return $self->{projects_db};
 }
 
 # Returns the effective branch group to use for modules. You should not call
 # this unless kde-build-metadata is also in use (see
 # setKDEDependenciesMetadataModule and moduleBranchGroupResolver).
 sub effectiveBranchGroup
 {
     my $self = shift;
     my $branchGroup = $self->getOption('branch-group', 'module') // '';
 
     if (!$branchGroup) {
         $branchGroup = $self->getOption('use-stable-kde')
             ? 'latest-qt4'
             : ($self->hasOption('use-stable-kde') # Could also be false if unset
                 ? 'kf5-qt5'      # Really set to false
                 : 'latest-qt4'); # Unset / this is default branch group if no option set
     }
 
     return $branchGroup;
 }
 
 # Returns a ksb::Module::BranchGroupResolver which can be used to efficiently
 # determine a git branch to use for a given kde-projects module (when the
 # branch-group option is in use), as specified at
 # https://community.kde.org/Infrastructure/Project_Metadata.
 sub moduleBranchGroupResolver
 {
     my $self = shift;
 
     if (!$self->{logical_module_resolver}) {
         my $metadataModule = $self->getKDEDependenciesMetadataModule();
 
         croak_internal("Tried to use branch-group, but needed data wasn't loaded!")
             unless $metadataModule;
 
         my $resolver = ksb::Module::BranchGroupResolver->new(
             $metadataModule->scm()->logicalModuleGroups());
         $self->{logical_module_resolver} = $resolver;
     }
 
     return $self->{logical_module_resolver};
 }
 
 sub statusViewer
 {
     my $self = shift;
     return $self->{status_view};
 }
 
 1;
diff --git a/modules/ksb/Module.pm b/modules/ksb/Module.pm
index 2d27ec1..695cc55 100644
--- a/modules/ksb/Module.pm
+++ b/modules/ksb/Module.pm
@@ -1,976 +1,984 @@
 package ksb::Module 0.20;
 
 # Class: Module
 #
 # Represents a source code module of some sort, which can be updated, built,
 # and installed. Includes a stringifying overload and can be sorted amongst
 # other ksb::Modules.
 
 use 5.014;
 use warnings;
 no if $] >= 5.018, 'warnings', 'experimental::smartmatch';
 
 use parent qw(ksb::OptionsBase);
 
 use ksb::IPC;
 use ksb::Debug;
 use ksb::Util;
 
 use ksb::l10nSystem;
 
 use ksb::Updater::Svn;
 use ksb::Updater::Git;
 use ksb::Updater::Bzr;
 use ksb::Updater::KDEProject;
 use ksb::Updater::KDEProjectMetadata;
 
 use ksb::BuildException 0.20;
 
 use ksb::BuildSystem 0.30;
 use ksb::BuildSystem::Autotools;
 use ksb::BuildSystem::QMake;
 use ksb::BuildSystem::Qt4;
 use ksb::BuildSystem::KDE4;
 use ksb::BuildSystem::CMakeBootstrap;
 
 use ksb::ModuleSet::Null;
 
 use Storable 'dclone';
 use Carp 'confess';
 use Scalar::Util 'blessed';
 use overload
     '""' => 'toString', # Add stringify operator.
     '<=>' => 'compare',
     ;
 
 my $ModuleSource = 'config';
 
 sub new
 {
     my ($class, $ctx, $name) = @_;
 
     croak_internal ("Empty ksb::Module constructed") unless $name;
 
     my $self = ksb::OptionsBase::new($class);
 
     # If building a BuildContext instead of a ksb::Module, then the context
     # can't have been setup yet...
     my $contextClass = 'ksb::BuildContext';
     if ($class ne $contextClass &&
         (!blessed($ctx) || !$ctx->isa($contextClass)))
     {
         croak_internal ("Invalid context $ctx");
     }
 
     # Clone the passed-in phases so we can be different.
     my $phases = dclone($ctx->phases()) if $ctx;
 
     my %newOptions = (
         name         => $name,
         scm_obj      => undef,
         build_obj    => undef,
         phases       => $phases,
         context      => $ctx,
         'module-set' => undef,
     );
 
     @{$self}{keys %newOptions} = values %newOptions;
 
     return $self;
 }
 
 sub phases
 {
     my $self = shift;
     return $self->{phases};
 }
 
 sub moduleSet
 {
     my ($self) = @_;
     $self->{'module-set'} //= ksb::ModuleSet::Null->new();
     return $self->{'module-set'};
 }
 
 sub setModuleSet
 {
     my ($self, $moduleSetName) = @_;
     $self->{'module-set'} = $moduleSetName;
 }
 
 sub setModuleSource
 {
     my ($class, $source) = @_;
     $ModuleSource = $source;
 }
 
 sub moduleSource
 {
     my $class = shift;
     # Should be 'config' or 'cmdline';
     return $ModuleSource;
 }
 
 # Subroutine to retrieve a subdirectory path with tilde-expansion and
 # relative path handling.
 # The parameter is the option key (e.g. build-dir or log-dir) to read and
 # interpret.
 sub getSubdirPath
 {
     my ($self, $subdirOption) = @_;
     my $dir = $self->getOption($subdirOption);
 
     # If build-dir starts with a slash, it is an absolute path.
     return $dir if $dir =~ /^\//;
 
     # Make sure we got a valid option result.
     if (!$dir) {
         confess ("Reading option for $subdirOption gave empty \$dir!");
     }
 
     # If it starts with a tilde, expand it out.
     if ($dir =~ /^~/)
     {
         $dir =~ s/^~/$ENV{'HOME'}/;
     }
     else
     {
         # Relative directory, tack it on to the end of $kdesrcdir.
         my $kdesrcdir = $self->getOption('source-dir');
         $dir = "$kdesrcdir/$dir";
     }
 
     return $dir;
 }
 
 # Method: getInstallPathComponents
 #
 # Returns the directory that a module should be installed in.
 #
 # NOTE: The return value is a hash. The key 'module' will return the final
 # module name, the key 'path' will return the full path to the module. The
 # key 'fullpath' will return their concatenation.
 #
 # For example, with $module == 'KDE/kdelibs', and no change in the dest-dir
 # option, you'd get something like:
 #
 # > {
 # >   'path'     => '/home/user/kdesrc/KDE',
 # >   'module'   => 'kdelibs',
 # >   'fullpath' => '/home/user/kdesrc/KDE/kdelibs'
 # > }
 #
 # If dest-dir were changed to e.g. extragear-multimedia, you'd get:
 #
 # > {
 # >   'path'     => '/home/user/kdesrc',
 # >   'module'   => 'extragear-multimedia',
 # >   'fullpath' => '/home/user/kdesrc/extragear-multimedia'
 # > }
 #
 # Parameters:
 #   pathType - Either 'source' or 'build'.
 #
 # Returns:
 #   hash (Not a hashref; See description).
 sub getInstallPathComponents
 {
     my $module = assert_isa(shift, 'ksb::Module');
     my $type = shift;
     my $destdir = $module->destDir();
     my $srcbase = $module->getSourceDir();
     $srcbase = $module->getSubdirPath('build-dir') if $type eq 'build';
 
     my $combined = "$srcbase/$destdir";
 
     # Remove dup //
     $combined =~ s/\/+/\//;
 
     my @parts = split(/\//, $combined);
     my %result = ();
     $result{'module'} = pop @parts;
     $result{'path'} = join('/', @parts);
     $result{'fullpath'} = "$result{path}/$result{module}";
 
     my $compatDestDir = $module->destDir($module->name());
     my $fullCompatPath = "$srcbase/$compatDestDir";
 
     # We used to have code here to migrate very old directory layouts. It was
     # removed as of about 2013-09-29.
 
     return %result;
 }
 
 # Do note that this returns the *base* path to the source directory,
 # without the module name or kde_projects stuff appended. If you want that
 # use subroutine fullpath().
 sub getSourceDir
 {
     my $self = shift;
     return $self->getSubdirPath('source-dir');
 }
 
 sub name
 {
     my $self = shift;
     return $self->{name};
 }
 
 sub scm
 {
     my $self = shift;
 
     return $self->{scm_obj} if $self->{scm_obj};
 
     # Look for specific setting of repository and svn-server. If both is
     # set it's a bug, if one is set, that's the type (because the user says
     # so...). Don't use getOption($key) as it will try to fallback to
     # global options.
 
     my $svn_status = $self->getOption('svn-server', 'module');
     my $repository = $self->getOption('repository', 'module') // '';
     my $rcfile = $self->buildContext()->rcFile();
 
     if ($svn_status && $repository) {
         error (<<EOF);
 You have specified both y[b[svn-server] and y[b[repository] options for the
 b[$self] module in $rcfile.
 
 You should only specify one or the other -- a module cannot be both types
 - svn-server uses Subversion.
 - repository uses git.
 EOF
         die (make_exception('Config', 'svn-server and repository both set'));
     }
 
     # Overload repository to allow bzr URLs?
     if ($repository =~ /^bzr:\/\//) {
         $self->{scm_obj} = ksb::Updater::Bzr->new($self);
     }
 
     # If it needs a repo it's git. Everything else is svn for now.
     $self->{scm_obj} //=
         $repository
             ? ksb::Updater::Git->new($self)
             : ksb::Updater::Svn->new($self);
 
     return $self->{scm_obj};
 }
 
 sub setScmType
 {
     my ($self, $scmType) = @_;
 
     my $newType;
 
     given($scmType) {
         when('git')  { $newType = ksb::Updater::Git->new($self); }
         when('proj') { $newType = ksb::Updater::KDEProject->new($self); }
         when('metadata') { $newType = ksb::Updater::KDEProjectMetadata->new($self); }
         when('l10n') { $newType = ksb::l10nSystem->new($self); }
         when('svn')  { $newType = ksb::Updater::Svn->new($self); }
         when('bzr')  { $newType = ksb::Updater::Bzr->new($self); }
         default      { $newType = undef; }
     }
 
     $self->{scm_obj} = $newType;
 }
 
 # Returns a string describing the scm platform of the given module.
 # Return value: 'git' or 'svn' at this point, as appropriate.
 sub scmType
 {
     my $self = shift;
     return $self->scm()->name();
 }
 
 sub currentScmRevision
 {
     my $self = shift;
 
     return $self->scm()->currentRevisionInternal();
 }
 
 # Returns a new build system object, given the appropriate name.
 # This is a sub-optimal way to fix the problem of allowing users to override
 # the detected build system (we could instead use introspection to figure out
 # available build systems at runtime). However, KISS...
 sub buildSystemFromName
 {
     my ($self, $name) = @_;
     my %buildSystemClasses = (
         'generic'         => 'ksb::BuildSystem',
         'qmake'           => 'ksb::BuildSystem::QMake',
         'cmake-bootstrap' => 'ksb::BuildSystem::CMakeBootstrap',
         'kde'             => 'ksb::BuildSystem::KDE4',
         'qt'              => 'ksb::BuildSystem::Qt4',
         'autotools'       => 'ksb::BuildSystem::Autotools',
     );
 
     my $class = $buildSystemClasses{lc $name} // undef;
     return $class->new($self) if ($class);
 
     # Past here, no class found
     croak_runtime("Invalid build system $name requested");
 }
 
 sub buildSystem
 {
     my $self = shift;
 
     if ($self->{build_obj} && $self->{build_obj}->name() ne 'generic') {
         return $self->{build_obj};
     }
 
     if (my $userBuildSystem = $self->getOption('override-build-system')) {
         $self->{build_obj} = $self->buildSystemFromName($userBuildSystem);
         return $self->{build_obj};
     }
 
     # If not set, let's guess.
     my $buildType;
     my $sourceDir = $self->fullpath('source');
 
     if (($self->getOption('repository') =~ /gitorious\.org\/qt\//) ||
         ($self->getOption('repository') =~ /^kde:qt$/) ||
         (-e "$sourceDir/bin/syncqt"))
     {
         $buildType = ksb::BuildSystem::Qt4->new($self);
     }
 
     # This test must come before the KDE buildsystem's as cmake's own
     # bootstrap system also has CMakeLists.txt
     if (!$buildType && (-e "$sourceDir/CMakeLists.txt") &&
         (-e "$sourceDir/bootstrap"))
     {
         $buildType = ksb::BuildSystem::CMakeBootstrap->new($self);
     }
 
     if (!$buildType && (-e "$sourceDir/CMakeLists.txt" ||
             $self->getOption('#xml-full-path')))
     {
         $buildType = ksb::BuildSystem::KDE4->new($self);
     }
 
     # We have to assign to an array to force glob to return all results,
     # otherwise it acts like a non-reentrant generator whose output depends on
     # how many times it's been called...
     if (!$buildType && (my @files = glob ("$sourceDir/*.pro"))) {
         $buildType = ksb::BuildSystem::QMake->new($self);
     }
 
     # 'configure' is a popular fall-back option even for other build
     # systems so ensure we check last for autotools.
     if (!$buildType &&
         (-e "$sourceDir/configure" || -e "$sourceDir/autogen.sh"))
     {
         $buildType = ksb::BuildSystem::Autotools->new($self);
     }
 
     # Don't just assume the build system is KDE-based...
     $buildType //= ksb::BuildSystem->new($self);
 
     $self->{build_obj} = $buildType;
 
     return $self->{build_obj};
 }
 
 # Sets the build system **object**, although you can find the build system
 # type afterwards (see buildSystemType).
 sub setBuildSystem
 {
     my ($self, $obj) = @_;
 
     assert_isa($obj, 'ksb::BuildSystem');
     $self->{build_obj} = $obj;
 }
 
 # Current possible build system types:
 # KDE (i.e. cmake), Qt, l10n (KDE language buildsystem), autotools (either
 # configure or autogen.sh). A final possibility is 'pendingSource' which
 # simply means that we don't know yet.
 #
 # If the build system type is not set ('pendingSource' counts as being
 # set!) when this function is called then it will be autodetected if
 # possible, but note that not all possible types will be detected this way.
 # If in doubt use setBuildSystemType
 sub buildSystemType
 {
     my $self = shift;
     return $self->buildSystem()->name();
 }
 
 # Subroutine to build this module.
 # Returns boolean false on failure, boolean true on success.
 sub build
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $moduleName = $self->name();
     my %pathinfo = $self->getInstallPathComponents('build');
     my $builddir = $pathinfo{'fullpath'};
     my $buildSystem = $self->buildSystem();
 
     if ($buildSystem->name() eq 'generic' && !pretending()) {
         error ("\tr[b[$self] does not seem to have a build system to use.");
         return 0;
     }
 
     # Ensure we're in a known directory before we start; some options remove
     # the old build directory that a previous module might have been using.
     super_mkdir($pathinfo{'path'});
     p_chdir($pathinfo{'path'});
 
     return 0 if !$self->setupBuildSystem();
     return 1 if $self->getOption('build-system-only');
 
     if (!$buildSystem->buildInternal())
     {
         return 0;
     }
 
     $self->setPersistentOption('last-build-rev', $self->currentScmRevision());
 
     # TODO: This should be a simple phase to run.
     if ($self->getOption('run-tests'))
     {
         $self->buildSystem()->runTestsuite();
     }
 
     # TODO: Likewise this should be a phase to run.
     if ($self->getOption('install-after-build'))
     {
         return 0 if !$self->install();
     }
     else
     {
         info ("\tSkipping install for y[$self]");
     }
 
     return 1;
 }
 
 # Subroutine to setup the build system in a directory.
 # Returns boolean true on success, boolean false (0) on failure.
 sub setupBuildSystem
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $moduleName = $self->name();
 
     my $buildSystem = $self->buildSystem();
 
     if ($buildSystem->name() eq 'generic' && !pretending()) {
         croak_internal('Build system determination still pending when build attempted.');
     }
 
     my $refreshReason = $buildSystem->needsRefreshed();
     if ($refreshReason ne "")
     {
         # The build system needs created, either because it doesn't exist, or
         # because the user has asked that it be completely rebuilt.
         info ("\tPreparing build system for y[$self].");
 
         # Check to see if we're actually supposed to go through the
         # cleaning process.
         if (!$self->getOption('#cancel-clean') &&
             !$buildSystem->cleanBuildSystem())
         {
             warning ("\tUnable to clean r[$self]!");
             return 0;
         }
     }
 
     if (!$buildSystem->createBuildSystem()) {
         error ("\tError creating r[$self]'s build system!");
         return 0;
     }
 
     # Now we're in the checkout directory
     # So, switch to the build dir.
     # builddir is automatically set to the right value for qt
     p_chdir ($self->fullpath('build'));
 
     if (!$buildSystem->configureInternal()) {
         error ("\tUnable to configure r[$self] with " . $self->buildSystemType());
 
         # Add undocumented ".refresh-me" file to build directory to flag
         # for --refresh-build for this module on next run. See also the
         # "needsRefreshed" subroutine.
         if (open my $fh, '>', '.refresh-me') {
             say $fh "# Build directory will be re-generated next kdesrc-build run";
             say $fh "# due to failing to complete configuration on the last run";
             close $fh;
         };
 
         return 0;
     }
 
     return 1;
 }
 
 # Responsible for installing the module (no update, build, etc.)
 # Return value: Boolean flag indicating whether module installed successfully or
 # not.
 # Exceptions may be thrown for abnormal conditions (e.g. no build dir exists)
 sub install
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $builddir = $self->fullpath('build');
     my $buildSysFile = $self->buildSystem()->configuredModuleFileName();
 
     if (!pretending() && ! -e "$builddir/$buildSysFile")
     {
         warning ("\tThe build system doesn't exist for r[$self].");
         warning ("\tTherefore, we can't install it. y[:-(].");
         return 0;
     }
 
     $self->setupEnvironment();
 
     my @makeInstallOpts = split(' ', $self->getOption('make-install-prefix'));
 
     # We can optionally uninstall prior to installing
     # to weed out old unused files.
     if ($self->getOption('use-clean-install') &&
         $self->getPersistentOption('last-install-rev'))
     {
         if (!$self->buildSystem()->uninstallInternal(@makeInstallOpts)) {
             warning ("\tUnable to uninstall r[$self] before installing the new build.");
             warning ("\tContinuing anyways...");
         }
         else {
             $self->unsetPersistentOption('last-install-rev');
         }
     }
 
     if (!$self->buildSystem()->installInternal(@makeInstallOpts))
     {
         error ("\tUnable to install r[$self]!");
         $self->buildContext()->markModulePhaseFailed('install', $self);
         return 0;
     }
 
     if (pretending())
     {
         pretend ("\tWould have installed g[$self]");
         return 1;
     }
 
     # Past this point we know we've successfully installed, for real.
 
     $self->setPersistentOption('last-install-rev', $self->currentScmRevision());
 
     my $remove_setting = $self->getOption('remove-after-install');
 
     # Possibly remove the srcdir and builddir after install for users with
     # a little bit of HD space.
     if($remove_setting eq 'all')
     {
         # Remove srcdir
         my $srcdir = $self->fullpath('source');
         note ("\tRemoving b[r[$self source].");
         safe_rmtree($srcdir);
     }
 
     if($remove_setting eq 'builddir' || $remove_setting eq 'all')
     {
         # Remove builddir
         note ("\tRemoving b[r[$self build directory].");
         safe_rmtree($builddir);
 
         # We're likely already in the builddir, so chdir back to the root
         p_chdir('/');
     }
 
     return 1;
 }
 
 # Handles uninstalling this module (or its sub-directories as given by the checkout-only
 # option).
 #
 # Returns boolean false on failure, boolean true otherwise.
 sub uninstall
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $builddir = $self->fullpath('build');
     my $buildSysFile = $self->buildSystem()->configuredModuleFileName();
 
     if (!pretending() && ! -e "$builddir/$buildSysFile")
     {
         warning ("\tThe build system doesn't exist for r[$self].");
         warning ("\tTherefore, we can't uninstall it.");
         return 0;
     }
 
     $self->setupEnvironment();
 
     my @makeInstallOpts = split(' ', $self->getOption('make-install-prefix'));
 
     if (!$self->buildSystem()->uninstallInternal(@makeInstallOpts))
     {
         error ("\tUnable to uninstall r[$self]!");
         $self->buildContext()->markModulePhaseFailed('install', $self);
         return 0;
     }
 
     if (pretending())
     {
         pretend ("\tWould have uninstalled g[$self]");
         return 1;
     }
 
     $self->unsetPersistentOption('last-install-rev');
     return 1;
 }
 
 sub buildContext
 {
     my $self = shift;
     return $self->{context};
 }
 
 # Integrates 'set-env' option to the build context environment
 sub applyUserEnvironment
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $ctx = $self->buildContext();
 
     # Let's see if the user has set env vars to be set.
     # Note the global set-env must be checked separately anyways, so
     # we limit inheritance when searching.
     my $env_hash_ref = $self->getOption('set-env', 'module');
 
     while (my ($key, $value) = each %{$env_hash_ref})
     {
         $ctx->queueEnvironmentVariable($key, $value);
     }
 }
 
 # Establishes proper build environment in the build context. Should be run
 # before forking off commands for e.g. updates, builds, installs, etc.
 sub setupEnvironment
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $ctx = $self->buildContext();
     my $kdedir = $self->getOption('kdedir');
     my $prefix = $self->installationPath();
 
     # Add global set-envs and context
     $self->buildContext()->applyUserEnvironment();
 
     # Avoid moving /usr up in env vars
     if ($kdedir ne '/usr') {
         my @pkg_config_dirs = ("$kdedir/lib/pkgconfig");
         $ctx->prependEnvironmentValue('PKG_CONFIG_PATH', @pkg_config_dirs);
 
         my @ld_dirs = ("$kdedir/lib", $self->getOption('libpath'));
         $ctx->prependEnvironmentValue('LD_LIBRARY_PATH', @ld_dirs);
 
         my @path = ("$kdedir/bin", $self->getOption('binpath'));
         $ctx->prependEnvironmentValue('PATH', @path);
     }
 
     # Build system's environment injection
     my $buildSystem = $self->buildSystem();
     $buildSystem->prepareModuleBuildEnvironment($ctx, $self, $prefix);
 
     # Read in user environment defines
     $self->applyUserEnvironment() unless $self == $ctx;
 }
 
 # Returns the path to the log directory used during this run for this
-# ksb::Module.
-#
-# In addition it handles the 'latest' symlink to allow for ease of access
-# to the log directory afterwards.
+# ksb::Module, based on an autogenerated unique id. The id doesn't change
+# once generated within a single run of the script.
 sub getLogDir
 {
     my ($self) = @_;
     return $self->buildContext()->getLogDirFor($self);
 }
 
+# Returns a full path that can be open()'d to write a log
+# file, based on the given basename (with extension).
+# Updates the 'latest' symlink as well, unlike getLogDir
+# Use when you know you're going to create a new log
+sub getLogPath
+{
+    my ($self, $path) = @_;
+    return $self->buildContext()->getLogPathFor($self, $path);
+}
+
 sub toString
 {
     my $self = shift;
     return $self->name();
 }
 
 sub compare
 {
     my ($self, $other) = @_;
     return $self->name() cmp $other->name();
 }
 
 sub update
 {
     my ($self, $ipc, $ctx) = @_;
 
     my $moduleName = $self->name();
     my $module_src_dir = $self->getSourceDir();
     my $kdesrc = $ctx->getSourceDir();
 
     if ($kdesrc ne $module_src_dir)
     {
         # This module has a different source directory, ensure it exists.
         if (!super_mkdir($module_src_dir))
         {
             error ("Unable to create separate source directory for r[$self]: $module_src_dir");
             $ipc->sendIPCMessage(ksb::IPC::MODULE_FAILURE, $moduleName);
             next;
         }
     }
 
     my $fullpath = $self->fullpath('source');
     my $count;
     my $returnValue;
 
     eval { $count = $self->scm()->updateInternal($ipc) };
 
     if ($@)
     {
         my $reason = ksb::IPC::MODULE_FAILURE;
 
         if (had_an_exception()) {
             if ($@->{'exception_type'} eq 'ConflictPresent') {
                 $reason = ksb::IPC::MODULE_CONFLICT;
             }
             else {
                 $ctx->markModulePhaseFailed('build', $self);
             }
 
             $@ = $@->{'message'};
         }
 
         error ("Error updating r[$self], removing from list of packages to build.");
         error (" > y[$@]");
 
         $ipc->sendIPCMessage($reason, $moduleName);
         $self->phases()->filterOutPhase('build');
         $returnValue = 0;
     }
     else
     {
         my $message;
         if (not defined $count)
         {
             $message = ksb::Debug::colorize ("b[y[Unknown changes].");
             $ipc->notifyUpdateSuccess($moduleName, $message);
         }
         elsif ($count)
         {
             $message = "1 file affected." if $count == 1;
             $message = "$count files affected." if $count != 1;
             $ipc->notifyUpdateSuccess($moduleName, $message);
         }
         else
         {
             $message = "0 files affected.";
             my $refreshReason = $self->buildSystem()->needsRefreshed();
 
             $ipc->sendIPCMessage(ksb::IPC::MODULE_UPTODATE, "$moduleName,$refreshReason");
         }
 
         # We doing e.g. --src-only, the build phase that normally outputs
         # number of files updated doesn't get run, so manually mention it
         # here.
         if (!$ipc->supportsConcurrency()) {
             info ("\t$self update complete, $message");
         }
 
         $returnValue = 1;
     }
 
     info (""); # Print empty line.
     return $returnValue;
 }
 
 # OVERRIDE
 #
 # This calls OptionsBase::setOption and performs any Module-specific
 # handling.
 sub setOption
 {
     my ($self, %options) = @_;
 
     # Ensure we don't accidentally get fed module-set options
     for (qw(git-repository-base use-modules ignore-modules)) {
         if (exists $options{$_}) {
             error (" r[b[*] module b[$self] should be declared as module-set to use b[$_]");
             die ksb::BuildException::Config->new($_, "Option $_ can only be used in module-set");
         };
     }
 
     # Special case handling.
     if (exists $options{'filter-out-phases'}) {
         for my $phase (split(' ', $options{'filter-out-phases'})) {
             $self->phases()->filterOutPhase($phase);
         }
         delete $options{'filter-out-phases'};
     }
 
     $self->SUPER::setOption(%options);
 }
 
 # OVERRIDE
 #
 # This subroutine returns an option value for a given module.  Some globals
 # can't be overridden by a module's choice (but see 2nd parameter below).
 # If so, the module's choice will be ignored, and a warning will be issued.
 #
 # Option names are case-sensitive!
 #
 # Some options (e.g. cmake-options, configure-flags) have the global value
 # and then the module's own value appended together. To get the actual
 # module setting you must use the level limit parameter set to 'module'.
 #
 # Likewise, some qt module options do not obey the previous proviso since
 # Qt options are not likely to agree nicely with generic KDE buildsystem
 # options.
 #
 # 1st parameter: Name of option
 # 2nd parameter: Level limit (optional). If not present, then the value
 # 'allow-inherit' is used. Options:
 #   - allow-inherit: Module value is used if present (with exceptions),
 #     otherwise global is used.
 #   - module: Only module value is used (if you want only global then use the
 #     buildContext) NOTE: This overrides global "sticky" options as well!
 sub getOption
 {
     my ($self, $key, $levelLimit) = @_;
     my $ctx = $self->buildContext();
     $levelLimit //= 'allow-inherit';
 
     # Some global options would probably make no sense applied to Qt.
     my @qtCopyOverrides = qw(branch configure-flags tag cxxflags);
     if (list_has(\@qtCopyOverrides, $key) && $self->buildSystemType() eq 'Qt') {
         $levelLimit = 'module';
     }
 
     assert_in($levelLimit, [qw(allow-inherit module)]);
 
     # If module-only, check that first.
     return $self->{options}{$key} if $levelLimit eq 'module';
 
     # Some global options always override module options.
     return $ctx->getOption($key) if $ctx->hasStickyOption($key);
 
     # Some options append to the global (e.g. conf flags)
     my @confFlags = qw(cmake-options configure-flags cxxflags);
     if (list_has(\@confFlags, $key) && $ctx->hasOption($key)) {
         return $ctx->getOption($key) . " " . ($self->{options}{$key} || '');
     }
 
     # Everything else overrides the global option, unless it's simply not
     # set at all.
     return $self->{options}{$key} // $ctx->getOption($key);
 }
 
 # Gets persistent options set for this module. First parameter is the name
 # of the option to lookup. Undef is returned if the option is not set,
 # although even if the option is set, the value returned might be empty.
 # Note that ksb::BuildContext also has this function, with a slightly
 # different signature, which OVERRIDEs this function since Perl does not
 # have parameter-based method overloading.
 sub getPersistentOption
 {
     my ($self, $key) = @_;
     return $self->buildContext()->getPersistentOption($self->name(), $key);
 }
 
 # Sets a persistent option (i.e. survives between processes) for this module.
 # First parameter is the name of the persistent option.
 # Second parameter is its actual value.
 # See the warning for getPersistentOption above, it also applies for this
 # method vs. ksb::BuildContext::setPersistentOption
 sub setPersistentOption
 {
     my ($self, $key, $value) = @_;
     return $self->buildContext()->setPersistentOption($self->name(), $key, $value);
 }
 
 # Unsets a persistent option for this module.
 # Only parameter is the name of the option to unset.
 sub unsetPersistentOption
 {
     my ($self, $key) = @_;
     $self->buildContext()->unsetPersistentOption($self->name(), $key);
 }
 
 # Returns the path to the desired directory type (source or build),
 # including the module destination directory itself.
 sub fullpath
 {
     my ($self, $type) = @_;
     assert_in($type, [qw/build source/]);
 
     my %pathinfo = $self->getInstallPathComponents($type);
     return $pathinfo{'fullpath'};
 }
 
 # Returns the "full kde-projects path" for the module. As should be obvious by
 # the description, this only works for modules with an scm type that is a
 # Updater::KDEProject (or its subclasses).
 sub fullProjectPath
 {
     my $self = shift;
     my $path = $self->getOption('#xml-full-path', 'module') ||
         croak_internal("Tried to ask for full path of a module $self that doesn't have one!");
 
     return $path;
 }
 
 # Returns true if this module is (or was derived from) a kde-projects module.
 sub isKDEProject
 {
     my $self = shift;
     return $self->hasOption('#xml-full-path');
 }
 
 # Subroutine to return the name of the destination directory for the
 # checkout and build routines.  Based on the dest-dir option.  The return
 # value will be relative to the src/build dir.  The user may use the
 # '$MODULE' or '${MODULE}' sequences, which will be replaced by the name of
 # the module in question.
 #
 # The first parameter is optional, but if provided will be used as the base
 # path to replace $MODULE entries in dest-dir.
 sub destDir
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $destDir = $self->getOption('dest-dir');
 
     my $basePath = "";
 
     if ($self->getOption('ignore-kde-structure')) {
         $basePath = $self->name();
     } else {
         $basePath = shift // $self->getOption('#xml-full-path');
         $basePath ||= $self->name(); # Default if not provided in repo-metadata
     }
 
     $destDir =~ s/(\$\{MODULE})|(\$MODULE\b)/$basePath/g;
 
     return $destDir;
 }
 
 # Subroutine to return the installation path of a given module (the value
 # that is passed to the CMAKE_INSTALL_PREFIX CMake option).
 # It is based on the "prefix" and, if it is not set, the "kdedir" option.
 # The user may use '$MODULE' or '${MODULE}' in the "prefix" option to have
 # them replaced by the name of the module in question.
 sub installationPath
 {
     my $self = assert_isa(shift, 'ksb::Module');
     my $path = $self->getOption('prefix');
 
     if (!$path)
     {
         return $self->getOption('kdedir');
     }
 
     my $moduleName = $self->name();
     $path =~ s/(\$\{MODULE})|(\$MODULE\b)/$moduleName/g;
 
     return $path;
 }
 
 1;
diff --git a/modules/ksb/Util.pm b/modules/ksb/Util.pm
index 5331fdd..d1eaaa9 100644
--- a/modules/ksb/Util.pm
+++ b/modules/ksb/Util.pm
@@ -1,766 +1,764 @@
 package ksb::Util 0.20;
 
 # Useful utilities, which are exported into the calling module's namespace by default.
 
 use 5.014; # Needed for state keyword
 use strict;
 use warnings;
 
 use Carp qw(cluck);
 use Scalar::Util qw(blessed);
 use File::Path qw(make_path);
 use File::Find;
 use Cwd qw(getcwd);
 use Errno qw(:POSIX);
 use Digest::MD5;
 use HTTP::Tiny;
 
 use ksb::Debug;
 use ksb::Version qw(scriptVersion);
 use ksb::BuildException;
 
 use Exporter qw(import); # Use Exporter's import method
 our @EXPORT = qw(list_has assert_isa assert_in any unique_items
                  croak_runtime croak_internal had_an_exception make_exception
                  download_file absPathToExecutable
                  fileDigestMD5 log_command disable_locale_message_translation
                  split_quoted_on_whitespace safe_unlink safe_system p_chdir
                  pretend_open safe_rmtree get_list_digest is_dir_empty
                  super_mkdir filter_program_output prettify_seconds);
 
 # Function to work around a Perl language limitation.
 # First parameter is a reference to the list to search. ALWAYS.
 # Second parameter is the value to search for.
 # Returns true if the value is in the list
 sub list_has
 {
     my ($listRef, $value) = @_;
     my @list = @{$listRef};
 
     return scalar grep { "$_" eq "$value" } (@list);
 }
 
 # Subroutine to return the path to the given executable based on the
 # current PATH.  e.g. if you pass make you could get '/usr/bin/make'.  If
 # the executable is not found undef is returned.
 #
 # This assumes that the module environment has already been updated since
 # binpath doesn't exactly correspond to $ENV{'PATH'}.
 sub absPathToExecutable
 {
     my $prog = shift;
     my @paths = split(/:/, $ENV{'PATH'});
 
     # If it starts with a / the path is already absolute.
     return $prog if $prog =~ /^\//;
 
     for my $path (@paths)
     {
         return "$path/$prog" if (-x "$path/$prog");
     }
 
     return undef;
 }
 
 # Returns a Perl object worth "die"ing for. (i.e. can be given to the die
 # function and handled appropriately later with an eval). The returned
 # reference will be an instance of ksb::BuildException. The actual exception
 # type is passed in as the first parameter (as a string), and can be retrieved
 # from the object later using the 'exception_type' key, and the message is
 # returned as 'message'
 #
 # First parameter: Exception type. Recommended are one of: Config, Internal
 # (for logic errors), Runtime (other runtime errors which are not logic
 # bugs in kdesrc-build), or just leave blank for 'Exception'.
 # Second parameter: Message to show to user
 # Return: Reference to the exception object suitable for giving to "die"
 sub make_exception
 {
     my $exception_type = shift // 'Exception';
     my $message = shift;
     my $levels = shift // 0; # Allow for more levels to be removed from bt
 
     # Remove this subroutine from the backtrace
     local $Carp::CarpLevel = 1 + $levels;
 
     $message = Carp::cluck($message) if $exception_type eq 'Internal';
     return ksb::BuildException->new($exception_type, $message);
 }
 
 # Helper function to return $@ if $@ is a ksb::BuildException.
 #
 # This function assumes that an eval block had just been used in order to set or
 # clear $@ as appropriate.
 sub had_an_exception
 {
     if ($@ && ref $@ && $@->isa('ksb::BuildException')) {
         return $@;
     }
 
     return;
 }
 
 # Should be used for "runtime errors" (i.e. unrecoverable runtime problems that
 # don't indicate a bug in the program itself).
 sub croak_runtime
 {
     die (make_exception('Runtime', $_[0], 1));
 }
 
 # Should be used for "logic errors" (i.e. impossibilities in program state, things
 # that shouldn't be possible no matter what input is fed at runtime)
 sub croak_internal
 {
     die (make_exception('Internal', $_[0], 1));
 }
 
 # Throws an exception if the first parameter is not an object at all, or if
 # it is not an object of the type given by the second parameter (which
 # should be a string of the class name. There is no return value;
 sub assert_isa
 {
     my ($obj, $class) = @_;
 
     if (!blessed($obj) || !$obj->isa($class)) {
         croak_internal("$obj is not of type $class, but of type " . ref($obj));
     }
 
     return $obj;
 }
 
 # Throws an exception if the first parameter is not included in the
 # provided list of possible alternatives. The list of alternatives must
 # be passed as a reference, as the second parameter.
 sub assert_in
 {
     my ($val, $listRef) = @_;
 
     if (!list_has($listRef, $val)) {
         croak_runtime("$val is not a permissible value for its argument");
     }
 
     return $val;
 }
 
 # Subroutine to unlink the given symlink if global-pretend isn't set.
 sub safe_unlink
 {
     if (pretending())
     {
         pretend ("\tWould have unlinked ", shift, ".");
         return 1; # Return true
     }
 
     return unlink (shift);
 }
 
 # Subroutine to execute the system call on the given list if the pretend
 # global option is not set.
 #
 # Returns the shell error code, so 0 means success, non-zero means failure.
 sub safe_system(@)
 {
     if (!pretending())
     {
         whisper ("\tExecuting g['", join("' '", @_), "'");
         return system (@_) >> 8;
     }
 
     pretend ("\tWould have run g['" . join("' '", @_) . "'");
     return 0; # Return true
 }
 
 # Is exactly like "chdir", but it will also print out a message saying that
 # we're switching to the directory when debugging.
 sub p_chdir($)
 {
     my $dir = shift;
     debug ("\tcd g[$dir]\n");
 
     chdir ($dir) or do {
         return 1 if pretending();
         croak_runtime("Could not change to directory $dir: $!");
     };
 }
 
 # Helper subroutine to create a directory, including any parent
 # directories that may also need created.
 # Throws an exception on failure. See File::Path.
 sub super_mkdir
 {
     my $pathname = shift;
     state %createdPaths;
 
     if (pretending()) {
         if (!exists $createdPaths{$pathname} && ! -e $pathname) {
             pretend ("\tWould have created g[$pathname]");
         }
 
         $createdPaths{$pathname} = 1;
         return 1;
     }
     else {
         make_path($pathname);
         return (-e $pathname) ? 1 : 0;
     }
 }
 
 # Calculates the MD5 digest of a file already on-disk. The digest is
 # returned as a hex string digest as from Digest::MD5::md5_hex
 #
 # First parameter: File name to read
 # Return value: hex string MD5 digest of file.
 # An exception is thrown if an error occurs reading the file.
 sub fileDigestMD5
 {
     my $fileName = shift;
     my $md5 = Digest::MD5->new;
 
     open my $file, '<', $fileName or croak_runtime(
         "Unable to open $fileName: $!");
     binmode($file);
 
     $md5->addfile($file);
     return $md5->hexdigest();
 }
 
 # This function is intended to disable the message translation catalog
 # settings in the program environment, so that any child processes executed
 # will have their output untranslated (and therefore scrapeable).
 #
 # As such this should only be called for a forked child about to exec as
 # there is no easy way to undo this within the process.
 sub disable_locale_message_translation
 {
     # Ensure that program output is untranslated by setting 'C' locale.
     # We're really trying to affect the LC_MESSAGES locale category, but
     # LC_ALL is a catch-all for that (so needs to be unset if set).
     #
     # Note that the ONLY SUPPORTED way to pass file names, command-line
     # args, etc. to commands is under the UTF-8 encoding at this point, as
     # that is the only sane way for this en_US-based developer to handle
     # the task.  Patches (likely using Encode::Locale) are accepted. :P
 
     $ENV{'LC_MESSAGES'} = 'C';
     if ($ENV{'LC_ALL'}) {
         $ENV{'LANG'} = $ENV{'LC_ALL'}; # This is lower-priority "catch all"
         delete $ENV{'LC_ALL'};
     }
 }
 
 # Returns an array of lines output from a program.  Use this only if you
 # expect that the output will be short.
 #
 # Since there is no way to disambiguate no output from an error, this
 # function will call die on error, wrap in eval if this bugs you.
 #
 # First parameter is subroutine reference to use as a filter (this sub will
 # be passed a line at a time and should return true if the line should be
 # returned).  If no filtering is desired pass 'undef'.
 #
 # Second parameter is the program to run (either full path or something
 # accessible in $PATH).
 #
 # All remaining arguments are passed to the program.
 #
 # Return value is an array of lines that were accepted by the filter.
 sub filter_program_output
 {
     my ($filterRef, $program, @args) = @_;
     $filterRef //= sub { return 1 }; # Default to all lines
 
     debug ("Slurping '$program' '", join("' '", @args), "'");
 
     # Check early for whether an executable exists since otherwise
     # it is possible for our fork-open below to "succeed" (i.e. fork()
     # happens OK) and then fail when it gets to the exec(2) syscall.
     if (!absPathToExecutable($program)) {
         croak_runtime("Can't find $program in PATH!");
     }
 
     my $execFailedError = "\t - kdesrc-build - exec failed!\n";
     my $pid = open(my $childOutput, '-|');
     croak_internal("Can't fork: $!") if ! defined($pid);
 
     if ($pid) {
         # parent
         my @lines = grep { &$filterRef; } (<$childOutput>);
         close $childOutput or do {
             # $! indicates a rather grievous error
             croak_internal("Unable to open pipe to read $program output: $!") if $!;
 
             # we can pass serious errors back to ourselves too.
             my $exitCode = $? >> 8;
             if ($exitCode == 99 && @lines >= 1 && $lines[0] eq $execFailedError) {
                 croak_runtime("Failed to exec $program, is it installed?");
             }
 
             # other errors might still be serious but don't need a backtrace
             if (pretending()) {
                 whisper ("$program gave error exit code $exitCode");
             } else {
                 warning ("$program gave error exit code $exitCode");
             }
         };
 
         return @lines;
     }
     else {
         disable_locale_message_translation();
 
         # We don't want stderr output on tty.
         open (STDERR, '>', '/dev/null') or close (STDERR);
 
         exec { $program } ($program, @args) or do {
             # Send a message back to parent
             print $execFailedError;
             exit 99; # Helper proc, so don't use finish(), just die
         };
     }
 }
 
 # Subroutine to return a string suitable for displaying an elapsed time,
 # (like a stopwatch) would.  The first parameter is the number of seconds
 # elapsed.
 sub prettify_seconds
 {
     my $elapsed = $_[0];
     my $str = "";
     my ($days,$hours,$minutes,$seconds,$fraction);
 
     $fraction = int (100 * ($elapsed - int $elapsed));
     $elapsed = int $elapsed;
 
     $seconds = $elapsed % 60;
     $elapsed = int $elapsed / 60;
 
     $minutes = $elapsed % 60;
     $elapsed = int $elapsed / 60;
 
     $hours = $elapsed % 24;
     $elapsed = int $elapsed / 24;
 
     $days = $elapsed;
 
     $seconds = "$seconds.$fraction" if $fraction;
 
     my @str_list;
 
     for (qw(days hours minutes seconds))
     {
         # Use a symbolic reference without needing to disable strict refs.
         # I couldn't disable it even if I wanted to because these variables
         # aren't global or localized global variables.
         my $value = eval "return \$$_;";
         my $text = $_;
         $text =~ s/s$// if $value == 1; # Make singular
 
         push @str_list, "$value $text" if $value or $_ eq 'seconds';
     }
 
     # Add 'and ' in front of last element if there was more than one.
     push @str_list, ("and " . pop @str_list) if (scalar @str_list > 1);
 
     $str = join (", ", @str_list);
 
     return $str;
 }
 
 # Subroutine to mark a file as being the error log for a module.  This also
 # creates a symlink in the module log directory for easy viewing.
 # First parameter is the module in question.
 # Second parameter is the filename in the log directory of the error log.
 sub _setErrorLogfile
 {
     my $module = assert_isa(shift, 'ksb::Module');
     my $logfile = shift;
 
     return unless $logfile;
 
     my $logdir = $module->getLogDir();
 
     $module->setOption('#error-log-file', "$logdir/$logfile");
     debug ("Logfile for $module is $logfile");
 
     # Setup symlink in the module log directory pointing to the appropriate
     # file.  Make sure to remove it first if it already exists.
     unlink("$logdir/error.log") if -l "$logdir/error.log";
 
     if(-e "$logdir/error.log")
     {
         # Maybe it was a regular file?
         error ("r[b[ * Unable to create symlink to error log file]");
         return;
     }
 
     symlink "$logfile", "$logdir/error.log";
 }
 
 
 # Subroutine to run a command, optionally filtering on the output of the child
 # command.
 #
 # First parameter is the module object being built (for logging purposes
 #   and such).
 # Second parameter is the name of the log file to use (relative to the log
 #   directory).
 # Third parameter is a reference to an array with the command and its
 #   arguments.  i.e. ['command', 'arg1', 'arg2']
 #
 # After the required three parameters you can pass a hash reference of
 # optional features:
 #   'callback' => a reference to a subroutine to have each line
 #   of child output passed to.  This output is not supposed to be printed
 #   to the screen by the subroutine, normally the output is only logged.
 #   However this is useful for e.g. munging out the progress of the build.
 #   USEFUL: When there is no more output from the child, the callback will be
 #     called with an undef string.  (Not just empty, it is also undefined).
 #
 #   'no_translate' => any true value will cause a flag to be set to request
 #   the executed child process to not translate (for locale purposes) its
 #   output, so that it can be screen-scraped.
 #
 # The return value is the shell return code, so 0 is success, and non-zero is
 #   failure.
 #
 # NOTE: This function has a special feature.  If the command passed into the
 #   argument reference is 'kdesrc-build', then log_command will, when it
 #   forks, execute the subroutine named by the second parameter rather than
 #   executing a child process.  The subroutine should include the full package
 #   name as well (otherwise the package containing log_command's implementation
 #   is used).  The remaining arguments in the list are passed to the
 #   subroutine that is called.
 sub log_command
 {
     my ($module, $filename, $argRef, $optionsRef) = @_;
     assert_isa($module, 'ksb::Module');
     my @command = @{$argRef};
 
     $optionsRef //= { };
     my $callbackRef = $optionsRef->{'callback'};
 
     debug ("log_command(): Module $module, Command: ", join(' ', @command));
 
     if (pretending())
     {
         pretend ("\tWould have run g['" . join ("' '", @command) . "'");
         return 0;
     }
 
+    # Do this before we fork so we can see errors
+    my $logpath = $module->getLogPath("$filename.log");
+
     # Fork a child, with its stdout connected to CHILD.
     my $pid = open(CHILD, '-|');
     if ($pid)
     {
         # Parent
         if (!$callbackRef && debugging()) {
             # If no other callback given, pass to debug() if debug-mode is on.
             while (<CHILD>) {
                 print ($_) if $_;
             }
         }
 
         if ($callbackRef) {
             &{$callbackRef}($_) while (<CHILD>);
 
             # Let callback know there is no more output.
             &{$callbackRef}(undef);
         }
 
         # This implicitly does a waitpid() as well
         close CHILD or do {
             if ($! == 0) {
                 _setErrorLogfile($module, "$filename.log");
                 return $?;
             }
 
             return 1;
         };
 
         return 0;
     }
     else
     {
         # Child. Note here that we need to avoid running our exit cleanup
         # handlers in here. For that we need POSIX::_exit.
 
         # Apply altered environment variables.
         $module->buildContext()->commitEnvironmentChanges();
 
-        my $logdir = $module->getLogDir();
-        if (!$logdir || ! -e $logdir)
-        {
-            # Error creating directory for some reason.
-            error ("\tLogging to std out due to failure creating log dir.");
-        }
-
         $SIG{PIPE} = "IGNORE";
         $SIG{INT} = sub {
             close (STDOUT); # This should be a pipe
             close (STDERR);
             POSIX::_exit(EINTR);
         };
 
         # Redirect STDIN to /dev/null so that the handle is open but fails when
         # being read from (to avoid waiting forever for e.g. a password prompt
         # that the user can't see.
 
         open (STDIN, '<', "/dev/null") unless exists $ENV{'KDESRC_BUILD_USE_TTY'};
         if ($callbackRef || debugging()) {
-            open (STDOUT, "|tee $logdir/$filename.log") or do {
+            open (STDOUT, "|tee $logpath") or do {
                 error ("Error opening pipe to tee command.");
                 # Don't abort, hopefully STDOUT still works.
             };
         }
         else {
-            open (STDOUT, '>', "$logdir/$filename.log");
+            open (STDOUT, '>', $logpath) or do {
+                error ("Error $! opening log to $logpath!");
+            };
         }
 
         # Make sure we log everything.
         open (STDERR, ">&STDOUT");
 
         # Call internal function, name given by $command[1]
         if ($command[0] eq 'kdesrc-build')
         {
             # No colors!
             ksb::Debug::setColorfulOutput(0);
             debug ("Calling $command[1]");
 
             my $cmd = $command[1];
             splice (@command, 0, 2); # Remove first two elements.
 
             no strict 'refs'; # Disable restriction on symbolic subroutines.
             if (! &{$cmd}(@command)) # Call sub
             {
                 POSIX::_exit (EINVAL);
             }
 
             POSIX::_exit (0); # Exit child process successfully.
         }
 
         # Don't leave empty output files, give an indication of the particular
         # command run. Use print to go to stdout.
         say "# kdesrc-build running: '", join("' '", @command), "'";
         say "# from directory: ", getcwd();
 
         # If a callback is set assume no translation can be permitted.
         disable_locale_message_translation() if $optionsRef->{'no_translate'};
 
         # External command.
         exec (@command) or do {
             my $cmd_string = join(' ', @command);
             error (<<EOF);
 r[b[Unable to execute "$cmd_string"]!
 $!
 
 Please check your binpath setting (it controls the PATH used by kdesrc-build).
 Currently it is set to g[$ENV{PATH}].
 EOF
             # Don't use return, this is the child still!
             POSIX::_exit (1);
         };
     }
 }
 
 # This subroutine acts like split(' ', $_) except that double-quoted strings
 # are not split in the process.
 #
 # First parameter: String to split on whitespace.
 # Return value: A list of the individual words and quoted values in the string.
 # The quotes themselves are not returned.
 sub split_quoted_on_whitespace
 {
     use Text::ParseWords qw(parse_line);
     my $line = shift;
 
     # Remove leading/trailing whitespace
     $line =~ s/^\s+//;
     $line =~ s/\s+$//;
 
     # 0 means not to keep delimiters or quotes
     return parse_line('\s+', 0, $line);
 }
 
 # This subroutine downloads the file pointed to by the URL given in the
 # first parameter, saving to the given filename.  (FILENAME, not
 # directory). HTTP and HTTPS are supported, using Perl's built-in HTTP::Tiny (and for
 # HTTPS, IO::Socket::SSL must also be installed)
 #
 # First parameter: URL of link to download (i.e. https://kdesrc-build.kde.org/foo.tbz2)
 # Second parameter: Filename to save as (i.e. $ENV{HOME}/blah.tbz2)
 # Third parameter: URL of a proxy to use (undef or empty means proxy as set in environment)
 # Return value is 0 for failure, non-zero for success.
 sub download_file
 {
     my ($url, $filename, $proxy) = @_;
 
     my $scriptVersion = scriptVersion();
     my %opts = (
         # Trailing space adds lib version info
         agent => "kdesrc-build/$scriptVersion ",
         timeout => 30,
     );
 
     if ($proxy) {
         whisper ("Using proxy $proxy for HTTP downloads");
         $opts{proxy} = $proxy;
     }
 
     my $http_client = HTTP::Tiny->new(%opts);
 
     whisper ("Downloading g[$filename] from g[$url]");
     my $response = $http_client->mirror($url, $filename);
 
     return 1 if $response->{success};
 
     $response->{reason} .= " $response->{content}" if $response->{status} == 599;
     error ("Failed to download y[b[$url] to b[$filename]");
     error ("Result was: y[b[$response->{status} $response->{reason}]");
 
     return 0;
 }
 
 # Function: pretend_open
 #
 # Opens the given file and returns a filehandle to it if the file actually
 # exists or the script is not in pretend mode. If the script is in pretend mode
 # and the file is not already present then an open filehandle to an empty
 # string is returned.
 #
 # Parameters:
 #  filename - Path to the file to open.
 #  default  - String to use if the file doesn't exist in pretend mode
 #
 # Returns:
 #  filehandle on success (supports readline() and eof()), can return boolean
 #  false if there is an error opening an existing file (or if the file doesn't
 #  exist when not in pretend mode)
 sub pretend_open
 {
     my $path = shift;
     my $defaultText = shift // '';
     my $fh;
 
     if (pretending() && ! -e $path) {
         open $fh, '<', \$defaultText or return;
     }
     else {
         open $fh, '<', $path or return;
     }
 
     return $fh;
 }
 
 # Returns true if the given sub returns true for any item in the given listref.
 sub any(&@)
 {
     my ($subRef, $listRef) = @_;
     ($subRef->($_) && return 1) foreach @{$listRef};
     return 0;
 }
 
 # Returns unique items of the list. Order not guaranteed.
 sub unique_items
 {
     # See perlfaq4
     my %seen;
     my @results = grep { ! $seen{$_}++; } @_;
     return @results;
 }
 
 # Subroutine to delete a directory and all files and subdirectories within.
 # Does nothing in pretend mode.  An analogue to "rm -rf" from Linux.
 # Requires File::Find module.
 #
 # First parameter: Path to delete
 # Returns boolean true on success, boolean false for failure.
 sub safe_rmtree
 {
     my $path = shift;
 
     # Pretty user-visible path
     my $user_path = $path;
     $user_path =~ s/^$ENV{HOME}/~/;
 
     my $delete_file_or_dir = sub {
         # $_ is the filename/dirname.
         return if $_ eq '.' or $_ eq '..';
         if (-f $_ || -l $_)
         {
             unlink ($_) or croak_runtime("Unable to delete $File::Find::name: $!");
         }
         elsif (-d $_)
         {
             rmdir ($File::Find::name) or
                 croak_runtime("Unable to remove directory $File::Find::name: $!");
         }
     };
 
     if (pretending())
     {
         pretend ("Would have removed all files/folders in $user_path");
         return 1;
     }
 
     # Error out because we probably have a logic error even though it would
     # delete just fine.
     if (not -d $path)
     {
         error ("Cannot recursively remove $user_path, as it is not a directory.");
         return 0;
     }
 
     eval {
         $@ = '';
         finddepth( # finddepth does a postorder traversal.
         {
             wanted => $delete_file_or_dir,
             no_chdir => 1, # We'll end up deleting directories, so prevent this.
         }, $path);
     };
 
     if ($@)
     {
         error ("Unable to remove directory $user_path: $@");
         return 0;
     }
 
     return 1;
 }
 
 # Returns a hash digest of the given options in the list.  The return value is
 # base64-encoded at this time.
 #
 # Note: Don't be dumb and pass data that depends on execution state as the
 # returned hash is almost certainly not useful for whatever you're doing with
 # it.  (i.e. passing a reference to a list is not helpful, pass the list itself)
 #
 # Parameters: List of scalar values to hash.
 # Return value: base64-encoded hash value.
 sub get_list_digest
 {
     use Digest::MD5 "md5_base64"; # Included standard with Perl 5.8
 
     return md5_base64(@_);
 }
 
 # Utility function to see if a directory path is empty or not
 sub is_dir_empty
 {
     my $dir = shift;
 
     opendir my $dirh, $dir or return;
 
     # while-readdir needs Perl 5.12
     while (readdir $dirh) {
         next if ($_ eq '.' || $_ eq '..');
 
         closedir ($dirh);
         return; # not empty
     }
 
     closedir ($dirh);
     return 1;
 }
 
 1;