uopi/cmd/uopi/main.go

package main

import (
	"context"
	"embed"
	"flag"
	"fmt"
	"io/fs"
	"log/slog"
	"os"
	"os/signal"
	"syscall"

	"github.com/uopi/uopi/internal/access"
	"github.com/uopi/uopi/internal/broker"
	"github.com/uopi/uopi/internal/config"
	"github.com/uopi/uopi/internal/controllogic"
	"github.com/uopi/uopi/internal/datasource/epics"
	"github.com/uopi/uopi/internal/datasource/pva"
	"github.com/uopi/uopi/internal/datasource/stub"
	"github.com/uopi/uopi/internal/datasource/synthetic"
	"github.com/uopi/uopi/internal/panelacl"
	"github.com/uopi/uopi/internal/server"
	"github.com/uopi/uopi/internal/storage"
	"github.com/uopi/uopi/web"
)

// The web package's embed.go embeds web/dist at build time.
// This blank import ensures the compiler includes the package.
var _ embed.FS

func main() {
	configPath := flag.String("config", "", "path to TOML config file (optional)")
	flag.Parse()

	log := slog.New(slog.NewTextHandler(os.Stdout, nil))

	cfg, err := config.Load(*configPath)
	if err != nil {
		log.Error("failed to load config", "err", err)
		os.Exit(1)
	}

	if err := os.MkdirAll(cfg.Server.StorageDir, 0o755); err != nil {
		log.Error("failed to create storage dir", "dir", cfg.Server.StorageDir, "err", err)
		os.Exit(1)
	}

	store, err := storage.New(cfg.Server.StorageDir)
	if err != nil {
		log.Error("failed to open interface store", "err", err)
		os.Exit(1)
	}

	aclStore, err := panelacl.New(cfg.Server.StorageDir)
	if err != nil {
		log.Error("failed to open panel ACL store", "err", err)
		os.Exit(1)
	}

	webFS, err := fs.Sub(web.FS, "dist")
	if err != nil {
		log.Error("failed to sub web dist", "err", err)
		os.Exit(1)
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	brk := broker.New(ctx, log, broker.WithMaxUpdateRate(cfg.Server.MaxUpdateRateHz))

	// Stub data source: built-in simulated signals (sine, ramp, noise, setpoint).
	// Enabled by default; disable via [datasource.stub] enabled = false in config.
	if cfg.Datasource.Stub.Enabled {
		stubDS := stub.New()
		if err := stubDS.Connect(ctx); err != nil {
			log.Error("stub connect", "err", err)
			os.Exit(1)
		}
		brk.Register(stubDS)
	}

	// Synthetic data source: computes derived signals from upstream sources via
	// configurable DSP pipelines defined in synthetic.json inside the storage dir.
	var synthDS *synthetic.Synthetic
	if cfg.Datasource.Synthetic.Enabled {
		synthDS = synthetic.New(cfg.Server.StorageDir, brk, log)
		if err := synthDS.Connect(ctx); err != nil {
			log.Warn("synthetic connect failed — continuing without synthetic signals", "err", err)
			synthDS = nil
		} else {
			brk.Register(synthDS)
		}
	}

	// EPICS Channel Access data source.
	// The pure-Go implementation is used by default (no CGo required).
	// Build with -tags epics to use the CGo-based libca implementation instead.
	if cfg.Datasource.EPICS.Enabled && epics.Available() {
		ds := epics.New(
			cfg.Datasource.EPICS.CAAddrList,
			cfg.Datasource.EPICS.ArchiveURL,
			cfg.Datasource.EPICS.ChannelFinderURL,
			cfg.Datasource.EPICS.AutoSyncFilter,
			cfg.Datasource.EPICS.AutoSyncFromArchiver,
			cfg.Datasource.EPICS.PVNames,
		)
		if err := ds.Connect(ctx); err != nil {
			log.Error("epics connect", "err", err)
		} else {
			brk.Register(ds)
		}
	}

	// PV Access data source.
	if cfg.Datasource.PVA.Enabled {
		pvaDS := pva.New(cfg.Datasource.PVA.AddrList)
		if err := pvaDS.Connect(ctx); err != nil {
			log.Error("pva connect", "err", err)
		} else {
			brk.Register(pvaDS)
		}
	}

	// Build the global access policy from config: every user is trusted with
	// full write access unless downgraded by the blacklist; groups are named
	// sets of users referenced by per-panel sharing.
	blacklist := make(map[string]string, len(cfg.Server.Blacklist))
	for _, e := range cfg.Server.Blacklist {
		blacklist[e.User] = e.Level
	}
	groups := make(map[string][]string, len(cfg.Groups))
	for _, g := range cfg.Groups {
		groups[g.Name] = g.Members
	}
	policy := access.New(cfg.Server.DefaultUser, blacklist, groups, cfg.Server.LogicEditors)

	// Server-side control logic: flow graphs that run continuously under the root
	// context, independent of any panel. The store is loaded from disk and the
	// engine starts all enabled graphs.
	ctrlStore, err := controllogic.NewStore(cfg.Server.StorageDir)
	if err != nil {
		log.Error("failed to open control logic store", "err", err)
		os.Exit(1)
	}
	ctrlEngine := controllogic.NewEngine(ctx, brk, ctrlStore, log)
	ctrlEngine.Reload()

	srv := server.New(cfg.Server.Listen, webFS, brk, synthDS, store, policy, aclStore, ctrlStore, ctrlEngine, cfg.Datasource.EPICS.ChannelFinderURL, cfg.Datasource.EPICS.ArchiveURL, cfg.Server.TrustedUserHeader, log)

	if err := srv.Start(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "server error: %v\n", err)
		os.Exit(1)
	}
}