//AddTasksToBuild creates the tasks for the given build of a project
func AddTasksToBuild(b *build.Build, project *Project, v *version.Version,
taskNames []string) (*build.Build, error) {
// find the build variant for this project/build
buildVariant := project.FindBuildVariant(b.BuildVariant)
if buildVariant == nil {
return nil, fmt.Errorf("Could not find build %v in %v project file",
b.BuildVariant, project.Identifier)
}
// create the new tasks for the build
tasks, err := createTasksForBuild(
project, buildVariant, b, v, BuildTaskIdTable(project, v), taskNames)
if err != nil {
return nil, fmt.Errorf("error creating tasks for build %v: %v",
b.Id, err)
}
// insert the tasks into the db
for _, task := range tasks {
evergreen.Logger.Logf(slogger.INFO, "Creating task “%v”", task.DisplayName)
if err := task.Insert(); err != nil {
return nil, fmt.Errorf("error inserting task %v: %v", task.Id, err)
}
}
// update the build to hold the new tasks
RefreshTasksCache(b.Id)
return b, nil
}
func TestHostFindNextTask(t *testing.T) {
Convey("With a host", t, func() {
Convey("when finding the next task to be run on the host", func() {
testutil.HandleTestingErr(db.ClearCollections(host.Collection,
task.Collection, TaskQueuesCollection), t,
"Error clearing test collections")
h := &host.Host{Id: "hostId", Distro: distro.Distro{}}
So(h.Insert(), ShouldBeNil)
Convey("if there is no task queue for the host's distro, no task"+
" should be returned", func() {
nextTask, err := NextTaskForHost(h)
So(err, ShouldBeNil)
So(nextTask, ShouldBeNil)
})
Convey("if the task queue is empty, no task should be"+
" returned", func() {
tQueue := &TaskQueue{Distro: h.Distro.Id}
So(tQueue.Save(), ShouldBeNil)
nextTask, err := NextTaskForHost(h)
So(err, ShouldBeNil)
So(nextTask, ShouldBeNil)
})
Convey("if the task queue is not empty, the corresponding task"+
" object from the database should be returned", func() {
tQueue := &TaskQueue{
Distro: h.Distro.Id,
Queue: []TaskQueueItem{{Id: "taskOne"}},
}
So(tQueue.Save(), ShouldBeNil)
task := &task.Task{Id: "taskOne"}
So(task.Insert(), ShouldBeNil)
nextTask, err := NextTaskForHost(h)
So(err, ShouldBeNil)
So(nextTask.Id, ShouldEqual, task.Id)
})
})
})
}
func createTask(id string, order int, project string, buildVariant string, gitspec string) error {
task := &task.Task{}
task.BuildVariant = buildVariant
task.RevisionOrderNumber = order
task.Project = project
task.Revision = gitspec
task.DisplayName = id
task.Id = id
task.Requester = evergreen.RepotrackerVersionRequester
return task.Insert()
}
// CreateBuildFromVersion creates a build given all of the necessary information
// from the corresponding version and project and a list of tasks.
func CreateBuildFromVersion(project *Project, v *version.Version, tt TaskIdTable,
buildName string, activated bool, taskNames []string) (string, error) {
evergreen.Logger.Logf(slogger.DEBUG, "Creating %v %v build, activated: %v", v.Requester, buildName, activated)
// find the build variant for this project/build
buildVariant := project.FindBuildVariant(buildName)
if buildVariant == nil {
return "", fmt.Errorf("could not find build %v in %v project file", buildName, project.Identifier)
}
// create a new build id
buildId := util.CleanName(
fmt.Sprintf("%v_%v_%v_%v",
project.Identifier,
buildName,
v.Revision,
v.CreateTime.Format(build.IdTimeLayout)))
// create the build itself
b := &build.Build{
Id: buildId,
CreateTime: v.CreateTime,
PushTime: v.CreateTime,
Activated: activated,
Project: project.Identifier,
Revision: v.Revision,
Status: evergreen.BuildCreated,
BuildVariant: buildName,
Version: v.Id,
DisplayName: buildVariant.DisplayName,
RevisionOrderNumber: v.RevisionOrderNumber,
Requester: v.Requester,
}
// get a new build number for the build
buildNumber, err := db.GetNewBuildVariantBuildNumber(buildName)
if err != nil {
return "", fmt.Errorf("could not get build number for build variant"+
" %v in %v project file", buildName, project.Identifier)
}
b.BuildNumber = strconv.FormatUint(buildNumber, 10)
// create all of the necessary tasks for the build
tasksForBuild, err := createTasksForBuild(project, buildVariant, b, v, tt, taskNames)
if err != nil {
return "", fmt.Errorf("error creating tasks for build %v: %v", b.Id, err)
}
// insert all of the build's tasks into the db
for _, task := range tasksForBuild {
if err := task.Insert(); err != nil {
return "", fmt.Errorf("error inserting task %v: %v", task.Id, err)
}
}
// create task caches for all of the tasks, and place them into the build
tasks := make([]task.Task, 0, len(tasksForBuild))
for _, taskP := range tasksForBuild {
tasks = append(tasks, *taskP)
}
b.Tasks = CreateTasksCache(tasks)
// insert the build
if err := b.Insert(); err != nil {
return "", fmt.Errorf("error inserting build %v: %v", b.Id, err)
}
// success!
return b.Id, nil
}
func SetupAPITestData(taskDisplayName string, patchPath string, t *testing.T) (*task.Task, *build.Build, error) {
//ignore errs here because the ns might just not exist.
testutil.HandleTestingErr(
db.ClearCollections(task.Collection, build.Collection,
host.Collection, version.Collection, patch.Collection),
t, "Failed to clear test collections")
testHost := &host.Host{
Id: "testHost",
Host: "testHost",
RunningTask: "testTaskId",
StartedBy: evergreen.User,
}
testutil.HandleTestingErr(testHost.Insert(), t, "failed to insert host")
task := &task.Task{
Id: "testTaskId",
BuildId: "testBuildId",
DistroId: "rhel55",
BuildVariant: "linux-64",
Project: "mongodb-mongo-master",
DisplayName: taskDisplayName,
HostId: "testHost",
Version: "testVersionId",
Secret: "testTaskSecret",
Status: evergreen.TaskDispatched,
Requester: evergreen.RepotrackerVersionRequester,
}
if patchPath != "" {
task.Requester = evergreen.PatchVersionRequester
}
testutil.HandleTestingErr(task.Insert(), t, "failed to insert task")
version := &version.Version{Id: "testVersionId", BuildIds: []string{task.BuildId}}
testutil.HandleTestingErr(version.Insert(), t, "failed to insert version %v")
if patchPath != "" {
modulePatchContent, err := ioutil.ReadFile(patchPath)
testutil.HandleTestingErr(err, t, "failed to read test module patch file %v")
patch := &patch.Patch{
Status: evergreen.PatchCreated,
Version: version.Id,
Patches: []patch.ModulePatch{
{
ModuleName: "enterprise",
Githash: "c2d7ce942a96d7dacd27c55b257e3f2774e04abf",
PatchSet: patch.PatchSet{Patch: string(modulePatchContent)},
},
},
}
testutil.HandleTestingErr(patch.Insert(), t, "failed to insert patch %v")
}
session, _, err := db.GetGlobalSessionFactory().GetSession()
testutil.HandleTestingErr(err, t, "couldn't get db session!")
//Remove any logs for our test task from previous runs.
_, err = session.DB(model.TaskLogDB).C(model.TaskLogCollection).RemoveAll(bson.M{"t_id": task.Id})
testutil.HandleTestingErr(err, t, "failed to remove logs")
build := &build.Build{Id: "testBuildId", Tasks: []build.TaskCache{build.NewTaskCache(task.Id, task.DisplayName, true)}}
testutil.HandleTestingErr(build.Insert(), t, "failed to insert build %v")
return task, build, nil
}