internal/boot: introduce package for booting images

The package takes the existing code from /cmd/osbuild-image-tests and
makes it available for other executables.

internal/boot/context-managers.go

@@ -0,0 +1,271 @@
+// +build integration
+
+package boot
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/osbuild/osbuild-composer/cmd/osbuild-image-tests/constants"
+	"github.com/osbuild/osbuild-composer/internal/common"
+	"github.com/osbuild/osbuild-composer/internal/distro"
+)
+
+// withNetworkNamespace provides the function f with a new network namespace
+// which is deleted immediately after f returns
+func withNetworkNamespace(f func(ns netNS) error) error {
+	ns, err := newNetworkNamespace()
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		err := ns.Delete()
+		if err != nil {
+			log.Printf("cannot delete network namespace: %#v", err)
+		}
+	}()
+
+	return f(ns)
+}
+
+// withTempFile provides the function f with a new temporary file
+// dir and pattern parameters have the same semantics as in ioutil.TempFile
+func withTempFile(dir, pattern string, f func(file *os.File) error) error {
+	tempFile, err := ioutil.TempFile(dir, pattern)
+	if err != nil {
+		return fmt.Errorf("cannot create the temporary file: %#v", err)
+	}
+
+	defer func() {
+		err := os.Remove(tempFile.Name())
+		if err != nil {
+			log.Printf("cannot remove the temporary file: %#v", err)
+		}
+	}()
+
+	return f(tempFile)
+}
+
+func withTempDir(dir, pattern string, f func(dir string) error) error {
+	tempDir, err := ioutil.TempDir(dir, pattern)
+	if err != nil {
+		return fmt.Errorf("cannot create the temporary directory %#v", err)
+	}
+
+	defer func() {
+		err := os.RemoveAll(tempDir)
+		if err != nil {
+			log.Printf("cannot remove the temporary directory: %#v", err)
+		}
+	}()
+
+	return f(tempDir)
+}
+
+// writeCloudInitSO creates cloud-init iso from specified userData and
+// metaData and writes it to the writer
+func writeCloudInitISO(writer io.Writer, userData, metaData string) error {
+	isoCmd := exec.Command(
+		"genisoimage",
+		"-quiet",
+		"-input-charset", "utf-8",
+		"-volid", "cidata",
+		"-joliet",
+		"-rock",
+		userData,
+		metaData,
+	)
+	isoCmd.Stdout = writer
+	isoCmd.Stderr = os.Stderr
+
+	err := isoCmd.Run()
+	if err != nil {
+		return fmt.Errorf("cannot create cloud-init iso: %#v", err)
+	}
+
+	return nil
+}
+
+// withBootedQemuImage boots the specified image in the specified namespace
+// using qemu. The VM is killed immediately after function returns.
+func withBootedQemuImage(image string, ns netNS, f func() error) error {
+	return withTempFile("", "osbuild-image-tests-cloudinit", func(cloudInitFile *os.File) error {
+		err := writeCloudInitISO(
+			cloudInitFile,
+			constants.TestPaths.UserData,
+			constants.TestPaths.MetaData,
+		)
+		if err != nil {
+			return err
+		}
+
+		err = cloudInitFile.Close()
+		if err != nil {
+			return fmt.Errorf("cannot close temporary cloudinit file: %#v", err)
+		}
+
+		var qemuCmd *exec.Cmd
+		if common.CurrentArch() == "x86_64" {
+			hostDistroName, _, err := distro.GetHostDistroName()
+			if err != nil {
+				return fmt.Errorf("cannot determing the current distro: %v", err)
+			}
+
+			var qemuPath string
+			if strings.HasPrefix(hostDistroName, "rhel") {
+				qemuPath = "/usr/libexec/qemu-kvm"
+			} else {
+				qemuPath = "qemu-system-x86_64"
+			}
+
+			qemuCmd = ns.NamespacedCommand(
+				qemuPath,
+				"-cpu", "host",
+				"-smp", strconv.Itoa(runtime.NumCPU()),
+				"-m", "1024",
+				"-snapshot",
+				"-M", "accel=kvm",
+				"-cdrom", cloudInitFile.Name(),
+				"-net", "nic,model=rtl8139", "-net", "user,hostfwd=tcp::22-:22",
+				"-nographic",
+				image,
+			)
+		} else if common.CurrentArch() == "aarch64" {
+			// This command does not use KVM as I was unable to make it work in Beaker,
+			// once we have machines that can use KVM, enable it to make it faster
+			qemuCmd = ns.NamespacedCommand(
+				"qemu-system-aarch64",
+				"-cpu", "host",
+				"-M", "virt",
+				"-m", "2048",
+				// As opposed to x86_64, aarch64 uses UEFI, this one comes from edk2-aarch64 package on Fedora
+				"-bios", "/usr/share/edk2/aarch64/QEMU_EFI.fd",
+				"-boot", "efi",
+				"-M", "accel=kvm",
+				"-snapshot",
+				"-cdrom", cloudInitFile.Name(),
+				"-net", "nic,model=rtl8139", "-net", "user,hostfwd=tcp::22-:22",
+				"-nographic",
+				image,
+			)
+		} else {
+			panic("Running on unknown architecture.")
+		}
+
+		err = qemuCmd.Start()
+		if err != nil {
+			return fmt.Errorf("cannot start the qemu process: %#v", err)
+		}
+
+		defer func() {
+			err := killProcessCleanly(qemuCmd.Process, time.Second)
+			if err != nil {
+				log.Printf("cannot kill the qemu process: %#v", err)
+			}
+		}()
+
+		return f()
+	})
+}
+
+// withBootedNspawnImage boots the specified image in the specified namespace
+// using nspawn. The VM is killed immediately after function returns.
+func withBootedNspawnImage(image string, ns netNS, f func() error) error {
+	cmd := exec.Command(
+		"systemd-nspawn",
+		"--boot", "--register=no",
+		"--image", image,
+		"--network-namespace-path", ns.Path(),
+	)
+
+	err := cmd.Start()
+	if err != nil {
+		return fmt.Errorf("cannot start the systemd-nspawn process: %#v", err)
+	}
+
+	defer func() {
+		err := killProcessCleanly(cmd.Process, time.Second)
+		if err != nil {
+			log.Printf("cannot kill the systemd-nspawn process: %#v", err)
+		}
+	}()
+
+	return f()
+}
+
+// withBootedNspawnImage boots the specified directory in the specified namespace
+// using nspawn. The VM is killed immediately after function returns.
+func withBootedNspawnDirectory(dir string, ns netNS, f func() error) error {
+	cmd := exec.Command(
+		"systemd-nspawn",
+		"--boot", "--register=no",
+		"--directory", dir,
+		"--network-namespace-path", ns.Path(),
+	)
+
+	err := cmd.Start()
+	if err != nil {
+		return fmt.Errorf("cannot start the systemd-nspawn process: %#v", err)
+	}
+
+	defer func() {
+		err := killProcessCleanly(cmd.Process, time.Second)
+		if err != nil {
+			log.Printf("cannot kill the systemd-nspawn process: %#v", err)
+		}
+	}()
+
+	return f()
+}
+
+// withExtractedTarArchive extracts the provided archive and passes
+// a path to the result to the function f. The result is deleted
+// immediately after the function returns.
+func withExtractedTarArchive(archive string, f func(dir string) error) error {
+	return withTempDir("", "tar-archive", func(dir string) error {
+		cmd := exec.Command(
+			"tar",
+			"xf", archive,
+			"-C", dir,
+		)
+		cmd.Stderr = os.Stderr
+		cmd.Stdout = os.Stdout
+
+		err := cmd.Run()
+		if err != nil {
+			return fmt.Errorf("cannot untar the archive: %#v", err)
+		}
+
+		return f(dir)
+	})
+}
+
+// withSSHKeyPair runs the function f with a newly generated
+// ssh key-pair, they key-pair is deleted immediately after
+// the function f returns
+func withSSHKeyPair(f func(privateKey, publicKey string) error) error {
+	return withTempDir("", "keys", func(dir string) error {
+		privateKey := dir + "/id_rsa"
+		publicKey := dir + "/id_rsa.pub"
+		cmd := exec.Command("ssh-keygen",
+			"-N", "",
+			"-f", privateKey,
+		)
+
+		err := cmd.Run()
+		if err != nil {
+			return fmt.Errorf("ssh-keygen failed: %#v", err)
+		}
+
+		return f(privateKey, publicKey)
+	})
+}