isle/go-workspace/src/bootstrap/bootstrap.go

// Package bootstrap deals with the creation of bootstrap files
package bootstrap

import (
	"cryptic-net/garage"
	"cryptic-net/tarutil"
	"cryptic-net/yamlutil"
	"crypto/sha512"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"gopkg.in/yaml.v3"
)

// Paths within the bootstrap FS which for general data.
const (
	hostNamePath = "hostname"
)

// Bootstrap is used for accessing all information contained within a
// bootstrap.tgz file.
//
// An instance of Bootstrap is read-only, the creator sub-package should be used
// to create new instances.
type Bootstrap struct {
	Hosts    map[string]Host
	HostName string

	NebulaCertsCACert   string
	NebulaCertsHostCert string
	NebulaCertsHostKey  string

	GarageRPCSecret                    string
	GarageGlobalBucketS3APICredentials garage.S3APICredentials
}

// FromFS loads a Boostrap instance from the given fs.FS, which presumably
// represents the file structure of a bootstrap.tgz file.
func FromFS(bootstrapFS fs.FS) (Bootstrap, error) {

	var (
		b   Bootstrap
		err error
	)

	if b.Hosts, err = loadHosts(bootstrapFS); err != nil {
		return Bootstrap{}, fmt.Errorf("loading hosts info from fs: %w", err)
	}

	if err = yamlutil.LoadYamlFSFile(
		&b.GarageGlobalBucketS3APICredentials,
		bootstrapFS,
		garageGlobalBucketKeyYmlPath,
	); err != nil {
		return Bootstrap{}, fmt.Errorf("loading %q from fs: %w", b.GarageGlobalBucketS3APICredentials, err)
	}

	filesToLoadAsString := []struct {
		into *string
		path string
	}{
		{&b.HostName, hostNamePath},
		{&b.NebulaCertsCACert, nebulaCertsCACertPath},
		{&b.NebulaCertsHostCert, nebulaCertsHostCertPath},
		{&b.NebulaCertsHostKey, nebulaCertsHostKeyPath},
		{&b.GarageRPCSecret, garageRPCSecretPath},
	}

	for _, f := range filesToLoadAsString {
		body, err := fs.ReadFile(bootstrapFS, f.path)
		if err != nil {
			return Bootstrap{}, fmt.Errorf("loading %q from fs: %w", f.path, err)
		}
		*f.into = string(body)
	}

	// TODO confirm if this is necessary
	b.GarageRPCSecret = strings.TrimSpace(b.GarageRPCSecret)

	return b, nil
}

// FromReader reads a bootstrap.tgz file from the given io.Reader.
func FromReader(r io.Reader) (Bootstrap, error) {

	fs, err := tarutil.FSFromReader(r)
	if err != nil {
		return Bootstrap{}, fmt.Errorf("reading bootstrap.tgz: %w", err)
	}

	return FromFS(fs)
}

// FromFile reads a bootstrap.tgz from a file at the given path.
func FromFile(path string) (Bootstrap, error) {

	f, err := os.Open(path)
	if err != nil {
		return Bootstrap{}, fmt.Errorf("opening file: %w", err)
	}
	defer f.Close()

	return FromReader(f)
}

// WriteTo writes the Bootstrap as a new bootstrap.tgz to the given io.Writer.
func (b Bootstrap) WriteTo(into io.Writer) error {

	w := tarutil.NewTGZWriter(into)

	filesToWriteAsString := []struct {
		value string
		path  string
	}{
		{b.HostName, hostNamePath},
		{b.NebulaCertsCACert, nebulaCertsCACertPath},
		{b.NebulaCertsHostCert, nebulaCertsHostCertPath},
		{b.NebulaCertsHostKey, nebulaCertsHostKeyPath},
		{b.GarageRPCSecret, garageRPCSecretPath},
	}

	for _, f := range filesToWriteAsString {
		w.WriteFileBytes(f.path, []byte(f.value))
	}

	garageGlobalBucketKeyB, err := yaml.Marshal(b.GarageGlobalBucketS3APICredentials)
	if err != nil {
		return fmt.Errorf("yaml encoding garage global bucket creds: %w", err)
	}

	w.WriteFileBytes(garageGlobalBucketKeyYmlPath, garageGlobalBucketKeyB)

	for _, host := range b.Hosts {

		hostB, err := yaml.Marshal(host)
		if err != nil {
			return fmt.Errorf("yaml encoding host %#v: %w", host, err)
		}

		path := filepath.Join(hostsDirPath, host.Name+".yml")

		w.WriteFileBytes(path, hostB)
	}

	return w.Close()
}

// ThisHost is a shortcut for b.Hosts[b.HostName], but will panic if the
// HostName isn't found in the Hosts map.
func (b Bootstrap) ThisHost() Host {

	host, ok := b.Hosts[b.HostName]
	if !ok {
		panic(fmt.Sprintf("hostname %q not defined in bootstrap's hosts", b.HostName))
	}

	return host
}

// Hash returns a deterministic hash of the given hosts map.
func HostsHash(hostsMap map[string]Host) ([]byte, error) {

	hosts := make([]Host, 0, len(hostsMap))
	for _, host := range hostsMap {
		hosts = append(hosts, host)
	}

	sort.Slice(hosts, func(i, j int) bool { return hosts[i].Name < hosts[j].Name })

	h := sha512.New()

	if err := yaml.NewEncoder(h).Encode(hosts); err != nil {
		return nil, err
	}

	return h.Sum(nil), nil
}

// WithHosts returns a copy of the Bootstrap with the given set of Hosts applied
// to it. It will _not_ overwrite the Host for _this_ host, however.
func (b Bootstrap) WithHosts(hosts map[string]Host) Bootstrap {

	hostsCopy := make(map[string]Host, len(hosts))

	for name, host := range hosts {
		hostsCopy[name] = host
	}

	hostsCopy[b.HostName] = b.ThisHost()

	b.Hosts = hostsCopy
	return b
}