// MarkVersionCompleted updates the status of a completed version to reflect its correct state by
// checking the status of its individual builds.
func MarkVersionCompleted(versionId string, finishTime time.Time) error {
status := evergreen.VersionSucceeded
// Find the statuses for all builds in the version so we can figure out the version's status
builds, err := build.Find(
build.ByVersion(versionId).WithFields(build.StatusKey),
)
if err != nil {
return err
}
for _, b := range builds {
if !b.IsFinished() {
return nil
}
if b.Status != evergreen.BuildSucceeded {
status = evergreen.VersionFailed
}
}
return version.UpdateOne(
bson.M{version.IdKey: versionId},
bson.M{"$set": bson.M{
version.FinishTimeKey: finishTime,
version.StatusKey: status,
}},
)
}
// Returns a JSON response with the status of the specified version
// grouped on the build variants. The keys of the object are the build
// variant name, with each key in the nested object representing a
// particular task.
func (restapi restAPI) getVersionStatusByBuild(versionId string, w http.ResponseWriter, r *http.Request) {
// Get all of the builds corresponding to this version
builds, err := build.Find(
build.ByVersion(versionId).WithFields(build.BuildVariantKey, build.TasksKey),
)
if err != nil {
msg := fmt.Sprintf("Error finding status for version '%v'", versionId)
evergreen.Logger.Logf(slogger.ERROR, "%v: %v", msg, err)
restapi.WriteJSON(w, http.StatusInternalServerError, responseError{Message: msg})
return
}
result := versionStatusByBuildContent{
Id: versionId,
Builds: make(map[string]versionStatusByBuild, len(builds)),
}
for _, build := range builds {
statuses := make(versionStatusByBuild, len(build.Tasks))
for _, task := range build.Tasks {
status := versionStatus{
Id: task.Id,
Status: task.Status,
TimeTaken: task.TimeTaken,
}
statuses[task.DisplayName] = status
}
result.Builds[build.BuildVariant] = statuses
}
restapi.WriteJSON(w, http.StatusOK, result)
return
}
// Given a patch version and a list of variant/task pairs, creates the set of new builds that
// do not exist yet out of the set of pairs. No tasks are added for builds which already exist
// (see AddNewTasksForPatch).
func AddNewBuildsForPatch(p *patch.Patch, patchVersion *version.Version, project *Project, pairs TVPairSet) error {
tt := NewPatchTaskIdTable(project, patchVersion, pairs)
newBuildIds := make([]string, 0)
newBuildStatuses := make([]version.BuildStatus, 0)
existingBuilds, err := build.Find(build.ByVersion(patchVersion.Id).WithFields(build.BuildVariantKey, build.IdKey))
if err != nil {
return err
}
variantsProcessed := map[string]bool{}
for _, b := range existingBuilds {
variantsProcessed[b.BuildVariant] = true
}
for _, pair := range pairs {
if _, ok := variantsProcessed[pair.Variant]; ok { // skip variant that was already processed
continue
}
variantsProcessed[pair.Variant] = true
// Extract the unique set of task names for the variant we're about to create
taskNames := pairs.TaskNames(pair.Variant)
if len(taskNames) == 0 {
continue
}
buildId, err := CreateBuildFromVersion(project, patchVersion, tt, pair.Variant, p.Activated, taskNames)
evergreen.Logger.Logf(slogger.INFO,
"Creating build for version %v, buildVariant %v, activated = %v",
patchVersion.Id, pair.Variant, p.Activated)
if err != nil {
return err
}
newBuildIds = append(newBuildIds, buildId)
newBuildStatuses = append(newBuildStatuses,
version.BuildStatus{
BuildVariant: pair.Variant,
BuildId: buildId,
Activated: p.Activated,
},
)
}
return version.UpdateOne(
bson.M{version.IdKey: patchVersion.Id},
bson.M{
"$push": bson.M{
version.BuildIdsKey: bson.M{"$each": newBuildIds},
version.BuildVariantsKey: bson.M{"$each": newBuildStatuses},
},
},
)
return nil
}
// SetVersionActivation updates the "active" state of all builds and tasks associated with a
// version to the given setting. It also updates the task cache for all builds affected.
func SetVersionActivation(versionId string, active bool, caller string) error {
builds, err := build.Find(
build.ByVersion(versionId).WithFields(build.IdKey),
)
if err != nil {
return err
}
for _, b := range builds {
err = SetBuildActivation(b.Id, active, caller)
if err != nil {
return err
}
}
return nil
}