ci / test (pull_request) Successful in 40s
The network the installer writes was IPv4 only. Docker relays an IPv6 connection to a published port of an IPv4-only container through docker-proxy, so the server saw every client that connected over IPv6 as the network's gateway, 172.31.253.1: SPF, DMARC and iprev were checked against it, IPv6 senders shared one set of bans and rate limits, and with --proxy snippets (or front ends on the host) the gateway is on the server's allowed list, so IPv6 clients were never banned at all. On a machine with IPv6, compose.yaml now gives the network a unique local /64 (fd69:6e62:7578::/64) beside the IPv4 subnet. Re-running install converges an existing deployment: compose recreates the network. That is enough with Docker 27 and later and with podman, which forward both families themselves. Docker before 27 still relays IPv6 unless ip6tables is on, which there also takes "experimental" (with ip6tables alone the daemon does not start). The survey now reads the engine version and /etc/docker/daemon.json, and deps offers to set both keys, keeping the old file as daemon.json.before-inbuxa and putting it back if Docker does not come up on the new one. Without --install-deps the plan warns instead, and it never writes over a daemon.json it cannot parse. Outbound mail is unchanged in practice: the server tries IPv4 first by default and uses IPv6 only for hosts that have no IPv4 address. e2e/cases/ipv6-sources.sh opens SMTP sessions from a second network namespace with addresses of its own; with OLD_REF it shows the bug on an install from before the fix, then converges it. Fixes #65
572 lines
18 KiB
Go
572 lines
18 KiB
Go
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
// Package deps is what the installer does about something the machine needs
|
|
// and does not have.
|
|
//
|
|
// Refusing because Docker is missing is not help; it is a chore handed back
|
|
// to the operator, who will then install it in whatever way the first search
|
|
// result suggests. The installer knows what it needs, knows this machine, and
|
|
// can do it -- so it offers, says exactly what it would run, and does it only
|
|
// when told.
|
|
//
|
|
// What it will install, and from where:
|
|
//
|
|
// - the Docker daemon: the distribution's own package, never a third-party
|
|
// apt repository. One package from the archive the machine already
|
|
// trusts beats a new signing key and a new source.
|
|
// - the Compose plugin: Debian's docker.io has no compose v2 at all, so
|
|
// this is the official static binary from Docker's release, pinned by
|
|
// version and verified against a checksum in this source file.
|
|
// - Node: the distribution's, when it is new enough; otherwise the
|
|
// official tarball into /opt, pinned and checksummed the same way. No
|
|
// NodeSource repository either, for the same reason.
|
|
//
|
|
// Every fetch is verified before anything is put in place. A checksum that
|
|
// does not match stops the step; it does not warn and continue.
|
|
package deps
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/host"
|
|
)
|
|
|
|
// Pinned versions. Bumping one means bumping its checksum in the same
|
|
// commit: the pair is the point.
|
|
const (
|
|
composeVersion = "v5.5.1"
|
|
nodeVersion = "v26.11.1" // the webmail's image runs Node 26
|
|
NodeMajor = 26
|
|
)
|
|
|
|
var composeSHA = map[string]string{
|
|
"amd64": "db1889184726840f75c4f9c001048430d4f25b3be3cb084d3ddd762bc0aed576",
|
|
"arm64": "732e3a84c1a0f67256ce80bc2598a24546b10ca05f9faa97efceb1171ece2ef7",
|
|
}
|
|
|
|
var nodeSHA = map[string]string{
|
|
"amd64": "3883bfc73f9a680ca4eab04b196068aaaab1373ffa77d8fc1a4408222495b651",
|
|
"arm64": "0945e2cde6aa0f54d980f03874dfe5cf3a549ce714c7fb9019e591ce0accf282",
|
|
}
|
|
|
|
// Need is one missing thing, and what the installer would do about it.
|
|
type Need struct {
|
|
Name string // "docker", "compose", "node"
|
|
Because string // the shape that wants it
|
|
Fixable bool // the installer can do this here
|
|
Why string // when it cannot, the reason
|
|
Actions []string // what it would do, in the words the plan shows
|
|
steps []step // what it would actually run
|
|
}
|
|
|
|
type step struct {
|
|
title string
|
|
run func(ctx context.Context, log io.Writer) error
|
|
}
|
|
|
|
// For works out what is missing for a shape, and what could be done about it
|
|
// on this machine. An empty result means nothing is in the way.
|
|
func For(f host.Facts, wantContainers, wantHostWebmail bool) []Need {
|
|
var needs []Need
|
|
if wantContainers {
|
|
needs = append(needs, runtimeNeeds(f)...)
|
|
if f.IPv6 {
|
|
needs = append(needs, dockerIPv6Need(f, needs))
|
|
}
|
|
}
|
|
// The webmail on the host runs on the installer's own Node, in
|
|
// /opt/inbuxa/node, whatever else the machine has: the version it was
|
|
// released against, and nothing the system's package manager can move.
|
|
if wantHostWebmail && (f.Node.Path != host.OwnPath || f.Node.Major != NodeMajor) {
|
|
needs = append(needs, nodeNeed(f))
|
|
}
|
|
var out []Need
|
|
for _, n := range needs {
|
|
if n.Name != "" {
|
|
out = append(out, n)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// runtimeNeeds is what this machine is missing before it can run containers.
|
|
//
|
|
// Which runtime depends on the distribution, and that is the whole point:
|
|
// Debian and Arch ship Docker, and the Red Hat family ships podman and no
|
|
// Docker at all. Telling a Fedora or Rocky operator to add Docker's own
|
|
// repository -- a new source and a new signing key -- to a machine that
|
|
// already has a working container runtime would be the wrong trade. Compose
|
|
// speaks the Docker API and podman serves it, so one compose file and one
|
|
// plugin drive either.
|
|
func runtimeNeeds(f host.Facts) []Need {
|
|
if f.Runtime.Usable {
|
|
return nil
|
|
}
|
|
switch {
|
|
// Something is installed and broken in a way that is not ours to fix.
|
|
case f.Runtime.Present && f.Runtime.Compose != "":
|
|
return []Need{{
|
|
Name: f.Runtime.Kind,
|
|
Because: "a container install",
|
|
Why: f.Runtime.Why + " -- that is not something this installer should fix for you",
|
|
}}
|
|
case f.Runtime.Kind == "podman":
|
|
// Podman is here; what is missing is its API socket, the compose
|
|
// plugin, or both.
|
|
var needs []Need
|
|
if strings.Contains(f.Runtime.Why, "socket") {
|
|
needs = append(needs, podmanSocketNeed())
|
|
}
|
|
if strings.Contains(f.Runtime.Why, "compose") || len(needs) == 0 {
|
|
needs = append(needs, composeNeed(f))
|
|
}
|
|
return needs
|
|
case f.OS.Family == "rhel":
|
|
// No runtime at all, on a distribution whose own is podman.
|
|
return []Need{podmanNeed(f), podmanSocketNeed(), composeNeed(f)}
|
|
case !f.Runtime.Present:
|
|
return []Need{dockerNeed(f), composeNeed(f)}
|
|
default:
|
|
return []Need{{
|
|
Name: "docker",
|
|
Because: "a container install",
|
|
Why: f.Runtime.Why + " -- that is not something this installer should fix for you",
|
|
}}
|
|
}
|
|
}
|
|
|
|
func podmanNeed(f host.Facts) Need {
|
|
n := Need{Name: "podman", Because: "a container install"}
|
|
pkg, install := packageInstall(f.OS.Family, "podman")
|
|
if install == nil {
|
|
n.Why = "this installer does not know how to install podman on " + describeOS(f.OS)
|
|
return n
|
|
}
|
|
n.Fixable = true
|
|
n.Actions = []string{fmt.Sprintf("install %s from the distribution's own archive", pkg)}
|
|
n.steps = []step{{"installing " + pkg, install}}
|
|
return n
|
|
}
|
|
|
|
// podmanSocketNeed turns on the API socket compose talks to. Podman works
|
|
// perfectly well without it; compose does not.
|
|
func podmanSocketNeed() Need {
|
|
return Need{
|
|
Name: "podman socket",
|
|
Because: "compose, which speaks the Docker API that this socket serves",
|
|
Fixable: true,
|
|
Actions: []string{"enable and start podman.socket, which serves the API at /run/podman/podman.sock"},
|
|
steps: []step{{"starting podman.socket", func(ctx context.Context, log io.Writer) error {
|
|
return run(ctx, log, "systemctl", "enable", "--now", "podman.socket")
|
|
}}},
|
|
}
|
|
}
|
|
|
|
func dockerNeed(f host.Facts) Need {
|
|
n := Need{Name: "docker", Because: "a container install"}
|
|
pkg, install := packageInstall(f.OS.Family, dockerPackage(f.OS.Family))
|
|
if install == nil {
|
|
n.Why = "this installer does not know how to install a container runtime on " + describeOS(f.OS)
|
|
return n
|
|
}
|
|
n.Fixable = true
|
|
n.Actions = []string{
|
|
fmt.Sprintf("install %s from the distribution's own archive", pkg),
|
|
"enable and start the docker service",
|
|
}
|
|
n.steps = []step{
|
|
{"installing " + pkg, install},
|
|
{"starting docker", func(ctx context.Context, log io.Writer) error {
|
|
return run(ctx, log, "systemctl", "enable", "--now", "docker")
|
|
}},
|
|
}
|
|
return n
|
|
}
|
|
|
|
// dockerIPv6Need turns on Docker's own IPv6 forwarding where it is off, so
|
|
// a client that connects over IPv6 reaches the containers with its own
|
|
// address. Without it docker-proxy relays the connection, and the server
|
|
// sees the project network's gateway for every IPv6 client: SPF and DMARC
|
|
// are checked against it, and bans and rate limits lump them together (#65).
|
|
//
|
|
// It is offered for Docker that is here and relays, and for Docker this run
|
|
// is about to install, whose version is not known yet; the step looks again
|
|
// once it is there and leaves a Docker that already forwards alone. Not for
|
|
// podman, which forwards both families itself, and not for a daemon.json
|
|
// that is not JSON, which the plan warns about instead: writing over a file
|
|
// that cannot be read is not a fix.
|
|
func dockerIPv6Need(f host.Facts, before []Need) Need {
|
|
installing := false
|
|
for _, n := range before {
|
|
if n.Name == "docker" && n.Fixable {
|
|
installing = true
|
|
}
|
|
}
|
|
if !installing {
|
|
if f.Runtime.Kind != "docker" || !f.Runtime.Usable || f.Runtime.ForwardsIPv6 {
|
|
return Need{}
|
|
}
|
|
cur, _ := os.ReadFile(host.DockerDaemonConfig)
|
|
if _, err := host.DockerForwardsIPv6(f.Runtime.Version, cur); err != nil {
|
|
return Need{}
|
|
}
|
|
}
|
|
n := Need{Name: "docker IPv6 forwarding", Because: "mail and web clients that connect over IPv6", Fixable: true}
|
|
if installing {
|
|
n.Actions = append(n.Actions, "if the Docker it installs relays IPv6 rather than forwarding it:")
|
|
}
|
|
n.Actions = append(n.Actions,
|
|
`set "ip6tables": true in `+host.DockerDaemonConfig+` (and "experimental": true, which Docker before 27 needs for it), keeping a copy of the file as it was`,
|
|
"restart Docker, which restarts the containers already running on this machine",
|
|
)
|
|
n.steps = []step{{"turning on Docker's IPv6 forwarding", dockerIPv6On}}
|
|
return n
|
|
}
|
|
|
|
func dockerIPv6On(ctx context.Context, log io.Writer) error {
|
|
out, err := exec.CommandContext(ctx, "docker", "version", "--format", "{{.Server.Version}}").Output()
|
|
if err != nil {
|
|
return fmt.Errorf("asking docker its version: %w", err)
|
|
}
|
|
version := strings.TrimSpace(string(out))
|
|
path := host.DockerDaemonConfig
|
|
cur, err := os.ReadFile(path)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
on, err := host.DockerForwardsIPv6(version, cur)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if on {
|
|
fmt.Fprintf(log, " Docker %s already forwards IPv6\n", version)
|
|
return nil
|
|
}
|
|
cfg := map[string]any{}
|
|
if len(strings.TrimSpace(string(cur))) > 0 {
|
|
if err := json.Unmarshal(cur, &cfg); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
cfg["ip6tables"] = true
|
|
if host.DockerMajor(version) < 27 {
|
|
cfg["experimental"] = true
|
|
}
|
|
next, err := json.MarshalIndent(cfg, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
return err
|
|
}
|
|
if cur != nil {
|
|
backup := path + ".before-inbuxa"
|
|
if _, err := os.Stat(backup); os.IsNotExist(err) {
|
|
if err := os.WriteFile(backup, cur, 0o644); err != nil {
|
|
return err
|
|
}
|
|
fmt.Fprintf(log, " the file as it was is in %s\n", backup)
|
|
}
|
|
}
|
|
if err := writeFile(path, append(next, '\n')); err != nil {
|
|
return err
|
|
}
|
|
if err := run(ctx, log, "systemctl", "restart", "docker"); err != nil {
|
|
// A daemon that will not start on the new file is worse than one
|
|
// that relays IPv6: put the old one back and start it on that.
|
|
if cur != nil {
|
|
_ = writeFile(path, cur)
|
|
} else {
|
|
_ = os.Remove(path)
|
|
}
|
|
_ = run(ctx, log, "systemctl", "restart", "docker")
|
|
return fmt.Errorf("docker did not restart with ip6tables on, so %s is back as it was: %w", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// writeFile replaces path in one step, so a reader never finds half a file.
|
|
func writeFile(path string, b []byte) error {
|
|
tmp := path + ".tmp"
|
|
if err := os.WriteFile(tmp, b, 0o644); err != nil {
|
|
return err
|
|
}
|
|
return os.Rename(tmp, path)
|
|
}
|
|
|
|
// composeNeed is the same plugin whichever runtime is underneath: compose
|
|
// speaks the Docker API, and podman serves it.
|
|
func composeNeed(f host.Facts) Need {
|
|
arch := goarch()
|
|
sum, ok := composeSHA[arch]
|
|
n := Need{Name: "compose", Because: "a container install"}
|
|
if !ok {
|
|
n.Why = "no pinned Compose build for " + arch
|
|
return n
|
|
}
|
|
url := fmt.Sprintf("https://github.com/docker/compose/releases/download/%s/docker-compose-linux-%s",
|
|
composeVersion, archName(arch))
|
|
n.Fixable = true
|
|
n.Actions = []string{
|
|
fmt.Sprintf("fetch the Compose plugin %s (%s) and check it against its pinned checksum", composeVersion, arch),
|
|
"put it at " + host.ComposePluginPath,
|
|
}
|
|
n.steps = []step{
|
|
{"fetching compose " + composeVersion, func(ctx context.Context, log io.Writer) error {
|
|
return fetchVerified(ctx, log, url, sum, host.ComposePluginPath, 0o755)
|
|
}},
|
|
}
|
|
return n
|
|
}
|
|
|
|
func nodeNeed(f host.Facts) Need {
|
|
n := Need{Name: "node", Because: "a host install of the webmail"}
|
|
arch := goarch()
|
|
sum, ok := nodeSHA[arch]
|
|
if !ok {
|
|
n.Why = "no pinned Node build for " + arch
|
|
return n
|
|
}
|
|
url := fmt.Sprintf("https://nodejs.org/dist/%s/node-%s-linux-%s.tar.xz", nodeVersion, nodeVersion, archName2(arch))
|
|
n.Fixable = true
|
|
n.Actions = []string{
|
|
fmt.Sprintf("fetch Node %s (%s) and check it against its pinned checksum", nodeVersion, arch),
|
|
"unpack it into /opt/inbuxa/node, used by the webmail's unit and nothing else",
|
|
}
|
|
n.steps = []step{
|
|
{"fetching node " + nodeVersion, func(ctx context.Context, log io.Writer) error {
|
|
tmp := filepath.Join(os.TempDir(), "inbuxa-node.tar.xz")
|
|
if err := fetchVerified(ctx, log, url, sum, tmp, 0o644); err != nil {
|
|
return err
|
|
}
|
|
// A different version unpacked over the old one would leave
|
|
// the old one's files behind it.
|
|
if err := os.RemoveAll("/opt/inbuxa/node"); err != nil {
|
|
return err
|
|
}
|
|
if err := os.MkdirAll("/opt/inbuxa/node", 0o755); err != nil {
|
|
return err
|
|
}
|
|
return run(ctx, log, "tar", "-xJf", tmp, "-C", "/opt/inbuxa/node", "--strip-components=1")
|
|
}},
|
|
}
|
|
return n
|
|
}
|
|
|
|
func dockerPackage(family string) string {
|
|
switch family {
|
|
case "debian":
|
|
return "docker.io"
|
|
case "arch":
|
|
return "docker"
|
|
case "suse":
|
|
return "docker"
|
|
}
|
|
// The Red Hat family is deliberately absent: its distributions ship
|
|
// podman, not Docker, and runtimeNeeds sends them there.
|
|
return ""
|
|
}
|
|
|
|
// packageInstall returns the package name and the command that installs it,
|
|
// or nil when this installer has nothing to say about the machine's
|
|
// packaging.
|
|
func packageInstall(family, pkg string) (string, func(context.Context, io.Writer) error) {
|
|
if pkg == "" {
|
|
return "", nil
|
|
}
|
|
switch family {
|
|
case "debian":
|
|
return pkg, func(ctx context.Context, log io.Writer) error {
|
|
if err := run(ctx, log, "apt-get", "update", "-qq"); err != nil {
|
|
return err
|
|
}
|
|
cmd := exec.CommandContext(ctx, "apt-get", "install", "-y", "-qq", pkg)
|
|
cmd.Env = append(os.Environ(), "DEBIAN_FRONTEND=noninteractive")
|
|
return pipe(cmd, log)
|
|
}
|
|
case "arch":
|
|
return pkg, func(ctx context.Context, log io.Writer) error {
|
|
return run(ctx, log, "pacman", "-S", "--noconfirm", "--needed", pkg)
|
|
}
|
|
case "rhel":
|
|
return pkg, func(ctx context.Context, log io.Writer) error {
|
|
return run(ctx, log, "dnf", "install", "-y", pkg)
|
|
}
|
|
case "suse":
|
|
return pkg, func(ctx context.Context, log io.Writer) error {
|
|
return run(ctx, log, "zypper", "--non-interactive", "install", pkg)
|
|
}
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
// Resolve does what the needs say, in order, writing what it is doing to log.
|
|
// It stops at the first failure: a half-resolved machine is worse than one
|
|
// that is clearly still missing something.
|
|
func Resolve(ctx context.Context, log io.Writer, needs []Need) error {
|
|
for _, n := range needs {
|
|
if !n.Fixable {
|
|
return fmt.Errorf("%s: %s", n.Name, n.Why)
|
|
}
|
|
for _, s := range n.steps {
|
|
fmt.Fprintf(log, " %s\n", s.title)
|
|
if err := s.run(ctx, log); err != nil {
|
|
return fmt.Errorf("%s: %w", n.Name, err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Describe is the offer, in the words the interface and the plan use.
|
|
func Describe(needs []Need) string {
|
|
var b strings.Builder
|
|
for _, n := range needs {
|
|
if n.Fixable {
|
|
fmt.Fprintf(&b, " %s is missing, for %s. The installer can:\n", n.Name, n.Because)
|
|
for _, a := range n.Actions {
|
|
fmt.Fprintf(&b, " %s\n", a)
|
|
}
|
|
} else {
|
|
fmt.Fprintf(&b, " %s is missing, for %s, and cannot be installed here: %s\n", n.Name, n.Because, n.Why)
|
|
}
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// Fixable is true when everything in the way can be dealt with.
|
|
func Fixable(needs []Need) bool {
|
|
for _, n := range needs {
|
|
if !n.Fixable {
|
|
return false
|
|
}
|
|
}
|
|
return len(needs) > 0
|
|
}
|
|
|
|
// FetchVerified downloads url to dest, and puts it there only when its
|
|
// SHA-256 is want. It is how everything this program installs from the
|
|
// network arrives: against a checksum written into the source, never one
|
|
// fetched from beside the download.
|
|
func FetchVerified(ctx context.Context, log io.Writer, url, want, dest string, mode os.FileMode) error {
|
|
return fetchVerified(ctx, log, url, want, dest, mode)
|
|
}
|
|
|
|
func fetchVerified(ctx context.Context, log io.Writer, url, want, dest string, mode os.FileMode) error {
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
client := &http.Client{Timeout: 10 * time.Minute}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("%s: %s", url, resp.Status)
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
|
|
return err
|
|
}
|
|
tmp := dest + ".part"
|
|
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, mode)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
h := sha256.New()
|
|
if _, err := io.Copy(io.MultiWriter(f, h), resp.Body); err != nil {
|
|
f.Close()
|
|
os.Remove(tmp)
|
|
return err
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
os.Remove(tmp)
|
|
return err
|
|
}
|
|
got := hex.EncodeToString(h.Sum(nil))
|
|
if got != want {
|
|
os.Remove(tmp)
|
|
return fmt.Errorf("checksum of %s is %s, expected %s -- nothing was installed", url, got, want)
|
|
}
|
|
fmt.Fprintf(log, " checksum ok (%s…)\n", got[:16])
|
|
return os.Rename(tmp, dest)
|
|
}
|
|
|
|
func run(ctx context.Context, log io.Writer, name string, args ...string) error {
|
|
return pipe(exec.CommandContext(ctx, name, args...), log)
|
|
}
|
|
|
|
func pipe(cmd *exec.Cmd, log io.Writer) error {
|
|
out := &prefixer{w: log}
|
|
cmd.Stdout, cmd.Stderr = out, out
|
|
if err := cmd.Run(); err != nil {
|
|
return fmt.Errorf("%s: %w", strings.Join(cmd.Args, " "), err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// prefixer indents a command's own output so it is plainly the command
|
|
// talking and not the installer.
|
|
type prefixer struct {
|
|
w io.Writer
|
|
buf []byte
|
|
}
|
|
|
|
func (p *prefixer) Write(b []byte) (int, error) {
|
|
p.buf = append(p.buf, b...)
|
|
for {
|
|
i := strings.IndexByte(string(p.buf), '\n')
|
|
if i < 0 {
|
|
break
|
|
}
|
|
line := strings.TrimRight(string(p.buf[:i]), "\r")
|
|
p.buf = p.buf[i+1:]
|
|
if strings.TrimSpace(line) != "" {
|
|
fmt.Fprintf(p.w, " | %s\n", line)
|
|
}
|
|
}
|
|
return len(b), nil
|
|
}
|
|
|
|
func goarch() string { return runtime.GOARCH }
|
|
|
|
// Docker and Node name the same architectures differently, which is a small
|
|
// thing that breaks a download silently if it is guessed.
|
|
func archName(a string) string {
|
|
if a == "arm64" {
|
|
return "aarch64"
|
|
}
|
|
return "x86_64"
|
|
}
|
|
|
|
func archName2(a string) string {
|
|
if a == "arm64" {
|
|
return "arm64"
|
|
}
|
|
return "x64"
|
|
}
|
|
|
|
func describeOS(o host.OSInfo) string {
|
|
if o.Pretty != "" {
|
|
return o.Pretty
|
|
}
|
|
if o.ID != "" {
|
|
return o.ID
|
|
}
|
|
return "this distribution"
|
|
}
|