two/internal/dhcpd/store.go

257 lines
5.2 KiB
Go

package dhcpd
import (
"errors"
"fmt"
"net"
"sort"
"sync"
"git.g3e.fr/syonad/two/pkg/db/statefile"
)
var (
ErrNoMAC = errors.New("host mac is required")
ErrNotConfigured = errors.New("subnet is not configured")
)
type diskSubnet struct {
Network string `json:"network"`
InterfaceIP string `json:"interface_ip"`
VPCRoute string `json:"vpc_route,omitempty"`
DefaultGateway string `json:"default_gateway,omitempty"`
MTU int `json:"mtu,omitempty"`
}
type diskHost struct {
MAC string `json:"mac"`
IP string `json:"ip"`
VM string `json:"vm,omitempty"`
DefaultRoute bool `json:"default_route"`
}
type diskState struct {
Subnet *diskSubnet `json:"subnet,omitempty"`
Hosts []diskHost `json:"hosts"`
}
type Store struct {
mu sync.RWMutex
file *statefile.File[diskState]
subnet SubnetConfig
configured bool
hosts map[string]Host
}
func NewStore(path string) *Store {
return &Store{
file: statefile.New[diskState](path),
hosts: make(map[string]Host),
}
}
func (s *Store) Path() string {
return s.file.Path()
}
func (s *Store) Load() error {
state, err := s.file.Load()
if err != nil {
return err
}
subnet := SubnetConfig{}
configured := false
if state.Subnet != nil {
parsed, err := subnetFromDisk(*state.Subnet)
if err != nil {
return err
}
subnet = parsed
configured = true
}
hosts := make(map[string]Host, len(state.Hosts))
for _, h := range state.Hosts {
host, err := hostFromDisk(h)
if err != nil {
return err
}
hosts[host.MAC.String()] = host
}
s.mu.Lock()
defer s.mu.Unlock()
s.subnet = subnet
s.configured = configured
s.hosts = hosts
return nil
}
func subnetFromDisk(d diskSubnet) (SubnetConfig, error) {
_, network, err := net.ParseCIDR(d.Network)
if err != nil {
return SubnetConfig{}, fmt.Errorf("invalid network %q: %w", d.Network, err)
}
interfaceIP := net.ParseIP(d.InterfaceIP)
if interfaceIP == nil {
return SubnetConfig{}, ErrNoInterfaceIP
}
c := SubnetConfig{Network: network, InterfaceIP: interfaceIP, MTU: d.MTU}
if d.VPCRoute != "" {
if _, c.VPCRoute, err = net.ParseCIDR(d.VPCRoute); err != nil {
return SubnetConfig{}, fmt.Errorf("invalid vpc route %q: %w", d.VPCRoute, err)
}
}
if d.DefaultGateway != "" {
if c.DefaultGateway = net.ParseIP(d.DefaultGateway); c.DefaultGateway == nil {
return SubnetConfig{}, fmt.Errorf("invalid default gateway %q", d.DefaultGateway)
}
}
return c, nil
}
func hostFromDisk(d diskHost) (Host, error) {
mac, err := net.ParseMAC(d.MAC)
if err != nil {
return Host{}, fmt.Errorf("invalid mac %q: %w", d.MAC, err)
}
ip := net.ParseIP(d.IP)
if ip == nil {
return Host{}, fmt.Errorf("invalid host ip %q", d.IP)
}
return Host{MAC: mac, IP: ip, VM: d.VM, DefaultRoute: d.DefaultRoute}, nil
}
func (s *Store) SetSubnet(c SubnetConfig) error {
if c.Network == nil {
return ErrNoNetwork
}
if c.InterfaceIP == nil {
return ErrNoInterfaceIP
}
s.mu.Lock()
defer s.mu.Unlock()
previous, wasConfigured := s.subnet, s.configured
s.subnet, s.configured = c, true
if err := s.persist(); err != nil {
s.subnet, s.configured = previous, wasConfigured
return err
}
return nil
}
func (s *Store) SetHost(h Host) error {
if len(h.MAC) == 0 {
return ErrNoMAC
}
if h.IP == nil {
return ErrNoHostIP
}
key := h.MAC.String()
s.mu.Lock()
defer s.mu.Unlock()
previous, existed := s.hosts[key]
s.hosts[key] = h
if err := s.persist(); err != nil {
if existed {
s.hosts[key] = previous
} else {
delete(s.hosts, key)
}
return err
}
return nil
}
func (s *Store) DelHost(mac net.HardwareAddr) error {
if len(mac) == 0 {
return ErrNoMAC
}
key := mac.String()
s.mu.Lock()
defer s.mu.Unlock()
previous, existed := s.hosts[key]
delete(s.hosts, key)
if err := s.persist(); err != nil {
if existed {
s.hosts[key] = previous
}
return err
}
return nil
}
func (s *Store) Lookup(mac net.HardwareAddr) (Host, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
h, ok := s.hosts[mac.String()]
return h, ok
}
func (s *Store) Subnet() (SubnetConfig, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
return s.subnet, s.configured
}
func (s *Store) Hosts() []Host {
s.mu.RLock()
defer s.mu.RUnlock()
return s.sortedHosts()
}
func (s *Store) sortedHosts() []Host {
hosts := make([]Host, 0, len(s.hosts))
for _, h := range s.hosts {
hosts = append(hosts, h)
}
sort.Slice(hosts, func(i, j int) bool { return hosts[i].MAC.String() < hosts[j].MAC.String() })
return hosts
}
func (s *Store) persist() error {
state := diskState{Hosts: make([]diskHost, 0, len(s.hosts))}
if s.configured {
sub := diskSubnet{
Network: s.subnet.Network.String(),
InterfaceIP: s.subnet.InterfaceIP.String(),
MTU: s.subnet.MTU,
}
if s.subnet.VPCRoute != nil {
sub.VPCRoute = s.subnet.VPCRoute.String()
}
if s.subnet.DefaultGateway != nil {
sub.DefaultGateway = s.subnet.DefaultGateway.String()
}
state.Subnet = &sub
}
for _, h := range s.sortedHosts() {
state.Hosts = append(state.Hosts, diskHost{
MAC: h.MAC.String(),
IP: h.IP.String(),
VM: h.VM,
DefaultRoute: h.DefaultRoute,
})
}
return s.file.Save(state)
}