Revert "added GetInitErrors to blocking_resolver"

This reverts commit 940bf9b.
0xERR0R · 0xERR0R · Oct 13, 2021 · Oct 10, 2021 · Oct 10, 2021 · Oct 10, 2021
commit 5c9581dca8b6acb2663e2e0314e0b4e8e04f5e0a
diff --git a/resolver/blocking_resolver.go b/resolver/blocking_resolver.go
@@ -66,7  66,6 @@ type status struct {
 	disabledGroups []string
 	enableTimer    *time.Timer
 	disableEnd     time.Time
-	initErrors     []error
 }
 
 // BlockingResolver checks request's question (domain name) against black and white lists
@@ -85,17  84,10 @@ func NewBlockingResolver(cfg config.BlockingConfig) ChainedResolver {
 	blockHandler := createBlockHandler(cfg)
 	refreshPeriod := time.Duration(cfg.RefreshPeriod)
 	timeout := time.Duration(cfg.DownloadTimeout)
-	blacklistMatcher, blErr := lists.NewListCache(lists.ListCacheTypeBlacklist, cfg.BlackLists, refreshPeriod, timeout)
-	whitelistMatcher, wlErr := lists.NewListCache(lists.ListCacheTypeWhitelist, cfg.WhiteLists, refreshPeriod, timeout)
 	blacklistMatcher := lists.NewListCache(lists.ListCacheTypeBlacklist, cfg.BlackLists, refreshPeriod, timeout)
 	whitelistMatcher := lists.NewListCache(lists.ListCacheTypeWhitelist, cfg.WhiteLists, refreshPeriod, timeout)
 	whitelistOnlyGroups := determineWhitelistOnlyGroups(&cfg)
 
-	var initErrors []error
-	if len(blErr) > 0 {
-		initErrors = append(initErrors, blErr...)
-	}
-	if len(wlErr) > 0 {
-		initErrors = append(initErrors, wlErr...)
-	}
 	res := &BlockingResolver{
 		blockHandler:        blockHandler,
 		cfg:                 cfg,
@@ -105,18  97,12 @@ func NewBlockingResolver(cfg config.BlockingConfig) ChainedResolver {
 		status: &status{
 			enabled:     true,
 			enableTimer: time.NewTimer(0),
-			initErrors:  initErrors,
 		},
 	}
 
 	return res
 }
 
-//returns a list of errors which occurred during the initialisation
-func (c *BlockingResolver) GetInitErrors() []error {
-	return c.status.initErrors
-}
-
 // RefreshLists triggers the refresh of all black and white lists in the cache
 func (r *BlockingResolver) RefreshLists() {
 	r.blacklistMatcher.Refresh()

diff --git a/resolver/caching_resolver.go b/resolver/caching_resolver.go
@@ -52,10  52,6 @@ func NewCachingResolver(cfg config.CachingConfig) ChainedResolver {
 	return c
 }
 
-func (c *CachingResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 func createQueryResultCache(cfg *config.CachingConfig) *cache.Cache {
 	return cache.NewWithLRU(15*time.Minute, 15*time.Second, cfg.MaxItemsCount)
 }

diff --git a/resolver/client_names_resolver.go b/resolver/client_names_resolver.go
@@ -39,10  39,6 @@ func NewClientNamesResolver(cfg config.ClientLookupConfig) ChainedResolver {
 	}
 }
 
-func (c *ClientNamesResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 // Configuration returns current resolver configuration
 func (r *ClientNamesResolver) Configuration() (result []string) {
 	if r.externalResolver != nil || len(r.clientIPMapping) > 0 {

diff --git a/resolver/conditionall_upstream_resolver.go b/resolver/conditionall_upstream_resolver.go
@@ -37,10  37,6 @@ func NewConditionalUpstreamResolver(cfg config.ConditionalUpstreamConfig) Chaine
 	return &ConditionalUpstreamResolver{mapping: m, rewrite: rewrite}
 }
 
-func (c *ConditionalUpstreamResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 // Configuration returns current configuration
 func (r *ConditionalUpstreamResolver) Configuration() (result []string) {
 	if len(r.mapping) > 0 {

diff --git a/resolver/custom_dns_resolver.go b/resolver/custom_dns_resolver.go
@@ -39,10  39,6 @@ func NewCustomDNSResolver(cfg config.CustomDNSConfig) ChainedResolver {
 	return &CustomDNSResolver{mapping: m, reverseAddresses: reverse}
 }
 
-func (c *CustomDNSResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 // Configuration returns current resolver configuration
 func (r *CustomDNSResolver) Configuration() (result []string) {
 	if len(r.mapping) > 0 {

diff --git a/resolver/ipv6_disabling_resolver.go b/resolver/ipv6_disabling_resolver.go
@@ -35,7  35,3 @@ func (r *IPv6DisablingResolver) Configuration() (result []string) {
 func NewIPv6Checker(disable bool) ChainedResolver {
 	return &IPv6DisablingResolver{disableAAAA: disable}
 }
-
-func (c *IPv6DisablingResolver) GetInitErrors() []error {
-	return []error{}
-}
diff --git a/resolver/metrics_resolver.go b/resolver/metrics_resolver.go
@@ -84,10  84,6 @@ func NewMetricsResolver(cfg config.PrometheusConfig) ChainedResolver {
 	}
 }
 
-func (c *MetricsResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 func totalQueriesMetric() *prometheus.CounterVec {
 	return prometheus.NewCounterVec(
 		prometheus.CounterOpts{

diff --git a/resolver/mocks.go b/resolver/mocks.go
@@ -37,10  37,6 @@ func (r *resolverMock) Resolve(req *model.Request) (*model.Response, error) {
 	return nil, args.Error(1)
 }
 
-func (c *resolverMock) GetInitErrors() []error {
-	return []error{}
-}
-
 // TestDOHUpstream creates a mock DoH Upstream
 func TestDOHUpstream(fn func(request *dns.Msg) (response *dns.Msg),
 	reqFn ...func(w http.ResponseWriter)) config.Upstream {

diff --git a/resolver/parallel_best_resolver.go b/resolver/parallel_best_resolver.go
@@ -175,10  175,6 @@ func (r *ParallelBestResolver) Resolve(request *model.Request) (*model.Response,
 		r1.resolver, r2.resolver, collectedErrors)
 }
 
-func (c *ParallelBestResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 // pick 2 different random resolvers from the resolver pool
 func pickRandom(resolvers []*upstreamResolverStatus) (resolver1, resolver2 *upstreamResolverStatus) {
 	resolver1 = weightedRandom(resolvers, nil)

diff --git a/resolver/query_logging_resolver.go b/resolver/query_logging_resolver.go
@@ -57,10  57,6 @@ func NewQueryLoggingResolver(cfg config.QueryLogConfig) ChainedResolver {
 	return &resolver
 }
 
-func (c *QueryLoggingResolver) GetInitErrors() []error {
-	return []error{}
-}
-
 // triggers periodically cleanup of old log files
 func (r *QueryLoggingResolver) periodicCleanUp() {
 	ticker := time.NewTicker(cleanUpRunPeriod)

diff --git a/resolver/resolver.go b/resolver/resolver.go
@@ -47,9  47,6 @@ type Resolver interface {
 
 	// Configuration prints current resolver configuration
 	Configuration() []string
-
-	//returns a list of errors which occurred during the initialisation
-	GetInitErrors() []error
 }
 
 // ChainedResolver represents a resolver, which can delegate result to the next one

diff --git a/resolver/upstream_resolver.go b/resolver/upstream_resolver.go
@@ -204,7  204,3 @@ func (r *UpstreamResolver) Resolve(request *model.Request) (response *model.Resp
 
 	return response, err
 }
-
-func (c *UpstreamResolver) GetInitErrors() []error {
-	return []error{}
-}