149 lines
5.1 KiB
Go
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
|
|
}
|