gitoria

5.8 KB

1. // lib/transport.hl — CLONE, FETCH AND PUSH OVER HTTPS (ticket gitoria#7; docs/git-backend.md). Git's "smart HTTP" protocol,
2. // answered by this app itself with the `git` binary: on a repo address `<slug>.<domain>` the paths
3. // /<slug>.git/info/refs?service=git-upload-pack | git-receive-pack (what a client asks first)
4. // /<slug>.git/git-upload-pack (fetch / clone) /<slug>.git/git-receive-pack (push)
5. // spawn `git upload-pack | receive-pack --stateless-rpc` and hand the request body over and the answer back.
6. // The clone URL is https://<slug>.<domain>/<slug>.git — the folder git makes is named like the repo.
7. // * READ (clone, fetch) needs no login: every repo is public (the concept has no private repos yet).
8. // * WRITE (push) needs a token as the password (tokens.hl) of THE REPO'S OWNER — nobody else may push (decision below).
9. // * The body travels through temp files, byte for byte (a String here holds raw bytes; hl:fs writes and reads them as
10. // they are): hl:proc run() has no stdin, so the child reads `< body` and writes `> answer` in a tiny `sh -c` with
11. // the paths as positional arguments (no user text in the script). A gzip body (git compresses big requests) is
12. // unpacked first. Git protocol v2 is passed through (`Git-Protocol` → GIT_PROTOCOL, digits only).
13. // * No hook: pull requests and releases are read from the commits when their page is built.
14. // The checks, the plain answers and the pkt-line are in transport-helpers.hl.
15. import { Response } from 'hl:http1'
16. import { run } from 'hl:proc'
17. import { readFile, writeFile, remove, exists } from 'hl:fs'
18. import { randomBytes } from 'hl:crypto'
19. import { NL, slugOfHost, publicUrl } from './util.hl'
20. import { repoBySlug, mayPush } from './repos.hl'
21. import { slugError } from './repos-helpers.hl'
22. import { userOfToken } from './tokens.hl'
23. import { repoDir, tmpDir } from './git.hl'
24. import { notifyPush } from './tickets.hl'
25. import { passwordOf, plain, protocolEnv, pktLine } from './transport-helpers.hl'
27. static seconds = 300 // one upload-pack / receive-pack call
28. static maxBody = 500000000 // a push or fetch request above this is refused (bytes)
30. // ONE GIT CALL: the request body (or none) in, the answer out. → the answer's bytes as a String, or null (git failed and said nothing)
31. static callGit = (slug, service, advertise, req) => {
32. dir = tmpDir()
33. name = dir + '/' + randomBytes(12, 'hex')
34. inFile = name + '.in'
35. outFile = name + '.out'
36. let zipped = false
37. let script = 'exec git ' + service.slice(4) + ' --stateless-rpc --advertise-refs "$1" > "$3"'
38. if (!advertise) {
39. body = req.body == null ? '' : req.body
40. writeFile(inFile, body, 384)
41. enc = req.headers['content-encoding']
42. zipped = enc != null && hlTypeName(enc) == 'String' && (enc.toLowerCase() == 'gzip' || enc.toLowerCase() == 'x-gzip')
43. script = zipped ? 'gzip -dc < "$2" | git ' + service.slice(4) + ' --stateless-rpc "$1" > "$3"' : 'exec git ' + service.slice(4) + ' --stateless-rpc "$1" < "$2" > "$3"'
44. }
45. r = run(['sh', '-c', script, 'sh', repoDir(slug), inFile, outFile], { timeout = seconds env = protocolEnv(req) })
46. out = exists(outFile) ? readFile(outFile) : null
47. if (exists(inFile)) { remove(inFile) }
48. if (exists(outFile)) { remove(outFile) }
49. // git answers nothing to the client's "0000" probe of a big push (exit 0): that is a 200 with an empty body, as git http-backend does
50. if (out == null || (out == '' && (r == null || r.exit != 0))) { return null }
51. return out
52. }
54. // THE ROUTE (project.hl, a function route): `/:repo/info/refs`, `/:repo/git-upload-pack`, `/:repo/git-receive-pack`
55. static gitTransport = (route, req) => {
56. hostHeader = req.headers['host']
57. slug = slugOfHost(hostHeader == null ? '' : hostHeader.split(':')[0])
58. repoName = route.params.repo
59. if (slug == '' || slugError(slug) != null || repoName != slug + '.git' || repoBySlug(slug) == null) { return plain(404, 'no such repository') }
60. last = req.path.slice(req.path.lastIndexOf('/') + 1)
61. advertise = last == 'refs'
62. service = advertise ? (req.query != null ? req.query.service : null) : last
63. if (service != 'git-upload-pack' && service != 'git-receive-pack') { return plain(403, 'only the smart git protocol is served here: use git clone / fetch / push') }
64. if (advertise && req.method != 'GET') { return plain(405, 'GET only') }
65. if (!advertise && req.method != 'POST') { return plain(405, 'POST only') }
66. if (req.body != null && req.body.length > maxBody) { return plain(413, 'that request is too big') }
68. if (service == 'git-receive-pack') {
69. realm = { 'WWW-Authenticate' = 'Basic realm="gitoria"' }
70. pw = passwordOf(req.headers['authorization'])
71. if (pw == null) { return plain(401, 'pushing needs a token: log in at ' + publicUrl + ', make one under "Access tokens", and use it as the password', realm) }
72. userId = userOfToken(pw)
73. if (userId == null) { return plain(401, 'that token is not valid (removed, or mistyped)', realm) }
74. repo = repoBySlug(slug)
75. if (!mayPush(userId, repo)) { return plain(403, 'only the owner of this repository can push to it') }
76. }
78. let out = callGit(slug, service, advertise, req)
79. if (out == null) { return plain(500, 'git gave no answer') }
80. let headers = { 'Cache-Control' = 'no-cache, max-age=0, must-revalidate' 'Pragma' = 'no-cache' }
81. if (advertise) {
82. headers['Content-Type'] = 'application/x-' + service + '-advertisement'
83. // protocol v2 answers without the service banner; v0/v1 starts with it (as git http-backend does)
84. v2 = protocolEnv(req).GIT_PROTOCOL != null && protocolEnv(req).GIT_PROTOCOL.includes('version=2')
85. if (!v2) { out = pktLine('# service=' + service + NL) + '0000' + out }
86. } else {
87. headers['Content-Type'] = 'application/x-' + service + '-result'
88. // a push arrived: tell the connected tickets project about commits naming a ticket (tickets.hl; never fails the push)
89. if (service == 'git-receive-pack') { notifyPush(slug, false) }
90. }
91. return new Response(out, { headers = headers })
92. }