Merged
fix: AUR vóór self-update, dode jobs na herstart
timfa
wants to merge
2 commits
from
cursor/self-update-herstart-674d
into
stage
Overview Commits 2 Pipelines 2 Changes 13
Wat er misging
Pipeline #140, job 540, bleef twee keer op running staan. self_update poltte tot de update ok was, maar Steve draait in bluegit.service. post_upgrade herstart die service tijdens pacman -U. De container sterft mee en de job blijft running. publish_aur heeft daardoor nooit een geslaagde voorganger. Retry met mode failed pakt een job met status running niet op.
Een poll in publish_aur na een POST die meteen eindigt lost dat niet op: die job loopt dan tijdens de herstart en sterft net zo goed. De updater wacht op publish_aur, en publish_aur wacht op de update.
Wat deze MR doet
1. bluegit serve zet elke job die nog running is op failed. In het nieuwe proces heeft geen van die jobs nog een container. Het log krijgt: BlueGit herstartte terwijl deze job liep; het proces is weg. De pipelinestatus wordt herberekend. Retry met mode failed zet die job terug in de wachtrij, plus een vervolg dat daardoor was overgeslagen.
2. publish_aur draait vóór self_update, met needs: [build] en allow_failure: true. De archive-route staat live, dus de tarball van CI_COMMIT_SHA is te downloaden zonder de nieuwe versie. self_update is de laatste job, met needs: [publish_aur]. Een AUR-fout blokkeert de deploy niet. scripts/self-update.sh doet alleen de POST en eindigt meteen groen. De poll en de jq-afhankelijkheid zijn weg, ook uit bluegit/base en bluegit/go.
3. De uitzondering in de jobtelling is weg. Geen van beide jobs wacht nog op de updater. Elke job met status running telt mee. publish_aur is klaar vóór de POST, en self_update eindigt vóór de bouw en pacman -U.
Een release die de archive-route zelf wijzigt kan publish_aur één keer laten falen, omdat die job nog tegen de oude binary draait. Na de self-update publiceert een retry van die job alsnog. Dat staat in docs/AUR.md.
Niet mergen.
Activity
- timfa Pipeline #142 is Passed 23 October 2026
- timfa opened this merge request 23 October 2026
- timfa Pipeline #143 is Passed 23 October 2026
-
timfa
pushed
23 October 2026
fix: publiceer de AUR vóór de self-update
-
timfa
changed the title
23 October 2026
fix: AUR vóór self-update, dode jobs na herstart
- timfa merged this merge request 23 October 2026
Commits
Pipelines
Changes
@@ -64,13 +64,15 @@ jobs:
paths: [bluegit]
expire_in: 14d
# Na self_update. needs: [] liep tegen de binary van de vorige release.
# allow_failure: een AUR-storing maakt de pipeline niet rood.
# Vóór self_update. De archive-route staat live, dus de tarball van
# deze sha is te downloaden met de binary die al draait.
# allow_failure: een AUR-storing maakt de pipeline niet rood en houdt
# self_update niet tegen.
publish_aur:
stage: release
image: archlinux/archlinux:base-devel
extends: .on_master
needs: [self_update]
needs: [build]
allow_failure: true
script:
- pacman -Syu --noconfirm
@@ -79,16 +81,16 @@ jobs:
- ./scripts/aur-ssh-setup.sh
- ./scripts/publish-aur.sh
# Na een geslaagde build. Het script start de update en polt tot
# status ok is voor deze sha, ongeveer 5 minuten. publish_aur wacht
# op deze job. De updater bouwt zelf uit git; dit artifact gaat niet mee.
# Laatste job. needs: [publish_aur] geldt ook als die job met
# allow_failure mislukt. Alleen de POST; de job eindigt meteen groen.
# De updater bouwt zelf uit git; dit artifact gaat niet mee.
# BLUEGIT_UPDATE_TOKEN is hetzelfde geheim als in /etc/bluegit/env.
# CI_API_URL eindigt op /api/v1.
self_update:
stage: release
image: bluegit/base
extends: .on_master
needs: [build]
needs: [publish_aur]
script:
- chmod +x scripts/self-update.sh
- ./scripts/self-update.sh
@@ -64,13 +64,15 @@ jobs: paths: [bluegit] paths: [bluegit] expire_in: 14d expire_in: 14d # Na self_update. needs: [] liep tegen de binary van de vorige release. # Vóór self_update. De archive-route staat live, dus de tarball van # allow_failure: een AUR-storing maakt de pipeline niet rood. # deze sha is te downloaden met de binary die al draait. # allow_failure: een AUR-storing maakt de pipeline niet rood en houdt # self_update niet tegen. publish_aur: publish_aur: stage: release stage: release image: archlinux/archlinux:base-devel image: archlinux/archlinux:base-devel extends: .on_master extends: .on_master needs: [self_update] needs: [build] allow_failure: true allow_failure: true script: script: - pacman -Syu --noconfirm - pacman -Syu --noconfirm@@ -79,16 +81,16 @@ jobs: - ./scripts/aur-ssh-setup.sh - ./scripts/aur-ssh-setup.sh - ./scripts/publish-aur.sh - ./scripts/publish-aur.sh # Na een geslaagde build. Het script start de update en polt tot # Laatste job. needs: [publish_aur] geldt ook als die job met # status ok is voor deze sha, ongeveer 5 minuten. publish_aur wacht # allow_failure mislukt. Alleen de POST; de job eindigt meteen groen. # op deze job. De updater bouwt zelf uit git; dit artifact gaat niet mee. # De updater bouwt zelf uit git; dit artifact gaat niet mee. # BLUEGIT_UPDATE_TOKEN is hetzelfde geheim als in /etc/bluegit/env. # BLUEGIT_UPDATE_TOKEN is hetzelfde geheim als in /etc/bluegit/env. # CI_API_URL eindigt op /api/v1. # CI_API_URL eindigt op /api/v1. self_update: self_update: stage: release stage: release image: bluegit/base image: bluegit/base extends: .on_master extends: .on_master needs: [build] needs: [publish_aur] script: script: - chmod +x scripts/self-update.sh - chmod +x scripts/self-update.sh - ./scripts/self-update.sh - ./scripts/self-update.sh@@ -107,6 +107,13 @@ func serve(args []string) error {
if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" {
srv.Mail = m
}
abandoned, err := st.FailAbandonedJobs(ctx)
if err != nil {
return err
}
if abandoned > 0 {
log.Info("lopende jobs na herstart als mislukt gemarkeerd", "count", abandoned)
}
var rn *runner.Runner
if cfg.CI.Enabled {
rn = &runner.Runner{
@@ -107,6 +107,13 @@ func serve(args []string) error { if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" { if m, ok := provider.(auth.Mailer); ok && cfg.Auth.ClientSecret != "" { srv.Mail = m srv.Mail = m } } abandoned, err := st.FailAbandonedJobs(ctx) if err != nil { return err } if abandoned > 0 { log.Info("lopende jobs na herstart als mislukt gemarkeerd", "count", abandoned) } var rn *runner.Runner var rn *runner.Runner if cfg.CI.Enabled { if cfg.CI.Enabled { rn = &runner.Runner{ rn = &runner.Runner{@@ -55,9 +55,11 @@ Markeer de geheimen als beschermd en bescherm de branch `master`. Een beschermd
| `AUR_GIT_AUTHOR_EMAIL` | e-mail in de AUR-commit |
| `BLUEGIT_UPDATE_TOKEN` | dezelfde waarde als `BLUEGIT_UPDATE_TOKEN` in `/etc/bluegit/env` op de mini-PC |
`publish_aur` draait op `master` en `main`, met `allow_failure: true` en `needs: [self_update]`, zodat hij pas start als de self-update-job klaar is. Een AUR-storing maakt de pipeline niet rood. Een merge-request-pipeline slaat hem over.
`publish_aur` draait op `master` en `main`, vóór `self_update`, met `allow_failure: true` en `needs: [build]`. De archive-route staat live, dus de tarball van `CI_COMMIT_SHA` is te downloaden met de binary die al draait. Een AUR-storing maakt de pipeline niet rood en houdt `self_update` niet tegen. Een merge-request-pipeline slaat hem over.
`self_update` draait in dezelfde stage, wacht op `build`, en roept daarna `scripts/self-update.sh` aan. Dat script stuurt de sha naar `POST /api/v1/admin/self-update` en polt `GET /api/v1/admin/self-update` tot `status` `ok` is voor diezelfde sha. De timeout is 300 seconden. Een andere sha, ook met `ok`, telt niet. `failed` voor de eigen sha faalt meteen. Een time-out faalt de job, en daardoor start `publish_aur` niet.
Een release die de archive-route zelf wijzigt, kan `publish_aur` één keer laten falen. Die job draait nog tegen de oude binary. `self_update` installeert daarna de nieuwe route. Een retry van alleen `publish_aur` publiceert dan alsnog.
`self_update` is de laatste job in dezelfde stage en wacht op `publish_aur`. Omdat die job `allow_failure: true` heeft, start de deploy ook als de AUR-publicatie mislukt. `scripts/self-update.sh` stuurt de sha naar `POST /api/v1/admin/self-update` en stopt meteen, groen. Er is geen poll. De POST antwoordt 202 zodra de unit start. Steve draait in `bluegit.service`, en `post_upgrade` herstart die service. Een job die op dat moment nog `running` is, sterft mee en blijft anders voor altijd op `running` staan.
`CI_API_URL` eindigt op `/api/v1`. De body mag `ref` zijn; de job stuurt de sha van de pipeline. Zonder `BLUEGIT_UPDATE_TOKEN` op de server antwoordt het endpoint met 404 en faalt de job. Een merge-request-pipeline draait deze job niet: alleen `vet`, `test`, `frontend_checks` en `build`.
@@ -71,9 +73,13 @@ Het clonet of werkt `ssh://aur@aur.archlinux.org/bluegit.git` bij in `~/.cache/b
## Self-update
`self_update` wacht op `build`. Het script polt tot de update `ok` is voor de sha van de pipeline, ongeveer 5 minuten. `publish_aur` wacht op die job (`needs: [self_update]`, `allow_failure: true`) en publiceert daarna.
`publish_aur` wacht op `build` en publiceert de tarball van deze sha. Die URL werkt op de binary die al draait. `self_update` wacht op die job (`needs: [publish_aur]`), doet alleen de POST en eindigt groen. `publish_aur` heeft `allow_failure: true`, dus een AUR-fout blokkeert de deploy niet.
Een release die de archive-route zelf wijzigt kan `publish_aur` één keer laten falen, omdat die job de oude binary gebruikt. De self-update daarna installeert de nieuwe route. Een retry van `publish_aur` publiceert dan alsnog.
`BLUEGIT_UPDATE_TOKEN` is een gemaskeerde, beschermde CI-variabele. Dezelfde waarde staat op de mini-PC in `/etc/bluegit/env` (EnvironmentFile, optioneel). Zonder die variabele antwoordt `POST /api/v1/admin/self-update` met 404. De vergelijking is constant-time, en een burst krijgt 429. De body mag leeg zijn of `ref` / `sha` bevatten. Het endpoint schrijft die ref naar `/var/lib/bluegit/update-request` en start alleen `bluegit-update.service` (`systemctl start --no-block`). De CI-job wacht daarna niet. Een poll in de job zou de herstart niet overleven, en de updater zou op die lopende job blijven wachten.
`BLUEGIT_UPDATE_TOKEN` is een gemaskeerde, beschermde CI-variabele. Dezelfde waarde staat op de mini-PC in `/etc/bluegit/env` (EnvironmentFile, optioneel). Zonder die variabele antwoordt `POST /api/v1/admin/self-update` met 404. De vergelijking is constant-time, en een burst krijgt 429. De body mag leeg zijn of `ref` / `sha` bevatten. Het endpoint schrijft die ref naar `/var/lib/bluegit/update-request` en start alleen `bluegit-update.service` (`systemctl start --no-block`). De CI-job blijft daarna pollen. `self_update` van `timfa/bluegit` telt niet mee in `running`, anders wacht de updater op de job die op hem wacht. Een job met die naam in een andere repository telt wel. Die telling zit in de binary en geldt pas nadat deze versie geïnstalleerd is. De poll leest `status` en `sha` met `jq`, omdat `log` vooraan in de JSON staat en die tekst dezelfde woorden bevat.
Bij `bluegit serve` zet BlueGit elke job die nog `running` is op `failed`. In het nieuwe proces heeft geen van die jobs nog een container. Het log zegt dat BlueGit herstartte terwijl de job liep. Daarna pakt retry met mode `failed` die job op, plus een vervolg dat daardoor was overgeslagen. Elke job met status `running` telt mee. `publish_aur` is dan al klaar en `self_update` eindigt bij de POST, vóór de bouw en `pacman -U`.
De polkit-regel `packaging/bluegit-update.rules` laat gebruiker `bluegit` uitsluitend `start` van die ene unit toe. Geen stop, geen restart, geen andere unit. De unit is een oneshot als root.
@@ -81,7 +87,7 @@ De polkit-regel `packaging/bluegit-update.rules` laat gebruiker `bluegit` uitslu
Mislukt de bouw of de installatie, dan blijft de oude versie staan. De uitvoer staat in het journal van `bluegit-update.service` en, vanaf deze versie, in `/var/lib/bluegit/update.log`. Elke run maakt dat bestand leeg en schrijft het opnieuw (mode 644). `GET /api/v1/admin/self-update` met dezelfde Bearer als de POST geeft `running`, `status`, `sha`, `started_at`, `result`, `error` en `log` (de laatste 200 regels). Het object `update` blijft. Het veld `running` blijft, want de updater wacht tot dat 0 is. Zonder sleutel is het antwoord 404, met een foute sleutel 401.
Een POST die 202 teruggeeft is nog geen installatie. De unit wacht tot `BLUEGIT_UPDATE_TIMEOUT` (standaard 1800 seconden) tot `running` 0 is, ook vóór `pacman -U`. De job `self_update` van `timfa/bluegit` zit niet in die telling. `openapi.json` blijft 404 zolang de oude binary draait.
Een POST die 202 teruggeeft is nog geen installatie. De unit wacht tot `BLUEGIT_UPDATE_TIMEOUT` (standaard 1800 seconden) tot `running` 0 is, ook vóór `pacman -U`. Elke job met status `running` zit in die telling. `openapi.json` blijft 404 zolang de oude binary draait.
`packaging/aur/PKGBUILD` heeft geen `check()`. `makepkg` draait de testsuite niet en komt `unshare` dus niet tegen. De bouw is `go build`. `pkgver` komt uit `git show` op `BLUEGIT_UPDATE_REPO`. Die aanroep zet `safe.directory`: Git weigert ook als root een repo van een andere uid. Mislukt git, dan stopt het script en wordt de status `failed`. Het script dat nu geïnstalleerd is, is dat van het vorige pakket. Deze log en `safe.directory` gelden pas nadat een update deze versie echt geïnstalleerd heeft. Het script schrijft `/var/lib/bluegit/update-status.json` met tijd, sha en resultaat (`running`, `ok`, `failed`). Een installatiebeheerder ziet dat op de Info-pagina en op de setup-pagina.
@@ -55,9 +55,11 @@ Markeer de geheimen als beschermd en bescherm de branch `master`. Een beschermd| `AUR_GIT_AUTHOR_EMAIL` | e-mail in de AUR-commit || `AUR_GIT_AUTHOR_EMAIL` | e-mail in de AUR-commit || `BLUEGIT_UPDATE_TOKEN` | dezelfde waarde als `BLUEGIT_UPDATE_TOKEN` in `/etc/bluegit/env` op de mini-PC || `BLUEGIT_UPDATE_TOKEN` | dezelfde waarde als `BLUEGIT_UPDATE_TOKEN` in `/etc/bluegit/env` op de mini-PC |`publish_aur` draait op `master` en `main`, met `allow_failure: true` en `needs: [self_update]`, zodat hij pas start als de self-update-job klaar is. Een AUR-storing maakt de pipeline niet rood. Een merge-request-pipeline slaat hem over.`publish_aur` draait op `master` en `main`, vóór `self_update`, met `allow_failure: true` en `needs: [build]`. De archive-route staat live, dus de tarball van `CI_COMMIT_SHA` is te downloaden met de binary die al draait. Een AUR-storing maakt de pipeline niet rood en houdt `self_update` niet tegen. Een merge-request-pipeline slaat hem over.`self_update` draait in dezelfde stage, wacht op `build`, en roept daarna `scripts/self-update.sh` aan. Dat script stuurt de sha naar `POST /api/v1/admin/self-update` en polt `GET /api/v1/admin/self-update` tot `status` `ok` is voor diezelfde sha. De timeout is 300 seconden. Een andere sha, ook met `ok`, telt niet. `failed` voor de eigen sha faalt meteen. Een time-out faalt de job, en daardoor start `publish_aur` niet.Een release die de archive-route zelf wijzigt, kan `publish_aur` één keer laten falen. Die job draait nog tegen de oude binary. `self_update` installeert daarna de nieuwe route. Een retry van alleen `publish_aur` publiceert dan alsnog.`self_update` is de laatste job in dezelfde stage en wacht op `publish_aur`. Omdat die job `allow_failure: true` heeft, start de deploy ook als de AUR-publicatie mislukt. `scripts/self-update.sh` stuurt de sha naar `POST /api/v1/admin/self-update` en stopt meteen, groen. Er is geen poll. De POST antwoordt 202 zodra de unit start. Steve draait in `bluegit.service`, en `post_upgrade` herstart die service. Een job die op dat moment nog `running` is, sterft mee en blijft anders voor altijd op `running` staan.`CI_API_URL` eindigt op `/api/v1`. De body mag `ref` zijn; de job stuurt de sha van de pipeline. Zonder `BLUEGIT_UPDATE_TOKEN` op de server antwoordt het endpoint met 404 en faalt de job. Een merge-request-pipeline draait deze job niet: alleen `vet`, `test`, `frontend_checks` en `build`.`CI_API_URL` eindigt op `/api/v1`. De body mag `ref` zijn; de job stuurt de sha van de pipeline. Zonder `BLUEGIT_UPDATE_TOKEN` op de server antwoordt het endpoint met 404 en faalt de job. Een merge-request-pipeline draait deze job niet: alleen `vet`, `test`, `frontend_checks` en `build`.@@ -71,9 +73,13 @@ Het clonet of werkt `ssh://aur@aur.archlinux.org/bluegit.git` bij in `~/.cache/b## Self-update## Self-update`self_update` wacht op `build`. Het script polt tot de update `ok` is voor de sha van de pipeline, ongeveer 5 minuten. `publish_aur` wacht op die job (`needs: [self_update]`, `allow_failure: true`) en publiceert daarna.`publish_aur` wacht op `build` en publiceert de tarball van deze sha. Die URL werkt op de binary die al draait. `self_update` wacht op die job (`needs: [publish_aur]`), doet alleen de POST en eindigt groen. `publish_aur` heeft `allow_failure: true`, dus een AUR-fout blokkeert de deploy niet.Een release die de archive-route zelf wijzigt kan `publish_aur` één keer laten falen, omdat die job de oude binary gebruikt. De self-update daarna installeert de nieuwe route. Een retry van `publish_aur` publiceert dan alsnog.`BLUEGIT_UPDATE_TOKEN` is een gemaskeerde, beschermde CI-variabele. Dezelfde waarde staat op de mini-PC in `/etc/bluegit/env` (EnvironmentFile, optioneel). Zonder die variabele antwoordt `POST /api/v1/admin/self-update` met 404. De vergelijking is constant-time, en een burst krijgt 429. De body mag leeg zijn of `ref` / `sha` bevatten. Het endpoint schrijft die ref naar `/var/lib/bluegit/update-request` en start alleen `bluegit-update.service` (`systemctl start --no-block`). De CI-job wacht daarna niet. Een poll in de job zou de herstart niet overleven, en de updater zou op die lopende job blijven wachten.`BLUEGIT_UPDATE_TOKEN` is een gemaskeerde, beschermde CI-variabele. Dezelfde waarde staat op de mini-PC in `/etc/bluegit/env` (EnvironmentFile, optioneel). Zonder die variabele antwoordt `POST /api/v1/admin/self-update` met 404. De vergelijking is constant-time, en een burst krijgt 429. De body mag leeg zijn of `ref` / `sha` bevatten. Het endpoint schrijft die ref naar `/var/lib/bluegit/update-request` en start alleen `bluegit-update.service` (`systemctl start --no-block`). De CI-job blijft daarna pollen. `self_update` van `timfa/bluegit` telt niet mee in `running`, anders wacht de updater op de job die op hem wacht. Een job met die naam in een andere repository telt wel. Die telling zit in de binary en geldt pas nadat deze versie geïnstalleerd is. De poll leest `status` en `sha` met `jq`, omdat `log` vooraan in de JSON staat en die tekst dezelfde woorden bevat.Bij `bluegit serve` zet BlueGit elke job die nog `running` is op `failed`. In het nieuwe proces heeft geen van die jobs nog een container. Het log zegt dat BlueGit herstartte terwijl de job liep. Daarna pakt retry met mode `failed` die job op, plus een vervolg dat daardoor was overgeslagen. Elke job met status `running` telt mee. `publish_aur` is dan al klaar en `self_update` eindigt bij de POST, vóór de bouw en `pacman -U`.De polkit-regel `packaging/bluegit-update.rules` laat gebruiker `bluegit` uitsluitend `start` van die ene unit toe. Geen stop, geen restart, geen andere unit. De unit is een oneshot als root.De polkit-regel `packaging/bluegit-update.rules` laat gebruiker `bluegit` uitsluitend `start` van die ene unit toe. Geen stop, geen restart, geen andere unit. De unit is een oneshot als root.@@ -81,7 +87,7 @@ De polkit-regel `packaging/bluegit-update.rules` laat gebruiker `bluegit` uitsluMislukt de bouw of de installatie, dan blijft de oude versie staan. De uitvoer staat in het journal van `bluegit-update.service` en, vanaf deze versie, in `/var/lib/bluegit/update.log`. Elke run maakt dat bestand leeg en schrijft het opnieuw (mode 644). `GET /api/v1/admin/self-update` met dezelfde Bearer als de POST geeft `running`, `status`, `sha`, `started_at`, `result`, `error` en `log` (de laatste 200 regels). Het object `update` blijft. Het veld `running` blijft, want de updater wacht tot dat 0 is. Zonder sleutel is het antwoord 404, met een foute sleutel 401.Mislukt de bouw of de installatie, dan blijft de oude versie staan. De uitvoer staat in het journal van `bluegit-update.service` en, vanaf deze versie, in `/var/lib/bluegit/update.log`. Elke run maakt dat bestand leeg en schrijft het opnieuw (mode 644). `GET /api/v1/admin/self-update` met dezelfde Bearer als de POST geeft `running`, `status`, `sha`, `started_at`, `result`, `error` en `log` (de laatste 200 regels). Het object `update` blijft. Het veld `running` blijft, want de updater wacht tot dat 0 is. Zonder sleutel is het antwoord 404, met een foute sleutel 401.Een POST die 202 teruggeeft is nog geen installatie. De unit wacht tot `BLUEGIT_UPDATE_TIMEOUT` (standaard 1800 seconden) tot `running` 0 is, ook vóór `pacman -U`. De job `self_update` van `timfa/bluegit` zit niet in die telling. `openapi.json` blijft 404 zolang de oude binary draait.Een POST die 202 teruggeeft is nog geen installatie. De unit wacht tot `BLUEGIT_UPDATE_TIMEOUT` (standaard 1800 seconden) tot `running` 0 is, ook vóór `pacman -U`. Elke job met status `running` zit in die telling. `openapi.json` blijft 404 zolang de oude binary draait.`packaging/aur/PKGBUILD` heeft geen `check()`. `makepkg` draait de testsuite niet en komt `unshare` dus niet tegen. De bouw is `go build`. `pkgver` komt uit `git show` op `BLUEGIT_UPDATE_REPO`. Die aanroep zet `safe.directory`: Git weigert ook als root een repo van een andere uid. Mislukt git, dan stopt het script en wordt de status `failed`. Het script dat nu geïnstalleerd is, is dat van het vorige pakket. Deze log en `safe.directory` gelden pas nadat een update deze versie echt geïnstalleerd heeft. Het script schrijft `/var/lib/bluegit/update-status.json` met tijd, sha en resultaat (`running`, `ok`, `failed`). Een installatiebeheerder ziet dat op de Info-pagina en op de setup-pagina.`packaging/aur/PKGBUILD` heeft geen `check()`. `makepkg` draait de testsuite niet en komt `unshare` dus niet tegen. De bouw is `go build`. `pkgver` komt uit `git show` op `BLUEGIT_UPDATE_REPO`. Die aanroep zet `safe.directory`: Git weigert ook als root een repo van een andere uid. Mislukt git, dan stopt het script en wordt de status `failed`. Het script dat nu geïnstalleerd is, is dat van het vorige pakket. Deze log en `safe.directory` gelden pas nadat een update deze versie echt geïnstalleerd heeft. Het script schrijft `/var/lib/bluegit/update-status.json` met tijd, sha en resultaat (`running`, `ok`, `failed`). Een installatiebeheerder ziet dat op de Info-pagina en op de setup-pagina.@@ -90,7 +90,7 @@ Steve heeft geen aparte runners per taal. `image: bluegit/base` en de andere ali
| Preset | Basis |
| --- | --- |
| `bluegit/base` | Alpine 3.20, met git, curl, bash en jq |
| `bluegit/base` | Alpine 3.20, met git, curl en bash |
| `bluegit/node` | Node.js 22 |
| `bluegit/python` | Python 3.12 |
| `bluegit/go` | Go 1.22, plus `git-daemon` zodat `git http-backend` aanwezig is |
@@ -90,7 +90,7 @@ Steve heeft geen aparte runners per taal. `image: bluegit/base` en de andere ali| Preset | Basis || Preset | Basis || --- | --- || --- | --- || `bluegit/base` | Alpine 3.20, met git, curl, bash en jq || `bluegit/base` | Alpine 3.20, met git, curl en bash || `bluegit/node` | Node.js 22 || `bluegit/node` | Node.js 22 || `bluegit/python` | Python 3.12 || `bluegit/python` | Python 3.12 || `bluegit/go` | Go 1.22, plus `git-daemon` zodat `git http-backend` aanwezig is || `bluegit/go` | Go 1.22, plus `git-daemon` zodat `git http-backend` aanwezig is |@@ -88,52 +88,66 @@ func TestBlueGitExampleFile(t *testing.T) {
t.Fatalf("master %d %v", len(active), err)
}
aur := by["publish_aur"]
if !aur.AllowFailure || !aur.NeedsSet || len(aur.Needs) != 1 || aur.Needs[0] != "self_update" {
if !aur.AllowFailure || !aur.NeedsSet || len(aur.Needs) != 1 || aur.Needs[0] != "build" {
t.Fatalf("publish_aur: %+v", aur)
}
aurScript := strings.Join(aur.Script, "\n")
if strings.Contains(aurScript, "wait-self-update") || strings.Contains(aurScript, "jq") || !strings.Contains(aurScript, "scripts/publish-aur.sh") {
t.Fatalf("publish_aur publiceert zonder poll: %s", aurScript)
}
if Gate(p.Jobs, map[string]string{
"vet": "success", "test": "success", "frontend_checks": "success",
"build": "success", "self_update": "running",
"build": "running",
}, aur) != "wait" {
t.Fatal("publish_aur wacht tot self_update klaar is")
t.Fatal("publish_aur wacht op build")
}
if Gate(p.Jobs, map[string]string{
"vet": "success", "test": "success", "frontend_checks": "success",
"build": "success", "self_update": "success",
"build": "success", "self_update": "running",
}, aur) != "ready" {
t.Fatal("publish_aur start na self_update")
t.Fatal("publish_aur start na build, vóór self_update")
}
upd := by["self_update"]
if !upd.NeedsSet || len(upd.Needs) != 1 || upd.Needs[0] != "build" {
t.Fatalf("self_update hoort alleen op build te wachten: %+v", upd)
if !upd.NeedsSet || len(upd.Needs) != 1 || upd.Needs[0] != "publish_aur" {
t.Fatalf("self_update hoort op publish_aur te wachten: %+v", upd)
}
joined := strings.Join(upd.Script, "\n")
if !strings.Contains(joined, "scripts/self-update.sh") {
if !strings.Contains(joined, "scripts/self-update.sh") || strings.Contains(joined, "jq") {
t.Fatalf("self_update: %s", joined)
}
script, err := os.ReadFile("../../scripts/self-update.sh")
post, err := os.ReadFile("../../scripts/self-update.sh")
if err != nil {
t.Fatal(err)
}
text := string(script)
for _, want := range []string{
`/admin/self-update`, "BLUEGIT_UPDATE_TOKEN", "CI_COMMIT_SHA", `"ok"`, "300", "jq -er",
} {
if !strings.Contains(text, want) {
postText := string(post)
for _, want := range []string{`/admin/self-update`, "BLUEGIT_UPDATE_TOKEN", "CI_COMMIT_SHA", "POST"} {
if !strings.Contains(postText, want) {
t.Fatalf("self-update.sh mist %q", want)
}
}
if strings.Contains(postText, "jq") || strings.Contains(postText, "while true") {
t.Fatal("self-update.sh hoort alleen de POST te doen")
}
if _, err := os.Stat("../../scripts/wait-self-update.sh"); !os.IsNotExist(err) {
t.Fatal("de poll hoort weg te zijn")
}
if Gate(p.Jobs, map[string]string{
"vet": "success", "test": "success", "frontend_checks": "success",
"build": "queued", "publish_aur": "running",
"build": "success", "publish_aur": "running",
}, upd) != "wait" {
t.Fatal("self_update wacht op build")
t.Fatal("self_update wacht tot publish_aur klaar is")
}
if Gate(p.Jobs, map[string]string{
"vet": "success", "test": "success", "frontend_checks": "success",
"build": "success", "publish_aur": "running",
"build": "success", "publish_aur": "success",
}, upd) != "ready" {
t.Fatal("self_update start na een geslaagde publish_aur")
}
if Gate(p.Jobs, map[string]string{
"vet": "success", "test": "success", "frontend_checks": "success",
"build": "success", "publish_aur": "failed",
}, upd) != "ready" {
t.Fatal("self_update hoort klaar te zijn terwijl publish_aur nog loopt")
t.Fatal("een AUR-fout met allow_failure hoort de deploy niet te blokkeren")
}
}
@@ -88,52 +88,66 @@ func TestBlueGitExampleFile(t *testing.T) { t.Fatalf("master %d %v", len(active), err) t.Fatalf("master %d %v", len(active), err) } } aur := by["publish_aur"] aur := by["publish_aur"] if !aur.AllowFailure || !aur.NeedsSet || len(aur.Needs) != 1 || aur.Needs[0] != "self_update" { if !aur.AllowFailure || !aur.NeedsSet || len(aur.Needs) != 1 || aur.Needs[0] != "build" { t.Fatalf("publish_aur: %+v", aur) t.Fatalf("publish_aur: %+v", aur) } } aurScript := strings.Join(aur.Script, "\n") if strings.Contains(aurScript, "wait-self-update") || strings.Contains(aurScript, "jq") || !strings.Contains(aurScript, "scripts/publish-aur.sh") { t.Fatalf("publish_aur publiceert zonder poll: %s", aurScript) } if Gate(p.Jobs, map[string]string{ if Gate(p.Jobs, map[string]string{ "vet": "success", "test": "success", "frontend_checks": "success", "vet": "success", "test": "success", "frontend_checks": "success", "build": "success", "self_update": "running", "build": "running", }, aur) != "wait" { }, aur) != "wait" { t.Fatal("publish_aur wacht tot self_update klaar is") t.Fatal("publish_aur wacht op build") } } if Gate(p.Jobs, map[string]string{ if Gate(p.Jobs, map[string]string{ "vet": "success", "test": "success", "frontend_checks": "success", "vet": "success", "test": "success", "frontend_checks": "success", "build": "success", "self_update": "success", "build": "success", "self_update": "running", }, aur) != "ready" { }, aur) != "ready" { t.Fatal("publish_aur start na self_update") t.Fatal("publish_aur start na build, vóór self_update") } } upd := by["self_update"] upd := by["self_update"] if !upd.NeedsSet || len(upd.Needs) != 1 || upd.Needs[0] != "build" { if !upd.NeedsSet || len(upd.Needs) != 1 || upd.Needs[0] != "publish_aur" { t.Fatalf("self_update hoort alleen op build te wachten: %+v", upd) t.Fatalf("self_update hoort op publish_aur te wachten: %+v", upd) } } joined := strings.Join(upd.Script, "\n") joined := strings.Join(upd.Script, "\n") if !strings.Contains(joined, "scripts/self-update.sh") { if !strings.Contains(joined, "scripts/self-update.sh") || strings.Contains(joined, "jq") { t.Fatalf("self_update: %s", joined) t.Fatalf("self_update: %s", joined) } } script, err := os.ReadFile("../../scripts/self-update.sh") post, err := os.ReadFile("../../scripts/self-update.sh") if err != nil { if err != nil { t.Fatal(err) t.Fatal(err) } } text := string(script) postText := string(post) for _, want := range []string{ for _, want := range []string{`/admin/self-update`, "BLUEGIT_UPDATE_TOKEN", "CI_COMMIT_SHA", "POST"} { `/admin/self-update`, "BLUEGIT_UPDATE_TOKEN", "CI_COMMIT_SHA", `"ok"`, "300", "jq -er", if !strings.Contains(postText, want) { } { if !strings.Contains(text, want) { t.Fatalf("self-update.sh mist %q", want) t.Fatalf("self-update.sh mist %q", want) } } } } if strings.Contains(postText, "jq") || strings.Contains(postText, "while true") { t.Fatal("self-update.sh hoort alleen de POST te doen") } if _, err := os.Stat("../../scripts/wait-self-update.sh"); !os.IsNotExist(err) { t.Fatal("de poll hoort weg te zijn") } if Gate(p.Jobs, map[string]string{ if Gate(p.Jobs, map[string]string{ "vet": "success", "test": "success", "frontend_checks": "success", "vet": "success", "test": "success", "frontend_checks": "success", "build": "queued", "publish_aur": "running", "build": "success", "publish_aur": "running", }, upd) != "wait" { }, upd) != "wait" { t.Fatal("self_update wacht op build") t.Fatal("self_update wacht tot publish_aur klaar is") } } if Gate(p.Jobs, map[string]string{ if Gate(p.Jobs, map[string]string{ "vet": "success", "test": "success", "frontend_checks": "success", "vet": "success", "test": "success", "frontend_checks": "success", "build": "success", "publish_aur": "running", "build": "success", "publish_aur": "success", }, upd) != "ready" { t.Fatal("self_update start na een geslaagde publish_aur") } if Gate(p.Jobs, map[string]string{ "vet": "success", "test": "success", "frontend_checks": "success", "build": "success", "publish_aur": "failed", }, upd) != "ready" { }, upd) != "ready" { t.Fatal("self_update hoort klaar te zijn terwijl publish_aur nog loopt") t.Fatal("een AUR-fout met allow_failure hoort de deploy niet te blokkeren") } }}}@@ -1,3 +1,3 @@
# runtime: Alpine 3.20
FROM alpine:3.20
RUN apk add --no-cache bash ca-certificates curl git jq
RUN apk add --no-cache bash ca-certificates curl git
@@ -1,3 +1,3 @@# runtime: Alpine 3.20# runtime: Alpine 3.20FROM alpine:3.20FROM alpine:3.20RUN apk add --no-cache bash ca-certificates curl git jqRUN apk add --no-cache bash ca-certificates curl git@@ -3,6 +3,6 @@ FROM golang:1.22-alpine
# git-daemon levert git-http-backend. Zonder die binary spreekt een
# testserver geen smart HTTP en valt git push terug op dumb HTTP (code 22).
# git-remote-http hoort bij git zelf en is de client voor die push.
RUN apk add --no-cache bash ca-certificates curl git git-daemon jq
RUN apk add --no-cache bash ca-certificates curl git git-daemon
RUN test -x "$(git --exec-path)/git-http-backend" \
&& test -e "$(git --exec-path)/git-remote-http"
@@ -3,6 +3,6 @@ FROM golang:1.22-alpine# git-daemon levert git-http-backend. Zonder die binary spreekt een# git-daemon levert git-http-backend. Zonder die binary spreekt een# testserver geen smart HTTP en valt git push terug op dumb HTTP (code 22).# testserver geen smart HTTP en valt git push terug op dumb HTTP (code 22).# git-remote-http hoort bij git zelf en is de client voor die push.# git-remote-http hoort bij git zelf en is de client voor die push.RUN apk add --no-cache bash ca-certificates curl git git-daemon jqRUN apk add --no-cache bash ca-certificates curl git git-daemonRUN test -x "$(git --exec-path)/git-http-backend" \RUN test -x "$(git --exec-path)/git-http-backend" \ && test -e "$(git --exec-path)/git-remote-http" && test -e "$(git --exec-path)/git-remote-http"@@ -0,0 +1,130 @@
package store
import (
"context"
"strings"
"testing"
)
func TestFailAbandonedJobsThenRetryFailed(t *testing.T) {
s := openTest(t)
ctx := context.Background()
tim, err := s.UpsertUser(ctx, 1, "tim", "", false)
if err != nil {
t.Fatal(err)
}
repo, err := s.CreateRepo(ctx, "user", tim.ID, "bluegit", "", "master", "public")
if err != nil {
t.Fatal(err)
}
sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
id, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/master", "push", "tim", "release", []NewJob{
{Name: "build", Stage: "build", Position: 0, Script: "go build"},
{Name: "publish_aur", Stage: "release", Position: 1, Script: "aur", Needs: []string{"build"}, NeedsSet: true, AllowFailure: true},
{Name: "self_update", Stage: "release", Position: 2, Script: "post", Needs: []string{"publish_aur"}, NeedsSet: true},
})
if err != nil {
t.Fatal(err)
}
queuedID, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/topic", "push", "tim", "side", []NewJob{
{Name: "wait", Stage: "test", Script: "sleep"},
})
if err != nil {
t.Fatal(err)
}
softID, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/soft", "push", "tim", "soft", []NewJob{
{Name: "build", Stage: "build", Script: "go build"},
{Name: "publish_aur", Stage: "release", Script: "aur", AllowFailure: true},
})
if err != nil {
t.Fatal(err)
}
set := func(pipe int64, name, status, log string) {
t.Helper()
if _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = ?, started_at = ? WHERE pipeline_id = ? AND name = ?`, status, log, now(), pipe, name); err != nil {
t.Fatal(err)
}
}
set(id, "build", "success", "ok\n")
set(id, "publish_aur", "success", "aur ok\n")
set(id, "self_update", "running", "post verstuurd\n")
set(queuedID, "wait", "queued", "")
set(softID, "build", "success", "ok\n")
set(softID, "publish_aur", "running", "bezig\n")
if _, err := s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running' WHERE id IN (?, ?, ?)`, id, queuedID, softID); err != nil {
t.Fatal(err)
}
n, err := s.FailAbandonedJobs(ctx)
if err != nil || n != 2 {
t.Fatalf("abandoned: %d %v", n, err)
}
jobs, err := s.JobsByPipeline(ctx, id)
if err != nil {
t.Fatal(err)
}
by := map[string]Job{}
for _, j := range jobs {
by[j.Name] = j
}
upd := by["self_update"]
if upd.Status != "failed" || upd.FinishedAt.IsZero() || upd.StartedAt.IsZero() || !strings.Contains(upd.Log, "post verstuurd\n") || !strings.Contains(upd.Log, AbandonedJobNote) {
t.Fatalf("self_update: status=%s log=%q started=%v finished=%v", upd.Status, upd.Log, upd.StartedAt, upd.FinishedAt)
}
if by["build"].Status != "success" || by["publish_aur"].Status != "success" {
t.Fatalf("andere jobs: build=%s publish=%s", by["build"].Status, by["publish_aur"].Status)
}
p, err := s.PipelineByID(ctx, repo.ID, id)
if err != nil || p.Status != "failed" || p.FinishedAt.IsZero() {
t.Fatalf("pipeline: %+v %v", p, err)
}
if got := jobStatus(t, s, queuedID)["wait"]; got != "queued" {
t.Fatalf("wachtende job: %s", got)
}
queuedPipe, err := s.PipelineByID(ctx, repo.ID, queuedID)
if err != nil || queuedPipe.Status != "running" {
t.Fatalf("pipeline zonder dode job: %+v %v", queuedPipe, err)
}
softJobs, err := s.JobsByPipeline(ctx, softID)
if err != nil {
t.Fatal(err)
}
for _, j := range softJobs {
if j.Name == "publish_aur" && (j.Status != "failed" || !strings.Contains(j.Log, AbandonedJobNote)) {
t.Fatalf("allow_failure job: status=%s log=%q", j.Status, j.Log)
}
}
softPipe, err := s.PipelineByID(ctx, repo.ID, softID)
if err != nil || softPipe.Status != "success" {
t.Fatalf("alleen een zachte mislukking: %+v %v", softPipe, err)
}
running, err := s.CountRunningJobs(ctx)
if err != nil || running != 0 {
t.Fatalf("running na herstart: %d %v", running, err)
}
again, err := s.FailAbandonedJobs(ctx)
if err != nil || again != 0 {
t.Fatalf("tweede start: %d %v", again, err)
}
ok, err := s.RetryFailedJobs(ctx, id)
if err != nil || !ok {
t.Fatalf("retry: %v %v", ok, err)
}
got := jobStatus(t, s, id)
if got["build"] != "success" || got["publish_aur"] != "success" || got["self_update"] != "queued" {
t.Fatalf("mode failed: %v", got)
}
retried, err := s.JobsByPipeline(ctx, id)
if err != nil {
t.Fatal(err)
}
for _, j := range retried {
if j.Name == "self_update" && (j.Log != "" || !j.FinishedAt.IsZero()) {
t.Fatalf("retry maakt de job leeg: log=%q finished=%v", j.Log, j.FinishedAt)
}
}
if side := jobStatus(t, s, queuedID)["wait"]; side != "queued" {
t.Fatalf("retry van de release raakt de andere pipeline: %s", side)
}
}
@@ -0,0 +1,130 @@package storeimport ( "context" "strings" "testing")func TestFailAbandonedJobsThenRetryFailed(t *testing.T) { s := openTest(t) ctx := context.Background() tim, err := s.UpsertUser(ctx, 1, "tim", "", false) if err != nil { t.Fatal(err) } repo, err := s.CreateRepo(ctx, "user", tim.ID, "bluegit", "", "master", "public") if err != nil { t.Fatal(err) } sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" id, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/master", "push", "tim", "release", []NewJob{ {Name: "build", Stage: "build", Position: 0, Script: "go build"}, {Name: "publish_aur", Stage: "release", Position: 1, Script: "aur", Needs: []string{"build"}, NeedsSet: true, AllowFailure: true}, {Name: "self_update", Stage: "release", Position: 2, Script: "post", Needs: []string{"publish_aur"}, NeedsSet: true}, }) if err != nil { t.Fatal(err) } queuedID, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/topic", "push", "tim", "side", []NewJob{ {Name: "wait", Stage: "test", Script: "sleep"}, }) if err != nil { t.Fatal(err) } softID, err := s.CreatePipeline(ctx, repo.ID, sha, "refs/heads/soft", "push", "tim", "soft", []NewJob{ {Name: "build", Stage: "build", Script: "go build"}, {Name: "publish_aur", Stage: "release", Script: "aur", AllowFailure: true}, }) if err != nil { t.Fatal(err) } set := func(pipe int64, name, status, log string) { t.Helper() if _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = ?, started_at = ? WHERE pipeline_id = ? AND name = ?`, status, log, now(), pipe, name); err != nil { t.Fatal(err) } } set(id, "build", "success", "ok\n") set(id, "publish_aur", "success", "aur ok\n") set(id, "self_update", "running", "post verstuurd\n") set(queuedID, "wait", "queued", "") set(softID, "build", "success", "ok\n") set(softID, "publish_aur", "running", "bezig\n") if _, err := s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running' WHERE id IN (?, ?, ?)`, id, queuedID, softID); err != nil { t.Fatal(err) } n, err := s.FailAbandonedJobs(ctx) if err != nil || n != 2 { t.Fatalf("abandoned: %d %v", n, err) } jobs, err := s.JobsByPipeline(ctx, id) if err != nil { t.Fatal(err) } by := map[string]Job{} for _, j := range jobs { by[j.Name] = j } upd := by["self_update"] if upd.Status != "failed" || upd.FinishedAt.IsZero() || upd.StartedAt.IsZero() || !strings.Contains(upd.Log, "post verstuurd\n") || !strings.Contains(upd.Log, AbandonedJobNote) { t.Fatalf("self_update: status=%s log=%q started=%v finished=%v", upd.Status, upd.Log, upd.StartedAt, upd.FinishedAt) } if by["build"].Status != "success" || by["publish_aur"].Status != "success" { t.Fatalf("andere jobs: build=%s publish=%s", by["build"].Status, by["publish_aur"].Status) } p, err := s.PipelineByID(ctx, repo.ID, id) if err != nil || p.Status != "failed" || p.FinishedAt.IsZero() { t.Fatalf("pipeline: %+v %v", p, err) } if got := jobStatus(t, s, queuedID)["wait"]; got != "queued" { t.Fatalf("wachtende job: %s", got) } queuedPipe, err := s.PipelineByID(ctx, repo.ID, queuedID) if err != nil || queuedPipe.Status != "running" { t.Fatalf("pipeline zonder dode job: %+v %v", queuedPipe, err) } softJobs, err := s.JobsByPipeline(ctx, softID) if err != nil { t.Fatal(err) } for _, j := range softJobs { if j.Name == "publish_aur" && (j.Status != "failed" || !strings.Contains(j.Log, AbandonedJobNote)) { t.Fatalf("allow_failure job: status=%s log=%q", j.Status, j.Log) } } softPipe, err := s.PipelineByID(ctx, repo.ID, softID) if err != nil || softPipe.Status != "success" { t.Fatalf("alleen een zachte mislukking: %+v %v", softPipe, err) } running, err := s.CountRunningJobs(ctx) if err != nil || running != 0 { t.Fatalf("running na herstart: %d %v", running, err) } again, err := s.FailAbandonedJobs(ctx) if err != nil || again != 0 { t.Fatalf("tweede start: %d %v", again, err) } ok, err := s.RetryFailedJobs(ctx, id) if err != nil || !ok { t.Fatalf("retry: %v %v", ok, err) } got := jobStatus(t, s, id) if got["build"] != "success" || got["publish_aur"] != "success" || got["self_update"] != "queued" { t.Fatalf("mode failed: %v", got) } retried, err := s.JobsByPipeline(ctx, id) if err != nil { t.Fatal(err) } for _, j := range retried { if j.Name == "self_update" && (j.Log != "" || !j.FinishedAt.IsZero()) { t.Fatalf("retry maakt de job leeg: log=%q finished=%v", j.Log, j.FinishedAt) } } if side := jobStatus(t, s, queuedID)["wait"]; side != "queued" { t.Fatalf("retry van de release raakt de andere pipeline: %s", side) }}@@ -934,26 +934,64 @@ func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
return n == 1, nil
}
// AbandonedJobNote komt in het log van een job die de herstart niet haalde.
// Steve zit in dit proces. Een job die nog running is, heeft hier geen container.
const AbandonedJobNote = "BlueGit herstartte terwijl deze job liep; het proces is weg.\n"
// FailAbandonedJobs zet elke job met status running op failed.
// Aanroep dit bij het starten van de service, vóór de runner jobs oppakt.
// Een tweede keer doet niets. De pipelinestatus wordt daarna opnieuw berekend,
// zodat retry met mode failed deze jobs en hun wachtende vervolg oppakt.
func (s *Store) FailAbandonedJobs(ctx context.Context) (int, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id, pipeline_id FROM jobs WHERE status = 'running' ORDER BY id`)
if err != nil {
return 0, err
}
defer rows.Close()
type item struct{ id, pipe int64 }
var found []item
for rows.Next() {
var it item
if err := rows.Scan(&it.id, &it.pipe); err != nil {
return 0, err
}
found = append(found, it)
}
if err := rows.Err(); err != nil {
return 0, err
}
n := 0
seen := map[int64]struct{}{}
var pipes []int64
for _, it := range found {
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'failed', log = log || ?, finished_at = ? WHERE id = ? AND status = 'running'`, AbandonedJobNote, now(), it.id)
if err != nil {
return n, err
}
affected, _ := res.RowsAffected()
if affected == 0 {
continue
}
n++
if _, ok := seen[it.pipe]; !ok {
seen[it.pipe] = struct{}{}
pipes = append(pipes, it.pipe)
}
}
for _, id := range pipes {
if _, err := s.RefreshPipelineStatus(ctx, id); err != nil {
return n, err
}
}
return n, nil
}
// CountRunningJobs telt jobs die Steve nu uitvoert.
// self_update van timfa/bluegit blijft buiten de telling. Die job polt tot
// deze update status ok heeft. Meerekenen laat wait_until_idle op die poll
// wachten, en de poll op pacman -U. Dezelfde jobnaam in een andere repo telt wel.
// publish_aur eindigt vóór de POST en self_update eindigt meteen daarna,
// dus er is geen job die tijdens de installatie op de updater wacht.
func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {
var n int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM jobs j
WHERE j.status = 'running'
AND NOT (
j.name = 'self_update'
AND j.repo_id IN (
SELECT r.id FROM repos r
WHERE r.name = 'bluegit'
AND (
(r.owner_kind = 'user' AND r.owner_id = (SELECT id FROM users WHERE username = 'timfa'))
OR (r.owner_kind = 'group' AND r.owner_id = (SELECT id FROM groups WHERE path = 'timfa'))
)
)
)`).Scan(&n)
err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n)
return n, err
}
@@ -934,26 +934,64 @@ func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) { return n == 1, nil return n == 1, nil}}// AbandonedJobNote komt in het log van een job die de herstart niet haalde.// Steve zit in dit proces. Een job die nog running is, heeft hier geen container.const AbandonedJobNote = "BlueGit herstartte terwijl deze job liep; het proces is weg.\n"// FailAbandonedJobs zet elke job met status running op failed.// Aanroep dit bij het starten van de service, vóór de runner jobs oppakt.// Een tweede keer doet niets. De pipelinestatus wordt daarna opnieuw berekend,// zodat retry met mode failed deze jobs en hun wachtende vervolg oppakt.func (s *Store) FailAbandonedJobs(ctx context.Context) (int, error) { rows, err := s.db.QueryContext(ctx, `SELECT id, pipeline_id FROM jobs WHERE status = 'running' ORDER BY id`) if err != nil { return 0, err } defer rows.Close() type item struct{ id, pipe int64 } var found []item for rows.Next() { var it item if err := rows.Scan(&it.id, &it.pipe); err != nil { return 0, err } found = append(found, it) } if err := rows.Err(); err != nil { return 0, err } n := 0 seen := map[int64]struct{}{} var pipes []int64 for _, it := range found { res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'failed', log = log || ?, finished_at = ? WHERE id = ? AND status = 'running'`, AbandonedJobNote, now(), it.id) if err != nil { return n, err } affected, _ := res.RowsAffected() if affected == 0 { continue } n++ if _, ok := seen[it.pipe]; !ok { seen[it.pipe] = struct{}{} pipes = append(pipes, it.pipe) } } for _, id := range pipes { if _, err := s.RefreshPipelineStatus(ctx, id); err != nil { return n, err } } return n, nil}// CountRunningJobs telt jobs die Steve nu uitvoert.// CountRunningJobs telt jobs die Steve nu uitvoert.// self_update van timfa/bluegit blijft buiten de telling. Die job polt tot// publish_aur eindigt vóór de POST en self_update eindigt meteen daarna,// deze update status ok heeft. Meerekenen laat wait_until_idle op die poll// dus er is geen job die tijdens de installatie op de updater wacht.// wachten, en de poll op pacman -U. Dezelfde jobnaam in een andere repo telt wel.func (s *Store) CountRunningJobs(ctx context.Context) (int, error) {func (s *Store) CountRunningJobs(ctx context.Context) (int, error) { var n int var n int err := s.db.QueryRowContext(ctx, ` err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs WHERE status = 'running'`).Scan(&n) SELECT COUNT(*) FROM jobs j WHERE j.status = 'running' AND NOT ( j.name = 'self_update' AND j.repo_id IN ( SELECT r.id FROM repos r WHERE r.name = 'bluegit' AND ( (r.owner_kind = 'user' AND r.owner_id = (SELECT id FROM users WHERE username = 'timfa')) OR (r.owner_kind = 'group' AND r.owner_id = (SELECT id FROM groups WHERE path = 'timfa')) ) ) )`).Scan(&n) return n, err return n, err}}@@ -5,7 +5,7 @@ import (
"testing"
)
func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) {
func TestCountRunningJobsCountsEveryJob(t *testing.T) {
s := openTest(t)
ctx := context.Background()
tim, err := s.UpsertUser(ctx, 1, "tim", "", false)
@@ -26,14 +26,15 @@ func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) {
}
sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
otherID, err := s.CreatePipeline(ctx, other.ID, sha, "refs/heads/master", "push", "tim", "update", []NewJob{
{Name: "self_update", Stage: "release", Script: "poll"},
{Name: "self_update", Stage: "release", Script: "post"},
{Name: "publish_aur", Stage: "release", Script: "aur"},
})
if err != nil {
t.Fatal(err)
}
blueID, err := s.CreatePipeline(ctx, blue.ID, sha, "refs/heads/master", "push", "timfa", "update", []NewJob{
{Name: "self_update", Stage: "release", Script: "poll"},
{Name: "publish_aur", Stage: "release", Script: "aur"},
{Name: "self_update", Stage: "release", Script: "post"},
})
if err != nil {
t.Fatal(err)
@@ -44,19 +45,20 @@ func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) {
t.Fatal(err)
}
}
set(blueID, "self_update", "running")
set(blueID, "publish_aur", "running")
n, err := s.CountRunningJobs(ctx)
if err != nil || n != 0 {
t.Fatalf("timfa/bluegit self_update: %d %v", n, err)
}
set(otherID, "self_update", "running")
n, err = s.CountRunningJobs(ctx)
if err != nil || n != 1 {
t.Fatalf("self_update in een andere repo hoort mee te tellen: %d %v", n, err)
t.Fatalf("publish_aur van timfa/bluegit hoort mee te tellen: %d %v", n, err)
}
set(blueID, "publish_aur", "running")
set(blueID, "self_update", "running")
n, err = s.CountRunningJobs(ctx)
if err != nil || n != 2 {
t.Fatalf("publish_aur: %d %v", n, err)
t.Fatalf("self_update van timfa/bluegit hoort mee te tellen: %d %v", n, err)
}
set(otherID, "publish_aur", "running")
set(otherID, "self_update", "running")
n, err = s.CountRunningJobs(ctx)
if err != nil || n != 4 {
t.Fatalf("jobs in een andere repo: %d %v", n, err)
}
}
@@ -5,7 +5,7 @@ import ( "testing" "testing"))func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) {func TestCountRunningJobsCountsEveryJob(t *testing.T) { s := openTest(t) s := openTest(t) ctx := context.Background() ctx := context.Background() tim, err := s.UpsertUser(ctx, 1, "tim", "", false) tim, err := s.UpsertUser(ctx, 1, "tim", "", false)@@ -26,14 +26,15 @@ func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) { } } sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" sha := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" otherID, err := s.CreatePipeline(ctx, other.ID, sha, "refs/heads/master", "push", "tim", "update", []NewJob{ otherID, err := s.CreatePipeline(ctx, other.ID, sha, "refs/heads/master", "push", "tim", "update", []NewJob{ {Name: "self_update", Stage: "release", Script: "poll"}, {Name: "self_update", Stage: "release", Script: "post"}, {Name: "publish_aur", Stage: "release", Script: "aur"}, }) }) if err != nil { if err != nil { t.Fatal(err) t.Fatal(err) } } blueID, err := s.CreatePipeline(ctx, blue.ID, sha, "refs/heads/master", "push", "timfa", "update", []NewJob{ blueID, err := s.CreatePipeline(ctx, blue.ID, sha, "refs/heads/master", "push", "timfa", "update", []NewJob{ {Name: "self_update", Stage: "release", Script: "poll"}, {Name: "publish_aur", Stage: "release", Script: "aur"}, {Name: "publish_aur", Stage: "release", Script: "aur"}, {Name: "self_update", Stage: "release", Script: "post"}, }) }) if err != nil { if err != nil { t.Fatal(err) t.Fatal(err)@@ -44,19 +45,20 @@ func TestCountRunningJobsSkipsSelfUpdateOnBlueGitOnly(t *testing.T) { t.Fatal(err) t.Fatal(err) } } } } set(blueID, "self_update", "running") set(blueID, "publish_aur", "running") n, err := s.CountRunningJobs(ctx) n, err := s.CountRunningJobs(ctx) if err != nil || n != 0 { t.Fatalf("timfa/bluegit self_update: %d %v", n, err) } set(otherID, "self_update", "running") n, err = s.CountRunningJobs(ctx) if err != nil || n != 1 { if err != nil || n != 1 { t.Fatalf("self_update in een andere repo hoort mee te tellen: %d %v", n, err) t.Fatalf("publish_aur van timfa/bluegit hoort mee te tellen: %d %v", n, err) } } set(blueID, "publish_aur", "running") set(blueID, "self_update", "running") n, err = s.CountRunningJobs(ctx) n, err = s.CountRunningJobs(ctx) if err != nil || n != 2 { if err != nil || n != 2 { t.Fatalf("publish_aur: %d %v", n, err) t.Fatalf("self_update van timfa/bluegit hoort mee te tellen: %d %v", n, err) } set(otherID, "publish_aur", "running") set(otherID, "self_update", "running") n, err = s.CountRunningJobs(ctx) if err != nil || n != 4 { t.Fatalf("jobs in een andere repo: %d %v", n, err) } }}}@@ -71,8 +71,7 @@ write_status() {
mv -f "$tmp" "$STATUS"
}
# running komt uit de API. self_update telt daar niet mee: die job polt
# tot deze installatie status ok schrijft.
# running komt uit de API. Elke job met status running telt mee.
wait_until_idle() {
local deadline body n poll
poll="$BLUEGIT_UPDATE_POLL"
@@ -71,8 +71,7 @@ write_status() { mv -f "$tmp" "$STATUS" mv -f "$tmp" "$STATUS"}}# running komt uit de API. self_update telt daar niet mee: die job polt# running komt uit de API. Elke job met status running telt mee.# tot deze installatie status ok schrijft.wait_until_idle() {wait_until_idle() { local deadline body n poll local deadline body n poll poll="$BLUEGIT_UPDATE_POLL" poll="$BLUEGIT_UPDATE_POLL"@@ -1,55 +1,20 @@
#!/usr/bin/env bash
# Start de self-update en wacht tot GET /api/v1/admin/self-update
# status ok meldt voor CI_COMMIT_SHA. publish_aur heeft needs: [self_update],
# dus die job start pas hierna. Een mislukking of timeout faalt deze job.
# SELF_UPDATE_TIMEOUT is seconden (standaard 300). SELF_UPDATE_INTERVAL
# is de pauze tussen pogingen (standaard 5).
# Start de self-update en stop meteen, groen. POST /api/v1/admin/self-update
# antwoordt 202 zodra de unit start. publish_aur is dan al klaar
# (needs: [publish_aur], allow_failure). Er is geen poll: een wachtende
# job sterft mee als post_upgrade bluegit.service herstart, en de updater
# zou op die job blijven wachten.
set -euo pipefail
: "${CI_API_URL:?CI_API_URL ontbreekt}"
: "${BLUEGIT_UPDATE_TOKEN:?BLUEGIT_UPDATE_TOKEN ontbreekt}"
: "${CI_COMMIT_SHA:?CI_COMMIT_SHA ontbreekt}"
timeout="${SELF_UPDATE_TIMEOUT:-300}"
interval="${SELF_UPDATE_INTERVAL:-5}"
[[ "$timeout" =~ ^[0-9]+$ ]] || timeout=300
[[ "$interval" =~ ^[0-9]+$ ]] || interval=5
if ! command -v jq >/dev/null 2>&1; then
apk add --no-cache jq >&2
fi
api="${CI_API_URL%/}/admin/self-update"
auth=(-H "Authorization: Bearer ${BLUEGIT_UPDATE_TOKEN}")
curl -fsS --connect-timeout 5 --max-time 20 -X POST "$api" "${auth[@]}" \
curl -fsS --connect-timeout 5 --max-time 20 -X POST "$api" \
-H "Authorization: Bearer ${BLUEGIT_UPDATE_TOKEN}" \
-H "Content-Type: application/json" \
-d "{\"ref\":\"${CI_COMMIT_SHA}\"}"
start="$(date +%s)"
while true; do
# Een herstart van de service tijdens pacman -U mag de poll niet stoppen.
# log staat live als eerste key en bevat de tekst "status" en "sha".
body="$(curl -fsS --connect-timeout 5 --max-time 20 "$api" "${auth[@]}" || true)"
status=""
sha=""
if parsed="$(printf '%s' "$body" | jq -er '[.status // "", .sha // ""] | @tsv' 2>/dev/null)"; then
status="${parsed%%$'\t'*}"
sha="${parsed#*$'\t'}"
fi
if [[ "$sha" == "$CI_COMMIT_SHA" && "$status" == "ok" ]]; then
echo "Self-update ok: $sha"
exit 0
fi
if [[ "$sha" == "$CI_COMMIT_SHA" && "$status" == "failed" ]]; then
echo "Self-update mislukt: $sha" >&2
exit 1
fi
now="$(date +%s)"
if (( now - start >= timeout )); then
echo "Self-update timeout na ${timeout}s (status ${status:-onbekend}, sha ${sha:-onbekend})" >&2
exit 1
fi
echo "Self-update status ${status:-onbekend} voor ${sha:-onbekend}"
sleep "$interval"
done
echo "Self-update gestart: ${CI_COMMIT_SHA}"
@@ -1,55 +1,20 @@#!/usr/bin/env bash#!/usr/bin/env bash# Start de self-update en wacht tot GET /api/v1/admin/self-update# Start de self-update en stop meteen, groen. POST /api/v1/admin/self-update# status ok meldt voor CI_COMMIT_SHA. publish_aur heeft needs: [self_update],# antwoordt 202 zodra de unit start. publish_aur is dan al klaar# dus die job start pas hierna. Een mislukking of timeout faalt deze job.# (needs: [publish_aur], allow_failure). Er is geen poll: een wachtende# SELF_UPDATE_TIMEOUT is seconden (standaard 300). SELF_UPDATE_INTERVAL# job sterft mee als post_upgrade bluegit.service herstart, en de updater# is de pauze tussen pogingen (standaard 5).# zou op die job blijven wachten.set -euo pipefailset -euo pipefail: "${CI_API_URL:?CI_API_URL ontbreekt}": "${CI_API_URL:?CI_API_URL ontbreekt}": "${BLUEGIT_UPDATE_TOKEN:?BLUEGIT_UPDATE_TOKEN ontbreekt}": "${BLUEGIT_UPDATE_TOKEN:?BLUEGIT_UPDATE_TOKEN ontbreekt}": "${CI_COMMIT_SHA:?CI_COMMIT_SHA ontbreekt}": "${CI_COMMIT_SHA:?CI_COMMIT_SHA ontbreekt}"timeout="${SELF_UPDATE_TIMEOUT:-300}"interval="${SELF_UPDATE_INTERVAL:-5}"[[ "$timeout" =~ ^[0-9]+$ ]] || timeout=300[[ "$interval" =~ ^[0-9]+$ ]] || interval=5if ! command -v jq >/dev/null 2>&1; then apk add --no-cache jq >&2fiapi="${CI_API_URL%/}/admin/self-update"api="${CI_API_URL%/}/admin/self-update"auth=(-H "Authorization: Bearer ${BLUEGIT_UPDATE_TOKEN}")curl -fsS --connect-timeout 5 --max-time 20 -X POST "$api" "${auth[@]}" \curl -fsS --connect-timeout 5 --max-time 20 -X POST "$api" \ -H "Authorization: Bearer ${BLUEGIT_UPDATE_TOKEN}" \ -H "Content-Type: application/json" \ -H "Content-Type: application/json" \ -d "{\"ref\":\"${CI_COMMIT_SHA}\"}" -d "{\"ref\":\"${CI_COMMIT_SHA}\"}"start="$(date +%s)"echo "Self-update gestart: ${CI_COMMIT_SHA}"while true; do # Een herstart van de service tijdens pacman -U mag de poll niet stoppen. # log staat live als eerste key en bevat de tekst "status" en "sha". body="$(curl -fsS --connect-timeout 5 --max-time 20 "$api" "${auth[@]}" || true)" status="" sha="" if parsed="$(printf '%s' "$body" | jq -er '[.status // "", .sha // ""] | @tsv' 2>/dev/null)"; then status="${parsed%%$'\t'*}" sha="${parsed#*$'\t'}" fi if [[ "$sha" == "$CI_COMMIT_SHA" && "$status" == "ok" ]]; then echo "Self-update ok: $sha" exit 0 fi if [[ "$sha" == "$CI_COMMIT_SHA" && "$status" == "failed" ]]; then echo "Self-update mislukt: $sha" >&2 exit 1 fi now="$(date +%s)" if (( now - start >= timeout )); then echo "Self-update timeout na ${timeout}s (status ${status:-onbekend}, sha ${sha:-onbekend})" >&2 exit 1 fi echo "Self-update status ${status:-onbekend} voor ${sha:-onbekend}" sleep "$interval"done@@ -1,197 +1,62 @@
package scripts
import (
"context"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"testing"
"time"
)
func TestSelfUpdateWaitsForOwnSHA(t *testing.T) {
func TestSelfUpdatePostsWithoutWaiting(t *testing.T) {
if _, err := exec.LookPath("bash"); err != nil {
t.Skip("bash ontbreekt")
}
if _, err := exec.LookPath("curl"); err != nil {
t.Skip("curl ontbreekt")
}
if _, err := exec.LookPath("jq"); err != nil {
t.Skip("jq ontbreekt")
}
script := filepath.Join("..", "scripts", "self-update.sh")
sha := "0123456789abcdef0123456789abcdef01234567"
other := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
t.Run("ok na running", func(t *testing.T) {
var posts int
var gets int
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/v1/admin/self-update" {
http.NotFound(w, r)
return
}
if r.Method == http.MethodPost {
posts++
w.WriteHeader(http.StatusAccepted)
_, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
return
}
gets++
w.Header().Set("Content-Type", "application/json")
if gets < 3 {
_, _ = w.Write([]byte(`{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":"","update":{"sha":"` + sha + `","result":"running"}}`))
return
}
// log bevat een andere status. Alleen het veld ervoor telt.
_, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":"zie \"status\":\"failed\"","update":{"sha":"` + sha + `","result":"ok"}}`))
}))
t.Cleanup(srv.Close)
out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
if err != nil {
t.Fatalf("wacht: %v %s", err, out)
}
if posts != 1 || gets < 3 || !strings.Contains(out, "Self-update ok: "+sha) {
t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
}
})
t.Run("andere sha telt niet", func(t *testing.T) {
var gets int
srv := statusServer(t, func(gets int) string {
if gets == 1 {
return `{"running":0,"status":"ok","sha":"` + other + `","result":"ok","log":""}`
}
return `{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`
}, &gets)
out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
if err != nil {
t.Fatalf("wacht: %v %s", err, out)
}
if gets < 2 {
t.Fatalf("stops bij de vorige sha, gets %d\n%s", gets, out)
}
})
t.Run("log staat vooraan", func(t *testing.T) {
var gets int
// De live response begint met log. Daarin staat een nep-status en een nep-sha.
running := `{"log":"Self-update naar iets\n\"status\":\"ok\"\n\"sha\":\"` + sha + `\"","running":1,"status":"running","sha":"` + sha + `","result":"running"}`
done := `{"log":"klaar\n\"status\":\"ok\"\n\"sha\":\"ffffffffffffffffffffffffffffffffffffffff\"","running":0,"status":"ok","sha":"` + sha + `","result":"ok"}`
if !strings.HasPrefix(running, `{"log":`) || !strings.HasPrefix(done, `{"log":`) {
t.Fatal("log hoort de eerste key te zijn")
}
srv := statusServer(t, func(n int) string {
if n == 1 {
return running
}
return done
}, &gets)
out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
if err != nil {
t.Fatalf("wacht: %v %s", err, out)
}
if gets < 2 || !strings.Contains(out, "Self-update ok: "+sha) {
t.Fatalf("nep-status in log telde mee, gets %d\n%s", gets, out)
}
})
t.Run("failed faalt meteen", func(t *testing.T) {
srv := statusServer(t, func(int) string {
return `{"running":0,"status":"failed","sha":"` + sha + `","result":"failed","log":"exit 1"}`
}, nil)
out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
if err == nil || !strings.Contains(out, "Self-update mislukt: "+sha) {
t.Fatalf("failed hoort te stoppen: %v %s", err, out)
}
})
t.Run("timeout", func(t *testing.T) {
srv := statusServer(t, func(int) string {
return `{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":""}`
}, nil)
out, err := runSelfUpdate(t, script, srv.URL, sha, "0", "0")
if err == nil || !strings.Contains(out, "Self-update timeout na 0s") {
t.Fatalf("timeout: %v %s", err, out)
}
})
t.Run("korte storing tijdens herstart", func(t *testing.T) {
var gets int
var mu sync.Mutex
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
w.WriteHeader(http.StatusAccepted)
_, _ = w.Write([]byte(`{"status":"accepted"}`))
return
}
mu.Lock()
gets++
n := gets
mu.Unlock()
if n == 1 {
hj, ok := w.(http.Hijacker)
if !ok {
http.Error(w, "down", http.StatusBadGateway)
return
}
conn, _, err := hj.Hijack()
if err != nil {
return
}
_ = conn.Close()
return
}
_, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`))
}))
t.Cleanup(srv.Close)
out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
if err != nil {
t.Fatalf("na herstart: %v %s", err, out)
}
})
}
func statusServer(t *testing.T, body func(gets int) string, gets *int) *httptest.Server {
t.Helper()
var n int
var mu sync.Mutex
var posts, gets int
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/v1/admin/self-update" {
http.NotFound(w, r)
return
}
if r.Method == http.MethodPost {
posts++
w.WriteHeader(http.StatusAccepted)
_, _ = w.Write([]byte(`{"status":"accepted"}`))
_, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
return
}
mu.Lock()
n++
cur := n
if gets != nil {
*gets = n
}
mu.Unlock()
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(body(cur)))
gets++
select {}
}))
t.Cleanup(srv.Close)
return srv
}
func runSelfUpdate(t *testing.T, script, base, sha, timeout, interval string) (string, error) {
t.Helper()
cmd := exec.Command("bash", script)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
t.Cleanup(cancel)
cmd := exec.CommandContext(ctx, "bash", script)
cmd.Env = append(os.Environ(),
"CI_API_URL="+base+"/api/v1",
"CI_API_URL="+srv.URL+"/api/v1",
"BLUEGIT_UPDATE_TOKEN=test-token",
"CI_COMMIT_SHA="+sha,
"SELF_UPDATE_TIMEOUT="+timeout,
"SELF_UPDATE_INTERVAL="+interval,
)
out, err := cmd.CombinedOutput()
return string(out), err
if err != nil {
t.Fatalf("post: %v %s", err, out)
}
if posts != 1 || gets != 0 || !strings.Contains(string(out), "Self-update gestart: "+sha) {
t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
}
raw, err := os.ReadFile(script)
if err != nil {
t.Fatal(err)
}
if strings.Contains(string(raw), "jq") || strings.Contains(string(raw), "while true") {
t.Fatal("self-update.sh polt nog")
}
}
@@ -1,197 +1,62 @@package scriptspackage scriptsimport (import ( "context" "net/http" "net/http" "net/http/httptest" "net/http/httptest" "os" "os" "os/exec" "os/exec" "path/filepath" "path/filepath" "strings" "strings" "sync" "testing" "testing" "time"))func TestSelfUpdateWaitsForOwnSHA(t *testing.T) {func TestSelfUpdatePostsWithoutWaiting(t *testing.T) { if _, err := exec.LookPath("bash"); err != nil { if _, err := exec.LookPath("bash"); err != nil { t.Skip("bash ontbreekt") t.Skip("bash ontbreekt") } } if _, err := exec.LookPath("curl"); err != nil { if _, err := exec.LookPath("curl"); err != nil { t.Skip("curl ontbreekt") t.Skip("curl ontbreekt") } } if _, err := exec.LookPath("jq"); err != nil { t.Skip("jq ontbreekt") } script := filepath.Join("..", "scripts", "self-update.sh") script := filepath.Join("..", "scripts", "self-update.sh") sha := "0123456789abcdef0123456789abcdef01234567" sha := "0123456789abcdef0123456789abcdef01234567" other := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" var posts, gets int t.Run("ok na running", func(t *testing.T) { var posts int var gets int srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/api/v1/admin/self-update" { http.NotFound(w, r) return } if r.Method == http.MethodPost { posts++ w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`)) return } gets++ w.Header().Set("Content-Type", "application/json") if gets < 3 { _, _ = w.Write([]byte(`{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":"","update":{"sha":"` + sha + `","result":"running"}}`)) return } // log bevat een andere status. Alleen het veld ervoor telt. _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":"zie \"status\":\"failed\"","update":{"sha":"` + sha + `","result":"ok"}}`)) })) t.Cleanup(srv.Close) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if posts != 1 || gets < 3 || !strings.Contains(out, "Self-update ok: "+sha) { t.Fatalf("posts %d gets %d\n%s", posts, gets, out) } }) t.Run("andere sha telt niet", func(t *testing.T) { var gets int srv := statusServer(t, func(gets int) string { if gets == 1 { return `{"running":0,"status":"ok","sha":"` + other + `","result":"ok","log":""}` } return `{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}` }, &gets) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if gets < 2 { t.Fatalf("stops bij de vorige sha, gets %d\n%s", gets, out) } }) t.Run("log staat vooraan", func(t *testing.T) { var gets int // De live response begint met log. Daarin staat een nep-status en een nep-sha. running := `{"log":"Self-update naar iets\n\"status\":\"ok\"\n\"sha\":\"` + sha + `\"","running":1,"status":"running","sha":"` + sha + `","result":"running"}` done := `{"log":"klaar\n\"status\":\"ok\"\n\"sha\":\"ffffffffffffffffffffffffffffffffffffffff\"","running":0,"status":"ok","sha":"` + sha + `","result":"ok"}` if !strings.HasPrefix(running, `{"log":`) || !strings.HasPrefix(done, `{"log":`) { t.Fatal("log hoort de eerste key te zijn") } srv := statusServer(t, func(n int) string { if n == 1 { return running } return done }, &gets) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("wacht: %v %s", err, out) } if gets < 2 || !strings.Contains(out, "Self-update ok: "+sha) { t.Fatalf("nep-status in log telde mee, gets %d\n%s", gets, out) } }) t.Run("failed faalt meteen", func(t *testing.T) { srv := statusServer(t, func(int) string { return `{"running":0,"status":"failed","sha":"` + sha + `","result":"failed","log":"exit 1"}` }, nil) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err == nil || !strings.Contains(out, "Self-update mislukt: "+sha) { t.Fatalf("failed hoort te stoppen: %v %s", err, out) } }) t.Run("timeout", func(t *testing.T) { srv := statusServer(t, func(int) string { return `{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":""}` }, nil) out, err := runSelfUpdate(t, script, srv.URL, sha, "0", "0") if err == nil || !strings.Contains(out, "Self-update timeout na 0s") { t.Fatalf("timeout: %v %s", err, out) } }) t.Run("korte storing tijdens herstart", func(t *testing.T) { var gets int var mu sync.Mutex srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method == http.MethodPost { w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted"}`)) return } mu.Lock() gets++ n := gets mu.Unlock() if n == 1 { hj, ok := w.(http.Hijacker) if !ok { http.Error(w, "down", http.StatusBadGateway) return } conn, _, err := hj.Hijack() if err != nil { return } _ = conn.Close() return } _, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`)) })) t.Cleanup(srv.Close) out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0") if err != nil { t.Fatalf("na herstart: %v %s", err, out) } })}func statusServer(t *testing.T, body func(gets int) string, gets *int) *httptest.Server { t.Helper() var n int var mu sync.Mutex srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/api/v1/admin/self-update" { if r.URL.Path != "/api/v1/admin/self-update" { http.NotFound(w, r) http.NotFound(w, r) return return } } if r.Method == http.MethodPost { if r.Method == http.MethodPost { posts++ w.WriteHeader(http.StatusAccepted) w.WriteHeader(http.StatusAccepted) _, _ = w.Write([]byte(`{"status":"accepted"}`)) _, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`)) return return } } mu.Lock() gets++ n++ select {} cur := n if gets != nil { *gets = n } mu.Unlock() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(body(cur))) })) })) t.Cleanup(srv.Close) t.Cleanup(srv.Close) return srv ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)} t.Cleanup(cancel) cmd := exec.CommandContext(ctx, "bash", script)func runSelfUpdate(t *testing.T, script, base, sha, timeout, interval string) (string, error) { t.Helper() cmd := exec.Command("bash", script) cmd.Env = append(os.Environ(), cmd.Env = append(os.Environ(), "CI_API_URL="+base+"/api/v1", "CI_API_URL="+srv.URL+"/api/v1", "BLUEGIT_UPDATE_TOKEN=test-token", "BLUEGIT_UPDATE_TOKEN=test-token", "CI_COMMIT_SHA="+sha, "CI_COMMIT_SHA="+sha, "SELF_UPDATE_TIMEOUT="+timeout, "SELF_UPDATE_INTERVAL="+interval, ) ) out, err := cmd.CombinedOutput() out, err := cmd.CombinedOutput() return string(out), err if err != nil { t.Fatalf("post: %v %s", err, out) } if posts != 1 || gets != 0 || !strings.Contains(string(out), "Self-update gestart: "+sha) { t.Fatalf("posts %d gets %d\n%s", posts, gets, out) } raw, err := os.ReadFile(script) if err != nil { t.Fatal(err) } if strings.Contains(string(raw), "jq") || strings.Contains(string(raw), "while true") { t.Fatal("self-update.sh polt nog") }}}