From 1a1891c8b63b390a58e890f734f095202df030cf Mon Sep 17 00:00:00 2001 From: Kwitsch Date: Tue, 21 Nov 2023 06:33:38 +0100 Subject: [PATCH] symbol name refactoring (#1263) * ECSConfig -> ECS * EdeConfig -> EDE * EdeResolver -> EDEResolver * SUDNConfig -> SUDN * FqdnOnlyConfig -> FQDNOnly * FqdnOnlyResolver -> FQDNOnlyResolver --- config/config.go | 12 ++++++------ config/config_test.go | 2 +- config/ecs.go | 8 ++++---- config/ecs_test.go | 8 ++++---- config/sudn.go | 8 ++++---- config/sudn_test.go | 4 ++-- resolver/ecs_resolver.go | 4 ++-- resolver/ecs_resolver_test.go | 2 +- resolver/ede_resolver.go | 16 ++++++++-------- resolver/ede_resolver_test.go | 10 +++++----- resolver/fqdn_only_resolver.go | 10 +++++----- resolver/fqdn_only_resolver_test.go | 10 +++++----- resolver/sudn_resolver.go | 14 +++++++------- resolver/sudn_resolver_test.go | 4 ++-- server/server.go | 4 ++-- 15 files changed, 58 insertions(+), 58 deletions(-) diff --git a/config/config.go b/config/config.go index 0b885e65..90c1ff16 100644 --- a/config/config.go +++ b/config/config.go @@ -208,11 +208,11 @@ type Config struct { KeyFile string `yaml:"keyFile"` BootstrapDNS BootstrapDNSConfig `yaml:"bootstrapDns"` HostsFile HostsFileConfig `yaml:"hostsFile"` - FqdnOnly FqdnOnlyConfig `yaml:"fqdnOnly"` + FQDNOnly FQDNOnly `yaml:"fqdnOnly"` Filtering FilteringConfig `yaml:"filtering"` - Ede EdeConfig `yaml:"ede"` - ECS ECSConfig `yaml:"ecs"` - SUDN SUDNConfig `yaml:"specialUseDomains"` + EDE EDE `yaml:"ede"` + ECS ECS `yaml:"ecs"` + SUDN SUDN `yaml:"specialUseDomains"` // Deprecated options Deprecated struct { @@ -274,8 +274,8 @@ type RedisConfig struct { } type ( - FqdnOnlyConfig = toEnable - EdeConfig = toEnable + FQDNOnly = toEnable + EDE = toEnable ) type toEnable struct { diff --git a/config/config_test.go b/config/config_test.go index e59c2076..06b98283 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -791,7 +791,7 @@ func defaultTestFileConfig() { Expect(config.Blocking.BlockTTL).Should(Equal(Duration(time.Minute))) Expect(config.Blocking.Loading.RefreshPeriod).Should(Equal(Duration(2 * time.Hour))) Expect(config.Filtering.QueryTypes).Should(HaveLen(2)) - Expect(config.FqdnOnly.Enable).Should(BeTrue()) + Expect(config.FQDNOnly.Enable).Should(BeTrue()) Expect(config.Caching.MaxCachingTime).Should(BeZero()) Expect(config.Caching.MinCachingTime).Should(BeZero()) diff --git a/config/ecs.go b/config/ecs.go index 042098d5..936a57fb 100644 --- a/config/ecs.go +++ b/config/ecs.go @@ -42,8 +42,8 @@ func (x *ECSv6Mask) UnmarshalText(text []byte) error { return nil } -// ECSConfig is the configuration of the ECS resolver -type ECSConfig struct { +// ECS is the configuration of the ECS resolver +type ECS struct { UseAsClient bool `yaml:"useAsClient" default:"false"` Forward bool `yaml:"forward" default:"false"` IPv4Mask ECSv4Mask `yaml:"ipv4Mask" default:"0"` @@ -51,12 +51,12 @@ type ECSConfig struct { } // IsEnabled returns true if the ECS resolver is enabled -func (c *ECSConfig) IsEnabled() bool { +func (c *ECS) IsEnabled() bool { return c.UseAsClient || c.Forward || c.IPv4Mask > 0 || c.IPv6Mask > 0 } // LogConfig logs the configuration -func (c *ECSConfig) LogConfig(logger *logrus.Entry) { +func (c *ECS) LogConfig(logger *logrus.Entry) { logger.Infof("Use as client = %t", c.UseAsClient) logger.Infof("Forward = %t", c.Forward) logger.Infof("IPv4 netmask = %d", c.IPv4Mask) diff --git a/config/ecs_test.go b/config/ecs_test.go index 372ccc05..b6165c6e 100644 --- a/config/ecs_test.go +++ b/config/ecs_test.go @@ -8,9 +8,9 @@ import ( "gopkg.in/yaml.v2" ) -var _ = Describe("ECSConfig", func() { +var _ = Describe("ECS", func() { var ( - c ECSConfig + c ECS err error ) @@ -26,7 +26,7 @@ var _ = Describe("ECSConfig", func() { }) }) - When("UseEcsAsClient is true", func() { + When("UseAsClient is true", func() { BeforeEach(func() { c.UseAsClient = true }) @@ -36,7 +36,7 @@ var _ = Describe("ECSConfig", func() { }) }) - When("ForwardEcs is true", func() { + When("Forward is true", func() { BeforeEach(func() { c.Forward = true }) diff --git a/config/sudn.go b/config/sudn.go index bf18a05c..6f65bb06 100644 --- a/config/sudn.go +++ b/config/sudn.go @@ -4,8 +4,8 @@ import ( "github.com/sirupsen/logrus" ) -// SUDNConfig configuration for Special Use Domain Names -type SUDNConfig struct { +// SUDN configuration for Special Use Domain Names +type SUDN struct { // These are "recommended for private use" but not mandatory. // If a user wishes to use one, it will most likely be via conditional // upstream or custom DNS, which come before SUDN in the resolver chain. @@ -14,12 +14,12 @@ type SUDNConfig struct { } // IsEnabled implements `config.Configurable`. -func (c *SUDNConfig) IsEnabled() bool { +func (c *SUDN) IsEnabled() bool { // The Special Use RFCs are always active return true } // LogConfig implements `config.Configurable`. -func (c *SUDNConfig) LogConfig(logger *logrus.Entry) { +func (c *SUDN) LogConfig(logger *logrus.Entry) { logger.Debugf("rfc6762-appendixG = %v", c.RFC6762AppendixG) } diff --git a/config/sudn_test.go b/config/sudn_test.go index 350efa12..705ebdd0 100644 --- a/config/sudn_test.go +++ b/config/sudn_test.go @@ -6,14 +6,14 @@ import ( ) var _ = Describe("SUDNConfig", func() { - var cfg SUDNConfig + var cfg SUDN suiteBeforeEach() BeforeEach(func() { var err error - cfg, err = WithDefaults[SUDNConfig]() + cfg, err = WithDefaults[SUDN]() Expect(err).Should(Succeed()) }) diff --git a/resolver/ecs_resolver.go b/resolver/ecs_resolver.go index 9a241550..16086ebf 100644 --- a/resolver/ecs_resolver.go +++ b/resolver/ecs_resolver.go @@ -31,13 +31,13 @@ type ECSMask interface { // ECSResolver is responsible for adding the EDNS Client Subnet information as EDNS0 option. type ECSResolver struct { - configurable[*config.ECSConfig] + configurable[*config.ECS] NextResolver typed } // NewECSResolver creates new resolver instance which adds the subnet information as EDNS0 option -func NewECSResolver(cfg config.ECSConfig) ChainedResolver { +func NewECSResolver(cfg config.ECS) ChainedResolver { return &ECSResolver{ configurable: withConfig(&cfg), typed: withType("extended_client_subnet"), diff --git a/resolver/ecs_resolver_test.go b/resolver/ecs_resolver_test.go index b10efb77..7d6507d8 100644 --- a/resolver/ecs_resolver_test.go +++ b/resolver/ecs_resolver_test.go @@ -19,7 +19,7 @@ import ( var _ = Describe("EcsResolver", func() { var ( sut *ECSResolver - sutConfig config.ECSConfig + sutConfig config.ECS m *mockResolver mockAnswer *dns.Msg err error diff --git a/resolver/ede_resolver.go b/resolver/ede_resolver.go index f6b507ff..740d8122 100644 --- a/resolver/ede_resolver.go +++ b/resolver/ede_resolver.go @@ -7,17 +7,17 @@ import ( "github.com/miekg/dns" ) -// A EdeResolver is responsible for adding the reason for the response as EDNS0 option -type EdeResolver struct { - configurable[*config.EdeConfig] +// A EDEResolver is responsible for adding the reason for the response as EDNS0 option +type EDEResolver struct { + configurable[*config.EDE] NextResolver typed } -// NewEdeResolver creates new resolver instance which adds the reason for +// NewEDEResolver creates new resolver instance which adds the reason for // the response as EDNS0 option to the response if it is enabled in the configuration -func NewEdeResolver(cfg config.EdeConfig) *EdeResolver { - return &EdeResolver{ +func NewEDEResolver(cfg config.EDE) *EDEResolver { + return &EDEResolver{ configurable: withConfig(&cfg), typed: withType("extended_error_code"), } @@ -25,7 +25,7 @@ func NewEdeResolver(cfg config.EdeConfig) *EdeResolver { // Resolve adds the reason as EDNS0 option to the response of the next resolver // if it is enabled in the configuration -func (r *EdeResolver) Resolve(request *model.Request) (*model.Response, error) { +func (r *EDEResolver) Resolve(request *model.Request) (*model.Response, error) { if !r.cfg.Enable { return r.next.Resolve(request) } @@ -41,7 +41,7 @@ func (r *EdeResolver) Resolve(request *model.Request) (*model.Response, error) { } // addExtraReasoning adds the reason for the response as EDNS0 option -func (r *EdeResolver) addExtraReasoning(res *model.Response) { +func (r *EDEResolver) addExtraReasoning(res *model.Response) { infocode := res.RType.ToExtendedErrorCode() if infocode == dns.ExtendedErrorCodeOther { diff --git a/resolver/ede_resolver_test.go b/resolver/ede_resolver_test.go index cad90600..4c0036c3 100644 --- a/resolver/ede_resolver_test.go +++ b/resolver/ede_resolver_test.go @@ -20,8 +20,8 @@ import ( var _ = Describe("EdeResolver", func() { var ( - sut *EdeResolver - sutConfig config.EdeConfig + sut *EDEResolver + sutConfig config.EDE m *mockResolver mockAnswer *dns.Msg ) @@ -46,13 +46,13 @@ var _ = Describe("EdeResolver", func() { }, nil) } - sut = NewEdeResolver(sutConfig) + sut = NewEDEResolver(sutConfig) sut.Next(m) }) When("ede is disabled", func() { BeforeEach(func() { - sutConfig = config.EdeConfig{ + sutConfig = config.EDE{ Enable: false, } }) @@ -79,7 +79,7 @@ var _ = Describe("EdeResolver", func() { When("ede is enabled", func() { BeforeEach(func() { - sutConfig = config.EdeConfig{ + sutConfig = config.EDE{ Enable: true, } }) diff --git a/resolver/fqdn_only_resolver.go b/resolver/fqdn_only_resolver.go index 25093f4b..5a81a11b 100644 --- a/resolver/fqdn_only_resolver.go +++ b/resolver/fqdn_only_resolver.go @@ -9,20 +9,20 @@ import ( "github.com/miekg/dns" ) -type FqdnOnlyResolver struct { - configurable[*config.FqdnOnlyConfig] +type FQDNOnlyResolver struct { + configurable[*config.FQDNOnly] NextResolver typed } -func NewFqdnOnlyResolver(cfg config.FqdnOnlyConfig) *FqdnOnlyResolver { - return &FqdnOnlyResolver{ +func NewFQDNOnlyResolver(cfg config.FQDNOnly) *FQDNOnlyResolver { + return &FQDNOnlyResolver{ configurable: withConfig(&cfg), typed: withType("fqdn_only"), } } -func (r *FqdnOnlyResolver) Resolve(request *model.Request) (*model.Response, error) { +func (r *FQDNOnlyResolver) Resolve(request *model.Request) (*model.Response, error) { if r.IsEnabled() { domainFromQuestion := util.ExtractDomain(request.Req.Question[0]) if !strings.Contains(domainFromQuestion, ".") { diff --git a/resolver/fqdn_only_resolver_test.go b/resolver/fqdn_only_resolver_test.go index 7838cc34..713d155e 100644 --- a/resolver/fqdn_only_resolver_test.go +++ b/resolver/fqdn_only_resolver_test.go @@ -13,8 +13,8 @@ import ( var _ = Describe("FqdnOnlyResolver", func() { var ( - sut *FqdnOnlyResolver - sutConfig config.FqdnOnlyConfig + sut *FQDNOnlyResolver + sutConfig config.FQDNOnly m *mockResolver mockAnswer *dns.Msg ) @@ -30,7 +30,7 @@ var _ = Describe("FqdnOnlyResolver", func() { }) JustBeforeEach(func() { - sut = NewFqdnOnlyResolver(sutConfig) + sut = NewFQDNOnlyResolver(sutConfig) m = &mockResolver{} m.On("Resolve", mock.Anything).Return(&Response{Res: mockAnswer}, nil) sut.Next(m) @@ -54,7 +54,7 @@ var _ = Describe("FqdnOnlyResolver", func() { When("Fqdn only is enabled", func() { BeforeEach(func() { - sutConfig = config.FqdnOnlyConfig{Enable: true} + sutConfig = config.FQDNOnly{Enable: true} }) It("Should delegate to next resolver if request query is fqdn", func() { Expect(sut.Resolve(newRequest("example.com", A))). @@ -100,7 +100,7 @@ var _ = Describe("FqdnOnlyResolver", func() { When("Fqdn only is disabled", func() { BeforeEach(func() { - sutConfig = config.FqdnOnlyConfig{Enable: false} + sutConfig = config.FQDNOnly{Enable: false} }) It("Should delegate to next resolver if request query is fqdn", func() { Expect(sut.Resolve(newRequest("example.com", A))). diff --git a/resolver/sudn_resolver.go b/resolver/sudn_resolver.go index f70c51a5..adf1cce0 100644 --- a/resolver/sudn_resolver.go +++ b/resolver/sudn_resolver.go @@ -9,7 +9,7 @@ import ( "github.com/miekg/dns" ) -type sudnHandler = func(request *model.Request, cfg *config.SUDNConfig) *model.Response +type sudnHandler = func(request *model.Request, cfg *config.SUDN) *model.Response //nolint:gochecknoglobals var ( @@ -89,10 +89,10 @@ var ( type SpecialUseDomainNamesResolver struct { NextResolver typed - configurable[*config.SUDNConfig] + configurable[*config.SUDN] } -func NewSpecialUseDomainNamesResolver(cfg config.SUDNConfig) *SpecialUseDomainNamesResolver { +func NewSpecialUseDomainNamesResolver(cfg config.SUDN) *SpecialUseDomainNamesResolver { return &SpecialUseDomainNamesResolver{ typed: withType("special_use_domains"), configurable: withConfig(&cfg), @@ -134,11 +134,11 @@ func newSUDNResponse(response *model.Request, rcode int) *model.Response { return newResponse(response, rcode, model.ResponseTypeSPECIAL, "Special-Use Domain Name") } -func sudnNXDomain(request *model.Request, _ *config.SUDNConfig) *model.Response { +func sudnNXDomain(request *model.Request, _ *config.SUDN) *model.Response { return newSUDNResponse(request, dns.RcodeNameError) } -func sudnLocalhost(request *model.Request, cfg *config.SUDNConfig) *model.Response { +func sudnLocalhost(request *model.Request, cfg *config.SUDN) *model.Response { q := request.Req.Question[0] var rr dns.RR @@ -165,7 +165,7 @@ func sudnLocalhost(request *model.Request, cfg *config.SUDNConfig) *model.Respon return response } -func sudnRFC6762AppendixG(request *model.Request, cfg *config.SUDNConfig) *model.Response { +func sudnRFC6762AppendixG(request *model.Request, cfg *config.SUDN) *model.Response { if !cfg.RFC6762AppendixG { return nil } @@ -173,7 +173,7 @@ func sudnRFC6762AppendixG(request *model.Request, cfg *config.SUDNConfig) *model return sudnNXDomain(request, cfg) } -func sudnHomeArpa(request *model.Request, cfg *config.SUDNConfig) *model.Response { +func sudnHomeArpa(request *model.Request, cfg *config.SUDN) *model.Response { if request.Req.Question[0].Qtype == dns.TypeDS { // DS queries must be forwarded return nil diff --git a/resolver/sudn_resolver_test.go b/resolver/sudn_resolver_test.go index 1c004b20..d4a747be 100644 --- a/resolver/sudn_resolver_test.go +++ b/resolver/sudn_resolver_test.go @@ -17,7 +17,7 @@ import ( var _ = Describe("SudnResolver", Label("sudnResolver"), func() { var ( sut *SpecialUseDomainNamesResolver - sutConfig config.SUDNConfig + sutConfig config.SUDN m *mockResolver ) @@ -30,7 +30,7 @@ var _ = Describe("SudnResolver", Label("sudnResolver"), func() { BeforeEach(func() { var err error - sutConfig, err = config.WithDefaults[config.SUDNConfig]() + sutConfig, err = config.WithDefaults[config.SUDN]() Expect(err).Should(Succeed()) }) diff --git a/server/server.go b/server/server.go index a091b6f3..5cfb3f2f 100644 --- a/server/server.go +++ b/server/server.go @@ -414,10 +414,10 @@ func createQueryResolver( r = resolver.Chain( resolver.NewFilteringResolver(cfg.Filtering), - resolver.NewFqdnOnlyResolver(cfg.FqdnOnly), + resolver.NewFQDNOnlyResolver(cfg.FQDNOnly), resolver.NewECSResolver(cfg.ECS), clientNames, - resolver.NewEdeResolver(cfg.Ede), + resolver.NewEDEResolver(cfg.EDE), resolver.NewQueryLoggingResolver(ctx, cfg.QueryLog), resolver.NewMetricsResolver(cfg.Prometheus), resolver.NewRewriterResolver(cfg.CustomDNS.RewriterConfig, resolver.NewCustomDNSResolver(cfg.CustomDNS)),