feat: skip in deleting ips and networks

cheina97 · cheina97 · commit c68bd94c26e8 · 2024-11-29T18:17:21.000+01:00
diff --git a/cmd/ipam/main.go b/cmd/ipam/main.go
@@ -70,9 +70,12 @@ func main() {
 
 	// Server options.
 	cmd.Flags().IntVar(&options.ServerOpts.Port, "port", consts.IpamPort, "The port on which to listen for incoming gRPC requests.")
-	cmd.Flags().DurationVar(&options.ServerOpts.SyncFrequency, "interval", consts.SyncFrequency,
+	cmd.Flags().DurationVar(&options.ServerOpts.SyncFrequency, "sync-interval", consts.SyncInterval,
 		"The interval at which the IPAM will synchronize the IPAM storage.")
 	cmd.Flags().BoolVar(&options.ServerOpts.GraphvizEnabled, "enable-graphviz", false, "Enable the graphviz output for the IPAM.")
+	cmd.Flags().StringSliceVar(&options.ServerOpts.Pools, "pools",
+		[]string{"10.0.0.0/8", "192.168.0.0/16", "172.16.0.0/12"}, "The pools used by the IPAM.",
+	)
 
 	// Leader election flags.
 	cmd.Flags().BoolVar(&options.EnableLeaderElection, "leader-election", false, "Enable leader election for IPAM. "+
@@ -133,9 +136,7 @@ func run(cmd *cobra.Command, _ []string) error {
 		}
 	}
 
-	liqoIPAM, err := ipam.New(ctx, cl, []string{
-		"10.0.0.0/8", "192.168.0.0/16", "172.16.0.0/12",
-	}, &options.ServerOpts)
+	liqoIPAM, err := ipam.New(ctx, cl, options.ServerOpts.Pools, &options.ServerOpts)
 	if err != nil {
 		return err
 	}
diff --git a/cmd/liqo-controller-manager/modules/networking.go b/cmd/liqo-controller-manager/modules/networking.go
@@ -264,7 +264,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien
 				Cidr: nw.Spec.CIDR.String(),
 			})
 			if err != nil {
-				return err
+				return fmt.Errorf("IPAM: %w", err)
 			}
 
 			if res.Available {
@@ -275,7 +275,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien
 					PreAllocated: nw.Spec.PreAllocated,
 				})
 				if err != nil {
-					return err
+					return fmt.Errorf("IPAM: %w", err)
 				}
 			}
 
@@ -286,6 +286,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien
 		if err := cl.Status().Update(ctx, nw); err != nil {
 			return fmt.Errorf("unable to update the reserved network %s: %w", nw.Name, err)
 		}
+		klog.Infof("Updated reserved Network %q status (spec: %s | status: %s)", client.ObjectKeyFromObject(nw), nw.Spec.CIDR, nw.Status.CIDR)
 	}
 
 	klog.Info("Reserved networks initialized")
diff --git a/deployments/liqo/templates/liqo-ipam-deployment.yaml b/deployments/liqo/templates/liqo-ipam-deployment.yaml
@@ -51,7 +51,7 @@ spec:
           args:
             - --pod-name=$(POD_NAME)
             - --port=6000
-            - --interval={{ .Values.ipam.internal.syncInterval }}
+            - --sync-interval={{ .Values.ipam.internal.syncInterval }}
             {{- if $ha }}
             - --leader-election
             - --leader-election-namespace=$(POD_NAMESPACE)
diff --git a/pkg/consts/ipam.go b/pkg/consts/ipam.go
@@ -22,8 +22,8 @@ type NetworkType string
 const (
 	// IpamPort is the port used by the IPAM gRPC server.
 	IpamPort = 6000
-	// SyncFrequency is the frequency at which the IPAM should periodically sync its status.
-	SyncFrequency = 2 * time.Minute
+	// SyncInterval is the frequency at which the IPAM should periodically sync its status.
+	SyncInterval = 2 * time.Minute
 
 	// NetworkNotRemappedLabelKey is the label key used to mark a Network that does not need CIDR remapping.
 	NetworkNotRemappedLabelKey = "ipam.liqo.io/network-not-remapped"
diff --git a/pkg/ipam/core/doc.go b/pkg/ipam/core/doc.go
@@ -13,4 +13,10 @@
 // limitations under the License.
 
 // Package ipamcore provides the core functionality for the IPAM service.
+//
+// The IPAM is organized like a binary tree, where each node represents a network.
+// In order to optimize the network allocation we use buddy mmory allocation alghorithm
+// to allocate networks like they are memory blocks (https://en.wikipedia.org/wiki/Buddy_memory_allocation).
+// When a network is splitted in two, the left child represents the first half of the network, while the right child
+// represents the second half. The splitting is done until the network is splitted in blocks of the desired size.
 package ipamcore
diff --git a/pkg/ipam/core/ipam.go b/pkg/ipam/core/ipam.go
@@ -26,17 +26,17 @@ type Ipam struct {
 }
 
 // NewIpam creates a new IPAM instance.
-func NewIpam(roots []string) (*Ipam, error) {
-	ipamRootsPrefixes := make([]netip.Prefix, len(roots))
-	for i, root := range roots {
+func NewIpam(pools []string) (*Ipam, error) {
+	ipamRootsPrefixes := make([]netip.Prefix, len(pools))
+	for i, root := range pools {
 		ipamRootsPrefixes[i] = netip.MustParsePrefix(root)
 	}
 
 	if err := checkRoots(ipamRootsPrefixes); err != nil {
 		return nil, err
 	}
 
-	ipamRoots := make([]node, len(roots))
+	ipamRoots := make([]node, len(pools))
 	for i := range ipamRootsPrefixes {
 		ipamRoots[i] = newNode(ipamRootsPrefixes[i])
 	}
@@ -173,6 +173,17 @@ func (ipam *Ipam) IsAllocatedIP(prefix netip.Prefix, addr netip.Addr) (bool, err
 	return false, nil
 }
 
+// IsPrefixInRoots checks if the given prefix is contained in the roots.
+// It returns true if the prefix is contained, false otherwise.
+func (ipam *Ipam) IsPrefixInRoots(prefix netip.Prefix) bool {
+	for i := range ipam.roots {
+		if isPrefixChildOf(ipam.roots[i].prefix, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
 // ToGraphviz generates the Graphviz representation of the IPAM structure.
 func (ipam *Ipam) ToGraphviz() error {
 	for i := range ipam.roots {
diff --git a/pkg/ipam/core/net.go b/pkg/ipam/core/net.go
@@ -45,34 +45,47 @@ func checkHostBitsZero(prefix netip.Prefix) error {
 	return nil
 }
 
+// splitNetworkPrefix splits a network prefix into two subnets.
+// It increases the prefix length by one and sets the bit at
+// the new position to 0 or 1 to retrieve the two subnets.
 func splitNetworkPrefix(prefix netip.Prefix) (left, right netip.Prefix) {
+	// We neer to check that the host bits are zero.
 	if err := checkHostBitsZero(prefix); err != nil {
 		panic("Host bits must be zero")
 	}
 
+	// We need to convert the prefix to a byte slice to manipulate it.
 	bin, err := prefix.MarshalBinary()
 	if err != nil {
 		panic(err)
 	}
 
+	// We need to get the mask length to know where to split the prefix.
 	maskLen := bin[len(bin)-1]
 
+	// Since the prefix host bits are zero, we just need to shift
+	// the mask length by one to get the first splitted prefix.
 	left = netip.MustParsePrefix(
 		fmt.Sprintf("%s/%d", convertByteSliceToString(bin[:4]), maskLen+1),
 	)
 
+	// We need to set the bit at the mask length position to 1 to get the second splitted prefix.
+	// Since the IP is expressed like a slice of bytes, we need to get the byte index and the bit index to set the bit.
 	byteIndex := maskLen / 8
 	bitIndex := maskLen % 8
 
+	// We set the bit at the mask length position to 1.
 	bin[byteIndex] = setBit(bin[byteIndex], bitIndex)
 
+	// We forge and return the second splitted prefix.
 	right = netip.MustParsePrefix(
 		fmt.Sprintf("%s/%d", convertByteSliceToString(bin[:4]), maskLen+1),
 	)
 
 	return left, right
 }
 
+// isPrefixChildOf checks if the child prefix is a child of the parent prefix.
 func isPrefixChildOf(parent, child netip.Prefix) bool {
 	if parent.Bits() <= child.Bits() && parent.Overlaps(child) {
 		return true
diff --git a/pkg/ipam/core/node.go b/pkg/ipam/core/node.go
@@ -50,14 +50,14 @@ func allocateNetwork(size int, node *node) *netip.Prefix {
 		return nil
 	}
 	if node.prefix.Bits() == size {
-		if !node.isSplit() {
+		if !node.isSplitted() {
 			node.acquired = true
 			return &node.prefix
 		}
 		return nil
 	}
 
-	if !node.isSplit() {
+	if !node.isSplitted() {
 		node.split()
 	}
 
@@ -81,7 +81,7 @@ func allocateNetworkWithPrefix(prefix netip.Prefix, node *node) *netip.Prefix {
 		return nil
 	}
 
-	if !node.isSplit() {
+	if !node.isSplitted() {
 		node.split()
 	}
 
@@ -157,6 +157,7 @@ func (n *node) ipAcquire() *netip.Addr {
 
 	size := int(math.Pow(2, float64(n.prefix.Addr().BitLen()-n.prefix.Bits())))
 
+	// If the lastip is not initialized, set it to the first address of the prefix.
 	if !n.lastip.IsValid() {
 		n.lastip = n.prefix.Addr()
 	}
@@ -168,6 +169,8 @@ func (n *node) ipAcquire() *netip.Addr {
 	}
 
 	for i := 0; i < size; i++ {
+		// we need to check if the address is contained in the prefix.
+		// If it is not, we need to set it to the first address of the prefix to prevent overflow.
 		if !n.prefix.Contains(addr) {
 			addr = n.prefix.Addr()
 		}
@@ -235,7 +238,7 @@ func search(prefix netip.Prefix, node *node) *node {
 }
 
 func (n *node) split() {
-	if n.isSplit() {
+	if n.isSplitted() {
 		return
 	}
 	left, right := splitNetworkPrefix(n.prefix)
@@ -265,16 +268,16 @@ func (n *node) insert(nd nodeDirection, prefix netip.Prefix) {
 }
 
 func (n *node) bestDirection() (first, second nodeDirection) {
-	if n.left.isSplit() {
+	if n.left.isSplitted() {
 		return leftDirection, rightDirection
 	}
-	if n.right.isSplit() {
+	if n.right.isSplitted() {
 		return rightDirection, leftDirection
 	}
 	return leftDirection, rightDirection
 }
 
-func (n *node) isSplit() bool {
+func (n *node) isSplitted() bool {
 	if n.left != nil && n.right != nil {
 		return true
 	}
diff --git a/pkg/ipam/initialize.go b/pkg/ipam/initialize.go
@@ -25,6 +25,8 @@ import (
 // +kubebuilder:rbac:groups=ipam.liqo.io,resources=networks,verbs=get;list;watch
 
 func (lipam *LiqoIPAM) initialize(ctx context.Context) error {
+	lipam.mutex.Lock()
+	defer lipam.mutex.Unlock()
 	klog.Info("Initializing IPAM")
 
 	if err := lipam.initializeNetworks(ctx); err != nil {
diff --git a/pkg/ipam/ipam.go b/pkg/ipam/ipam.go
@@ -19,6 +19,7 @@ import (
 	"errors"
 	"fmt"
 	"net/netip"
+	"strings"
 	"sync"
 	"time"
 
@@ -90,6 +91,10 @@ func (lipam *LiqoIPAM) IPAcquire(_ context.Context, req *IPAcquireRequest) (*IPA
 		return &IPAcquireResponse{}, fmt.Errorf("failed to parse prefix %q: %w", req.GetCidr(), err)
 	}
 
+	if !lipam.isInPool(prefix) {
+		return nil, fmt.Errorf("prefix %q is not in the pool %q", req.GetCidr(), strings.Join(lipam.opts.Pools, ","))
+	}
+
 	remappedIP, err := lipam.ipAcquire(prefix)
 	if err != nil {
 		return &IPAcquireResponse{}, err
@@ -133,6 +138,10 @@ func (lipam *LiqoIPAM) NetworkAcquire(_ context.Context, req *NetworkAcquireRequ
 		return &NetworkAcquireResponse{}, fmt.Errorf("failed to parse prefix %q: %w", req.GetCidr(), err)
 	}
 
+	if !lipam.isInPool(prefix) {
+		return &NetworkAcquireResponse{}, fmt.Errorf("prefix %q is not in the pool %q", req.GetCidr(), strings.Join(lipam.opts.Pools, ","))
+	}
+
 	if req.GetImmutable() {
 		remappedCidr, err = lipam.networkAcquireSpecific(prefix)
 		if err != nil {
@@ -182,6 +191,10 @@ func (lipam *LiqoIPAM) NetworkIsAvailable(_ context.Context, req *NetworkAvailab
 		return &NetworkAvailableResponse{}, fmt.Errorf("failed to parse prefix %q: %w", req.GetCidr(), err)
 	}
 
+	if !lipam.isInPool(prefix) {
+		return &NetworkAvailableResponse{}, fmt.Errorf("prefix %q is not in the pool %q", req.GetCidr(), strings.Join(lipam.opts.Pools, ","))
+	}
+
 	available := lipam.networkIsAvailable(prefix)
 
 	return &NetworkAvailableResponse{Available: available}, nil
diff --git a/pkg/ipam/ips.go b/pkg/ipam/ips.go
@@ -64,10 +64,11 @@ func (lipam *LiqoIPAM) ipAcquireWithAddr(addr netip.Addr, prefix netip.Prefix) e
 func (lipam *LiqoIPAM) ipRelease(addr netip.Addr, prefix netip.Prefix) error {
 	result, err := lipam.IpamCore.IPRelease(prefix, addr)
 	if err != nil {
-		return fmt.Errorf("error freeing IP %q in network %q: %w", addr.String(), prefix.String(), err)
+		return fmt.Errorf("error freeing IP %q (network %q): %w", addr.String(), prefix.String(), err)
 	}
 	if result == nil {
-		return fmt.Errorf("failed to free IP %q (network %q)", addr.String(), prefix.String())
+		klog.Infof("IP %q (network %q) already freed", addr.String(), prefix.String())
+		return nil
 	}
 	klog.Infof("Freed IP %q (network %q)", addr.String(), prefix.String())
 
@@ -93,6 +94,11 @@ func (lipam *LiqoIPAM) listIPsOnCluster(ctx context.Context, cl client.Client) (
 	for i := range ipList.Items {
 		ip := &ipList.Items[i]
 
+		deleting := !ip.GetDeletionTimestamp().IsZero()
+		if deleting {
+			continue
+		}
+
 		address := ip.Status.IP.String()
 		if address == "" {
 			klog.Warningf("IP %q has no address", ip.Name)
diff --git a/pkg/ipam/networks.go b/pkg/ipam/networks.go
@@ -63,7 +63,8 @@ func (lipam *LiqoIPAM) networkAcquireSpecific(prefix netip.Prefix) (*netip.Prefi
 func (lipam *LiqoIPAM) networkRelease(prefix netip.Prefix) error {
 	result := lipam.IpamCore.NetworkRelease(prefix)
 	if result == nil {
-		return fmt.Errorf("failed to free network %q", prefix.String())
+		klog.Infof("Network %q already freed", prefix.String())
+		return nil
 	}
 	klog.Infof("Freed network %q", prefix.String())
 
@@ -92,6 +93,11 @@ func (lipam *LiqoIPAM) listNetworksOnCluster(ctx context.Context, cl client.Clie
 	for i := range networks.Items {
 		net := &networks.Items[i]
 
+		deleting := !net.GetDeletionTimestamp().IsZero()
+		if deleting {
+			continue
+		}
+
 		cidr := net.Status.CIDR.String()
 		if cidr == "" {
 			continue
@@ -107,3 +113,8 @@ func (lipam *LiqoIPAM) listNetworksOnCluster(ctx context.Context, cl client.Clie
 
 	return result, nil
 }
+
+// isInPool checks if a prefix is contained in the prefixes pool used by the ipam as roots.
+func (lipam *LiqoIPAM) isInPool(prefix netip.Prefix) bool {
+	return lipam.IpamCore.IsPrefixInRoots(prefix)
+}
diff --git a/pkg/ipam/sync.go b/pkg/ipam/sync.go

Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien`
`264`	`264`	`Cidr: nw.Spec.CIDR.String(),`
`265`	`265`	`})`
`266`	`266`	`if err != nil {`
`267`		`- return err`
	`267`	`+ return fmt.Errorf("IPAM: %w", err)`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`if res.Available {`
`@@ -275,7 +275,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien`
`275`	`275`	`PreAllocated: nw.Spec.PreAllocated,`
`276`	`276`	`})`
`277`	`277`	`if err != nil {`
`278`		`- return err`
	`278`	`+ return fmt.Errorf("IPAM: %w", err)`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`@@ -286,6 +286,7 @@ func initializeReservedNetworks(ctx context.Context, cl client.Client, ipamClien`
`286`	`286`	`if err := cl.Status().Update(ctx, nw); err != nil {`
`287`	`287`	`return fmt.Errorf("unable to update the reserved network %s: %w", nw.Name, err)`
`288`	`288`	`}`
	`289`	`+ klog.Infof("Updated reserved Network %q status (spec: %s \| status: %s)", client.ObjectKeyFromObject(nw), nw.Spec.CIDR, nw.Status.CIDR)`
`289`	`290`	`}`
`290`	`291`
`291`	`292`	`klog.Info("Reserved networks initialized")`
Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,14 @@ func allocateNetwork(size int, node node) netip.Prefix {`
`50`	`50`	`return nil`
`51`	`51`	`}`
`52`	`52`	`if node.prefix.Bits() == size {`
`53`		`- if !node.isSplit() {`
	`53`	`+ if !node.isSplitted() {`
`54`	`54`	`node.acquired = true`
`55`	`55`	`return &node.prefix`
`56`	`56`	`}`
`57`	`57`	`return nil`
`58`	`58`	`}`
`59`	`59`
`60`		`- if !node.isSplit() {`
	`60`	`+ if !node.isSplitted() {`
`61`	`61`	`node.split()`
`62`	`62`	`}`
`63`	`63`
`@@ -81,7 +81,7 @@ func allocateNetworkWithPrefix(prefix netip.Prefix, node node) netip.Prefix {`
`81`	`81`	`return nil`
`82`	`82`	`}`
`83`	`83`
`84`		`- if !node.isSplit() {`
	`84`	`+ if !node.isSplitted() {`
`85`	`85`	`node.split()`
`86`	`86`	`}`
`87`	`87`
`@@ -157,6 +157,7 @@ func (n node) ipAcquire() netip.Addr {`
`157`	`157`
`158`	`158`	`size := int(math.Pow(2, float64(n.prefix.Addr().BitLen()-n.prefix.Bits())))`
`159`	`159`
	`160`	`+ // If the lastip is not initialized, set it to the first address of the prefix.`
`160`	`161`	`if !n.lastip.IsValid() {`
`161`	`162`	`n.lastip = n.prefix.Addr()`
`162`	`163`	`}`
`@@ -168,6 +169,8 @@ func (n node) ipAcquire() netip.Addr {`
`168`	`169`	`}`
`169`	`170`
`170`	`171`	`for i := 0; i < size; i++ {`
	`172`	`+ // we need to check if the address is contained in the prefix.`
	`173`	`+ // If it is not, we need to set it to the first address of the prefix to prevent overflow.`
`171`	`174`	`if !n.prefix.Contains(addr) {`
`172`	`175`	`addr = n.prefix.Addr()`
`173`	`176`	`}`
`@@ -235,7 +238,7 @@ func search(prefix netip.Prefix, node node) node {`
`235`	`238`	`}`
`236`	`239`
`237`	`240`	`func (n *node) split() {`
`238`		`- if n.isSplit() {`
	`241`	`+ if n.isSplitted() {`
`239`	`242`	`return`
`240`	`243`	`}`
`241`	`244`	`left, right := splitNetworkPrefix(n.prefix)`
`@@ -265,16 +268,16 @@ func (n *node) insert(nd nodeDirection, prefix netip.Prefix) {`
`265`	`268`	`}`
`266`	`269`
`267`	`270`	`func (n *node) bestDirection() (first, second nodeDirection) {`
`268`		`- if n.left.isSplit() {`
	`271`	`+ if n.left.isSplitted() {`
`269`	`272`	`return leftDirection, rightDirection`
`270`	`273`	`}`
`271`		`- if n.right.isSplit() {`
	`274`	`+ if n.right.isSplitted() {`
`272`	`275`	`return rightDirection, leftDirection`
`273`	`276`	`}`
`274`	`277`	`return leftDirection, rightDirection`
`275`	`278`	`}`
`276`	`279`
`277`		`-func (n *node) isSplit() bool {`
	`280`	`+func (n *node) isSplitted() bool {`
`278`	`281`	`if n.left != nil && n.right != nil {`
`279`	`282`	`return true`
`280`	`283`	`}`