From 886dbf6d0070ea7efc37e8235bb9bae50a1f0b61 Mon Sep 17 00:00:00 2001 From: Tom Limoncelli Date: Fri, 11 Feb 2022 14:30:45 -0500 Subject: [PATCH] MAINT: Make staticcheck more strict and fix new warnings (#1408) * Make staticcheck more strict and fix new warnings --- models/t_parse.go | 32 +++++++-------- pkg/acme/acme.go | 6 ++- pkg/js/js.go | 6 +-- providers/cloudflare/rest.go | 4 +- providers/linode/api.go | 50 ++++++++++++------------ providers/linode/linodeProvider.go | 2 +- providers/msdns/corrections.go | 22 +++++------ providers/msdns/domains.go | 2 +- providers/msdns/listzones.go | 4 +- providers/namedotcom/zones.go | 8 ++-- providers/ns1/ns1Provider.go | 8 ++-- providers/octodns/octodnsProvider.go | 14 +++---- providers/octodns/staticcheck.conf | 1 + providers/packetframe/api.go | 48 +++++++++++------------ providers/softlayer/softlayerProvider.go | 14 +++---- staticcheck.conf | 3 ++ 16 files changed, 117 insertions(+), 107 deletions(-) create mode 100644 providers/octodns/staticcheck.conf create mode 100644 staticcheck.conf diff --git a/models/t_parse.go b/models/t_parse.go index 00aba0812..ac444208d 100644 --- a/models/t_parse.go +++ b/models/t_parse.go @@ -12,43 +12,43 @@ import ( // // If this doesn't work for all rtypes, process the special cases then // call this for the remainder. -func (r *RecordConfig) PopulateFromString(rtype, contents, origin string) error { - if r.Type != "" && r.Type != rtype { - panic(fmt.Errorf("assertion failed: rtype already set (%s) (%s)", rtype, r.Type)) +func (rc *RecordConfig) PopulateFromString(rtype, contents, origin string) error { + if rc.Type != "" && rc.Type != rtype { + 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": ip := net.ParseIP(contents) if ip == nil || ip.To4() == nil { 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": ip := net.ParseIP(contents) if ip == nil || ip.To16() == nil { 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": - return r.SetTarget(contents) + return rc.SetTarget(contents) case "CAA": - return r.SetTargetCAAString(contents) + return rc.SetTargetCAAString(contents) case "DS": - return r.SetTargetDSString(contents) + return rc.SetTargetDSString(contents) case "MX": - return r.SetTargetMXString(contents) + return rc.SetTargetMXString(contents) case "NAPTR": - return r.SetTargetNAPTRString(contents) + return rc.SetTargetNAPTRString(contents) case "SRV": - return r.SetTargetSRVString(contents) + return rc.SetTargetSRVString(contents) case "SOA": - return r.SetTargetSOAString(contents) + return rc.SetTargetSOAString(contents) case "SSHFP": - return r.SetTargetSSHFPString(contents) + return rc.SetTargetSSHFPString(contents) case "TLSA": - return r.SetTargetTLSAString(contents) + return rc.SetTargetTLSAString(contents) case "SPF", "TXT": - return r.SetTargetTXTString(contents) + return rc.SetTargetTXTString(contents) default: return fmt.Errorf("unknown rtype (%s) when parsing (%s) domain=(%s)", rtype, contents, origin) diff --git a/pkg/acme/acme.go b/pkg/acme/acme.go index 31de71d4a..2ccf9deee 100644 --- a/pkg/acme/acme.go +++ b/pkg/acme/acme.go @@ -181,7 +181,11 @@ func getCertInfo(pemBytes []byte) (names []string, remaining float64, err error) if err != nil { 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) return cert.DNSNames, daysLeft, nil } diff --git a/pkg/js/js.go b/pkg/js/js.go index 8a31ee257..9660055c9 100644 --- a/pkg/js/js.go +++ b/pkg/js/js.go @@ -149,7 +149,7 @@ func require(call otto.FunctionCall) otto.Value { 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 strings.HasSuffix(filepath.Ext(relFile), "json") { @@ -194,7 +194,7 @@ func listFiles(call otto.FunctionCall) otto.Value { } // Second: Recursive? - var recursive bool = true + var recursive = true if call.Argument(1).IsDefined() && !call.Argument(1).IsNull() { if call.Argument(1).IsBoolean() { 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. - var fileExtension string = ".js" + var fileExtension = ".js" if call.Argument(2).IsDefined() && !call.Argument(2).IsNull() { if call.Argument(2).IsString() { fileExtension = call.Argument(2).String() // Which file extension to filter for. diff --git a/providers/cloudflare/rest.go b/providers/cloudflare/rest.go index d25692dd1..79b6638e2 100644 --- a/providers/cloudflare/rest.go +++ b/providers/cloudflare/rest.go @@ -352,7 +352,9 @@ func (c *cloudflareProvider) createTestWorker(workerName string) error { 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 { Operator string `json:"operator"` Value string `json:"value"` diff --git a/providers/linode/api.go b/providers/linode/api.go index c5e1ccfab..59f72c093 100644 --- a/providers/linode/api.go +++ b/providers/linode/api.go @@ -15,17 +15,17 @@ const ( domainsPath = "domains" ) -func (c *linodeProvider) fetchDomainList() error { - c.domainIndex = map[string]int{} +func (api *linodeProvider) fetchDomainList() error { + api.domainIndex = map[string]int{} page := 1 for { dr := &domainResponse{} 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) } 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 { break @@ -35,13 +35,13 @@ func (c *linodeProvider) fetchDomainList() error { return nil } -func (c *linodeProvider) getRecords(id int) ([]domainRecord, error) { +func (api *linodeProvider) getRecords(id int) ([]domainRecord, error) { records := []domainRecord{} page := 1 for { dr := &recordResponse{} 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) } @@ -56,21 +56,21 @@ func (c *linodeProvider) getRecords(id int) ([]domainRecord, error) { 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) - req, err := c.newRequest(http.MethodPost, endpoint, rec) + req, err := api.newRequest(http.MethodPost, endpoint, rec) if err != nil { return nil, err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return nil, err } if resp.StatusCode != http.StatusOK { - return nil, c.handleErrors(resp) + return nil, api.handleErrors(resp) } record := &domainRecord{} @@ -84,52 +84,52 @@ func (c *linodeProvider) createRecord(domainID int, rec *recordEditRequest) (*do 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) - req, err := c.newRequest(http.MethodPut, endpoint, rec) + req, err := api.newRequest(http.MethodPut, endpoint, rec) if err != nil { return err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { - return c.handleErrors(resp) + return api.handleErrors(resp) } 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) - req, err := c.newRequest(http.MethodDelete, endpoint, nil) + req, err := api.newRequest(http.MethodDelete, endpoint, nil) if err != nil { return err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { - return c.handleErrors(resp) + return api.handleErrors(resp) } 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) if err != nil { return nil, err } - u := c.baseURL.ResolveReference(rel) + u := api.baseURL.ResolveReference(rel) buf := new(bytes.Buffer) if body != nil { @@ -149,24 +149,24 @@ func (c *linodeProvider) newRequest(method, endpoint string, body interface{}) ( return req, nil } -func (c *linodeProvider) get(endpoint string, target interface{}) error { - req, err := c.newRequest(http.MethodGet, endpoint, nil) +func (api *linodeProvider) get(endpoint string, target interface{}) error { + req, err := api.newRequest(http.MethodGet, endpoint, nil) if err != nil { return err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { - return c.handleErrors(resp) + return api.handleErrors(resp) } defer resp.Body.Close() decoder := json.NewDecoder(resp.Body) return decoder.Decode(target) } -func (c *linodeProvider) handleErrors(resp *http.Response) error { +func (api *linodeProvider) handleErrors(resp *http.Response) error { defer resp.Body.Close() decoder := json.NewDecoder(resp.Body) diff --git a/providers/linode/linodeProvider.go b/providers/linode/linodeProvider.go index d6b1926c8..7a5414b33 100644 --- a/providers/linode/linodeProvider.go +++ b/providers/linode/linodeProvider.go @@ -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) } - var serviceName, protocol string = result[1], strings.ToLower(result[2]) + var serviceName, protocol = result[1], strings.ToLower(result[2]) req.Protocol = protocol req.Service = serviceName diff --git a/providers/msdns/corrections.go b/providers/msdns/corrections.go index a166028ca..a80ef4082 100644 --- a/providers/msdns/corrections.go +++ b/providers/msdns/corrections.go @@ -9,10 +9,10 @@ import ( ) // 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: - foundRecords, err := c.GetZoneRecords(dc.Name) + foundRecords, err := client.GetZoneRecords(dc.Name) if err != nil { 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. corrections := []*models.Correction{} 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 { - corrections = append(corrections, c.createRec(c.dnsserver, dc.Name, cre)...) + corrections = append(corrections, client.createRec(client.dnsserver, dc.Name, cre)...) } 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 } -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 return &models.Correction{ Msg: cor.String(), 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 arr := []*models.Correction{{ Msg: cre.String(), F: func() error { - return c.shell.RecordCreate(dnsserver, domainname, rec) + return client.shell.RecordCreate(dnsserver, domainname, rec) }, }} 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 return &models.Correction{ Msg: m.String(), F: func() error { - return c.shell.RecordModify(dnsserver, domainname, old, rec) + return client.shell.RecordModify(dnsserver, domainname, old, rec) }, } } diff --git a/providers/msdns/domains.go b/providers/msdns/domains.go index 4767cd576..88e643335 100644 --- a/providers/msdns/domains.go +++ b/providers/msdns/domains.go @@ -2,7 +2,7 @@ package msdns 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. return nil, nil } diff --git a/providers/msdns/listzones.go b/providers/msdns/listzones.go index 5168e5c8d..9ad65f651 100644 --- a/providers/msdns/listzones.go +++ b/providers/msdns/listzones.go @@ -1,7 +1,7 @@ package msdns -func (c *msdnsProvider) ListZones() ([]string, error) { - zones, err := c.shell.GetDNSServerZoneAll(c.dnsserver) +func (client *msdnsProvider) ListZones() ([]string, error) { + zones, err := client.shell.GetDNSServerZoneAll(client.dnsserver) if err != nil { return nil, err } diff --git a/providers/namedotcom/zones.go b/providers/namedotcom/zones.go index 0896497a0..93f45140b 100644 --- a/providers/namedotcom/zones.go +++ b/providers/namedotcom/zones.go @@ -5,18 +5,18 @@ import ( ) // ListZones returns all the zones in an account -func (c *namedotcomProvider) ListZones() ([]string, error) { +func (n *namedotcomProvider) ListZones() ([]string, error) { var names []string var page int32 for { - n, err := c.client.ListDomains(&namecom.ListDomainsRequest{Page: page}) + response, err := n.client.ListDomains(&namecom.ListDomainsRequest{Page: page}) if err != nil { return nil, err } - page = n.NextPage + page = response.NextPage - for _, j := range n.Domains { + for _, j := range response.Domains { names = append(names, j.DomainName) } diff --git a/providers/ns1/ns1Provider.go b/providers/ns1/ns1Provider.go index e609dad14..95c0b9d73 100644 --- a/providers/ns1/ns1Provider.go +++ b/providers/ns1/ns1Provider.go @@ -176,8 +176,8 @@ func buildRecord(recs models.Records, domain string, id string) *dns.Record { Rdata: []string{ fmt.Sprintf("%v", r.CaaFlag), r.CaaTag, - fmt.Sprintf("%s", r.GetTargetField()), - }}) + r.GetTargetField(), + }}) } 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()), " ")}) } else if r.Type == "NAPTR" { @@ -216,8 +216,8 @@ func convert(zr *dns.ZoneRecord, domain string) ([]*models.RecordConfig, error) } case "CAA": //dnscontrol expects quotes around multivalue CAA entries, API doesn't add them - x_ans := strings.SplitN(ans, " ", 3) - if err := rec.SetTargetCAAStrings(x_ans[0], x_ans[1], x_ans[2]); err != nil { + xAns := strings.SplitN(ans, " ", 3) + 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) } default: diff --git a/providers/octodns/octodnsProvider.go b/providers/octodns/octodnsProvider.go index 64498fb56..27224ec67 100644 --- a/providers/octodns/octodnsProvider.go +++ b/providers/octodns/octodnsProvider.go @@ -52,13 +52,13 @@ func initProvider(config map[string]string, providermeta json.RawMessage) (provi if api.directory == "" { api.directory = "config" } - if len(providermeta) != 0 { - err := json.Unmarshal(providermeta, api) - if err != nil { - return nil, err - } - } - //api.nameservers = models.StringsToNameservers(api.DefaultNS) + // Commented out because at this time api has no exported fields. + // if len(providermeta) != 0 { + // err := json.Unmarshal(providermeta, api) + // if err != nil { + // return nil, err + // } + // } return api, nil } diff --git a/providers/octodns/staticcheck.conf b/providers/octodns/staticcheck.conf new file mode 100644 index 000000000..f147677e5 --- /dev/null +++ b/providers/octodns/staticcheck.conf @@ -0,0 +1 @@ +checks = ["inherit", "-S1034"] diff --git a/providers/packetframe/api.go b/providers/packetframe/api.go index 069d33c87..e990a52e5 100644 --- a/providers/packetframe/api.go +++ b/providers/packetframe/api.go @@ -57,25 +57,25 @@ type domainRecord struct { Zone string `json:"zone"` } -func (c *packetframeProvider) fetchDomainList() error { - c.domainIndex = map[string]zone{} +func (api *packetframeProvider) fetchDomainList() error { + api.domainIndex = map[string]zone{} dr := &domainResponse{} 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) } for _, zone := range dr.Data.Zones { - c.domainIndex[zone.Zone] = zone + api.domainIndex[zone.Zone] = zone } return nil } -func (c *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error) { +func (api *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error) { var records []domainRecord dr := &recordResponse{} 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) } records = append(records, dr.Data.Records...) @@ -93,15 +93,15 @@ func (c *packetframeProvider) getRecords(zoneID string) ([]domainRecord, error) return records, nil } -func (c *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, error) { +func (api *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, error) { endpoint := "dns/records" - req, err := c.newRequest(http.MethodPost, endpoint, rec) + req, err := api.newRequest(http.MethodPost, endpoint, rec) if err != nil { return nil, err } - _, err = c.client.Do(req) + _, err = api.client.Do(req) if err != nil { return nil, err } @@ -109,15 +109,15 @@ func (c *packetframeProvider) createRecord(rec *domainRecord) (*domainRecord, er return rec, nil } -func (c *packetframeProvider) modifyRecord(rec *domainRecord) error { +func (api *packetframeProvider) modifyRecord(rec *domainRecord) error { endpoint := "dns/records" - req, err := c.newRequest(http.MethodPut, endpoint, rec) + req, err := api.newRequest(http.MethodPut, endpoint, rec) if err != nil { return err } - _, err = c.client.Do(req) + _, err = api.client.Do(req) if err != nil { return err } @@ -125,31 +125,31 @@ func (c *packetframeProvider) modifyRecord(rec *domainRecord) error { return nil } -func (c *packetframeProvider) deleteRecord(zoneID string, recordID string) error { +func (api *packetframeProvider) deleteRecord(zoneID string, recordID string) error { 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 { return err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { - return c.handleErrors(resp) + return api.handleErrors(resp) } 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) if err != nil { return nil, err } - u := c.baseURL.ResolveReference(rel) + u := api.baseURL.ResolveReference(rel) buf := new(bytes.Buffer) 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("Accept", mediaType) - req.Header.Add("Authorization", "Token "+c.token) + req.Header.Add("Authorization", "Token "+api.token) return req, nil } -func (c *packetframeProvider) get(endpoint string, target interface{}) error { - req, err := c.newRequest(http.MethodGet, endpoint, nil) +func (api *packetframeProvider) get(endpoint string, target interface{}) error { + req, err := api.newRequest(http.MethodGet, endpoint, nil) if err != nil { return err } - resp, err := c.client.Do(req) + resp, err := api.client.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { - return c.handleErrors(resp) + return api.handleErrors(resp) } defer resp.Body.Close() @@ -188,7 +188,7 @@ func (c *packetframeProvider) get(endpoint string, target interface{}) error { 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) if err != nil { return err diff --git a/providers/softlayer/softlayerProvider.go b/providers/softlayer/softlayerProvider.go index b0ca137ea..ec237476c 100644 --- a/providers/softlayer/softlayerProvider.go +++ b/providers/softlayer/softlayerProvider.go @@ -150,7 +150,7 @@ func (s *softlayerProvider) getExistingRecords(domain *datatypes.Dns_Domain) ([] switch recType { case "SRV": - var service, protocol string = "", "_tcp" + var service, protocol = "", "_tcp" if record.Weight != nil { 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 { - var ttl, preference, domainID int = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference), *domain.Id - var weight, priority, port int = int(desired.SrvWeight), int(desired.SrvPriority), int(desired.SrvPort) - var host, data, newType string = desired.GetLabel(), desired.GetTargetField(), desired.Type + var ttl, preference, domainID = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference), *domain.Id + var weight, priority, port = int(desired.SrvWeight), int(desired.SrvPriority), int(desired.SrvPort) + var host, data, newType = desired.GetLabel(), desired.GetTargetField(), desired.Type var err error srvRegexp := regexp.MustCompile(`^_(?P\w+)\.\_(?P\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) } - 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{ 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 { - var ttl, preference int = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference) - var priority, weight, port int = int(desired.SrvPriority), int(desired.SrvWeight), int(desired.SrvPort) + var ttl, preference = verifyMinTTL(int(desired.TTL)), int(desired.MxPreference) + var priority, weight, port = int(desired.SrvPriority), int(desired.SrvWeight), int(desired.SrvPort) return func() error { var changes = false diff --git a/staticcheck.conf b/staticcheck.conf new file mode 100644 index 000000000..5a9502dd5 --- /dev/null +++ b/staticcheck.conf @@ -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.