func (restapi restAPI) getTaskHistory(w http.ResponseWriter, r *http.Request) {
taskName := mux.Vars(r)["task_name"]
projectName := r.FormValue("project")
projectRef, err := model.FindOneProjectRef(projectName)
if err != nil || projectRef == nil {
msg := fmt.Sprintf("Error finding project '%v'", projectName)
statusCode := http.StatusNotFound
if err != nil {
evergreen.Logger.Logf(slogger.ERROR, "%v: %v", msg, err)
statusCode = http.StatusInternalServerError
}
restapi.WriteJSON(w, statusCode, responseError{Message: msg})
return
}
project, err := model.FindProject("", projectRef)
if err != nil {
msg := fmt.Sprintf("Error finding project '%v'", projectName)
evergreen.Logger.Logf(slogger.ERROR, "%v: %v", msg, err)
restapi.WriteJSON(w, http.StatusInternalServerError, responseError{Message: msg})
return
}
buildVariants := project.GetVariantsWithTask(taskName)
iter := model.NewTaskHistoryIterator(taskName, buildVariants, project.Identifier)
chunk, err := iter.GetChunk(nil, MaxNumRevisions, NoRevisions, false)
if err != nil {
msg := fmt.Sprintf("Error finding history for task '%v'", taskName)
evergreen.Logger.Logf(slogger.ERROR, "%v: %v", msg, err)
restapi.WriteJSON(w, http.StatusInternalServerError, responseError{Message: msg})
return
}
restapi.WriteJSON(w, http.StatusOK, chunk)
return
}
func (uis *UIServer) taskHistoryTestNames(w http.ResponseWriter, r *http.Request) {
taskName := mux.Vars(r)["task_name"]
projCtx := MustHaveProjectContext(r)
if projCtx.Project == nil {
http.Error(w, "not found", http.StatusNotFound)
return
}
buildVariants := projCtx.Project.GetVariantsWithTask(taskName)
taskHistoryIterator := model.NewTaskHistoryIterator(taskName, buildVariants,
projCtx.Project.Identifier)
results, err := taskHistoryIterator.GetDistinctTestNames(NumTestsToSearchForTestNames)
if err != nil {
http.Error(w, fmt.Sprintf("Error finding test names: `%v`", err.Error()), http.StatusInternalServerError)
return
}
uis.WriteJSON(w, http.StatusOK, results)
}
func (restapi restAPI) getTaskHistory(w http.ResponseWriter, r *http.Request) {
taskName := mux.Vars(r)["task_name"]
projCtx := MustHaveRESTContext(r)
project := projCtx.Project
if project == nil {
restapi.WriteJSON(w, http.StatusInternalServerError, responseError{Message: "error loading project"})
return
}
buildVariants := project.GetVariantsWithTask(taskName)
iter := model.NewTaskHistoryIterator(taskName, buildVariants, project.Identifier)
chunk, err := iter.GetChunk(nil, MaxRestNumRevisions, NoRevisions, false)
if err != nil {
msg := fmt.Sprintf("Error finding history for task '%v'", taskName)
evergreen.Logger.Logf(slogger.ERROR, "%v: %v", msg, err)
restapi.WriteJSON(w, http.StatusInternalServerError, responseError{Message: msg})
return
}
restapi.WriteJSON(w, http.StatusOK, chunk)
return
}
// Serves the task history page itself.
func (uis *UIServer) taskHistoryPage(w http.ResponseWriter, r *http.Request) {
projCtx := MustHaveProjectContext(r)
if projCtx.Project == nil {
http.Error(w, "not found", http.StatusNotFound)
return
}
taskName := mux.Vars(r)["task_name"]
var chunk model.TaskHistoryChunk
var v *version.Version
var before bool
var err error
if strBefore := r.FormValue("before"); strBefore != "" {
if before, err = strconv.ParseBool(strBefore); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
buildVariants := projCtx.Project.GetVariantsWithTask(taskName)
if revision := r.FormValue("revision"); revision != "" {
v, err = version.FindOne(version.ByProjectIdAndRevision(projCtx.Project.Identifier, revision))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
}
taskHistoryIterator := model.NewTaskHistoryIterator(taskName, buildVariants, projCtx.Project.Identifier)
if r.FormValue("format") == "" {
if v != nil {
chunk, err = taskHistoryIterator.GetChunk(v, InitRevisionsBefore, InitRevisionsAfter, true)
} else {
// Load the most recent MaxNumRevisions if a particular
// version was unspecified
chunk, err = taskHistoryIterator.GetChunk(v, MaxNumRevisions, NoRevisions, false)
}
} else if before {
chunk, err = taskHistoryIterator.GetChunk(v, MaxNumRevisions, NoRevisions, false)
} else {
chunk, err = taskHistoryIterator.GetChunk(v, NoRevisions, MaxNumRevisions, false)
}
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
data := taskHistoryPageData{
TaskName: taskName,
Tasks: chunk.Tasks,
Variants: buildVariants,
FailedTests: chunk.FailedTests,
Versions: chunk.Versions,
ExhaustedBefore: chunk.Exhausted.Before,
ExhaustedAfter: chunk.Exhausted.After,
SelectedRevision: r.FormValue("revision"),
}
switch r.FormValue("format") {
case "json":
uis.WriteJSON(w, http.StatusOK, data)
return
default:
uis.WriteHTML(w, http.StatusOK, struct {
ProjectData projectContext
User *user.DBUser
Flashes []interface{}
Data taskHistoryPageData
}{projCtx, GetUser(r), []interface{}{}, data}, "base",
"task_history.html", "base_angular.html", "menu.html")
}
}