TrueCloudLab/coredns
16
0
Fork 2
Code Issues Pull requests 3 Projects Releases Packages Wiki Activity Actions

Run gofmt -s and golint on the codebase (#2918)

Browse source 
* Run gofmt -s and golint on the codebase

Run golint and fix everythign it flagged (except the context arg
ordering), mostly edits in the rewrite plugin.

Signed-off-by: Miek Gieben <miek@miek.nl>

* ... and ofcourse the test as well

Signed-off-by: Miek Gieben <miek@miek.nl>
This commit is contained in:
Miek Gieben 2019-06-25 08:00:33 +01:00 • committed by Yong Tang
parent 123628dc46
commit cd176f859b
8 changed files with 72 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
plugin/chaos/zowners.go
View file

@ -1,4 +1,4 @@
package chaos package chaos
// Owners are all GitHub handlers of all maintainers. // Owners are all GitHub handlers of all maintainers.
var Owners = []string{"bradbeam", "chrisohaver", "dilyevsky", "ekleiner", "fastest963", "greenpau", "grobie", "inigohu", "isolus", "johnbelamaric", "miekg", "nchrisdk", "nitisht", "pmoroney", "rajansandeep", "rdrozhdzh", "rtreffer", "stp-ip", "superq", "varyoo", "yongtang"} var Owners = []string{"bradbeam", "chrisohaver", "dilyevsky", "ekleiner", "fastest963", "greenpau", "grobie", "inigohu", "isolus", "johnbelamaric", "miekg", "nchrisdk", "nitisht", "pmoroney", "rajansandeep", "rdrozhdzh", "rtreffer", "stp-ip", "superq", "varyoo", "yongtang"}

10
plugin/kubernetes/controller_test.go
View file

@ -79,7 +79,7 @@ func generateEndpoints(cidr string, client kubernetes.Interface) {
} }
ep.ObjectMeta.Name = "svc" + strconv.Itoa(count) ep.ObjectMeta.Name = "svc" + strconv.Itoa(count)
_, err = client.CoreV1().Endpoints("testns").Create(ep) _, err = client.CoreV1().Endpoints("testns").Create(ep)
count += 1 count++
} }
} }
@ -94,17 +94,17 @@ func generateSvcs(cidr string, svcType string, client kubernetes.Interface) {
case "clusterip": case "clusterip":
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) { for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) {
createClusterIPSvc(count, client, ip) createClusterIPSvc(count, client, ip)
count += 1 count++
} }
case "headless": case "headless":
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) { for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) {
createHeadlessSvc(count, client, ip) createHeadlessSvc(count, client, ip)
count += 1 count++
} }
case "external": case "external":
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) { for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) {
createExternalSvc(count, client, ip) createExternalSvc(count, client, ip)
count += 1 count++
} }
default: default:
for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) { for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) {
@ -115,7 +115,7 @@ func generateSvcs(cidr string, svcType string, client kubernetes.Interface) {
} else if count%3 == 2 { } else if count%3 == 2 {
createExternalSvc(count, client, ip) createExternalSvc(count, client, ip)
} }
count += 1 count++
} }
} }
} }

2
plugin/log/setup.go
View file

@ -104,7 +104,7 @@ func logParse(c *caddy.Controller) ([]Rule, error) {
classes[response.All] = struct{}{} classes[response.All] = struct{}{}
} }
for i := len(rules) - 1; i >= length; i -= 1 { for i := len(rules) - 1; i >= length; i-- {
rules[i].Class = classes rules[i].Class = classes
} }
} }

23
plugin/rewrite/reverter.go
View file

@ -1,10 +1,11 @@
package rewrite package rewrite
import ( import (
"github.com/miekg/dns"
"regexp" "regexp"
"strconv" "strconv"
"strings" "strings"
"github.com/miekg/dns"
) )
// ResponseRule contains a rule to rewrite a response with. // ResponseRule contains a rule to rewrite a response with.
@ -13,7 +14,7 @@ type ResponseRule struct {
Type string Type string
Pattern *regexp.Regexp Pattern *regexp.Regexp
Replacement string Replacement string
Ttl uint32 TTL uint32
} }
// ResponseReverter reverses the operations done on the question section of a packet. // ResponseReverter reverses the operations done on the question section of a packet.
@ -39,10 +40,12 @@ func (r *ResponseReverter) WriteMsg(res *dns.Msg) error {
res.Question[0] = r.originalQuestion res.Question[0] = r.originalQuestion
if r.ResponseRewrite { if r.ResponseRewrite {
for _, rr := range res.Answer { for _, rr := range res.Answer {
var isNameRewritten bool = false var (
var isTtlRewritten bool = false isNameRewritten bool
var name string = rr.Header().Name isTTLRewritten bool
var ttl uint32 = rr.Header().Ttl name = rr.Header().Name
ttl = rr.Header().Ttl
)
for _, rule := range r.ResponseRules { for _, rule := range r.ResponseRules {
if rule.Type == "" { if rule.Type == "" {
rule.Type = "name" rule.Type = "name"
@ -63,14 +66,14 @@ func (r *ResponseReverter) WriteMsg(res *dns.Msg) error {
name = s name = s
isNameRewritten = true isNameRewritten = true
case "ttl": case "ttl":
ttl = rule.Ttl ttl = rule.TTL
isTtlRewritten = true isTTLRewritten = true
} }
} }
if isNameRewritten == true { if isNameRewritten {
rr.Header().Name = name rr.Header().Name = name
} }
if isTtlRewritten == true { if isTTLRewritten {
rr.Header().Ttl = ttl rr.Header().Ttl = ttl
} }
} }

4
plugin/rewrite/rewrite.go
View file

@ -51,7 +51,7 @@ func (rw Rewrite) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg
return dns.RcodeServerFailure, fmt.Errorf("invalid name after rewrite: %s", x) return dns.RcodeServerFailure, fmt.Errorf("invalid name after rewrite: %s", x)
} }
respRule := rule.GetResponseRule() respRule := rule.GetResponseRule()
if respRule.Active == true { if respRule.Active {
wr.ResponseRewrite = true wr.ResponseRewrite = true
wr.ResponseRules = append(wr.ResponseRules, respRule) wr.ResponseRules = append(wr.ResponseRules, respRule)
} }
@ -128,7 +128,7 @@ func newRule(args ...string) (Rule, error) {
case "edns0": case "edns0":
return newEdns0Rule(mode, args[startArg:]...) return newEdns0Rule(mode, args[startArg:]...)
case "ttl": case "ttl":
return newTtlRule(mode, args[startArg:]...) return newTTLRule(mode, args[startArg:]...)
default: default:
return nil, fmt.Errorf("invalid rule type %q", args[0]) return nil, fmt.Errorf("invalid rule type %q", args[0])
} }

76
plugin/rewrite/ttl.go
View file

@ -12,31 +12,31 @@ import (
//"github.com/miekg/dns" //"github.com/miekg/dns"
) )
type exactTtlRule struct { type exactTTLRule struct {
NextAction string NextAction string
From string From string
ResponseRule ResponseRule
} }
type prefixTtlRule struct { type prefixTTLRule struct {
NextAction string NextAction string
Prefix string Prefix string
ResponseRule ResponseRule
} }
type suffixTtlRule struct { type suffixTTLRule struct {
NextAction string NextAction string
Suffix string Suffix string
ResponseRule ResponseRule
} }
type substringTtlRule struct { type substringTTLRule struct {
NextAction string NextAction string
Substring string Substring string
ResponseRule ResponseRule
} }
type regexTtlRule struct { type regexTTLRule struct {
NextAction string NextAction string
Pattern *regexp.Regexp Pattern *regexp.Regexp
ResponseRule ResponseRule
@ -44,7 +44,7 @@ type regexTtlRule struct {
// Rewrite rewrites the current request based upon exact match of the name // Rewrite rewrites the current request based upon exact match of the name
// in the question section of the request. // in the question section of the request.
func (rule *exactTtlRule) Rewrite(ctx context.Context, state request.Request) Result { func (rule *exactTTLRule) Rewrite(ctx context.Context, state request.Request) Result {
if rule.From == state.Name() { if rule.From == state.Name() {
return RewriteDone return RewriteDone
} }
@ -52,7 +52,7 @@ func (rule *exactTtlRule) Rewrite(ctx context.Context, state request.Request) Re
} }
// Rewrite rewrites the current request when the name begins with the matching string. // Rewrite rewrites the current request when the name begins with the matching string.
func (rule *prefixTtlRule) Rewrite(ctx context.Context, state request.Request) Result { func (rule *prefixTTLRule) Rewrite(ctx context.Context, state request.Request) Result {
if strings.HasPrefix(state.Name(), rule.Prefix) { if strings.HasPrefix(state.Name(), rule.Prefix) {
return RewriteDone return RewriteDone
} }
@ -60,7 +60,7 @@ func (rule *prefixTtlRule) Rewrite(ctx context.Context, state request.Request) R
} }
// Rewrite rewrites the current request when the name ends with the matching string. // Rewrite rewrites the current request when the name ends with the matching string.
func (rule *suffixTtlRule) Rewrite(ctx context.Context, state request.Request) Result { func (rule *suffixTTLRule) Rewrite(ctx context.Context, state request.Request) Result {
if strings.HasSuffix(state.Name(), rule.Suffix) { if strings.HasSuffix(state.Name(), rule.Suffix) {
return RewriteDone return RewriteDone
} }
@ -69,7 +69,7 @@ func (rule *suffixTtlRule) Rewrite(ctx context.Context, state request.Request) R
// Rewrite rewrites the current request based upon partial match of the // Rewrite rewrites the current request based upon partial match of the
// name in the question section of the request. // name in the question section of the request.
func (rule *substringTtlRule) Rewrite(ctx context.Context, state request.Request) Result { func (rule *substringTTLRule) Rewrite(ctx context.Context, state request.Request) Result {
if strings.Contains(state.Name(), rule.Substring) { if strings.Contains(state.Name(), rule.Substring) {
return RewriteDone return RewriteDone
} }
@ -78,7 +78,7 @@ func (rule *substringTtlRule) Rewrite(ctx context.Context, state request.Request
// Rewrite rewrites the current request when the name in the question // Rewrite rewrites the current request when the name in the question
// section of the request matches a regular expression. // section of the request matches a regular expression.
func (rule *regexTtlRule) Rewrite(ctx context.Context, state request.Request) Result { func (rule *regexTTLRule) Rewrite(ctx context.Context, state request.Request) Result {
regexGroups := rule.Pattern.FindStringSubmatch(state.Name()) regexGroups := rule.Pattern.FindStringSubmatch(state.Name())
if len(regexGroups) == 0 { if len(regexGroups) == 0 {
return RewriteIgnored return RewriteIgnored
@ -86,8 +86,8 @@ func (rule *regexTtlRule) Rewrite(ctx context.Context, state request.Request) Re
return RewriteDone return RewriteDone
} }
// newTtlRule creates a name matching rule based on exact, partial, or regex match // newTTLRule creates a name matching rule based on exact, partial, or regex match
func newTtlRule(nextAction string, args ...string) (Rule, error) { func newTTLRule(nextAction string, args ...string) (Rule, error) {
if len(args) < 2 { if len(args) < 2 {
return nil, fmt.Errorf("too few (%d) arguments for a ttl rule", len(args)) return nil, fmt.Errorf("too few (%d) arguments for a ttl rule", len(args))
} }
@ -98,50 +98,50 @@ func newTtlRule(nextAction string, args ...string) (Rule, error) {
if len(args) == 3 { if len(args) == 3 {
s = args[2] s = args[2]
} }
ttl, valid := isValidTtl(s) ttl, valid := isValidTTL(s)
if valid == false { if !valid {
return nil, fmt.Errorf("invalid TTL '%s' for a ttl rule", s) return nil, fmt.Errorf("invalid TTL '%s' for a ttl rule", s)
} }
if len(args) == 3 { if len(args) == 3 {
switch strings.ToLower(args[0]) { switch strings.ToLower(args[0]) {
case ExactMatch: case ExactMatch:
return &exactTtlRule{ return &exactTTLRule{
nextAction, nextAction,
plugin.Name(args[1]).Normalize(), plugin.Name(args[1]).Normalize(),
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
case PrefixMatch: case PrefixMatch:
return &prefixTtlRule{ return &prefixTTLRule{
nextAction, nextAction,
plugin.Name(args[1]).Normalize(), plugin.Name(args[1]).Normalize(),
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
case SuffixMatch: case SuffixMatch:
return &suffixTtlRule{ return &suffixTTLRule{
nextAction, nextAction,
plugin.Name(args[1]).Normalize(), plugin.Name(args[1]).Normalize(),
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
case SubstringMatch: case SubstringMatch:
return &substringTtlRule{ return &substringTTLRule{
nextAction, nextAction,
plugin.Name(args[1]).Normalize(), plugin.Name(args[1]).Normalize(),
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
case RegexMatch: case RegexMatch:
@ -149,13 +149,13 @@ func newTtlRule(nextAction string, args ...string) (Rule, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("invalid regex pattern in a ttl rule: %s", args[1]) return nil, fmt.Errorf("invalid regex pattern in a ttl rule: %s", args[1])
} }
return &regexTtlRule{ return &regexTTLRule{
nextAction, nextAction,
regexPattern, regexPattern,
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
default: default:
@ -165,51 +165,51 @@ func newTtlRule(nextAction string, args ...string) (Rule, error) {
if len(args) > 3 { if len(args) > 3 {
return nil, fmt.Errorf("many few arguments for a ttl rule") return nil, fmt.Errorf("many few arguments for a ttl rule")
} }
return &exactTtlRule{ return &exactTTLRule{
nextAction, nextAction,
plugin.Name(args[0]).Normalize(), plugin.Name(args[0]).Normalize(),
ResponseRule{ ResponseRule{
Active: true, Active: true,
Type: "ttl", Type: "ttl",
Ttl: ttl, TTL: ttl,
}, },
}, nil }, nil
} }
// Mode returns the processing nextAction // Mode returns the processing nextAction
func (rule *exactTtlRule) Mode() string { return rule.NextAction } func (rule *exactTTLRule) Mode() string { return rule.NextAction }
func (rule *prefixTtlRule) Mode() string { return rule.NextAction } func (rule *prefixTTLRule) Mode() string { return rule.NextAction }
func (rule *suffixTtlRule) Mode() string { return rule.NextAction } func (rule *suffixTTLRule) Mode() string { return rule.NextAction }
func (rule *substringTtlRule) Mode() string { return rule.NextAction } func (rule *substringTTLRule) Mode() string { return rule.NextAction }
func (rule *regexTtlRule) Mode() string { return rule.NextAction } func (rule *regexTTLRule) Mode() string { return rule.NextAction }
// GetResponseRule return a rule to rewrite the response with. Currently not implemented. // GetResponseRule return a rule to rewrite the response with. Currently not implemented.
func (rule *exactTtlRule) GetResponseRule() ResponseRule { func (rule *exactTTLRule) GetResponseRule() ResponseRule {
return rule.ResponseRule return rule.ResponseRule
} }
// GetResponseRule return a rule to rewrite the response with. Currently not implemented. // GetResponseRule return a rule to rewrite the response with. Currently not implemented.
func (rule *prefixTtlRule) GetResponseRule() ResponseRule { func (rule *prefixTTLRule) GetResponseRule() ResponseRule {
return rule.ResponseRule return rule.ResponseRule
} }
// GetResponseRule return a rule to rewrite the response with. Currently not implemented. // GetResponseRule return a rule to rewrite the response with. Currently not implemented.
func (rule *suffixTtlRule) GetResponseRule() ResponseRule { func (rule *suffixTTLRule) GetResponseRule() ResponseRule {
return rule.ResponseRule return rule.ResponseRule
} }
// GetResponseRule return a rule to rewrite the response with. Currently not implemented. // GetResponseRule return a rule to rewrite the response with. Currently not implemented.
func (rule *substringTtlRule) GetResponseRule() ResponseRule { func (rule *substringTTLRule) GetResponseRule() ResponseRule {
return rule.ResponseRule return rule.ResponseRule
} }
// GetResponseRule return a rule to rewrite the response with. // GetResponseRule return a rule to rewrite the response with.
func (rule *regexTtlRule) GetResponseRule() ResponseRule { func (rule *regexTTLRule) GetResponseRule() ResponseRule {
return rule.ResponseRule return rule.ResponseRule
} }
// validTtl returns true if v is valid TTL value. // validTTL returns true if v is valid TTL value.
func isValidTtl(v string) (uint32, bool) { func isValidTTL(v string) (uint32, bool) {
i, err := strconv.Atoi(v) i, err := strconv.Atoi(v)
if err != nil { if err != nil {
return uint32(0), false return uint32(0), false

22
plugin/rewrite/ttl_test.go
View file

@ -12,7 +12,7 @@ import (
"github.com/miekg/dns" "github.com/miekg/dns"
) )
func TestNewTtlRule(t *testing.T) { func TestNewTTLRule(t *testing.T) {
tests := []struct { tests := []struct {
next string next string
args []string args []string
@ -36,7 +36,7 @@ func TestNewTtlRule(t *testing.T) {
} }
for i, tc := range tests { for i, tc := range tests {
failed := false failed := false
rule, err := newTtlRule(tc.next, tc.args...) rule, err := newTTLRule(tc.next, tc.args...)
if err != nil { if err != nil {
failed = true failed = true
} }
@ -71,13 +71,13 @@ func TestTtlRewrite(t *testing.T) {
args []string args []string
expectedType reflect.Type expectedType reflect.Type
}{ }{
{[]string{"stop", "ttl", "srv1.coredns.rocks", "1"}, reflect.TypeOf(&exactTtlRule{})}, {[]string{"stop", "ttl", "srv1.coredns.rocks", "1"}, reflect.TypeOf(&exactTTLRule{})},
{[]string{"stop", "ttl", "exact", "srv15.coredns.rocks", "15"}, reflect.TypeOf(&exactTtlRule{})}, {[]string{"stop", "ttl", "exact", "srv15.coredns.rocks", "15"}, reflect.TypeOf(&exactTTLRule{})},
{[]string{"stop", "ttl", "prefix", "srv30", "30"}, reflect.TypeOf(&prefixTtlRule{})}, {[]string{"stop", "ttl", "prefix", "srv30", "30"}, reflect.TypeOf(&prefixTTLRule{})},
{[]string{"stop", "ttl", "suffix", "45.coredns.rocks", "45"}, reflect.TypeOf(&suffixTtlRule{})}, {[]string{"stop", "ttl", "suffix", "45.coredns.rocks", "45"}, reflect.TypeOf(&suffixTTLRule{})},
{[]string{"stop", "ttl", "substring", "rv50", "50"}, reflect.TypeOf(&substringTtlRule{})}, {[]string{"stop", "ttl", "substring", "rv50", "50"}, reflect.TypeOf(&substringTTLRule{})},
{[]string{"stop", "ttl", "regex", `(srv10)\.(coredns)\.(rocks)`, "10"}, reflect.TypeOf(&regexTtlRule{})}, {[]string{"stop", "ttl", "regex", `(srv10)\.(coredns)\.(rocks)`, "10"}, reflect.TypeOf(&regexTTLRule{})},
{[]string{"stop", "ttl", "regex", `(srv20)\.(coredns)\.(rocks)`, "20"}, reflect.TypeOf(&regexTtlRule{})}, {[]string{"stop", "ttl", "regex", `(srv20)\.(coredns)\.(rocks)`, "20"}, reflect.TypeOf(&regexTTLRule{})},
} }
for i, r := range ruleset { for i, r := range ruleset {
rule, err := newRule(r.args...) rule, err := newRule(r.args...)
@ -90,10 +90,10 @@ func TestTtlRewrite(t *testing.T) {
} }
rules = append(rules, rule) rules = append(rules, rule)
} }
doTtlTests(rules, t) doTTLTests(rules, t)
} }
func doTtlTests(rules []Rule, t *testing.T) { func doTTLTests(rules []Rule, t *testing.T) {
tests := []struct { tests := []struct {
from string from string
fromType uint16 fromType uint16

2
plugin/tls/tls_test.go
View file

@ -50,7 +50,7 @@ func TestTLS(t *testing.T) {
func TestTLSClientAuthentication(t *testing.T) { func TestTLSClientAuthentication(t *testing.T) {
// Invalid configurations are tested in the general test case. In this test we only look into specific details of valid client_auth options. // Invalid configurations are tested in the general test case. In this test we only look into specific details of valid client_auth options.
tests := []struct { tests := []struct {
option string // tls plugin option(s) option string // tls plugin option(s)
expectedType tls.ClientAuthType // expected authentication type. expectedType tls.ClientAuthType // expected authentication type.
}{ }{
// By default, or if 'nocert' is specified, no cert should be requested. // By default, or if 'nocert' is specified, no cert should be requested.