reflective [WIP]

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

.gitignore

@@ -1,2 +1 @@
 .tmp
-.version

cmd/jpictl/main.go

@@ -2,8 +2,6 @@
 package main
 
 import (
-	_ "embed"
-
 	"github.com/spf13/cobra"
 )
 
@@ -14,9 +12,8 @@ const (
 
 var (
 	rootCmd = &cobra.Command{
-		Use:     CmdName,
-		Short:   "control tool for jpi.cloud",
-		Version: version,
+		Use:   CmdName,
+		Short: "control tool for jpi.cloud",
 	}
 )
 

cmd/jpictl/version.go

@@ -1,31 +0,0 @@
-package main
-
-import (
-	_ "embed"
-
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-//go:generate sh -c "git describe | tr -d '\r\n' > .version"
-//go:embed .version
-var version string
-
-var versionCmd = &cobra.Command{
-	Use:   "version",
-	Short: "Returns jpictl's version",
-	Args:  cobra.NoArgs,
-	Run: func(_ *cobra.Command, _ []string) {
-		_, _ = fmt.Fprintf(os.Stdout, "%s\n", version)
-	},
-}
-
-func init() {
-	if version == "" {
-		version = "undetermined"
-	}
-
-	rootCmd.AddCommand(versionCmd)
-}

go.mod

@@ -2,6 +2,8 @@ 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,7 +1,5 @@
 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,9 +39,6 @@ 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,10 +2,9 @@ package ceph
 
 import (
 	"io/fs"
-	"net/netip"
+	"log"
 
 	"asciigoat.org/ini/basic"
-	"asciigoat.org/ini/parser"
 
 	"darvaza.org/core"
 )
@@ -36,61 +35,27 @@ 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 {
-	// revive:enable:cyclomatic
-	// revive:enable:cognitive-complexity
+	log.Printf("%s[%q] = %q", "global", field.Key, field.Value)
 
-	// TODO: refactor when asciigoat's ini parser learns to do reflection
+	key, value := field.Key, field.Value
 
-	switch field.Key {
+	switch key {
 	case "fsid":
-		if !core.IsZero(cfg.FSID) {
-			return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key)
-		}
-
-		err := cfg.FSID.UnmarshalText([]byte(field.Value))
-		switch {
-		case err != nil:
-			return core.Wrap(err, field.Key)
-		default:
-			return nil
-		}
+		return configFieldHandler(&cfg.FSID, key, value)
 	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
+		return configFieldHandler(&cfg.MonitorsAddr, key, value)
 	case "mon_initial_members":
-		entries, _ := parser.SplitCommaArray(field.Value)
-		cfg.Monitors = append(cfg.Monitors, entries...)
-		return nil
+		return configFieldHandler(&cfg.Monitors, key, value)
 	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 configFieldHandler(&cfg.ClusterNetwork, key, value)
+	default:
+		return core.Wrap(fs.ErrNotExist, "field %q unknown", key)
 	}
-	return nil
 }
 
+func configFieldHandler(vi any, key, value string) error
+
 func newConfigFromDocument(doc *basic.Document) (*Config, error) {
 	var out Config
 

pkg/cluster/cluster_scan.go

@@ -4,7 +4,6 @@ import (
 	"io/fs"
 	"path"
 	"sort"
-	"strings"
 
 	"darvaza.org/core"
 )
@@ -13,10 +12,6 @@ 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 {
@@ -191,8 +186,6 @@ 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:
@@ -225,32 +218,6 @@ func (z *Zone) loadRegions() error {
 	return err
 }
 
-func (z *Zone) loadClusterToken() error {
-	var token string
-
-	filename := path.Join(z.Name, RegionClusterTokenFileName)
-	lines, err := z.zones.ReadLines(filename)
-	if err != nil {
-		return err
-	}
-
-	// first non-empty line
-	for _, s := range lines {
-		s = strings.TrimSpace(s)
-		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/env.go

@@ -4,14 +4,12 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"sort"
 	"strings"
 )
 
 // Env is a shell environment factory for this cluster
 type Env struct {
 	ZoneIterator
-	RegionIterator
 
 	cephFSID string
 	export   bool
@@ -25,10 +23,9 @@ func (m *Cluster) Env(export bool) (*Env, error) {
 	}
 
 	env := &Env{
-		ZoneIterator:   m,
-		RegionIterator: m,
-		cephFSID:       fsid.String(),
-		export:         export,
+		ZoneIterator: m,
+		cephFSID:     fsid.String(),
+		export:       export,
 	}
 
 	return env, nil
@@ -46,22 +43,6 @@ func (m *Env) Zones() []int {
 	return zones
 }
 
-// Regions returns the list of primary regions
-func (m *Env) Regions() []string {
-	var regions []string
-
-	m.ForEachRegion(func(r *Region) bool {
-		if r.Cluster != nil {
-			regions = append(regions, r.Name)
-		}
-
-		return false
-	})
-
-	sort.Strings(regions)
-	return regions
-}
-
 // WriteTo generates environment variables for shell scripts
 func (m *Env) WriteTo(w io.Writer) (int64, error) {
 	var buf bytes.Buffer
@@ -70,7 +51,6 @@ func (m *Env) WriteTo(w io.Writer) (int64, error) {
 		m.writeEnvVar(&buf, m.cephFSID, "FSID")
 	}
 
-	m.writeEnvVarStrings(&buf, m.Regions(), "REGIONS")
 	m.writeEnvVarInts(&buf, m.Zones(), "ZONES")
 
 	m.ForEachZone(func(z *Zone) bool {
@@ -94,9 +74,6 @@ func (m *Env) writeEnvZone(w io.Writer, z *Zone) {
 	gateways, _ := z.GatewayIDs()
 	m.writeEnvVarInts(w, gateways, "ZONE%v_%s", zoneID, "GW")
 
-	// ZONE{zoneID}_REGION
-	m.writeEnvVar(w, genEnvZoneRegion(z), "ZONE%v_%s", zoneID, "REGION")
-
 	// Ceph
 	monitors := z.GetCephMonitors()
 	// MON{zoneID}_NAME
@@ -108,29 +85,22 @@ func (m *Env) writeEnvZone(w io.Writer, z *Zone) {
 }
 
 func (m *Env) writeEnvVarInts(w io.Writer, value []int, name string, args ...any) {
-	var buf bytes.Buffer
+	var s string
 
-	for _, v := range value {
-		if buf.Len() > 0 {
-			_, _ = fmt.Fprint(&buf, " ")
+	if n := len(value); n > 0 {
+		var buf bytes.Buffer
+
+		for i, v := range value {
+			if i != 0 {
+				_, _ = fmt.Fprint(&buf, " ")
+			}
+			_, _ = fmt.Fprintf(&buf, "%v", v)
 		}
-		_, _ = fmt.Fprintf(&buf, "%v", v)
+
+		s = buf.String()
 	}
 
-	m.writeEnvVar(w, buf.String(), name, args...)
-}
-
-func (m *Env) writeEnvVarStrings(w io.Writer, value []string, name string, args ...any) {
-	var buf bytes.Buffer
-
-	for _, v := range value {
-		if buf.Len() > 0 {
-			_, _ = fmt.Fprint(&buf, " ")
-		}
-		_, _ = fmt.Fprintf(&buf, "%s", v)
-	}
-
-	m.writeEnvVar(w, buf.String(), name, args...)
+	m.writeEnvVar(w, s, name, args...)
 }
 
 func (m *Env) writeEnvVar(w io.Writer, value string, name string, args ...any) {
@@ -147,11 +117,7 @@ func (m *Env) writeEnvVar(w io.Writer, value string, name string, args ...any) {
 	if name != "" {
 		value = strings.TrimSpace(value)
 
-		if value == "" {
-			_, _ = fmt.Fprintf(w, "%s%s=\n", prefix, name)
-		} else {
-			_, _ = fmt.Fprintf(w, "%s%s=%q\n", prefix, name, value)
-		}
+		_, _ = fmt.Fprintf(w, "%s%s=%q\n", prefix, name, value)
 	}
 }
 
@@ -169,21 +135,6 @@ func genEnvZoneNodes(z *Zone) string {
 	return ""
 }
 
-func genEnvZoneRegion(z *Zone) string {
-	var region string
-
-	z.ForEachRegion(func(r *Region) bool {
-		if r.Cluster != nil {
-			region = r.Name
-			return true
-		}
-
-		return false
-	})
-
-	return region
-}
-
 func genEnvZoneCephMonNames(m Machines) string {
 	var buf strings.Builder
 	m.ForEachMachine(func(p *Machine) bool {

pkg/cluster/regions.go

@@ -8,23 +8,14 @@ import (
 var (
 	_ MachineIterator = (*Region)(nil)
 	_ ZoneIterator    = (*Region)(nil)
-
-	_ RegionIterator = (*Zone)(nil)
-	_ RegionIterator = (*Cluster)(nil)
 )
 
-// A RegionIterator is a set of Regions we can iterate on
-type RegionIterator interface {
-	ForEachRegion(func(*Region) bool)
-}
-
 // Region represents a group of zones geographically related
 type Region struct {
 	m     *Cluster
 	zones []*Zone
 
 	Name    string
-	Cluster *string  `json:",omitempty" yaml:",omitempty"`
 	Regions []string `json:",omitempty" yaml:",omitempty"`
 }
 
@@ -115,26 +106,6 @@ 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]
@@ -153,28 +124,6 @@ func (m *Cluster) appendRegionRegions(name string, subs ...string) {
 	})
 }
 
-// ForEachRegion calls a function on all regions this zone belongs to.
-func (z *Zone) ForEachRegion(fn func(*Region) bool) {
-	if fn == nil {
-		return
-	}
-
-	z.zones.ForEachRegion(func(r *Region) bool {
-		var match bool
-
-		r.ForEachZone(func(z2 *Zone) bool {
-			match = (z == z2)
-			return match
-		})
-
-		if match && fn(r) {
-			return true
-		}
-
-		return false
-	})
-}
-
 func (z *Zone) appendRegions(regions ...string) error {
 	for _, s := range regions {
 		// TODO: validate
@@ -198,7 +147,7 @@ func (m *Cluster) finishRegion(r *Region) {
 	r.m = m
 	sub := []string{}
 	for _, name := range r.Regions {
-		r2, ok := m.getFinishRegion(name)
+		r2, ok := m.getRegion(name)
 		if !ok {
 			m.warn(nil).WithField("region", name).Print("unknown region")
 			continue
@@ -213,7 +162,9 @@ func (m *Cluster) finishRegion(r *Region) {
 func (m *Cluster) getRegion(name string) (*Region, bool) {
 	for i := range m.Regions {
 		r := &m.Regions[i]
+
 		if name == r.Name {
+			m.finishRegion(r)
 			return r, true
 		}
 	}
@@ -221,22 +172,17 @@ func (m *Cluster) getRegion(name string) (*Region, bool) {
 	return nil, false
 }
 
-func (m *Cluster) getFinishRegion(name string) (*Region, bool) {
-	if r, ok := m.getRegion(name); ok {
-		m.finishRegion(r)
-		return r, true
-	}
-
-	return nil, false
-}
-
 // SyncRegions writes to the file system the regions this [Zone]
 // belongs to.
 func (z *Zone) SyncRegions() error {
 	err := z.syncZoneRegions()
 	if err == nil {
 		z.ForEachMachine(func(p *Machine) bool {
-			err = z.syncMachineRegions(p)
+			if p.IsActive() {
+				err = p.RemoveFile("region")
+			} else {
+				err = p.WriteStringFile("none\n", "region")
+			}
 			return err != nil
 		})
 	}
@@ -244,24 +190,8 @@ func (z *Zone) SyncRegions() error {
 	return err
 }
 
-func (*Zone) syncMachineRegions(p *Machine) error {
-	var err error
-
-	if p.IsActive() {
-		err = p.RemoveFile("region")
-	} else {
-		err = p.WriteStringFile("none\n", "region")
-	}
-
-	if err == nil {
-		err = p.RemoveFile(RegionClusterTokenFileName)
-	}
-
-	return err
-}
-
 func (z *Zone) syncZoneRegions() error {
-	name := filepath.Join(z.Name, ZoneRegionsFileName)
+	name := filepath.Join(z.Name, "regions")
 
 	if len(z.Regions) > 0 {
 		var buf bytes.Buffer
@@ -280,25 +210,9 @@ func (z *Zone) syncZoneRegions() error {
 // SyncRegions writes to the file system the regions covered
 // by this meta-region
 func (r *Region) SyncRegions() error {
-	if err := r.syncRegionsFile(); err != nil {
-		return err
-	}
+	name := filepath.Join(r.Name, "regions")
 
-	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 {
+	if len(r.Regions) > 0 {
 		var buf bytes.Buffer
 
 		for _, s := range r.Regions {
@@ -306,29 +220,12 @@ func (r *Region) syncRegionsFile() error {
 			_, _ = buf.WriteRune('\n')
 		}
 
-		err = r.m.WriteStringFile(buf.String(), name)
-	}
-
-	return err
-}
-
-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')
+		if err := r.m.MkdirAll(r.Name); err != nil {
+			return err
 		}
 
-		err = r.m.WriteStringFile(buf.String(), name)
+		return r.m.WriteStringFile(buf.String(), name)
 	}
 
-	return err
+	return r.m.RemoveFile(name)
 }

pkg/rings/cidr.go

@@ -1,77 +0,0 @@
-package rings
-
-import "net/netip"
-
-// AddrFromU32 converts a 32bit value into an IPv4
-// address.
-func AddrFromU32(v uint32) netip.Addr {
-	return AddrFrom4(
-		uint(v>>24),
-		uint(v>>16),
-		uint(v>>8),
-		uint(v),
-	)
-}
-
-// AddrFrom4 assembles an IPv4 address for 4 numbers.
-// each number is truncated to 8-bits.
-func AddrFrom4(a, b, c, d uint) netip.Addr {
-	return netip.AddrFrom4([4]byte{
-		byte(a & 0xff),
-		byte(b & 0xff),
-		byte(c & 0xff),
-		byte(d & 0xff),
-	})
-}
-
-// AddrToU32 converts a valid IPv4 address into it's
-// 32bit numeric representation.
-func AddrToU32(addr netip.Addr) (v uint32, ok bool) {
-	if addr.IsValid() {
-		if addr.Is4() || addr.Is4In6() {
-			a4 := addr.As4()
-
-			v = uint32(a4[0])<<24 +
-				uint32(a4[1])<<16 +
-				uint32(a4[2])<<8 +
-				uint32(a4[3])
-			return v, true
-		}
-	}
-
-	return 0, false
-}
-
-// PrefixToRange returns the beginning and end of a
-// [netip.Prefix] (aka CIDR or subnet).
-func PrefixToRange(subnet netip.Prefix) (from, to netip.Addr, ok bool) {
-	var u uint32
-
-	addr := subnet.Addr()
-	if u, ok = AddrToU32(addr); ok {
-		bits := subnet.Bits()
-
-		switch {
-		case bits > 32, bits < 0:
-			// bad
-		case bits == 32:
-			// single
-			from, to, ok = addr, addr, true
-		default:
-			// subnet
-			shift := 32 - bits
-
-			m1 := uint32((1 << shift) - 1)
-			m0 := uint32(0xffffffff) & ^m1
-
-			u0 := u & m0
-			u1 := u0 + m1
-
-			ok = true
-			from = AddrFromU32(u0)
-			to = AddrFromU32(u1)
-		}
-	}
-
-	return from, to, ok
-}

pkg/rings/cidr_test.go

@@ -1,178 +0,0 @@
-package rings
-
-import (
-	"fmt"
-	"net/netip"
-	"testing"
-)
-
-func TestAddrFrom4(t *testing.T) {
-	cases := []struct {
-		v [4]uint
-		s string
-	}{
-		{[4]uint{0, 0, 0, 0}, "0.0.0.0"},
-		{[4]uint{127, 0, 0, 1}, "127.0.0.1"},
-		{[4]uint{4096 + 127, 0, 0, 1}, "127.0.0.1"},
-		{[4]uint{257, 258, 259, 260}, "1.2.3.4"},
-		{[4]uint{255, 255, 255, 255}, "255.255.255.255"},
-	}
-
-	for i, tc := range cases {
-		fn := fmt.Sprintf("%v.%v.%v.%v", tc.v[0], tc.v[1], tc.v[2], tc.v[3])
-		addr := AddrFrom4(tc.v[0], tc.v[1], tc.v[2], tc.v[3])
-		s := addr.String()
-
-		if s == tc.s {
-			t.Logf("[%v/%v]: %s → %s", i, len(cases), fn, s)
-		} else {
-			t.Errorf("ERROR: [%v/%v]: %s → %s (expected %s)", i, len(cases), fn, s, tc.s)
-		}
-	}
-}
-
-func TestAddrU32Invalid(t *testing.T) {
-	cases := []netip.Addr{
-		{},
-		netip.IPv6Unspecified(),
-		netip.IPv6Loopback(),
-	}
-
-	for i, tc := range cases {
-		v, ok := AddrToU32(tc)
-		switch {
-		case !ok && v == 0:
-			t.Logf("[%v/%v]: %s → %v %v", i, len(cases), tc, 0, false)
-		default:
-			t.Errorf("ERROR: [%v/%v]: %s → %v %v (expected %v %v)", i, len(cases),
-				tc, v, ok, 0, false)
-		}
-	}
-}
-
-func TestAddrU32Valid(t *testing.T) {
-	cases := []netip.Addr{
-		netip.IPv4Unspecified(),
-		AddrFrom4(0, 0, 0, 0),
-		AddrFrom4(1, 2, 3, 4),
-		AddrFrom4(10, 20, 30, 40),
-		AddrFrom4(127, 0, 0, 1),
-		AddrFrom4(255, 255, 255, 255),
-		MustParseAddr("::ffff:1.2.3.4"),
-	}
-
-	for i, tc := range cases {
-		u32, ok := AddrToU32(tc)
-		if !ok {
-			t.Errorf("ERROR: [%v/%v]: %s → %v %v", i, len(cases), tc, u32, ok)
-			continue
-		}
-
-		addr := AddrFromU32(u32)
-		if tc.Is4In6() {
-			ok = addr.Compare(tc.Unmap()) == 0
-		} else {
-			ok = addr.Compare(tc) == 0
-		}
-
-		if ok {
-			t.Logf("[%v/%v]: %s → %v → %s", i, len(cases), tc, u32, addr)
-		} else {
-			t.Errorf("ERROR: [%v/%v]: %s → %v → %s", i, len(cases), tc, u32, addr)
-		}
-	}
-}
-
-func MustParseAddr(s string) netip.Addr {
-	addr, err := netip.ParseAddr(s)
-	if err != nil {
-		panic(err)
-	}
-	return addr
-}
-
-func MustParsePrefix(s string) netip.Prefix {
-	subnet, err := netip.ParsePrefix(s)
-	if err != nil {
-		panic(err)
-	}
-	return subnet
-}
-
-func TestPrefixToRangeValid(t *testing.T) {
-	cases := []struct {
-		subnet netip.Prefix
-		from   netip.Addr
-		to     netip.Addr
-	}{
-		{
-			MustParsePrefix("127.0.0.1/32"),
-			MustParseAddr("127.0.0.1"),
-			MustParseAddr("127.0.0.1"),
-		},
-		{
-			MustParsePrefix("127.0.0.1/24"),
-			MustParseAddr("127.0.0.0"),
-			MustParseAddr("127.0.0.255"),
-		},
-		{
-			MustParsePrefix("127.0.1.2/16"),
-			MustParseAddr("127.0.0.0"),
-			MustParseAddr("127.0.255.255"),
-		},
-		{
-			MustParsePrefix("127.1.2.3/8"),
-			MustParseAddr("127.0.0.0"),
-			MustParseAddr("127.255.255.255"),
-		},
-		{
-			MustParsePrefix("10.20.30.40/12"),
-			MustParseAddr("10.16.0.0"),
-			MustParseAddr("10.31.255.255"),
-		},
-		{
-			MustParsePrefix("10.20.30.40/20"),
-			MustParseAddr("10.20.16.0"),
-			MustParseAddr("10.20.31.255"),
-		},
-		{
-			MustParsePrefix("10.0.0.0/12"),
-			MustParseAddr("10.0.0.0"),
-			MustParseAddr("10.15.255.255"),
-		},
-		{
-			MustParsePrefix("10.16.0.0/12"),
-			MustParseAddr("10.16.0.0"),
-			MustParseAddr("10.31.255.255"),
-		},
-		{
-			MustParsePrefix("10.32.0.0/12"),
-			MustParseAddr("10.32.0.0"),
-			MustParseAddr("10.47.255.255"),
-		},
-		{
-			MustParsePrefix("10.48.0.0/12"),
-			MustParseAddr("10.48.0.0"),
-			MustParseAddr("10.63.255.255"),
-		},
-	}
-
-	for i, tc := range cases {
-		from, to, ok := PrefixToRange(tc.subnet)
-		if ok && from.IsValid() && to.IsValid() &&
-			from.Compare(tc.from) == 0 &&
-			to.Compare(tc.to) == 0 {
-			//
-			t.Logf("[%v/%v]: %s → %s - %s",
-				i, len(cases),
-				tc.subnet,
-				from, to)
-		} else {
-			t.Errorf("ERROR: [%v/%v]: %q → %s - %s %v (expected %s - %s %v)",
-				i, len(cases),
-				tc.subnet,
-				from, to, ok,
-				tc.from, tc.to, true)
-		}
-	}
-}

pkg/rings/rings.go

@@ -1,3 +0,0 @@
-// Package rings provides logic to work with the four rings
-// of a JPI cluster
-package rings

pkg/wireguard/config.go

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

pkg/wireguard/config_parser.go

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