ipamapi

type AllocatedPool struct {
	// PoolID represents the ID of the allocated pool. Its value is opaque and
	// shouldn't be interpreted by anything but the IPAM driver that generated
	// it.
	PoolID string
	// Pool is the allocated prefix.
	Pool netip.Prefix
	// Meta represents a list of extra IP addresses automatically reserved
	// during the pool allocation. These are generally keyed by well-known
	// strings defined in the netlabel package.
	Meta map[string]string
}

type Capability struct {
	// Whether on address request, libnetwork must
	// specify the endpoint MAC address
	RequiresMACAddress bool
	// Whether of daemon start, libnetwork must replay the pool
	// request and the address request for current local networks
	RequiresRequestReplay bool
}

type Ipam interface {
	// GetDefaultAddressSpaces returns the default local and global address spaces for this ipam
	GetDefaultAddressSpaces() (string, string, error)
	// RequestPool allocate an address pool either statically or dynamically
	// based on req.
	RequestPool(req PoolRequest) (AllocatedPool, error)
	// ReleasePool releases the address pool identified by the passed id
	ReleasePool(poolID string) error
	// RequestAddress request an address from the specified pool ID. Input options or required IP can be passed.
	RequestAddress(string, net.IP, map[string]string) (*net.IPNet, map[string]string, error)
	// ReleaseAddress releases the address from the specified pool ID.
	ReleaseAddress(string, net.IP) error

	// IsBuiltIn returns true if it is a built-in driver.
	IsBuiltIn() bool
}

type PoolRequest struct {
	// AddressSpace is a mandatory field which denotes which block of pools
	// should be used to make the allocation. This value is opaque, and only
	// the IPAM driver can interpret it. Each driver might support a different
	// set of AddressSpace.
	AddressSpace string
	// Pool is a prefix in CIDR notation. It's non-mandatory. When specified
	// the Pool will be statically allocated. The Pool is used for dynamic
	// address allocation -- except when SubPool is specified.
	Pool string
	// SubPool is a subnet from Pool, in CIDR notation too. It's non-mandatory.
	// When specified, it represents the subnet where addresses will be
	// dynamically allocated. It can't be specified if Pool isn't specified.
	SubPool string
	// Options is a map of opaque k/v passed to the driver. It's non-mandatory.
	// Drivers are free to ignore it.
	Options map[string]string
	// Exclude is a list of prefixes the requester wish to not be dynamically
	// allocated (ie. when Pool isn't specified). It's up to the IPAM driver to
	// take it into account, or totally ignore it. It's required to be sorted.
	Exclude []netip.Prefix
	// V6 indicates which address family should be used to dynamically allocate
	// a prefix (ie. when Pool isn't specified).
	V6 bool
}

type Registerer interface {
	// RegisterIpamDriver provides a way for drivers to dynamically register with libnetwork
	RegisterIpamDriver(name string, driver Ipam) error
	// RegisterIpamDriverWithCapabilities provides a way for drivers to dynamically register with libnetwork and specify capabilities
	RegisterIpamDriverWithCapabilities(name string, driver Ipam, capability *Capability) error
}