harness-drone/handler/api/system/stats.go
2021-07-22 18:56:41 +02:00

235 lines
5.7 KiB
Go

// Copyright 2019 Drone.IO Inc. All rights reserved.
// Use of this source code is governed by the Drone Non-Commercial License
// that can be found in the LICENSE file.
// +build !oss
package system
import (
"net/http"
"github.com/drone/drone/core"
"github.com/drone/drone/handler/api/render"
"github.com/drone/drone/logger"
)
type (
users struct {
Total int64 `json:"total"`
}
repos struct {
Active int64 `json:"active"`
}
builds struct {
Pending int `json:"pending"`
Running int `json:"running"`
Total int64 `json:"total"`
}
events struct {
Subscribers int `json:"subscribers"`
}
streams struct {
Subscribers int `json:"subscribers"`
Channels int `json:"channels"`
}
platform struct {
Subscribers int `json:"subscribers"`
OS string `json:"os"`
Arch string `json:"arch"`
Variant string `json:"variant"`
Kernel string `json:"kernel"`
Pending int `json:"pending"`
Running int `json:"running"`
}
stats struct {
Users users `json:"users"`
Repos repos `json:"repos"`
Builds builds `json:"builds"`
Pipelines []*platform `json:"pipelines"`
Events events `json:"events"`
Streams map[int64]int `json:"streams"`
Watchers map[int64]int `json:"watchers"`
}
)
// HandleStats returns an http.HandlerFunc that writes a
// json-encoded list of system stats to the response body.
func HandleStats(
builds core.BuildStore,
stages core.StageStore,
users core.UserStore,
repos core.RepositoryStore,
bus core.Pubsub,
streams core.LogStream,
) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var ctx = r.Context()
var err error
//
// User Stats
//
stats := &stats{}
stats.Users.Total, err = users.Count(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get user count")
return
}
//
// Repo Stats
//
stats.Repos.Active, err = repos.Count(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get repo count")
return
}
//
// Build Stats
//
stats.Builds.Total, err = builds.Count(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get build count")
return
}
buildsPending, err := builds.Pending(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get pending build count")
return
}
buildsRunning, err := builds.Running(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get running build count")
return
}
stats.Builds.Pending = len(buildsPending)
stats.Builds.Running = len(buildsRunning)
//
// Queue Stats
//
incomplete, err := stages.ListIncomplete(ctx)
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get pending stage count")
return
}
platforms := newPlatformList()
aggregatePlatformStats(platforms, incomplete)
stats.Pipelines = platforms
//
// Event Stats
//
stats.Events.Subscribers, err = bus.Subscribers()
if err != nil {
render.InternalError(w, err)
logger.FromRequest(r).WithError(err).
Warnln("stats: cannot get number of subscribers")
return
}
//
// Stream Stats
//
stats.Streams = streams.Info(ctx).Streams
render.JSON(w, stats, 200)
}
}
// platform statistics are returned in a fixed array. these
// are pointers to the platform index in the array.
const (
linuxArm6 int = iota
linuxArm7
linuxArm8
linuxArm9
linuxAmd64
windows1709
windows1803
windows1809
)
// helper function returns a list of all platforms
// and variants currently supported by core.
func newPlatformList() []*platform {
platforms := [8]*platform{}
platforms[linuxArm6] = &platform{OS: "linux", Arch: "arm", Variant: "v6"}
platforms[linuxArm7] = &platform{OS: "linux", Arch: "arm", Variant: "v7"}
platforms[linuxArm8] = &platform{OS: "linux", Arch: "arm64", Variant: "v8"}
platforms[linuxArm9] = &platform{OS: "linux", Arch: "arm", Variant: "v9"}
platforms[linuxAmd64] = &platform{OS: "linux", Arch: "amd64"}
platforms[windows1709] = &platform{OS: "windows", Arch: "arm64", Kernel: "1709"}
platforms[windows1803] = &platform{OS: "windows", Arch: "arm64", Kernel: "1803"}
platforms[windows1809] = &platform{OS: "windows", Arch: "arm64", Kernel: "1809"}
return platforms[:]
}
// helper function counts the number of running and
// pending stages by os, architecture, and variant.
func aggregatePlatformStats(platforms []*platform, stages []*core.Stage) {
for _, stage := range stages {
var index int
switch {
case stage.OS == "windows" && stage.Kernel == "1709":
index = windows1709
case stage.OS == "windows" && stage.Kernel == "1803":
index = windows1803
case stage.OS == "windows" && stage.Kernel == "1809":
index = windows1809
case stage.OS == "windows":
// default to 1803 when no variant specified
index = windows1809
case stage.Arch == "arm" && stage.Variant == "v6":
index = linuxArm6
case stage.Arch == "arm" && stage.Variant == "v7":
index = linuxArm7
case stage.Arch == "arm" && stage.Variant == "v9":
index = linuxArm9
case stage.Arch == "arm":
// default to arm7 when no variant specified
index = linuxArm7
case stage.Arch == "arm64" && stage.Variant == "v8":
index = linuxArm8
case stage.Arch == "arm64":
// default to arm8 when arm64
index = linuxArm8
default:
index = linuxAmd64
continue
}
switch stage.Status {
case core.StatusPending:
platforms[index].Pending++
case core.StatusRunning:
platforms[index].Running++
}
}
}