func (as *APIServer) getTaskQueueSizes(w http.ResponseWriter, r *http.Request) {
distroNames := make(map[string]int)
taskQueues, err := model.FindAllTaskQueues()
if err != nil {
as.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
for _, queue := range taskQueues {
distroNames[queue.Distro] = queue.Length()
}
taskQueueResponse := struct {
Distros map[string]int
}{distroNames}
as.WriteJSON(w, http.StatusOK, taskQueueResponse)
}
// getTaskQueueSize returns a JSON response with a SUCCESS flag if all task queues have a size
// less than the size indicated. If a distro's task queue has size greater than or equal to the size given,
// there will be an ERROR flag along with a map of the distro name to the size of the task queue.
// If the size is 0 or the size is not sent, the JSON response will be SUCCESS with a list of all distros and their
// task queue sizes.
func (as *APIServer) checkTaskQueueSize(w http.ResponseWriter, r *http.Request) {
size, err := util.GetIntValue(r, "size", 0)
if err != nil {
as.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
distro := r.FormValue("distro")
distroNames := make(map[string]int)
status := "SUCCESS"
if distro != "" {
taskQueue, err := model.FindTaskQueueForDistro(distro)
if err != nil {
as.LoggedError(w, r, http.StatusBadRequest, err)
return
}
if taskQueue.Length() >= size {
distroNames[distro] = taskQueue.Length()
status = "ERROR"
}
} else {
taskQueues, err := model.FindAllTaskQueues()
if err != nil {
as.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
for _, queue := range taskQueues {
if queue.Length() >= size {
distroNames[queue.Distro] = queue.Length()
status = "ERROR"
}
}
}
growthResponse := struct {
Status string
Distros map[string]int
}{status, distroNames}
as.WriteJSON(w, http.StatusOK, growthResponse)
}
func (uis *UIServer) allTaskQueues(w http.ResponseWriter, r *http.Request) {
projCtx := MustHaveProjectContext(r)
taskQueues, err := model.FindAllTaskQueues()
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError,
fmt.Errorf("Error finding task queues: %v", err))
return
}
// cached map of version id to relevant patch
cachedPatches := map[string]*patch.Patch{}
// convert the task queues to the ui versions
uiTaskQueues := []uiTaskQueue{}
for _, tQ := range taskQueues {
asUI := uiTaskQueue{
Distro: tQ.Distro,
Queue: []uiTaskQueueItem{},
}
if len(tQ.Queue) == 0 {
uiTaskQueues = append(uiTaskQueues, asUI)
continue
}
// convert the individual task queue items
taskIds := []string{}
for _, item := range tQ.Queue {
// cache the ids, for fetching the tasks from the db
taskIds = append(taskIds, item.Id)
queueItemAsUI := uiTaskQueueItem{
Id: item.Id,
DisplayName: item.DisplayName,
BuildVariant: item.BuildVariant,
RevisionOrderNumber: item.RevisionOrderNumber,
Requester: item.Requester,
Revision: item.Revision,
Project: item.Project,
}
asUI.Queue = append(asUI.Queue, queueItemAsUI)
}
// find all the relevant tasks
tasks, err := task.Find(task.ByIds(taskIds).WithFields(task.VersionKey, task.BuildIdKey))
if err != nil {
msg := fmt.Sprintf("Error finding tasks: %v", err)
evergreen.Logger.Errorf(slogger.ERROR, msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
// store all of the version and build ids in the relevant task queue
// items
for _, task := range tasks {
// this sucks, but it's because we're not guaranteed the order out
// of the db
for idx, queueItemAsUI := range asUI.Queue {
if queueItemAsUI.Id == task.Id {
queueItemAsUI.Version = task.Version
queueItemAsUI.Build = task.BuildId
asUI.Queue[idx] = queueItemAsUI
}
}
}
// add all of the necessary patch info into the relevant task queue
// items
for idx, queueItemAsUI := range asUI.Queue {
if queueItemAsUI.Requester == evergreen.PatchVersionRequester {
// fetch the patch, if necessary
var p *patch.Patch
var ok bool
if p, ok = cachedPatches[queueItemAsUI.Version]; ok {
queueItemAsUI.User = p.Author
asUI.Queue[idx] = queueItemAsUI
} else {
p, err = patch.FindOne(
patch.ByVersion(queueItemAsUI.Version).WithFields(patch.AuthorKey),
)
if err != nil {
msg := fmt.Sprintf("Error finding patch: %v", err)
evergreen.Logger.Errorf(slogger.ERROR, msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
if p == nil {
msg := fmt.Sprintf("Couldn't find patch for version %v", queueItemAsUI.Version)
evergreen.Logger.Errorf(slogger.ERROR, msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
cachedPatches[queueItemAsUI.Version] = p
}
queueItemAsUI.User = p.Author
asUI.Queue[idx] = queueItemAsUI
}
}
uiTaskQueues = append(uiTaskQueues, asUI)
}
// add other useful statistics to view alongside queue
idleHosts, err := host.Find(host.IsIdle)
if err != nil {
msg := fmt.Sprintf("Error finding idle hosts: %v", err)
evergreen.Logger.Errorf(slogger.ERROR, msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
activeHosts, err := host.Find(host.IsLive)
if err != nil {
msg := fmt.Sprintf("Error finding active hosts: %v", err)
evergreen.Logger.Errorf(slogger.ERROR, msg)
http.Error(w, msg, http.StatusInternalServerError)
return
}
idleStaticHostsCount := 0
for _, host := range idleHosts {
if host.Provider == evergreen.HostTypeStatic {
idleStaticHostsCount++
}
}
activeStaticHostsCount := 0
for _, host := range activeHosts {
if host.Provider == evergreen.HostTypeStatic {
activeStaticHostsCount++
}
}
hostStats := uiHostStatistics{
ActiveHosts: len(activeHosts),
ActiveStaticHosts: activeStaticHostsCount,
IdleHosts: len(idleHosts),
IdleStaticHosts: idleStaticHostsCount,
}
uis.WriteHTML(w, http.StatusOK, struct {
ProjectData projectContext
User *user.DBUser
Flashes []interface{}
Data uiResourceInfo
}{projCtx, GetUser(r), []interface{}{}, uiResourceInfo{uiTaskQueues, hostStats}},
"base", "task_queues.html", "base_angular.html", "menu.html")
}