Merge pull request 'jpictl: introduce --config-file/-f as alternative to scanning m/' (#19)

Reviewed-on: #19

cmd/jpictl/config.go

@@ -1,22 +1,59 @@
 package main
 
-import "git.jpi.io/amery/jpictl/pkg/zones"
+import (
+	"os"
+
+	"darvaza.org/core"
+
+	"git.jpi.io/amery/jpictl/pkg/cluster"
+)
+
+const (
+	// DefaultConfigFile is read if -f/--config-file isn't specified.
+	// If it doesn't exist, m/ will be scanned
+	DefaultConfigFile = "cloud.yaml"
+)
 
 // Config describes the repository
 type Config struct {
 	Base   string
 	Domain string
+
+	ConfigFile string
 }
 
 var cfg = &Config{
-	Base:   "./m",
-	Domain: "m.jpi.cloud",
+	Base:   "m",
+	Domain: "jpi.cloud",
 }
 
 // LoadZones loads all zones and machines in the config directory
-func (cfg *Config) LoadZones(resolve bool) (*zones.Zones, error) {
-	return zones.New(cfg.Base, cfg.Domain,
-		zones.ResolvePublicAddresses(resolve),
-		zones.WithLogger(log),
+// or file
+func (cfg *Config) LoadZones(resolve bool) (*cluster.Cluster, error) {
+	// try config file first
+	zones, err := cluster.NewFromConfig(cfg.ConfigFile,
+		cluster.ResolvePublicAddresses(resolve),
+		cluster.WithLogger(log),
+	)
+
+	switch {
+	case err == nil:
+		// file was good
+		return zones, nil
+	case !os.IsNotExist(err) || cfg.ConfigFile != DefaultConfigFile:
+		// file was bad
+		return nil, core.Wrapf(err, "NewFromConfig(%q)", cfg.ConfigFile)
+	}
+
+	// default file doesn't exist. scan instead.
+	return cluster.NewFromDirectory(cfg.Base, cfg.Domain,
+		cluster.ResolvePublicAddresses(resolve),
+		cluster.WithLogger(log),
 	)
 }
+
+func init() {
+	rootCmd.PersistentFlags().
+		StringVarP(&cfg.ConfigFile, "config-file", "f",
+			DefaultConfigFile, "config file (JSON or YAML)")
+}

cmd/jpictl/gateway.go

@@ -7,8 +7,9 @@ import (
 	"strconv"
 	"strings"
 
-	"git.jpi.io/amery/jpictl/pkg/zones"
 	"github.com/spf13/cobra"
+
+	"git.jpi.io/amery/jpictl/pkg/cluster"
 )
 
 // Command
@@ -38,9 +39,9 @@ var gatewaySetCmd = &cobra.Command{
 	},
 }
 
-func gatewaySet(zi zones.ZoneIterator, gw string) error {
+func gatewaySet(zi cluster.ZoneIterator, gw string) error {
 	var err error
-	zi.ForEachZone(func(z *zones.Zone) bool {
+	zi.ForEachZone(func(z *cluster.Zone) bool {
 		for _, m := range z.Machines {
 			if m.Name == gw {
 				z.SetGateway(m.ID, true)
@@ -74,9 +75,9 @@ var gatewayUnsetCmd = &cobra.Command{
 	},
 }
 
-func gatewayUnset(zi zones.ZoneIterator, ngw string) error {
+func gatewayUnset(zi cluster.ZoneIterator, ngw string) error {
 	var err error
-	zi.ForEachZone(func(z *zones.Zone) bool {
+	zi.ForEachZone(func(z *cluster.Zone) bool {
 		for _, m := range z.Machines {
 			if m.Name == ngw && m.IsGateway() {
 				z.SetGateway(m.ID, false)
@@ -115,10 +116,10 @@ var gatewayListCmd = &cobra.Command{
 	},
 }
 
-func gatewayListAll(zi zones.ZoneIterator) error {
+func gatewayListAll(zi cluster.ZoneIterator) error {
 	var b bytes.Buffer
 	var err error
-	zi.ForEachZone(func(z *zones.Zone) bool {
+	zi.ForEachZone(func(z *cluster.Zone) bool {
 		b.WriteString(z.Name + ":")
 		var sIDs []string
 		ids, num := z.GatewayIDs()
@@ -137,10 +138,10 @@ func gatewayListAll(zi zones.ZoneIterator) error {
 	return err
 }
 
-func gatewayList(zi zones.ZoneIterator, m string) error {
+func gatewayList(zi cluster.ZoneIterator, m string) error {
 	var b bytes.Buffer
 	var err error
-	zi.ForEachZone(func(z *zones.Zone) bool {
+	zi.ForEachZone(func(z *cluster.Zone) bool {
 		if z.Name == m {
 			b.WriteString(z.Name + ":")
 			ids, num := z.GatewayIDs()

pkg/cluster/ceph.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"bytes"
@@ -12,7 +12,7 @@ import (
 )
 
 // GetCephFSID returns our Ceph's FSID
-func (m *Zones) GetCephFSID() (uuid.UUID, error) {
+func (m *Cluster) GetCephFSID() (uuid.UUID, error) {
 	if core.IsZero(m.CephFSID) {
 		// generate one
 		v, err := uuid.NewV4()
@@ -25,7 +25,7 @@ func (m *Zones) GetCephFSID() (uuid.UUID, error) {
 }
 
 // GetCephConfig reads the ceph.conf file
-func (m *Zones) GetCephConfig() (*ceph.Config, error) {
+func (m *Cluster) GetCephConfig() (*ceph.Config, error) {
 	data, err := m.ReadFile("ceph.conf")
 	if err != nil {
 		return nil, err
@@ -36,7 +36,7 @@ func (m *Zones) GetCephConfig() (*ceph.Config, error) {
 }
 
 // WriteCephConfig writes the ceph.conf file
-func (m *Zones) WriteCephConfig(cfg *ceph.Config) error {
+func (m *Cluster) WriteCephConfig(cfg *ceph.Config) error {
 	f, err := m.CreateTruncFile("ceph.conf")
 	if err != nil {
 		return err
@@ -48,7 +48,7 @@ func (m *Zones) WriteCephConfig(cfg *ceph.Config) error {
 }
 
 // GenCephConfig prepares a ceph.Config using the cluster information
-func (m *Zones) GenCephConfig() (*ceph.Config, error) {
+func (m *Cluster) GenCephConfig() (*ceph.Config, error) {
 	fsid, err := m.GetCephFSID()
 	if err != nil {
 		return nil, err

pkg/cluster/ceph_scan.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"os"
@@ -71,7 +71,7 @@ func newCephScanTODO(cfg *ceph.Config) *cephScanTODO {
 	return todo
 }
 
-func (m *Zones) scanCephMonitors(_ *ScanOptions) error {
+func (m *Cluster) scanCephMonitors(_ *ScanOptions) error {
 	cfg, err := m.GetCephConfig()
 	switch {
 	case os.IsNotExist(err):

pkg/cluster/cluster.go

@@ -0,0 +1,77 @@
+// Package cluster contains information about the cluster
+package cluster
+
+import (
+	"io/fs"
+
+	"darvaza.org/resolver"
+	"darvaza.org/slog"
+	"github.com/gofrs/uuid/v5"
+)
+
+var (
+	_ MachineIterator = (*Cluster)(nil)
+	_ ZoneIterator    = (*Cluster)(nil)
+)
+
+// revive:disable:line-length-limit
+
+// Cluster represents all zones in a cluster
+type Cluster struct {
+	dir      fs.FS
+	log      slog.Logger
+	resolver resolver.Resolver
+
+	BaseDir string `json:"dir,omitempty"    yaml:"dir,omitempty"`
+	Name    string `json:"name,omitempty"   yaml:"name,omitempty"`
+	Domain  string `json:"domain,omitempty" yaml:"domain,omitempty"`
+
+	CephFSID uuid.UUID `json:"ceph_fsid,omitempty" yaml:"ceph_fsid,omitempty"`
+	Zones    []*Zone   `json:"zones,omitempty"     yaml:"zones,omitempty"`
+}
+
+// revive:enable:line-length-limit
+
+// ForEachMachine calls a function for each Machine in the cluster
+// until instructed to terminate the loop
+func (m *Cluster) ForEachMachine(fn func(*Machine) bool) {
+	m.ForEachZone(func(z *Zone) bool {
+		var term bool
+
+		z.ForEachMachine(func(p *Machine) bool {
+			term = fn(p)
+			return term
+		})
+
+		return term
+	})
+}
+
+// ForEachZone calls a function for each Zone in the cluster
+// until instructed to terminate the loop
+func (m *Cluster) ForEachZone(fn func(*Zone) bool) {
+	for _, p := range m.Zones {
+		if fn(p) {
+			// terminate
+			return
+		}
+	}
+}
+
+// GetMachineByName looks for a machine with the specified
+// name on any zone
+func (m *Cluster) GetMachineByName(name string) (*Machine, bool) {
+	var out *Machine
+
+	if name != "" {
+		m.ForEachMachine(func(p *Machine) bool {
+			if p.Name == name {
+				out = p
+			}
+
+			return out != nil
+		})
+	}
+
+	return out, out != nil
+}

pkg/cluster/cluster_file.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"fmt"
@@ -9,7 +9,7 @@ import (
 )
 
 // OpenFile opens a file on the cluster's config directory with the specified flags
-func (m *Zones) OpenFile(name string, flags int, args ...any) (fs.File, error) {
+func (m *Cluster) OpenFile(name string, flags int, args ...any) (fs.File, error) {
 	if len(args) > 0 {
 		name = fmt.Sprintf(name, args...)
 	}
@@ -18,16 +18,16 @@ func (m *Zones) OpenFile(name string, flags int, args ...any) (fs.File, error) {
 }
 
 // CreateTruncFile creates or truncates a file on the cluster's config directory
-func (m *Zones) CreateTruncFile(name string, args ...any) (io.WriteCloser, error) {
+func (m *Cluster) CreateTruncFile(name string, args ...any) (io.WriteCloser, error) {
 	return m.openWriter(name, os.O_CREATE|os.O_TRUNC, args...)
 }
 
 // CreateFile creates a file on the cluster's config directory
-func (m *Zones) CreateFile(name string, args ...any) (io.WriteCloser, error) {
+func (m *Cluster) CreateFile(name string, args ...any) (io.WriteCloser, error) {
 	return m.openWriter(name, os.O_CREATE, args...)
 }
 
-func (m *Zones) openWriter(name string, flags int, args ...any) (io.WriteCloser, error) {
+func (m *Cluster) openWriter(name string, flags int, args ...any) (io.WriteCloser, error) {
 	f, err := m.OpenFile(name, os.O_WRONLY|flags, args...)
 	if err != nil {
 		return nil, err
@@ -37,7 +37,7 @@ func (m *Zones) openWriter(name string, flags int, args ...any) (io.WriteCloser,
 }
 
 // ReadFile reads a file from the cluster's config directory
-func (m *Zones) ReadFile(name string, args ...any) ([]byte, error) {
+func (m *Cluster) ReadFile(name string, args ...any) ([]byte, error) {
 	if len(args) > 0 {
 		name = fmt.Sprintf(name, args...)
 	}

pkg/cluster/cluster_fs.go

@@ -0,0 +1,25 @@
+package cluster
+
+import (
+	"io/fs"
+	"path/filepath"
+
+	"github.com/hack-pad/hackpadfs/os"
+)
+
+// DirFS returns a file system (an [fs.FS]) for the tree
+// of files rooted at the directory dir.
+func DirFS(dir string) (fs.FS, error) {
+	dir = filepath.Clean(dir)
+	fullPath, err := filepath.Abs(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	sub, err := os.NewFS().Sub(fullPath[1:])
+	if err != nil {
+		return nil, err
+	}
+
+	return sub, nil
+}

pkg/cluster/cluster_import.go

@@ -0,0 +1,137 @@
+package cluster
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+func (m *Cluster) init(opts *ScanOptions) error {
+	for _, fn := range []func(*ScanOptions) error{
+		m.initZones,
+		m.scanZoneIDs,
+		m.scanSort,
+		m.scanGateways,
+	} {
+		if err := fn(opts); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Cluster) initZones(opts *ScanOptions) error {
+	var err error
+
+	sub, err := DirFS(m.BaseDir)
+	if err != nil {
+		return err
+	}
+
+	m.dir = sub
+
+	m.ForEachZone(func(z *Zone) bool {
+		err = m.initZone(z, opts)
+		return err != nil
+	})
+
+	return err
+}
+
+func (m *Cluster) initZone(z *Zone, _ *ScanOptions) error {
+	var hasMissing bool
+	var lastMachineID int
+
+	z.zones = m
+	z.logger = m
+
+	z.ForEachMachine(func(p *Machine) bool {
+		p.zone = z
+		p.logger = z
+
+		switch {
+		case p.ID == 0:
+			hasMissing = true
+		case p.ID > lastMachineID:
+			lastMachineID = z.ID
+		}
+
+		return false
+	})
+
+	if hasMissing {
+		next := lastMachineID + 1
+
+		z.ForEachMachine(func(p *Machine) bool {
+			if p.ID == 0 {
+				p.ID, next = next, next+1
+			}
+
+			return false
+		})
+	}
+
+	z.ForEachMachine(func(p *Machine) bool {
+		p.Name = fmt.Sprintf("%s-%v", z.Name, p.ID)
+		return false
+	})
+
+	return nil
+}
+
+func decodeConfigData(data []byte) (out *Cluster, err error) {
+	// try JSON first
+	out = new(Cluster)
+	err = json.Unmarshal(data, out)
+	if err == nil {
+		// good json
+		return out, nil
+	} else if _, ok := err.(*json.SyntaxError); !ok {
+		// bad json
+		return nil, err
+	}
+
+	out = new(Cluster)
+	err = yaml.Unmarshal(data, out)
+	if err != nil {
+		// bad yaml too
+		return nil, err
+	}
+
+	// good yaml
+	return out, nil
+}
+
+// NewFromConfig loads the cluster data from the given file
+func NewFromConfig(filename string, opts ...ScanOption) (*Cluster, error) {
+	var scanOptions ScanOptions
+
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	m, err := decodeConfigData(data)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, opt := range opts {
+		if err = opt(m, &scanOptions); err != nil {
+			return nil, err
+		}
+	}
+
+	if err = m.setScanDefaults(&scanOptions); err != nil {
+		return nil, err
+	}
+
+	if err := m.init(&scanOptions); err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}

pkg/cluster/cluster_scan.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"io/fs"
@@ -7,7 +7,7 @@ import (
 	"darvaza.org/core"
 )
 
-func (m *Zones) scan(opts *ScanOptions) error {
+func (m *Cluster) scan(opts *ScanOptions) error {
 	for _, fn := range []func(*ScanOptions) error{
 		m.scanDirectory,
 		m.scanMachines,
@@ -24,7 +24,7 @@ func (m *Zones) scan(opts *ScanOptions) error {
 	return nil
 }
 
-func (m *Zones) scanDirectory(_ *ScanOptions) error {
+func (m *Cluster) scanDirectory(_ *ScanOptions) error {
 	// each directory is a zone
 	entries, err := fs.ReadDir(m.dir, ".")
 	if err != nil {
@@ -50,7 +50,7 @@ func (m *Zones) scanDirectory(_ *ScanOptions) error {
 	return nil
 }
 
-func (m *Zones) newZone(name string) (*Zone, error) {
+func (m *Cluster) newZone(name string) (*Zone, error) {
 	z := &Zone{
 		zones:  m,
 		logger: m,
@@ -67,7 +67,7 @@ func (m *Zones) newZone(name string) (*Zone, error) {
 	return z, nil
 }
 
-func (m *Zones) scanMachines(opts *ScanOptions) error {
+func (m *Cluster) scanMachines(opts *ScanOptions) error {
 	var err error
 	m.ForEachMachine(func(p *Machine) bool {
 		err = p.scan(opts)
@@ -76,7 +76,7 @@ func (m *Zones) scanMachines(opts *ScanOptions) error {
 	return err
 }
 
-func (m *Zones) scanZoneIDs(_ *ScanOptions) error {
+func (m *Cluster) scanZoneIDs(_ *ScanOptions) error {
 	var hasMissing bool
 	var lastZoneID int
 
@@ -106,7 +106,7 @@ func (m *Zones) scanZoneIDs(_ *ScanOptions) error {
 	return nil
 }
 
-func (m *Zones) scanSort(_ *ScanOptions) error {
+func (m *Cluster) scanSort(_ *ScanOptions) error {
 	sort.SliceStable(m.Zones, func(i, j int) bool {
 		id1 := m.Zones[i].ID
 		id2 := m.Zones[j].ID
@@ -132,7 +132,7 @@ func (m *Zones) scanSort(_ *ScanOptions) error {
 	return nil
 }
 
-func (m *Zones) scanGateways(_ *ScanOptions) error {
+func (m *Cluster) scanGateways(_ *ScanOptions) error {
 	var err error
 
 	m.ForEachZone(func(z *Zone) bool {

pkg/cluster/cluster_scan_options.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"io/fs"
@@ -6,12 +6,10 @@ import (
 
 	"darvaza.org/resolver"
 	"darvaza.org/slog"
-	"darvaza.org/slog/handlers/discard"
-	"github.com/hack-pad/hackpadfs/os"
 )
 
 // A ScanOption pre-configures the Zones before scanning
-type ScanOption func(*Zones, *ScanOptions) error
+type ScanOption func(*Cluster, *ScanOptions) error
 
 // ScanOptions contains flags used by the initial scan
 type ScanOptions struct {
@@ -29,7 +27,7 @@ type ScanOptions struct {
 // the DNS resolver to get PublicAddresses of nodes.
 // Default is true
 func ResolvePublicAddresses(resolve bool) ScanOption {
-	return func(m *Zones, opt *ScanOptions) error {
+	return func(m *Cluster, opt *ScanOptions) error {
 		opt.DontResolvePublicAddresses = !resolve
 		return nil
 	}
@@ -38,7 +36,7 @@ func ResolvePublicAddresses(resolve bool) ScanOption {
 // WithLookuper specifies what resolver.Lookuper to use to
 // find public addresses
 func WithLookuper(h resolver.Lookuper) ScanOption {
-	return func(m *Zones, opt *ScanOptions) error {
+	return func(m *Cluster, opt *ScanOptions) error {
 		if h == nil {
 			return fs.ErrInvalid
 		}
@@ -51,7 +49,7 @@ func WithLookuper(h resolver.Lookuper) ScanOption {
 // public addresses. if nil is passed, the [net.Resolver] will be used.
 // The default is using Cloudflare's 1.1.1.1.
 func WithResolver(h resolver.Resolver) ScanOption {
-	return func(m *Zones, opt *ScanOptions) error {
+	return func(m *Cluster, opt *ScanOptions) error {
 		if h == nil {
 			h = resolver.SystemResolver(true)
 		}
@@ -63,9 +61,9 @@ func WithResolver(h resolver.Resolver) ScanOption {
 
 // WithLogger specifies what to use for logging
 func WithLogger(log slog.Logger) ScanOption {
-	return func(m *Zones, opt *ScanOptions) error {
+	return func(m *Cluster, opt *ScanOptions) error {
 		if log == nil {
-			log = discard.New()
+			log = DefaultLogger()
 		}
 
 		opt.Logger = log
@@ -74,9 +72,9 @@ func WithLogger(log slog.Logger) ScanOption {
 	}
 }
 
-func (m *Zones) setDefaults(opt *ScanOptions) error {
+func (m *Cluster) setScanDefaults(opt *ScanOptions) error {
 	if m.resolver == nil {
-		h := resolver.NewCloudflareLookuper()
+		h := DefaultLookuper()
 
 		if err := WithLookuper(h)(m, opt); err != nil {
 			return err
@@ -92,43 +90,41 @@ func (m *Zones) setDefaults(opt *ScanOptions) error {
 	return nil
 }
 
-// NewFS builds a [Zones] tree using the given directory
-func NewFS(dir fs.FS, domain string, opts ...ScanOption) (*Zones, error) {
+// NewFromDirectory builds a [Cluster] tree using the given directory
+func NewFromDirectory(dir, domain string, opts ...ScanOption) (*Cluster, error) {
 	var scanOptions ScanOptions
 
-	z := &Zones{
-		dir:    dir,
-		domain: domain,
+	dir = filepath.Clean(dir)
+	fullPath, err := filepath.Abs(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	sub, err := DirFS(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	m := &Cluster{
+		dir:     sub,
+		BaseDir: dir,
+		Name:    filepath.Base(fullPath),
+		Domain:  domain,
 	}
 
 	for _, opt := range opts {
-		if err := opt(z, &scanOptions); err != nil {
+		if err := opt(m, &scanOptions); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := z.setDefaults(&scanOptions); err != nil {
+	if err := m.setScanDefaults(&scanOptions); err != nil {
 		return nil, err
 	}
 
-	if err := z.scan(&scanOptions); err != nil {
+	if err := m.scan(&scanOptions); err != nil {
 		return nil, err
 	}
 
-	return z, nil
-}
-
-// New builds a [Zones] tree using the given directory
-func New(dir, domain string, opts ...ScanOption) (*Zones, error) {
-	dir, err := filepath.Abs(dir)
-	if err != nil {
-		return nil, err
-	}
-
-	base, err := os.NewFS().Sub(dir[1:])
-	if err != nil {
-		return nil, err
-	}
-
-	return NewFS(base, domain, opts...)
+	return m, nil
 }

pkg/cluster/defaults.go

@@ -0,0 +1,17 @@
+package cluster
+
+import (
+	"darvaza.org/resolver"
+	"darvaza.org/slog"
+	"darvaza.org/slog/handlers/discard"
+)
+
+// DefaultLogger returns a logger that doesn't log anything
+func DefaultLogger() slog.Logger {
+	return discard.New()
+}
+
+// DefaultLookuper returns a [resolver.Lookuper] using Cloudflare's 1.1.1.1
+func DefaultLookuper() resolver.Lookuper {
+	return resolver.NewCloudflareLookuper()
+}

pkg/cluster/env.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"bytes"
@@ -16,7 +16,7 @@ type Env struct {
 }
 
 // Env returns a shell environment factory
-func (m *Zones) Env(export bool) (*Env, error) {
+func (m *Cluster) Env(export bool) (*Env, error) {
 	fsid, err := m.GetCephFSID()
 	if err != nil {
 		return nil, err

pkg/cluster/errors.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import "errors"
 

pkg/cluster/hosts.go

@@ -0,0 +1,128 @@
+package cluster
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"text/template"
+)
+
+type hostsFile struct {
+	Ring0 []hostsEntry
+	Ring1 []hostsEntry
+}
+
+type hostsEntry struct {
+	Addr  string
+	Names []string
+}
+
+var hostsTemplate = template.Must(template.New("hosts").Funcs(template.FuncMap{
+	"StringsJoin": strings.Join,
+}).Parse(`127.0.0.1 localhost
+
+# The following lines are desirable for IPv6 capable hosts
+::1     ip6-localhost ip6-loopback
+fe00::0 ip6-localnet
+ff00::0 ip6-mcastprefix
+ff02::1 ip6-allnodes
+ff02::2 ip6-allrouters
+ff02::3 ip6-allhosts
+
+{{range .Ring1 -}}
+{{.Addr}}  {{StringsJoin .Names " "}}
+{{end}}
+{{range .Ring0 -}}
+{{.Addr}}  {{StringsJoin .Names " "}}
+{{end -}}
+`))
+
+// WriteHosts rewrites all hosts files on the tree
+func (m *Cluster) WriteHosts() error {
+	var err error
+
+	m.ForEachZone(func(z *Zone) bool {
+		err = z.WriteHosts()
+		return err != nil
+	})
+
+	return err
+}
+
+// WriteHosts rewrites all hosts files in the zone
+func (z *Zone) WriteHosts() error {
+	var err error
+
+	s := z.Hosts()
+	z.ForEachMachine(func(p *Machine) bool {
+		err = p.WriteStringFile(s, "hosts")
+		return err != nil
+	})
+
+	return err
+}
+
+// WriteHosts rewrites the hosts file
+func (p *Machine) WriteHosts() error {
+	s := p.zone.Hosts()
+	return p.WriteStringFile(s, "hosts")
+}
+
+func (z *Zone) genHosts(out *hostsFile, p *Machine) {
+	var names []string
+
+	ip, _ := RingOneAddress(p.zone.ID, p.ID)
+	names = append(names, p.Name)
+
+	if p.CephMonitor {
+		names = append(names, fmt.Sprintf("%s-%s", p.zone.Name, "ceph"))
+		names = append(names, fmt.Sprintf("%s-%s", p.zone.Name, "k3s"))
+
+		if z.ID == p.zone.ID {
+			names = append(names, "ceph")
+			names = append(names, "k3s")
+		}
+	}
+
+	entry := hostsEntry{
+		Addr:  ip.String(),
+		Names: names,
+	}
+
+	out.Ring1 = append(out.Ring1, entry)
+
+	if p.IsGateway() {
+		var s string
+
+		ip, _ = RingZeroAddress(p.zone.ID, p.ID)
+		s = fmt.Sprintf("%s-%v", p.Name, 0)
+
+		entry = hostsEntry{
+			Addr:  ip.String(),
+			Names: []string{s},
+		}
+
+		out.Ring0 = append(out.Ring0, entry)
+	}
+}
+
+// Hosts renders the /etc/hosts to be used on this zone
+func (z *Zone) Hosts() string {
+	var buf bytes.Buffer
+	var out hostsFile
+
+	z.zones.ForEachZone(func(z2 *Zone) bool {
+		z2.ForEachMachine(func(p *Machine) bool {
+			z.genHosts(&out, p)
+
+			return false
+		})
+		return false
+	})
+
+	if err := hostsTemplate.Execute(&buf, &out); err != nil {
+		panic(err)
+	}
+
+	return buf.String()
+}

pkg/cluster/log.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import "darvaza.org/slog"
 
@@ -13,26 +13,26 @@ type logger interface {
 }
 
 var (
-	_ logger = (*Zones)(nil)
+	_ logger = (*Cluster)(nil)
 )
 
-func (z *Zones) withDebug() (slog.Logger, bool) {
+func (z *Cluster) withDebug() (slog.Logger, bool) {
 	return z.debug().WithEnabled()
 }
 
-func (z *Zones) withInfo() (slog.Logger, bool) {
+func (z *Cluster) withInfo() (slog.Logger, bool) {
 	return z.debug().WithEnabled()
 }
 
-func (z *Zones) debug() slog.Logger {
+func (z *Cluster) debug() slog.Logger {
 	return z.log.Debug()
 }
 
-func (z *Zones) info() slog.Logger {
+func (z *Cluster) info() slog.Logger {
 	return z.log.Info()
 }
 
-func (z *Zones) warn(err error) slog.Logger {
+func (z *Cluster) warn(err error) slog.Logger {
 	l := z.log.Warn()
 	if err != nil {
 		l = l.WithField(slog.ErrorFieldName, err)
@@ -40,7 +40,7 @@ func (z *Zones) warn(err error) slog.Logger {
 	return l
 }
 
-func (z *Zones) error(err error) slog.Logger {
+func (z *Cluster) error(err error) slog.Logger {
 	l := z.log.Error()
 	if err != nil {
 		l = l.WithField(slog.ErrorFieldName, err)

pkg/cluster/machine.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"net/netip"
@@ -28,16 +28,19 @@ func (m *Machine) String() string {
 
 // FullName returns the Name of the machine including domain name
 func (m *Machine) FullName() string {
-	if domain := m.zone.zones.domain; domain != "" {
-		var s = []string{
-			m.Name,
-			domain,
-		}
+	var name []string
 
-		return strings.Join(s, ".")
+	for _, s := range []string{
+		m.Name,
+		m.zone.zones.Name,
+		m.zone.zones.Domain,
+	} {
+		if s != "" {
+			name = append(name, s)
+		}
 	}
 
-	return m.Name
+	return strings.Join(name, ".")
 }
 
 // IsGateway tells if the Machine is a ring0 gateway

pkg/cluster/machine_file.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"bytes"

pkg/cluster/machine_rings.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"bytes"

pkg/cluster/machine_scan.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"context"

pkg/cluster/machines.go

@@ -0,0 +1,69 @@
+package cluster
+
+import "sort"
+
+var (
+	_ MachineIterator = Machines(nil)
+	_ sort.Interface  = Machines(nil)
+)
+
+// A MachineIterator is a set of Machines we can iterate on
+type MachineIterator interface {
+	ForEachMachine(func(*Machine) bool)
+}
+
+// Machines is a list of Machine objects
+type Machines []*Machine
+
+// ForEachMachine calls a function for each Machine in the list
+// until instructed to terminate the loop
+func (m Machines) ForEachMachine(fn func(*Machine) bool) {
+	for _, p := range m {
+		if fn(p) {
+			return
+		}
+	}
+}
+
+// Len returns the number of machines in the list
+func (m Machines) Len() int {
+	return len(m)
+}
+
+// Less implements sort.Interface to sort the list
+func (m Machines) Less(i, j int) bool {
+	a, b := m[i], m[j]
+	za, zb := a.Zone(), b.Zone()
+
+	switch {
+	case za == zb:
+		return a.ID < b.ID
+	default:
+		return za < zb
+	}
+}
+
+// Swap implements sort.Interface to sort the list
+func (m Machines) Swap(i, j int) {
+	m[i], m[j] = m[j], m[i]
+}
+
+// FilterMachines produces a subset of the machines offered by the given
+// iterator fulfilling a condition
+func FilterMachines(m MachineIterator, cond func(*Machine) bool) (Machines, int) {
+	var out []*Machine
+
+	if cond == nil {
+		// unconditional
+		cond = func(*Machine) bool { return true }
+	}
+
+	m.ForEachMachine(func(p *Machine) bool {
+		if cond(p) {
+			out = append(out, p)
+		}
+		return false
+	})
+
+	return out, len(out)
+}

pkg/cluster/rings.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"fmt"

pkg/cluster/sync.go

@@ -1,10 +1,11 @@
-package zones
+package cluster
 
 // SyncAll updates all config files
-func (m *Zones) SyncAll() error {
+func (m *Cluster) SyncAll() error {
 	for _, fn := range []func() error{
 		m.SyncAllWireguard,
 		m.SyncAllCeph,
+		m.WriteHosts,
 	} {
 		if err := fn(); err != nil {
 			return err
@@ -15,7 +16,7 @@ func (m *Zones) SyncAll() error {
 }
 
 // SyncAllWireguard updates all wireguard config files
-func (m *Zones) SyncAllWireguard() error {
+func (m *Cluster) SyncAllWireguard() error {
 	var err error
 
 	for ring := 0; ring < RingsCount; ring++ {
@@ -34,7 +35,7 @@ func (m *Zones) SyncAllWireguard() error {
 }
 
 // SyncAllCeph updates the ceph.conf file
-func (m *Zones) SyncAllCeph() error {
+func (m *Cluster) SyncAllCeph() error {
 	cfg, err := m.GenCephConfig()
 	if err != nil {
 		return err

pkg/cluster/wireguard.go

@@ -1,4 +1,4 @@
-package zones
+package cluster
 
 import (
 	"io/fs"
@@ -6,19 +6,19 @@ import (
 )
 
 var (
-	_ WireguardConfigPruner = (*Zones)(nil)
+	_ WireguardConfigPruner = (*Cluster)(nil)
 	_ WireguardConfigPruner = (*Zone)(nil)
 	_ WireguardConfigPruner = (*Machine)(nil)
 
-	_ WireguardConfigWriter = (*Zones)(nil)
+	_ WireguardConfigWriter = (*Cluster)(nil)
 	_ WireguardConfigWriter = (*Zone)(nil)
 	_ WireguardConfigWriter = (*Machine)(nil)
 
-	_ WireguardConfigSyncer = (*Zones)(nil)
+	_ WireguardConfigSyncer = (*Cluster)(nil)
 	_ WireguardConfigSyncer = (*Zone)(nil)
 	_ WireguardConfigSyncer = (*Machine)(nil)
 
-	_ WireguardKeysWriter = (*Zones)(nil)
+	_ WireguardKeysWriter = (*Cluster)(nil)
 	_ WireguardKeysWriter = (*Zone)(nil)
 	_ WireguardKeysWriter = (*Machine)(nil)
 )
@@ -31,7 +31,7 @@ type WireguardConfigPruner interface {
 
 // PruneWireguardConfig removes wgN.conf files of machines with
 // the corresponding ring disabled on all zones
-func (m *Zones) PruneWireguardConfig(ring int) error {
+func (m *Cluster) PruneWireguardConfig(ring int) error {
 	return pruneWireguardConfig(m, ring)
 }
 
@@ -76,7 +76,7 @@ type WireguardConfigWriter interface {
 
 // WriteWireguardConfig rewrites all wgN.conf on all machines
 // attached to that ring
-func (m *Zones) WriteWireguardConfig(ring int) error {
+func (m *Cluster) WriteWireguardConfig(ring int) error {
 	switch ring {
 	case 0:
 		return writeWireguardConfig(m, m, ring)
@@ -154,7 +154,7 @@ type WireguardConfigSyncer interface {
 
 // SyncWireguardConfig updates all wgN.conf files for the specified
 // ring
-func (m *Zones) SyncWireguardConfig(ring int) error {
+func (m *Cluster) SyncWireguardConfig(ring int) error {
 	switch ring {
 	case 0:
 		return syncWireguardConfig(m, m, ring)
@@ -214,7 +214,7 @@ type WireguardKeysWriter interface {
 }
 
 // WriteWireguardKeys rewrites all wgN.{key,pub} files
-func (m *Zones) WriteWireguardKeys(ring int) error {
+func (m *Cluster) WriteWireguardKeys(ring int) error {
 	return writeWireguardKeys(m, ring)
 }
 

pkg/cluster/zones.go

@@ -0,0 +1,68 @@
+package cluster
+
+import (
+	"io/fs"
+)
+
+var (
+	_ MachineIterator = (*Zone)(nil)
+)
+
+// A ZoneIterator is a set of Zones we can iterate on
+type ZoneIterator interface {
+	ForEachZone(func(*Zone) bool)
+}
+
+// A Zone is a set of machines in close proximity and strong
+// affinity.
+type Zone struct {
+	zones  *Cluster
+	logger `json:"-" yaml:"-"`
+
+	ID   int
+	Name string
+
+	Machines
+}
+
+func (z *Zone) String() string {
+	return z.Name
+}
+
+// SetGateway configures a machine to be the zone's ring0 gateway
+func (z *Zone) SetGateway(gatewayID int, enabled bool) error {
+	var err error
+	var found bool
+
+	z.ForEachMachine(func(p *Machine) bool {
+		if p.ID == gatewayID {
+			found = true
+			err = p.SetGateway(enabled)
+
+			return true
+		}
+		return false
+	})
+
+	switch {
+	case err != nil:
+		return err
+	case !found:
+		return fs.ErrNotExist
+	default:
+		return nil
+	}
+}
+
+// GatewayIDs returns the list of IDs of machines that act as ring0 gateways
+func (z *Zone) GatewayIDs() ([]int, int) {
+	var out []int
+	z.ForEachMachine(func(p *Machine) bool {
+		if p.IsGateway() {
+			out = append(out, p.ID)
+		}
+		return false
+	})
+
+	return out, len(out)
+}

pkg/zones/zones.go

@@ -1,198 +0,0 @@
-// Package zones contains information about the cluster
-package zones
-
-import (
-	"io/fs"
-	"sort"
-
-	"darvaza.org/resolver"
-	"darvaza.org/slog"
-	"github.com/gofrs/uuid/v5"
-)
-
-var (
-	_ MachineIterator = Machines(nil)
-	_ sort.Interface  = Machines(nil)
-
-	_ MachineIterator = (*Zone)(nil)
-	_ MachineIterator = (*Zones)(nil)
-	_ ZoneIterator    = (*Zones)(nil)
-)
-
-// A MachineIterator is a set of Machines we can iterate on
-type MachineIterator interface {
-	ForEachMachine(func(*Machine) bool)
-}
-
-// A ZoneIterator is a set of Zones we can iterate on
-type ZoneIterator interface {
-	ForEachZone(func(*Zone) bool)
-}
-
-// Machines is a list of Machine objects
-type Machines []*Machine
-
-// ForEachMachine calls a function for each Machine in the list
-// until instructed to terminate the loop
-func (m Machines) ForEachMachine(fn func(*Machine) bool) {
-	for _, p := range m {
-		if fn(p) {
-			return
-		}
-	}
-}
-
-// Len returns the number of machines in the list
-func (m Machines) Len() int {
-	return len(m)
-}
-
-// Less implements sort.Interface to sort the list
-func (m Machines) Less(i, j int) bool {
-	a, b := m[i], m[j]
-	za, zb := a.Zone(), b.Zone()
-
-	switch {
-	case za == zb:
-		return a.ID < b.ID
-	default:
-		return za < zb
-	}
-}
-
-// Swap implements sort.Interface to sort the list
-func (m Machines) Swap(i, j int) {
-	m[i], m[j] = m[j], m[i]
-}
-
-// FilterMachines produces a subset of the machines offered by the given
-// iterator fulfilling a condition
-func FilterMachines(m MachineIterator, cond func(*Machine) bool) (Machines, int) {
-	var out []*Machine
-
-	if cond == nil {
-		// unconditional
-		cond = func(*Machine) bool { return true }
-	}
-
-	m.ForEachMachine(func(p *Machine) bool {
-		if cond(p) {
-			out = append(out, p)
-		}
-		return false
-	})
-
-	return out, len(out)
-}
-
-// Zone represents one zone in a cluster
-type Zone struct {
-	zones  *Zones
-	logger `json:"-" yaml:"-"`
-
-	ID   int
-	Name string
-
-	Machines
-}
-
-func (z *Zone) String() string {
-	return z.Name
-}
-
-// SetGateway configures a machine to be the zone's ring0 gateway
-func (z *Zone) SetGateway(gatewayID int, enabled bool) error {
-	var err error
-	var found bool
-
-	z.ForEachMachine(func(p *Machine) bool {
-		if p.ID == gatewayID {
-			found = true
-			err = p.SetGateway(enabled)
-
-			return true
-		}
-		return false
-	})
-
-	switch {
-	case err != nil:
-		return err
-	case !found:
-		return fs.ErrNotExist
-	default:
-		return nil
-	}
-}
-
-// GatewayIDs returns the list of IDs of machines that act as ring0 gateways
-func (z *Zone) GatewayIDs() ([]int, int) {
-	var out []int
-	z.ForEachMachine(func(p *Machine) bool {
-		if p.IsGateway() {
-			out = append(out, p.ID)
-		}
-		return false
-	})
-
-	return out, len(out)
-}
-
-// revive:disable:line-length-limit
-
-// Zones represents all zones in a cluster
-type Zones struct {
-	dir      fs.FS
-	log      slog.Logger
-	resolver resolver.Resolver
-	domain   string
-
-	CephFSID uuid.UUID `json:"ceph_fsid,omitempty" yaml:"ceph_fsid,omitempty"`
-	Zones    []*Zone
-}
-
-// revive:enable:line-length-limit
-
-// ForEachMachine calls a function for each Machine in the cluster
-// until instructed to terminate the loop
-func (m *Zones) ForEachMachine(fn func(*Machine) bool) {
-	m.ForEachZone(func(z *Zone) bool {
-		var term bool
-
-		z.ForEachMachine(func(p *Machine) bool {
-			term = fn(p)
-			return term
-		})
-
-		return term
-	})
-}
-
-// ForEachZone calls a function for each Zone in the cluster
-// until instructed to terminate the loop
-func (m *Zones) ForEachZone(fn func(*Zone) bool) {
-	for _, p := range m.Zones {
-		if fn(p) {
-			// terminate
-			return
-		}
-	}
-}
-
-// GetMachineByName looks for a machine with the specified
-// name on any zone
-func (m *Zones) GetMachineByName(name string) (*Machine, bool) {
-	var out *Machine
-
-	if name != "" {
-		m.ForEachMachine(func(p *Machine) bool {
-			if p.Name == name {
-				out = p
-			}
-
-			return out != nil
-		})
-	}
-
-	return out, out != nil
-}