wgipam

type Family int

type HTTPHandler struct {
	// contains filtered or unexported fields
}

type Handler struct {
	// Leases specifies a Store for Lease storage. Leases must be non-nil or
	// the Handler will panic.
	Leases LeaseStore

	// IPs specifies an IPAllocator for allocating and freeing client addresses.
	// IPs must be non-nil or the Handler will panic.
	IPs IPAllocator

	// LeaseDuration specifies the amount of time leases may exist before they
	// expire and are purged.
	LeaseDuration time.Duration

	// Log specifies a logger for the Server. If nil, all logs are discarded.
	Log *log.Logger

	// Metrics specifies Prometheus metrics for the Handler. If nil, metrics
	// are not collected.
	Metrics *HandlerMetrics

	// NewRequest specifies an optional hook which will be invoked when a new
	// request is received. The source address src of the remote client is
	// passed to NewRequest. If NewRequest is nil, it is a no-op.
	NewRequest func(src net.Addr)
}

type HandlerMetrics struct {
	RequestsTotal *prometheus.CounterVec
	ErrorsTotal   *prometheus.CounterVec
}

type IPAllocator interface {
	// Allocate allocates an available IP address from each underlying subnet
	// which matches the input Family. It returns false if one or more of the
	// subnets ran out of IP addresses during allocation.
	Allocate(family Family) (ips []*net.IPNet, ok bool, err error)

	// Free returns an allocated IP address to the IPAllocator. Free operations
	// should be idempotent; that is, an error should only be returned if the
	// free operation fails. Attempting to free an IP that did not already exist
	// should not return an error.
	Free(ip *net.IPNet) error
}

type IPStore interface {
	// Subnets returns all existing subnets. Note that the order of the subnets
	// is unspecified. The caller must sort the leases for deterministic output.
	Subnets() (subnets []*net.IPNet, err error)

	// SaveSubnet creates or updates a Subnet by its CIDR value.
	SaveSubnet(subnet *net.IPNet) error

	// AllocatedIPs returns all of the IP addresses allocated within a specific
	// subnet. Note that the order of the addresses is unspecified. The caller
	// must sort the addresses for deterministic output.
	AllocatedIPs(subnet *net.IPNet) (ips []*net.IPNet, err error)

	// AllocateIP allocates an IP address from the specified subnet. It returns
	// false if the address is already allocated from the subnet, and returns an
	// error if the subnet does not exist.
	AllocateIP(subnet, ip *net.IPNet) (ok bool, err error)

	// FreeIP frees an allocated IP address in the specified subnet. FreeIP
	// operations should be idempotent; the same rules apply as with DeleteLease.
	// It returns an error if the subnet does not exist.
	FreeIP(subnet, ip *net.IPNet) error
}

type Lease struct {
	IPs    []*net.IPNet
	Start  time.Time
	Length time.Duration
}

type LeaseStore interface {
	// Leases returns all existing Leases. Note that the order of the Leases
	// is unspecified. The caller must sort the leases for deterministic output.
	Leases() (leases []*Lease, err error)

	// Lease returns the Lease identified by key. It returns false if no
	// Lease exists for key.
	Lease(key uint64) (lease *Lease, ok bool, err error)

	// SaveLease creates or updates a Lease by key.
	SaveLease(key uint64, lease *Lease) error

	// DeleteLease deletes a Lease by key. Delete operations should be idempotent;
	// that is, an error should only be returned if the delete operation fails.
	// Attempting to delete an item that did not already exist should not
	// return an error.
	DeleteLease(key uint64) error
}

type PurgeStats struct {
	// FreedIPs contains a map of subnet CIDRs to the number of IP addresses
	// that were freed within that subnet.
	FreedIPs map[string]int
}

type Store interface {
	// Close syncs and closes the Store's internal state.
	io.Closer

	// Purge purge Leases which expire on or before the specified point in time,
	// and frees the IP addresses associated with the leases.
	// Purge operations that specify the same point in time should be
	// idempotent; the same rules apply as with DeleteLease.
	Purge(t time.Time) (*PurgeStats, error)

	LeaseStore
	IPStore
}

type Subnet struct {
	Subnet     net.IPNet
	Start, End net.IP
	Reserved   []net.IP
}