2 files changed, 219 insertions, 0 deletions
diff --git a/utils/ipam/ipam.go b/utils/ipam/ipam.go
new file mode 100644
index 0000000..d61fa3e
--- /dev/null
+++ b/utils/ipam/ipam.go
@@ -0,0 +1,183 @@
+package ipam
+
+import (
+	"cmp"
+	"fmt"
+	"log"
+	"net/netip"
+	"slices"
+	"utils/ipam/yaml_model"
+)
+
+func LoadIpam(bs []byte) (*Ipam, error) {
+	parsed, err := yaml_model.Parse(bs)
+	if err != nil {
+		return nil, err
+	}
+
+	ipam := Ipam{}
+	err = processNetworks(parsed.Ipam6.Networks, &ipam)
+	if err != nil {
+		return nil, err
+	}
+
+	err = processRouters(parsed.Routers, &ipam)
+	if err != nil {
+		return nil, err
+	}
+
+	ipam.ResolveParents()
+
+	return &ipam, nil
+}
+
+type Ipam struct {
+	Networks []*Network
+	Routers  []*Router
+}
+
+func contains(a, b netip.Prefix) bool {
+	return b.Bits() > a.Bits() && b.Overlaps(a)
+}
+
+func (ipam *Ipam) ResolveParents() {
+	for _, n := range ipam.Networks {
+		log.Printf("network %s/%s", n.Name, n.Prefix)
+		for _, p := range ipam.Networks {
+			if n == p {
+				continue
+			}
+			log.Printf(" candidate %s/%s", p.Name, p.Prefix)
+			if contains(p.Prefix, n.Prefix) {
+				if n.Parent == nil {
+					log.Printf(" found parent %s/%s", p.Name, p.Prefix)
+					n.Parent = p
+				} else {
+					if n.Parent.Prefix.Bits() < p.Prefix.Bits() {
+						log.Printf(" found better parent %s/%s", p.Name, p.Prefix)
+						n.Parent = p
+					}
+				}
+			}
+		}
+	}
+
+	return
+}
+
+func (ipam *Ipam) FindRoots() []*Network {
+	var ns []*Network
+
+	for _, n := range ipam.Networks {
+		if n.Parent == nil {
+			ns = append(ns, n)
+		}
+	}
+
+	return ns
+}
+
+type Network struct {
+	Name   string
+	Parent *Network
+	Prefix netip.Prefix
+	hosts  []networkHost
+}
+
+func CompareNetwork(a, b *Network) int {
+	return cmp.Compare(a.Name, b.Name)
+}
+
+func (n *Network) Compare(other *Network) int {
+	return cmp.Compare(n.Name, other.Name)
+}
+
+type networkHost struct {
+	name    string
+	address netip.Addr
+}
+
+func processNetworks(networks map[string]yaml_model.Network6Yaml, ipam *Ipam) error {
+	var ns []*Network
+
+	for name, net := range networks {
+		log.Printf("Processing net %v\n", name)
+		prefix, err := netip.ParsePrefix(net.Range)
+		if err != nil {
+			return fmt.Errorf("error parsing net range: %v", err)
+		}
+		log.Printf("prefix: %s", prefix.String())
+
+		n := Network{Name: name, Prefix: prefix}
+		for hostname, a := range net.Hosts {
+			addr, err := netip.ParseAddr(a)
+			if err != nil {
+				return fmt.Errorf("network: %s, unable to parse host address %s", n.Name, a)
+			}
+
+			n.hosts = append(n.hosts, networkHost{
+				name:    hostname,
+				address: addr,
+			})
+		}
+
+		ns = append(ns, &n)
+	}
+
+	ipam.Networks = ns
+	return nil
+}
+
+type Router struct {
+	Name  string
+	As    string
+	Peers []Peer
+}
+
+func (r *Router) Compare(other *Router) int {
+	return cmp.Compare(r.Name, other.Name)
+}
+
+type Peer struct {
+	Name string
+	/// Router is set if this is a known peer
+	Router *Router
+
+	As string
+}
+
+func processRouters(routers map[string]yaml_model.Router, ipam *Ipam) error {
+	var rs []*Router
+	rsIndex := make(map[string]*Router)
+	for name, router := range routers {
+		r := &Router{
+			Name: name,
+			As:   router.As,
+		}
+
+		rs = append(rs, r)
+		rsIndex[name] = r
+	}
+
+	for _, r := range rs {
+		router := routers[r.Name]
+
+		for name, peer := range router.Peers {
+			remote := rsIndex[name]
+
+			r.Peers = append(r.Peers, Peer{
+				Name:   name,
+				Router: remote,
+				As:     peer.As,
+			})
+		}
+	}
+
+	compare := func(a *Router, b *Router) int {
+		return a.Compare(b)
+	}
+
+	ipam.Routers = slices.SortedStableFunc(slices.Values(rs), compare)
+
+	return nil
+}
diff --git a/utils/ipam/yaml_model/yaml_model.go b/utils/ipam/yaml_model/yaml_model.go
new file mode 100644
index 0000000..4109e12
--- /dev/null
+++ b/utils/ipam/yaml_model/yaml_model.go
@@ -0,0 +1,36 @@
+package yaml_model
+
+import "gopkg.in/yaml.v3"
+
+type Ipam struct {
+	Ipam6   Ipam6             `yaml:"ipam6,omitempty"`
+	Routers map[string]Router `yaml:"routers,omitempty"`
+}
+
+type Ipam6 struct {
+	Networks map[string]Network6Yaml `yaml:"networks"`
+}
+
+type Network6Yaml struct {
+	Range string            `yaml:"range"`
+	Hosts map[string]string `yaml:"hosts"`
+}
+
+type Router struct {
+	As    string          `yaml:"as,omitempty"`
+	Peers map[string]Peer `yaml:"peers,omitempty"`
+}
+
+type Peer struct {
+	As string `yaml:"as"`
+}
+
+func Parse(bs []byte) (Ipam, error) {
+	var ipam Ipam
+	err := yaml.Unmarshal(bs, &ipam)
+	if err != nil {
+		return Ipam{}, err
+	}
+
+	return ipam, nil
+}