add --txt-suffix feature

main.go

@@ -299,7 +299,7 @@ func main() {
 	case "noop":
 		r, err = registry.NewNoopRegistry(p)
 	case "txt":
-		r, err = registry.NewTXTRegistry(p, cfg.TXTPrefix, cfg.TXTOwnerID, cfg.TXTCacheInterval)
+		r, err = registry.NewTXTRegistry(p, cfg.TXTPrefix, cfg.TXTSuffix, cfg.TXTOwnerID, cfg.TXTCacheInterval)
 	case "aws-sd":
 		r, err = registry.NewAWSSDRegistry(p.(*awssd.AWSSDProvider), cfg.TXTOwnerID)
 	default:

pkg/apis/externaldns/types.go

@@ -109,6 +109,7 @@ type Config struct {
 	Registry                          string
 	TXTOwnerID                        string
 	TXTPrefix                         string
+	TXTSuffix                         string
 	Interval                          time.Duration
 	Once                              bool
 	DryRun                            bool
@@ -205,6 +206,7 @@ var defaultConfig = &Config{
 	Registry:                    "txt",
 	TXTOwnerID:                  "default",
 	TXTPrefix:                   "",
+	TXTSuffix:                   "",
 	TXTCacheInterval:            0,
 	Interval:                    time.Minute,
 	Once:                        false,
@@ -392,7 +394,8 @@ func (cfg *Config) ParseFlags(args []string) error {
 	// Flags related to the registry
 	app.Flag("registry", "The registry implementation to use to keep track of DNS record ownership (default: txt, options: txt, noop, aws-sd)").Default(defaultConfig.Registry).EnumVar(&cfg.Registry, "txt", "noop", "aws-sd")
 	app.Flag("txt-owner-id", "When using the TXT registry, a name that identifies this instance of ExternalDNS (default: default)").Default(defaultConfig.TXTOwnerID).StringVar(&cfg.TXTOwnerID)
-	app.Flag("txt-prefix", "When using the TXT registry, a custom string that's prefixed to each ownership DNS record (optional)").Default(defaultConfig.TXTPrefix).StringVar(&cfg.TXTPrefix)
+	app.Flag("txt-prefix", "When using the TXT registry, a custom string that's prefixed to each ownership DNS record (optional). Mutual exclusive with txt-suffix!").Default(defaultConfig.TXTPrefix).StringVar(&cfg.TXTPrefix)
+	app.Flag("txt-suffix", "When using the TXT registry, a custom string that's suffixed to the host portion of each ownership DNS record (optional). Mutual exclusive with txt-prefix!").Default(defaultConfig.TXTSuffix).StringVar(&cfg.TXTSuffix)
 
 	// Flags related to the main control loop
 	app.Flag("txt-cache-interval", "The interval between cache synchronizations in duration format (default: disabled)").Default(defaultConfig.TXTCacheInterval.String()).DurationVar(&cfg.TXTCacheInterval)

pkg/apis/externaldns/validation/validation.go

@@ -91,5 +91,10 @@ func ValidateConfig(cfg *externaldns.Config) error {
 	if cfg.IgnoreHostnameAnnotation && cfg.FQDNTemplate == "" {
 		return errors.New("FQDN Template must be set if ignoring annotations")
 	}
+
+	if len(cfg.TXTPrefix) > 0 && len(cfg.TXTSuffix) > 0 {
+		return errors.New("txt-prefix and txt-suffix are mutual exclusive")
+	}
+
 	return nil
 }

registry/txt.go

@@ -43,12 +43,16 @@ type TXTRegistry struct {
 }
 
 // NewTXTRegistry returns new TXTRegistry object
-func NewTXTRegistry(provider provider.Provider, txtPrefix, ownerID string, cacheInterval time.Duration) (*TXTRegistry, error) {
+func NewTXTRegistry(provider provider.Provider, txtPrefix, txtSuffix, ownerID string, cacheInterval time.Duration) (*TXTRegistry, error) {
 	if ownerID == "" {
 		return nil, errors.New("owner id cannot be empty")
 	}
 
-	mapper := newPrefixNameMapper(txtPrefix)
+	if len(txtPrefix) > 0 && len(txtSuffix) > 0 {
+		return nil, errors.New("txt-prefix and txt-suffix are mutual exclusive")
+	}
+
+	mapper := newaffixNameMapper(txtPrefix, txtSuffix)
 
 	return &TXTRegistry{
 		provider:      provider,
@@ -201,26 +205,35 @@ type nameMapper interface {
 	toTXTName(string) string
 }
 
-type prefixNameMapper struct {
+type affixNameMapper struct {
 	prefix string
+	suffix string
 }
 
-var _ nameMapper = prefixNameMapper{}
+var _ nameMapper = affixNameMapper{}
 
-func newPrefixNameMapper(prefix string) prefixNameMapper {
-	return prefixNameMapper{prefix: strings.ToLower(prefix)}
+func newaffixNameMapper(prefix string, suffix string) affixNameMapper {
+	return affixNameMapper{prefix: strings.ToLower(prefix), suffix: strings.ToLower(suffix)}
 }
 
-func (pr prefixNameMapper) toEndpointName(txtDNSName string) string {
+func (pr affixNameMapper) toEndpointName(txtDNSName string) string {
 	lowerDNSName := strings.ToLower(txtDNSName)
-	if strings.HasPrefix(lowerDNSName, pr.prefix) {
+	if strings.HasPrefix(lowerDNSName, pr.prefix) && len(pr.suffix) == 0 {
 		return strings.TrimPrefix(lowerDNSName, pr.prefix)
 	}
+
+	if len(pr.suffix) > 0 {
+		DNSName := strings.SplitN(lowerDNSName, ".", 2)
+		if strings.HasSuffix(DNSName[0], pr.suffix) {
+			return strings.TrimSuffix(DNSName[0], pr.suffix) + "." + DNSName[1]
+		}
+	}
 	return ""
 }
 
-func (pr prefixNameMapper) toTXTName(endpointDNSName string) string {
-	return pr.prefix + endpointDNSName
+func (pr affixNameMapper) toTXTName(endpointDNSName string) string {
+	DNSName := strings.SplitN(endpointDNSName, ".", 2)
+	return pr.prefix + DNSName[0] + pr.suffix + "." + DNSName[1]
 }
 
 func (im *TXTRegistry) addToCache(ep *endpoint.Endpoint) {