Keep dns records in ExternalDNS Status (#4)

Signed-off-by: rasel [email protected]

apis/external-dns/v1alpha1/externaldns_types.go

@@ -489,6 +489,17 @@ type ExternalDNSSpec struct {
 	TXTWildcardReplacement *string `json:"txtWildcardReplacement,omitempty"`
 }
 
+// DNSRecord hold the DNS name and target address, if there are multiple target address then the addresses are joint by separator ';' between them (ex: 1:2:3:4;6:7:8:9)
+type DNSRecord struct {
+	// target is the list of target address
+	// +optional
+	Target string `json:"target,omitempty"`
+
+	// dns name is the domain name for this record
+	// +optional
+	Name string `json:"name,omitempty"`
+}
+
 // ExternalDNSStatus defines the observed state of ExternalDNS
 type ExternalDNSStatus struct {
 	// Phase indicates the current state of the controller (ex: Failed,InProgress,Current)
@@ -502,6 +513,10 @@ type ExternalDNSStatus struct {
 	// Conditions describe the current condition of the CRD
 	// +optional
 	Conditions []kmapi.Condition `json:"conditions,omitempty"`
+
+	// DNSRecord is the list of records that this external dns operator registered
+	// +optional
+	DNSRecords []DNSRecord `json:"dnsRecords,omitempty"`
 }
 
 //+kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase"

config/crd/bases/external-dns.appscode.com_externaldns.yaml

@@ -391,6 +391,19 @@ spec:
                   - type
                   type: object
                 type: array
+              dnsRecords:
+                description: DNSRecord is the list of records that this external dns
+                  operator registered
+                items:
+                  properties:
+                    name:
+                      description: dns name is the domain name for this record
+                      type: string
+                    target:
+                      description: target is the list of target address
+                      type: string
+                  type: object
+                type: array
               observedGeneration:
                 description: ObservedGeneration indicates the latest generation that
                   successfully reconciled

controllers/external-dns/externaldns_controller.go

@@ -79,6 +79,16 @@ func (r *ExternalDNSReconciler) updateEdnsStatus(ctx context.Context, edns *exte
 	return patchErr
 }
 
+func (r ExternalDNSReconciler) patchDNSRecords(ctx context.Context, edns *externaldnsv1alpha1.ExternalDNS, dnsRecs []externaldnsv1alpha1.DNSRecord) error {
+	_, _, patchErr := kmc.PatchStatus(ctx, r.Client, edns, func(obj client.Object) client.Object {
+		in := obj.(*externaldnsv1alpha1.ExternalDNS)
+		in.Status.DNSRecords = dnsRecs
+		return in
+	})
+
+	return patchErr
+}
+
 func (r *ExternalDNSReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	_ = log.FromContext(ctx)
 
@@ -130,13 +140,17 @@ func (r *ExternalDNSReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	// APPLY DNS RECORD
 	//SetDNSRecords creates the dns record according to user information
 	//successMsg is used to identify whether the 'plan applied' or 'already up to date'
-	successMsg, err := plan.SetDNSRecords(edns, ctx)
-
+	dnsRecs, err := plan.SetDNSRecords(ctx, edns)
 	if err != nil {
 		return ctrl.Result{}, r.updateEdnsStatus(ctx, edns, newConditionPtr(externaldnsv1alpha1.CreateAndApplyPlan, err.Error(), edns.Generation, false), phasePointer(externaldnsv1alpha1.ExternalDNSPhaseFailed))
 	}
 
-	return ctrl.Result{}, r.updateEdnsStatus(ctx, edns, newConditionPtr(externaldnsv1alpha1.CreateAndApplyPlan, successMsg, edns.Generation, true), phasePointer(externaldnsv1alpha1.ExternalDNSPhaseCurrent))
+	err = r.patchDNSRecords(ctx, edns, dnsRecs)
+	if err != nil {
+		return ctrl.Result{}, err
+	}
+
+	return ctrl.Result{}, r.updateEdnsStatus(ctx, edns, newConditionPtr(externaldnsv1alpha1.CreateAndApplyPlan, "plan applied", edns.Generation, true), phasePointer(externaldnsv1alpha1.ExternalDNSPhaseCurrent))
 }
 
 // SetupWithManager sets up the controller with the Manager.

pkg/plan/plan.go

@@ -184,7 +184,8 @@ var defaultConfig = externaldns.Config{
 	IBMCloudConfigFile:          "/etc/kubernetes/ibmcloud.json",
 }
 
-func createAndApplyPlan(ctx context.Context, cfg *externaldns.Config, r registry.Registry, endpointSource source.Source) (string, error) {
+//create and apply dns plan, If plan is successfully applied then returns dns record, which defines the desired records of the plan
+func createAndApplyPlan(ctx context.Context, cfg *externaldns.Config, r registry.Registry, endpointSource source.Source) ([]externaldnsv1alpha1.DNSRecord, error) {
 
 	var domainFilter endpoint.DomainFilter
 	if cfg.RegexDomainFilter.String() != "" {
@@ -195,15 +196,15 @@ func createAndApplyPlan(ctx context.Context, cfg *externaldns.Config, r registry
 
 	records, err := r.Records(ctx)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 
 	missingRecords := r.MissingRecords()
 
 	ctx = context.WithValue(ctx, provider.RecordsContextKey, records)
 	endpoints, err := endpointSource.Endpoints(ctx)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 
 	endpoints = r.AdjustEndpoints(endpoints)
@@ -221,7 +222,7 @@ func createAndApplyPlan(ctx context.Context, cfg *externaldns.Config, r registry
 		if missingRecordsPlan.Changes.HasChanges() {
 			err = r.ApplyChanges(ctx, missingRecordsPlan.Changes)
 			if err != nil {
-				return "", err
+				return nil, err
 			}
 			klog.Info("all missing records are created")
 		}
@@ -240,22 +241,24 @@ func createAndApplyPlan(ctx context.Context, cfg *externaldns.Config, r registry
 	klog.Info("Desired: ", pln.Desired)
 	klog.Info("Current: ", pln.Current)
 
-	var successMsg = ""
+	dnsRecs := make([]externaldnsv1alpha1.DNSRecord, 0)
 
 	if pln.Changes.HasChanges() {
 		err = r.ApplyChanges(ctx, pln.Changes)
 		if err != nil {
 			klog.Error("failed to apply plan")
-			return "", err
+			return nil, err
 		}
 		klog.Info("plan applied")
-		successMsg = "plan applied"
+
 	} else {
 		klog.Info("all records are already up to date")
-		successMsg = "all records are already up to date"
 	}
 
-	return successMsg, nil
+	for _, rec := range pln.Desired {
+		dnsRecs = append(dnsRecs, externaldnsv1alpha1.DNSRecord{Name: rec.DNSName, Target: rec.Targets.String()})
+	}
+	return dnsRecs, nil
 }
 
 func convertEDNSObjectToCfg(crd *externaldnsv1alpha1.ExternalDNS) (*externaldns.Config, error) {
@@ -748,37 +751,36 @@ func createRegistry(cfg *externaldns.Config, p provider.Provider) (registry.Regi
 	return r, err
 }
 
-func SetDNSRecords(edns *externaldnsv1alpha1.ExternalDNS, ctx context.Context) (string, error) {
+func SetDNSRecords(ctx context.Context, edns *externaldnsv1alpha1.ExternalDNS) ([]externaldnsv1alpha1.DNSRecord, error) {
 
 	cfg, err := convertEDNSObjectToCfg(edns)
 	if err != nil {
 		klog.Error("failed to convert crd into cfg.", err.Error())
-		return "", err
+		return nil, err
 	}
 	endpointsSource, err := createEndpointsSource(ctx, cfg)
 	if err != nil {
 		klog.Error("failed to create endpoints source.", err.Error())
-		return "", err
+		return nil, err
 	}
 
 	pvdr, err := createProviderFromCfg(ctx, cfg, endpointsSource)
 	if err != nil {
 		klog.Error("failed to create provider.", err.Error())
-		return "", err
+		return nil, err
 	}
 
 	reg, err := createRegistry(cfg, *pvdr)
 	if err != nil {
 		klog.Errorf("failed to create Registry.", err.Error())
-		return "", err
+		return nil, err
 	}
 
-	var successMsg string
-	successMsg, err = createAndApplyPlan(ctx, cfg, reg, endpointsSource)
-	if err != nil {
+	dnsRecs, e := createAndApplyPlan(ctx, cfg, reg, endpointsSource)
+	if e != nil {
 		klog.Errorf("failed to create and apply plan: %s", err.Error())
-		return "", err
+		return nil, e
 	}
 
-	return successMsg, nil
+	return dnsRecs, nil
 }