From 2e30fd0ba8201776a5497738ba6eb857a8c71b7f Mon Sep 17 00:00:00 2001 From: Ludovic Fernandez Date: Mon, 10 Feb 2020 18:20:52 +0100 Subject: [PATCH] Minors changes (#1059) --- .golangci.toml | 4 ++ acme/api/api.go | 7 ++- providers/dns/checkdomain/checkdomain.go | 28 ++++----- providers/dns/checkdomain/client.go | 76 +++++++++++------------ providers/dns/selectel/internal/client.go | 2 +- providers/dns/vscale/internal/client.go | 2 +- providers/dns/zoneee/zoneee_test.go | 3 - 7 files changed, 63 insertions(+), 59 deletions(-) diff --git a/.golangci.toml b/.golangci.toml index 0e4a8e73..19f61e54 100644 --- a/.golangci.toml +++ b/.golangci.toml @@ -33,6 +33,7 @@ "wsl", "stylecheck", "godox", + "gomnd", ] [issues] @@ -121,3 +122,6 @@ [[issues.exclude-rules]] path = "providers/dns/checkdomain/client.go" text = "`payed` is a misspelling of `paid`" + [[issues.exclude-rules]] + path = "providers/dns/namecheap/namecheap_test.go" + text = "cognitive complexity (\\d+) of func `TestDNSProvider_getHosts` is high" diff --git a/acme/api/api.go b/acme/api/api.go index b018b25f..1bcbc87a 100644 --- a/acme/api/api.go +++ b/acme/api/api.go @@ -93,7 +93,6 @@ func (a *Core) retrievablePost(uri string, content []byte, response interface{}) switch err.(type) { // Retry if the nonce was invalidated case *acme.NonceError: - log.Infof("nonce error retry: %s", err) return err default: cancel() @@ -104,7 +103,11 @@ func (a *Core) retrievablePost(uri string, content []byte, response interface{}) return nil } - err := backoff.Retry(operation, backoff.WithContext(bo, ctx)) + notify := func(err error, duration time.Duration) { + log.Infof("retry due to: %v", err) + } + + err := backoff.RetryNotify(operation, backoff.WithContext(bo, ctx), notify) if err != nil { return nil, err } diff --git a/providers/dns/checkdomain/checkdomain.go b/providers/dns/checkdomain/checkdomain.go index 4235e839..fa3e5a64 100644 --- a/providers/dns/checkdomain/checkdomain.go +++ b/providers/dns/checkdomain/checkdomain.go @@ -94,22 +94,22 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { } // Present creates a TXT record to fulfill the dns-01 challenge -func (p *DNSProvider) Present(domain, token, keyAuth string) error { - domainID, err := p.getDomainIDByName(domain) +func (d *DNSProvider) Present(domain, token, keyAuth string) error { + domainID, err := d.getDomainIDByName(domain) if err != nil { return fmt.Errorf("checkdomain: %v", err) } - err = p.checkNameservers(domainID) + err = d.checkNameservers(domainID) if err != nil { return fmt.Errorf("checkdomain: %v", err) } name, value := dns01.GetRecord(domain, keyAuth) - err = p.createRecord(domainID, &Record{ + err = d.createRecord(domainID, &Record{ Name: name, - TTL: p.config.TTL, + TTL: d.config.TTL, Type: "TXT", Value: value, }) @@ -122,31 +122,31 @@ func (p *DNSProvider) Present(domain, token, keyAuth string) error { } // CleanUp removes the TXT record previously created -func (p *DNSProvider) CleanUp(domain, token, keyAuth string) error { - domainID, err := p.getDomainIDByName(domain) +func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { + domainID, err := d.getDomainIDByName(domain) if err != nil { return fmt.Errorf("checkdomain: %v", err) } - err = p.checkNameservers(domainID) + err = d.checkNameservers(domainID) if err != nil { return fmt.Errorf("checkdomain: %v", err) } name, value := dns01.GetRecord(domain, keyAuth) - err = p.deleteTXTRecord(domainID, name, value) + err = d.deleteTXTRecord(domainID, name, value) if err != nil { return fmt.Errorf("checkdomain: %v", err) } - p.domainIDMu.Lock() - delete(p.domainIDMapping, name) - p.domainIDMu.Unlock() + d.domainIDMu.Lock() + delete(d.domainIDMapping, name) + d.domainIDMu.Unlock() return nil } -func (p *DNSProvider) Timeout() (timeout, interval time.Duration) { - return p.config.PropagationTimeout, p.config.PollingInterval +func (d *DNSProvider) Timeout() (timeout, interval time.Duration) { + return d.config.PropagationTimeout, d.config.PollingInterval } diff --git a/providers/dns/checkdomain/client.go b/providers/dns/checkdomain/client.go index e1656721..f1557d84 100644 --- a/providers/dns/checkdomain/client.go +++ b/providers/dns/checkdomain/client.go @@ -98,17 +98,17 @@ type ( } ) -func (p *DNSProvider) getDomainIDByName(name string) (int, error) { +func (d *DNSProvider) getDomainIDByName(name string) (int, error) { // Load from cache if exists - p.domainIDMu.Lock() - id, ok := p.domainIDMapping[name] - p.domainIDMu.Unlock() + d.domainIDMu.Lock() + id, ok := d.domainIDMapping[name] + d.domainIDMu.Unlock() if ok { return id, nil } // Find out by querying API - domains, err := p.listDomains() + domains, err := d.listDomains() if err != nil { return domainNotFound, err } @@ -116,9 +116,9 @@ func (p *DNSProvider) getDomainIDByName(name string) (int, error) { // Linear search over all registered domains for _, domain := range domains { if domain.Name == name || strings.HasSuffix(name, "."+domain.Name) { - p.domainIDMu.Lock() - p.domainIDMapping[name] = domain.ID - p.domainIDMu.Unlock() + d.domainIDMu.Lock() + d.domainIDMapping[name] = domain.ID + d.domainIDMu.Unlock() return domain.ID, nil } @@ -127,8 +127,8 @@ func (p *DNSProvider) getDomainIDByName(name string) (int, error) { return domainNotFound, fmt.Errorf("domain not found") } -func (p *DNSProvider) listDomains() ([]*Domain, error) { - req, err := p.makeRequest(http.MethodGet, "/v1/domains", http.NoBody) +func (d *DNSProvider) listDomains() ([]*Domain, error) { + req, err := d.makeRequest(http.MethodGet, "/v1/domains", http.NoBody) if err != nil { return nil, fmt.Errorf("failed to make request: %v", err) } @@ -148,7 +148,7 @@ func (p *DNSProvider) listDomains() ([]*Domain, error) { req.URL.RawQuery = q.Encode() var res DomainListingResponse - if err := p.sendRequest(req, &res); err != nil { + if err := d.sendRequest(req, &res); err != nil { return nil, fmt.Errorf("failed to send domain listing request: %v", err) } @@ -166,22 +166,22 @@ func (p *DNSProvider) listDomains() ([]*Domain, error) { return domainList, nil } -func (p *DNSProvider) getNameserverInfo(domainID int) (*NameserverResponse, error) { - req, err := p.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d/nameservers", domainID), http.NoBody) +func (d *DNSProvider) getNameserverInfo(domainID int) (*NameserverResponse, error) { + req, err := d.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d/nameservers", domainID), http.NoBody) if err != nil { return nil, err } res := &NameserverResponse{} - if err := p.sendRequest(req, res); err != nil { + if err := d.sendRequest(req, res); err != nil { return nil, err } return res, nil } -func (p *DNSProvider) checkNameservers(domainID int) error { - info, err := p.getNameserverInfo(domainID) +func (d *DNSProvider) checkNameservers(domainID int) error { + info, err := d.getNameserverInfo(domainID) if err != nil { return err } @@ -203,35 +203,35 @@ func (p *DNSProvider) checkNameservers(domainID int) error { return nil } -func (p *DNSProvider) createRecord(domainID int, record *Record) error { +func (d *DNSProvider) createRecord(domainID int, record *Record) error { bs, err := json.Marshal(record) if err != nil { return fmt.Errorf("encoding record failed: %v", err) } - req, err := p.makeRequest(http.MethodPost, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), bytes.NewReader(bs)) + req, err := d.makeRequest(http.MethodPost, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), bytes.NewReader(bs)) if err != nil { return err } - return p.sendRequest(req, nil) + return d.sendRequest(req, nil) } // Checkdomain doesn't seem provide a way to delete records but one can replace all records at once. // The current solution is to fetch all records and then use that list minus the record deleted as the new record list. // TODO: Simplify this function once Checkdomain do provide the functionality. -func (p *DNSProvider) deleteTXTRecord(domainID int, recordName, recordValue string) error { - domainInfo, err := p.getDomainInfo(domainID) +func (d *DNSProvider) deleteTXTRecord(domainID int, recordName, recordValue string) error { + domainInfo, err := d.getDomainInfo(domainID) if err != nil { return err } - nsInfo, err := p.getNameserverInfo(domainID) + nsInfo, err := d.getNameserverInfo(domainID) if err != nil { return err } - allRecords, err := p.listRecords(domainID, "") + allRecords, err := d.listRecords(domainID, "") if err != nil { return err } @@ -256,17 +256,17 @@ func (p *DNSProvider) deleteTXTRecord(domainID int, recordName, recordValue stri recordsToKeep = append(recordsToKeep, record) } - return p.replaceRecords(domainID, recordsToKeep) + return d.replaceRecords(domainID, recordsToKeep) } -func (p *DNSProvider) getDomainInfo(domainID int) (*DomainResponse, error) { - req, err := p.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d", domainID), http.NoBody) +func (d *DNSProvider) getDomainInfo(domainID int) (*DomainResponse, error) { + req, err := d.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d", domainID), http.NoBody) if err != nil { return nil, err } var res DomainResponse - err = p.sendRequest(req, &res) + err = d.sendRequest(req, &res) if err != nil { return nil, err } @@ -274,8 +274,8 @@ func (p *DNSProvider) getDomainInfo(domainID int) (*DomainResponse, error) { return &res, nil } -func (p *DNSProvider) listRecords(domainID int, recordType string) ([]*Record, error) { - req, err := p.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), http.NoBody) +func (d *DNSProvider) listRecords(domainID int, recordType string) ([]*Record, error) { + req, err := d.makeRequest(http.MethodGet, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), http.NoBody) if err != nil { return nil, fmt.Errorf("failed to make request: %v", err) } @@ -295,7 +295,7 @@ func (p *DNSProvider) listRecords(domainID int, recordType string) ([]*Record, e req.URL.RawQuery = q.Encode() var res RecordListingResponse - if err := p.sendRequest(req, &res); err != nil { + if err := d.sendRequest(req, &res); err != nil { return nil, fmt.Errorf("failed to send record listing request: %v", err) } @@ -312,18 +312,18 @@ func (p *DNSProvider) listRecords(domainID int, recordType string) ([]*Record, e return recordList, nil } -func (p *DNSProvider) replaceRecords(domainID int, records []*Record) error { +func (d *DNSProvider) replaceRecords(domainID int, records []*Record) error { bs, err := json.Marshal(records) if err != nil { return fmt.Errorf("encoding record failed: %v", err) } - req, err := p.makeRequest(http.MethodPut, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), bytes.NewReader(bs)) + req, err := d.makeRequest(http.MethodPut, fmt.Sprintf("/v1/domains/%d/nameservers/records", domainID), bytes.NewReader(bs)) if err != nil { return err } - return p.sendRequest(req, nil) + return d.sendRequest(req, nil) } func skipRecord(recordName, recordValue string, record *Record, nsInfo *NameserverResponse) bool { @@ -348,8 +348,8 @@ func skipRecord(recordName, recordValue string, record *Record, nsInfo *Nameserv return false } -func (p *DNSProvider) makeRequest(method, resource string, body io.Reader) (*http.Request, error) { - uri, err := p.config.Endpoint.Parse(resource) +func (d *DNSProvider) makeRequest(method, resource string, body io.Reader) (*http.Request, error) { + uri, err := d.config.Endpoint.Parse(resource) if err != nil { return nil, err } @@ -360,7 +360,7 @@ func (p *DNSProvider) makeRequest(method, resource string, body io.Reader) (*htt } req.Header.Set("Accept", "application/json") - req.Header.Set("Authorization", "Bearer "+p.config.Token) + req.Header.Set("Authorization", "Bearer "+d.config.Token) if method != http.MethodGet { req.Header.Set("Content-Type", "application/json") } @@ -368,8 +368,8 @@ func (p *DNSProvider) makeRequest(method, resource string, body io.Reader) (*htt return req, nil } -func (p *DNSProvider) sendRequest(req *http.Request, result interface{}) error { - resp, err := p.config.HTTPClient.Do(req) +func (d *DNSProvider) sendRequest(req *http.Request, result interface{}) error { + resp, err := d.config.HTTPClient.Do(req) if err != nil { return err } diff --git a/providers/dns/selectel/internal/client.go b/providers/dns/selectel/internal/client.go index fda9404a..69ccda0a 100644 --- a/providers/dns/selectel/internal/client.go +++ b/providers/dns/selectel/internal/client.go @@ -180,7 +180,7 @@ func (c *Client) do(req *http.Request, to interface{}) (*http.Response, error) { } func checkResponse(resp *http.Response) error { - if resp.StatusCode >= http.StatusBadRequest && resp.StatusCode <= http.StatusNetworkAuthenticationRequired { + if resp.StatusCode >= http.StatusBadRequest { if resp.Body == nil { return fmt.Errorf("request failed with status code %d and empty body", resp.StatusCode) } diff --git a/providers/dns/vscale/internal/client.go b/providers/dns/vscale/internal/client.go index 7e297c1b..39013ec8 100644 --- a/providers/dns/vscale/internal/client.go +++ b/providers/dns/vscale/internal/client.go @@ -180,7 +180,7 @@ func (c *Client) do(req *http.Request, to interface{}) (*http.Response, error) { } func checkResponse(resp *http.Response) error { - if resp.StatusCode >= http.StatusBadRequest && resp.StatusCode <= http.StatusNetworkAuthenticationRequired { + if resp.StatusCode >= http.StatusBadRequest { if resp.Body == nil { return fmt.Errorf("request failed with status code %d and empty body", resp.StatusCode) } diff --git a/providers/dns/zoneee/zoneee_test.go b/providers/dns/zoneee/zoneee_test.go index 3989f409..9611b400 100644 --- a/providers/dns/zoneee/zoneee_test.go +++ b/providers/dns/zoneee/zoneee_test.go @@ -153,9 +153,6 @@ func TestDNSProvider_Present(t *testing.T) { username: "bar", apiKey: "foo", handlers: map[string]http.HandlerFunc{ - "/": http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { - fmt.Println(req.URL) - }), "/" + hostedZone + "/txt": mockHandlerCreateRecord, }, },