Merge pull request 'cluster: drop wg1.conf' (#58)

Reviewed-on: #58

cmd/jpictl/gateway.go

@@ -43,7 +43,7 @@ func gatewaySet(zi cluster.ZoneIterator, gw string) error {
 	zi.ForEachZone(func(z *cluster.Zone) bool {
 		for _, m := range z.Machines {
 			if m.Name == gw {
-				z.SetGateway(m.ID, true)
+				_ = z.SetGateway(m.ID, true)
 				return true
 			}
 		}
@@ -79,8 +79,8 @@ func gatewayUnset(zi cluster.ZoneIterator, ngw string) error {
 	zi.ForEachZone(func(z *cluster.Zone) bool {
 		for _, m := range z.Machines {
 			if m.Name == ngw && m.IsGateway() {
-				z.SetGateway(m.ID, false)
-				m.RemoveWireguardConfig(0)
+				_ = z.SetGateway(m.ID, false)
+				_ = m.RemoveWireguardConfig(0)
 				return true
 			}
 		}

cmd/jpictl/list.go

@@ -0,0 +1,200 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"net/netip"
+	"os"
+
+	"darvaza.org/core"
+	"github.com/spf13/cobra"
+
+	"git.jpi.io/amery/jpictl/pkg/cluster"
+	"git.jpi.io/amery/jpictl/pkg/rings"
+	"git.jpi.io/amery/jpictl/pkg/tools"
+)
+
+type inventory struct {
+	r []*cluster.Region
+	z [][]*cluster.Zone
+}
+
+func (g *inventory) renderRingZero(out *tools.LazyBuffer) error {
+	ring0 := netip.PrefixFrom(rings.UnsafeRingZeroAddress(0, 0, 0), rings.RingZeroBits)
+	from, to, _ := rings.PrefixToRange(ring0)
+
+	_ = out.Printf("; wg%v\n", 0)
+	_ = out.Printf("%s\t%s-%s\n", ring0, from, to)
+
+	if err := g.renderRingZeroRegions(out); err != nil {
+		return err
+	}
+
+	return g.renderRingZeroZones(out)
+}
+
+func (g *inventory) renderRingZeroRegions(out *tools.LazyBuffer) error {
+	for _, r := range g.r {
+		if err := g.renderRingZeroRegion(out, r); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (*inventory) renderRingZeroRegion(out *tools.LazyBuffer, r *cluster.Region) error {
+	addr := rings.UnsafeRingZeroAddress(r.ID, 0, 0)
+	ring0r := netip.PrefixFrom(addr, rings.RingZeroBits+4)
+	from, to, _ := rings.PrefixToRange(ring0r)
+
+	_ = out.Printf("%s\t%s-%s\t# %s\n", ring0r, from, to, r.Name)
+	return nil
+}
+
+func (g *inventory) renderRingZeroZones(out *tools.LazyBuffer) error {
+	for i, r := range g.r {
+		for _, z := range g.z[i] {
+			if err := g.renderRingZeroZone(out, r, z); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+func (*inventory) renderRingZeroZone(out *tools.LazyBuffer, r *cluster.Region, z *cluster.Zone) error {
+	addr := rings.UnsafeRingZeroAddress(r.ID, z.ID, 0)
+	ring0rz := netip.PrefixFrom(addr, rings.RingZeroBits+4+4)
+	from, to, _ := rings.PrefixToRange(ring0rz)
+
+	_ = out.Printf("; wg%v: %s (%s)\n", 0, z.Name, r.Name)
+	_ = out.Printf("%s\t%s-%s\t%s\n", ring0rz, from, to, z.Name)
+
+	z.ForEachMachine(func(m *cluster.Machine) bool {
+		if m.IsGateway() {
+			addr, _ := m.RingZeroAddress()
+			cidr := netip.PrefixFrom(addr, 32)
+			_ = out.Printf("%s\t\t%s-%v\n", cidr, m.Name, 0)
+		}
+
+		return false
+	})
+
+	return nil
+}
+
+func (g *inventory) renderRingOne(out *tools.LazyBuffer) error {
+	for i, r := range g.r {
+		for _, z := range g.z[i] {
+			if err := g.renderRingOneZone(out, r, z); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (*inventory) renderRingOneZone(out *tools.LazyBuffer, r *cluster.Region, z *cluster.Zone) error {
+	ring1, err := rings.RingOnePrefix(r.ID, z.ID)
+	if err != nil {
+		return err
+	}
+
+	from, to, _ := rings.PrefixToRange(ring1)
+
+	_ = out.Printf("; wg%v: %s (%s)\n", 1, z.Name, r.Name)
+	_ = out.Printf("%s\t%s-%s\t%s\n", ring1, from, to, z.Name)
+
+	z.ForEachMachine(func(m *cluster.Machine) bool {
+		addr := m.RingOneAddress()
+		cidr := netip.PrefixFrom(addr, 32)
+		_ = out.Printf("%s\t\t%s\n", cidr, m.Name)
+		return false
+	})
+	return nil
+}
+
+func (g *inventory) Marshal() ([]byte, error) {
+	var buf tools.LazyBuffer
+
+	if err := g.renderRingZero(&buf); err != nil {
+		return nil, err
+	}
+
+	if err := g.renderRingOne(&buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (g *inventory) WriteTo(out io.Writer) (int64, error) {
+	b, err := g.Marshal()
+	if err != nil {
+		return 0, err
+	}
+
+	buf := bytes.NewBuffer(b)
+	return buf.WriteTo(out)
+}
+
+func genInventory(m *cluster.Cluster) (*inventory, error) {
+	g := new(inventory)
+
+	g.populateRegions(m)
+	g.populateZones()
+
+	return g, nil
+}
+
+func (g *inventory) populateRegions(m *cluster.Cluster) {
+	m.ForEachRegion(func(r *cluster.Region) bool {
+		if r.IsPrimary() {
+			g.r = append(g.r, r)
+		}
+		return false
+	})
+
+	core.SliceSortFn(g.r, func(a, b *cluster.Region) bool {
+		return a.ID < b.ID
+	})
+}
+
+func (g *inventory) populateZones() {
+	g.z = make([][]*cluster.Zone, len(g.r))
+	for i, r := range g.r {
+		r.ForEachZone(func(z *cluster.Zone) bool {
+			g.z[i] = append(g.z[i], z)
+			return false
+		})
+
+		core.SliceSortFn(g.z[i], func(a, b *cluster.Zone) bool {
+			return a.ID < b.ID
+		})
+	}
+}
+
+// Command
+var listCmd = &cobra.Command{
+	Use:    "list",
+	Short:  "list shows the IP/CIDR inventory",
+	PreRun: setVerbosity,
+	RunE: func(_ *cobra.Command, _ []string) error {
+		m, err := cfg.LoadZones(false)
+		if err != nil {
+			return err
+		}
+
+		out, err := genInventory(m)
+		if err != nil {
+			return err
+		}
+
+		_, err = out.WriteTo(os.Stdout)
+		return err
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(listCmd)
+}

pkg/cluster/ceph_scan.go

@@ -73,10 +73,7 @@ func newCephScanTODO(cfg *ceph.Config) *cephScanTODO {
 
 func (m *Cluster) scanCephMonitors(opts *ScanOptions) error {
 	cfg, err := m.GetCephConfig()
-	switch {
-	case os.IsNotExist(err):
-		err = nil
-	case err != nil:
+	if err != nil && !os.IsNotExist(err) {
 		return err
 	}
 

pkg/cluster/errors.go

@@ -25,5 +25,5 @@ var (
 // ErrInvalidRing returns an error indicating the [rings.RingID]
 // can't be used for the intended purpose
 func ErrInvalidRing(ringID rings.RingID) error {
-	return core.QuietWrap(fs.ErrInvalid, "invalid ring %v", ringID)
+	return core.QuietWrap(fs.ErrInvalid, "invalid ring %v", ringID-1)
 }

pkg/cluster/rings.go

@@ -27,8 +27,6 @@ func AsWireguardInterfaceID(ring rings.RingID) (WireguardInterfaceID, error) {
 	switch ring {
 	case rings.RingZeroID:
 		return 0, nil
-	case rings.RingOneID:
-		return 1, nil
 	default:
 		return 0, ErrInvalidRing(ring)
 	}
@@ -148,17 +146,9 @@ var (
 		Decode: rings.DecodeRingZeroAddress,
 		Encode: rings.RingZeroAddress,
 	}
-	// RingOne is a wg1 address encoder/decoder
-	RingOne = RingAddressEncoder{
-		ID:     rings.RingOneID,
-		Port:   RingOnePort,
-		Decode: rings.DecodeRingOneAddress,
-		Encode: rings.RingOneAddress,
-	}
 	// Rings provides indexed access to the ring address encoders
 	Rings = []RingAddressEncoder{
 		RingZero,
-		RingOne,
 	}
 )
 
@@ -201,61 +191,17 @@ func (r *Ring) AddPeer(p *Machine) bool {
 		},
 	}
 
-	switch {
-	case r.ID == rings.RingZeroID:
-		r.setRingZeroAllowedIPs(rp)
-	case p.IsGateway():
-		r.setRingOneGatewayAllowedIPs(rp)
-	default:
-		r.setRingOneNodeAllowedIPs(rp)
-	}
-
+	r.setRingZeroAllowedIPs(rp)
 	r.Peers = append(r.Peers, rp)
 	return true
 }
 
-func (r *Ring) setRingZeroAllowedIPs(rp *RingPeer) {
-	regionID, zoneID, _, _ := r.Decode(rp.Address)
-
-	// everyone on ring0 is a gateway to ring1
-	subnet, _ := rings.RingOnePrefix(regionID, zoneID)
-	rp.AllowSubnet(subnet)
-
-	// peer
-	rp.AllowCIDR(rp.Address, 32)
-}
-
-func (r *Ring) setRingOneGatewayAllowedIPs(rp *RingPeer) {
-	regionID, zoneID, _, _ := r.Decode(rp.Address)
-
-	// peer
+func (*Ring) setRingZeroAllowedIPs(rp *RingPeer) {
+	// ring0 peer
 	rp.AllowCIDR(rp.Address, 32)
 
-	// ring1 gateways connect to all other ring1 networks
-	r.ForEachZone(func(z *Zone) bool {
-		if !z.Is(regionID, zoneID) {
-			subnet := z.RingOnePrefix()
-			rp.AllowSubnet(subnet)
-		}
-		return false
-	})
-
-	// ring1 gateways also connect to all ring0 addresses
-	r.ForEachZone(func(z *Zone) bool {
-		z.ForEachMachine(func(p *Machine) bool {
-			if p.IsGateway() {
-				addr, _ := p.RingZeroAddress()
-				rp.AllowCIDR(addr, 32)
-			}
-			return false
-		})
-		return false
-	})
-}
-
-func (*Ring) setRingOneNodeAllowedIPs(rp *RingPeer) {
-	// only to the peer itself
-	rp.AllowCIDR(rp.Address, 32)
+	// everyone on ring0 has a leg on ring1
+	rp.AllowCIDR(rp.Node.RingOneAddress(), 32)
 }
 
 // ForEachMachine calls a function for each Machine in the ring

pkg/cluster/wireguard.go

@@ -82,13 +82,6 @@ func (m *Cluster) WriteWireguardConfig(ring rings.RingID) error {
 	switch ring {
 	case rings.RingZeroID:
 		return writeWireguardConfig(m, m, ring)
-	case rings.RingOneID:
-		var err error
-		m.ForEachZone(func(z *Zone) bool {
-			err = writeWireguardConfig(m, z, ring)
-			return err != nil
-		})
-		return err
 	default:
 		return ErrInvalidRing(ring)
 	}
@@ -100,8 +93,6 @@ func (z *Zone) WriteWireguardConfig(ring rings.RingID) error {
 	switch ring {
 	case rings.RingZeroID:
 		return writeWireguardConfig(z.zones, z.zones, ring)
-	case rings.RingOneID:
-		return writeWireguardConfig(z.zones, z, ring)
 	default:
 		return ErrInvalidRing(ring)
 	}
@@ -165,13 +156,6 @@ func (m *Cluster) SyncWireguardConfig(ring rings.RingID) error {
 	switch ring {
 	case rings.RingZeroID:
 		return syncWireguardConfig(m, m, ring)
-	case rings.RingOneID:
-		var err error
-		m.ForEachZone(func(z *Zone) bool {
-			err = syncWireguardConfig(m, z, ring)
-			return err != nil
-		})
-		return err
 	default:
 		return ErrInvalidRing(ring)
 	}
@@ -183,8 +167,6 @@ func (z *Zone) SyncWireguardConfig(ring rings.RingID) error {
 	switch ring {
 	case rings.RingZeroID:
 		return syncWireguardConfig(z.zones, z.zones, ring)
-	case rings.RingOneID:
-		return syncWireguardConfig(z.zones, z, ring)
 	default:
 		return ErrInvalidRing(ring)
 	}

pkg/rings/encode.go

@@ -14,7 +14,7 @@ func RingZeroPrefix(region RegionID, zone ZoneID) (cidr netip.Prefix, err error)
 	case !zone.Valid():
 		err = ErrOutOfRange(zone, "zone")
 	default:
-		addr := unsafeRingZeroAddress(region, zone, 0)
+		addr := UnsafeRingZeroAddress(region, zone, 0)
 		cidr = netip.PrefixFrom(addr, RingZeroBits)
 	}
 
@@ -33,7 +33,7 @@ func RingZeroAddress(region RegionID, zone ZoneID, node NodeID) (addr netip.Addr
 	case !node.ValidZero():
 		err = ErrOutOfRange(node, "node")
 	default:
-		addr = unsafeRingZeroAddress(region, zone, node)
+		addr = UnsafeRingZeroAddress(region, zone, node)
 	}
 
 	return addr, err
@@ -52,7 +52,7 @@ func RingOnePrefix(region RegionID, zone ZoneID) (cidr netip.Prefix, err error)
 	case !zone.Valid():
 		err = ErrOutOfRange(zone, "zone")
 	default:
-		addr := unsafeRingOneAddress(region, zone, 0)
+		addr := UnsafeRingOneAddress(region, zone, 0)
 		cidr = netip.PrefixFrom(addr, RingOneBits)
 	}
 	return cidr, err
@@ -71,7 +71,7 @@ func RingOneAddress(region RegionID, zone ZoneID, node NodeID) (addr netip.Addr,
 	case !node.Valid():
 		err = ErrOutOfRange(node, "node")
 	default:
-		addr = unsafeRingOneAddress(region, zone, node)
+		addr = UnsafeRingOneAddress(region, zone, node)
 	}
 	return addr, err
 }
@@ -86,7 +86,7 @@ func RingTwoPrefix(region RegionID) (cidr netip.Prefix, err error) {
 	case !region.Valid():
 		err = ErrOutOfRange(region, "region")
 	default:
-		addr := unsafeRingTwoAddress(region, 0)
+		addr := UnsafeRingTwoAddress(region, 0)
 		cidr = netip.PrefixFrom(addr, RingTwoBits)
 	}
 	return cidr, err
@@ -101,20 +101,25 @@ func RingThreePrefix(region RegionID) (subnet netip.Prefix, err error) {
 	case !region.Valid():
 		err = ErrOutOfRange(region, "region")
 	default:
-		addr := unsafeRingThreeAddress(region, 0)
+		addr := UnsafeRingThreeAddress(region, 0)
 		subnet = netip.PrefixFrom(addr, RingThreeBits)
 	}
 	return subnet, err
 }
 
-func unsafeRingZeroAddress(region RegionID, zone ZoneID, node NodeID) netip.Addr {
+// UnsafeRingZeroAddress is equivalent ot RingZeroAddress but without validating
+// the input.
+func UnsafeRingZeroAddress(region RegionID, zone ZoneID, node NodeID) netip.Addr {
 	r := uint(region)
 	z := uint(zone)
 	n := uint(node)
 
 	return AddrFrom4(10, 0, r<<4+z, n)
 }
-func unsafeRingOneAddress(region RegionID, zone ZoneID, node NodeID) netip.Addr {
+
+// UnsafeRingOneAddress is equivalent ot RingOneAddress but without validating
+// the input.
+func UnsafeRingOneAddress(region RegionID, zone ZoneID, node NodeID) netip.Addr {
 	r := uint(region)
 	z := uint(zone)
 	n := uint(node)
@@ -125,7 +130,9 @@ func unsafeRingOneAddress(region RegionID, zone ZoneID, node NodeID) netip.Addr
 	return AddrFrom4(10, r, z<<4+n1, n0)
 }
 
-func unsafeRingTwoAddress(region RegionID, n uint) netip.Addr {
+// UnsafeRingTwoAddress is equivalent ot RingTwoAddress but without validating
+// the input.
+func UnsafeRingTwoAddress(region RegionID, n uint) netip.Addr {
 	r := uint(region)
 
 	n1 := n >> 8
@@ -134,7 +141,9 @@ func unsafeRingTwoAddress(region RegionID, n uint) netip.Addr {
 	return AddrFrom4(10, r, n1, n0)
 }
 
-func unsafeRingThreeAddress(region RegionID, n uint) netip.Addr {
+// UnsafeRingThreeAddress is equivalent ot RingThreeAddress but without validating
+// the input.
+func UnsafeRingThreeAddress(region RegionID, n uint) netip.Addr {
 	r := uint(region)
 
 	n2 := n >> 16

pkg/tools/buffer.go

@@ -0,0 +1,72 @@
+package tools
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+)
+
+// LazyBuffer is a [bytes.Buffer] that minimizes counting and error checks.
+type LazyBuffer bytes.Buffer
+
+// Sys returns the underlying [bytes.Buffer].
+func (buf *LazyBuffer) Sys() *bytes.Buffer {
+	if buf == nil {
+		return nil
+	}
+	return (*bytes.Buffer)(buf)
+}
+
+// Len tells the size in bytes of the currently stored data.
+func (buf *LazyBuffer) Len() int { return buf.Sys().Len() }
+
+// String returns the stored data as string.
+func (buf *LazyBuffer) String() string { return buf.Sys().String() }
+
+// Bytes returns the stored data as a bytes slice.
+func (buf *LazyBuffer) Bytes() []byte { return buf.Sys().Bytes() }
+
+// Write implements the standard io.Writer interface.
+func (buf *LazyBuffer) Write(b []byte) (int, error) { return buf.Sys().Write(b) }
+
+// WriteTo implements the standard WriteTo() interface.
+func (buf *LazyBuffer) WriteTo(out io.Writer) (int64, error) { return buf.Sys().WriteTo(out) }
+
+// Print appends the [fmt.Print] equivalent to the buffer.
+func (buf *LazyBuffer) Print(a ...any) error {
+	_, err := fmt.Fprint(buf.Sys(), a...)
+	return err
+}
+
+// Println appends the [fmt.Println] equivalent to the buffer.
+func (buf *LazyBuffer) Println(a ...any) error {
+	_, err := fmt.Fprintln(buf.Sys(), a...)
+	return err
+}
+
+// Printf appends the [fmt.Printf] equivalent to the buffer.
+func (buf *LazyBuffer) Printf(format string, a ...any) error {
+	_, err := fmt.Fprintf(buf.Sys(), format, a...)
+	return err
+}
+
+// WriteRunes appends the given runes as UTF-8 characters to the buffer.
+func (buf *LazyBuffer) WriteRunes(runes ...rune) {
+	for _, r := range runes {
+		_, _ = buf.Sys().WriteRune(r)
+	}
+}
+
+// WriteBytes writes the given byte arrays to the buffer.
+func (buf *LazyBuffer) WriteBytes(s ...[]byte) {
+	for _, b := range s {
+		_, _ = buf.Sys().Write(b)
+	}
+}
+
+// WriteStrings writes the given strings as UTF-8 to the buffer.
+func (buf *LazyBuffer) WriteStrings(strings ...string) {
+	for _, s := range strings {
+		_, _ = buf.Sys().WriteString(s)
+	}
+}

pkg/tools/tools.go

@@ -1,3 +1,11 @@
-//go:build tools
+// Package tools contains helpers
+package tools
 
-package build
+import "io"
+
+// LazyClose closes an [io.Closer] and discards the error
+func LazyClose(p io.Closer) {
+	if p != nil {
+		_ = p.Close()
+	}
+}

pkg/wireguard/config_parser.go

@@ -8,8 +8,6 @@ import (
 	"darvaza.org/core"
 )
 
-type sectionHandler func(*Config, *basic.Section) error
-
 var sectionMap = map[string]func(*Config, *basic.Section) error{
 	"Interface": loadInterfaceConfSection,
 	"Peer":      loadPeerConfSection,