Merge branch 'pr-amery-k8s_token' into next-amery

Signed-off-by: Alejandro Mery <amery@jpi.io>

go.mod

@@ -2,8 +2,6 @@ module git.jpi.io/amery/jpictl
 
 go 1.19
 
-replace asciigoat.org/ini => ../../../asciigoat.org/ini
-
 require (
 	asciigoat.org/ini v0.2.5
 	darvaza.org/core v0.12.0

go.sum

@@ -1,5 +1,7 @@
 asciigoat.org/core v0.3.9 h1:hgDDz4ecm3ZvehX++m8A/IzAt+B5oDPiRtxatzfUHPQ=
 asciigoat.org/core v0.3.9/go.mod h1:CAaHwyw8MpAq4a1MYtN2dxJrsK+hmIdW50OndaQZYPI=
+asciigoat.org/ini v0.2.5 h1:4gRIp9rU+XQt8+HMqZO5R7GavMv9Yl2+N+je6djDIAE=
+asciigoat.org/ini v0.2.5/go.mod h1:gmXzJ9XFqf1NLk5nQkj04USQ4tMtdRJHNQX6vp3DzjU=
 darvaza.org/cache/x/simplelru v0.1.8 h1:rvFucut4wKYbsYc994yR3P0M08NqlsvZxr5G4QK82tw=
 darvaza.org/cache/x/simplelru v0.1.8/go.mod h1:Mv1isOJTcXYK+aK0AvUe+/3KpRTXDsYga6rdTS/upNs=
 darvaza.org/core v0.12.0 h1:LLtYh9RZJSd0sgPTDocofCc4H5jbutSUQgPbKt+8gcI=

pkg/ceph/config.go

@@ -39,6 +39,9 @@ func writeGlobalToBuffer(w *bytes.Buffer, c *GlobalConfig) {
 	_, _ = fmt.Fprintf(w, "%s = %s\n", "mon_initial_members", strings.Join(c.Monitors, ", "))
 	_, _ = fmt.Fprintf(w, "%s = %s\n", "mon_host", joinAddrs(c.MonitorsAddr, ", "))
 	_, _ = fmt.Fprintf(w, "%s = %s\n", "cluster_network", c.ClusterNetwork.String())
+
+	_, _ = fmt.Fprintf(w, "\n; %s\n", "don't rewrite labels on startup")
+	_, _ = fmt.Fprintf(w, "%s = %s\n", "osd_class_update_on_start", "false")
 }
 
 func joinAddrs(addrs []netip.Addr, sep string) string {

pkg/ceph/config_parser.go

@@ -2,9 +2,10 @@ package ceph
 
 import (
 	"io/fs"
-	"log"
+	"net/netip"
 
 	"asciigoat.org/ini/basic"
+	"asciigoat.org/ini/parser"
 
 	"darvaza.org/core"
 )
@@ -35,26 +36,60 @@ func loadGlobalConfSection(out *Config, src *basic.Section) error {
 	return nil
 }
 
+// revive:disable:cyclomatic
+// revive:disable:cognitive-complexity
+
 func loadGlobalConfField(cfg *GlobalConfig, field basic.Field) error {
-	log.Printf("%s[%q] = %q", "global", field.Key, field.Value)
+	// revive:enable:cyclomatic
+	// revive:enable:cognitive-complexity
 
-	key, value := field.Key, field.Value
+	// TODO: refactor when asciigoat's ini parser learns to do reflection
 
-	switch key {
+	switch field.Key {
 	case "fsid":
-		return configFieldHandler(&cfg.FSID, key, value)
+		if !core.IsZero(cfg.FSID) {
-	case "mon_host":
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
-		return configFieldHandler(&cfg.MonitorsAddr, key, value)
-	case "mon_initial_members":
-		return configFieldHandler(&cfg.Monitors, key, value)
-	case "cluster_network":
-		return configFieldHandler(&cfg.ClusterNetwork, key, value)
-	default:
-		return core.Wrap(fs.ErrNotExist, "field %q unknown", key)
-	}
 		}
 
-func configFieldHandler(vi any, key, value string) error
+		err := cfg.FSID.UnmarshalText([]byte(field.Value))
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		default:
+			return nil
+		}
+	case "mon_host":
+		entries, _ := parser.SplitCommaArray(field.Value)
+		for _, s := range entries {
+			var addr netip.Addr
+
+			if err := addr.UnmarshalText([]byte(s)); err != nil {
+				return core.Wrap(err, field.Key)
+			}
+
+			cfg.MonitorsAddr = append(cfg.MonitorsAddr, addr)
+		}
+		return nil
+	case "mon_initial_members":
+		entries, _ := parser.SplitCommaArray(field.Value)
+		cfg.Monitors = append(cfg.Monitors, entries...)
+		return nil
+	case "cluster_network":
+		if !core.IsZero(cfg.ClusterNetwork) {
+			err := core.Wrap(fs.ErrInvalid, "fields before the first section")
+			return err
+		}
+
+		err := cfg.ClusterNetwork.UnmarshalText([]byte(field.Value))
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		default:
+			return nil
+		}
+	}
+	return nil
+}
 
 func newConfigFromDocument(doc *basic.Document) (*Config, error) {
 	var out Config

pkg/cluster/cluster_scan.go

@@ -12,6 +12,10 @@ const (
 	// ZoneRegionsFileName indicates the file containing
 	// region names as references
 	ZoneRegionsFileName = "regions"
+
+	// RegionClusterTokenFileName contains the kubernetes
+	// token of the cluster this region represents
+	RegionClusterTokenFileName = "k8s_token"
 )
 
 func (m *Cluster) scan(opts *ScanOptions) error {
@@ -186,6 +190,8 @@ func (z *Zone) scan() error {
 		switch {
 		case name == ZoneRegionsFileName:
 			err = z.loadRegions()
+		case name == RegionClusterTokenFileName:
+			err = z.loadClusterToken()
 		case e.IsDir():
 			err = z.scanSubdirectory(name)
 		default:
@@ -218,6 +224,28 @@ func (z *Zone) loadRegions() error {
 	return err
 }
 
+func (z *Zone) loadClusterToken() error {
+	filename := path.Join(z.Name, RegionClusterTokenFileName)
+	lines, err := z.zones.ReadLines(filename)
+	if err == nil {
+		var token string
+
+		for _, s := range lines {
+			if s != "" {
+				token = s
+				break
+			}
+		}
+
+		err = z.zones.setRegionClusterToken(z.Name, token)
+		if err != nil {
+			err = core.Wrap(err, filename)
+		}
+	}
+
+	return err
+}
+
 func (z *Zone) scanSubdirectory(name string) error {
 	m := &Machine{
 		zone:   z,

pkg/cluster/regions.go

@@ -16,6 +16,7 @@ type Region struct {
 	zones []*Zone
 
 	Name    string
+	Cluster *string  `json:",omitempty" yaml:",omitempty"`
 	Regions []string `json:",omitempty" yaml:",omitempty"`
 }
 
@@ -106,6 +107,26 @@ func (m *Cluster) setRegionZones(name string, zones ...*Zone) {
 	})
 }
 
+func (m *Cluster) setRegionClusterToken(name string, token string) error {
+	for i := range m.Regions {
+		r := &m.Regions[i]
+
+		if r.Name == name {
+			// found
+			r.Cluster = &token
+			return nil
+		}
+	}
+
+	// new
+	m.Regions = append(m.Regions, Region{
+		m:       m,
+		Name:    name,
+		Cluster: &token,
+	})
+	return nil
+}
+
 func (m *Cluster) appendRegionRegions(name string, subs ...string) {
 	for i := range m.Regions {
 		r := &m.Regions[i]
@@ -191,7 +212,7 @@ func (z *Zone) SyncRegions() error {
 }
 
 func (z *Zone) syncZoneRegions() error {
-	name := filepath.Join(z.Name, "regions")
+	name := filepath.Join(z.Name, ZoneRegionsFileName)
 
 	if len(z.Regions) > 0 {
 		var buf bytes.Buffer
@@ -210,9 +231,25 @@ func (z *Zone) syncZoneRegions() error {
 // SyncRegions writes to the file system the regions covered
 // by this meta-region
 func (r *Region) SyncRegions() error {
-	name := filepath.Join(r.Name, "regions")
+	if err := r.syncRegionsFile(); err != nil {
+		return err
+	}
 
-	if len(r.Regions) > 0 {
+	return r.syncClusterFile()
+}
+
+func (r *Region) mkdir() error {
+	return r.m.MkdirAll(r.Name)
+}
+
+func (r *Region) syncRegionsFile() error {
+	var err error
+
+	name := filepath.Join(r.Name, ZoneRegionsFileName)
+
+	if len(r.Regions) == 0 {
+		err = r.m.RemoveFile(name)
+	} else if err = r.mkdir(); err == nil {
 		var buf bytes.Buffer
 
 		for _, s := range r.Regions {
@@ -220,12 +257,29 @@ func (r *Region) SyncRegions() error {
 			_, _ = buf.WriteRune('\n')
 		}
 
-		if err := r.m.MkdirAll(r.Name); err != nil {
+		err = r.m.WriteStringFile(buf.String(), name)
+	}
+
 	return err
 }
 
-		return r.m.WriteStringFile(buf.String(), name)
+func (r *Region) syncClusterFile() error {
+	var err error
+
+	name := filepath.Join(r.Name, RegionClusterTokenFileName)
+
+	if r.Cluster == nil {
+		err = r.m.RemoveFile(name)
+	} else if err = r.mkdir(); err == nil {
+		var buf bytes.Buffer
+
+		_, _ = buf.WriteString(*r.Cluster)
+		if buf.Len() > 0 {
+			_, _ = buf.WriteRune('\n')
 		}
 
-	return r.m.RemoveFile(name)
+		err = r.m.WriteStringFile(buf.String(), name)
+	}
+
+	return err
 }

pkg/wireguard/config.go

@@ -78,7 +78,7 @@ type PeerConfig struct {
 	Name       string
 	PublicKey  PublicKey
 	Endpoint   EndpointAddress
-	AllowedIPs []netip.Prefix `ini:",comma"`
+	AllowedIPs []netip.Prefix
 }
 
 // EndpointAddress is a host:port pair to reach the Peer

pkg/wireguard/config_parser.go

@@ -2,7 +2,7 @@ package wireguard
 
 import (
 	"io/fs"
-	"log"
+	"strconv"
 
 	"asciigoat.org/ini/basic"
 	"darvaza.org/core"
@@ -50,42 +50,106 @@ func loadPeerConfSection(out *Config, src *basic.Section) error {
 	return nil
 }
 
-func configFieldHandler(vi any, key, value string) error
+// revive:disable:cyclomatic
+// revive:disable:cognitive-complexity
 
 func loadInterfaceConfField(cfg *InterfaceConfig, field basic.Field) error {
-	log.Printf("%s[%q] = %q", "Interface", field.Key, field.Value)
+	// revive:enable:cyclomatic
+	// revive:enable:cognitive-complexity
 
-	key, value := field.Key, field.Value
+	// TODO: refactor when asciigoat's ini parser learns to do reflection
-
+	switch field.Key {
-	switch key {
 	case "Address":
-		return configFieldHandler(&cfg.Address, key, value)
+		if !core.IsZero(cfg.Address) {
-	case "PrivateKey":
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
-		return configFieldHandler(&cfg.PrivateKey, key, value)
+		}
-	case "ListenPort":
+
-		return configFieldHandler(&cfg.ListenPort, key, value)
+		err := cfg.Address.UnmarshalText([]byte(field.Value))
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
 		default:
-		return core.Wrap(fs.ErrInvalid, "unknown field %q", key)
+			return nil
 		}
+	case "PrivateKey":
+		if !core.IsZero(cfg.PrivateKey) {
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
 		}
 
-func loadPeerConfField(cfg *PeerConfig, field basic.Field) error {
+		err := cfg.PrivateKey.UnmarshalText([]byte(field.Value))
-	log.Printf("%s[%q] = %q", "Peer", field.Key, field.Value)
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		default:
+			return nil
+		}
+	case "ListenPort":
+		if cfg.ListenPort > 0 {
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
+		}
 
-	key, value := field.Key, field.Value
+		u64, err := strconv.ParseUint(field.Value, 10, 16)
-
+		switch {
-	switch key {
+		case err != nil:
-	case "PublicKey":
+			return core.Wrap(err, field.Key)
-		return configFieldHandler(&cfg.PublicKey, key, value)
+		case u64 == 0:
-	case "Endpoint":
+			return core.Wrap(fs.ErrInvalid, "invalid %q value", field.Key)
-		return configFieldHandler(&cfg.Endpoint, key, value)
+		default:
-	case "AllowedIPs":
+			cfg.ListenPort = uint16(u64)
-		return configFieldHandler(&cfg.AllowedIPs, key, value)
+			return nil
+		}
 	default:
 		return core.Wrap(fs.ErrInvalid, "unknown field %q", field.Key)
 	}
 }
 
+// revive:disable:cyclomatic
+// revive:disable:cognitive-complexity
+
+func loadPeerConfField(cfg *PeerConfig, field basic.Field) error {
+	// revive:enable:cyclomatic
+	// revive:enable:cognitive-complexity
+
+	switch field.Key {
+	case "PublicKey":
+		if !core.IsZero(cfg.PublicKey) {
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
+		}
+
+		err := cfg.PublicKey.UnmarshalText([]byte(field.Value))
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		default:
+			return nil
+		}
+	case "Endpoint":
+		if cfg.Endpoint.String() != "" {
+			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
+		}
+
+		err := cfg.Endpoint.UnmarshalText([]byte(field.Value))
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		default:
+			return nil
+		}
+	case "AllowedIPs":
+		s, err := parseAllowedIPs(field.Value)
+		switch {
+		case err != nil:
+			return core.Wrap(err, field.Key)
+		case len(s) > 0:
+			cfg.AllowedIPs = append(cfg.AllowedIPs, s...)
+			return nil
+		}
+	default:
+		return core.Wrap(fs.ErrInvalid, "unknown field %q", field.Key)
+	}
+	return nil
+}
+
 func newConfigFromDocument(doc *basic.Document) (*Config, error) {
 	var out Config