use availabe ips in range to create list for status

Author: bruelea

api/v1/iprangeclaim_types.go

@@ -51,6 +51,20 @@ type IpRangeClaimSpec struct {
 type IpRangeClaimStatus struct {
 	IpRange string `json:"ipRange,omitempty"`
 
+	IpRangeDotDecimal string `json:"ipRangeDotDecimal,omitempty"`
+
+	IpAddresses []string `json:"ipAddresses,omitempty"`
+
+	IpAddressesDotDecimal []string `json:"ipAddressesDotDecimal,omitempty"`
+
+	StartAddress string `json:"startAddress,omitempty"`
+
+	StartAddressDotDecimal string `json:"startAddressDotDecimal,omitempty"`
+
+	EndAddress string `json:"endAddress,omitempty"`
+
+	EndAddressDotDecimal string `json:"endAddressDotDecimal,omitempty"`
+
 	IpRangeName string `json:"ipAddressName,omitempty"`
 
 	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
@@ -60,7 +74,7 @@ type IpRangeClaimStatus struct {
 //+kubebuilder:subresource:status
 //+kubebuilder:storageversion
 //+kubebuilder:printcolumn:name="IpRange",type=string,JSONPath=`.status.ipRange`
-//+kubebuilder:printcolumn:name="IpRangeAssigned",type=string,JSONPath=`.status.conditions[?(@.type=="IPAssigned")].status`
+//+kubebuilder:printcolumn:name="IpRangeAssigned",type=string,JSONPath=`.status.conditions[?(@.type=="IpRangeAssigned")].status`
 //+kubebuilder:printcolumn:name="Ready",type=string,JSONPath=`.status.conditions[?(@.type=="Ready")].status`
 //+kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`
 // +kubebuilder:resource:shortName=irc
@@ -115,9 +129,9 @@ var ConditionIpRangeAssignedFalse = metav1.Condition{
 	Message: "Failed to fetch new Ip Range from NetBox",
 }
 
-var ConditionIpAssignedFalseSizeMissmatch = metav1.Condition{
+var ConditionIpRangeAssignedFalseSizeMissmatch = metav1.Condition{
 	Type:    "IpRangeAssigned",
 	Status:  "False",
 	Reason:  "IpRangeCRNotCreated",
-	Message: "Size of restored IpRange does not match the requested size",
+	Message: "Assigned/Resored ip range has less available ip addresses than requested",
 }

api/v1/zz_generated.deepcopy.go

@@ -20,7 +20,7 @@ spec:
     - jsonPath: .status.ipRange
       name: IpRange
       type: string
-    - jsonPath: .status.conditions[?(@.type=="IPAssigned")].status
+    - jsonPath: .status.conditions[?(@.type=="IpRangeAssigned")].status
       name: IpRangeAssigned
       type: string
     - jsonPath: .status.conditions[?(@.type=="Ready")].status
@@ -155,10 +155,28 @@ spec:
                   - type
                   type: object
                 type: array
+              endAddress:
+                type: string
+              endAddressDotDecimal:
+                type: string
               ipAddressName:
                 type: string
+              ipAddresses:
+                items:
+                  type: string
+                type: array
+              ipAddressesDotDecimal:
+                items:
+                  type: string
+                type: array
               ipRange:
                 type: string
+              ipRangeDotDecimal:
+                type: string
+              startAddress:
+                type: string
+              startAddressDotDecimal:
+                type: string
             type: object
         type: object
     served: true

config/crd/bases/netbox.dev_iprangeclaims.yaml

@@ -23,7 +23,6 @@ import (
 	"time"
 
 	netboxv1 "github.com/netbox-community/netbox-operator/api/v1"
-	"github.com/netbox-community/netbox-operator/pkg/config"
 	"github.com/netbox-community/netbox-operator/pkg/netbox/api"
 	"github.com/netbox-community/netbox-operator/pkg/netbox/models"
 	"github.com/swisscom/leaselocker"
@@ -102,9 +101,9 @@ func (r *IpRangeClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request
 
 		// 4. try to reclaim ip range
 		h := generateIpRangeRestorationHash(o)
-		ipRangeModel, err := r.NetboxClient.RestoreExistingIpRangeByHash(config.GetOperatorConfig().NetboxRestorationHashFieldName, h)
+		ipRangeModel, err := r.NetboxClient.RestoreExistingIpRangeByHash(h)
 		if err != nil {
-			if err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpAssignedFalse, corev1.EventTypeWarning, "", err); err != nil {
+			if err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalse, corev1.EventTypeWarning, "", err); err != nil {
 				return ctrl.Result{}, err
 			}
 			return ctrl.Result{Requeue: true}, nil
@@ -123,7 +122,7 @@ func (r *IpRangeClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request
 				},
 			)
 			if err != nil {
-				if err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpAssignedFalse, corev1.EventTypeWarning, "", err); err != nil {
+				if err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalse, corev1.EventTypeWarning, "", err); err != nil {
 					return ctrl.Result{}, err
 				}
 				return ctrl.Result{Requeue: true}, nil
@@ -133,10 +132,10 @@ func (r *IpRangeClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request
 			// 5.b reassign reserved ip range from netbox
 
 			// check if the restored ip range has the size requested by the claim
-			err = correctSizeOrErr(*ipRangeModel, o.Spec.Size)
-			if err != nil {
+			availableIps, err := r.NetboxClient.GetAvailableIpAddressesByIpRange(ipRangeModel.Id)
+			if len(availableIps.Payload) != o.Spec.Size {
 				ll.Unlock()
-				err = r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpAssignedFalseSizeMissmatch, corev1.EventTypeWarning, "", err)
+				err = r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalseSizeMissmatch, corev1.EventTypeWarning, "", err)
 				if err != nil {
 					return ctrl.Result{}, err
 				}
@@ -173,7 +172,7 @@ func (r *IpRangeClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request
 		}
 	}
 
-	err = r.updateIpRangeClaimReadyStatus(ctx, o, ipRange)
+	err = r.updateIpRangeClaimStatus(ctx, o, ipRange)
 	if err != nil {
 		return ctrl.Result{}, err
 	}
@@ -256,21 +255,46 @@ func (r *IpRangeClaimReconciler) tryLockOnParentPrefix(ctx context.Context, o *n
 	return ll, ctrl.Result{}, nil
 }
 
-func (r *IpRangeClaimReconciler) updateIpRangeClaimReadyStatus(ctx context.Context, o *netboxv1.IpRangeClaim, ipRange *netboxv1.IpRange) error {
+func (r *IpRangeClaimReconciler) updateIpRangeClaimStatus(ctx context.Context, o *netboxv1.IpRangeClaim, ipRange *netboxv1.IpRange) error {
 	debugLogger := log.FromContext(ctx).V(4)
 
 	if apismeta.IsStatusConditionTrue(ipRange.Status.Conditions, "Ready") {
 		debugLogger.Info("iprange status ready true")
-		o.Status.IpRange = fmt.Sprintf("%s-%s", strings.Split(ipRange.Spec.StartAddress, "/")[0],
-			strings.Split(ipRange.Spec.EndAddress, "/")[0])
+
+		startAddressDotDecimal := strings.Split(ipRange.Spec.StartAddress, "/")[0]
+		endAddressDotDecimal := strings.Split(ipRange.Spec.EndAddress, "/")[0]
+
+		o.Status.IpRange = fmt.Sprintf("%s-%s", ipRange.Spec.StartAddress, ipRange.Spec.EndAddress)
+
+		o.Status.IpRangeDotDecimal = fmt.Sprintf("%s-%s", startAddressDotDecimal, endAddressDotDecimal)
+
+		availableIps, err := r.NetboxClient.GetAvailableIpAddressesByIpRange(ipRange.Status.IpRangeId)
+		if err != nil {
+			return err
+		}
+
+		o.Status.IpAddresses = []string{}
+		o.Status.IpAddressesDotDecimal = []string{}
+		for _, ip := range availableIps.Payload {
+			o.Status.IpAddresses = append(o.Status.IpAddresses, ip.Address)
+			o.Status.IpAddressesDotDecimal = append(o.Status.IpAddressesDotDecimal, strings.Split(ip.Address, "/")[0])
+		}
+
+		o.Status.StartAddress = ipRange.Spec.StartAddress
+		o.Status.StartAddressDotDecimal = startAddressDotDecimal
+
+		o.Status.EndAddress = ipRange.Spec.EndAddress
+		o.Status.EndAddressDotDecimal = endAddressDotDecimal
+
 		o.Status.IpRangeName = ipRange.Name
-		err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpClaimReadyTrue, corev1.EventTypeNormal, "", nil)
+
+		err = r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyTrue, corev1.EventTypeNormal, "", nil)
 		if err != nil {
 			return err
 		}
 	} else {
 		debugLogger.Info("iprange status ready false")
-		err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpClaimReadyFalse, corev1.EventTypeWarning, "", nil)
+		err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeReadyFalse, corev1.EventTypeWarning, "", nil)
 		if err != nil {
 			return err
 		}
@@ -288,14 +312,14 @@ func (r *IpRangeClaimReconciler) createIpRangeCR(ctx context.Context, o *netboxv
 
 	err = r.Client.Create(ctx, ipRangeResource)
 	if err != nil {
-		err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpAssignedFalse, corev1.EventTypeWarning, "", err)
+		err := r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedFalse, corev1.EventTypeWarning, "", err)
 		if err != nil {
 			return err
 		}
 		return err
 	}
 
-	err = r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpAssignedTrue, corev1.EventTypeNormal, "", nil)
+	err = r.SetConditionAndCreateEvent(ctx, o, netboxv1.ConditionIpRangeAssignedTrue, corev1.EventTypeNormal, "", nil)
 	if err != nil {
 		return err
 	}

gen/mock_interfaces/netbox_mocks.go

@@ -23,45 +23,10 @@ import (
 	. "github.com/onsi/gomega"
 
 	netboxv1 "github.com/netbox-community/netbox-operator/api/v1"
-	"github.com/netbox-community/netbox-operator/pkg/netbox/models"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 var _ = Describe("IpRangeClaim Controller", func() {
-	Context("When checking the ip range size", func() {
-		It("should succeed if correct size", func() {
-			ipRange := &models.IpRange{
-				StartAddress: "1.0.0.1/32",
-				EndAddress:   "1.0.0.3/32",
-			}
-			Expect(correctSizeOrErr(*ipRange, 3)).To(Succeed())
-		})
-
-		It("should succeed if correct size IPv6", func() {
-			ipRange := &models.IpRange{
-				StartAddress: "2001:db8:85a3:8d3::1/128",
-				EndAddress:   "2001:db8:85a3:8d3::3/128",
-			}
-			Expect(correctSizeOrErr(*ipRange, 3)).To(Succeed())
-		})
-
-		It("should fail if wrong size", func() {
-			ipRange := &models.IpRange{
-				StartAddress: "1.0.0.1/32",
-				EndAddress:   "1.0.0.2/32",
-			}
-			Expect(correctSizeOrErr(*ipRange, 3)).To(HaveOccurred())
-		})
-
-		It("should fail if ip adresses are invalid", func() {
-			ipRange := &models.IpRange{
-				StartAddress: "",
-				EndAddress:   "",
-			}
-			Expect(correctSizeOrErr(*ipRange, 3)).To(HaveOccurred())
-		})
-	})
-
 	Context("When generating the ip range spec", func() {
 		It("should create the correct spec", func() {
 			ctx := context.TODO()

internal/controller/iprangeclaim_controller.go

@@ -20,12 +20,10 @@ import (
 	"context"
 	"crypto/sha1"
 	"fmt"
-	"net"
 
 	"github.com/go-logr/logr"
 	netboxv1 "github.com/netbox-community/netbox-operator/api/v1"
 	"github.com/netbox-community/netbox-operator/pkg/config"
-	"github.com/netbox-community/netbox-operator/pkg/netbox/models"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
@@ -79,43 +77,6 @@ func generateIpRangeRestorationHash(claim *netboxv1.IpRangeClaim) string {
 	return fmt.Sprintf("%x", sha1.Sum([]byte(rd.Namespace+rd.Name+rd.ParentPrefix+rd.Tenant+rd.Size)))
 }
 
-func correctSizeOrErr(ipRange models.IpRange, size int) error {
-	// check if the restored ip range has the size that was requested in the claim
-	// to detect if the ip range was restored correctly and was not edited in NetBox
-	startIP, _, err := net.ParseCIDR(ipRange.StartAddress)
-	if err != nil {
-		return fmt.Errorf("invalid IP address in IP range")
-	}
-
-	endIP, _, err := net.ParseCIDR(ipRange.EndAddress)
-	if err != nil {
-		return fmt.Errorf("invalid IP address in IP range")
-	}
-
-	if startIP == nil || endIP == nil {
-		return fmt.Errorf("invalid IP address in IP range")
-	}
-
-	if startIP.To4() != nil && endIP.To4() != nil {
-		ipRangeSize := int(endIP.To4()[3]-startIP.To4()[3]) + 1
-		if ipRangeSize != size {
-			return fmt.Errorf("IP range size mismatch: requested size by claim %d, size of restored ip range %d",
-				size, ipRangeSize)
-		}
-	}
-	if startIP.To16() != nil && endIP.To16() != nil {
-		ipRangeSize := int(endIP.To16()[15]-startIP.To16()[15]) + 1
-		if ipRangeSize != size {
-			return fmt.Errorf("IP range size mismatch: requested size by claim %d, size of restored ip range %d",
-				size, ipRangeSize)
-		}
-	}
-
-	// Calculate the size of the IP range
-
-	return nil
-}
-
 type IpRangeClaimRestorationData struct {
 	// only use immutable fields
 	Namespace    string

internal/controller/iprangeclaim_controller_test.go

@@ -23,13 +23,19 @@ import (
 	"net"
 
 	"github.com/netbox-community/go-netbox/v3/netbox/client/ipam"
+	"github.com/netbox-community/netbox-operator/pkg/config"
 	"github.com/netbox-community/netbox-operator/pkg/netbox/models"
 	"github.com/netbox-community/netbox-operator/pkg/netbox/utils"
 )
 
-func (r *NetboxClient) RestoreExistingIpRangeByHash(customFieldName string, hash string) (*models.IpRange, error) {
-	customIpSearch := newCustomFieldStringFilterOperation(customFieldName, hash)
-	list, err := r.Ipam.IpamIPRangesList(ipam.NewIpamIPRangesListParams(), nil, customIpSearch)
+func (r *NetboxClient) RestoreExistingIpRangeByHash(hash string) (*models.IpRange, error) {
+	customIpRangeSearch := newQueryFilterOperation(nil, []CustomFieldEntry{
+		{
+			key:   config.GetOperatorConfig().NetboxRestorationHashFieldName,
+			value: hash,
+		},
+	})
+	list, err := r.Ipam.IpamIPRangesList(ipam.NewIpamIPRangesListParams(), nil, customIpRangeSearch)
 	if err != nil {
 		return nil, err
 	}
@@ -51,6 +57,7 @@ func (r *NetboxClient) RestoreExistingIpRangeByHash(customFieldName string, hash
 	return &models.IpRange{
 		StartAddress: *res.StartAddress,
 		EndAddress:   *res.EndAddress,
+		Id:           res.ID,
 	}, nil
 }
 
@@ -99,6 +106,16 @@ func (r *NetboxClient) GetAvailableIpRangeByClaim(ipRangeClaim *models.IpRangeCl
 	}, nil
 }
 
+// GetAvailableIpsByIpRange returns all available Ips in Netbox matching IpRangeClaim requirements
+func (r *NetboxClient) GetAvailableIpAddressesByIpRange(ipRangeId int64) (*ipam.IpamIPRangesAvailableIpsListOK, error) {
+	requestAvailableIPs := ipam.NewIpamIPRangesAvailableIpsListParams().WithID(ipRangeId)
+	responseAvailableIPs, err := r.Ipam.IpamIPRangesAvailableIpsList(requestAvailableIPs, nil)
+	if err != nil {
+		return nil, err
+	}
+	return responseAvailableIPs, nil
+}
+
 func searchAvailableIpRange(availableIps *ipam.IpamPrefixesAvailableIpsListOK, requiredSize int) (string, string, error) {
 	// this function receives a list of available IPs it chan have IPv4 or IPv6 IPs
 	// it will search for the first available range of IPs with the required size