entry metric + improve handling for non-matchind provider includes

pkg/controller/provider/alicloud/handler.go

@@ -56,6 +56,10 @@ func NewHandler(logger logger.LogContext, config *provider.DNSHandlerConfig, met
 	return this, nil
 }
 
+func (h *Handler) ProviderType() string {
+	return TYPE_CODE
+}
+
 func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 	raw := []alidns.Domain{}
 	{
@@ -86,7 +90,9 @@ func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 			if err != nil {
 				return nil, err
 			}
-			hostedZone := provider.NewDNSHostedZone(z.DomainId, z.DomainName, z.DomainName, forwarded)
+			hostedZone := provider.NewDNSHostedZone(
+				this.ProviderType(), z.DomainId,
+				z.DomainName, z.DomainName, forwarded)
 			zones = append(zones, hostedZone)
 		}
 	}

pkg/controller/provider/aws/handler.go

@@ -68,6 +68,10 @@ func NewHandler(logger logger.LogContext, config *provider.DNSHandlerConfig, met
 	return this, nil
 }
 
+func (h *Handler) ProviderType() string {
+	return TYPE_CODE
+}
+
 func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 	rt := provider.M_LISTZONES
 	raw := []*route53.HostedZone{}
@@ -101,7 +105,7 @@ func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 		}
 		this.handleRecordSets(id, aggr)
 
-		hostedZone := provider.NewDNSHostedZone(
+		hostedZone := provider.NewDNSHostedZone(this.ProviderType(),
 			id, dns.NormalizeHostname(domain), aws.StringValue(z.Id), forwarded)
 		zones = append(zones, hostedZone)
 	}

pkg/controller/provider/azure/handler.go

@@ -92,6 +92,10 @@ func NewHandler(logger logger.LogContext, config *provider.DNSHandlerConfig, met
 
 var re = regexp.MustCompile("/resourceGroups/([^/]+)/")
 
+func (h *Handler) ProviderType() string {
+	return TYPE_CODE
+}
+
 func (h *Handler) GetZones() (provider.DNSHostedZones, error) {
 	zones := provider.DNSHostedZones{}
 
@@ -115,6 +119,7 @@ func (h *Handler) GetZones() (provider.DNSHostedZones, error) {
 
 		// ResourceGroup needed for requests to Azure. Remember by adding to Id. Split by calling splitZoneid().
 		hostedZone := provider.NewDNSHostedZone(
+			h.ProviderType(),
 			resourceGroup+"/"+*item.Name,
 			dns.NormalizeHostname(*item.Name),
 			"",

pkg/controller/provider/google/handler.go

@@ -81,6 +81,10 @@ func NewHandler(logger logger.LogContext, config *provider.DNSHandlerConfig, met
 	return this, nil
 }
 
+func (h *Handler) ProviderType() string {
+	return TYPE_CODE
+}
+
 func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 	rt := provider.M_LISTZONES
 	raw := []*googledns.ManagedZone{}
@@ -108,7 +112,7 @@ func (this *Handler) GetZones() (provider.DNSHostedZones, error) {
 			}
 		}
 		this.handleRecordSets(z.Name, f)
-		hostedZone := provider.NewDNSHostedZone(
+		hostedZone := provider.NewDNSHostedZone(this.ProviderType(),
 			z.Name, dns.NormalizeHostname(z.DnsName), "", forwarded)
 		zones = append(zones, hostedZone)
 	}

pkg/controller/provider/openstack/handler.go

@@ -100,13 +100,18 @@ func readAuthConfig(config *provider.DNSHandlerConfig) (*authConfig, error) {
 	return &authConfig, nil
 }
 
+func (h *Handler) ProviderType() string {
+	return TYPE_CODE
+}
+
 func (h *Handler) GetZones() (provider.DNSHostedZones, error) {
 	hostedZones := provider.DNSHostedZones{}
 
 	zoneHandler := func(zone *zones.Zone) error {
 		forwarded := h.collectForwardedSubzones(zone)
 
 		hostedZone := provider.NewDNSHostedZone(
+			h.ProviderType(),
 			zone.ID,
 			dns.NormalizeHostname(zone.Name),
 			"",

pkg/dns/provider/changemodel.go

@@ -71,8 +71,15 @@ func (this *ChangeGroup) cleanup(logger logger.LogContext, model *ChangeModel) b
 		if !ok {
 			if s.IsOwnedBy(model.owners) {
 				if e := model.IsStale(s.Name); e != nil {
-					model.Infof("found stale set '%s' -> preserve unchanged", s.Name)
-					e.UpdateStatus(logger, v1alpha1.STATE_STALE, "errornous entry presevered in provider", nil)
+					status := e.object.Status()
+					msg := MSG_PRESERVED
+					if status.State == v1alpha1.STATE_ERROR || status.State == v1alpha1.STATE_INVALID {
+						msg = msg + ": " + utils.StringValue(status.Message)
+						model.Infof("found stale set '%s': %s -> preserve unchanged", utils.StringValue(status.Message), s.Name)
+					} else {
+						model.Infof("found stale set '%s' -> preserve unchanged", s.Name)
+					}
+					e.UpdateStatus(logger, v1alpha1.STATE_STALE, msg, nil)
 				} else {
 					model.Infof("found unapplied managed set '%s'", s.Name)
 					for ty := range s.Sets {

pkg/dns/provider/default.go

@@ -39,10 +39,11 @@ func NewDNSZoneState(sets dns.DNSSets) DNSZoneState {
 ////////////////////////////////////////////////////////////////////////////////
 
 type DefaultDNSHostedZone struct {
-	id        string   // identifying id for provider api
-	domain    string   // base domain for zone
-	forwarded []string // forwarded sub domains
-	key       string   // internal key used by provider (not used by this lib)
+	providerType string   // provider type
+	id           string   // identifying id for provider api
+	domain       string   // base domain for zone
+	forwarded    []string // forwarded sub domains
+	key          string   // internal key used by provider (not used by this lib)
 }
 
 func (this *DefaultDNSHostedZone) Key() string {
@@ -52,6 +53,10 @@ func (this *DefaultDNSHostedZone) Key() string {
 	return this.id
 }
 
+func (this *DefaultDNSHostedZone) ProviderType() string {
+	return this.providerType
+}
+
 func (this *DefaultDNSHostedZone) Id() string {
 	return this.id
 }
@@ -64,6 +69,6 @@ func (this *DefaultDNSHostedZone) ForwardedDomains() []string {
 	return this.forwarded
 }
 
-func NewDNSHostedZone(id, domain, key string, forwarded []string) DNSHostedZone {
-	return &DefaultDNSHostedZone{id: id, key: key, domain: domain, forwarded: forwarded}
+func NewDNSHostedZone(ptype string, id, domain, key string, forwarded []string) DNSHostedZone {
+	return &DefaultDNSHostedZone{providerType: ptype, id: id, key: key, domain: domain, forwarded: forwarded}
 }

pkg/dns/provider/entry.go

@@ -38,6 +38,8 @@ import (
 	corev1 "k8s.io/api/core/v1"
 )
 
+const MSG_PRESERVED = "errornous entry preserved in provider"
+
 type Entry struct {
 	lock      sync.Mutex
 	object    *dnsutils.DNSEntryObject
@@ -240,8 +242,7 @@ func (this *Entry) Update(logger logger.LogContext, state *state, op string, own
 	}
 
 	if utils.StringValue(status.ProviderType) != resp {
-		err = state.RemoveFinalizer(object)
-		return reconcile.RepeatOnError(logger, err)
+		return reconcile.RepeatOnError(logger, state.RemoveFinalizer(object))
 	}
 
 	logger.Infof("%s ENTRY", op)
@@ -327,8 +328,16 @@ func (this *Entry) Update(logger logger.LogContext, state *state, op string, own
 		}
 		mod.AssureStringPtrValue(&status.Zone, zoneid)
 		if err != nil {
-			mod.AssureStringValue(&status.State, api.STATE_ERROR)
-			mod.AssureStringPtrValue(&status.Message, err.Error())
+			if status.State != api.STATE_STALE {
+				mod.AssureStringValue(&status.State, api.STATE_ERROR)
+				mod.AssureStringPtrValue(&status.Message, err.Error())
+			} else {
+				if strings.HasPrefix(*status.Message, MSG_PRESERVED) {
+					mod.AssureStringPtrValue(&status.Message, MSG_PRESERVED+": "+err.Error())
+				} else {
+					mod.AssureStringPtrValue(&status.Message, err.Error())
+				}
+			}
 		} else {
 			if zoneid == "" {
 				mod.AssureStringValue(&status.State, api.STATE_ERROR)

pkg/dns/provider/interface.go

@@ -55,6 +55,7 @@ func NewConfigForController(c controller.Interface, factory DNSHandlerFactory) C
 }
 
 type DNSHostedZone interface {
+	ProviderType() string
 	Key() string
 	Id() string
 	Domain() string
@@ -106,6 +107,7 @@ type Metrics interface {
 }
 
 type DNSHandler interface {
+	ProviderType() string
 	GetZones() (DNSHostedZones, error)
 	GetZoneState(DNSHostedZone) (DNSZoneState, error)
 	ExecuteRequests(logger logger.LogContext, zone DNSHostedZone, state DNSZoneState, reqs []*ChangeRequest) error

pkg/dns/provider/provider.go

@@ -64,10 +64,9 @@ func newProvider() *dnsProvider {
 ///////////////////////////////////////////////////////////////////////////////
 
 type DNSAccount struct {
-	lock         sync.Mutex
-	handler      DNSHandler
-	config       utils.Properties
-	providerType string
+	lock    sync.Mutex
+	handler DNSHandler
+	config  utils.Properties
 
 	hash    string
 	clients resources.ObjectNameSet
@@ -83,11 +82,11 @@ var _ DNSHandler = &DNSAccount{}
 var _ Metrics = &DNSAccount{}
 
 func (this *DNSAccount) AddRequests(requestType string, n int) {
-	metrics.AddRequests(this.providerType, this.hash, requestType, n)
+	metrics.AddRequests(this.handler.ProviderType(), this.hash, requestType, n)
 }
 
-func (this *DNSAccount) Type() string {
-	return this.providerType
+func (this *DNSAccount) ProviderType() string {
+	return this.handler.ProviderType()
 }
 
 func (this *DNSAccount) Hash() string {
@@ -142,7 +141,7 @@ func (this *AccountCache) Get(logger logger.LogContext, provider *dnsutils.DNSPr
 			Config:     provider.Spec().ProviderConfig,
 			DryRun:     state.GetConfig().Dryrun,
 		}
-		a = &DNSAccount{providerType: provider.Spec().Type, ttl: this.ttl, config: props, hash: h, clients: resources.ObjectNameSet{}}
+		a = &DNSAccount{ttl: this.ttl, config: props, hash: h, clients: resources.ObjectNameSet{}}
 		a.handler, err = state.GetHandlerFactory().Create(logger, &cfg, a)
 		if err != nil {
 			return nil, err
@@ -169,7 +168,7 @@ func (this *AccountCache) Release(logger logger.LogContext, a *DNSAccount, name
 	if len(a.clients) == 0 {
 		logger.Infof("releasing account for %s (%s)", name, a.Hash())
 		delete(this.cache, a.hash)
-		metrics.DeleteAccount(a.Type(), a.Hash())
+		metrics.DeleteAccount(a.ProviderType(), a.Hash())
 	} else {
 		logger.Infof("keeping account for %s (%s): %d client(s)", name, a.Hash(), len(a.clients))
 	}
@@ -205,6 +204,7 @@ type dnsProviderVersion struct {
 
 	object  *dnsutils.DNSProviderObject
 	account *DNSAccount
+	valid   bool
 
 	secret      resources.ObjectName
 	def_include utils.StringSet
@@ -216,6 +216,10 @@ type dnsProviderVersion struct {
 	excluded utils.StringSet
 }
 
+func (this *dnsProviderVersion) IsValid() bool {
+	return this.valid
+}
+
 func (this *dnsProviderVersion) equivalentTo(v *dnsProviderVersion) bool {
 	if this.account != v.account {
 		return false
@@ -282,7 +286,7 @@ func updateDNSProvider(logger logger.LogContext, state *state, provider *dnsutil
 
 	this.account, err = state.GetDNSAccount(logger, provider, props)
 	if err != nil {
-		return nil, reconcile.Delay(logger, err)
+		return this, reconcile.Delay(logger, err)
 	}
 
 	dspec := provider.DNSProvider().Spec.Domains
@@ -296,7 +300,7 @@ func updateDNSProvider(logger logger.LogContext, state *state, provider *dnsutil
 
 	this.zones, err = this.account.GetZones()
 	if err != nil {
-		return nil, this.failed(logger, false, fmt.Errorf("cannot get zones: %s", err), true)
+		return this, this.failed(logger, false, fmt.Errorf("cannot get zones: %s", err), true)
 	}
 
 	included, err := filterByZones(this.def_include, this.zones)
@@ -310,14 +314,14 @@ func updateDNSProvider(logger logger.LogContext, state *state, provider *dnsutil
 
 	if len(this.def_include) == 0 {
 		if len(this.zones) == 0 {
-			return nil, this.failed(logger, false, fmt.Errorf("no hosted zones found"), false)
+			return this, this.failed(logger, false, fmt.Errorf("no hosted zones found"), false)
 		}
 		for _, z := range this.zones {
 			included.Add(z.Domain())
 		}
 	} else {
 		if len(included) == 0 {
-			return nil, this.failed(logger, false, fmt.Errorf("no domain matching hosting zones"), false)
+			return this, this.failed(logger, false, fmt.Errorf("no domain matching hosting zones"), false)
 
 		}
 	}
@@ -341,6 +345,7 @@ func updateDNSProvider(logger logger.LogContext, state *state, provider *dnsutil
 	this.included = included
 	this.excluded = excluded
 
+	this.valid = true
 	return this, this.succeeded(logger, this.object.SetDomains(included, excluded))
 }