From a6654dcd5770a32d933fa6d419fea13aea90ebac Mon Sep 17 00:00:00 2001 From: ThinkChaos Date: Sun, 3 Dec 2023 17:47:18 -0500 Subject: [PATCH] refactor(config): rename `StartStrategyType` to `InitStrategy` --- config/blocking.go | 18 +- config/config.go | 16 +- config/config_enum.go | 178 +++++++++--------- config/config_test.go | 42 ++--- lists/list_cache_test.go | 6 +- resolver/blocking_resolver_test.go | 6 +- resolver/client_names_resolver_test.go | 2 +- .../conditional_upstream_resolver_test.go | 2 +- resolver/parallel_best_resolver.go | 2 +- resolver/parallel_best_resolver_test.go | 26 +-- resolver/strict_resolver.go | 2 +- resolver/strict_resolver_test.go | 14 +- resolver/upstream_tree_resolver_test.go | 4 +- 13 files changed, 159 insertions(+), 159 deletions(-) diff --git a/config/blocking.go b/config/blocking.go index bd548598..af4d8e35 100644 --- a/config/blocking.go +++ b/config/blocking.go @@ -17,14 +17,14 @@ type Blocking struct { // Deprecated options Deprecated struct { - DownloadTimeout *Duration `yaml:"downloadTimeout"` - DownloadAttempts *uint `yaml:"downloadAttempts"` - DownloadCooldown *Duration `yaml:"downloadCooldown"` - RefreshPeriod *Duration `yaml:"refreshPeriod"` - FailStartOnListError *bool `yaml:"failStartOnListError"` - ProcessingConcurrency *uint `yaml:"processingConcurrency"` - StartStrategy *StartStrategyType `yaml:"startStrategy"` - MaxErrorsPerFile *int `yaml:"maxErrorsPerFile"` + DownloadTimeout *Duration `yaml:"downloadTimeout"` + DownloadAttempts *uint `yaml:"downloadAttempts"` + DownloadCooldown *Duration `yaml:"downloadCooldown"` + RefreshPeriod *Duration `yaml:"refreshPeriod"` + FailStartOnListError *bool `yaml:"failStartOnListError"` + ProcessingConcurrency *uint `yaml:"processingConcurrency"` + StartStrategy *InitStrategy `yaml:"startStrategy"` + MaxErrorsPerFile *int `yaml:"maxErrorsPerFile"` } `yaml:",inline"` } @@ -36,7 +36,7 @@ func (c *Blocking) migrate(logger *logrus.Entry) bool { "refreshPeriod": Move(To("loading.refreshPeriod", &c.Loading)), "failStartOnListError": Apply(To("loading.strategy", &c.Loading.Init), func(oldValue bool) { if oldValue { - c.Loading.Strategy = StartStrategyTypeFailOnError + c.Loading.Strategy = InitStrategyFailOnError } }), "processingConcurrency": Move(To("loading.concurrency", &c.Loading)), diff --git a/config/config.go b/config/config.go index 33ca165f..9f41e59e 100644 --- a/config/config.go +++ b/config/config.go @@ -109,19 +109,19 @@ func (v *TLSVersion) validate(logger *logrus.Entry) { // ) type QueryLogType int16 -// StartStrategyType upstart strategy ENUM( +// InitStrategy startup strategy ENUM( // blocking // synchronously download blocking lists on startup // failOnError // synchronously download blocking lists on startup and shutdown on error // fast // asyncronously download blocking lists on startup // ) -type StartStrategyType uint16 +type InitStrategy uint16 -func (s StartStrategyType) Do(ctx context.Context, init func(context.Context) error, logErr func(error)) error { +func (s InitStrategy) Do(ctx context.Context, init func(context.Context) error, logErr func(error)) error { init = recoverToError(init, func(panicVal any) error { return fmt.Errorf("panic during initialization: %v", panicVal) }) - if s == StartStrategyTypeFast { + if s == InitStrategyFast { go func() { err := init(ctx) if err != nil { @@ -136,7 +136,7 @@ func (s StartStrategyType) Do(ctx context.Context, init func(context.Context) er if err != nil { logErr(err) - if s == StartStrategyTypeFailOnError { + if s == InitStrategyFailOnError { return err } } @@ -314,7 +314,7 @@ func (c *toEnable) LogConfig(logger *logrus.Entry) { } type Init struct { - Strategy StartStrategyType `yaml:"strategy" default:"blocking"` + Strategy InitStrategy `yaml:"strategy" default:"blocking"` } func (c *Init) LogConfig(logger *logrus.Entry) { @@ -563,9 +563,9 @@ func (cfg *Config) migrate(logger *logrus.Entry) bool { "dohUserAgent": Move(To("upstreams.userAgent", &cfg.Upstreams)), "startVerifyUpstream": Apply(To("upstreams.init.strategy", &cfg.Upstreams.Init), func(value bool) { if value { - cfg.Upstreams.Init.Strategy = StartStrategyTypeFailOnError + cfg.Upstreams.Init.Strategy = InitStrategyFailOnError } else { - cfg.Upstreams.Init.Strategy = StartStrategyTypeFast + cfg.Upstreams.Init.Strategy = InitStrategyFast } }), }) diff --git a/config/config_enum.go b/config/config_enum.go index 8d895e6f..e7b808e0 100644 --- a/config/config_enum.go +++ b/config/config_enum.go @@ -100,6 +100,95 @@ func (x *IPVersion) UnmarshalText(text []byte) error { return nil } +const ( + // InitStrategyBlocking is a InitStrategy of type Blocking. + // synchronously download blocking lists on startup + InitStrategyBlocking InitStrategy = iota + // InitStrategyFailOnError is a InitStrategy of type FailOnError. + // synchronously download blocking lists on startup and shutdown on error + InitStrategyFailOnError + // InitStrategyFast is a InitStrategy of type Fast. + // asyncronously download blocking lists on startup + InitStrategyFast +) + +var ErrInvalidInitStrategy = fmt.Errorf("not a valid InitStrategy, try [%s]", strings.Join(_InitStrategyNames, ", ")) + +const _InitStrategyName = "blockingfailOnErrorfast" + +var _InitStrategyNames = []string{ + _InitStrategyName[0:8], + _InitStrategyName[8:19], + _InitStrategyName[19:23], +} + +// InitStrategyNames returns a list of possible string values of InitStrategy. +func InitStrategyNames() []string { + tmp := make([]string, len(_InitStrategyNames)) + copy(tmp, _InitStrategyNames) + return tmp +} + +// InitStrategyValues returns a list of the values for InitStrategy +func InitStrategyValues() []InitStrategy { + return []InitStrategy{ + InitStrategyBlocking, + InitStrategyFailOnError, + InitStrategyFast, + } +} + +var _InitStrategyMap = map[InitStrategy]string{ + InitStrategyBlocking: _InitStrategyName[0:8], + InitStrategyFailOnError: _InitStrategyName[8:19], + InitStrategyFast: _InitStrategyName[19:23], +} + +// String implements the Stringer interface. +func (x InitStrategy) String() string { + if str, ok := _InitStrategyMap[x]; ok { + return str + } + return fmt.Sprintf("InitStrategy(%d)", x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x InitStrategy) IsValid() bool { + _, ok := _InitStrategyMap[x] + return ok +} + +var _InitStrategyValue = map[string]InitStrategy{ + _InitStrategyName[0:8]: InitStrategyBlocking, + _InitStrategyName[8:19]: InitStrategyFailOnError, + _InitStrategyName[19:23]: InitStrategyFast, +} + +// ParseInitStrategy attempts to convert a string to a InitStrategy. +func ParseInitStrategy(name string) (InitStrategy, error) { + if x, ok := _InitStrategyValue[name]; ok { + return x, nil + } + return InitStrategy(0), fmt.Errorf("%s is %w", name, ErrInvalidInitStrategy) +} + +// MarshalText implements the text marshaller method. +func (x InitStrategy) MarshalText() ([]byte, error) { + return []byte(x.String()), nil +} + +// UnmarshalText implements the text unmarshaller method. +func (x *InitStrategy) UnmarshalText(text []byte) error { + name := string(text) + tmp, err := ParseInitStrategy(name) + if err != nil { + return err + } + *x = tmp + return nil +} + const ( // NetProtocolTcpUdp is a NetProtocol of type Tcp+Udp. // TCP and UDP protocols @@ -388,95 +477,6 @@ func (x *QueryLogType) UnmarshalText(text []byte) error { return nil } -const ( - // StartStrategyTypeBlocking is a StartStrategyType of type Blocking. - // synchronously download blocking lists on startup - StartStrategyTypeBlocking StartStrategyType = iota - // StartStrategyTypeFailOnError is a StartStrategyType of type FailOnError. - // synchronously download blocking lists on startup and shutdown on error - StartStrategyTypeFailOnError - // StartStrategyTypeFast is a StartStrategyType of type Fast. - // asyncronously download blocking lists on startup - StartStrategyTypeFast -) - -var ErrInvalidStartStrategyType = fmt.Errorf("not a valid StartStrategyType, try [%s]", strings.Join(_StartStrategyTypeNames, ", ")) - -const _StartStrategyTypeName = "blockingfailOnErrorfast" - -var _StartStrategyTypeNames = []string{ - _StartStrategyTypeName[0:8], - _StartStrategyTypeName[8:19], - _StartStrategyTypeName[19:23], -} - -// StartStrategyTypeNames returns a list of possible string values of StartStrategyType. -func StartStrategyTypeNames() []string { - tmp := make([]string, len(_StartStrategyTypeNames)) - copy(tmp, _StartStrategyTypeNames) - return tmp -} - -// StartStrategyTypeValues returns a list of the values for StartStrategyType -func StartStrategyTypeValues() []StartStrategyType { - return []StartStrategyType{ - StartStrategyTypeBlocking, - StartStrategyTypeFailOnError, - StartStrategyTypeFast, - } -} - -var _StartStrategyTypeMap = map[StartStrategyType]string{ - StartStrategyTypeBlocking: _StartStrategyTypeName[0:8], - StartStrategyTypeFailOnError: _StartStrategyTypeName[8:19], - StartStrategyTypeFast: _StartStrategyTypeName[19:23], -} - -// String implements the Stringer interface. -func (x StartStrategyType) String() string { - if str, ok := _StartStrategyTypeMap[x]; ok { - return str - } - return fmt.Sprintf("StartStrategyType(%d)", x) -} - -// IsValid provides a quick way to determine if the typed value is -// part of the allowed enumerated values -func (x StartStrategyType) IsValid() bool { - _, ok := _StartStrategyTypeMap[x] - return ok -} - -var _StartStrategyTypeValue = map[string]StartStrategyType{ - _StartStrategyTypeName[0:8]: StartStrategyTypeBlocking, - _StartStrategyTypeName[8:19]: StartStrategyTypeFailOnError, - _StartStrategyTypeName[19:23]: StartStrategyTypeFast, -} - -// ParseStartStrategyType attempts to convert a string to a StartStrategyType. -func ParseStartStrategyType(name string) (StartStrategyType, error) { - if x, ok := _StartStrategyTypeValue[name]; ok { - return x, nil - } - return StartStrategyType(0), fmt.Errorf("%s is %w", name, ErrInvalidStartStrategyType) -} - -// MarshalText implements the text marshaller method. -func (x StartStrategyType) MarshalText() ([]byte, error) { - return []byte(x.String()), nil -} - -// UnmarshalText implements the text unmarshaller method. -func (x *StartStrategyType) UnmarshalText(text []byte) error { - name := string(text) - tmp, err := ParseStartStrategyType(name) - if err != nil { - return err - } - *x = tmp - return nil -} - const ( // TLSVersion10 is a TLSVersion of type 1.0. TLSVersion10 TLSVersion = iota + 769 diff --git a/config/config_test.go b/config/config_test.go index 4bf74de5..0bc52140 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -54,16 +54,16 @@ var _ = Describe("Config", func() { c.Blocking.Deprecated.FailStartOnListError = ptrOf(true) }) It("should change loading.strategy blocking to failOnError", func() { - c.Blocking.Loading.Strategy = StartStrategyTypeBlocking + c.Blocking.Loading.Strategy = InitStrategyBlocking c.migrate(logger) Expect(hook.Messages).Should(ContainElement(ContainSubstring("blocking.loading.strategy"))) - Expect(c.Blocking.Loading.Strategy).Should(Equal(StartStrategyTypeFailOnError)) + Expect(c.Blocking.Loading.Strategy).Should(Equal(InitStrategyFailOnError)) }) It("shouldn't change loading.strategy if set to fast", func() { - c.Blocking.Loading.Strategy = StartStrategyTypeFast + c.Blocking.Loading.Strategy = InitStrategyFast c.migrate(logger) Expect(hook.Messages).Should(ContainElement(ContainSubstring("blocking.loading.strategy"))) - Expect(c.Blocking.Loading.Strategy).Should(Equal(StartStrategyTypeFast)) + Expect(c.Blocking.Loading.Strategy).Should(Equal(InitStrategyFast)) }) }) @@ -148,7 +148,7 @@ var _ = Describe("Config", func() { c.Deprecated.StartVerifyUpstream = ptrOf(true) c.migrate(logger) Expect(hook.Messages).Should(ContainElement(ContainSubstring("startVerifyUpstream"))) - Expect(c.Upstreams.Init.Strategy).Should(Equal(StartStrategyTypeFailOnError)) + Expect(c.Upstreams.Init.Strategy).Should(Equal(InitStrategyFailOnError)) }) }) }) @@ -590,10 +590,10 @@ bootstrapDns: }) }) - Describe("StartStrategyType", func() { - Describe("StartStrategyTypeBlocking", func() { + Describe("InitStrategy", func() { + Describe("InitStrategyBlocking", func() { It("runs in the current goroutine", func() { - sut := StartStrategyTypeBlocking + sut := InitStrategyBlocking panicVal := new(int) defer func() { @@ -611,7 +611,7 @@ bootstrapDns: }) It("logs errors and doesn't return them", func() { - sut := StartStrategyTypeBlocking + sut := InitStrategyBlocking expectedErr := errors.New("test") err := sut.Do(context.Background(), func(context.Context) error { @@ -624,7 +624,7 @@ bootstrapDns: }) It("logs panics and doesn't convert them to errors", func() { - sut := StartStrategyTypeBlocking + sut := InitStrategyBlocking logged := false err := sut.Do(context.Background(), func(context.Context) error { @@ -639,9 +639,9 @@ bootstrapDns: }) }) - Describe("StartStrategyTypeFailOnError", func() { + Describe("InitStrategyFailOnError", func() { It("runs in the current goroutine", func() { - sut := StartStrategyTypeFailOnError + sut := InitStrategyFailOnError panicVal := new(int) defer func() { @@ -659,7 +659,7 @@ bootstrapDns: }) It("logs errors and returns them", func() { - sut := StartStrategyTypeFailOnError + sut := InitStrategyFailOnError expectedErr := errors.New("test") err := sut.Do(context.Background(), func(context.Context) error { @@ -672,7 +672,7 @@ bootstrapDns: }) It("returns logs panics and converts them to errors", func() { - sut := StartStrategyTypeFailOnError + sut := InitStrategyFailOnError logged := false err := sut.Do(context.Background(), func(context.Context) error { @@ -687,9 +687,9 @@ bootstrapDns: }) }) - Describe("StartStrategyTypeFast", func() { + Describe("InitStrategyFast", func() { It("runs in a new goroutine", func() { - sut := StartStrategyTypeFast + sut := InitStrategyFast events := make(chan string) wait := make(chan struct{}) @@ -709,7 +709,7 @@ bootstrapDns: }) It("logs errors", func() { - sut := StartStrategyTypeFast + sut := InitStrategyFast expectedErr := errors.New("test") wait := make(chan struct{}) @@ -725,7 +725,7 @@ bootstrapDns: }) It("logs panics", func() { - sut := StartStrategyTypeFast + sut := InitStrategyFast expectedErr := errors.New("test") wait := make(chan struct{}) @@ -778,7 +778,7 @@ bootstrapDns: }) It("handles panics", func() { sut := SourceLoadingConfig{ - Init: Init{Strategy: StartStrategyTypeFailOnError}, + Init: Init{Strategy: InitStrategyFailOnError}, } panicMsg := "panic value" @@ -794,7 +794,7 @@ bootstrapDns: It("periodically calls refresh", func() { sut := SourceLoadingConfig{ - Init: Init{Strategy: StartStrategyTypeFast}, + Init: Init{Strategy: InitStrategyFast}, RefreshPeriod: Duration(5 * time.Millisecond), } @@ -850,7 +850,7 @@ bootstrapDns: func defaultTestFileConfig(config *Config) { Expect(config.Ports.DNS).Should(Equal(ListenConfig{"55553", ":55554", "[::1]:55555"})) - Expect(config.Upstreams.Init.Strategy).Should(Equal(StartStrategyTypeFailOnError)) + Expect(config.Upstreams.Init.Strategy).Should(Equal(InitStrategyFailOnError)) Expect(config.Upstreams.UserAgent).Should(Equal("testBlocky")) Expect(config.Upstreams.Groups["default"]).Should(HaveLen(3)) Expect(config.Upstreams.Groups["default"][0].Host).Should(Equal("8.8.8.8")) diff --git a/lists/list_cache_test.go b/lists/list_cache_test.go index 81ae8c3e..8b68525b 100644 --- a/lists/list_cache_test.go +++ b/lists/list_cache_test.go @@ -352,7 +352,7 @@ var _ = Describe("ListCache", func() { When("Text file has too many errors", func() { BeforeEach(func() { sutConfig.MaxErrorsPerSource = 0 - sutConfig.Strategy = config.StartStrategyTypeFailOnError + sutConfig.Strategy = config.InitStrategyFailOnError lists = map[string][]config.BytesSource{ "gr1": { config.TextBytesSource("invaliddomain!"), // too many errors since `maxErrorsPerSource` is 0 @@ -421,10 +421,10 @@ var _ = Describe("ListCache", func() { }) }) - Describe("StartStrategy", func() { + Describe("loading strategy", func() { When("async load is enabled", func() { BeforeEach(func() { - sutConfig.Strategy = config.StartStrategyTypeFast + sutConfig.Strategy = config.InitStrategyFast lists = map[string][]config.BytesSource{ "gr1": config.NewBytesSources("doesnotexist"), diff --git a/resolver/blocking_resolver_test.go b/resolver/blocking_resolver_test.go index 57d8b379..70db11b3 100644 --- a/resolver/blocking_resolver_test.go +++ b/resolver/blocking_resolver_test.go @@ -159,7 +159,7 @@ var _ = Describe("BlockingResolver", Label("blockingResolver"), func() { }) }) - Describe("Blocking with fast start strategy", func() { + Describe("Blocking with fast init strategy", func() { BeforeEach(func() { sutConfig = config.Blocking{ BlockType: "ZEROIP", @@ -171,7 +171,7 @@ var _ = Describe("BlockingResolver", Label("blockingResolver"), func() { "default": {"gr1"}, }, Loading: config.SourceLoadingConfig{ - Init: config.Init{Strategy: config.StartStrategyTypeFast}, + Init: config.Init{Strategy: config.InitStrategyFast}, }, } }) @@ -1127,7 +1127,7 @@ var _ = Describe("BlockingResolver", Label("blockingResolver"), func() { BlackLists: map[string][]config.BytesSource{"gr1": config.NewBytesSources("wrongPath")}, WhiteLists: map[string][]config.BytesSource{"whitelist": config.NewBytesSources("wrongPath")}, Loading: config.SourceLoadingConfig{ - Init: config.Init{Strategy: config.StartStrategyTypeFailOnError}, + Init: config.Init{Strategy: config.InitStrategyFailOnError}, }, BlockType: "zeroIp", }, nil, systemResolverBootstrap) diff --git a/resolver/client_names_resolver_test.go b/resolver/client_names_resolver_test.go index ee977b62..28a61dbe 100644 --- a/resolver/client_names_resolver_test.go +++ b/resolver/client_names_resolver_test.go @@ -397,7 +397,7 @@ var _ = Describe("ClientResolver", Label("clientNamesResolver"), func() { b := newTestBootstrap(ctx, &dns.Msg{MsgHdr: dns.MsgHdr{Rcode: dns.RcodeServerFailure}}) upstreamsCfg := defaultUpstreamsConfig - upstreamsCfg.Init.Strategy = config.StartStrategyTypeFailOnError + upstreamsCfg.Init.Strategy = config.InitStrategyFailOnError r, err := NewClientNamesResolver(ctx, config.ClientLookup{ Upstream: config.Upstream{Host: "example.com"}, diff --git a/resolver/conditional_upstream_resolver_test.go b/resolver/conditional_upstream_resolver_test.go index d59c94c0..6996c072 100644 --- a/resolver/conditional_upstream_resolver_test.go +++ b/resolver/conditional_upstream_resolver_test.go @@ -197,7 +197,7 @@ var _ = Describe("ConditionalUpstreamResolver", Label("conditionalResolver"), fu b := newTestBootstrap(ctx, &dns.Msg{MsgHdr: dns.MsgHdr{Rcode: dns.RcodeServerFailure}}) upstreamsCfg := defaultUpstreamsConfig - upstreamsCfg.Init.Strategy = config.StartStrategyTypeFailOnError + upstreamsCfg.Init.Strategy = config.InitStrategyFailOnError sutConfig := config.ConditionalUpstream{ Mapping: config.ConditionalUpstreamMapping{ diff --git a/resolver/parallel_best_resolver.go b/resolver/parallel_best_resolver.go index a2f6670a..f467bb24 100644 --- a/resolver/parallel_best_resolver.go +++ b/resolver/parallel_best_resolver.go @@ -97,7 +97,7 @@ func NewParallelBestResolver( ) (*ParallelBestResolver, error) { r := newParallelBestResolver( cfg, - []Resolver{bootstrap}, // if start strategy is fast, use bootstrap until init finishes + []Resolver{bootstrap}, // if init strategy is fast, use bootstrap until init finishes ) return initGroupResolvers(ctx, r, cfg, bootstrap) diff --git a/resolver/parallel_best_resolver_test.go b/resolver/parallel_best_resolver_test.go index 51f2a761..631ec181 100644 --- a/resolver/parallel_best_resolver_test.go +++ b/resolver/parallel_best_resolver_test.go @@ -15,10 +15,10 @@ import ( var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { var ( - sut *ParallelBestResolver - sutStrategy config.UpstreamStrategy - sutStartStrategy config.StartStrategyType - upstreams []config.Upstream + sut *ParallelBestResolver + sutStrategy config.UpstreamStrategy + sutInitStrategy config.InitStrategy + upstreams []config.Upstream ctx context.Context cancelFn context.CancelFunc @@ -40,7 +40,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { upstreams = []config.Upstream{{Host: "wrong"}, {Host: "127.0.0.2"}} - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking sutStrategy = config.UpstreamStrategyParallelBest bootstrap = systemResolverBootstrap @@ -49,7 +49,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { JustBeforeEach(func() { upstreamsCfg := config.Upstreams{ Init: config.Init{ - Strategy: sutStartStrategy, + Strategy: sutInitStrategy, }, Strategy: sutStrategy, Timeout: config.Duration(timeout), @@ -90,7 +90,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyFailOnError", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeFailOnError + sutInitStrategy = config.InitStrategyFailOnError }) It("should fail to start", func() { Expect(err).Should(HaveOccurred()) @@ -99,7 +99,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyBlocking", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking }) It("should start", func() { Expect(err).Should(Succeed()) @@ -125,7 +125,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyFailOnError", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeFailOnError + sutInitStrategy = config.InitStrategyFailOnError }) It("should fail to start", func() { Expect(err).Should(HaveOccurred()) @@ -134,7 +134,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyBlocking", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking }) It("should start", func() { Expect(err).Should(Succeed()) @@ -162,7 +162,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyFailOnError", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeFailOnError + sutInitStrategy = config.InitStrategyFailOnError }) It("should fail to start", func() { Expect(err).Should(HaveOccurred()) @@ -171,7 +171,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { When("using InitStrategyBlocking", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking }) It("should start", func() { Expect(err).Should(Succeed()) @@ -357,7 +357,7 @@ var _ = Describe("ParallelBestResolver", Label("parallelBestResolver"), func() { b := newTestBootstrap(ctx, &dns.Msg{MsgHdr: dns.MsgHdr{Rcode: dns.RcodeServerFailure}}) upstreamsCfg := sut.cfg.Upstreams - upstreamsCfg.Init.Strategy = config.StartStrategyTypeFailOnError + upstreamsCfg.Init.Strategy = config.InitStrategyFailOnError group := config.NewUpstreamGroup("test", upstreamsCfg, []config.Upstream{{Host: "example.com"}}) diff --git a/resolver/strict_resolver.go b/resolver/strict_resolver.go index 11cdc498..3347b12f 100644 --- a/resolver/strict_resolver.go +++ b/resolver/strict_resolver.go @@ -34,7 +34,7 @@ func NewStrictResolver( ) (*StrictResolver, error) { r := newStrictResolver( cfg, - []Resolver{bootstrap}, // if start strategy is fast, use bootstrap until init finishes + []Resolver{bootstrap}, // if init strategy is fast, use bootstrap until init finishes ) return initGroupResolvers(ctx, r, cfg, bootstrap) diff --git a/resolver/strict_resolver_test.go b/resolver/strict_resolver_test.go index 2fb47fe5..8ca9282f 100644 --- a/resolver/strict_resolver_test.go +++ b/resolver/strict_resolver_test.go @@ -16,9 +16,9 @@ import ( var _ = Describe("StrictResolver", Label("strictResolver"), func() { var ( - sut *StrictResolver - sutStartStrategy config.StartStrategyType - upstreams []config.Upstream + sut *StrictResolver + sutInitStrategy config.InitStrategy + upstreams []config.Upstream err error @@ -47,14 +47,14 @@ var _ = Describe("StrictResolver", Label("strictResolver"), func() { {Host: "127.0.0.2"}, } - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking bootstrap = systemResolverBootstrap }) JustBeforeEach(func() { upstreamsCfg := defaultUpstreamsConfig - upstreamsCfg.Init.Strategy = sutStartStrategy + upstreamsCfg.Init.Strategy = sutInitStrategy sutConfig := config.NewUpstreamGroup("test", upstreamsCfg, upstreams) sutConfig.Timeout = config.Duration(timeout) @@ -120,7 +120,7 @@ var _ = Describe("StrictResolver", Label("strictResolver"), func() { When("strict checking is enabled", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeFailOnError + sutInitStrategy = config.InitStrategyFailOnError }) It("should fail to start", func() { Expect(err).Should(HaveOccurred()) @@ -129,7 +129,7 @@ var _ = Describe("StrictResolver", Label("strictResolver"), func() { When("strict checking is disabled", func() { BeforeEach(func() { - sutStartStrategy = config.StartStrategyTypeBlocking + sutInitStrategy = config.InitStrategyBlocking }) It("should start", func() { Expect(err).Should(Succeed()) diff --git a/resolver/upstream_tree_resolver_test.go b/resolver/upstream_tree_resolver_test.go index 5338c870..f2cd07ab 100644 --- a/resolver/upstream_tree_resolver_test.go +++ b/resolver/upstream_tree_resolver_test.go @@ -132,9 +132,9 @@ var _ = Describe("UpstreamTreeResolver", Label("upstreamTreeResolver"), func() { }) }) - When("start strategy is failOnError", func() { + When("init strategy is failOnError", func() { BeforeEach(func() { - sutConfig.Init.Strategy = config.StartStrategyTypeFailOnError + sutConfig.Init.Strategy = config.InitStrategyFailOnError }) It("should fail", func() {