/* Notification sender work queue. FIXME: if hydra-queue-runner is
       killed before it has finished sending notifications about a
       build, then the notifications may be lost. It would be better
       to mark builds with pending notification in the database. */
    typedef std::pair<BuildID, std::vector<BuildID>> NotificationItem;
    Sync<std::queue<NotificationItem>> notificationSenderQueue;
    std::condition_variable_any notificationSenderWakeup;

    /* Thread that asynchronously invokes hydra-notify to send build
       notifications. */
    void notificationSender();

        }
        /* Send notification about this build. */
        {
            auto notificationSenderQueue_(notificationSenderQueue.lock());
            notificationSenderQueue_->push(NotificationItem(build->id, std::vector<BuildID>()));

        notificationSenderWakeup.notify_one();

        std::vector<BuildID> dependentIDs;

                    dependentIDs.push_back(build2->id);

        }
        /* Send notification about this build and its dependents. */
        {
            auto notificationSenderQueue_(notificationSenderQueue.lock());
            notificationSenderQueue_->push(NotificationItem(build->id, dependentIDs));

        notificationSenderWakeup.notify_one();

                throw SysError("cannot start ssh");

                throw SysError("cannot start bzip2");

void State::notificationSender()
{
    while (true) {
        try {

            NotificationItem item;
            {
                auto notificationSenderQueue_(notificationSenderQueue.lock());
                while (notificationSenderQueue_->empty())
                    notificationSenderQueue_.wait(notificationSenderWakeup);
                item = notificationSenderQueue_->front();
                notificationSenderQueue_->pop();
            }
            printMsg(lvlChatty, format("sending notification about build %1%") % item.first);
            Pid pid = startProcess([&]() {
                Strings argv({"hydra-notify", "build", int2String(item.first)});
                for (auto id : item.second)
                    argv.push_back(int2String(id));
                execvp("hydra-notify", (char * *) stringsToCharPtrs(argv).data()); // FIXME: remove cast
                throw SysError("cannot start hydra-notify");
            });
            int res = pid.wait(true);
            if (res != 0)
                throw Error(format("hydra-build returned exit code %1% notifying about build %2%")
                    % res % item.first);
        } catch (std::exception & e) {
            printMsg(lvlError, format("notification sender: %1%") % e.what());
            sleep(5);
        }
    }
}

    auto queueMonitorThread = std::thread(&State::queueMonitor, this);

    std::thread(&State::queueMonitor, this).detach();

    /* Idem for notification sending. */
    std::thread(&State::notificationSender, this).detach();
    /* Monitor the database for status dump requests (e.g. from
       ‘hydra-queue-runner --status’). */

    // Never reached.
    queueMonitorThread.join();

  hydra-notify					\

#! /var/run/current-system/sw/bin/perl

#! /run/current-system/sw/bin/perl

#! /run/current-system/sw/bin/perl
use strict;
use utf8;
use Hydra::Plugin;
use Hydra::Helper::Nix;
use Hydra::Helper::PluginHooks;
STDERR->autoflush(1);
binmode STDERR, ":encoding(utf8)";
my $config = getHydraConfig();
my $db = Hydra::Model::DB->new();
my @plugins = Hydra::Plugin->instantiate(db => $db, config => $config);
my $cmd = shift @ARGV or die "Syntax: hydra-notify build BUILD-ID [BUILD-IDs...]\n";
if ($cmd eq "build") {
    my $buildId = shift @ARGV or die;
    my $build = $db->resultset('Builds')->find($buildId)
        or die "build $buildId does not exist\n";
    my @dependents;
    foreach my $id (@ARGV) {
        my $dep = $db->resultset('Builds')->find($id)
            or die "build $id does not exist\n";
        push @dependents, $dep;
    }
    notifyBuildFinished(\@plugins, $build, [@dependents]);
}
else {
    die "unknown action ‘$cmd’";
}