mirrors
/
blocky
mirror of https://github.com/0xERR0R/blocky.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

refactor(config): rename `StartStrategyType` to `InitStrategy`

This commit is contained in:
ThinkChaos 2023-12-03 17:47:18 -05:00
parent 7a3c054b43
commit a6654dcd57
13 changed files with 159 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
config/blocking.go
View File

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

16
config/config.go
View File

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

178
config/config_enum.go
View File

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

42
config/config_test.go
View File

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

6
lists/list_cache_test.go
View File

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

6
resolver/blocking_resolver_test.go
View File

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

2
resolver/client_names_resolver_test.go
View File

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

2
resolver/conditional_upstream_resolver_test.go
View File

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

2
resolver/parallel_best_resolver.go
View File

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

26
resolver/parallel_best_resolver_test.go
View File

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

2
resolver/strict_resolver.go
View File

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

14
resolver/strict_resolver_test.go
View File

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

4
resolver/upstream_tree_resolver_test.go
View File

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