fixup! feature: reserve n IPs on Networks

Author: fra98

pkg/ipam/initialize.go

@@ -45,7 +45,7 @@ func (lipam *LiqoIPAM) initializeNetworks(ctx context.Context) error {
 
 	// Initialize the networks.
 	for _, net := range nets {
-		if err := lipam.reserveNetwork(net); err != nil {
+		if err := lipam.reserveNetwork(&net); err != nil {
 			klog.Errorf("Failed to reserve network %q: %v", net, err)
 			return err
 		}

pkg/ipam/ipam.go

@@ -90,7 +90,7 @@ func (lipam *LiqoIPAM) IPRelease(_ context.Context, req *IPReleaseRequest) (*IPR
 
 // NetworkAcquire acquires a network. If it is already reserved, it allocates and reserves a new free one with the same prefix length.
 func (lipam *LiqoIPAM) NetworkAcquire(_ context.Context, req *NetworkAcquireRequest) (*NetworkAcquireResponse, error) {
-	remappedCidr, err := lipam.acquireNetwork(req.GetCidr(), req.GetImmutable(), uint(req.GetPreAllocated()))
+	remappedCidr, err := lipam.acquireNetwork(req.GetCidr(), uint(req.GetPreAllocated()), req.GetImmutable())
 	if err != nil {
 		return &NetworkAcquireResponse{}, err
 	}
@@ -100,14 +100,14 @@ func (lipam *LiqoIPAM) NetworkAcquire(_ context.Context, req *NetworkAcquireRequ
 
 // NetworkRelease releases a network.
 func (lipam *LiqoIPAM) NetworkRelease(_ context.Context, req *NetworkReleaseRequest) (*NetworkReleaseResponse, error) {
-	lipam.freeNetwork(req.GetCidr())
+	lipam.freeNetwork(&network{cidr: req.GetCidr()})
 
 	return &NetworkReleaseResponse{}, nil
 }
 
 // NetworkIsAvailable checks if a network is available.
 func (lipam *LiqoIPAM) NetworkIsAvailable(_ context.Context, req *NetworkAvailableRequest) (*NetworkAvailableResponse, error) {
-	available := lipam.isNetworkAvailable(req.GetCidr())
+	available := lipam.isNetworkAvailable(&network{cidr: req.GetCidr()})
 
 	return &NetworkAvailableResponse{Available: available}, nil
 }

pkg/ipam/networks.go

@@ -25,75 +25,86 @@ import (
 )
 
 type networkInfo struct {
-	cidr              string
+	network
 	creationTimestamp time.Time
 }
 
+type network struct {
+	cidr         string
+	preAllocated uint
+}
+
+func (n network) String() string {
+	return n.cidr
+}
+
 // reserveNetwork reserves a network, saving it in the cache.
-func (lipam *LiqoIPAM) reserveNetwork(cidr string, preAllocated uint) error {
+func (lipam *LiqoIPAM) reserveNetwork(nw *network) error {
 	lipam.mutex.Lock()
 	defer lipam.mutex.Unlock()
 
 	// TODO: implement real network reserve logic
-	_ = preAllocated
 	if lipam.cacheNetworks == nil {
 		lipam.cacheNetworks = make(map[string]networkInfo)
 	}
-	lipam.cacheNetworks[cidr] = networkInfo{
-		cidr:              cidr,
+	lipam.cacheNetworks[nw.String()] = networkInfo{
+		network:           *nw,
 		creationTimestamp: time.Now(),
 	}
 
-	klog.Infof("Reserved network %q", cidr)
+	klog.Infof("Reserved network %q", nw)
 	return nil
 }
 
 // acquireNetwork acquires a network, eventually remapped if conflicts are found.
-func (lipam *LiqoIPAM) acquireNetwork(cidr string, immutable bool, preAllocated uint) (string, error) {
+func (lipam *LiqoIPAM) acquireNetwork(cidr string, preAllocated uint, immutable bool) (string, error) {
 	lipam.mutex.Lock()
 	defer lipam.mutex.Unlock()
 
 	// TODO: implement real network acquire logic
 	_ = immutable
-	_ = preAllocated
 	if lipam.cacheNetworks == nil {
 		lipam.cacheNetworks = make(map[string]networkInfo)
 	}
-	lipam.cacheNetworks[cidr] = networkInfo{
-		cidr:              cidr,
+	nw := network{
+		cidr:         cidr,
+		preAllocated: preAllocated,
+	}
+	lipam.cacheNetworks[nw.String()] = networkInfo{
+		network:           nw,
 		creationTimestamp: time.Now(),
 	}
 
-	klog.Infof("Acquired network %q", cidr)
-	return cidr, nil
+	klog.Infof("Acquired network %q", nw)
+	return nw.cidr, nil
 }
 
 // freeNetwork frees a network, removing it from the cache.
-func (lipam *LiqoIPAM) freeNetwork(cidr string) {
+func (lipam *LiqoIPAM) freeNetwork(nw *network) {
 	lipam.mutex.Lock()
 	defer lipam.mutex.Unlock()
 
 	// TODO: implement real network free logic
-	delete(lipam.cacheNetworks, cidr)
-	klog.Infof("Freed network %q", cidr)
+	delete(lipam.cacheNetworks, nw.String())
+	klog.Infof("Freed network %q", nw.cidr)
 }
 
 // isNetworkAvailable checks if a network is available.
-func (lipam *LiqoIPAM) isNetworkAvailable(cidr string) bool {
+func (lipam *LiqoIPAM) isNetworkAvailable(nw *network) bool {
 	lipam.mutex.Lock()
 	defer lipam.mutex.Unlock()
 
 	// TODO: implement real network availability check logic
 	if lipam.cacheNetworks == nil {
 		return true
 	}
-	_, ok := lipam.cacheNetworks[cidr]
+	_, ok := lipam.cacheNetworks[nw.String()]
 
 	return ok
 }
 
-func listNetworksOnCluster(ctx context.Context, cl client.Client) ([]string, error) {
-	var nets []string
+func listNetworksOnCluster(ctx context.Context, cl client.Client) ([]network, error) {
+	var nets []network
 	var networks ipamv1alpha1.NetworkList
 	if err := cl.List(ctx, &networks); err != nil {
 		return nil, err
@@ -108,7 +119,10 @@ func listNetworksOnCluster(ctx context.Context, cl client.Client) ([]string, err
 			continue
 		}
 
-		nets = append(nets, cidr)
+		nets = append(nets, network{
+			cidr:         cidr,
+			preAllocated: net.Spec.PreAllocated,
+		})
 	}
 
 	return nets, nil

pkg/ipam/sync.go

@@ -21,6 +21,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/util/wait"
 	klog "k8s.io/klog/v2"
+	"k8s.io/utils/ptr"
 )
 
 // +kubebuilder:rbac:groups=ipam.liqo.io,resources=ips,verbs=get;list;watch
@@ -64,19 +65,20 @@ func (lipam *LiqoIPAM) syncNetworks(ctx context.Context, expiredThreshold time.T
 	setClusterNetworks := make(map[string]struct{})
 
 	// Add networks that are present in the cluster but not in the cache.
-	for _, net := range clusterNetworks {
-		if _, inCache := lipam.cacheNetworks[net]; !inCache {
+	for i := range clusterNetworks {
+		net := &clusterNetworks[i]
+		if _, inCache := lipam.cacheNetworks[net.String()]; !inCache {
 			if err := lipam.reserveNetwork(net); err != nil {
 				return err
 			}
 		}
-		setClusterNetworks[net] = struct{}{} // add network to the set
+		setClusterNetworks[net.String()] = struct{}{} // add network to the set
 	}
 
 	// Remove networks that are present in the cache but not in the cluster, and were added before the threshold.
 	for key := range lipam.cacheNetworks {
 		if _, inCluster := setClusterNetworks[key]; !inCluster && lipam.cacheNetworks[key].creationTimestamp.Before(expiredThreshold) {
-			lipam.freeNetwork(lipam.cacheNetworks[key].cidr)
+			lipam.freeNetwork(ptr.To(lipam.cacheNetworks[key].network))
 		}
 	}
 

pkg/ipam/sync_test.go

@@ -45,7 +45,9 @@ var _ = Describe("Sync routine tests", func() {
 
 		addNetowrkToCache = func(ipamServer *LiqoIPAM, cidr string, creationTimestamp time.Time) {
 			ipamServer.cacheNetworks[cidr] = networkInfo{
-				cidr:              cidr,
+				network: network{
+					cidr: cidr,
+				},
 				creationTimestamp: creationTimestamp,
 			}
 		}