A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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 }