92 lines
2.7 KiB
Go
92 lines
2.7 KiB
Go
package dashboard
|
|
|
|
import (
|
|
"net/http"
|
|
"sort"
|
|
)
|
|
|
|
type overviewData struct {
|
|
PageData
|
|
Status statusResponse
|
|
CurrentItems []ipQueueItem
|
|
LastCompleted []ipQueueItem
|
|
Breakdown map[string]int
|
|
LastN int
|
|
PollSeconds int
|
|
}
|
|
|
|
func (s *Server) loadOverview(r *http.Request) (overviewData, error) {
|
|
ctx := r.Context()
|
|
status, err := s.CA.Status(ctx)
|
|
if err != nil {
|
|
return overviewData{}, err
|
|
}
|
|
ips, err := s.CA.ListIPs(ctx)
|
|
if err != nil {
|
|
return overviewData{}, err
|
|
}
|
|
last := lastCompleted(ips, s.Cfg.LastCompletedCount)
|
|
return overviewData{
|
|
Status: status,
|
|
CurrentItems: currentlyChecking(ips),
|
|
LastCompleted: last,
|
|
Breakdown: resultBreakdown(last),
|
|
LastN: s.Cfg.LastCompletedCount,
|
|
PollSeconds: s.Cfg.OverviewPollIntervalS,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Server) handleOverview(w http.ResponseWriter, r *http.Request) {
|
|
data, err := s.loadOverview(r)
|
|
data.ActiveNav = "overview"
|
|
data.Banner = bannerFor(err)
|
|
s.renderPage(w, "overview_page", data)
|
|
}
|
|
|
|
func (s *Server) handleOverviewFragment(w http.ResponseWriter, r *http.Request) {
|
|
data, err := s.loadOverview(r)
|
|
s.renderFragment(w, "overview_fragment", data, err)
|
|
}
|
|
|
|
// currentlyChecking is every IP not yet in a terminal state, ordered by
|
|
// queue position — the "текущая проверка" live snapshot. No backend
|
|
// concept of a "run" exists; this is computed fresh on every request.
|
|
func currentlyChecking(ips []ipQueueItem) []ipQueueItem {
|
|
var out []ipQueueItem
|
|
for _, ip := range ips {
|
|
if ip.State != "done" && ip.State != "failed" {
|
|
out = append(out, ip)
|
|
}
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Sequence < out[j].Sequence })
|
|
return out
|
|
}
|
|
|
|
// lastCompleted returns the n most recently completed (done/failed) IPs by
|
|
// AggregatedAt descending — the "последняя завершённая проверка" summary
|
|
// window. This is an operational definition, not a real "batch": resubmit
|
|
// n if the window size needs tuning (overview.last_completed_count).
|
|
func lastCompleted(ips []ipQueueItem, n int) []ipQueueItem {
|
|
var done []ipQueueItem
|
|
for _, ip := range ips {
|
|
if (ip.State == "done" || ip.State == "failed") && ip.AggregatedAt != nil {
|
|
done = append(done, ip)
|
|
}
|
|
}
|
|
sort.Slice(done, func(i, j int) bool { return done[i].AggregatedAt.After(*done[j].AggregatedAt) })
|
|
if len(done) > n {
|
|
done = done[:n]
|
|
}
|
|
return done
|
|
}
|
|
|
|
// resultBreakdown counts OverallResult values across exactly the given
|
|
// items (normally the output of lastCompleted) — pass/partial/fail/cancelled.
|
|
func resultBreakdown(items []ipQueueItem) map[string]int {
|
|
out := map[string]int{"pass": 0, "partial": 0, "fail": 0, "cancelled": 0}
|
|
for _, ip := range items {
|
|
out[ip.OverallResult]++
|
|
}
|
|
return out
|
|
}
|