gitbay/Admin/AdminModels.swift
239 lines · 10141 bytes
1import Foundation
2
3/// The admin-only half of `dashboard`: the server build and every
4/// background worker's backlog. The web's `/admin` page is this read.
5/// Both are absent for anyone who is not an instance admin.
6nonisolated struct AdminDashboard: Decodable, Sendable, Hashable {
7 let queues: AdminQueues?
8 let server: Server?
9
10 nonisolated struct Server: Decodable, Sendable, Hashable {
11 let commit: String?
12 }
13}
14
15/// `dashboard`'s `queues` block.
16nonisolated struct AdminQueues: Decodable, Sendable, Hashable {
17 let webhooks: Queue
18 let mail: Queue
19 let push: Queue
20 let mirrors: Queue
21 let builds: Queue
22 let deps: Queue
23
24 /// Each queue reports a different subset of these counts; the
25 /// absent ones stay nil.
26 nonisolated struct Queue: Decodable, Sendable, Hashable {
27 let pending: Int?
28 let retrying: Int?
29 let failed: Int?
30 let running: Int?
31 let dirty: Int?
32 let errors: Int?
33 let oldestPending: String?
34 let items: [Row]?
35
36 enum CodingKeys: String, CodingKey {
37 case pending, retrying, failed, running, dirty, errors, items
38 case oldestPending = "oldest_pending"
39 }
40
41 var rows: [Row] { items ?? [] }
42 }
43
44 /// A row of any queue; each kind fills its own fields. Timestamps
45 /// stay strings: a pending build's `started_at` is `""`, which no
46 /// date decoder accepts.
47 nonisolated struct Row: Decodable, Sendable, Hashable {
48 let repo: String?
49 let url: String?
50 let recipient: String?
51 let subject: String?
52 let title: String?
53 let deviceID: Int64?
54 let direction: String?
55 let number: Int64?
56 let job: String?
57 let status: String?
58 let attempts: Int64?
59 let lastStatus: Int64?
60 let lastError: String?
61 let failedAt: String?
62 let lastSync: String?
63 let lastCheck: String?
64 let startedAt: String?
65 let createdAt: String?
66
67 enum CodingKeys: String, CodingKey {
68 case repo, url, recipient, subject, title, direction, number, job, status, attempts
69 case deviceID = "device_id"
70 case lastStatus = "last_status"
71 case lastError = "last_error"
72 case failedAt = "failed_at"
73 case lastSync = "last_sync"
74 case lastCheck = "last_check"
75 case startedAt = "started_at"
76 case createdAt = "created_at"
77 }
78 }
79
80 /// The web's six sections, in its order and its words
81 /// (`internal/web/templates/admin.html`). `when` renders a timestamp;
82 /// tests pass a fixed one.
83 func sections(when: (String) -> String = AdminQueues.relative) -> [QueueSection] {
84 func oldest(_ queue: Queue) -> String {
85 guard let at = queue.oldestPending, !at.isEmpty else { return "" }
86 return " · oldest pending \(when(at))"
87 }
88 func n(_ value: Int?) -> Int { value ?? 0 }
89 func attempts(_ row: Row) -> String? { row.attempts.map { "\($0) attempts" } }
90 func state(_ row: Row, failed: String) -> String {
91 guard let at = row.failedAt, !at.isEmpty else { return "retrying" }
92 return "\(failed) \(when(at))"
93 }
94 func lines(_ queue: Queue, _ make: (Row) -> (String, [String?])) -> [QueueLine] {
95 queue.rows.enumerated().map { index, row in
96 let (title, parts) = make(row)
97 let detail = parts.compactMap { $0 }.filter { !$0.isEmpty }.joined(separator: " · ")
98 return QueueLine(id: index, title: title, detail: detail)
99 }
100 }
101
102 return [
103 QueueSection(
104 id: "webhooks", heading: "Webhook deliveries", count: n(webhooks.pending),
105 summary: "\(n(webhooks.pending)) pending · \(n(webhooks.retrying)) retrying · \(n(webhooks.failed)) dead-lettered" + oldest(webhooks),
106 rows: lines(webhooks) { row in
107 let error = [row.lastStatus.map(String.init), row.lastError]
108 .compactMap { $0 }.filter { !$0.isEmpty }.joined(separator: " ")
109 return (row.repo ?? "", [row.url, attempts(row), state(row, failed: "dead-lettered"), error])
110 },
111 empty: "Nothing retrying or dead-lettered"),
112 QueueSection(
113 id: "mail", heading: "Mail", count: n(mail.pending),
114 summary: "\(n(mail.pending)) pending · \(n(mail.retrying)) retrying · \(n(mail.failed)) failed" + oldest(mail),
115 rows: lines(mail) { row in
116 (row.recipient ?? "", [row.subject, attempts(row), state(row, failed: "failed"), row.lastError])
117 },
118 empty: "Nothing retrying or failed"),
119 // A push row names the device id, never the token.
120 QueueSection(
121 id: "push", heading: "Push", count: n(push.pending),
122 summary: "\(n(push.pending)) pending · \(n(push.retrying)) retrying · \(n(push.failed)) failed" + oldest(push),
123 rows: lines(push) { row in
124 ("device \(row.deviceID.map(String.init) ?? "?")",
125 [row.title, attempts(row), state(row, failed: "failed"), row.lastError])
126 },
127 empty: "Nothing retrying or failed"),
128 QueueSection(
129 id: "mirrors", heading: "Mirrors", count: n(mirrors.errors),
130 summary: "\(n(mirrors.dirty)) waiting for a sync · \(n(mirrors.errors)) with a failed last sync",
131 rows: lines(mirrors) { row in
132 let sync = row.lastSync.flatMap { $0.isEmpty ? nil : "last sync \(when($0))" } ?? "never synced"
133 return (row.repo ?? "", [row.direction, row.url, sync, row.lastError])
134 },
135 empty: "Every mirror's last sync succeeded"),
136 QueueSection(
137 id: "builds", heading: "Builds", count: n(builds.pending),
138 summary: "\(n(builds.pending)) pending · \(n(builds.running)) running" + oldest(builds),
139 rows: lines(builds) { row in
140 let started = row.startedAt.flatMap { $0.isEmpty ? nil : $0 }
141 let since = (started ?? row.createdAt).map { "since \(when($0))" }
142 return ("\(row.repo ?? "") #\(row.number.map(String.init) ?? "?")", [row.job, row.status, since])
143 },
144 empty: "No build running or pending"),
145 QueueSection(
146 id: "deps", heading: "Dependency checks", count: n(deps.errors),
147 summary: nil,
148 rows: lines(deps) { row in
149 let check = row.lastCheck.flatMap { $0.isEmpty ? nil : "last check \(when($0))" } ?? "never checked"
150 return (row.repo ?? "", [check, row.lastError])
151 },
152 empty: "No check has failed"),
153 ]
154 }
155
156 /// "5 minutes ago", or the timestamp itself when it does not parse.
157 static func relative(_ timestamp: String) -> String {
158 let fractional = ISO8601DateFormatter()
159 fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
160 guard let date = fractional.date(from: timestamp) ?? ISO8601DateFormatter().date(from: timestamp)
161 else { return timestamp }
162 return date.formatted(.relative(presentation: .named))
163 }
164}
165
166/// One section of the admin screen: a heading with its count, the counts
167/// line, the rows, and what an empty queue says.
168nonisolated struct QueueSection: Sendable, Hashable, Identifiable {
169 let id: String
170 let heading: String
171 let count: Int
172 let summary: String?
173 let rows: [QueueLine]
174 let empty: String
175}
176
177nonisolated struct QueueLine: Sendable, Hashable, Identifiable {
178 let id: Int
179 let title: String
180 let detail: String
181}
182
183/// One row of `admin user list`.
184nonisolated struct AdminUser: Decodable, Sendable, Hashable, Identifiable {
185 let username: String
186 /// active, pending or disabled.
187 let state: String
188 let admin: Bool
189 let createdAt: Date
190 /// Absent for an account that has never signed in.
191 let lastSeen: Date?
192
193 enum CodingKeys: String, CodingKey {
194 case username, state, admin
195 case createdAt = "created_at"
196 case lastSeen = "last_seen"
197 }
198
199 var id: String { username }
200
201 /// The role button the web draws: Demote for an admin, Promote for
202 /// anyone else.
203 var roleAction: AdminAction { admin ? .demote : .promote }
204 /// Only an active account can be promoted; the web draws the button
205 /// disabled for the rest.
206 var canChangeRole: Bool { admin || state == "active" }
207 var accessAction: AdminAction { state == "disabled" ? .enable : .disable }
208}
209
210nonisolated enum AdminAction: String, Sendable, Hashable {
211 case promote, demote, disable, enable
212
213 /// Demote and disable take something away from the account, and the
214 /// web asks for the username typed before either.
215 var needsTypedName: Bool { self == .demote || self == .disable }
216
217 var title: String { rawValue.capitalized }
218
219 func argv(_ username: String) -> [String] { ["admin", "user", rawValue, username] }
220
221 func message(for username: String) -> String {
222 switch self {
223 case .promote: "\(username) becomes an instance admin."
224 case .demote: "\(username) stops being an instance admin. Type the username to confirm."
225 case .disable: "Signs \(username) out of the web and revokes their API tokens; SSH is refused until the account is enabled. Type the username to confirm."
226 case .enable: "\(username) can sign in again."
227 }
228 }
229}
230
231/// The web's five filters over `admin user list`.
232nonisolated enum AdminUserFilter: String, CaseIterable, Identifiable, Sendable {
233 case all, active, pending, disabled, admin
234
235 var id: String { rawValue }
236 var label: String { self == .admin ? "Admins" : rawValue.capitalized }
237
238 func flags() -> [String] { self == .all ? [] : ["--state", rawValue] }
239}