Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

9.7 KB
Raw Blame
package core

import (
	"fmt"
	"net/http"
	"os"
	"os/exec"
	"strings"
	"time"
)

func IsRoot() bool {
	return os.Geteuid() == 0
}

func RequireRoot(operation string) error {
	if !IsRoot() {
		return fmt.Errorf("root access required to %s. Please run this installer with sudo", operation)
	}
	return nil
}

func IsDockerInstalled() bool {
	path, err := exec.LookPath("docker")
	installed := err == nil
	GetLogger().Debug("IsDockerInstalled: %v (path=%s, err=%v)", installed, path, err)
	return installed
}

func IsDockerRunning() bool {
	cmd := exec.Command("docker", "info")
	err := cmd.Run()
	running := err == nil
	GetLogger().Debug("IsDockerRunning: %v (err=%v)", running, err)
	return running
}

func StartDockerDaemon() error {
	logger := GetLogger()
	logger.Debug("StartDockerDaemon called, checking root access")
	if err := RequireRoot("start Docker daemon"); err != nil {
		return err
	}

	logger.WriteString("Starting Docker daemon...\n")
	logger.Debug("Running: systemctl start docker")
	cmd := exec.Command("systemctl", "start", "docker")

	if err := cmd.Run(); err != nil {
		logger.Debug("systemctl start docker failed: %v", err)
		return fmt.Errorf("failed to start docker daemon: %w", err)
	}

	// Wait up to a minute for daemon to be ready
	logger.WriteString("Waiting for Docker daemon to start...\n")
	for i := 0; i < 60; i++ {
		logger.Debug("Waiting for docker daemon, attempt %d/60", i+1)
		if IsDockerRunning() {
			logger.WriteString("Docker daemon started\n")
			return nil
		}
		time.Sleep(1 * time.Second)
	}

	return fmt.Errorf("docker daemon started but not responding. Maybe you need to run this with sudo to access the Docker daemon?")
}

func InstallDocker() error {
	logger := GetLogger()
	logger.Debug("InstallDocker called")
	if err := RequireRoot("install Docker"); err != nil {
		return err
	}

	logger.WriteString("Installing Docker...\n")

	// apt-key was removed in Ubuntu 25.10; use the modern signed-by keyring approach instead.
	// See https://docs.docker.com/engine/install/ubuntu/ and issue #54406.
	commands := [][]string{
		{"apt", "update"},
		{"apt", "install", "-y", "apt-transport-https", "ca-certificates", "curl", "gnupg"},
		{"install", "-d", "-m", "0755", "/etc/apt/keyrings"},
		{"sh", "-c", "curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor --yes -o /etc/apt/keyrings/docker.gpg"},
		{"chmod", "a+r", "/etc/apt/keyrings/docker.gpg"},
		{"sh", "-c", "echo 'deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu jammy stable' > /etc/apt/sources.list.d/docker.list"},
		{"apt", "update"},
		{"apt", "install", "-y", "docker-ce"},
	}

	for i, cmdArgs := range commands {
		logger.Debug("InstallDocker step %d/%d: %v", i+1, len(commands), cmdArgs)
		cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
		if err := cmd.Run(); err != nil {
			logger.Debug("InstallDocker step %d failed: %v", i+1, err)
			return fmt.Errorf("failed to run %v: %w", cmdArgs, err)
		}
	}

	logger.Debug("Docker installed, adding user to docker group")
	if err := AddCurrentUserToDockerGroup(); err != nil {
		logger.Debug("AddCurrentUserToDockerGroup failed: %v", err)
		logger.WriteString("Warning: could not add user to docker group\n")
	}

	return nil
}

func InstallDockerCompose() error {
	if err := RequireRoot("install Docker Compose"); err != nil {
		return err
	}

	cmd := exec.Command("sh", "-c",
		`curl -L "https://github.com/docker/compose/releases/download/v2.33.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && chmod +x /usr/local/bin/docker-compose`)
	return cmd.Run()
}

func GetDockerComposeCommand() (string, []string) {
	logger := GetLogger()

	if _, err := exec.LookPath("docker-compose"); err == nil {
		logger.Debug("Using docker-compose binary")
		return "docker-compose", nil
	}

	logger.Debug("Using docker compose plugin")
	return "docker", []string{"compose"}
}

func DockerComposeStop() error {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "-f", "docker-compose.yml", "stop")

	_, err := RunCommand(cmd, fullArgs...)
	return err
}

func DockerComposeDown() error {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "-f", "docker-compose.yml", "down")
	_, err := RunCommand(cmd, fullArgs...)
	return err
}

func DockerComposePull() error {
	GetLogger().WriteString("Pulling Docker images (this may take a while)...\n")

	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "-f", "docker-compose.yml", "pull")
	_, err := RunCommand(cmd, fullArgs...)
	if err == nil {
		GetLogger().WriteString("All images pulled successfully\n")
	}
	return err
}

func DockerComposeUpWithRetry(maxAttempts int) error {
	logger := GetLogger()
	logger.WriteString("Starting PostHog containers...\n")

	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "-f", "docker-compose.yml", "up", "-d", "--no-build", "--pull", "always")

	var lastErr error
	for attempt := 1; attempt <= maxAttempts; attempt++ {
		logger.WriteString(fmt.Sprintf("Starting stack (attempt %d/%d)...\n", attempt, maxAttempts))
		_, err := RunCommand(cmd, fullArgs...)
		if err == nil {
			logger.WriteString("Stack started successfully\n")
			return nil
		}
		lastErr = err
		if attempt < maxAttempts {
			logger.WriteString("Failed to start stack, waiting 30s before retry...\n")
			time.Sleep(30 * time.Second)
		}
	}

	logger.WriteString(fmt.Sprintf("Failed to start stack after %d attempts\n", maxAttempts))
	return lastErr
}

func DockerComposeUpDB() error {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "-f", "docker-compose.yml", "up", "-d", "db")
	_, err := RunCommand(cmd, fullArgs...)
	return err
}

func RunAsyncMigrationsCheck() error {
	GetLogger().WriteString("Checking async migrations...\n")

	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "run", "asyncmigrationscheck")
	_, err := RunCommand(cmd, fullArgs...)
	return err
}

func WaitForHealth(timeout time.Duration) error {
	logger := GetLogger()
	logger.WriteString("Waiting for PostHog to start...\n")
	logger.Debug("WaitForHealth timeout=%v", timeout)

	deadline := time.Now().Add(timeout)
	client := &http.Client{Timeout: 5 * time.Second}
	attempt := 0

	for time.Now().Before(deadline) {
		attempt++
		resp, err := client.Get("http://localhost/_health")
		if err == nil {
			_ = resp.Body.Close()
			if resp.StatusCode == 200 {
				logger.WriteString("PostHog is healthy!\n")
				logger.Debug("Health check passed after %d attempts", attempt)
				return nil
			}
			logger.WriteString(fmt.Sprintf("Health check %d: status %d\n", attempt, resp.StatusCode))
			logger.Debug("Health check %d: HTTP %d", attempt, resp.StatusCode)
		} else {
			logger.WriteString(fmt.Sprintf("Health check %d: waiting...\n", attempt))
			logger.Debug("Health check %d error: %v", attempt, err)
		}

		if (attempt % 5) == 0 {
			logger.WriteString("Waiting for PostHog to be healthy, this might take several minutes...\n")
		}

		time.Sleep(5 * time.Second)
	}

	logger.Debug("WaitForHealth timed out after %d attempts", attempt)
	return fmt.Errorf("timeout waiting for PostHog to be healthy")
}

func CheckDockerVolumes() (bool, bool) {
	out, err := RunCommand("docker", "volume", "ls")
	if err != nil {
		return false, false
	}

	hasPostgres := strings.Contains(out, "postgres-data")
	hasClickhouse := strings.Contains(out, "clickhouse-data")

	return hasPostgres, hasClickhouse
}

// Compose prefixes a volume with the project name, so the MinIO volume is
// `<project>_objectstorage`. The SeaweedFS replacement uses `objectstorage-data`, which
// must not match, hence the exact name and suffix test rather than a substring.
func LegacyObjectStorageVolume() string {
	out, err := RunCommand("docker", "volume", "ls", "-q")
	if err != nil {
		return ""
	}
	return findLegacyObjectStorageVolume(strings.Split(out, "\n"))
}

func findLegacyObjectStorageVolume(names []string) string {
	for _, name := range names {
		name = strings.TrimSpace(name)
		if name == "objectstorage" || strings.HasSuffix(name, "_objectstorage") {
			return name
		}
	}
	return ""
}

func AddUserToDockerGroup(user string) error {
	if err := RequireRoot("add user to docker group"); err != nil {
		return err
	}
	return exec.Command("usermod", "-aG", "docker", user).Run()
}

func AddCurrentUserToDockerGroup() error {
	logger := GetLogger()

	sudoUser := os.Getenv("SUDO_USER")
	user := os.Getenv("USER")
	logger.Debug("AddCurrentUserToDockerGroup: SUDO_USER=%q, USER=%q", sudoUser, user)

	targetUser := sudoUser
	if targetUser == "" {
		targetUser = user
	}
	if targetUser == "" || targetUser == "root" {
		logger.Debug("No valid user found to add to docker group")
		return fmt.Errorf("cannot find user to add to docker group")
	}
	logger.Debug("Adding user %q to docker group", targetUser)
	return AddUserToDockerGroup(targetUser)
}

func DockerVolumeRemove(name string) error {
	return exec.Command("docker", "volume", "rm", name).Run()
}

func DockerExec(container string, command ...string) (string, error) {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "exec", "-T", container)
	fullArgs = append(fullArgs, command...)
	return RunCommand(cmd, fullArgs...)
}

func BackupPostgres(outputFile string) error {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "exec", "-T", "db", "pg_dumpall", "--clean", "-U", "posthog")

	shellCmd := fmt.Sprintf("%s %s | gzip > %s", cmd, joinArgs(fullArgs), outputFile)
	return exec.Command("sh", "-c", shellCmd).Run()
}

func RestorePostgres(inputFile string) error {
	cmd, args := GetDockerComposeCommand()
	fullArgs := append(args, "exec", "-T", "db", "psql", "-U", "posthog")

	shellCmd := fmt.Sprintf("gunzip -c %s | %s %s", inputFile, cmd, joinArgs(fullArgs))
	return exec.Command("sh", "-c", shellCmd).Run()
}

func joinArgs(args []string) string {
	result := ""
	for i, arg := range args {
		if i > 0 {
			result += " "
		}
		result += arg
	}
	return result
}