Selfupdate¶

Adds an update sub-command to a burrow binary that downloads the latest release for the running OS/arch from GitHub, Codeberg, or any Forgejo instance and atomically replaces the binary in place.

Package: github.com/oliverandrich/burrow/contrib/selfupdate

Depends on: none — uses anonymous HTTPS to the public Releases API. No tokens required.

Scope¶

Setup¶

Add to your server wiring in cmd/<app>/main.go:

import (
    "github.com/oliverandrich/burrow"
    "github.com/oliverandrich/burrow/contrib/selfupdate"
)

var version = "dev" // set by goreleaser via -ldflags="-X main.version=..."

func main() {
    srv := burrow.NewServer(
        // ... other apps ...
        selfupdate.New(
            selfupdate.WithRepo("me", "myapp"),
            selfupdate.WithHost("github.com"),
            selfupdate.WithCurrentVersion(version),
        ),
    )
    srv.Run()
}

WithRepo, WithHost, and WithCurrentVersion are required; everything else is optional.

CLI¶

myapp update              # apply latest update
myapp update --check      # report whether an update is available
myapp update --to v1.2.3  # pin to a specific release (also: rollback)

The command is always non-interactive — it just does it. There is no prompt.

Asset layout (defaults match the burrow scaffold)¶

The default asset-name template matches what the burrow scaffold's .goreleaser.yaml produces:

{{ .Name }}-{{ .Version }}-{{ .OS }}-{{ .ArchAlias }}.{{ .Ext }}

So a release at tag v1.2.3 would expose:

• myapp-1.2.3-linux-x86_64.tar.gz
• myapp-1.2.3-darwin-arm64.zip
• myapp-1.2.3-windows-x86_64.zip
• checksums.txt

The selfupdate flow:

1. Fetches /repos/<owner>/<repo>/releases/latest (or /releases/tags/<tag> with --to).
2. Compares the release's tag_name against WithCurrentVersion via golang.org/x/mod/semver.
3. Downloads the matching asset for the running OS/arch and the checksums.txt.
4. Verifies the archive against the recorded SHA256.
5. Extracts the binary (tar.gz or zip).
6. Atomically replaces the running binary via minio/selfupdate.

If your project uses a different asset layout, override the template:

selfupdate.New(
    selfupdate.WithRepo("me", "myapp"),
    selfupdate.WithHost("github.com"),
    selfupdate.WithCurrentVersion(version),
    selfupdate.WithAssetPattern(`{{ .Name }}_{{ .Version }}_{{ .OS }}_{{ .Arch }}.{{ .Ext }}`),
)

Available template variables: Name, Version (leading v stripped), OS, Arch, ArchAlias (amd64→x86_64), Ext (tar.gz on Linux, zip on macOS/Windows).

For layouts where a single template doesn't fit, swap in a predicate via WithAssetMatcher:

import "regexp"

var rel = regexp.MustCompile(`^myapp[-_]v?\d`)

selfupdate.New(
    ...,
    selfupdate.WithAssetMatcher(rel.MatchString),
)

The matcher is called with each asset's filename and selects the first one returning true. It takes precedence over WithAssetPattern.

When the binary inside the archive isn't named after the repo (e.g. repo go-myapp-server, binary myapp), use WithBinaryName:

selfupdate.New(
    selfupdate.WithRepo("me", "go-myapp-server"),
    selfupdate.WithBinaryName("myapp"),
    ...,
)

Configuration¶

Repo coords and current version are compile-time only — they live in your main.go.

Failure modes¶

After the update¶

The atomic swap replaces the on-disk binary. The currently-running process keeps executing the old code in memory — for daemons and long-running servers, you must restart the process to pick up the new version. The contrib prints a reminder on success:

selfupdate: installed v1.2.3 — restart this binary to run the new version