Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.")
+}