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
// 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)

6
pkg/acme/acme.go
View file

@ -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
}

6
pkg/js/js.go
View file

@ -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.

4
providers/cloudflare/rest.go
View file

@ -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"`

50
providers/linode/api.go
View file

@ -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)

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)
}
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

22
providers/msdns/corrections.go
View file

@ -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)
},
}
}

2
providers/msdns/domains.go
View file

@ -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
}

4
providers/msdns/listzones.go
View file

@ -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
}

8
providers/namedotcom/zones.go
View file

@ -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)
}

8
providers/ns1/ns1Provider.go
View file

@ -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:

14
providers/octodns/octodnsProvider.go
View file

@ -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
}

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"`
}
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

14
providers/softlayer/softlayerProvider.go
View file

@ -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<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)
}
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

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.