StackExchange/dnscontrol
1
1
Fork 0
mirror of https://github.com/StackExchange/dnscontrol.git synced 2024-09-20 06:46:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

MAINT: Make staticcheck more strict and fix new warnings (#1408)

Browse source 
* Make staticcheck more strict and fix new warnings
This commit is contained in:
Tom Limoncelli 2022-02-11 14:30:45 -05:00 committed by GitHub
parent 25d72395f3
commit 886dbf6d00
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 117 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
models/t_parse.go
View file

@ -12,43 +12,43 @@ import (
// //
// If this doesn't work for all rtypes, process the special cases then // If this doesn't work for all rtypes, process the special cases then
// call this for the remainder. // call this for the remainder.
func (r *RecordConfig) PopulateFromString(rtype, contents, origin string) error { func (rc *RecordConfig) PopulateFromString(rtype, contents, origin string) error {
if r.Type != "" && r.Type != rtype { if rc.Type != "" && rc.Type != rtype {
panic(fmt.Errorf("assertion failed: rtype already set (%s) (%s)", rtype, r.Type)) panic(fmt.Errorf("assertion failed: rtype already set (%s) (%s)", rtype, rc.Type))
} }
switch r.Type = rtype; rtype { // #rtype_variations switch rc.Type = rtype; rtype { // #rtype_variations
case "A": case "A":
ip := net.ParseIP(contents) ip := net.ParseIP(contents)
if ip == nil || ip.To4() == nil { if ip == nil || ip.To4() == nil {
return fmt.Errorf("invalid IP in A record: %s", contents) return fmt.Errorf("invalid IP in A record: %s", contents)
} }
return r.SetTargetIP(ip) // Reformat to canonical form. return rc.SetTargetIP(ip) // Reformat to canonical form.
case "AAAA": case "AAAA":
ip := net.ParseIP(contents) ip := net.ParseIP(contents)
if ip == nil || ip.To16() == nil { if ip == nil || ip.To16() == nil {
return fmt.Errorf("invalid IP in AAAA record: %s", contents) return fmt.Errorf("invalid IP in AAAA record: %s", contents)
} }
return r.SetTargetIP(ip) // Reformat to canonical form. return rc.SetTargetIP(ip) // Reformat to canonical form.
case "AKAMAICDN", "ALIAS", "ANAME", "CNAME", "NS", "PTR": case "AKAMAICDN", "ALIAS", "ANAME", "CNAME", "NS", "PTR":
return r.SetTarget(contents) return rc.SetTarget(contents)
case "CAA": case "CAA":
return r.SetTargetCAAString(contents) return rc.SetTargetCAAString(contents)
case "DS": case "DS":
return r.SetTargetDSString(contents) return rc.SetTargetDSString(contents)
case "MX": case "MX":
return r.SetTargetMXString(contents) return rc.SetTargetMXString(contents)
case "NAPTR": case "NAPTR":
return r.SetTargetNAPTRString(contents) return rc.SetTargetNAPTRString(contents)
case "SRV": case "SRV":
return r.SetTargetSRVString(contents) return rc.SetTargetSRVString(contents)
case "SOA": case "SOA":
return r.SetTargetSOAString(contents) return rc.SetTargetSOAString(contents)
case "SSHFP": case "SSHFP":
return r.SetTargetSSHFPString(contents) return rc.SetTargetSSHFPString(contents)
case "TLSA": case "TLSA":
return r.SetTargetTLSAString(contents) return rc.SetTargetTLSAString(contents)
case "SPF", "TXT": case "SPF", "TXT":
return r.SetTargetTXTString(contents) return rc.SetTargetTXTString(contents)
default: default:
return fmt.Errorf("unknown rtype (%s) when parsing (%s) domain=(%s)", return fmt.Errorf("unknown rtype (%s) when parsing (%s) domain=(%s)",
rtype, contents, origin) rtype, contents, origin)

6
pkg/acme/acme.go
View file

@ -181,7 +181,11 @@ func getCertInfo(pemBytes []byte) (names []string, remaining float64, err error)
if err != nil { if err != nil {
return nil, 0, err return nil, 0, err
} }
// FIXME(tlim): should use time.Until instead of t.Sub(time.Now()) (S1024) //lint:ignore S1024 Fixing this without unit tests scares me.
// TODO(tlim): I think the fix is the line below but since this code
// may be decommed eventually, and since there are no unit tests,
// I'm not excited about making this change.
// var daysLeft = float64(time.Until(cert.NotAfter)) / float64(time.Hour*24)
var daysLeft = float64(cert.NotAfter.Sub(time.Now())) / float64(time.Hour*24) var daysLeft = float64(cert.NotAfter.Sub(time.Now())) / float64(time.Hour*24)
return cert.DNSNames, daysLeft, nil return cert.DNSNames, daysLeft, nil
} }

6
pkg/js/js.go
View file

@ -149,7 +149,7 @@ func require(call otto.FunctionCall) otto.Value {
throw(call.Otto, err.Error()) throw(call.Otto, err.Error())
} }
var value otto.Value = otto.TrueValue() var value = otto.TrueValue()
// If its a json file return the json value, else default to true // If its a json file return the json value, else default to true
if strings.HasSuffix(filepath.Ext(relFile), "json") { if strings.HasSuffix(filepath.Ext(relFile), "json") {
@ -194,7 +194,7 @@ func listFiles(call otto.FunctionCall) otto.Value {
} }
// Second: Recursive? // Second: Recursive?
var recursive bool = true var recursive = true
if call.Argument(1).IsDefined() && !call.Argument(1).IsNull() { if call.Argument(1).IsDefined() && !call.Argument(1).IsNull() {
if call.Argument(1).IsBoolean() { if call.Argument(1).IsBoolean() {
recursive, _ = call.Argument(1).ToBoolean() // If it should be recursive recursive, _ = call.Argument(1).ToBoolean() // If it should be recursive
@ -204,7 +204,7 @@ func listFiles(call otto.FunctionCall) otto.Value {
} }
// Third: File extension filter. // Third: File extension filter.
var fileExtension string = ".js" var fileExtension = ".js"
if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() { if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() {
if call.Argument(2).IsString() { if call.Argument(2).IsString() {
fileExtension = call.Argument(2).String() // Which file extension to filter for. fileExtension = call.Argument(2).String() // Which file extension to filter for.

4
providers/cloudflare/rest.go
View file

@ -352,7 +352,9 @@ func (c *cloudflareProvider) createTestWorker(workerName string) error {
return err return err
} }
// go-staticcheck lies! //lint:ignore U1000 false positive due to
// https://github.com/dominikh/go-tools/issues/1137 which is a dup of
// https://github.com/dominikh/go-tools/issues/810
type pageRuleConstraint struct { type pageRuleConstraint struct {
Operator string `json:"operator"` Operator string `json:"operator"`
Value string `json:"value"` Value string `json:"value"`

50
providers/linode/api.go
View file

@ -15,17 +15,17 @@ const (
domainsPath = "domains" domainsPath = "domains"
) )
func (c *linodeProvider) fetchDomainList() error { func (api *linodeProvider) fetchDomainList() error {
c.domainIndex = map[string]int{} api.domainIndex = map[string]int{}
page := 1 page := 1
for { for {
dr := &domainResponse{} dr := &domainResponse{}
endpoint := fmt.Sprintf("%s?page=%d", domainsPath, page) endpoint := fmt.Sprintf("%s?page=%d", domainsPath, page)
if err := c.get(endpoint, dr); err != nil { if err := api.get(endpoint, dr); err != nil {
return fmt.Errorf("failed fetching domain list (Linode): %s", err) return fmt.Errorf("failed fetching domain list (Linode): %s", err)
} }
for _, domain := range dr.Data { for _, domain := range dr.Data {
c.domainIndex[domain.Domain] = domain.ID api.domainIndex[domain.Domain] = domain.ID
} }
if len(dr.Data) == 0 || dr.Page >= dr.Pages { if len(dr.Data) == 0 || dr.Page >= dr.Pages {
break break
@ -35,13 +35,13 @@ func (c *linodeProvider) fetchDomainList() error {
return nil return nil
} }
func (c *linodeProvider) getRecords(id int) ([]domainRecord, error) { func (api *linodeProvider) getRecords(id int) ([]domainRecord, error) {
records := []domainRecord{} records := []domainRecord{}
page := 1 page := 1
for { for {
dr := &recordResponse{} dr := &recordResponse{}
endpoint := fmt.Sprintf("%s/%d/records?page=%d", domainsPath, id, page) endpoint := fmt.Sprintf("%s/%d/records?page=%d", domainsPath, id, page)
if err := c.get(endpoint, dr); err != nil { if err := api.get(endpoint, dr); err != nil {
return nil, fmt.Errorf("failed fetching record list (Linode): %s", err) return nil, fmt.Errorf("failed fetching record list (Linode): %s", err)
} }
@ -56,21 +56,21 @@ func (c *linodeProvider) getRecords(id int) ([]domainRecord, error) {
return records, nil return records, nil
} }
func (c *linodeProvider) createRecord(domainID int, rec *recordEditRequest) (*domainRecord, error) { func (api *linodeProvider) createRecord(domainID int, rec *recordEditRequest) (*domainRecord, error) {
endpoint := fmt.Sprintf("%s/%d/records", domainsPath, domainID) endpoint := fmt.Sprintf("%s/%d/records", domainsPath, domainID)
req, err := c.newRequest(http.MethodPost, endpoint, rec) req, err := api.newRequest(http.MethodPost, endpoint, rec)
if err != nil { if err != nil {
return nil, err return nil, err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return nil, c.handleErrors(resp) return nil, api.handleErrors(resp)
} }
record := &domainRecord{} record := &domainRecord{}
@ -84,52 +84,52 @@ func (c *linodeProvider) createRecord(domainID int, rec *recordEditRequest) (*do
return record, nil return record, nil
} }
func (c *linodeProvider) modifyRecord(domainID, recordID int, rec *recordEditRequest) error { func (api *linodeProvider) modifyRecord(domainID, recordID int, rec *recordEditRequest) error {
endpoint := fmt.Sprintf("%s/%d/records/%d", domainsPath, domainID, recordID) endpoint := fmt.Sprintf("%s/%d/records/%d", domainsPath, domainID, recordID)
req, err := c.newRequest(http.MethodPut, endpoint, rec) req, err := api.newRequest(http.MethodPut, endpoint, rec)
if err != nil { if err != nil {
return err return err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return c.handleErrors(resp) return api.handleErrors(resp)
} }
return nil return nil
} }
func (c *linodeProvider) deleteRecord(domainID, recordID int) error { func (api *linodeProvider) deleteRecord(domainID, recordID int) error {
endpoint := fmt.Sprintf("%s/%d/records/%d", domainsPath, domainID, recordID) endpoint := fmt.Sprintf("%s/%d/records/%d", domainsPath, domainID, recordID)
req, err := c.newRequest(http.MethodDelete, endpoint, nil) req, err := api.newRequest(http.MethodDelete, endpoint, nil)
if err != nil { if err != nil {
return err return err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return c.handleErrors(resp) return api.handleErrors(resp)
} }
return nil return nil
} }
func (c *linodeProvider) newRequest(method, endpoint string, body interface{}) (*http.Request, error) { func (api *linodeProvider) newRequest(method, endpoint string, body interface{}) (*http.Request, error) {
rel, err := url.Parse(endpoint) rel, err := url.Parse(endpoint)
if err != nil { if err != nil {
return nil, err return nil, err
} }
u := c.baseURL.ResolveReference(rel) u := api.baseURL.ResolveReference(rel)
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
if body != nil { if body != nil {
@ -149,24 +149,24 @@ func (c *linodeProvider) newRequest(method, endpoint string, body interface{}) (
return req, nil return req, nil
} }
func (c *linodeProvider) get(endpoint string, target interface{}) error { func (api *linodeProvider) get(endpoint string, target interface{}) error {
req, err := c.newRequest(http.MethodGet, endpoint, nil) req, err := api.newRequest(http.MethodGet, endpoint, nil)
if err != nil { if err != nil {
return err return err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return c.handleErrors(resp) return api.handleErrors(resp)
} }
defer resp.Body.Close() defer resp.Body.Close()
decoder := json.NewDecoder(resp.Body) decoder := json.NewDecoder(resp.Body)
return decoder.Decode(target) return decoder.Decode(target)
} }
func (c *linodeProvider) handleErrors(resp *http.Response) error { func (api *linodeProvider) handleErrors(resp *http.Response) error {
defer resp.Body.Close() defer resp.Body.Close()
decoder := json.NewDecoder(resp.Body) decoder := json.NewDecoder(resp.Body)

2
providers/linode/linodeProvider.go
View file

@ -293,7 +293,7 @@ func toReq(dc *models.DomainConfig, rc *models.RecordConfig) (*recordEditRequest
return nil, fmt.Errorf("SRV Record must match format \"_service._protocol\" not %s", req.Name) return nil, fmt.Errorf("SRV Record must match format \"_service._protocol\" not %s", req.Name)
} }
var serviceName, protocol string = result[1], strings.ToLower(result[2]) var serviceName, protocol = result[1], strings.ToLower(result[2])
req.Protocol = protocol req.Protocol = protocol
req.Service = serviceName req.Service = serviceName

22
providers/msdns/corrections.go
View file

@ -9,10 +9,10 @@ import (
) )
// GetDomainCorrections gets existing records, diffs them against existing, and returns corrections. // GetDomainCorrections gets existing records, diffs them against existing, and returns corrections.
func (c *msdnsProvider) GenerateDomainCorrections(dc *models.DomainConfig, existing models.Records) ([]*models.Correction, error) { func (client *msdnsProvider) GenerateDomainCorrections(dc *models.DomainConfig, existing models.Records) ([]*models.Correction, error) {
// Read foundRecords: // Read foundRecords:
foundRecords, err := c.GetZoneRecords(dc.Name) foundRecords, err := client.GetZoneRecords(dc.Name)
if err != nil { if err != nil {
return nil, fmt.Errorf("c.GetDNSZoneRecords(%v) failed: %v", dc.Name, err) return nil, fmt.Errorf("c.GetDNSZoneRecords(%v) failed: %v", dc.Name, err)
} }
@ -30,45 +30,45 @@ func (c *msdnsProvider) GenerateDomainCorrections(dc *models.DomainConfig, exist
// Generate changes. // Generate changes.
corrections := []*models.Correction{} corrections := []*models.Correction{}
for _, del := range dels { for _, del := range dels {
corrections = append(corrections, c.deleteRec(c.dnsserver, dc.Name, del)) corrections = append(corrections, client.deleteRec(client.dnsserver, dc.Name, del))
} }
for _, cre := range creates { for _, cre := range creates {
corrections = append(corrections, c.createRec(c.dnsserver, dc.Name, cre)...) corrections = append(corrections, client.createRec(client.dnsserver, dc.Name, cre)...)
} }
for _, m := range modifications { for _, m := range modifications {
corrections = append(corrections, c.modifyRec(c.dnsserver, dc.Name, m)) corrections = append(corrections, client.modifyRec(client.dnsserver, dc.Name, m))
} }
return corrections, nil return corrections, nil
} }
func (c *msdnsProvider) deleteRec(dnsserver, domainname string, cor diff.Correlation) *models.Correction { func (client *msdnsProvider) deleteRec(dnsserver, domainname string, cor diff.Correlation) *models.Correction {
rec := cor.Existing rec := cor.Existing
return &models.Correction{ return &models.Correction{
Msg: cor.String(), Msg: cor.String(),
F: func() error { F: func() error {
return c.shell.RecordDelete(dnsserver, domainname, rec) return client.shell.RecordDelete(dnsserver, domainname, rec)
}, },
} }
} }
func (c *msdnsProvider) createRec(dnsserver, domainname string, cre diff.Correlation) []*models.Correction { func (client *msdnsProvider) createRec(dnsserver, domainname string, cre diff.Correlation) []*models.Correction {
rec := cre.Desired rec := cre.Desired
arr := []*models.Correction{{ arr := []*models.Correction{{
Msg: cre.String(), Msg: cre.String(),
F: func() error { F: func() error {
return c.shell.RecordCreate(dnsserver, domainname, rec) return client.shell.RecordCreate(dnsserver, domainname, rec)
}, },
}} }}
return arr return arr
} }
func (c *msdnsProvider) modifyRec(dnsserver, domainname string, m diff.Correlation) *models.Correction { func (client *msdnsProvider) modifyRec(dnsserver, domainname string, m diff.Correlation) *models.Correction {
old, rec := m.Existing, m.Desired old, rec := m.Existing, m.Desired
return &models.Correction{ return &models.Correction{
Msg: m.String(), Msg: m.String(),
F: func() error { F: func() error {
return c.shell.RecordModify(dnsserver, domainname, old, rec) return client.shell.RecordModify(dnsserver, domainname, old, rec)
}, },
} }
} }

2
providers/msdns/domains.go
View file

@ -2,7 +2,7 @@ package msdns
import "github.com/StackExchange/dnscontrol/v3/models" import "github.com/StackExchange/dnscontrol/v3/models"
func (c *msdnsProvider) GetNameservers(string) ([]*models.Nameserver, error) { func (client *msdnsProvider) GetNameservers(string) ([]*models.Nameserver, error) {
// TODO: If using AD for publicly hosted zones, probably pull these from config. // TODO: If using AD for publicly hosted zones, probably pull these from config.
return nil, nil return nil, nil
} }

4
providers/msdns/listzones.go
View file

@ -1,7 +1,7 @@
package msdns package msdns
func (c *msdnsProvider) ListZones() ([]string, error) { func (client *msdnsProvider) ListZones() ([]string, error) {
zones, err := c.shell.GetDNSServerZoneAll(c.dnsserver) zones, err := client.shell.GetDNSServerZoneAll(client.dnsserver)
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
providers/namedotcom/zones.go
View file

@ -5,18 +5,18 @@ import (
) )
// ListZones returns all the zones in an account // ListZones returns all the zones in an account
func (c *namedotcomProvider) ListZones() ([]string, error) { func (n *namedotcomProvider) ListZones() ([]string, error) {
var names []string var names []string
var page int32 var page int32
for { for {
n, err := c.client.ListDomains(&namecom.ListDomainsRequest{Page: page}) response, err := n.client.ListDomains(&namecom.ListDomainsRequest{Page: page})
if err != nil { if err != nil {
return nil, err return nil, err
} }
page = n.NextPage page = response.NextPage
for _, j := range n.Domains { for _, j := range response.Domains {
names = append(names, j.DomainName) names = append(names, j.DomainName)
} }

8
providers/ns1/ns1Provider.go
View file

@ -176,8 +176,8 @@ func buildRecord(recs models.Records, domain string, id string) *dns.Record {
Rdata: []string{ Rdata: []string{
fmt.Sprintf("%v", r.CaaFlag), fmt.Sprintf("%v", r.CaaFlag),
r.CaaTag, r.CaaTag,
fmt.Sprintf("%s", r.GetTargetField()), r.GetTargetField(),
}}) }})
} else if r.Type == "SRV" { } else if r.Type == "SRV" {
rec.AddAnswer(&dns.Answer{Rdata: strings.Split(fmt.Sprintf("%d %d %d %v", r.SrvPriority, r.SrvWeight, r.SrvPort, r.GetTargetField()), " ")}) rec.AddAnswer(&dns.Answer{Rdata: strings.Split(fmt.Sprintf("%d %d %d %v", r.SrvPriority, r.SrvWeight, r.SrvPort, r.GetTargetField()), " ")})
} else if r.Type == "NAPTR" { } else if r.Type == "NAPTR" {
@ -216,8 +216,8 @@ func convert(zr *dns.ZoneRecord, domain string) ([]*models.RecordConfig, error)
} }
case "CAA": case "CAA":
//dnscontrol expects quotes around multivalue CAA entries, API doesn't add them //dnscontrol expects quotes around multivalue CAA entries, API doesn't add them
x_ans := strings.SplitN(ans, " ", 3) xAns := strings.SplitN(ans, " ", 3)
if err := rec.SetTargetCAAStrings(x_ans[0], x_ans[1], x_ans[2]); err != nil { if err := rec.SetTargetCAAStrings(xAns[0], xAns[1], xAns[2]); err != nil {
return nil, fmt.Errorf("unparsable %s record received from ns1: %w", rtype, err) return nil, fmt.Errorf("unparsable %s record received from ns1: %w", rtype, err)
} }
default: default:

14
providers/octodns/octodnsProvider.go
View file

@ -52,13 +52,13 @@ func initProvider(config map[string]string, providermeta json.RawMessage) (provi
if api.directory == "" { if api.directory == "" {
api.directory = "config" api.directory = "config"
} }
if len(providermeta) != 0 { // Commented out because at this time api has no exported fields.
err := json.Unmarshal(providermeta, api) // if len(providermeta) != 0 {
if err != nil { // err := json.Unmarshal(providermeta, api)
return nil, err // if err != nil {
} // return nil, err
} // }
//api.nameservers = models.StringsToNameservers(api.DefaultNS) // }
return api, nil return api, nil
} }

1
providers/octodns/staticcheck.conf Normal file
View file

@ -0,0 +1 @@
checks = ["inherit", "-S1034"]

48
providers/packetframe/api.go
View file

@ -57,25 +57,25 @@ type domainRecord struct {
Zone string `json:"zone"` Zone string `json:"zone"`
} }
func (c *packetframeProvider) fetchDomainList() error { func (api *packetframeProvider) fetchDomainList() error {
c.domainIndex = map[string]zone{} api.domainIndex = map[string]zone{}
dr := &domainResponse{} dr := &domainResponse{}
endpoint := "dns/zones" endpoint := "dns/zones"
if err := c.get(endpoint, dr); err != nil { if err := api.get(endpoint, dr); err != nil {
return fmt.Errorf("failed fetching domain list (Packetframe): %w", err) return fmt.Errorf("failed fetching domain list (Packetframe): %w", err)
} }
for _, zone := range dr.Data.Zones { for _, zone := range dr.Data.Zones {
c.domainIndex[zone.Zone] = zone api.domainIndex[zone.Zone] = zone
} }
return nil return nil
} }
func (c *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error) { func (api *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error) {
var records []domainRecord var records []domainRecord
dr := &recordResponse{} dr := &recordResponse{}
endpoint := "dns/records/" + zoneID endpoint := "dns/records/" + zoneID
if err := c.get(endpoint, dr); err != nil { if err := api.get(endpoint, dr); err != nil {
return records, fmt.Errorf("failed fetching domain list (Packetframe): %w", err) return records, fmt.Errorf("failed fetching domain list (Packetframe): %w", err)
} }
records = append(records, dr.Data.Records...) records = append(records, dr.Data.Records...)
@ -93,15 +93,15 @@ func (c *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error)
return records, nil return records, nil
} }
func (c *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, error) { func (api *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, error) {
endpoint := "dns/records" endpoint := "dns/records"
req, err := c.newRequest(http.MethodPost, endpoint, rec) req, err := api.newRequest(http.MethodPost, endpoint, rec)
if err != nil { if err != nil {
return nil, err return nil, err
} }
_, err = c.client.Do(req) _, err = api.client.Do(req)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -109,15 +109,15 @@ func (c *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, er
return rec, nil return rec, nil
} }
func (c *packetframeProvider) modifyRecord(rec *domainRecord) error { func (api *packetframeProvider) modifyRecord(rec *domainRecord) error {
endpoint := "dns/records" endpoint := "dns/records"
req, err := c.newRequest(http.MethodPut, endpoint, rec) req, err := api.newRequest(http.MethodPut, endpoint, rec)
if err != nil { if err != nil {
return err return err
} }
_, err = c.client.Do(req) _, err = api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
@ -125,31 +125,31 @@ func (c *packetframeProvider) modifyRecord(rec *domainRecord) error {
return nil return nil
} }
func (c *packetframeProvider) deleteRecord(zoneID string, recordID string) error { func (api *packetframeProvider) deleteRecord(zoneID string, recordID string) error {
endpoint := "dns/records" endpoint := "dns/records"
req, err := c.newRequest(http.MethodDelete, endpoint, deleteRequest{Zone: zoneID, Record: recordID}) req, err := api.newRequest(http.MethodDelete, endpoint, deleteRequest{Zone: zoneID, Record: recordID})
if err != nil { if err != nil {
return err return err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return c.handleErrors(resp) return api.handleErrors(resp)
} }
return nil return nil
} }
func (c *packetframeProvider) newRequest(method, endpoint string, body interface{}) (*http.Request, error) { func (api *packetframeProvider) newRequest(method, endpoint string, body interface{}) (*http.Request, error) {
rel, err := url.Parse(endpoint) rel, err := url.Parse(endpoint)
if err != nil { if err != nil {
return nil, err return nil, err
} }
u := c.baseURL.ResolveReference(rel) u := api.baseURL.ResolveReference(rel)
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
if body != nil { if body != nil {
@ -166,21 +166,21 @@ func (c *packetframeProvider) newRequest(method, endpoint string, body interface
req.Header.Add("Content-Type", mediaType) req.Header.Add("Content-Type", mediaType)
req.Header.Add("Accept", mediaType) req.Header.Add("Accept", mediaType)
req.Header.Add("Authorization", "Token "+c.token) req.Header.Add("Authorization", "Token "+api.token)
return req, nil return req, nil
} }
func (c *packetframeProvider) get(endpoint string, target interface{}) error { func (api *packetframeProvider) get(endpoint string, target interface{}) error {
req, err := c.newRequest(http.MethodGet, endpoint, nil) req, err := api.newRequest(http.MethodGet, endpoint, nil)
if err != nil { if err != nil {
return err return err
} }
resp, err := c.client.Do(req) resp, err := api.client.Do(req)
if err != nil { if err != nil {
return err return err
} }
if resp.StatusCode != http.StatusOK { if resp.StatusCode != http.StatusOK {
return c.handleErrors(resp) return api.handleErrors(resp)
} }
defer resp.Body.Close() defer resp.Body.Close()
@ -188,7 +188,7 @@ func (c *packetframeProvider) get(endpoint string, target interface{}) error {
return decoder.Decode(target) return decoder.Decode(target)
} }
func (c *packetframeProvider) handleErrors(resp *http.Response) error { func (api *packetframeProvider) handleErrors(resp *http.Response) error {
body, err := ioutil.ReadAll(resp.Body) body, err := ioutil.ReadAll(resp.Body)
if err != nil { if err != nil {
return err return err

14
providers/softlayer/softlayerProvider.go
View file

@ -150,7 +150,7 @@ func (s *softlayerProvider) getExistingRecords(domain *datatypes.Dns_Domain) ([]
switch recType { switch recType {
case "SRV": case "SRV":
var service, protocol string = "", "_tcp" var service, protocol = "", "_tcp"
if record.Weight != nil { if record.Weight != nil {
recConfig.SrvWeight = uint16(*record.Weight) recConfig.SrvWeight = uint16(*record.Weight)
@ -190,9 +190,9 @@ func (s *softlayerProvider) getExistingRecords(domain *datatypes.Dns_Domain) ([]
} }
func (s *softlayerProvider) createRecordFunc(desired *models.RecordConfig, domain *datatypes.Dns_Domain) func() error { func (s *softlayerProvider) createRecordFunc(desired *models.RecordConfig, domain *datatypes.Dns_Domain) func() error {
var ttl, preference, domainID int = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference), *domain.Id var ttl, preference, domainID = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference), *domain.Id
var weight, priority, port int = int(desired.SrvWeight), int(desired.SrvPriority), int(desired.SrvPort) var weight, priority, port = int(desired.SrvWeight), int(desired.SrvPriority), int(desired.SrvPort)
var host, data, newType string = desired.GetLabel(), desired.GetTargetField(), desired.Type var host, data, newType = desired.GetLabel(), desired.GetTargetField(), desired.Type
var err error var err error
srvRegexp := regexp.MustCompile(`^_(?P<Service>\w+)\.\_(?P<Protocol>\w+)$`) srvRegexp := regexp.MustCompile(`^_(?P<Service>\w+)\.\_(?P<Protocol>\w+)$`)
@ -226,7 +226,7 @@ func (s *softlayerProvider) createRecordFunc(desired *models.RecordConfig, domai
return fmt.Errorf("SRV Record must match format \"_service._protocol\" not %s", host) return fmt.Errorf("SRV Record must match format \"_service._protocol\" not %s", host)
} }
var serviceName, protocol string = result[1], strings.ToLower(result[2]) var serviceName, protocol = result[1], strings.ToLower(result[2])
newSrv := datatypes.Dns_Domain_ResourceRecord_SrvType{ newSrv := datatypes.Dns_Domain_ResourceRecord_SrvType{
Dns_Domain_ResourceRecord: newRecord, Dns_Domain_ResourceRecord: newRecord,
@ -260,8 +260,8 @@ func (s *softlayerProvider) deleteRecordFunc(resID int) func() error {
} }
func (s *softlayerProvider) updateRecordFunc(existing *datatypes.Dns_Domain_ResourceRecord, desired *models.RecordConfig) func() error { func (s *softlayerProvider) updateRecordFunc(existing *datatypes.Dns_Domain_ResourceRecord, desired *models.RecordConfig) func() error {
var ttl, preference int = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference) var ttl, preference = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference)
var priority, weight, port int = int(desired.SrvPriority), int(desired.SrvWeight), int(desired.SrvPort) var priority, weight, port = int(desired.SrvPriority), int(desired.SrvWeight), int(desired.SrvPort)
return func() error { return func() error {
var changes = false var changes = false

3
staticcheck.conf Normal file
View file

@ -0,0 +1,3 @@
checks = ["all", "-ST1000", "-U1000"]
# U1000 is disabled due to https://github.com/dominikh/go-tools/issues/810
# TODO(tlim): When #810 is fixed, we should enable U1000.