Files
archie/internal/app/archied/release.go
T

149 lines
5.1 KiB
Go

package archied
import (
"context"
"crypto/ed25519"
"encoding/base64"
"flag"
"fmt"
"io"
"os"
"strings"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
const releaseUsage = `usage: archied release <command>
keygen -seed FILE write a new signing key's seed to FILE and print its public key
publish sign a release and push it to a release source's next channel
promote -version V point stable at a published release`
// RunRelease is the publisher's side of a release source: it makes the key
// a source signs with and pushes signed releases to it.
func RunRelease(args []string, out, stderr io.Writer) int {
if len(args) == 0 {
fmt.Fprintln(stderr, releaseUsage)
return 2
}
switch args[0] {
case "keygen":
return runReleaseKeygen(args[1:], out, stderr)
case "publish":
return runReleasePublish(args[1:], out, stderr)
case "promote":
return runReleasePromote(args[1:], out, stderr)
default:
fmt.Fprintln(stderr, releaseUsage)
return 2
}
}
// runReleaseKeygen writes the seed to a new file only, never to output, so
// the private half is not left in a terminal or CI log.
func runReleaseKeygen(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release keygen", flag.ContinueOnError)
flags.SetOutput(stderr)
seedPath := flags.String("seed", "", "file to create with the base64 private key seed")
if err := flags.Parse(args); err != nil {
return 2
}
if *seedPath == "" {
fmt.Fprintln(stderr, "release keygen: -seed is required")
return 2
}
public, private, err := ed25519.GenerateKey(nil)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
file, err := os.OpenFile(*seedPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
_, err = fmt.Fprintln(file, base64.StdEncoding.EncodeToString(private.Seed()))
if closeErr := file.Close(); err == nil {
err = closeErr
}
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintln(out, distribution.EncodeKey(public))
return 0
}
func runReleasePublish(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release publish", flag.ContinueOnError)
flags.SetOutput(stderr)
var req releaseupdate.PublishRequest
flags.StringVar(&req.Repository, "source", "", "OCI repository to publish to")
seedEnv := flags.String("seed-env", "ARCHIE_RELEASE_SEED", "environment variable holding the base64 private key seed")
flags.StringVar(&req.Version, "version", "", "release version")
flags.BoolVar(&req.Prerelease, "prerelease", false, "mark the release a prerelease, which never reaches stable")
flags.StringVar(&req.ZipPath, "zip", "", "distribution zip")
flags.StringVar(&req.AgentImage, "agent-image", "", "agent image pinned by digest")
flags.StringVar(&req.Changelog, "changelog", "", "URL of the release notes")
if err := flags.Parse(args); err != nil {
return 2
}
if req.Repository == "" || req.Version == "" || req.ZipPath == "" || req.AgentImage == "" {
fmt.Fprintln(stderr, "release publish: -source, -version, -zip and -agent-image are required")
return 2
}
seed, err := base64.StdEncoding.DecodeString(strings.TrimSpace(os.Getenv(*seedEnv)))
if err != nil || len(seed) != ed25519.SeedSize {
fmt.Fprintf(stderr, "release publish: %s must hold a base64 ed25519 seed\n", *seedEnv)
return 2
}
req.Signer = ed25519.NewKeyFromSeed(seed)
public := distribution.EncodeKey(ed25519.PublicKey(req.Signer[ed25519.SeedSize:]))
// stable moves only when the release is promoted.
req.Channels = []string{"next"}
statement, err := releaseupdate.Publish(context.Background(), req)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintf(out, "published %s to %s (%s) with key %s\n", statement.Version, req.Repository,
strings.Join(req.Channels, ", "), public)
return 0
}
// runReleasePromote moves stable to a published release.
func runReleasePromote(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release promote", flag.ContinueOnError)
flags.SetOutput(stderr)
reference := flags.String("source", "", "OCI repository releases are published to; blank is the official releases")
key := flags.String("key", "", "base64 ed25519 public key the source signs with")
version := flags.String("version", "", "release to promote")
latest := flags.String("latest", "", "comma-separated image repositories whose v<version> tag becomes latest")
if err := flags.Parse(args); err != nil {
return 2
}
source, err := distribution.Parse(*reference, *key, distribution.DefaultReleases())
if err != nil || *version == "" {
fmt.Fprintln(stderr, "release promote: -version is required, and -source with -key name another source")
return 2
}
statement, err := releaseupdate.Promote(context.Background(), source.Reference, source.Key, *version, splitList(*latest))
if err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintf(out, "stable is %s\n", statement.Version)
return 0
}
func splitList(value string) []string {
var items []string
for item := range strings.SplitSeq(value, ",") {
if item = strings.TrimSpace(item); item != "" {
items = append(items, item)
}
}
return items
}