feat: add location sync to nautobot operator

Author: abhimanyu003

docs/schema/locations.schema.json

@@ -0,0 +1 @@
+../../schema/locations.schema.json

go/nautobotop/.gitignore

@@ -8,6 +8,7 @@
 bin/*
 dist/*
 Dockerfile.cross
+cmd/cmd
 
 # Test binary, built with `go test -c`
 *.test
@@ -25,6 +26,7 @@ dist/
 
 # editor and IDE paraphernalia
 .idea
+.kiro
 .vscode
 *.swp
 *.swo

go/nautobotop/api/v1alpha1/nautobot_types.go

@@ -33,6 +33,7 @@ type NautobotSpec struct {
 	NautobotServiceRef  ServiceSelector   `json:"nautobotServiceRef,omitempty"`
 	DeviceTypesRef      []ConfigMapRef    `json:"deviceTypeRef,omitempty"`
 	LocationTypesRef    []ConfigMapRef    `json:"locationTypesRef,omitempty"`
+	LocationRef         []ConfigMapRef    `json:"locationRef,omitempty"`
 }
 
 // NautobotStatus defines the observed state of Nautobot.

go/nautobotop/api/v1alpha1/zz_generated.deepcopy.go

@@ -68,6 +68,35 @@ spec:
                   - name
                   type: object
                 type: array
+              locationRef:
+                items:
+                  description: ConfigMapRef defines a reference to a specific ConfigMap
+                  properties:
+                    configMapSelector:
+                      description: The name of the ConfigMap resource being referred
+                        to
+                      properties:
+                        key:
+                          description: The key in the ConfigMap data
+                          type: string
+                        name:
+                          description: The name of the ConfigMap
+                          minLength: 1
+                          type: string
+                        namespace:
+                          description: The namespace where the ConfigMap resides
+                          type: string
+                      required:
+                      - name
+                      type: object
+                    name:
+                      description: Name of this config set (logical name)
+                      type: string
+                  required:
+                  - configMapSelector
+                  - name
+                  type: object
+                type: array
               locationTypesRef:
                 items:
                   description: ConfigMapRef defines a reference to a specific ConfigMap

go/nautobotop/config/crd/bases/sync.rax.io_nautobots.yaml

@@ -68,6 +68,35 @@ spec:
                   - name
                   type: object
                 type: array
+              locationRef:
+                items:
+                  description: ConfigMapRef defines a reference to a specific ConfigMap
+                  properties:
+                    configMapSelector:
+                      description: The name of the ConfigMap resource being referred
+                        to
+                      properties:
+                        key:
+                          description: The key in the ConfigMap data
+                          type: string
+                        name:
+                          description: The name of the ConfigMap
+                          minLength: 1
+                          type: string
+                        namespace:
+                          description: The namespace where the ConfigMap resides
+                          type: string
+                      required:
+                      - name
+                      type: object
+                    name:
+                      description: Name of this config set (logical name)
+                      type: string
+                  required:
+                  - configMapSelector
+                  - name
+                  type: object
+                type: array
               locationTypesRef:
                 items:
                   description: ConfigMapRef defines a reference to a specific ConfigMap

go/nautobotop/helm/crds/clients.yaml

@@ -61,70 +61,86 @@ type NautobotReconciler struct {
 //
 // For more details, check Reconcile and its Result here:
 // - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.20.4/pkg/reconcile
+// resourceConfig defines configuration for a single resource type
+type resourceConfig struct {
+	name       string
+	configRefs []syncv1alpha1.ConfigMapRef
+	syncFunc   func(context.Context, *nbClient.NautobotClient, map[string]string) error
+}
+
 func (r *NautobotReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	log := logf.FromContext(ctx)
 	var nautobotCR syncv1alpha1.Nautobot
 	if err := r.Get(ctx, req.NamespacedName, &nautobotCR); err != nil {
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
 
-	// Aggregate device type data from all referenced ConfigMaps
-	locationTypeMap, err := r.aggregateDeviceTypeDataFromConfigMap(ctx, nautobotCR.Spec.LocationTypesRef)
-	if err != nil {
-		log.Error(err, "failed to aggregate device type data from ConfigMaps")
-		return ctrl.Result{}, err
+	syncInterval := time.Duration(nautobotCR.Spec.SyncIntervalSeconds) * time.Second
+	requeueAfter := time.Duration(nautobotCR.Spec.RequeueAfter) * time.Second
+
+	// Define all resources to sync
+	// Add more resources here: {name: "location", configRefs: nautobotCR.Spec.LocationsRef, syncFunc: r.syncLocations}
+	resources := []resourceConfig{
+		{name: "locationType", configRefs: nautobotCR.Spec.LocationTypesRef, syncFunc: r.syncLocationTypes},
+		{name: "location", configRefs: nautobotCR.Spec.LocationRef, syncFunc: r.syncLocation},
+		{name: "deviceType", configRefs: nautobotCR.Spec.DeviceTypesRef, syncFunc: r.syncDeviceTypes},
 	}
 
-	// Aggregate device type data from all referenced ConfigMaps
-	deviceTypeMap, err := r.aggregateDeviceTypeDataFromConfigMap(ctx, nautobotCR.Spec.DeviceTypesRef)
-	if err != nil {
-		log.Error(err, "failed to aggregate device type data from ConfigMaps")
-		return ctrl.Result{}, err
+	// Aggregate data and check sync decisions for all resources
+	resourcesToSync := make(map[string]map[string]string)
+	for _, res := range resources {
+		dataMap, err := r.aggregateDataFromConfigMap(ctx, res.configRefs)
+		if err != nil {
+			log.Error(err, "failed to aggregate data", "resource", res.name)
+			return ctrl.Result{}, err
+		}
+
+		currentHash := computeHash(dataMap)
+		previousHash := nautobotCR.GetSyncHash(res.name)
+		decision := r.shouldSync(nautobotCR.Status.LastSyncedAt, syncInterval, currentHash, previousHash)
+
+		if decision.ShouldSync {
+			log.Info("resource needs sync", "resource", res.name, "reason", decision.Reason)
+			resourcesToSync[res.name] = dataMap
+		} else {
+			log.Info("skipping resource sync", "resource", res.name, "reason", decision.Reason)
+		}
 	}
 
-	// Check if sync should proceed based on time interval and data changes
-	syncInterval := time.Duration(nautobotCR.Spec.SyncIntervalSeconds) * time.Second
-	requestTimeAfter := time.Duration(nautobotCR.Spec.RequeueAfter) * time.Second
-	currentHash := computeHash(deviceTypeMap)
-	previousHash := nautobotCR.GetSyncHash("deviceType")
-
-	syncDecision := r.shouldSync(nautobotCR.Status.LastSyncedAt, syncInterval, currentHash, previousHash)
-	if !syncDecision.ShouldSync {
-		log.Info("skipping sync", "reason", syncDecision.Reason, "hash", currentHash)
-		nautobotCR.Status.Message = syncDecision.StatusMessage
+	// If nothing to sync, update status and requeue
+	if len(resourcesToSync) == 0 {
+		nautobotCR.Status.Message = "No changes detected"
 		if err := r.Status().Update(ctx, &nautobotCR); err != nil {
 			log.Error(err, "failed to update status")
 			return ctrl.Result{}, err
 		}
-		return ctrl.Result{RequeueAfter: requestTimeAfter}, nil
+		return ctrl.Result{RequeueAfter: requeueAfter}, nil
 	}
 
-	log.Info("proceeding with sync", "reason", syncDecision.Reason, "hash", currentHash)
-
-	// Retrieve the Nautobot authentication token from a secret or external source
+	// Create Nautobot client
 	username, token, err := r.getAuthTokenFromSecretRef(ctx, nautobotCR)
 	if err != nil {
-		log.Error(err, "failed parse find nautobot auth token")
+		log.Error(err, "failed to get nautobot auth token")
 		return ctrl.Result{}, err
 	}
-
-	// Create Nautobot client
 	nautobotURL := fmt.Sprintf("http://%s.%s.svc.cluster.local/api", nautobotCR.Spec.NautobotServiceRef.Name, nautobotCR.Spec.NautobotServiceRef.Namespace)
 	nautobotClient := nbClient.NewNautobotClient(nautobotURL, username, token)
 
-	if err := r.syncLocationTypes(ctx, nautobotClient, locationTypeMap); err != nil {
-		log.Error(err, "failed to sync device types")
-		return ctrl.Result{}, err
-	}
-	if err := r.syncDeviceTypes(ctx, nautobotClient, deviceTypeMap); err != nil {
-		log.Error(err, "failed to sync device types")
-		return ctrl.Result{}, err
+	// Sync resources that need updating
+	for _, res := range resources {
+		if dataMap, ok := resourcesToSync[res.name]; ok {
+			if err := res.syncFunc(ctx, nautobotClient, dataMap); err != nil {
+				log.Error(err, "failed to sync resource", "resource", res.name)
+				return ctrl.Result{}, err
+			}
+			nautobotCR.SetSyncHash(res.name, computeHash(dataMap))
+		}
 	}
 
+	// Update status
 	nautobotCR.Status.LastSyncedAt = metav1.Now()
 	nautobotCR.Status.Ready = true
 	nautobotCR.Status.NautobotStatusReport = nautobotClient.Report
-	nautobotCR.SetSyncHash("deviceType", currentHash)
 	if len(nautobotClient.Report) > 0 {
 		nautobotCR.Status.Message = "sync completed with some errors"
 	} else {
@@ -134,15 +150,14 @@ func (r *NautobotReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 		log.Error(err, "failed to update status")
 		return ctrl.Result{}, err
 	}
-	// Successfully completed reconciliation; requeue after configured sync interval
+
 	log.Info("sync completed successfully")
-	return ctrl.Result{RequeueAfter: requestTimeAfter}, nil
+	return ctrl.Result{RequeueAfter: requeueAfter}, nil
 }
 
-// aggregateDeviceTypeDataFromConfigMap fetches and merges data from all referenced ConfigMaps.
-// It returns a map containing all device type configurations.
-func (r *NautobotReconciler) aggregateDeviceTypeDataFromConfigMap(ctx context.Context, refs []syncv1alpha1.ConfigMapRef) (map[string]string, error) {
-	deviceTypeMap := make(map[string]string)
+// aggregateDataFromConfigMap fetches and merges data from all referenced ConfigMaps.
+func (r *NautobotReconciler) aggregateDataFromConfigMap(ctx context.Context, refs []syncv1alpha1.ConfigMapRef) (map[string]string, error) {
+	dataMap := make(map[string]string)
 
 	for _, ref := range refs {
 		var configMap corev1.ConfigMap
@@ -156,27 +171,36 @@ func (r *NautobotReconciler) aggregateDeviceTypeDataFromConfigMap(ctx context.Co
 				namespacedName.Namespace, namespacedName.Name, err)
 		}
 
-		// Merge ConfigMap data into the aggregate map
-		maps.Copy(deviceTypeMap, configMap.Data)
+		maps.Copy(dataMap, configMap.Data)
 	}
 
-	return deviceTypeMap, nil
+	return dataMap, nil
 }
 
 // syncDeviceTypes syncs device types to Nautobot.
-// The hash comparison is now handled in the Reconcile function.
 func (r *NautobotReconciler) syncDeviceTypes(ctx context.Context,
 	nautobotClient *nbClient.NautobotClient,
 	deviceTypeMap map[string]string,
 ) error {
 	log := logf.FromContext(ctx)
-
-	log.Info("syncing device types", "deviceTypeCount", len(deviceTypeMap))
+	log.Info("syncing device types", "count", len(deviceTypeMap))
 	syncSvc := sync.NewDeviceTypeSync(nautobotClient)
 	if err := syncSvc.SyncAll(ctx, deviceTypeMap); err != nil {
 		return fmt.Errorf("failed to sync device types: %w", err)
 	}
+	return nil
+}
 
+func (r *NautobotReconciler) syncLocation(ctx context.Context,
+	nautobotClient *nbClient.NautobotClient,
+	locationType map[string]string,
+) error {
+	log := logf.FromContext(ctx)
+	log.Info("syncing location types", "count", len(locationType))
+	syncSvc := sync.NewLocationSync(nautobotClient)
+	if err := syncSvc.SyncAll(ctx, locationType); err != nil {
+		return fmt.Errorf("failed to sync location types: %w", err)
+	}
 	return nil
 }
 
@@ -185,13 +209,11 @@ func (r *NautobotReconciler) syncLocationTypes(ctx context.Context,
 	locationType map[string]string,
 ) error {
 	log := logf.FromContext(ctx)
-
-	log.Info("syncing location types", "locationTypeCount", len(locationType))
+	log.Info("syncing location types", "count", len(locationType))
 	syncSvc := sync.NewLocationTypeSync(nautobotClient)
 	if err := syncSvc.SyncAll(ctx, locationType); err != nil {
 		return fmt.Errorf("failed to sync location types: %w", err)
 	}
-
 	return nil
 }