0
0
package table
import (
"cmp"
"errors"
"fmt"
"regexp"
"slices"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
)
type Kind string
const (
KindStore Kind = "store"
KindKine Kind = "kine"
KindFront Kind = "front"
KindSlot Kind = "slot"
KindCore Kind = "core"
)
const (
RoleGateway = "gateway"
RoleBidder = "bidder"
RoleRequester = "requester"
StoreSqlite = "kine-sqlite"
StorePostgres = "kine-postgres"
GatewayKey = "gw"
GatewayCore = "computer-gateway" + hostsvc.ServiceSuffix
BidderCore = "computer-bidder@"
RequesterCore = "computer-requester@"
RolePostgres = "pg"
RoleFront = "front"
RoleCore = "core"
SlotA = "a"
SlotB = "b"
)
var (
keyRE = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]{0,22}[a-z0-9])?$`)
slotRE = regexp.MustCompile(`^[a-z]$`)
)
type App struct {
Role string
Key string
Handle string
Name string
Store string
Slots []string
DevCore bool
Prefix string
}
type Entry struct {
Kind Kind
Role string
Unit string
Slot string
After []string
Wants []string
}
type Names struct {
Prefix string
Key string
}
func Gateway() App {
return App{Role: RoleGateway, Key: GatewayKey, Store: StorePostgres, Slots: []string{SlotA, SlotB}}
}
func Bidder(handle, hid string) App {
return App{Role: RoleBidder, Key: hid, Handle: handle, Store: StoreSqlite, Slots: []string{SlotA}}
}
func Requester(name, key string) App {
return App{Role: RoleRequester, Key: key, Name: name, Store: StoreSqlite, Slots: []string{SlotA}}
}
func (a App) SingleSlot() bool { return a.Role == RoleBidder || a.Role == RoleRequester }
func Dev(key, store string) App {
slots := []string{SlotA}
if store == StorePostgres {
slots = []string{SlotA, SlotB}
}
return App{Role: RoleGateway, Key: key, Store: store, Slots: slots, DevCore: true}
}
func DevNames(key string) Names { return Names{Prefix: hostsvc.NamePrefix, Key: key} }
func (a App) Names() Names {
p := a.Prefix
p = cmp.Or(p, hostsvc.NamePrefix)
return Names{Prefix: p, Key: a.Key}
}
func (n Names) base() string { return n.Prefix + "kcp-" + n.Key }
func (n Names) Store() string { return n.base() + "-pg" + hostsvc.ServiceSuffix }
func (n Names) Kine(slot string) string { return n.base() + "-kine@" + slot + hostsvc.ServiceSuffix }
func (n Names) Front() string { return n.base() + "-front" + hostsvc.ServiceSuffix }
func (n Names) Slot(slot string) string { return n.base() + "@" + slot + hostsvc.ServiceSuffix }
func (n Names) Slice() string { return n.base() + ".slice" }
func (n Names) UnitPrefix() string { return n.base() }
func (n Names) DevCore() string { return n.Prefix + "core-" + n.Key + "-dev" + hostsvc.ServiceSuffix }
func (n Names) HostProcessPrefix() string { return n.Prefix + "hp-" + n.Key + "-" }
func (n Names) CorePrefix() string { return n.Prefix + "core-" + n.Key + "-" }
func (n Names) CoreSlice() string { return n.Prefix + "core-" + n.Key + ".slice" }
func (n Names) StandIn(role string) string { return n.base() + "-" + role + hostsvc.ServiceSuffix }
func KineRole(slot string) string { return "kine-" + slot }
func SlotRole(slot string) string { return "kcp-" + slot }
func (a App) Validate() error {
if a.Role != RoleGateway && a.Role != RoleBidder && a.Role != RoleRequester {
return fmt.Errorf("bootstrap: application role %q: want %s, %s or %s", a.Role, RoleGateway, RoleBidder, RoleRequester)
}
if !keyRE.MatchString(a.Key) {
return fmt.Errorf("bootstrap: application key %q: want lower-case letters, digits and dashes, at most 24", a.Key)
}
if a.Store != StoreSqlite && a.Store != StorePostgres {
return fmt.Errorf("bootstrap: store %q: want %s or %s", a.Store, StoreSqlite, StorePostgres)
}
if a.Role == RoleBidder {
if a.Store != StoreSqlite {
return errors.New("bootstrap: a bidder's kcp is one slot on kine-sqlite; it never has a postgres")
}
if a.Handle == "" && !a.DevCore {
return errors.New("bootstrap: a bidder application names its handle")
}
}
if a.Role == RoleRequester {
if a.Store != StoreSqlite {
return errors.New("bootstrap: a requester's kcp is one slot on kine-sqlite; it never has a postgres")
}
if a.Name == "" {
return errors.New("bootstrap: a requester application names its instance")
}
if len(a.Slots) != 1 {
return errors.New("bootstrap: a requester runs one kcp slot")
}
}
if len(a.Slots) == 0 || len(a.Slots) > 2 {
return fmt.Errorf("bootstrap: %d kcp slots: want one or two", len(a.Slots))
}
if a.Role == RoleBidder && len(a.Slots) != 1 {
return errors.New("bootstrap: a bidder runs one kcp slot")
}
for i, s := range a.Slots {
if !slotRE.MatchString(s) || slices.Contains(a.Slots[:i], s) {
return fmt.Errorf("bootstrap: slot %q: want distinct single letters", s)
}
}
return nil
}
func (a App) KineSlots() []string {
if a.Store == StorePostgres {
return slices.Clone(a.Slots)
}
return []string{a.Slots[0]}
}
func (a App) KineOf(slot string) string {
if a.Store == StorePostgres && slices.Contains(a.Slots, slot) {
return slot
}
return a.Slots[0]
}
func (a App) SlotEntry(slot string) Entry {
n := a.Names()
kine := n.Kine(a.KineOf(slot))
return Entry{Kind: KindSlot, Role: SlotRole(slot), Unit: n.Slot(slot), Slot: slot, After: []string{kine, n.Front()}, Wants: []string{kine}}
}
func (a App) CoreUnit() string {
switch {
case a.DevCore:
return a.Names().DevCore()
case a.Role == RoleBidder:
return a.Names().Prefix + BidderCore + a.Handle + hostsvc.ServiceSuffix
case a.Role == RoleRequester:
return a.Names().Prefix + RequesterCore + a.Name + hostsvc.ServiceSuffix
}
return a.Names().Prefix + GatewayCore
}
func CoreTemplate(prefix, role string) string {
prefix = cmp.Or(prefix, hostsvc.NamePrefix)
switch role {
case RoleBidder:
return prefix + BidderCore + hostsvc.ServiceSuffix
case RoleRequester:
return prefix + RequesterCore + hostsvc.ServiceSuffix
}
return prefix + GatewayCore
}
func Table(a App) ([]Entry, error) {
if err := a.Validate(); err != nil {
return nil, err
}
n := a.Names()
var out []Entry
var store []string
if a.Store == StorePostgres {
store = []string{n.Store()}
out = append(out, Entry{Kind: KindStore, Role: RolePostgres, Unit: n.Store()})
}
for _, s := range a.KineSlots() {
out = append(out, Entry{Kind: KindKine, Role: KineRole(s), Unit: n.Kine(s), Slot: s, After: store, Wants: store})
}
out = append(out, Entry{Kind: KindFront, Role: RoleFront, Unit: n.Front()})
for _, s := range a.Slots {
out = append(out, a.SlotEntry(s))
}
var after, wants []string
for _, e := range out {
after = append(after, e.Unit)
if e.Kind != KindSlot {
wants = append(wants, e.Unit)
}
}
out = append(out, Entry{Kind: KindCore, Role: RoleCore, Unit: a.CoreUnit(), After: after, Wants: wants})
return out, nil
}
func Order() []Kind { return []Kind{KindStore, KindKine, KindFront, KindSlot, KindCore} }