113 lines
3.7 KiB
Go
113 lines
3.7 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`
|
|
|
|
// 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)
|
|
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, "publish to next only")
|
|
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:]))
|
|
req.Channels = []string{"next"}
|
|
if !req.Prerelease {
|
|
req.Channels = append(req.Channels, "stable")
|
|
}
|
|
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
|
|
}
|