← Back to branch summary

~hduran-8/+junk/caddy

« back to all changes in this revision

Viewing changes to debian/gocode/src/github.com/xenolf/lego/providers/dns/dnspod/dnspod.go

  • Committer: Horacio Durán
  • Date: 2017-01-20 16:21:20 UTC
  • Revision ID: horacio.duran@canonical.com-20170120162120-l82mfqwmsclnk838
Upgrade to 0.9.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/gocode/src/github.com/xenolf/lego/providers/dns/dnspod/dnspod.go
 
1
// Package dnspod implements a DNS provider for solving the DNS-01 challenge
 
2
// using dnspod DNS.
 
3
package dnspod
 
4
 
 
5
import (
 
6
        "fmt"
 
7
        "os"
 
8
        "strings"
 
9
 
 
10
        "github.com/decker502/dnspod-go"
 
11
        "github.com/xenolf/lego/acme"
 
12
)
 
13
 
 
14
// DNSProvider is an implementation of the acme.ChallengeProvider interface.
 
15
type DNSProvider struct {
 
16
        client *dnspod.Client
 
17
}
 
18
 
 
19
// NewDNSProvider returns a DNSProvider instance configured for dnspod.
 
20
// Credentials must be passed in the environment variables: DNSPOD_API_KEY.
 
21
func NewDNSProvider() (*DNSProvider, error) {
 
22
        key := os.Getenv("DNSPOD_API_KEY")
 
23
        return NewDNSProviderCredentials(key)
 
24
}
 
25
 
 
26
// NewDNSProviderCredentials uses the supplied credentials to return a
 
27
// DNSProvider instance configured for dnspod.
 
28
func NewDNSProviderCredentials(key string) (*DNSProvider, error) {
 
29
        if key == "" {
 
30
                return nil, fmt.Errorf("dnspod credentials missing")
 
31
        }
 
32
 
 
33
        params := dnspod.CommonParams{LoginToken: key, Format: "json"}
 
34
        return &DNSProvider{
 
35
                client: dnspod.NewClient(params),
 
36
        }, nil
 
37
}
 
38
 
 
39
// Present creates a TXT record to fulfil the dns-01 challenge.
 
40
func (c *DNSProvider) Present(domain, token, keyAuth string) error {
 
41
        fqdn, value, ttl := acme.DNS01Record(domain, keyAuth)
 
42
        zoneID, zoneName, err := c.getHostedZone(domain)
 
43
        if err != nil {
 
44
                return err
 
45
        }
 
46
 
 
47
        recordAttributes := c.newTxtRecord(zoneName, fqdn, value, ttl)
 
48
        _, _, err = c.client.Domains.CreateRecord(zoneID, *recordAttributes)
 
49
        if err != nil {
 
50
                return fmt.Errorf("dnspod API call failed: %v", err)
 
51
        }
 
52
 
 
53
        return nil
 
54
}
 
55
 
 
56
// CleanUp removes the TXT record matching the specified parameters.
 
57
func (c *DNSProvider) CleanUp(domain, token, keyAuth string) error {
 
58
        fqdn, _, _ := acme.DNS01Record(domain, keyAuth)
 
59
 
 
60
        records, err := c.findTxtRecords(domain, fqdn)
 
61
        if err != nil {
 
62
                return err
 
63
        }
 
64
 
 
65
        zoneID, _, err := c.getHostedZone(domain)
 
66
        if err != nil {
 
67
                return err
 
68
        }
 
69
 
 
70
        for _, rec := range records {
 
71
                _, err := c.client.Domains.DeleteRecord(zoneID, rec.ID)
 
72
                if err != nil {
 
73
                        return err
 
74
                }
 
75
        }
 
76
        return nil
 
77
}
 
78
 
 
79
func (c *DNSProvider) getHostedZone(domain string) (string, string, error) {
 
80
        zones, _, err := c.client.Domains.List()
 
81
        if err != nil {
 
82
                return "", "", fmt.Errorf("dnspod API call failed: %v", err)
 
83
        }
 
84
 
 
85
        authZone, err := acme.FindZoneByFqdn(acme.ToFqdn(domain), acme.RecursiveNameservers)
 
86
        if err != nil {
 
87
                return "", "", err
 
88
        }
 
89
 
 
90
        var hostedZone dnspod.Domain
 
91
        for _, zone := range zones {
 
92
                if zone.Name == acme.UnFqdn(authZone) {
 
93
                        hostedZone = zone
 
94
                }
 
95
        }
 
96
 
 
97
        if hostedZone.ID == 0 {
 
98
                return "", "", fmt.Errorf("Zone %s not found in dnspod for domain %s", authZone, domain)
 
99
 
 
100
        }
 
101
 
 
102
        return fmt.Sprintf("%v", hostedZone.ID), hostedZone.Name, nil
 
103
}
 
104
 
 
105
func (c *DNSProvider) newTxtRecord(zone, fqdn, value string, ttl int) *dnspod.Record {
 
106
        name := c.extractRecordName(fqdn, zone)
 
107
 
 
108
        return &dnspod.Record{
 
109
                Type:  "TXT",
 
110
                Name:  name,
 
111
                Value: value,
 
112
                Line:  "默认",
 
113
                TTL:   "600",
 
114
        }
 
115
}
 
116
 
 
117
func (c *DNSProvider) findTxtRecords(domain, fqdn string) ([]dnspod.Record, error) {
 
118
        zoneID, zoneName, err := c.getHostedZone(domain)
 
119
        if err != nil {
 
120
                return nil, err
 
121
        }
 
122
 
 
123
        var records []dnspod.Record
 
124
        result, _, err := c.client.Domains.ListRecords(zoneID, "")
 
125
        if err != nil {
 
126
                return records, fmt.Errorf("dnspod API call has failed: %v", err)
 
127
        }
 
128
 
 
129
        recordName := c.extractRecordName(fqdn, zoneName)
 
130
 
 
131
        for _, record := range result {
 
132
                if record.Name == recordName {
 
133
                        records = append(records, record)
 
134
                }
 
135
        }
 
136
 
 
137
        return records, nil
 
138
}
 
139
 
 
140
func (c *DNSProvider) extractRecordName(fqdn, domain string) string {
 
141
        name := acme.UnFqdn(fqdn)
 
142
        if idx := strings.Index(name, "."+domain); idx != -1 {
 
143
                return name[:idx]
 
144
        }
 
145
        return name
 
146
}