hydra_queue_runner_SOURCES = hydra-queue-runner.cc build-result.cc build-remote.cc

hydra_queue_runner_SOURCES = hydra-queue-runner.cc build-result.cc build-remote.cc \
 build-remote.hh build-result.hh counter.hh pool.hh sync.hh token-server.hh

static void append(Strings & dst, const Strings & src)
{
    dst.insert(dst.end(), src.begin(), src.end());
}

        // FIXME: connection timeouts
        Strings argv(
            { "ssh", sshName, "-i", sshKey, "-x", "-a"
            , "-oBatchMode=yes", "-oConnectTimeout=60", "-oTCPKeepAlive=yes"
            , "--", "nix-store", "--serve", "--write" });

        Strings argv;
        if (sshName == "localhost")
            argv = {"nix-store", "--serve", "--write"};
        else {
            argv = {"ssh", sshName};
            if (sshKey != "" && sshKey != "-") append(argv, {"-i", sshKey});
            append(argv,
                { "-x", "-a", "-oBatchMode=yes", "-oConnectTimeout=60", "-oTCPKeepAlive=yes"
                , "--", "nix-store", "--serve", "--write" });
        }

        execvp("ssh", (char * *) stringsToCharPtrs(argv).data()); // FIXME: remove cast

        execvp(argv.front().c_str(), (char * *) stringsToCharPtrs(argv).data()); // FIXME: remove cast

    Sync<Machines> machines;

    Sync<Machines> machines; // FIXME: use atomic_shared_ptr

    /* Specific build to do for --build-one (testing only). */
    BuildID buildOne;

    void run();

    void run(BuildID buildOne = 0);

            if (buildOne && id != buildOne) continue;

    bool quit = build->id == buildOne;

            if (quit) exit(1);

                if (buildOne == b->id) quit = true;

    if (quit) exit(0); // testing hack

void State::run()

void State::run(BuildID buildOne)

    this->buildOne = buildOne;

        BuildID buildOne = 0;

            else

            else if (*arg == "--build-one") {
                if (!string2Int<BuildID>(getArg(*arg, arg, end), buildOne))
                    throw Error("‘--build-one’ requires a build ID");
            } else

            state.run();

            state.run(buildOne);

use strict;
use Hydra::Schema;
use Hydra::Model::DB;
my $db = Hydra::Model::DB->new;
my @sources = $db->schema->sources;
my $nrtables = scalar(@sources);
use Test::Simple tests => 38;
foreach my $source (@sources) {
    my $title = "Basic select query for $source";
    if ($source eq "SchemaVersion" || $source eq "NrBuilds") {
        ok(scalar($db->resultset($source)->all) == 1, $title);
    } elsif( $source !~ m/^LatestSucceeded/) {
        ok(scalar($db->resultset($source)->all) == 0, $title);
    } else {
        ok(scalar($db->resultset($source)->search({},{ bind => ["", "", ""] })) == 0, $title);
    }
}

  HYDRA_DBI="dbi:SQLite:db.sqlite"			\

  HYDRA_DBI="dbi:Pg:dbname=hydra-test-suite;"		\

  query-all-tables.pl \
  evaluation-tests.pl
clean:
	chmod -R a+w nix || true
	rm -rf db.sqlite data nix git-repo hg-repo svn-repo svn-checkout svn-checkout-repo bzr-repo bzr-checkout-repo darcs-repo
	rm -f .*-state

  set-up.pl \
  evaluation-tests.pl \
  tear-down.pl

check_SCRIPTS = db.sqlite repos

check_SCRIPTS = repos

    my ($res, $stdout, $stderr) = captureStdoutStderr(60, ("hydra-build", $build->id));
    print "STDERR: $stderr" if $stderr ne "";

    my ($res, $stdout, $stderr) = captureStdoutStderr(60, ("hydra-queue-runner", "-vvvv", "--build-one", $build->id));

    my $expected = $build->job->name eq "fails" ? 1 : 0;

    my $expected = $build->job->name eq "fails" ? 1 : $build->job->name =~ /with_failed/ ? 6 : 0;

use strict;
system("createdb hydra-test-suite") == 0 or die;
system("hydra-init") == 0 or die;

use strict;
system("chmod -R a+w nix") == 0 or die;
system("rm -rf data nix git-repo hg-repo svn-repo svn-checkout svn-checkout-repo bzr-repo bzr-checkout-repo darcs-repo") == 0 or die;
system("rm -f .*-state") == 0 or die;
system("dropdb hydra-test-suite") == 0 or die;