octoplex/main.go

package main

import (
	"cmp"
	"context"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"os/signal"
	"runtime"
	"runtime/debug"
	"syscall"

	"git.netflux.io/rob/octoplex/internal/client"
	"git.netflux.io/rob/octoplex/internal/config"
	"git.netflux.io/rob/octoplex/internal/domain"
	"git.netflux.io/rob/octoplex/internal/server"
	dockerclient "github.com/docker/docker/client"
	"github.com/urfave/cli/v2"
	"golang.design/x/clipboard"
	"golang.org/x/sync/errgroup"
)

var (
	// version is the version of the application.
	version string
	// commit is the commit hash of the application.
	commit string
	// date is the date of the build.
	date string
)

var errShutdown = errors.New("shutdown")

func main() {
	// when server is running:
	//   server log goes to wherever config defined it
	//   client log does not exist
	// when client is running:
	//   server log does not exist
	//   client log goes to ??? but for now octoplex.log
	// when both are running:
	//   server log goes to wherever config defined it
	//   client logs goes to ??? but for now octoplex.log
	app := &cli.App{
		Name:  "Octoplex",
		Usage: "Octoplex is a live video restreamer for Docker.",
		Commands: []*cli.Command{
			{
				Name:  "client",
				Usage: "Run the client",
				Flags: []cli.Flag{ /* client flags */ },
				Action: func(c *cli.Context) error {
					return runClient(c)
				},
			},
			{
				Name:  "server",
				Usage: "Run the server",
				Flags: []cli.Flag{ /* server flags */ },
				Action: func(c *cli.Context) error {
					return runServer(c, true)
				},
			},
			{
				Name:  "run",
				Usage: "Run server and client together (testing)",
				Flags: []cli.Flag{ /* optional combined flags */ },
				Action: func(c *cli.Context) error {
					return runClientAndServer(c)
				},
			},
		},
	}

	if err := app.Run(os.Args); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
}

func runClient(_ *cli.Context) error {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// TODO: logger from config
	fptr, err := os.OpenFile("octoplex.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		return fmt.Errorf("open log file: %w", err)
	}
	logger := slog.New(slog.NewTextHandler(fptr, nil))

	var clipboardAvailable bool
	if err = clipboard.Init(); err != nil {
		logger.Warn("Clipboard not available", "err", err)
	} else {
		clipboardAvailable = true
	}

	buildInfo, ok := debug.ReadBuildInfo()
	if !ok {
		return fmt.Errorf("read build info: %w", err)
	}

	app := client.New(client.NewParams{
		ClipboardAvailable: clipboardAvailable,
		BuildInfo: domain.BuildInfo{
			GoVersion: buildInfo.GoVersion,
			Version:   version,
			Commit:    commit,
			Date:      date,
		},
		Logger: logger,
	})
	if err := app.Run(ctx); err != nil {
		return fmt.Errorf("run app: %w", err)
	}

	return nil
}

func runServer(_ *cli.Context, stderrAvailable bool) error {
	ctx, cancel := context.WithCancelCause(context.Background())
	defer cancel(nil)

	configService, err := config.NewDefaultService()
	if err != nil {
		return fmt.Errorf("build config service: %w", err)
	}

	cfg, err := configService.ReadOrCreateConfig()
	if err != nil {
		return fmt.Errorf("read or create config: %w", err)
	}

	// TODO: improve logger API
	// Currently it's a bit complicated because we can only use stdout - the
	// preferred destination - if the client is not running. Otherwise we
	// fallback to the legacy configuration but this should be bought more
	// in-line with the client/server split.
	var w io.Writer
	if stderrAvailable {
		w = os.Stdout
	} else if !cfg.LogFile.Enabled {
		w = io.Discard
	} else {
		w, err = os.OpenFile(cfg.LogFile.GetPath(), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
		if err != nil {
			return fmt.Errorf("error opening log file: %w", err)
		}
	}

	var handlerOpts slog.HandlerOptions
	if os.Getenv("OCTO_DEBUG") != "" {
		handlerOpts.Level = slog.LevelDebug
	}
	logger := slog.New(slog.NewTextHandler(w, &handlerOpts))

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		<-ch
		logger.Info("Received interrupt signal, exiting")
		signal.Stop(ch)
		cancel(errShutdown)
	}()

	dockerClient, err := dockerclient.NewClientWithOpts(
		dockerclient.FromEnv,
		dockerclient.WithAPIVersionNegotiation(),
	)
	if err != nil {
		return fmt.Errorf("new docker client: %w", err)
	}

	app := server.New(server.Params{
		ConfigService:  configService,
		DockerClient:   dockerClient,
		ConfigFilePath: configService.Path(),
		Logger:         logger,
	})

	logger.Info(
		"Starting server",
		"version",
		cmp.Or(version, "devel"),
		"commit",
		cmp.Or(commit, "unknown"),
		"date",
		cmp.Or(date, "unknown"),
		"go_version",
		runtime.Version(),
	)

	if err := app.Run(ctx); err != nil {
		if errors.Is(err, context.Canceled) && context.Cause(ctx) == errShutdown {
			return errShutdown
		}
		return err
	}

	return nil
}

func runClientAndServer(c *cli.Context) error {
	g, _ := errgroup.WithContext(c.Context)

	g.Go(func() error {
		return runClient(c)
	})

	g.Go(func() error {
		return runServer(c, false)
	})

	return g.Wait()
}