warkanum
f0827fcdd7
- syncup: podman first, docker only as fallback (podman wins on name clash;
existing docker units found in podman switch to podman)
- syncup: group podman-compose containers into one `kind: stack` unit per
project (project, working_dir, compose_files, compose_bin from labels);
disable existing member units ("part of stack <project>")
- generator: compose mode (podman-compose up/stop, WorkingDirectory) with
pod start/stop fallback when compose binary/dir/files are missing
- reconcile: stacks disabled with "stack not found" when neither compose
files nor pod exist
- root: scan root + rootless users listed in `users:` (podman only)
- non-root: config ~/.config/unitdore/units.yaml, own user units only
- sysuser package: runuser with XDG_RUNTIME_DIR/DBUS env, home/linger lookup
- install: warn when linger is not enabled for user units
- testdata/stack: podman-compose test stack and captured podman ps fixture
- docs: README, generated-units, man page, AGENTS, PLAN
113 lines
3.6 KiB
Go
113 lines
3.6 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
const DefaultConfigPath = "/etc/unitdore/units.yaml"
|
|
|
|
// UserConfigPath returns the config path used when running as a normal user.
|
|
func UserConfigPath(home string) string {
|
|
return filepath.Join(home, ".config", "unitdore", "units.yaml")
|
|
}
|
|
|
|
// Unit kinds.
|
|
const (
|
|
KindContainer = "container"
|
|
KindStack = "stack"
|
|
)
|
|
|
|
// Unit represents a single managed container unit.
|
|
type Unit struct {
|
|
Name string `yaml:"name"`
|
|
Runtime string `yaml:"runtime"` // podman | docker | exec
|
|
User string `yaml:"user,omitempty"` // empty = root/system unit
|
|
Command string `yaml:"command,omitempty"` // override ExecStart
|
|
Order int `yaml:"order"`
|
|
Delay string `yaml:"delay,omitempty"` // e.g. "5s"
|
|
Enabled bool `yaml:"enabled"`
|
|
DisabledReason string `yaml:"disabled_reason,omitempty"`
|
|
Restart bool `yaml:"restart,omitempty"` // enable Restart=on-failure
|
|
RestartSec int `yaml:"restart_sec,omitempty"` // seconds between restarts
|
|
RestartRetries int `yaml:"restart_retries,omitempty"` // max restart attempts (StartLimitBurst)
|
|
|
|
// Stack fields (kind: stack) — one unit for a whole podman-compose project.
|
|
Kind string `yaml:"kind,omitempty"` // container (default) | stack
|
|
Project string `yaml:"project,omitempty"` // compose project name
|
|
WorkingDir string `yaml:"working_dir,omitempty"` // compose project directory
|
|
ComposeFiles []string `yaml:"compose_files,omitempty"` // relative to working_dir unless absolute
|
|
ComposeBin string `yaml:"compose_bin,omitempty"` // path to podman-compose
|
|
}
|
|
|
|
// IsStack reports whether the unit manages a compose stack.
|
|
func (u Unit) IsStack() bool { return u.Kind == KindStack }
|
|
|
|
// Config is the root config structure.
|
|
type Config struct {
|
|
Units []Unit `yaml:"units"`
|
|
Prefix string `yaml:"prefix,omitempty"` // prepended to generated service name, e.g. "prod-"
|
|
Suffix string `yaml:"suffix,omitempty"` // appended to generated service name, e.g. "-svc"
|
|
Users []string `yaml:"users,omitempty"` // rootless users scanned by syncup when run as root
|
|
}
|
|
|
|
// Load reads and parses the config file at path.
|
|
func Load(path string) (*Config, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("reading config: %w", err)
|
|
}
|
|
var cfg Config
|
|
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
|
return nil, fmt.Errorf("parsing config: %w", err)
|
|
}
|
|
return &cfg, nil
|
|
}
|
|
|
|
// LoadOrEmpty loads the config file, or returns an empty config if it doesn't exist.
|
|
func LoadOrEmpty(path string) (*Config, error) {
|
|
_, err := os.Stat(path)
|
|
if os.IsNotExist(err) {
|
|
return &Config{}, nil
|
|
}
|
|
return Load(path)
|
|
}
|
|
|
|
// Save writes the config back to disk, creating parent directories if needed.
|
|
func (c *Config) Save(path string) error {
|
|
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
|
|
return fmt.Errorf("creating config dir: %w", err)
|
|
}
|
|
data, err := yaml.Marshal(c)
|
|
if err != nil {
|
|
return fmt.Errorf("marshalling config: %w", err)
|
|
}
|
|
if err := os.WriteFile(path, data, 0644); err != nil {
|
|
return fmt.Errorf("writing config: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// FindUnit returns a pointer to the unit with the given name, or nil.
|
|
func (c *Config) FindUnit(name string) *Unit {
|
|
for i := range c.Units {
|
|
if c.Units[i].Name == name {
|
|
return &c.Units[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddUnit appends a unit if one with that name doesn't already exist.
|
|
// Returns true if it was added.
|
|
func (c *Config) AddUnit(u Unit) bool {
|
|
if c.FindUnit(u.Name) != nil {
|
|
return false
|
|
}
|
|
c.Units = append(c.Units, u)
|
|
return true
|
|
}
|