/* If this is an aggregate, then get its members. */

            /* If this is an aggregate, then get its constituents. */

                Bindings::iterator a = v.attrs->find(state.symbols.create("members"));

                Bindings::iterator a = v.attrs->find(state.symbols.create("constituents"));

                    throw EvalError("derivation must have a ‘members’ attribute");

                    throw EvalError("derivation must have a ‘constituents’ attribute");

                xmlAttrs["members"] = concatStringsSep(" ", drvs);

                xmlAttrs["constituents"] = concatStringsSep(" ", drvs);

package Hydra::Schema::AggregateMembers;

package Hydra::Schema::AggregateConstituents;

Hydra::Schema::AggregateMembers

Hydra::Schema::AggregateConstituents

=head1 TABLE: C<AggregateMembers>

=head1 TABLE: C<AggregateConstituents>

__PACKAGE__->table("AggregateMembers");

__PACKAGE__->table("AggregateConstituents");

=head2 member

=head2 constituent

  "member",

  "constituent",

=item * L</member>

=item * L</constituent>

__PACKAGE__->set_primary_key("aggregate", "member");

__PACKAGE__->set_primary_key("aggregate", "constituent");

=head2 member

=head2 constituent

  "member",

  "constituent",

  { id => "member" },

  { id => "constituent" },

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-08-13 22:17:52
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:jHJtO2baXiprv0OcWCLZ+w

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-08-15 00:20:01
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:TLNenyPLIWw2gWsOVhplZw

=head2 aggregatemembers_aggregates

=head2 aggregateconstituents_aggregates

Related object: L<Hydra::Schema::AggregateMembers>

Related object: L<Hydra::Schema::AggregateConstituents>

  "aggregatemembers_aggregates",
  "Hydra::Schema::AggregateMembers",

  "aggregateconstituents_aggregates",
  "Hydra::Schema::AggregateConstituents",

=head2 aggregatemembers_members

=head2 aggregateconstituents_constituents

Related object: L<Hydra::Schema::AggregateMembers>

Related object: L<Hydra::Schema::AggregateConstituents>

  "aggregatemembers_members",
  "Hydra::Schema::AggregateMembers",
  { "foreign.member" => "self.id" },

  "aggregateconstituents_constituents",
  "Hydra::Schema::AggregateConstituents",
  { "foreign.constituent" => "self.id" },

Composing rels: L</aggregatemembers_members> -> aggregate

Composing rels: L</aggregateconstituents_constituents> -> aggregate

__PACKAGE__->many_to_many("aggregates", "aggregatemembers_members", "aggregate");

__PACKAGE__->many_to_many(
  "aggregates",
  "aggregateconstituents_constituents",
  "aggregate",
);

=head2 members

=head2 constituents

Composing rels: L</aggregatemembers_members> -> member

Composing rels: L</aggregateconstituents_constituents> -> constituent

__PACKAGE__->many_to_many("members", "aggregatemembers_members", "member");

__PACKAGE__->many_to_many(
  "constituents",
  "aggregateconstituents_constituents",
  "constituent",
);

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-08-13 22:17:52
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:9jqsol/evbHYjusT09hLtw

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-08-15 00:20:01
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:U1j/qm0vslb6Jvgu5mGMtw

__PACKAGE__->many_to_many("members_", "aggregatemembers_aggregates", "member");

__PACKAGE__->many_to_many("constituents_", "aggregateconstituents_aggregates", "constituent");

[% isAggregate = build.members_ ? 1 : 0 %]

[% isAggregate = build.constituents_ ? 1 : 0 %]

                     nrMembers = 0;

                     nrConstituents = 0;

                     nrFailedMembers = 0;
                     FOREACH b IN build.members_;
                       nrMembers = nrMembers + 1;

                     nrFailedConstituents = 0;
                     FOREACH b IN build.constituents_;
                       nrConstituents = nrConstituents + 1;

                       IF b.finished && b.buildstatus != 0; nrFailedMembers = nrFailedMembers + 1; END;

                       IF b.finished && b.buildstatus != 0; nrFailedConstituents = nrFailedConstituents + 1; END;

                  [%+ IF nrFinished == 0 && nrFailedMembers == 0 %]
                    all [% nrMembers %] constituent builds succeeded

                  [%+ IF nrFinished == nrMembers && nrFailedConstituents == 0 %]
                    all [% nrConstituents %] constituent builds succeeded

                    [% nrFailedMembers %] out of [% nrMembers %] constituent builds failed
                    [% IF nrFinished < nrMembers %]
                      ([% nrMembers - nrFinished %] still pending)

                    [% nrFailedConstituents %] out of [% nrConstituents %] constituent builds failed
                    [% IF nrFinished < nrConstituents %]
                      ([% nrConstituents - nrFinished %] still pending)

      [% INCLUDE renderBuildList builds=build.members_ %]

      [% INCLUDE renderBuildList builds=build.constituents_ %]

            # Create AggregateMembers mappings.

            # Create AggregateConstituents mappings.

                next unless $job->{members};

                next unless $job->{constituents};

                foreach my $drvPath (split / /, $job->{members}) {
                    my $member = $drvPathToId{$drvPath};
                    if (defined $member) {
                        $db->resultset('AggregateMembers')->update_or_create({aggregate => $id, member => $member});

                foreach my $drvPath (split / /, $job->{constituents}) {
                    my $constituent = $drvPathToId{$drvPath};
                    if (defined $constituent) {
                        $db->resultset('AggregateConstituents')->update_or_create({aggregate => $id, constituent => $constituent});

                        warn "aggregate job ‘$job->{jobName}’ has a member ‘$drvPath’ that doesn't correspond to a Hydra build\n";

                        warn "aggregate job ‘$job->{jobName}’ has a constituent ‘$drvPath’ that doesn't correspond to a Hydra build\n";

create table AggregateMembers (

create table AggregateConstituents (

    member        integer not null references Builds(id) on delete cascade,
    primary key   (aggregate, member)

    constituent   integer not null references Builds(id) on delete cascade,
    primary key   (aggregate, constituent)

create table AggregateMembers (

create table AggregateConstituents (

    member        integer not null references Builds(id) on delete cascade,
    primary key   (aggregate, member)

    constituent   integer not null references Builds(id) on delete cascade,
    primary key   (aggregate, constituent)