{
                  auto notificationSenderQueue_(notificationSenderQueue.lock());
                  notificationSenderQueue_->push(NotificationItem{NotificationItem::Type::Started, build->id});
              }
              notificationSenderWakeup.notify_one();

              enqueueNotificationItem({NotificationItem::Type::BuildStarted, build->id});

    int stepNr = 0;

    unsigned int stepNr = 0;

            logCompressorQueue_->push(result.logFile);

            assert(stepNr);
            logCompressorQueue_->push({build->id, stepNr, result.logFile});

        for (auto id : buildIDs) {
            {
                auto notificationSenderQueue_(notificationSenderQueue.lock());
                notificationSenderQueue_->push(NotificationItem{NotificationItem::Type::Finished, id});
            }
            notificationSenderWakeup.notify_one();
        }

        for (auto id : buildIDs)
            enqueueNotificationItem({NotificationItem::Type::BuildFinished, id});

            notificationSenderQueue_->push(NotificationItem{NotificationItem::Type::Finished, build->id, dependentIDs});

            notificationSenderQueue_->push(NotificationItem{NotificationItem::Type::BuildFinished, build->id, dependentIDs});

int State::allocBuildStep(pqxx::work & txn, Build::ptr build)

unsigned int State::allocBuildStep(pqxx::work & txn, Build::ptr build)

int State::createBuildStep(pqxx::work & txn, time_t startTime, Build::ptr build, Step::ptr step,

unsigned int State::createBuildStep(pqxx::work & txn, time_t startTime, Build::ptr build, Step::ptr step,

    int stepNr = allocBuildStep(txn, build);

    unsigned int stepNr = allocBuildStep(txn, build);

    BuildID buildId, int stepNr, const std::string & machine, BuildStatus status,

    BuildID buildId, unsigned int stepNr, const std::string & machine, BuildStatus status,

            Path logPath;

            CompressionItem item;

                logPath = logCompressorQueue_->front();

                item = logCompressorQueue_->front();

            if (!pathExists(logPath)) continue;

            if (!pathExists(item.logPath)) continue;

            printMsg(lvlChatty, format("compressing log file ‘%1%’") % logPath);

            printMsg(lvlChatty, format("compressing log file ‘%1%’") % item.logPath);

            Path tmpPath = logPath + ".bz2.tmp";

            Path dstPath = item.logPath + ".bz2";
            Path tmpPath = dstPath + ".tmp";

                execlp("bzip2", "bzip2", "-c", logPath.c_str(), nullptr);

                execlp("bzip2", "bzip2", "-c", item.logPath.c_str(), nullptr);

                    % res % logPath);

                    % res % item.logPath);

            if (rename(tmpPath.c_str(), (logPath + ".bz2").c_str()) != 0)

            if (rename(tmpPath.c_str(), dstPath.c_str()) != 0)

            if (unlink(logPath.c_str()) != 0)
                throw SysError(format("unlinking ‘%1%’") % logPath);

            if (unlink(item.logPath.c_str()) != 0)
                throw SysError(format("unlinking ‘%1%’") % item.logPath);
            /* Run plugins. We do this after log compression to ensure
               that the log file doesn't change while the plugins may
               be accessing it. */
            enqueueNotificationItem({NotificationItem::Type::StepFinished, item.id, {}, item.stepNr, dstPath});

                Strings argv({"hydra-notify", item.type == NotificationItem::Type::Started ? "build-started" : "build-finished", std::to_string(item.id)});
                for (auto id : item.dependentIds)
                    argv.push_back(std::to_string(id));

                Strings argv;
                switch (item.type) {
                    case NotificationItem::Type::BuildStarted:
                        argv = {"hydra-notify", "build-started", std::to_string(item.id)};
                        for (auto id : item.dependentIds)
                            argv.push_back(std::to_string(id));
                        break;
                    case NotificationItem::Type::BuildFinished:
                        argv = {"hydra-notify", "build-finished", std::to_string(item.id)};
                        for (auto id : item.dependentIds)
                            argv.push_back(std::to_string(id));
                        break;
                    case NotificationItem::Type::StepFinished:
                        argv = {"hydra-notify", "step-finished", std::to_string(item.id), std::to_string(item.stepNr), item.logPath};
                        break;
                };

    nix::Sync<std::queue<nix::Path>> logCompressorQueue;

    struct CompressionItem
    {
        BuildID id;
        unsigned int stepNr;
        nix::Path logPath;
    };
    nix::Sync<std::queue<CompressionItem>> logCompressorQueue;

           Started,
           Finished

           BuildStarted,
           BuildFinished,
           StepFinished,

        unsigned int stepNr;
        nix::Path logPath;

    void enqueueNotificationItem(const NotificationItem && item)
    {
        {
            auto notificationSenderQueue_(notificationSenderQueue.lock());
            notificationSenderQueue_->emplace(item);
        }
        notificationSenderWakeup.notify_one();
    }

    int allocBuildStep(pqxx::work & txn, Build::ptr build);

    unsigned int allocBuildStep(pqxx::work & txn, Build::ptr build);

    int createBuildStep(pqxx::work & txn, time_t startTime, Build::ptr build, Step::ptr step,

    unsigned int createBuildStep(pqxx::work & txn, time_t startTime, Build::ptr build, Step::ptr step,

        unsigned int overhead, BuildID buildId, int stepNr,

        unsigned int overhead, BuildID buildId, unsigned int stepNr,

package Hydra::Helper::PluginHooks;
use strict;
use Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(
    notifyBuildStarted
    notifyBuildFinished);
sub notifyBuildStarted {
    my ($plugins, $build) = @_;
    foreach my $plugin (@{$plugins}) {
        eval {
            $plugin->buildStarted($build);
        };
        if ($@) {
            print STDERR "$plugin->buildStarted: $@\n";
        }
    }
}
sub notifyBuildFinished {
    my ($plugins, $build, $dependents) = @_;
    foreach my $plugin (@{$plugins}) {
        eval {
            $plugin->buildFinished($build, $dependents);
        };
        if ($@) {
            print STDERR "$plugin->buildFinished: $@\n";
        }
    }
}
1;

use Hydra::Helper::PluginHooks;

}
# Called when step $step has finished. The build log is stored in the
# file $logPath (bzip2-compressed).
sub stepFinished {
    my ($self, $step, $logPath) = @_;

use Hydra::Helper::PluginHooks;

my $cmd = shift @ARGV or die "Syntax: hydra-notify CMD BUILD-ID [BUILD-IDs...]\n";

my $cmd = shift @ARGV or die "Syntax: hydra-notify build-started BUILD | build-finished BUILD-ID [BUILD-IDs...] | step-finished BUILD-ID STEP-NR LOG-PATH\n";

    notifyBuildFinished(\@plugins, $build, [@dependents]);
} elsif ($cmd eq "build-started") {
    notifyBuildStarted(\@plugins, $build);

    foreach my $plugin (@plugins) {
        eval { $plugin->buildFinished($build, [@dependents]); };
        if ($@) {
            print STDERR "$plugin->buildFinished: $@\n";
        }
    }
}
elsif ($cmd eq "build-started") {
    foreach my $plugin (@plugins) {
        eval { $plugin->buildStarted($build); };
        if ($@) {
            print STDERR "$plugin->buildStarted: $@\n";
        }
    }
}
elsif ($cmd eq "step-finished") {
    my $stepNr = shift @ARGV or die;
    my $step = $build->buildsteps->find({stepnr => $stepNr})
        or die "step $stepNr does not exist\n";
    my $logPath = shift @ARGV or die;
    foreach my $plugin (@plugins) {
        eval { $plugin->stepFinished($step, $logPath); };
        if ($@) {
            print STDERR "$plugin->stepFinished: $@\n";
        }
    }