Some checks failed
Tests / test (push) Successful in 4m12s
Release Pipeline / set-release-target (push) Successful in 2s
Release Pipeline / upload-assets (lab-host.sh, scripts/lab-host.sh) (push) Successful in 7s
Release Pipeline / build (push) Successful in 1m31s
Release Pipeline / build (amd64, linux) (push) Successful in 0s
Release Pipeline / build (arm64, darwin) (push) Successful in 0s
Release Pipeline / checksums (push) Successful in 6s
Release Pipeline / release (push) Failing after 22s
Release Pipeline / publish (push) Failing after 0s
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
207 lines
5.3 KiB
Go
207 lines
5.3 KiB
Go
package provision
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
"git.g3e.fr/syonad/labctl/internal/render"
|
|
"git.g3e.fr/syonad/labctl/internal/topology"
|
|
)
|
|
|
|
const (
|
|
KeyFile = "lab_ed25519"
|
|
KeyLabel = "labctl"
|
|
DiskSize = "20G"
|
|
SeedLabel = "cidata"
|
|
|
|
ArgsFile = "qemu.args"
|
|
)
|
|
|
|
var SeedFiles = []string{"user-data", "meta-data", "network-config"}
|
|
|
|
type Runner interface {
|
|
Run(ctx context.Context, name string, args ...string) error
|
|
}
|
|
|
|
type ExecRunner struct{}
|
|
|
|
func (ExecRunner) Run(ctx context.Context, name string, args ...string) error {
|
|
out, err := exec.CommandContext(ctx, name, args...).CombinedOutput()
|
|
if err != nil {
|
|
return fmt.Errorf("%s: %w: %s", name, err, strings.TrimSpace(string(out)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Options struct {
|
|
RunDir string
|
|
Fetcher Fetcher
|
|
Runner Runner
|
|
}
|
|
|
|
func Prepare(ctx context.Context, p *topology.Plan, o Options) ([]render.Node, error) {
|
|
if !filepath.IsAbs(o.RunDir) {
|
|
return nil, fmt.Errorf("run dir %q must be an absolute path", o.RunDir)
|
|
}
|
|
if err := os.MkdirAll(o.RunDir, 0o700); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
images := map[string]string{}
|
|
for _, n := range p.Nodes {
|
|
if _, ok := images[n.Image]; ok {
|
|
continue
|
|
}
|
|
img, ok := imageNamed(p, n.Image)
|
|
if !ok {
|
|
return nil, fmt.Errorf("node %s: image %q is not declared", n.Name, n.Image)
|
|
}
|
|
base, err := o.Fetcher.Image(ctx, img)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
images[n.Image] = base
|
|
}
|
|
|
|
key, err := EnsureKey(ctx, o.Runner, o.RunDir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
opts := render.Options{RunDir: o.RunDir, AuthorizedKeys: []string{key}}
|
|
if err := ReadInputs(p, &opts); err != nil {
|
|
return nil, err
|
|
}
|
|
nodes, err := render.Render(p, opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for i, n := range nodes {
|
|
if err := Stage(ctx, o.Runner, n, images[p.Nodes[i].Image]); err != nil {
|
|
return nil, fmt.Errorf("node %s: %w", n.Name, err)
|
|
}
|
|
}
|
|
return nodes, nil
|
|
}
|
|
|
|
func ReadInputs(p *topology.Plan, o *render.Options) error {
|
|
var err error
|
|
if o.FRR, err = readNodeFiles(p, func(n topology.NodePlan) string { return n.FRR }); err != nil {
|
|
return err
|
|
}
|
|
if o.Provision, err = readNodeFiles(p, func(n topology.NodePlan) string { return n.Provision }); err != nil {
|
|
return err
|
|
}
|
|
if o.PostProvision, err = readNodeFiles(p, func(n topology.NodePlan) string { return n.PostProvision }); err != nil {
|
|
return err
|
|
}
|
|
for _, n := range p.Nodes {
|
|
for name, src := range n.Files {
|
|
if _, err := os.Stat(src); err != nil {
|
|
return fmt.Errorf("node %s: file %s: %w", n.Name, name, err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func readNodeFiles(p *topology.Plan, path func(topology.NodePlan) string) (map[string]string, error) {
|
|
files := map[string]string{}
|
|
for _, n := range p.Nodes {
|
|
if path(n) == "" {
|
|
continue
|
|
}
|
|
data, err := os.ReadFile(path(n))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("node %s: %w", n.Name, err)
|
|
}
|
|
files[n.Name] = string(data)
|
|
}
|
|
return files, nil
|
|
}
|
|
|
|
func EnsureKey(ctx context.Context, r Runner, dir string) (string, error) {
|
|
private := filepath.Join(dir, KeyFile)
|
|
if _, err := os.Stat(private); errors.Is(err, os.ErrNotExist) {
|
|
if err := r.Run(ctx, "ssh-keygen", "-q", "-t", "ed25519", "-N", "", "-C", KeyLabel, "-f", private); err != nil {
|
|
return "", err
|
|
}
|
|
} else if err != nil {
|
|
return "", err
|
|
}
|
|
data, err := os.ReadFile(private + ".pub")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
key := strings.TrimSpace(string(data))
|
|
if key == "" || strings.ContainsAny(key, "\r\n") {
|
|
return "", fmt.Errorf("%s.pub: not a single public key", private)
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
func WriteFiles(n render.Node) error {
|
|
if err := os.MkdirAll(n.Dir, 0o700); err != nil {
|
|
return err
|
|
}
|
|
files := map[string][]byte{
|
|
ArgsFile: []byte(strings.Join(n.QEMU, "\n") + "\n"),
|
|
"meta-data": n.MetaData,
|
|
"user-data": n.UserData,
|
|
"network-config": n.NetworkConfig,
|
|
}
|
|
for name, content := range files {
|
|
if err := os.WriteFile(filepath.Join(n.Dir, name), content, 0o600); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func Stage(ctx context.Context, r Runner, n render.Node, base string) error {
|
|
if !filepath.IsAbs(base) {
|
|
return fmt.Errorf("base image %q must be an absolute path", base)
|
|
}
|
|
if err := WriteFiles(n); err != nil {
|
|
return err
|
|
}
|
|
disk := filepath.Join(n.Dir, render.DiskFile)
|
|
seed := filepath.Join(n.Dir, render.SeedFile)
|
|
if err := r.Run(ctx, "qemu-img", "create", "-q", "-f", "qcow2", "-F", "qcow2", "-b", base, disk, DiskSize); err != nil {
|
|
return err
|
|
}
|
|
args := []string{"-quiet", "-output", seed, "-volid", SeedLabel, "-joliet", "-rock"}
|
|
for _, f := range SeedFiles {
|
|
args = append(args, filepath.Join(n.Dir, f))
|
|
}
|
|
if err := r.Run(ctx, "genisoimage", args...); err != nil {
|
|
return err
|
|
}
|
|
if len(n.Files) == 0 {
|
|
return nil
|
|
}
|
|
names := make([]string, 0, len(n.Files))
|
|
for name := range n.Files {
|
|
names = append(names, name)
|
|
}
|
|
sort.Strings(names)
|
|
args = []string{"-quiet", "-output", filepath.Join(n.Dir, render.FilesISO), "-volid", render.FilesLabel, "-joliet", "-rock", "-graft-points"}
|
|
for _, name := range names {
|
|
args = append(args, name+"="+n.Files[name])
|
|
}
|
|
return r.Run(ctx, "genisoimage", args...)
|
|
}
|
|
|
|
func imageNamed(p *topology.Plan, name string) (topology.Image, bool) {
|
|
for _, i := range p.Images {
|
|
if i.Name == name {
|
|
return i, true
|
|
}
|
|
}
|
|
return topology.Image{}, false
|
|
}
|