ipam

type AllocationResult struct {
	// IP is the allocated IP
	IP netip.Addr

	// IPPoolName is the IPAM pool from which the above IP was allocated from
	IPPoolName Pool

	// CIDRs is a list of all CIDRs to which the IP has direct access to.
	// This is primarily useful if the IP has been allocated out of a VPC
	// subnet range and the VPC provides routing to a set of CIDRs in which
	// the IP is routable.
	CIDRs []netip.Prefix

	// PrimaryMAC is the MAC address of the primary interface. This is useful
	// when the IP is a secondary address of an interface which is
	// represented on the node as a Linux device and all routing of the IP
	// must occur through that master interface.
	PrimaryMAC string

	// GatewayIP is the IP of the gateway which must be used for this IP.
	// If the allocated IP is derived from a VPC, then the gateway
	// represented the gateway of the VPC or VPC subnet.
	GatewayIP netip.Addr

	// ExpirationUUID is the UUID of the expiration timer. This field is
	// only set if AllocateNextWithExpiration is used.
	ExpirationUUID string

	// InterfaceNumber is a field for generically identifying an interface.
	// This is only useful in ENI mode.
	InterfaceNumber string

	// SkipMasquerade indicates whether the datapath should avoid masquerading connections from this IP when the cluster is in tunneling mode.
	SkipMasquerade bool
}

type Allocator interface {
	// Allocate allocates a specific IP or fails
	Allocate(addr netip.Addr, owner string, pool Pool) (*AllocationResult, error)

	// AllocateWithoutSyncUpstream allocates a specific IP without syncing
	// upstream or fails
	AllocateWithoutSyncUpstream(addr netip.Addr, owner string, pool Pool) (*AllocationResult, error)

	// Release releases a previously allocated IP or fails
	Release(addr netip.Addr, pool Pool) error

	// AllocateNext allocates the next available IP or fails if no more IPs
	// are available
	AllocateNext(owner string, pool Pool) (*AllocationResult, error)

	// AllocateNextWithoutSyncUpstream allocates the next available IP without syncing
	// upstream or fails if no more IPs are available
	AllocateNextWithoutSyncUpstream(owner string, pool Pool) (*AllocationResult, error)

	// Dump returns a map of all allocated IPs per pool with the IP represented as key in the
	// map. Dump must also provide a status one-liner to represent the overall status, e.g.
	// number of IPs allocated and overall health information if available.
	Dump() (map[Pool]map[string]string, string)

	// Capacity returns the total IPAM allocator capacity (not the current
	// available).
	Capacity() uint64

	// RestoreFinished marks the status of restoration as done
	RestoreFinished()
}

type ENIMultiPoolAllocatorParams struct {
	Logger *slog.Logger

	IPv4Enabled          bool
	IPv6Enabled          bool
	CiliumNodeUpdateRate time.Duration

	Node           agentK8s.LocalCiliumNodeResource
	LocalNodeStore *node.LocalNodeStore
	CNClient       cilium_v2.CiliumNodeInterface
	JobGroup       job.Group

	Conf        *option.DaemonConfig
	IPMasqAgent *ipmasq.IPMasqAgent
}

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

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

type Family string

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

type K8sEventRegister interface {
	// K8sEventReceived is called to do metrics accounting for received
	// Kubernetes events, as well as calculating timeouts for k8s watcher
	// cache sync.
	K8sEventReceived(apiGroupResourceName string, scope string, action string, valid, equal bool)

	// K8sEventProcessed is called to do metrics accounting for each processed
	// Kubernetes event.
	K8sEventProcessed(scope string, action string, status bool)
}

type Metadata interface {
	GetIPPoolForPod(owner string, family Family) (pool string, err error)
}

type MtuConfiguration interface {
	GetDeviceMTU() int
}

type MultiPoolAllocatorParams struct {
	Logger *slog.Logger

	IPv4Enabled          bool
	IPv6Enabled          bool
	CiliumNodeUpdateRate time.Duration
	PreAllocPools        map[string]string

	Node           agentK8s.LocalCiliumNodeResource
	LocalNodeStore *node.LocalNodeStore
	CNClient       cilium_v2.CiliumNodeInterface
	JobGroup       job.Group

	DB                        *statedb.DB
	PodIPPools                statedb.Table[podippool.LocalPodIPPool]
	OnlyMasqueradeDefaultPool bool
}

type MultiPoolManagerParams struct {
	Logger *slog.Logger

	IPv4Enabled          bool
	IPv6Enabled          bool
	CiliumNodeUpdateRate time.Duration
	PreallocMap          preAllocatePerPool

	Node     agentK8s.LocalCiliumNodeResource
	CNClient cilium_v2.CiliumNodeInterface
	JobGroup job.Group

	PoolsFromResource ciliumv2.PoolsFromResourceFunc

	SkipMasqueradeForPool SkipMasqueradeForPoolFn

	// AllowFirstLastIPs makes CIDR pools include the first and last IPs.
	// Used for ENI prefix delegation where the entire /28 is allocatable.
	AllowFirstLastIPs bool

	// LinearPreAlloc uses a simple inUse + preAlloc formula for demand
	// computation instead of the multi-pool's neededIPCeil rounding. This
	// matches the CRD allocator's calculateNeededIPs behavior and allows
	// the operator to recover exact usage from the demand signal.
	LinearPreAlloc bool
}

type NewIPAMParams struct {
	Logger         *slog.Logger
	NodeAddressing node.Addressing
	AgentConfig    *option.DaemonConfig
	NodeDiscovery  Owner
	LocalNodeStore *node.LocalNodeStore
	K8sEventReg    K8sEventRegister
	NodeResource   agentK8s.LocalCiliumNodeResource
	MTUConfig      MtuConfiguration
	Clientset      client.Clientset
	Metadata       Metadata
	Sysctl         sysctl.Sysctl
	IPMasqAgent    *ipmasq.IPMasqAgent

	JobGroup job.Group

	DB                        *statedb.DB
	PodIPPools                statedb.Table[podippool.LocalPodIPPool]
	OnlyMasqueradeDefaultPool bool
}

type Owner interface {
	// UpdateCiliumNodeResource is called to create/update the CiliumNode
	// resource. The function must block until the custom resource has been
	// created.
	UpdateCiliumNodeResource()
}

type Pool string

type SkipMasqueradeForPoolFn func(Pool) (bool, error)