gitoria

3.7 KB

1. // lib/git.hl — GIT ON THE SERVER: where the bare repositories live and how git is called. Each repo is one BARE git
2. // repository, <gitRoot>/<slug>.git (created with the repo: repos.hl createRepo → initRepo). Reads go through the
3. // `git` binary with hl:proc (docs/git-backend.md): an argv list, never a shell, the slug is
4. // validated by the caller (repos-helpers.hl slugError), a path only ever comes from git itself.
5. // Every read calls git with hl:proc run() (hybriel#80: it waits), so the readers answer through their callback
6. // before they return; the page components use the `...Now` forms at construction (server-rendered, gitoria#16).
7. // What is read: the homepage (homepage.hl), the code browser (code.hl), pull requests (pulls.hl), releases (releases.hl).
8. import { run, env, cwd } from 'hl:proc'
9. import { exists, mkDir } from 'hl:fs'
10. import { safeName } from './git-helpers.hl'
12. // where the bare repositories live: GITORIA_GIT, else ./storage/git under the launch directory
13. static gitRoot = env('GITORIA_GIT') != null && env('GITORIA_GIT') != '' ? env('GITORIA_GIT') : cwd() + '/storage/git'
14. static repoDir = (slug) => { return gitRoot + '/' + slug + '.git' }
16. static maxTree = 20000 // paths looked at
17. static seconds = 15 // one git call
19. // one git call: argv (after `git --git-dir=<dir>`), `done({ ok, lines })` exactly once — BEFORE git() returns:
20. // hl:proc run() waits for the program (hybriel#80), so a page's root can read git while it is built on the server
21. // and the callback style of the readers is synchronous. Past `seconds` git is killed; run() is then an Error
22. // (absorbed by project.hl `on Error`) and yields null → ok = false.
23. static git = (slug, rest, limit, done) => {
24. let argv = ['git', '--git-dir=' + repoDir(slug), '-c', 'core.quotePath=false']
25. for (a of rest) { argv.push(a) }
26. let r = run(argv, { timeout = seconds })
27. let lines = []
28. if (r != null) {
29. for (l of r.lines) { if (lines.length < limit) { lines.push(l) } }
30. }
31. done({ ok = r != null && r.exit == 0 lines = lines })
32. return null
33. }
35. // one git call answered directly: run()'s result ({ exit, lines }) or null
36. static gitRaw = (slug, rest) => {
37. let argv = ['git', '--git-dir=' + repoDir(slug), '-c', 'core.quotePath=false']
38. for (a of rest) { argv.push(a) }
39. return run(argv, { timeout = seconds })
40. }
42. // the branch names of a repo → done([name])
43. static branchNames = (slug, done) => {
44. git(slug, ['for-each-ref', '--format=%(refname:short)', 'refs/heads'], 500, (r) => {
45. let out = []
46. if (r.ok) { for (l of r.lines) { if (safeName(l)) { out.push(l) } } }
47. done(out)
48. return null
49. })
50. }
52. // which branch is "main" for a repo: the setting if it exists, else `main`, else the first one; null = no branch
53. static pickDefault = (names, setting) => {
54. if (setting != null && setting != '' && names.includes(setting)) { return setting }
55. if (names.includes('main')) { return 'main' }
56. return names.length > 0 ? names[0] : null
57. }
59. static defaultBranch = (slug, setting, done) => {
60. branchNames(slug, (names) => {
61. done(pickDefault(names, setting))
62. return null
63. })
64. }
66. // a new empty bare repository for a repo (a failure is not fatal: a repo without one just has no files)
67. static initRepo = (slug) => {
68. return run(['git', 'init', '--bare', '-q', '-b', 'main', repoDir(slug)], { timeout = seconds })
69. }
71. // does the repo have no branch yet (nothing pushed)? — the "how to add code" box opens itself then (gitoria#7)
72. static isEmptyNow = (slug) => {
73. let empty = true
74. git(slug, ['for-each-ref', '--count=1', 'refs/heads'], 1, (r) => {
75. empty = !r.ok || r.lines.length == 0
76. return null
77. })
78. return empty
79. }
81. // the folder for temp files beside the repositories (the push / fetch bodies of transport.hl, a key for ssh-keygen in sshkeys.hl)
82. static tmpDir = () => {
83. let d = gitRoot + '/.tmp'
84. if (!exists(d)) { mkDir(d, 448) }
85. return d
86. }