providers

Documentation

Index

• Variables
• func CreateDsps(d *models.DNSConfig, providerConfigs map[string]map[string]string) (map[string]DNSServiceProvider, error)
• func CreateRegistrars(d *models.DNSConfig, providerConfigs map[string]map[string]string) (map[string]Registrar, error)
• func ProviderHasCabability(pType string, cap Capability) bool
• func RegisterCustomRecordType(name, provider, realType string)
• func RegisterDomainServiceProviderType(name string, init DspInitializer, pm ...ProviderMetadata)
• func RegisterRegistrarType(name string, init RegistrarInitializer, pm ...ProviderMetadata)
• type Capability
• type CustomRType
  • func GetCustomRecordType(rType string) *CustomRType
• type DNSServiceProvider
  • func CreateDNSProvider(dType string, config map[string]string, meta json.RawMessage) (DNSServiceProvider, error)
• type DocumentationNote
  • func Can(comments ...string) *DocumentationNote
  • func Cannot(comments ...string) *DocumentationNote
  • func Unimplemented(comments ...string) *DocumentationNote
• type DocumentationNotes
• type DomainCreator
• type DspInitializer
• type None
  • func (n None) GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error)
  • func (n None) GetNameservers(string) ([]*models.Nameserver, error)
  • func (n None) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error)
• type ProviderMetadata
• type Registrar
• type RegistrarInitializer

Variables

var DNSProviderTypes = map[string]DspInitializer{}

var Notes = map[string]DocumentationNotes{}

Notes is a collection of all documentation notes, keyed by provider type

var RegistrarTypes = map[string]RegistrarInitializer{}

Functions

func CreateDsps

func CreateDsps(d *models.DNSConfig, providerConfigs map[string]map[string]string) (map[string]DNSServiceProvider, error)

func CreateRegistrars

func CreateRegistrars(d *models.DNSConfig, providerConfigs map[string]map[string]string) (map[string]Registrar, error)

CreateRegistrars will load all registrars from the dns config, and create instances of the correct type using data from the provider config to load relevant keys and options.

func ProviderHasCabability

func ProviderHasCabability(pType string, cap Capability) bool

func RegisterCustomRecordType

func RegisterCustomRecordType(name, provider, realType string)

RegisterCustomRecordType registers a record type that is only valid for one provider. provider is the registered type of provider this is valid with name is the record type as it will appear in the js. (should be something like $PROVIDER_FOO) realType is the record type it will be replaced with after validation

func RegisterDomainServiceProviderType

func RegisterDomainServiceProviderType(name string, init DspInitializer, pm ...ProviderMetadata)

RegisterDomainServiceProviderType adds a dsp to the registry with the given initialization function.

func RegisterRegistrarType

func RegisterRegistrarType(name string, init RegistrarInitializer, pm ...ProviderMetadata)

RegisterRegistrarType adds a registrar type to the registry by providing a suitable initialization function.

Types

type Capability

type Capability uint32

Capability is a bitmasked set of "features" that a provider supports. Only use constants from this package.

const (
	// CanUseAlias indicates the provider support ALIAS records (or flattened CNAMES). Up to the provider to translate them to the appropriate record type.
	// If you add something to this list, you probably want to add it to pkg/normalize/validate.go checkProviderCapabilities() or somewhere near there.
	CanUseAlias Capability = iota
	// CanUsePTR indicates the provider can handle PTR records
	CanUsePTR
	// CanUseSRV indicates the provider can handle SRV records
	CanUseSRV
	// CanUseCAA indicates the provider can handle CAA records
	CanUseCAA
	// CanUseTLSA indicates the provider can handle TLSA records
	CanUseTLSA
	// CantUseNOPURGE indicates NO_PURGE is broken for this provider. To make it
	// work would require complex emulation of an incremental update mechanism,
	// so it is easier to simply mark this feature as not working for this
	// provider.
	CantUseNOPURGE

	// DocOfficiallySupported means it is actively used and maintained by stack exchange
	DocOfficiallySupported
	// DocDualHost means provider allows full management of apex NS records, so we can safely dual-host with anothe provider
	DocDualHost
	// DocCreateDomains means provider can add domains with the `dnscontrol create-domains` command
	DocCreateDomains
)

type CustomRType

type CustomRType struct {
	Name     string
	Provider string
	RealType string
}

func GetCustomRecordType

func GetCustomRecordType(rType string) *CustomRType

GetCustomRecordType returns a registered custom record type, or nil if none

type DNSServiceProvider

type DNSServiceProvider interface {
	GetNameservers(domain string) ([]*models.Nameserver, error)
	GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error)
}

DNSServiceProvider is able to generate a set of corrections that need to be made to correct records for a domain

func CreateDNSProvider

func CreateDNSProvider(dType string, config map[string]string, meta json.RawMessage) (DNSServiceProvider, error)

type DocumentationNote

type DocumentationNote struct {
	HasFeature    bool
	Unimplemented bool
	Comment       string
	Link          string
}

DocumentationNote is a way for providers to give more detail about what features they support.

func Can

func Can(comments ...string) *DocumentationNote

Can is a small helper for concisely creating Documentation Notes comments are variadic for easy ommission. First is comment, second is link, the rest are ignored.

func Cannot

func Cannot(comments ...string) *DocumentationNote

Cannot is a small helper for concisely creating Documentation Notes comments are variadic for easy ommission. First is comment, second is link, the rest are ignored.

func Unimplemented

func Unimplemented(comments ...string) *DocumentationNote

Unimplemented is a small helper for concisely creating Documentation Notes comments are variadic for easy ommission. First is comment, second is link, the rest are ignored.

type DocumentationNotes

type DocumentationNotes map[Capability]*DocumentationNote

DocumentationNotes is a full list of notes for a single provider

type DomainCreator

type DomainCreator interface {
	EnsureDomainExists(domain string) error
}

DomainCreator should be implemented by providers that have the ability to add domains to an account. the create-domains command can be run to ensure all domains are present before running preview/push

type DspInitializer

type DspInitializer func(map[string]string, json.RawMessage) (DNSServiceProvider, error)

DspInitializer is a function to create a DNS service provider. Function will be passed the unprocessed json payload from the configuration file for the given provider.

type None

type None struct{}

None is a basic provider type that does absolutely nothing. Can be useful as a placeholder for third parties or unimplemented providers.

func (None) GetDomainCorrections

func (n None) GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error)

func (None) GetNameservers

func (n None) GetNameservers(string) ([]*models.Nameserver, error)

func (None) GetRegistrarCorrections

func (n None) GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error)

type ProviderMetadata

type ProviderMetadata interface{}

ProviderMetadata is a common interface for DocumentationNotes and Capability to be used interchangably

type Registrar

type Registrar interface {
	GetRegistrarCorrections(dc *models.DomainConfig) ([]*models.Correction, error)
}

Registrar is an interface for a domain registrar. It can return a list of needed corrections to be applied in the future.

type RegistrarInitializer

type RegistrarInitializer func(map[string]string) (Registrar, error)

RegistrarInitializer is a function to create a registrar. Function will be passed the unprocessed json payload from the configuration file for the given provider.