Files
sam 0e931485a0
Quality / check (push) Successful in 7m33s
deploy / gate (push) Successful in 6m27s
deploy / archied-image (push) Successful in 2m57s
deploy / agent-image (push) Successful in 12s
deploy / dist-zip (push) Skipped
docs(releaseupdate): use contractions in the release and canary text (#1716)
2026-10-31 22:18:57 +11:00

116 lines
4.3 KiB
Go

package releaseupdate
import (
"context"
"crypto/ed25519"
"encoding/json"
"errors"
"fmt"
"io"
"strings"
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/errdef"
"oras.land/oras-go/v2/registry/remote"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
// Promote points the stable tag at a published release. The signature covers
// the release statement, not the tag, so the release doesn't need signing
// again. It refuses a prerelease, and a release issued before the one stable
// already points at, which hosts would reject as a replay.
//
// Each image repository in latest gets its v<version> tag copied to latest
// before stable moves, so if that fails stable is unchanged and running
// Promote again finishes the job.
func Promote(ctx context.Context, repository string, key ed25519.PublicKey, version string, latest []string) (Statement, error) {
source := distribution.Source{Reference: repository, Key: key}
release, err := Fetch(ctx, source, Tag("exact-pin", version))
if err != nil {
return Statement{}, err
}
if release.Statement.Prerelease {
return Statement{}, fmt.Errorf("%s is a prerelease and never reaches stable", version)
}
current, err := Fetch(ctx, source, "stable")
switch {
case errors.Is(err, errdef.ErrNotFound):
case err != nil:
return Statement{}, err
case release.Statement.IssuedAt.Before(current.Statement.IssuedAt):
return Statement{}, fmt.Errorf("%s was issued before %s, which stable names", version, current.Statement.Version)
}
repo, err := pushRepository(repository)
if err != nil {
return Statement{}, err
}
desc, err := verifiedManifest(ctx, repo, version, release.Artifact.Statement, key)
if err != nil {
return Statement{}, err
}
for _, image := range latest {
if err := promoteImage(ctx, image, version, release.Statement.AgentImage); err != nil {
return Statement{}, err
}
}
if err := repo.Tag(ctx, desc, "stable"); err != nil {
return Statement{}, fmt.Errorf("tag stable: %w", err)
}
return release.Statement, nil
}
// promoteImage tags image:v<version> as latest. The agent image must be the
// one the statement pins, or latest would name an image the release never
// signed for.
func promoteImage(ctx context.Context, image, version, agentImage string) error {
repo, err := pushRepository(image)
if err != nil {
return err
}
desc, err := repo.Resolve(ctx, Tag("exact-pin", version))
if err != nil {
return fmt.Errorf("resolve %s:v%s: %w", image, version, err)
}
if pinned, digest, ok := strings.Cut(agentImage, "@"); ok && pinned == image && desc.Digest.String() != digest {
return fmt.Errorf("%s:v%s is %s, not the %s the release pins", image, version, desc.Digest, digest)
}
if err := repo.Tag(ctx, desc, "latest"); err != nil {
return fmt.Errorf("tag %s:latest: %w", image, err)
}
return nil
}
// verifiedManifest returns the manifest the version tag points at now, after
// checking it carries the statement that was already verified. This stops a
// tag that moved in the meantime from putting an unverified manifest on
// stable.
func verifiedManifest(ctx context.Context, repo *remote.Repository, version string, statement []byte, key ed25519.PublicKey) (ocispec.Descriptor, error) {
desc, err := repo.Resolve(ctx, Tag("exact-pin", version))
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("resolve %s: %w", version, err)
}
stream, err := repo.Fetch(ctx, desc)
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("fetch %s manifest: %w", version, err)
}
raw, err := io.ReadAll(io.LimitReader(stream, desc.Size))
_ = stream.Close()
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("read %s manifest: %w", version, err)
}
if digest.FromBytes(raw) != desc.Digest {
return ocispec.Descriptor{}, fmt.Errorf("%s manifest doesn't match its digest", version)
}
var manifest ocispec.Manifest
if err := json.Unmarshal(raw, &manifest); err != nil {
return ocispec.Descriptor{}, fmt.Errorf("%s manifest: %w", version, err)
}
if err := signedoci.Verify(manifest, statement, key, Annotation); err != nil {
return ocispec.Descriptor{}, fmt.Errorf("%s changed while promoting: %w", version, err)
}
return desc, nil
}