Redesigning how providers register themselves

[tlimoncelli]

The way providers work has a number of problems that I'd like to correct.

1. Providers register themselves as Registrars or DSPs. They're usually both.

• Historical note: Oops! We thought it would be the exception rather than the rule.
• Providers should just register. Whether they are Reg or Dsp should be determined by if they complete the proper interfaces.

2. Providers receive their metainfo as a raw JSON blob, which they must then parse.

• Historical note: Oops! We though this would provide excellent flexibility, and allow static typing (ints and strings, rather than "everything is a string")
• It turns out, everything is (basically) a string. The rare exceptions can be handled easily.
• It turns out that, while the JSON parsing isn't difficult, it is complexity that a new contributor shouldn't have to address.
• What would be better: Deliver the meta info as a map[string]string (or maybe a separate map for bools). All processing should be done ahead of time.

3. The whole NewRegistrar(), NewDnsProvider(), DnsProvider() thing was future-proofing that never paid off.

• Historical note: Ooops! We were bad at predicting the future.
• What would be better:
  • Eliminate the functions. Use the "key" name from creds.json instead:
  • New:

ZONE("example.com",
    REGISTRAR('credkey'),
    SERVER('credkey'),
    SERVER('credkey2'),   // If you are dual-homed
    A("www", "1.2.3.4"),
...
);

With meta fields specified like this:

ZONE("example.com",
    REGISTRAR('credkey', { field1: "data", field2: "data2"} ),
    SERVER('credkey', { field1: "data", field2: "data2"}),
    A("www", "1.2.3.4"),
...
);

ZONE_EXTEND() would work like DOMAIN_EXTEND()

4. Providers register themselves in an inflexible way.

• What would be better: Pass a struct with fields. We can always add more fields.

---

Here is example code for how providers would register itself:

func init() {
  providers.Register( 
    providers.RegisterOpts{
      Name:               "CLOUDFLARE",
      NameAliases:        []string{"CLOUDFLAREAPI"},
      MaintainerGithubID: "@tresni",
      SupportLevel:       "official", // "official", "community", "needs_volunteer", "deprecated"
      Initializer:        initializer,
      RecordAuditor:      AuditRecords,
      BrokeConcurrency:   false,
      DualHostSupport:    "Cloudflare will not work well in situations where it is not the only DNS server",
      // Fields in the creds.json file:
      CredsFields: []string{
        "apitoken",
        "apikey", "apiuser",
        "accountid",
      },
      // Fields in the REGISTRAR("credkey", { metafield: "foo" })
      MetaFields: []string{
        "ip_conversions:string",
        "ignored_labels:string",
        "transcode_log:string",
        "manage_redirects:bool",
        "manage_workers:bool",
        "manage_single_redirects:bool",
      },
      // DNS RecordTypes supported:
      RecordTypes: []any{
        "A",
        "AAAA",
        "ALIAS:supported:CF automatically flattens CNAME records into A records dynamically",
        "CAA",
        "DHCID:unimplemented",   // Indicates provider supports it, but DNSControl doesn't have code to support it
        "DNAME:unimplemented:This note appears in documentation",   // Anything after "note:" is for documentation.
        "DS:both",    // "apex" (DS only supported at the apex), "children" (supports DS on children), "both" (default)
        "HTTPS",
        "MX",
        "NAPTR",
        "OPENPGPKEY",
        "PTR",
        "SMIMEA",
        "SRV", 
        "SSHFP",
        "SVCB",
        "TLSA",
        "TXT",
        // Custom Types
        "CF_SINGLE_REDIRECT",
        "CF_REDIRECT",
        "CF_TEMP_REDIRECT",
        "CF_WORKER_ROUTE",
      }, 
    },
  ) 
} 

/*
    client := providers.NewClient("credKey") // Get an API handle
  _, ok := client.(providers.Registrar) // Is this a registrar?
  _, ok := client.(providers.DNSServiceProvider) // Is this a DNS Service Provider?
  _, ok := client.(providers.ZoneLister) // Does "get-zones" work?
  _, ok := client.(providers.ZoneCreator) // Does "create-zone" work?
  rtypeMap := providers.GetSupportedRecordTypes("CLOUDFLARE") // List supported record types
  b := providers.IsRTypeSupported("CLOUDFLARE", "TXT") // Is TXT supported?
  b := providers.IsFeatureSupported("CLOUDFLARE", "feature_name") // Is feature_name supported?

Signature for the initializer (called any time an API client handle is needed):
  func newCloudflare(m map[string]string, metadata map[string]string) (providers.DNSServiceProvider, error) {}

*/

For backwards compatibility, the providers.Register() function will set things up so that old code still works.

[tlimoncelli]

TODO:

• How to indicate that "DS" might be "all", "child only", "apex only"?
• Move "features" to a substructure? (for things like DualHostSupport, UnsupportedConcurrency, etc)
• Rather than passing in functions for Initializer and RecordAuditor, should those be methods on the provider struct?

[chicks-net]

From the provider maintainer perspective I like just defining the list of supported record types. It sounds like the capabilities matrix will be created based on that list so that existing tools such as the documentation generator work nicely. From the documentation generator perspective it would be harder to work with a list of unknown size. Having the delineated capabilities is very handy from the docs perspective and presumably other programatic consumers of the providers.