ccl/internal/pkg/config/config.go

package config

import (
	"context"
	"os"

	"gitea.elkins.co/Networking/ccl/internal/pkg/container"
	"gitea.elkins.co/Networking/ccl/internal/pkg/network"
	"github.com/emirpasic/gods/sets/hashset"
	toml "github.com/pelletier/go-toml"
	log "github.com/sirupsen/logrus"
	"golang.org/x/exp/slices"
)

const (
	CONFIG_FILE_DEFAULT = "/etc/ccl.toml"
)

type command string

var (
	ConfigFile = CONFIG_FILE_DEFAULT
	Networks   = []network.Network{}
	Containers = []container.Container{}
)

func Categories() []string {
	categories := []string{"all"}
	gs := hashset.New()
	for _, c := range Containers {
		gs.Add(c.Category)
	}
	for _, c := range gs.Values() {
		categories = append(categories, c.(string))
	}
	slices.Sort(categories)
	return categories
}

func Union(ids []string, catMask []string) (conts []container.Container) {
	if len(ids) == 0 {
		ids = []string{"all"}
	}
	h := hashset.New()
	for _, id := range ids {
		if j := slices.Index(catMask, id); j >= 0 {
			catMask = slices.Delete(catMask, j, j+1)
		}
		for _, c := range Containers {
			if (id == "all" || c.Category == id) && !slices.Contains(catMask, c.Category) {
				h.Add(c.Name)
			}
			if c.Name == id {
				h.Add(c.Name)
			}
		}
	}
	for _, c := range h.Values() {
		name := c.(string)
		match := slices.IndexFunc(Containers, func(c container.Container) bool { return c.Name == name })
		conts = append(conts, Containers[match])
	}
	if len(conts) == 0 {
		log.WithFields(log.Fields{
			"ids": ids,
		}).Warnln("No matching containers. If disabled, try adding -a")
	}
	slices.SortFunc(conts, func(a, b container.Container) bool {
		if a.Category < b.Category {
			return true
		}
		if a.Category > b.Category {
			return false
		}
		return a.Name <= b.Name
	})
	return
}

func Init(conn context.Context) error {
	// A parsing convenience
	type parse struct {
		Networks   []network.Network
		Containers []container.Container
	}

	f, err := os.ReadFile(ConfigFile)
	if err != nil {
		return err
	}
	p := parse{}
	err = toml.Unmarshal(f, &p)
	if err != nil {
		return err
	}
	Containers, Networks = p.Containers, p.Networks
	for i := range p.Containers {
		p.Containers[i].Init(conn, Networks)
	}
	slices.SortFunc(Containers, func(a, b container.Container) bool {
		return a.Name < b.Name
	})
	return nil
}