A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(rexctl): check host resources, engine and .env file
Hampus3c50fd17a034
diff --git a/fluxer_rexctl/internal/checks/boot_unit.go b/fluxer_rexctl/internal/checks/boot_unit.gonew file mode 100644index 000000000..db2197faa--- /dev/null+++ b/fluxer_rexctl/internal/checks/boot_unit.go@@ -0,0 +1,99 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "os"+ "path/filepath"+ "time"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+)++func init() {+ Register(Check{ID: "boot-unit", Phases: Installed, Run: runBootUnit, Fix: fixBootUnit, SafeFix: true})+}++func RunningBinary() (string, error) {+ bin, err := os.Executable()+ if err != nil {+ return "", err+ }+ if real, err := filepath.EvalSymlinks(bin); err == nil {+ bin = real+ }+ return filepath.Abs(bin)+}++func StopGrace(p *engine.Project) time.Duration {+ var longest time.Duration+ if p == nil || p.Model == nil {+ return longest+ }+ for _, svc := range p.Model.Services {+ if svc.StopGracePeriod != nil && time.Duration(*svc.StopGracePeriod) > longest {+ longest = time.Duration(*svc.StopGracePeriod)+ }+ }+ return longest+}++func BootUnitFor(inst *instance.Instance, e *engine.Engine, p *engine.Project) (host.BootUnit, error) {+ bin, err := RunningBinary()+ if err != nil {+ return host.BootUnit{}, err+ }+ dir, err := filepath.Abs(inst.Dir)+ if err != nil {+ return host.BootUnit{}, err+ }+ return host.BootUnit{+ Project: inst.Project(),+ Dir: dir,+ Binary: bin,+ Podman: e.Kind == engine.Podman,+ Rootless: e.Rootless,+ StopGrace: StopGrace(p),+ }, nil+}++func (e *Env) bootUnit(ctx context.Context) (host.BootUnit, host.BootUnitState, bool) {+ st := e.state()+ if st == nil || st.Ejected != nil || e.Engine == nil || !host.BootUnitSupported() {+ return host.BootUnit{}, host.BootUnitState{}, false+ }+ u, err := BootUnitFor(e.Instance, e.Engine, e.Project)+ if err != nil {+ return host.BootUnit{}, host.BootUnitState{}, false+ }+ s, err := host.CheckBootUnit(ctx, u)+ if err != nil || !s.Supported {+ return host.BootUnit{}, host.BootUnitState{}, false+ }+ return u, s, true+}++func runBootUnit(ctx context.Context, e *Env) Result {+ _, s, ok := e.bootUnit(ctx)+ if !ok {+ return skip("")+ }+ switch {+ case s.Missing, s.Disabled, s.NoLinger:+ return fixable(warn("Fluxer won't start again after this machine restarts.", "Run rexctl doctor --fix to start it with the machine."))+ case s.Stale, s.CopyStale:+ return fixable(warn("The service that starts Fluxer with this machine points at an old copy of rexctl.", "Run rexctl doctor --fix to update it."))+ }+ return pass("Fluxer starts with this machine.")+}++func fixBootUnit(ctx context.Context, e *Env) error {+ u, s, ok := e.bootUnit(ctx)+ if !ok || !s.Needed() {+ return nil+ }+ return host.InstallBootUnit(ctx, u)+}diff --git a/fluxer_rexctl/internal/checks/disk.go b/fluxer_rexctl/internal/checks/disk.gonew file mode 100644index 000000000..5c04dbbfd--- /dev/null+++ b/fluxer_rexctl/internal/checks/disk.go@@ -0,0 +1,77 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "fmt"+ "os"+ "runtime"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++const (+ diskNeededInstall = 20 << 30+ diskLow = 10 << 30+ diskCritical = 5 << 30+)++func init() {+ Register(Check{ID: "disk", Phases: Preinstall | Installed, Run: runDisk})+}++func runDisk(ctx context.Context, e *Env) Result {+ free, ok := e.freeDisk()+ if !ok {+ return skip("Couldn't read how much free disk space this machine has.")+ }+ if !e.installed() {+ if free < diskNeededInstall {+ return fail(fmt.Sprintf("This machine has %s of free disk space and Fluxer needs at least 20 GB.", freeGB(free)),+ "Free up space on this machine, then run rexctl doctor.")+ }+ return pass(fmt.Sprintf("This machine has %s of free disk space.", freeGB(free)))+ }+ switch {+ case free < diskCritical:+ return fail(fmt.Sprintf("This machine has only %s of free disk space left.", freeGB(free)),+ "Free up space on this machine, then run rexctl doctor.")+ case free < diskLow:+ return warn(fmt.Sprintf("This machine has %s of free disk space left and an upgrade needs about 10 GB.", freeGB(free)),+ "Free up space on this machine before you upgrade.")+ }+ return pass(fmt.Sprintf("This machine has %s of free disk space.", freeGB(free)))+}++func (e *Env) freeDisk() (uint64, bool) {+ paths := []string{e.Dir}+ if runtime.GOOS == "linux" {+ root := "/var/lib/docker"+ if e.Engine != nil && e.Engine.Kind == engine.Podman {+ root = "/var/lib/containers"+ }+ if e.Engine == nil || !e.Engine.Rootless {+ if _, err := os.Stat(root); err == nil {+ paths = append(paths, root)+ }+ }+ }+ var lowest uint64+ found := false+ for _, p := range paths {+ free, err := host.FreeDisk(p)+ if err != nil {+ continue+ }+ if !found || free < lowest {+ lowest, found = free, true+ }+ }+ return lowest, found+}++func freeGB(bytes uint64) string {+ return fmt.Sprintf("%d GB", bytes>>30)+}diff --git a/fluxer_rexctl/internal/checks/engine.go b/fluxer_rexctl/internal/checks/engine.gonew file mode 100644index 000000000..0cf84dcb9--- /dev/null+++ b/fluxer_rexctl/internal/checks/engine.go@@ -0,0 +1,96 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "errors"+ "fmt"+ "os"+ "runtime"+ "strings"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++func init() {+ Register(Check{ID: "engine", Phases: Preinstall | Installed, Run: runEngine, Fix: fixEngine, SafeFix: true})+}++func runEngine(ctx context.Context, e *Env) Result {+ name := e.engineName()+ if e.Engine == nil {+ switch engine.ClassOf(e.engineErr) {+ case engine.ClassDenied:+ if name == "Podman" {+ return fail("This account isn't allowed to use Podman.", "Run rexctl as the account that runs Podman, then run rexctl doctor.")+ }+ if runtime.GOOS == "windows" {+ return fail("This account isn't allowed to use Docker.", "Add your account to docker-users, then sign out and back in and run rexctl doctor.")+ }+ return fail("This account isn't allowed to use Docker.", "Add your account to the docker group with sudo usermod -aG docker $USER. Sign out and back in, then run rexctl doctor.")+ case engine.ClassWindowsContainers:+ return fail("Docker Desktop runs Windows containers, and Fluxer needs Linux containers.", "Switch Docker Desktop to Linux containers, then run rexctl doctor.")+ case engine.ClassPodmanTooOld:+ return fail("This Podman is too old for Fluxer.", fmt.Sprintf("Update Podman to %s or newer, then run rexctl doctor.", engine.MinPodman))+ case engine.ClassEngineChanged:+ var ee *engine.Error+ if errors.As(e.engineErr, &ee) && ee.Replaced {+ return fail("The engine Fluxer uses was replaced, and the new one doesn't have this instance's data.",+ "Start the engine Fluxer was installed on. If it was reset or reinstalled, restore a backup with rexctl restore <file>.")+ }+ return fail("The container engine on this machine isn't the one your instance runs on.", "Start the engine you installed Fluxer with, then run rexctl doctor.")+ }+ if e.podmanSocketOff() {+ return podmanSocketResult(ctx, e)+ }+ switch {+ case !e.installed() && runtime.GOOS == "linux" && name == "Docker":+ return fail("Docker isn't installed or isn't running.", "Run rexctl install and let it install Docker.")+ case name == "Docker" && runtime.GOOS != "linux":+ return fail("Docker Desktop isn't running.", "Open Docker Desktop and wait until its engine is running, then run rexctl doctor.")+ }+ return fail(name+" isn't running.", "Start "+name+", then run rexctl doctor.")+ }+ minimum := engine.MinDocker+ if e.Engine.Kind == engine.Podman {+ minimum = engine.MinPodman+ }+ if e.Engine.TooOld || versionLess(e.Engine.Version, minimum) {+ if e.Engine.Kind == engine.Podman && e.installed() {+ return fail(fmt.Sprintf("Podman %s is too old for Fluxer.", e.Engine.Version),+ fmt.Sprintf("Update Podman to %s or newer, or move to Docker with rexctl backup and then rexctl restore <file> --engine docker.", minimum))+ }+ return fail(fmt.Sprintf("%s %s is too old for Fluxer.", name, e.Engine.Version),+ fmt.Sprintf("Update %s to %s or newer, then run rexctl doctor.", name, minimum))+ }+ return pass(fmt.Sprintf("%s %s is running.", name, e.Engine.Version))+}++func podmanSocketResult(ctx context.Context, e *Env) Result {+ s := host.CheckPodman(ctx, os.Geteuid() != 0, true)+ if !s.Systemd {+ return fail("Podman's API socket isn't running.", "Start podman.socket, then run rexctl doctor.")+ }+ fix := "Run rexctl doctor --fix or rexctl install to start it."+ if e.installed() {+ fix = "Run rexctl doctor --fix to start it."+ }+ r := fixable(fail("Podman's API socket isn't running.", fix))+ if cmds := s.ManualFix(); len(cmds) > 0 {+ r.Manual = "Run " + strings.Join(cmds, " and ") + ", then run rexctl doctor."+ }+ return r+}++func fixEngine(ctx context.Context, e *Env) error {+ if !e.podmanSocketOff() {+ return nil+ }+ if err := host.FixPodman(ctx, host.CheckPodman(ctx, os.Geteuid() != 0, true)); err != nil {+ return err+ }+ e.reconnect(ctx)+ return nil+}diff --git a/fluxer_rexctl/internal/checks/env_file.go b/fluxer_rexctl/internal/checks/env_file.gonew file mode 100644index 000000000..3411a869c--- /dev/null+++ b/fluxer_rexctl/internal/checks/env_file.go@@ -0,0 +1,132 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "errors"+ "fmt"+ "os"+ "path/filepath"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/instance"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/release"+)++func init() {+ Register(Check{ID: "env-file", Phases: Installed, Run: runEnvFile, Fix: fixEnvFile})+ Register(Check{ID: "stack-edits", Phases: Installed, Run: runStackEdits, Fix: fixStackEdits})+}++func (e *Env) drift() (*instance.DriftReport, error) {+ if e.state() == nil {+ return nil, errNoProject+ }+ return instance.Drift(e.Instance)+}++func runEnvFile(ctx context.Context, e *Env) Result {+ if e.state() == nil || e.state().MigratedFromV1() || e.state().Ejected != nil {+ return skip("")+ }+ r, err := e.drift()+ if err != nil {+ r := fail("rexctl can't read the .env file in your instance's folder.", "Check that you can read it, then run rexctl doctor.")+ r.Details = []string{err.Error()}+ return r+ }+ switch {+ case r.Env == nil:+ return pass("rexctl keeps all of your instance's settings.")+ case r.Env.Same:+ return fixable(warn("Your instance has a .env file that only repeats settings rexctl keeps.", "Run rexctl doctor --fix to remove it."))+ }+ fix := r.Env.Fix()+ for _, c := range r.Env.Changes {+ fix += "\n " + c.Command()+ }+ res := fail("Your instance has a .env file, and rexctl doesn't read it.", fix)+ if len(r.Env.Unused) > 0 {+ return res+ }+ return fixable(res)+}++func fixEnvFile(ctx context.Context, e *Env) error {+ r, err := e.drift()+ if err != nil || r.Env == nil || len(r.Env.Unused) > 0 {+ return err+ }+ if r.Env.Same {+ return instance.RemoveEnv(e.Instance)+ }+ for k, v := range r.Env.Settings() {+ e.stage(k, v)+ }+ for k, v := range r.Env.Secrets() {+ e.stageSecret(k, v)+ }+ for k, v := range r.Env.Admin() {+ e.stageAdmin(k, v)+ }+ e.importEnv = true+ return nil+}++func runStackEdits(ctx context.Context, e *Env) Result {+ if e.state() == nil {+ return skip("")+ }+ r, err := e.drift()+ if err == nil && len(r.Changed) == 0 && len(e.keptEdits) > 0 {+ return keptEditsResult(e.keptEdits)+ }+ if err != nil || len(r.Changed) == 0 {+ return skip("")+ }+ var de *instance.DriftError+ if !errors.As(r.Err(), &de) {+ return skip("")+ }+ res := fixable(fail(de.Msg, "Run rexctl doctor --fix to put rexctl's version back and keep yours next to it, or rexctl eject to manage the files yourself."))+ res.Details = r.Changed+ return res+}++func fixStackEdits(ctx context.Context, e *Env) error {+ r, err := e.drift()+ if err != nil {+ return err+ }+ for _, name := range r.Changed {+ kept, err := instance.KeepEdited(e.Instance, name)+ if err != nil {+ return err+ }+ e.keptEdits = append(e.keptEdits, [2]string{name, kept})+ if err := os.Remove(filepath.Join(e.Instance.Dir, filepath.FromSlash(name))); err != nil && !errors.Is(err, os.ErrNotExist) {+ return err+ }+ }+ if _, err := release.RestoreMissing(e.Instance); err != nil {+ return err+ }+ if err := e.Instance.Save(); err != nil {+ return err+ }+ e.Project = nil+ e.prepared = false+ e.prepare(ctx)+ return e.up(ctx)+}++func keptEditsResult(kept [][2]string) Result {+ if len(kept) == 1 {+ return pass(fmt.Sprintf("Put rexctl's %s back. Your edited copy is in %s.", kept[0][0], kept[0][1]))+ }+ r := pass("Put rexctl's versions of your edited files back. Your copies are next to them.")+ for _, k := range kept {+ r.Details = append(r.Details, k[0]+" is in "+k[1])+ }+ return r+}diff --git a/fluxer_rexctl/internal/checks/low_ports.go b/fluxer_rexctl/internal/checks/low_ports.gonew file mode 100644index 000000000..22f540587--- /dev/null+++ b/fluxer_rexctl/internal/checks/low_ports.go@@ -0,0 +1,34 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "fmt"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++func init() {+ Register(Check{ID: "low-ports", Phases: Preinstall | Installed, Run: runLowPorts, Fix: fixLowPorts, SafeFix: true})+}++func runLowPorts(_ context.Context, e *Env) Result {+ if !e.rootless() || e.mode() != modeBundled {+ return skip("")+ }+ if host.LowPortsBlocked(true) {+ proxy := "run rexctl install --behind-proxy"+ if e.installed() {+ proxy = "run rexctl proxy on"+ }+ r := fixable(fail(fmt.Sprintf("%s can't use ports 80 and 443 under this account.", e.engineName()), "Run rexctl doctor --fix to allow them, or "+proxy+" to use your own proxy."))+ r.Manual = "Ask an administrator to add " + host.LowPortsSetting + " to " + host.LowPortsFile + " and run sudo sysctl --system, or " + proxy + " to use your own proxy."+ return r+ }+ return pass(fmt.Sprintf("%s can use ports 80 and 443 under this account.", e.engineName()))+}++func fixLowPorts(ctx context.Context, _ *Env) error {+ return host.AllowLowPorts(ctx)+}diff --git a/fluxer_rexctl/internal/checks/memory.go b/fluxer_rexctl/internal/checks/memory.gonew file mode 100644index 000000000..08b8f341a--- /dev/null+++ b/fluxer_rexctl/internal/checks/memory.go@@ -0,0 +1,28 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "fmt"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++const minMemory = 3584 << 20++func init() {+ Register(Check{ID: "memory", Phases: Preinstall | Installed, Run: runMemory})+}++func runMemory(ctx context.Context, e *Env) Result {+ total, err := host.Memory()+ if err != nil || total == 0 {+ return skip("Couldn't read how much memory this machine has.")+ }+ if total < minMemory {+ return fail(fmt.Sprintf("This machine has %s of memory and Fluxer needs at least 4 GB.", gb(total)),+ "Move Fluxer to a machine with more memory.")+ }+ return pass(fmt.Sprintf("This machine has %s of memory.", gb(total)))+}diff --git a/fluxer_rexctl/internal/checks/podman.go b/fluxer_rexctl/internal/checks/podman.gonew file mode 100644index 000000000..2f324daca--- /dev/null+++ b/fluxer_rexctl/internal/checks/podman.go@@ -0,0 +1,69 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "runtime"+ "strings"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/engine"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+)++func init() {+ Register(Check{ID: "podman-subids", Phases: Preinstall | Installed, Run: runPodmanSubIDs})+ Register(Check{ID: "podman-setup", Phases: Installed, Run: runPodmanSetup, Fix: fixPodmanSetup, SafeFix: true})+}++func (e *Env) podmanSetup(ctx context.Context) (host.PodmanSetup, bool) {+ if e.Engine == nil || e.Engine.Kind != engine.Podman {+ return host.PodmanSetup{}, false+ }+ return host.CheckPodman(ctx, e.Engine.Rootless, false), true+}++func runPodmanSubIDs(ctx context.Context, e *Env) Result {+ if runtime.GOOS != "linux" || !e.podman() || !e.rootless() {+ return skip("")+ }+ if !host.HasSubIDs(ctx) {+ return fail("Your account has no subordinate user IDs, and Podman needs them to unpack Fluxer.", "Add your account to /etc/subuid and /etc/subgid, run podman system migrate, then run rexctl doctor.")+ }+ return pass("Your account has the subordinate user IDs Podman needs.")+}++func runPodmanSetup(ctx context.Context, e *Env) Result {+ s, ok := e.podmanSetup(ctx)+ if !ok {+ return skip("")+ }+ var r Result+ switch {+ case s.SocketMissing && s.Systemd:+ r = fixable(fail("Podman's API socket isn't running.", "Run rexctl doctor --fix to start it."))+ case s.SocketMissing:+ r = fail("Podman's API socket isn't running.", "Start podman.socket, then run rexctl doctor.")+ case s.NoLinger || s.NoSocketStart:+ r = fixable(warn("Fluxer won't start again after this machine restarts.", "Run rexctl doctor --fix to start it with the machine."))+ case s.EventsOn:+ r = fixable(warn("Podman writes every health check to the system log.", "Run rexctl doctor --fix to stop that."))+ default:+ return pass("Podman is set up for Fluxer.")+ }+ if s.Needed() && (s.Systemd || !s.SocketMissing) {+ r.Fixable = true+ }+ if cmds := s.ManualFix(); len(cmds) > 0 {+ r.Manual = "Run " + strings.Join(cmds, " and ") + ", then run rexctl doctor."+ }+ return r+}++func fixPodmanSetup(ctx context.Context, e *Env) error {+ s, ok := e.podmanSetup(ctx)+ if !ok {+ return nil+ }+ return host.FixPodman(ctx, s)+}diff --git a/fluxer_rexctl/internal/checks/ports.go b/fluxer_rexctl/internal/checks/ports.gonew file mode 100644index 000000000..d0419d58b--- /dev/null+++ b/fluxer_rexctl/internal/checks/ports.go@@ -0,0 +1,159 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "fmt"+ "net"+ "slices"+ "strconv"+ "strings"++ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/host"+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"+)++func init() {+ Register(Check{ID: "ports", Phases: Preinstall, Run: runPorts})+}++var containerOwners = map[string]bool{+ "docker-proxy": true,+ "com.docker.backend": true,+ "com.docker.vpnkit": true,+ "vpnkit-bridge": true,+ "rootlessport": true,+ "rootlesskit": true,+ "conmon": true,+ "gvproxy": true,+ "wslrelay": true,+}++func runPorts(ctx context.Context, e *Env) Result {+ wanted := e.wantedPorts()+ var numbers, busy []string+ var first *stack.Port+ firstOwner := ""+ sameOwner := true+ seen := map[int]bool{}+ for _, p := range wanted {+ if seen[p.Number] {+ continue+ }+ used, owner, err := host.PortInUse(p.Proto, p.Number)+ if err != nil {+ return skip(fmt.Sprintf("Couldn't check whether port %d is free.", p.Number))+ }+ seen[p.Number] = true+ numbers = append(numbers, strconv.Itoa(p.Number))+ if !used {+ continue+ }+ busy = append(busy, strconv.Itoa(p.Number))+ if first == nil {+ first, firstOwner = &p, owner+ } else if owner != firstOwner {+ sameOwner = false+ }+ }+ switch {+ case first == nil:+ return pass(fmt.Sprintf("Ports %s are free.", joinAnd(numbers)))+ case len(busy) == 1:+ return e.portBusy(*first, firstOwner)+ }+ msg := fmt.Sprintf("Ports %s are already in use.", joinAnd(busy))+ fix := "Stop the programs that use them, then run rexctl doctor."+ switch {+ case sameOwner && containerOwners[firstOwner]:+ msg = fmt.Sprintf("Ports %s are already in use by containers.", joinAnd(busy))+ fix = "Stop the containers that use them, then run rexctl doctor."+ case sameOwner && firstOwner != "":+ msg = fmt.Sprintf("Ports %s are already in use by %s.", joinAnd(busy), firstOwner)+ fix = fmt.Sprintf("Stop %s, then run rexctl doctor.", firstOwner)+ }+ if e.mode() == modeBundled && !slices.ContainsFunc(busy, func(n string) bool { return n != "80" && n != "443" }) {+ fix = e.portFix(*first)+ }+ return fail(msg, fix)+}++func (e *Env) wantedPorts() []stack.Port {+ var out []stack.Port+ ports := e.ports()+ if e.mode() == modeBundled {+ for _, p := range ports {+ if p.Number == 80 || p.Number == 443 {+ out = append(out, p)+ }+ }+ } else if port := bindPort(e.Bind); port > 0 {+ out = append(out, stack.Port{Number: port, Proto: "tcp"})+ }+ for _, p := range ports {+ if p.Number != 80 && p.Number != 443 {+ out = append(out, p)+ }+ }+ return out+}++func bindPort(bind string) int {+ _, port, err := net.SplitHostPort(bind)+ if err != nil {+ port = strings.TrimPrefix(bind, ":")+ }+ n, err := strconv.Atoi(port)+ if err != nil {+ return 0+ }+ return n+}++func (e *Env) portBusy(p stack.Port, owner string) Result {+ msg := fmt.Sprintf("Port %d is already in use.", p.Number)+ switch {+ case containerOwners[owner]:+ msg = fmt.Sprintf("Port %d is already in use by a container.", p.Number)+ case owner != "":+ msg = fmt.Sprintf("Port %d is already in use by %s.", p.Number, owner)+ }+ if fix := e.portFix(p); fix != "" {+ return fail(msg, fix)+ }+ what := "the program that uses it"+ switch {+ case containerOwners[owner]:+ what = "the container that uses it"+ case owner != "":+ what = owner+ }+ return fail(msg, fmt.Sprintf("Stop %s, then run rexctl doctor.", what))+}++func (e *Env) portFix(p stack.Port) string {+ if e.mode() == modeBundled && (p.Number == 80 || p.Number == 443) {+ return "Run rexctl install --behind-proxy to use your own proxy."+ }+ if e.mode() != modeBundled && p.Number == bindPort(e.Bind) {+ if free := nextFreePort(p.Number + 1); free > 0 {+ host, _, err := net.SplitHostPort(e.Bind)+ if err != nil || host == "" {+ host = "127.0.0.1"+ }+ return fmt.Sprintf("Run rexctl install --behind-proxy --bind %s to use another port.", net.JoinHostPort(host, strconv.Itoa(free)))+ }+ }+ return ""+}++func nextFreePort(from int) int {+ for port := from; port < from+20 && port <= 65535; port++ {+ used, _, err := host.PortInUse("tcp", port)+ if err == nil && !used {+ return port+ }+ }+ return 0+}diff --git a/fluxer_rexctl/internal/checks/windows_containers.go b/fluxer_rexctl/internal/checks/windows_containers.gonew file mode 100644index 000000000..7598b3f5e--- /dev/null+++ b/fluxer_rexctl/internal/checks/windows_containers.go@@ -0,0 +1,27 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++package checks++import (+ "context"+ "runtime"+ "strings"+)++func init() {+ Register(Check{ID: "windows-linux-containers", Phases: Preinstall | Installed, Run: runWindowsContainers})+}++func runWindowsContainers(ctx context.Context, e *Env) Result {+ if e.Engine == nil {+ return skip("")+ }+ os := strings.ToLower(e.Engine.OSType)+ if os != "" && os != "linux" {+ return fail("Docker Desktop is set to Windows containers.", "Switch Docker Desktop to Linux containers, then run rexctl doctor.")+ }+ if runtime.GOOS != "windows" {+ return skip("")+ }+ return pass("Docker Desktop runs Linux containers.")+}