path: root/cmd/mbf/main.go

package main

import (
	"context"
	"errors"
	"fmt"
	"io"
	"log"
	"os"
	"os/signal"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"time"
	"unique"

	"hakurei.app/command"
	"hakurei.app/container"
	"hakurei.app/container/check"
	"hakurei.app/container/fhs"
	"hakurei.app/container/seccomp"
	"hakurei.app/container/std"
	"hakurei.app/internal/pkg"
	"hakurei.app/internal/rosa"
	"hakurei.app/message"
)

func main() {
	container.TryArgv0(nil)

	log.SetFlags(0)
	log.SetPrefix("mbf: ")
	msg := message.New(log.Default())

	if os.Geteuid() == 0 {
		log.Fatal("this program must not run as root")
	}

	var cache *pkg.Cache
	ctx, stop := signal.NotifyContext(context.Background(),
		syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
	defer stop()
	defer func() {
		if cache != nil {
			cache.Close()
		}

		if r := recover(); r != nil {
			fmt.Println(r)
			log.Fatal("consider scrubbing the on-disk cache")
		}
	}()

	var (
		flagQuiet  bool
		flagCures  int
		flagBase   string
		flagTShift int
		flagIdle   bool
	)
	c := command.New(os.Stderr, log.Printf, "mbf", func([]string) (err error) {
		msg.SwapVerbose(!flagQuiet)

		flagBase = os.ExpandEnv(flagBase)
		if flagBase == "" {
			flagBase = "cache"
		}

		var base *check.Absolute
		if flagBase, err = filepath.Abs(flagBase); err != nil {
			return
		} else if base, err = check.NewAbs(flagBase); err != nil {
			return
		}
		if cache, err = pkg.Open(ctx, msg, flagCures, base); err == nil {
			if flagTShift < 0 {
				cache.SetThreshold(0)
			} else if flagTShift > 31 {
				cache.SetThreshold(1 << 31)
			} else {
				cache.SetThreshold(1 << flagTShift)
			}
		}

		if flagIdle {
			pkg.SchedPolicy = container.SCHED_IDLE
		}

		return
	}).Flag(
		&flagQuiet,
		"q", command.BoolFlag(false),
		"Do not print cure messages",
	).Flag(
		&flagCures,
		"cures", command.IntFlag(0),
		"Maximum number of dependencies to cure at any given time",
	).Flag(
		&flagBase,
		"d", command.StringFlag("$MBF_CACHE_DIR"),
		"Directory to store cured artifacts",
	).Flag(
		&flagTShift,
		"tshift", command.IntFlag(-1),
		"Dependency graph size exponent, to the power of 2",
	).Flag(
		&flagIdle,
		"sched-idle", command.BoolFlag(false),
		"Set SCHED_IDLE scheduling policy",
	)

	{
		var flagShifts int
		c.NewCommand(
			"scrub", "Examine the on-disk cache for errors",
			func(args []string) error {
				if len(args) > 0 {
					return errors.New("scrub expects no arguments")
				}
				if flagShifts < 0 || flagShifts > 31 {
					flagShifts = 12
				}
				return cache.Scrub(runtime.NumCPU() << flagShifts)
			},
		).Flag(
			&flagShifts,
			"shift", command.IntFlag(12),
			"Scrub parallelism size exponent, to the power of 2",
		)
	}

	{
		var (
			flagStatus bool
			flagReport string
		)
		c.NewCommand(
			"info",
			"Display out-of-band metadata of an artifact",
			func(args []string) (err error) {
				if len(args) == 0 {
					return errors.New("info requires at least 1 argument")
				}

				var r *rosa.Report
				if flagReport != "" {
					if r, err = rosa.OpenReport(flagReport); err != nil {
						return err
					}
					defer func() {
						if closeErr := r.Close(); err == nil {
							err = closeErr
						}
					}()
					defer r.HandleAccess(&err)()
				}

				for i, name := range args {
					if p, ok := rosa.ResolveName(name); !ok {
						return fmt.Errorf("unknown artifact %q", name)
					} else {
						var suffix string
						if version := rosa.Std.Version(p); version != rosa.Unversioned {
							suffix += "-" + version
						}
						fmt.Println("name        : " + name + suffix)

						meta := rosa.GetMetadata(p)
						fmt.Println("description : " + meta.Description)
						if meta.Website != "" {
							fmt.Println("website     : " +
								strings.TrimSuffix(meta.Website, "/"))
						}

						const statusPrefix = "status      : "
						if flagStatus {
							if r == nil {
								var f io.ReadSeekCloser
								f, err = cache.OpenStatus(rosa.Std.Load(p))
								if err != nil {
									if errors.Is(err, os.ErrNotExist) {
										fmt.Println(
											statusPrefix + "not yet cured",
										)
									} else {
										return
									}
								} else {
									fmt.Print(statusPrefix)
									_, err = io.Copy(os.Stdout, f)
									if err = errors.Join(err, f.Close()); err != nil {
										return
									}
								}
							} else {
								status, n := r.ArtifactOf(cache.Ident(rosa.Std.Load(p)))
								if status == nil {
									fmt.Println(
										statusPrefix + "not in report",
									)
								} else {
									fmt.Println("size        :", n)
									fmt.Print(statusPrefix)
									if _, err = os.Stdout.Write(status); err != nil {
										return
									}
								}
							}
						}

						if i != len(args)-1 {
							fmt.Println()
						}
					}
				}
				return nil
			},
		).
			Flag(
				&flagStatus,
				"status", command.BoolFlag(false),
				"Display cure status if available",
			).
			Flag(
				&flagReport,
				"report", command.StringFlag(""),
				"Load cure status from this report file instead of cache",
			)
	}

	c.NewCommand(
		"report",
		"Generate an artifact cure report for the current cache",
		func(args []string) (err error) {
			var w *os.File
			switch len(args) {
			case 0:
				w = os.Stdout

			case 1:
				if w, err = os.OpenFile(
					args[0],
					os.O_CREATE|os.O_EXCL|syscall.O_WRONLY,
					0,
				); err != nil {
					return
				}
				defer func() {
					closeErr := w.Close()
					if err == nil {
						err = closeErr
					}
				}()

			default:
				return errors.New("report requires 1 argument")
			}

			if container.Isatty(int(w.Fd())) {
				return errors.New("output appears to be a terminal")
			}
			return rosa.WriteReport(msg, w, cache)
		},
	)

	{
		var flagJobs int
		c.NewCommand("updates", command.UsageInternal, func([]string) error {
			var (
				errsMu sync.Mutex
				errs   []error

				n atomic.Uint64
			)

			w := make(chan rosa.PArtifact)
			var wg sync.WaitGroup
			for range max(flagJobs, 1) {
				wg.Go(func() {
					for p := range w {
						meta := rosa.GetMetadata(p)
						if meta.ID == 0 {
							continue
						}

						v, err := meta.GetVersions(ctx)
						if err != nil {
							errsMu.Lock()
							errs = append(errs, err)
							errsMu.Unlock()
							continue
						}

						if current, latest :=
							rosa.Std.Version(p),
							meta.GetLatest(v); current != latest {

							n.Add(1)
							log.Printf("%s %s < %s", meta.Name, current, latest)
							continue
						}

						msg.Verbosef("%s is up to date", meta.Name)
					}
				})
			}

		done:
			for i := range rosa.PresetEnd {
				select {
				case w <- rosa.PArtifact(i):
					break
				case <-ctx.Done():
					break done
				}
			}
			close(w)
			wg.Wait()

			if v := n.Load(); v > 0 {
				errs = append(errs, errors.New(strconv.Itoa(int(v))+
					" package(s) are out of date"))
			}
			return errors.Join(errs...)
		}).
			Flag(
				&flagJobs,
				"j", command.IntFlag(32),
				"Maximum number of simultaneous connections",
			)
	}

	{
		var (
			flagGentoo   string
			flagChecksum string

			flagStage0 bool
		)
		c.NewCommand(
			"stage3",
			"Check for toolchain 3-stage non-determinism",
			func(args []string) (err error) {
				t := rosa.Std
				if flagGentoo != "" {
					t -= 3 // magic number to discourage misuse

					var checksum pkg.Checksum
					if len(flagChecksum) != 0 {
						if err = pkg.Decode(&checksum, flagChecksum); err != nil {
							return
						}
					}
					rosa.SetGentooStage3(flagGentoo, checksum)
				}

				_, _, _, stage1 := (t - 2).NewLLVM()
				_, _, _, stage2 := (t - 1).NewLLVM()
				_, _, _, stage3 := t.NewLLVM()
				var (
					pathname *check.Absolute
					checksum [2]unique.Handle[pkg.Checksum]
				)

				if pathname, _, err = cache.Cure(stage1); err != nil {
					return err
				}
				log.Println("stage1:", pathname)

				if pathname, checksum[0], err = cache.Cure(stage2); err != nil {
					return err
				}
				log.Println("stage2:", pathname)
				if pathname, checksum[1], err = cache.Cure(stage3); err != nil {
					return err
				}
				log.Println("stage3:", pathname)

				if checksum[0] != checksum[1] {
					err = &pkg.ChecksumMismatchError{
						Got:  checksum[0].Value(),
						Want: checksum[1].Value(),
					}
				} else {
					log.Println(
						"stage2 is identical to stage3",
						"("+pkg.Encode(checksum[0].Value())+")",
					)
				}

				if flagStage0 {
					if pathname, _, err = cache.Cure(
						t.Load(rosa.Stage0),
					); err != nil {
						return err
					}
					log.Println(pathname)
				}

				return
			},
		).
			Flag(
				&flagGentoo,
				"gentoo", command.StringFlag(""),
				"Bootstrap from a Gentoo stage3 tarball",
			).
			Flag(
				&flagChecksum,
				"checksum", command.StringFlag(""),
				"Checksum of Gentoo stage3 tarball",
			).
			Flag(
				&flagStage0,
				"stage0", command.BoolFlag(false),
				"Create bootstrap stage0 tarball",
			)
	}

	{
		var (
			flagDump string
		)
		c.NewCommand(
			"cure",
			"Cure the named artifact and show its path",
			func(args []string) error {
				if len(args) != 1 {
					return errors.New("cure requires 1 argument")
				}
				if p, ok := rosa.ResolveName(args[0]); !ok {
					return fmt.Errorf("unknown artifact %q", args[0])
				} else if flagDump == "" {
					pathname, _, err := cache.Cure(rosa.Std.Load(p))
					if err == nil {
						log.Println(pathname)
					}
					return err
				} else {
					f, err := os.OpenFile(
						flagDump,
						os.O_WRONLY|os.O_CREATE|os.O_EXCL,
						0644,
					)
					if err != nil {
						return err
					}

					if err = cache.EncodeAll(f, rosa.Std.Load(p)); err != nil {
						_ = f.Close()
						return err
					}

					return f.Close()
				}
			},
		).
			Flag(
				&flagDump,
				"dump", command.StringFlag(""),
				"Write IR to specified pathname and terminate",
			)
	}

	{
		var (
			flagNet     bool
			flagSession bool

			flagWithToolchain bool
		)
		c.NewCommand(
			"shell",
			"Interactive shell in the specified Rosa OS environment",
			func(args []string) error {
				root := make([]pkg.Artifact, 0, 6+len(args))
				for _, arg := range args {
					p, ok := rosa.ResolveName(arg)
					if !ok {
						return fmt.Errorf("unknown artifact %q", arg)
					}
					root = append(root, rosa.Std.Load(p))
				}

				if flagWithToolchain {
					musl, compilerRT, runtimes, clang := rosa.Std.NewLLVM()
					root = append(root, musl, compilerRT, runtimes, clang)
				} else {
					root = append(root, rosa.Std.Load(rosa.Musl))
				}
				root = append(root,
					rosa.Std.Load(rosa.Mksh),
					rosa.Std.Load(rosa.Toybox),
				)

				type cureRes struct {
					pathname *check.Absolute
					checksum unique.Handle[pkg.Checksum]
				}
				cured := make(map[pkg.Artifact]cureRes)
				for _, a := range root {
					pathname, checksum, err := cache.Cure(a)
					if err != nil {
						return err
					}
					cured[a] = cureRes{pathname, checksum}
				}

				layers := pkg.PromoteLayers(root, func(a pkg.Artifact) (
					*check.Absolute,
					unique.Handle[pkg.Checksum],
				) {
					res := cured[a]
					return res.pathname, res.checksum
				}, func(i int, d pkg.Artifact) {
					r := pkg.Encode(cache.Ident(d).Value())
					if s, ok := d.(fmt.Stringer); ok {
						if name := s.String(); name != "" {
							r += "-" + name
						}
					}
					msg.Verbosef("promoted layer %d as %s", i, r)
				})

				z := container.New(ctx, msg)
				z.WaitDelay = 3 * time.Second
				z.SeccompPresets = pkg.SeccompPresets
				z.SeccompFlags |= seccomp.AllowMultiarch
				z.ParentPerm = 0700
				z.HostNet = flagNet
				z.RetainSession = flagSession
				z.Hostname = "localhost"
				z.Uid, z.Gid = (1<<10)-1, (1<<10)-1
				z.Stdin, z.Stdout, z.Stderr = os.Stdin, os.Stdout, os.Stderr

				var tempdir *check.Absolute
				if s, err := filepath.Abs(os.TempDir()); err != nil {
					return err
				} else if tempdir, err = check.NewAbs(s); err != nil {
					return err
				}

				z.Dir = fhs.AbsRoot
				z.Env = []string{
					"SHELL=/system/bin/mksh",
					"PATH=/system/bin",
					"HOME=/",
				}
				z.Path = rosa.AbsSystem.Append("bin", "mksh")
				z.Args = []string{"mksh"}
				z.
					OverlayEphemeral(fhs.AbsRoot, layers...).
					Place(
						fhs.AbsEtc.Append("hosts"),
						[]byte("127.0.0.1 localhost\n"),
					).
					Place(
						fhs.AbsEtc.Append("passwd"),
						[]byte("media_rw:x:1023:1023::/:/system/bin/sh\n"+
							"nobody:x:65534:65534::/proc/nonexistent:/system/bin/false\n"),
					).
					Place(
						fhs.AbsEtc.Append("group"),
						[]byte("media_rw:x:1023:\nnobody:x:65534:\n"),
					).
					Bind(tempdir, fhs.AbsTmp, std.BindWritable).
					Proc(fhs.AbsProc).Dev(fhs.AbsDev, true)

				if err := z.Start(); err != nil {
					return err
				}
				if err := z.Serve(); err != nil {
					return err
				}
				return z.Wait()
			},
		).
			Flag(
				&flagNet,
				"net", command.BoolFlag(false),
				"Share host net namespace",
			).
			Flag(
				&flagSession,
				"session", command.BoolFlag(false),
				"Retain session",
			).
			Flag(
				&flagWithToolchain,
				"with-toolchain", command.BoolFlag(false),
				"Include the stage3 LLVM toolchain",
			)

	}

	c.Command(
		"help",
		"Show this help message",
		func([]string) error { c.PrintHelp(); return nil },
	)

	c.MustParse(os.Args[1:], func(err error) {
		if cache != nil {
			cache.Close()
		}
		if w, ok := err.(interface{ Unwrap() []error }); !ok {
			log.Fatal(err)
		} else {
			errs := w.Unwrap()
			for i, e := range errs {
				if i == len(errs)-1 {
					log.Fatal(e)
				}
				log.Println(e)
			}
		}
	})
}