antcolony

9.9 KB

1. // tickets.hl — the scheduler's ONLY way to state: the tickets.worldapi.org JSON API.
2. // Reads are public; writes need `Authorization: Bearer <token>` (token file from COLONY_TOKEN_FILE).
3. // Every request sends a user-agent (Cloudflare refuses default script agents).
4. import { fetch } from 'hl:fetch'
5. import { env } from 'hl:proc'
6. import { readFile, exists } from 'hl:fs'
7. import { fromCwd, isList, isObject, isString } from './util.hl'
8. import { now } from 'hl:time'
10. static setting = (name, fallback) => {
11. let v = env(name)
12. if (v == null || v == '') { return fallback }
13. return v
14. }
16. static baseUrl = () => {
17. let b = setting('COLONY_TICKETS_URL', 'https://tickets.worldapi.org')
18. while (b.endsWith('/')) { b = b.slice(0, b.length - 1) }
19. return b
20. }
21. static userAgent = () => { return setting('COLONY_USER_AGENT', 'antcolony-scheduler/0') }
22. static inboxProject = () => { return setting('COLONY_INBOX_PROJECT', 'antcolony') }
24. // the API token: { token } or { error } — never printed
25. static readToken = () => {
26. let f = env('COLONY_TOKEN_FILE')
27. if (f == null || f == '') { return { error = 'COLONY_TOKEN_FILE is not set (a file holding a tickets API token, tkt_…)' } }
28. let p = fromCwd(f)
29. if (!exists(p)) { return { error = 'COLONY_TOKEN_FILE: no such file: ' + p } }
30. let t = readFile(p).trim()
31. if (t == '') { return { error = 'COLONY_TOKEN_FILE is empty: ' + p } }
32. return { token = t }
33. }
35. // mission 035 (antcolony#14): the secret the scheduler and its agents share (COLONY_AGENT_TOKEN_FILE): { token } or { error }
36. static readAgentToken = () => {
37. let f = env('COLONY_AGENT_TOKEN_FILE')
38. if (f == null || f == '') { return { error = 'COLONY_AGENT_TOKEN_FILE is not set (a file holding the secret the scheduler and its agents share)' } }
39. let p = fromCwd(f)
40. if (!exists(p)) { return { error = 'COLONY_AGENT_TOKEN_FILE: no such file: ' + p } }
41. let t = readFile(p).trim()
42. if (t == '') { return { error = 'COLONY_AGENT_TOKEN_FILE is empty: ' + p } }
43. return { token = t }
44. }
46. // GET → the fetch response (status, headers, text(), json())
47. static getRaw = (path, accept) => {
48. return fetch(baseUrl() + path, { headers = { 'user-agent' = userAgent() accept = accept } timeoutMs = 20000 })
49. }
51. // ---- the states (antcolony#27, tickets#20) -------------------------------------------------------------------------
52. // tickets#20 renamed the states: awaiting creator → review (a question → pending), confirmed → done, rejected → reopened,
53. // in progress → progress, on hold → pending. The scheduler's logic keeps ONE vocabulary — the old names — and this file
54. // is the only place that knows both: everything READ is turned into the old names (a server that still speaks them is
55. // left as it is), everything WRITTEN is turned into what the server speaks (`serverIsNew`).
56. static TO_OLD = { 'progress' = 'in progress' 'review' = 'awaiting creator' 'pending' = 'on hold' 'done' = 'confirmed' 'reopened' = 'rejected' }
57. static TO_NEW = { 'in progress' = 'progress' 'awaiting creator' = 'review' 'on hold' = 'pending' 'confirmed' = 'done' 'rejected' = 'reopened' }
58. static STATE_KEYS = ['state', 'to', 'from']
60. static oldStateName = (s) => {
61. let o = TO_OLD[s]
62. return o == null ? s : o
63. }
65. // the tickets answer, read in the old names → a rebuilt copy (Hybriel copies a value it hands over, so nothing is changed in place)
66. static normalizeStates = (j) => {
67. if (isList(j)) {
68. let out = []
69. for (x of j) { out.push(normalizeStates(x)) }
70. return out
71. }
72. if (isObject(j)) {
73. let out = {}
74. for (k of j.keys()) {
75. let v = j[k]
76. if (isString(v)) { out[k] = STATE_KEYS.includes(k) ? oldStateName(v) : v }
77. else { out[k] = normalizeStates(v) }
78. }
79. return out
80. }
81. return j
82. }
84. // does the tickets server speak the new states? (its /api/projects lists them) — decided once it answered, then kept
85. static vocab = { known = false modern = false }
86. static serverIsNew = () => {
87. if (vocab.known) { return vocab.modern }
88. let r = getRaw('/api/projects', 'application/json')
89. if (r == null || r.status != 200) { return false }
90. let j = r.json()
91. vocab.modern = j != null && j.states != null && j.states.includes('review')
92. vocab.known = true
93. return vocab.modern
94. }
96. // the name to WRITE for a state of the scheduler's vocabulary; `question` = a creator question (new server: pending)
97. static writeState = (name, question) => {
98. if (!serverIsNew()) { return name }
99. if (question == true && name == 'awaiting creator') { return 'pending' }
100. let n = TO_NEW[name]
101. return n == null ? name : n
102. }
104. // ---- the creator = an admin of the project (antcolony#27) ------------------------------------------------------------
105. // The creator is the project's admin, not a name: the members of the project (GET /api/projects/<p>) with the role admin.
106. // Events carry the author's display name and — once tickets shows it — the user's id (`userId`); an id is matched when the
107. // event has one, else the name. A server without members (the old tickets) → null: the caller falls back to
108. // COLONY_CREATOR_NAMES. Kept 5 minutes per project.
109. static adminCache = {}
110. static adminsOf = (project) => {
111. let c = adminCache[project]
112. if (c != null && now() - c.at < 300000) { return c.admins }
113. let r = getJson('/api/projects/' + project)
114. let admins = null
115. if (r.status == 200 && r.json != null && r.json.members != null) {
116. admins = { ids = [] names = [] }
117. for (m of r.json.members) {
118. if (m.role == 'admin') {
119. if (m.user != null) { admins.ids.push(m.user) }
120. if (m.name != null && m.name != '') { admins.names.push(m.name) }
121. }
122. }
123. }
124. if (r.status == 200 || r.status == 404) { adminCache[project] = { at = now() admins = admins } }
125. return admins
126. }
128. // was this event written by the creator of `project`? `fallback` = the configured names (old tickets, no members)
129. static isCreatorEvent = (project, e, fallback) => {
130. let a = adminsOf(project)
131. if (a == null) { return fallback.includes(e.author) }
132. let uid = e.userId != null ? e.userId : e.user
133. if (isString(uid) && uid != '' && a.ids.length > 0) { return a.ids.includes(uid) }
134. return a.names.includes(e.author)
135. }
137. // GET JSON → { status, json } (json null unless 200); status 0 = no answer (connection refused, timeout — the
138. // global `on Error` in scheduler.hl absorbs the fetch error, fetch then yields null; mission 020: `run` survives it)
139. static getJson = (path) => {
140. let r = getRaw(path, 'application/json')
141. if (r == null) { return { status = 0 json = null text = 'no answer from ' + baseUrl() } }
142. if (r.status != 200) { return { status = r.status json = null text = r.text() } }
143. return { status = r.status json = normalizeStates(r.json()) }
144. }
146. // POST JSON with the token → { status, json, text }; a `state` in the body is written in the server's names, the answer
147. // is read in the old ones
148. static postJson = (path, body, token) => {
149. if (body != null && isString(body.state)) { body.state = writeState(body.state, false) }
150. let r = fetch(baseUrl() + path, { method = 'POST' headers = { 'user-agent' = userAgent() authorization = 'Bearer ' + token } json = body timeoutMs = 20000 })
151. if (r == null) { return { status = 0 json = null text = 'no answer from ' + baseUrl() } }
152. let t = r.text()
153. let j = null
154. if (t.startsWith('{')) { j = r.json() }
155. return { status = r.status json = normalizeStates(j) text = t }
156. }
158. static ticketPath = (project, number) => { return '/api/projects/' + project + '/tickets/' + number }
160. // the public page of a ticket row
161. static pageUrl = (row) => { return baseUrl() + row.href }
163. // every ticket (rows, no events)
164. static allTickets = () => {
165. let r = getJson('/api/tickets')
166. if (r.status != 200) { return { error = 'GET /api/tickets → ' + r.status } }
167. return { tickets = r.json.tickets }
168. }
170. // a ticket in the creator's inbox (project COLONY_INBOX_PROJECT, state `awaiting creator`),
171. // idempotent by `source`: a known source answers the existing ticket and nothing is written.
172. // parentKey = `<project>#<n>` of the ticket the question belongs to (mission 022: "linked (parent) to the
173. // ticket it belongs to"), or null. → { ticket, created } or { error }
174. static fileQuestion = (token, source, subject, summary, parentKey) => {
175. return fileQuestionIn(token, inboxProject(), source, subject, summary, parentKey)
176. }
178. // the same in any project (mission 022: a report's `questions` go to the ticket's own project).
179. // Idempotent and repairable: a known source creates nothing; the state is set only on a new ticket or on one
180. // that never had a state event (a run that stopped right after creating it) — a question the creator already
181. // moved is never touched; the parent is set only while the question has none (tickets without relations,
182. // i.e. no `children` key in the row, are left alone).
183. static fileQuestionIn = (token, project, source, subject, summary, parentKey) => {
184. let r = postJson('/api/projects/' + project + '/tickets', { subject = subject summary = summary source = source }, token)
185. if (r.status != 200 && r.status != 201) { return { error = 'filing the question failed: ' + r.status + ' ' + r.text } }
186. let t = r.json.ticket
187. let created = r.status == 201
188. let needState = created
189. if (!created && t.state == 'open') {
190. let d = getJson(ticketPath(t.project, t.number))
191. if (d.status == 200) {
192. needState = true
193. for (e of d.json.events) { if (e.kind == 'state') { needState = false } }
194. }
195. }
196. if (needState) {
197. let s = postJson(ticketPath(t.project, t.number) + '/state', { state = writeState('awaiting creator', true) text = 'Waiting for your answer.' }, token)
198. if (s.status != 201) { return { error = 'question ' + t.project + t.ref + ' filed, but setting it to awaiting creator failed: ' + s.status + ' ' + s.text } }
199. t = s.json.ticket
200. }
201. if (parentKey != null && t.keys().includes('children') && t.parent == null) {
202. let p = postJson(ticketPath(t.project, t.number) + '/parent', { parent = parentKey }, token)
203. if (p.status != 201) { return { error = 'question ' + t.project + t.ref + ' filed, but linking it to its parent ' + parentKey + ' failed: ' + p.status + ' ' + p.text } }
204. t = p.json.ticket
205. }
206. return { ticket = t created = created }
207. }