Skip to content

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

TypeScript fluxerfluxerapp

feat(rexctl): set up docker, podman and firewall ports

Hampus27daff38f705
diff --git a/fluxer_rexctl/internal/host/docker.go b/fluxer_rexctl/internal/host/docker.go
new file mode 100644
index 000000000..857de15fd
--- /dev/null
+++ b/fluxer_rexctl/internal/host/docker.go
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package host
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "os/user"
+ "path/filepath"
+ "slices"
+ "time"
+)
+
+const DockerInstallScript = "https://get.docker.com"
+
+var ErrRelogin = errors.New("host: log out and back in to use docker")
+
+var dockerDistros = []string{"ubuntu", "debian", "raspbian", "fedora", "centos", "rhel"}
+
+func CanInstallDocker(info *Info) bool {
+ if info == nil || info.OS != "linux" || info.WSL {
+ return false
+ }
+ if info.Arch != "amd64" && info.Arch != "arm64" {
+ return false
+ }
+ if !info.Root && !has("sudo") {
+ return false
+ }
+ return slices.Contains(dockerDistros, info.Distro)
+}
+
+func InstallDocker(ctx context.Context, info *Info, log func(string)) error {
+ if !CanInstallDocker(info) {
+ return errors.ErrUnsupported
+ }
+ script, err := downloadScript(ctx)
+ if err != nil {
+ return err
+ }
+ defer os.RemoveAll(filepath.Dir(script))
+ if err := stream(ctx, log, "sh", script); err != nil {
+ return err
+ }
+ if has("systemctl") {
+ if err := stream(ctx, log, "systemctl", "enable", "--now", "docker"); err != nil {
+ return err
+ }
+ }
+ if info.Root {
+ return nil
+ }
+ name := os.Getenv("USER")
+ if u, err := user.Current(); err == nil && u.Username != "" {
+ name = u.Username
+ }
+ if name == "" {
+ return ErrRelogin
+ }
+ if err := stream(ctx, log, "usermod", "-aG", "docker", name); err != nil {
+ return err
+ }
+ return ErrRelogin
+}
+
+func downloadScript(ctx context.Context) (string, error) {
+ ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+ defer cancel()
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, DockerInstallScript, nil)
+ if err != nil {
+ return "", err
+ }
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ return "", fmt.Errorf("%s returned %d", DockerInstallScript, resp.StatusCode)
+ }
+ dir, err := os.MkdirTemp("", "rexctl-docker-")
+ if err != nil {
+ return "", err
+ }
+ path := filepath.Join(dir, "get-docker.sh")
+ f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o700)
+ if err != nil {
+ os.RemoveAll(dir)
+ return "", err
+ }
+ n, err := io.Copy(f, io.LimitReader(resp.Body, 4<<20))
+ if cerr := f.Close(); err == nil {
+ err = cerr
+ }
+ if err == nil && n == 0 {
+ err = fmt.Errorf("%s returned an empty script", DockerInstallScript)
+ }
+ if err != nil {
+ os.RemoveAll(dir)
+ return "", err
+ }
+ return path, nil
+}
diff --git a/fluxer_rexctl/internal/host/firewall.go b/fluxer_rexctl/internal/host/firewall.go
new file mode 100644
index 000000000..7b0c794af
--- /dev/null
+++ b/fluxer_rexctl/internal/host/firewall.go
@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package host
+
+import (
+ "context"
+ "fmt"
+ "runtime"
+ "strconv"
+ "strings"
+)
+
+type Firewall string
+
+const (
+ FirewallNone Firewall = ""
+ FirewallUFW Firewall = "ufw"
+ FirewallFirewalld Firewall = "firewalld"
+)
+
+type Port struct {
+ Number int
+ Proto string
+}
+
+func (p Port) String() string { return fmt.Sprintf("%d/%s", p.Number, p.Proto) }
+
+type portRule struct {
+ from, to int
+ proto string
+}
+
+func (r portRule) allows(p Port) bool {
+ return p.Number >= r.from && p.Number <= r.to && (r.proto == "" || r.proto == p.Proto)
+}
+
+func DetectFirewall(ctx context.Context) (Firewall, error) {
+ if runtime.GOOS != "linux" {
+ return FirewallNone, nil
+ }
+ if has("ufw") {
+ out, err := output(ctx, true, "ufw", "status")
+ if err == nil && strings.Contains(strings.ToLower(string(out)), "status: active") {
+ return FirewallUFW, nil
+ }
+ }
+ if has("firewall-cmd") {
+ out, err := output(ctx, true, "firewall-cmd", "--state")
+ if err == nil && strings.TrimSpace(string(out)) == "running" {
+ return FirewallFirewalld, nil
+ }
+ }
+ return FirewallNone, nil
+}
+
+func ClosedPorts(ctx context.Context, fw Firewall, ports []Port) ([]Port, error) {
+ var rules []portRule
+ switch fw {
+ case FirewallNone:
+ return nil, nil
+ case FirewallUFW:
+ out, err := output(ctx, true, "ufw", "status", "verbose")
+ if err != nil {
+ return nil, err
+ }
+ allowAll, r := parseUFW(string(out))
+ if allowAll {
+ return nil, nil
+ }
+ rules = r
+ case FirewallFirewalld:
+ portsOut, err := output(ctx, true, "firewall-cmd", "--list-ports")
+ if err != nil {
+ return nil, err
+ }
+ servicesOut, err := output(ctx, true, "firewall-cmd", "--list-services")
+ if err != nil {
+ return nil, err
+ }
+ rules = parseFirewalld(string(portsOut), string(servicesOut))
+ default:
+ return nil, fmt.Errorf("host: unknown firewall %q", fw)
+ }
+ var closed []Port
+ for _, p := range ports {
+ open := false
+ for _, r := range rules {
+ if r.allows(p) {
+ open = true
+ break
+ }
+ }
+ if !open {
+ closed = append(closed, p)
+ }
+ }
+ return closed, nil
+}
+
+func OpenPorts(ctx context.Context, fw Firewall, ports []Port) error {
+ switch fw {
+ case FirewallNone:
+ return nil
+ case FirewallUFW:
+ for _, p := range ports {
+ if _, err := output(ctx, false, "ufw", "allow", p.String()); err != nil {
+ return err
+ }
+ }
+ return nil
+ case FirewallFirewalld:
+ for _, p := range ports {
+ if _, err := output(ctx, false, "firewall-cmd", "--permanent", "--add-port="+p.String()); err != nil {
+ return err
+ }
+ }
+ _, err := output(ctx, false, "firewall-cmd", "--reload")
+ return err
+ }
+ return fmt.Errorf("host: unknown firewall %q", fw)
+}
+
+func ClosePorts(ctx context.Context, fw Firewall, ports []Port) error {
+ switch fw {
+ case FirewallNone:
+ return nil
+ case FirewallUFW:
+ for _, p := range ports {
+ if _, err := output(ctx, false, "ufw", "delete", "allow", p.String()); err != nil {
+ return err
+ }
+ }
+ return nil
+ case FirewallFirewalld:
+ for _, p := range ports {
+ if _, err := output(ctx, false, "firewall-cmd", "--permanent", "--remove-port="+p.String()); err != nil {
+ return err
+ }
+ }
+ _, err := output(ctx, false, "firewall-cmd", "--reload")
+ return err
+ }
+ return fmt.Errorf("host: unknown firewall %q", fw)
+}
+
+func parseUFW(out string) (bool, []portRule) {
+ var rules []portRule
+ for _, line := range strings.Split(out, "\n") {
+ line = strings.TrimSpace(line)
+ lower := strings.ToLower(line)
+ if strings.HasPrefix(lower, "default:") {
+ if strings.Contains(lower, "allow (incoming)") {
+ return true, nil
+ }
+ continue
+ }
+ fields := strings.Fields(line)
+ if len(fields) < 3 {
+ continue
+ }
+ idx := -1
+ for i, f := range fields {
+ if f == "ALLOW" {
+ idx = i
+ break
+ }
+ }
+ if idx < 1 || (idx+1 < len(fields) && fields[idx+1] == "OUT") {
+ continue
+ }
+ from := strings.Join(fields[idx+1:], " ")
+ if !strings.Contains(from, "Anywhere") {
+ continue
+ }
+ rules = append(rules, parseSpec(fields[0], ":")...)
+ }
+ return false, rules
+}
+
+func parseFirewalld(ports, services string) []portRule {
+ var rules []portRule
+ for _, f := range strings.Fields(ports) {
+ rules = append(rules, parseSpec(f, "-")...)
+ }
+ known := map[string][]portRule{
+ "http": {{80, 80, "tcp"}},
+ "https": {{443, 443, "tcp"}},
+ "http3": {{443, 443, "udp"}},
+ }
+ for _, s := range strings.Fields(services) {
+ rules = append(rules, known[s]...)
+ }
+ return rules
+}
+
+func parseSpec(spec, rangeSep string) []portRule {
+ numbers, proto, _ := strings.Cut(spec, "/")
+ var rules []portRule
+ for _, part := range strings.Split(numbers, ",") {
+ lo, hi, isRange := strings.Cut(part, rangeSep)
+ from, err := strconv.Atoi(lo)
+ if err != nil {
+ continue
+ }
+ to := from
+ if isRange {
+ if to, err = strconv.Atoi(hi); err != nil {
+ continue
+ }
+ }
+ rules = append(rules, portRule{from: from, to: to, proto: proto})
+ }
+ return rules
+}
diff --git a/fluxer_rexctl/internal/host/podman.go b/fluxer_rexctl/internal/host/podman.go
new file mode 100644
index 000000000..9233d16c6
--- /dev/null
+++ b/fluxer_rexctl/internal/host/podman.go
@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package host
+
+import (
+ "bytes"
+ "context"
+ "net"
+ "net/http"
+ "os"
+ "os/exec"
+ "os/user"
+ "path/filepath"
+ "runtime"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/fluxerapp/fluxer/fluxer_rexctl/internal/envfile"
+)
+
+const healthcheckEventsFile = "fluxer-healthcheck-events.conf"
+
+type PodmanSetup struct {
+ Rootless bool
+ Systemd bool
+ SocketMissing bool
+ NoLinger bool
+ EventsOn bool
+ NoSocketStart bool
+}
+
+func (s PodmanSetup) Needed() bool {
+ return s.SocketMissing || s.NoSocketStart || s.NoLinger || s.EventsOn
+}
+
+func (s PodmanSetup) ManualFix() []string {
+ if !s.Systemd {
+ return nil
+ }
+ sys := "sudo systemctl"
+ if s.Rootless {
+ sys = "systemctl --user"
+ }
+ var cmds []string
+ if s.SocketMissing || s.NoSocketStart {
+ cmds = append(cmds, sys+" enable --now podman.socket")
+ }
+ if s.NoLinger {
+ if u, err := user.Current(); err == nil {
+ cmds = append(cmds, "sudo loginctl enable-linger "+u.Username)
+ }
+ }
+ return cmds
+}
+
+func CheckPodman(ctx context.Context, rootless, socketMissing bool) PodmanSetup {
+ s := PodmanSetup{Rootless: rootless, SocketMissing: socketMissing}
+ if runtime.GOOS != "linux" {
+ s.SocketMissing = false
+ return s
+ }
+ _, err := os.Stat("/run/systemd/system")
+ s.Systemd = err == nil && has("systemctl")
+ if s.Systemd {
+ out, _ := systemctl(ctx, rootless, "is-enabled", "podman.socket").Output()
+ s.NoSocketStart = strings.TrimSpace(string(out)) != "enabled"
+ if rootless {
+ s.NoLinger = !lingering(ctx)
+ }
+ }
+ s.EventsOn = !healthcheckEventsSet(rootless)
+ return s
+}
+
+func lingering(ctx context.Context) bool {
+ if !has("loginctl") {
+ return true
+ }
+ u, err := user.Current()
+ if err != nil {
+ return true
+ }
+ out, _ := exec.CommandContext(ctx, "loginctl", "show-user", u.Username, "--property=Linger", "--value").Output()
+ return strings.TrimSpace(string(out)) == "yes"
+}
+
+func enableLinger(ctx context.Context) error {
+ u, err := user.Current()
+ if err != nil {
+ return nil
+ }
+ if out, err := exec.CommandContext(ctx, "loginctl", "enable-linger", u.Username).CombinedOutput(); err != nil {
+ return &CommandError{Command: "loginctl enable-linger", Output: string(out), Err: err}
+ }
+ return nil
+}
+
+func HasSubIDs(ctx context.Context) bool {
+ u, err := user.Current()
+ if err != nil {
+ return true
+ }
+ if has("getsubids") {
+ return exec.CommandContext(ctx, "getsubids", u.Username).Run() == nil && exec.CommandContext(ctx, "getsubids", "-g", u.Username).Run() == nil
+ }
+ return subIDFileHas("/etc/subuid", u) && subIDFileHas("/etc/subgid", u)
+}
+
+func subIDFileHas(path string, u *user.User) bool {
+ data, err := os.ReadFile(path)
+ if err != nil {
+ return false
+ }
+ for _, line := range strings.Split(string(data), "\n") {
+ name, _, _ := strings.Cut(strings.TrimSpace(line), ":")
+ if name != "" && (name == u.Username || name == u.Uid) {
+ return true
+ }
+ }
+ return false
+}
+
+func systemctl(ctx context.Context, rootless bool, args ...string) *exec.Cmd {
+ if rootless {
+ return exec.CommandContext(ctx, "systemctl", append([]string{"--user"}, args...)...)
+ }
+ bin, argv, err := privileged("systemctl", args...)
+ if err != nil {
+ return exec.CommandContext(ctx, "systemctl", args...)
+ }
+ return exec.CommandContext(ctx, bin, argv...)
+}
+
+func containersConfDirs(rootless bool) []string {
+ var dirs []string
+ if rootless {
+ if home, err := os.UserHomeDir(); err == nil {
+ dirs = append(dirs, filepath.Join(home, ".config", "containers"))
+ }
+ }
+ return append(dirs, "/etc/containers", "/usr/share/containers")
+}
+
+func healthcheckEventsSet(rootless bool) bool {
+ for _, d := range containersConfDirs(rootless) {
+ files, _ := filepath.Glob(filepath.Join(d, "containers.conf.d", "*.conf"))
+ files = append(files, filepath.Join(d, "containers.conf"))
+ for _, f := range files {
+ data, err := os.ReadFile(f)
+ if err != nil {
+ continue
+ }
+ for _, line := range bytes.Split(data, []byte("\n")) {
+ if bytes.HasPrefix(bytes.TrimSpace(line), []byte("healthcheck_events")) {
+ return true
+ }
+ }
+ }
+ }
+ return false
+}
+
+func FixPodman(ctx context.Context, s PodmanSetup) error {
+ if (s.SocketMissing || s.NoSocketStart) && s.Systemd {
+ if out, err := systemctl(ctx, s.Rootless, "enable", "--now", "podman.socket").CombinedOutput(); err != nil {
+ return &CommandError{Command: "systemctl enable --now podman.socket", Output: string(out), Err: err}
+ }
+ waitPodmanSocket(ctx, s.Rootless)
+ }
+ if s.NoLinger {
+ if err := enableLinger(ctx); err != nil {
+ return err
+ }
+ }
+ if s.EventsOn {
+ dir := filepath.Join(containersConfDirs(s.Rootless)[0], "containers.conf.d")
+ if err := os.MkdirAll(dir, 0o755); err != nil {
+ return err
+ }
+ if err := envfile.WriteFileAtomic(filepath.Join(dir, healthcheckEventsFile), []byte("[engine]\nhealthcheck_events = false\n"), false); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func podmanSocketPath(rootless bool) string {
+ if !rootless {
+ return "/run/podman/podman.sock"
+ }
+ if dir := os.Getenv("XDG_RUNTIME_DIR"); dir != "" {
+ return filepath.Join(dir, "podman", "podman.sock")
+ }
+ return filepath.Join("/run/user", strconv.Itoa(os.Getuid()), "podman", "podman.sock")
+}
+
+func waitPodmanSocket(ctx context.Context, rootless bool) {
+ path := podmanSocketPath(rootless)
+ hc := &http.Client{Transport: &http.Transport{DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+ var d net.Dialer
+ return d.DialContext(ctx, "unix", path)
+ }}}
+ defer hc.CloseIdleConnections()
+ ctx, cancel := context.WithTimeout(ctx, 90*time.Second)
+ defer cancel()
+ for {
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://d/_ping", nil)
+ if err != nil {
+ return
+ }
+ if res, err := hc.Do(req); err == nil {
+ res.Body.Close()
+ if res.StatusCode == http.StatusOK {
+ return
+ }
+ }
+ select {
+ case <-ctx.Done():
+ return
+ case <-time.After(time.Second):
+ }
+ }
+}
+
+type CommandError struct {
+ Command string
+ Output string
+ Err error
+}
+
+func (e *CommandError) Error() string {
+ out := strings.TrimSpace(e.Output)
+ if out == "" {
+ return e.Command + ": " + e.Err.Error()
+ }
+ return e.Command + ": " + out
+}
+
+func (e *CommandError) Unwrap() error { return e.Err }