Update lego

vendor/github.com/xenolf/lego/providers/dns/linode/linode.go

@@ -19,6 +19,21 @@ const (
 	dnsUpdateFudgeSecs = 120
 )
 
+// Config is used to configure the creation of the DNSProvider
+type Config struct {
+	APIKey          string
+	PollingInterval time.Duration
+	TTL             int
+}
+
+// NewDefaultConfig returns a default configuration for the DNSProvider
+func NewDefaultConfig() *Config {
+	return &Config{
+		PollingInterval: env.GetOrDefaultSecond("LINODE_POLLING_INTERVAL", 15*time.Second),
+		TTL:             env.GetOrDefaultInt("LINODE_TTL", 60),
+	}
+}
+
 type hostedZoneInfo struct {
 	domainID     int
 	resourceName string
@@ -26,6 +41,7 @@ type hostedZoneInfo struct {
 
 // DNSProvider implements the acme.ChallengeProvider interface.
 type DNSProvider struct {
+	config *Config
 	client *dns.DNS
 }
 
@@ -34,27 +50,44 @@ type DNSProvider struct {
 func NewDNSProvider() (*DNSProvider, error) {
 	values, err := env.Get("LINODE_API_KEY")
 	if err != nil {
-		return nil, fmt.Errorf("Linode: %v", err)
+		return nil, fmt.Errorf("linode: %v", err)
 	}
 
-	return NewDNSProviderCredentials(values["LINODE_API_KEY"])
+	config := NewDefaultConfig()
+	config.APIKey = values["LINODE_API_KEY"]
+
+	return NewDNSProviderConfig(config)
 }
 
-// NewDNSProviderCredentials uses the supplied credentials to return a
-// DNSProvider instance configured for Linode.
+// NewDNSProviderCredentials uses the supplied credentials
+// to return a DNSProvider instance configured for Linode.
+// Deprecated
 func NewDNSProviderCredentials(apiKey string) (*DNSProvider, error) {
-	if len(apiKey) == 0 {
-		return nil, errors.New("Linode credentials missing")
+	config := NewDefaultConfig()
+	config.APIKey = apiKey
+
+	return NewDNSProviderConfig(config)
+}
+
+// NewDNSProviderConfig return a DNSProvider instance configured for Linode.
+func NewDNSProviderConfig(config *Config) (*DNSProvider, error) {
+	if config == nil {
+		return nil, errors.New("linode: the configuration of the DNS provider is nil")
+	}
+
+	if len(config.APIKey) == 0 {
+		return nil, errors.New("linode: credentials missing")
 	}
 
 	return &DNSProvider{
-		client: dns.New(apiKey),
+		config: config,
+		client: dns.New(config.APIKey),
 	}, nil
 }
 
 // Timeout returns the timeout and interval to use when checking for DNS
 // propagation.  Adjusting here to cope with spikes in propagation times.
-func (p *DNSProvider) Timeout() (timeout, interval time.Duration) {
+func (d *DNSProvider) Timeout() (timeout, interval time.Duration) {
 	// Since Linode only updates their zone files every X minutes, we need
 	// to figure out how many minutes we have to wait until we hit the next
 	// interval of X.  We then wait another couple of minutes, just to be
@@ -65,19 +98,19 @@ func (p *DNSProvider) Timeout() (timeout, interval time.Duration) {
 	timeout = (time.Duration(minsRemaining) * time.Minute) +
 		(dnsMinTTLSecs * time.Second) +
 		(dnsUpdateFudgeSecs * time.Second)
-	interval = 15 * time.Second
+	interval = d.config.PollingInterval
 	return
 }
 
 // Present creates a TXT record using the specified parameters.
-func (p *DNSProvider) Present(domain, token, keyAuth string) error {
+func (d *DNSProvider) Present(domain, token, keyAuth string) error {
 	fqdn, value, _ := acme.DNS01Record(domain, keyAuth)
-	zone, err := p.getHostedZoneInfo(fqdn)
+	zone, err := d.getHostedZoneInfo(fqdn)
 	if err != nil {
 		return err
 	}
 
-	if _, err = p.client.CreateDomainResourceTXT(zone.domainID, acme.UnFqdn(fqdn), value, 60); err != nil {
+	if _, err = d.client.CreateDomainResourceTXT(zone.domainID, acme.UnFqdn(fqdn), value, 60); err != nil {
 		return err
 	}
 
@@ -85,15 +118,15 @@ func (p *DNSProvider) Present(domain, token, keyAuth string) error {
 }
 
 // CleanUp removes the TXT record matching the specified parameters.
-func (p *DNSProvider) CleanUp(domain, token, keyAuth string) error {
+func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 	fqdn, value, _ := acme.DNS01Record(domain, keyAuth)
-	zone, err := p.getHostedZoneInfo(fqdn)
+	zone, err := d.getHostedZoneInfo(fqdn)
 	if err != nil {
 		return err
 	}
 
 	// Get all TXT records for the specified domain.
-	resources, err := p.client.GetResourcesByType(zone.domainID, "TXT")
+	resources, err := d.client.GetResourcesByType(zone.domainID, "TXT")
 	if err != nil {
 		return err
 	}
@@ -101,7 +134,7 @@ func (p *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 	// Remove the specified resource, if it exists.
 	for _, resource := range resources {
 		if resource.Name == zone.resourceName && resource.Target == value {
-			resp, err := p.client.DeleteDomainResource(resource.DomainID, resource.ResourceID)
+			resp, err := d.client.DeleteDomainResource(resource.DomainID, resource.ResourceID)
 			if err != nil {
 				return err
 			}
@@ -115,16 +148,17 @@ func (p *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 	return nil
 }
 
-func (p *DNSProvider) getHostedZoneInfo(fqdn string) (*hostedZoneInfo, error) {
+func (d *DNSProvider) getHostedZoneInfo(fqdn string) (*hostedZoneInfo, error) {
 	// Lookup the zone that handles the specified FQDN.
 	authZone, err := acme.FindZoneByFqdn(fqdn, acme.RecursiveNameservers)
 	if err != nil {
 		return nil, err
 	}
+
 	resourceName := strings.TrimSuffix(fqdn, "."+authZone)
 
 	// Query the authority zone.
-	domain, err := p.client.GetDomain(acme.UnFqdn(authZone))
+	domain, err := d.client.GetDomain(acme.UnFqdn(authZone))
 	if err != nil {
 		return nil, err
 	}