Remove IPAM clientset references from ipam and oob plugins

Author: damyan

plugins/ipam/k8s.go

@@ -12,15 +12,15 @@ import (
 	"os"
 	"reflect"
 	"strings"
+	"time"
+
+	"k8s.io/apimachinery/pkg/util/wait"
 
 	"github.com/ironcore-dev/fedhcp/internal/kubernetes"
 	ipamv1alpha1 "github.com/ironcore-dev/ipam/api/ipam/v1alpha1"
-	ipam "github.com/ironcore-dev/ipam/clientgo/ipam"
-	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/kubernetes/scheme"
 	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/client-go/tools/record"
@@ -33,22 +33,15 @@ const (
 
 type K8sClient struct {
 	Client        client.Client
-	Clientset     ipam.Clientset
 	Namespace     string
 	SubnetNames   []string
-	Ctx           context.Context
 	EventRecorder record.EventRecorder
 }
 
 func NewK8sClient(namespace string, subnetNames []string) (*K8sClient, error) {
 	cfg := kubernetes.GetConfig()
 	cl := kubernetes.GetClient()
 
-	clientset, err := ipam.NewForConfig(cfg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create IPAM clientset: %w", err)
-	}
-
 	corev1Client, err := corev1client.NewForConfig(cfg)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create core client: %w", err)
@@ -66,20 +59,18 @@ func NewK8sClient(namespace string, subnetNames []string) (*K8sClient, error) {
 
 	k8sClient := K8sClient{
 		Client:        cl,
-		Clientset:     *clientset,
 		Namespace:     namespace,
 		SubnetNames:   subnetNames,
-		Ctx:           context.Background(),
 		EventRecorder: recorder,
 	}
 	return &k8sClient, nil
 }
 
-func (k K8sClient) createIpamIP(ipaddr net.IP, mac net.HardwareAddr) error {
+func (k K8sClient) createIpamIP(ctx context.Context, ipaddr net.IP, mac net.HardwareAddr) error {
 	// select the subnet matching the CIDR of the request
 	subnetMatch := false
 	for _, subnetName := range k.SubnetNames {
-		subnet, err := k.getMatchingSubnet(subnetName, ipaddr)
+		subnet, err := k.getMatchingSubnet(ctx, subnetName, ipaddr)
 		if err != nil {
 			return err
 		}
@@ -90,12 +81,12 @@ func (k K8sClient) createIpamIP(ipaddr net.IP, mac net.HardwareAddr) error {
 		subnetMatch = true
 
 		var ipamIP *ipamv1alpha1.IP
-		ipamIP, err = k.prepareCreateIpamIP(subnetName, ipaddr, mac)
+		ipamIP, err = k.prepareCreateIpamIP(ctx, subnetName, ipaddr, mac)
 		if err != nil {
 			return err
 		}
 		if ipamIP != nil {
-			err = k.doCreateIpamIP(ipamIP)
+			err = k.doCreateIpamIP(ctx, ipamIP)
 			if err != nil {
 				return err
 			}
@@ -111,15 +102,15 @@ func (k K8sClient) createIpamIP(ipaddr net.IP, mac net.HardwareAddr) error {
 	return nil
 }
 
-func (k K8sClient) getMatchingSubnet(subnetName string, ipaddr net.IP) (*ipamv1alpha1.Subnet, error) {
+func (k K8sClient) getMatchingSubnet(ctx context.Context, subnetName string, ipaddr net.IP) (*ipamv1alpha1.Subnet, error) {
 	subnet := &ipamv1alpha1.Subnet{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      subnetName,
 			Namespace: k.Namespace,
 		},
 	}
 	existingSubnet := subnet.DeepCopy()
-	err := k.Client.Get(k.Ctx, client.ObjectKeyFromObject(subnet), existingSubnet)
+	err := k.Client.Get(ctx, client.ObjectKeyFromObject(subnet), existingSubnet)
 	if err != nil && !apierrors.IsNotFound(err) {
 		return nil, fmt.Errorf("failed to get subnet %s/%s: %w", k.Namespace, subnetName, err)
 	}
@@ -135,10 +126,7 @@ func (k K8sClient) getMatchingSubnet(subnetName string, ipaddr net.IP) (*ipamv1a
 	return subnet, nil
 }
 
-func (k K8sClient) prepareCreateIpamIP(
-	subnetName string,
-	ipaddr net.IP,
-	mac net.HardwareAddr) (*ipamv1alpha1.IP, error) {
+func (k K8sClient) prepareCreateIpamIP(ctx context.Context, subnetName string, ipaddr net.IP, mac net.HardwareAddr) (*ipamv1alpha1.IP, error) {
 	ip, err := ipamv1alpha1.IPAddrFromString(ipaddr.String())
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse IP %s: %w", ipaddr, err)
@@ -169,7 +157,7 @@ func (k K8sClient) prepareCreateIpamIP(
 	}
 
 	existingIpamIP := ipamIP.DeepCopy()
-	err = k.Client.Get(k.Ctx, client.ObjectKeyFromObject(ipamIP), existingIpamIP)
+	err = k.Client.Get(ctx, client.ObjectKeyFromObject(ipamIP), existingIpamIP)
 	if err != nil && !apierrors.IsNotFound(err) {
 		return nil, fmt.Errorf("failed to get IP %s/%s: %w", existingIpamIP.Namespace, existingIpamIP.Name, err)
 	}
@@ -183,14 +171,18 @@ func (k K8sClient) prepareCreateIpamIP(
 				prettyFormat(ipamIP.Spec))
 			log.Infof("Deleting old IP %s/%s", existingIpamIP.Namespace, existingIpamIP.Name)
 			// delete old IP object
-			err = k.Client.Delete(k.Ctx, existingIpamIP)
+			err = k.Client.Delete(ctx, existingIpamIP)
 			if err != nil {
 				return nil, fmt.Errorf("failed to delete IP %s/%s: %w", existingIpamIP.Namespace,
 					existingIpamIP.Name, err)
 			}
 
-			err = k.waitForDeletion(existingIpamIP)
-			if err != nil {
+			if err := wait.PollUntilContextTimeout(ctx, 1*time.Second, 30*time.Second, true, func(ctx context.Context) (bool, error) {
+				if err := k.Client.Get(ctx, client.ObjectKeyFromObject(existingIpamIP), existingIpamIP); !apierrors.IsNotFound(err) {
+					return false, err
+				}
+				return true, nil
+			}); err != nil {
 				return nil, fmt.Errorf("failed to delete IP %s/%s: %w", existingIpamIP.Namespace,
 					existingIpamIP.Name, err)
 			}
@@ -208,37 +200,8 @@ func (k K8sClient) prepareCreateIpamIP(
 	return ipamIP, nil
 }
 
-func (k K8sClient) waitForDeletion(ipamIP *ipamv1alpha1.IP) error {
-	// Define the namespace and resource name (if you want to watch a specific resource)
-	namespace := ipamIP.Namespace
-	resourceName := ipamIP.Name
-	fieldSelector := "metadata.name=" + resourceName + ",metadata.namespace=" + namespace
-	timeout := int64(5)
-
-	// watch for deletion finished event
-	watcher, err := k.Clientset.IpamV1alpha1().IPs(namespace).Watch(context.TODO(), metav1.ListOptions{
-		FieldSelector:  fieldSelector,
-		TimeoutSeconds: &timeout,
-	})
-	if err != nil {
-		log.Errorf("Error watching for IP: %v", err)
-	}
-
-	log.Debugf("Watching for changes to IP %s/%s...", namespace, resourceName)
-
-	for event := range watcher.ResultChan() {
-		log.Debugf("Type: %s, Object: %v\n", event.Type, event.Object)
-		foundIpamIP := event.Object.(*ipamv1alpha1.IP)
-		if event.Type == watch.Deleted && reflect.DeepEqual(ipamIP.Spec, foundIpamIP.Spec) {
-			log.Infof("IP %s/%s deleted", foundIpamIP.Namespace, foundIpamIP.Name)
-			return nil
-		}
-	}
-	return errors.New("timeout reached, IP not deleted")
-}
-
-func (k K8sClient) doCreateIpamIP(ipamIP *ipamv1alpha1.IP) error {
-	err := k.Client.Create(k.Ctx, ipamIP)
+func (k K8sClient) doCreateIpamIP(ctx context.Context, ipamIP *ipamv1alpha1.IP) error {
+	err := k.Client.Create(ctx, ipamIP)
 	if err != nil && !apierrors.IsAlreadyExists(err) {
 		return fmt.Errorf("failed to create IP %s/%s: %w", ipamIP.Namespace, ipamIP.Name, err)
 	}

plugins/ipam/plugin.go

@@ -4,6 +4,7 @@
 package ipam
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/coredhcp/coredhcp/handler"
@@ -94,8 +95,10 @@ func handler6(req, resp dhcpv6.DHCPv6) (dhcpv6.DHCPv6, bool) {
 	copy(ipaddr, relayMsg.LinkAddr)
 	ipaddr[len(ipaddr)-1] += 1
 
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
 	log.Infof("Generated IP address %s for mac %s", ipaddr.String(), mac.String())
-	err = k8sClient.createIpamIP(ipaddr, mac)
+	err = k8sClient.createIpamIP(ctx, ipaddr, mac)
 	if err != nil {
 		log.Errorf("Could not create IPAM IP: %s", err)
 		return nil, true