fix(configuration): load mapping_eviction_interval properly

Author: darkweak

pkg/middleware/middleware.go

@@ -95,19 +95,20 @@ func tryAcquireEvictionLock(storer types.Storer) bool {
 func registerMappingKeysEviction(logger core.Logger, storers []types.Storer, interval time.Duration) {
 	for _, storer := range storers {
 		logger.Debugf("registering mapping eviction for storer %s (interval: %s)", storer.Name(), interval)
-		go func(current types.Storer) {
+		go func(current types.Storer, currentInterval time.Duration) {
 			for {
 				if !tryAcquireEvictionLock(current) {
 					logger.Debugf("skipping mapping eviction for storer %s, another instance holds the lock", current.Name())
-					time.Sleep(time.Minute)
+					time.Sleep(currentInterval)
+
 					continue
 				}
 
 				logger.Debugf("run mapping eviction for storer %s", current.Name())
 				api.EvictMapping(current)
-				<-time.After(interval)
+				<-time.After(currentInterval)
 			}
-		}(storer)
+		}(storer, interval)
 	}
 }
 

plugins/caddy/admin.go

@@ -70,6 +70,9 @@ func (a *adminAPI) Provision(ctx caddy.Context) error {
 				TTL: configurationtypes.Duration{
 					Duration: 120 * time.Second,
 				},
+				MappingEvictionInterval: configurationtypes.Duration{
+					Duration: time.Hour,
+				},
 			},
 		}
 		a.InternalEndpointHandlers = api.GenerateHandlerMap(&config, currentApp.Storers, item.SurrogateStorage)

plugins/caddy/configuration.go

@@ -60,6 +60,8 @@ type DefaultCache struct {
 	Stale configurationtypes.Duration `json:"stale"`
 	// Disable the coalescing system.
 	DisableCoalescing bool `json:"disable_coalescing"`
+	// MappingEvictionInterval interval between eviction
+	MappingEvictionInterval configurationtypes.Duration `json:"mapping_eviction_interval"`
 }
 
 // GetAllowedHTTPVerbs returns the allowed verbs to cache
@@ -107,6 +109,11 @@ func (d *DefaultCache) GetEtcd() configurationtypes.CacheProvider {
 	return d.Etcd
 }
 
+// GetMappingEvictionInterval returns the interval between eviction
+func (d *DefaultCache) GetMappingEvictionInterval() time.Duration {
+	return d.MappingEvictionInterval.Duration
+}
+
 // GetMode returns mdoe configuration
 func (d *DefaultCache) GetMode() string {
 	return d.Mode
@@ -763,6 +770,12 @@ func parseConfiguration(cfg *Configuration, h *caddyfile.Dispenser, isGlobal boo
 				}
 			case "disable_coalescing":
 				cfg.DefaultCache.DisableCoalescing = true
+			case "mapping_eviction_interval":
+				args := h.RemainingArgs()
+				interval, err := time.ParseDuration(args[0])
+				if err == nil {
+					cfg.DefaultCache.MappingEvictionInterval.Duration = interval
+				}
 			case "disable_surrogate_key":
 				cfg.SurrogateKeyDisabled = true
 			default:

plugins/caddy/httpcache.go

@@ -142,6 +142,12 @@ func (s *SouinCaddyMiddleware) FromApp(app *SouinApp) error {
 		}
 	}
 
+	if app.DefaultCache.GetMappingEvictionInterval() == 0 {
+		if s.Configuration.DefaultCache.GetMappingEvictionInterval() == 0 {
+			app.DefaultCache.TTL = configurationtypes.Duration{Duration: time.Hour}
+		}
+	}
+
 	if s.Configuration.GetDefaultCache() == nil {
 		s.Configuration.DefaultCache = DefaultCache{
 			AllowedHTTPVerbs:             app.DefaultCache.AllowedHTTPVerbs,
@@ -151,6 +157,7 @@ func (s *SouinCaddyMiddleware) FromApp(app *SouinApp) error {
 			TTL:                          app.TTL,
 			Stale:                        app.Stale,
 			DefaultCacheControl:          app.DefaultCacheControl,
+			MappingEvictionInterval:      app.MappingEvictionInterval,
 			CacheName:                    app.CacheName,
 			Timeout:                      app.Timeout,
 		}
@@ -189,6 +196,9 @@ func (s *SouinCaddyMiddleware) FromApp(app *SouinApp) error {
 	if dc.TTL.Duration == 0 {
 		s.Configuration.DefaultCache.TTL = appDc.TTL
 	}
+	if dc.MappingEvictionInterval.Duration == 0 {
+		s.Configuration.DefaultCache.MappingEvictionInterval = appDc.MappingEvictionInterval
+	}
 	if dc.Stale.Duration == 0 {
 		s.Configuration.DefaultCache.Stale = appDc.Stale
 	}
@@ -296,8 +306,9 @@ func parseCaddyfileGlobalOption(h *caddyfile.Dispenser, _ interface{}) (interfac
 			TTL: configurationtypes.Duration{
 				Duration: 120 * time.Second,
 			},
-			DefaultCacheControl: "",
-			CacheName:           "",
+			MappingEvictionInterval: configurationtypes.Duration{Duration: time.Hour},
+			DefaultCacheControl:     "",
+			CacheName:               "",
 		},
 		URLs: make(map[string]configurationtypes.URL),
 	}

plugins/souin/agnostic/configuration_parser.go

@@ -104,9 +104,10 @@ func parseDefaultCache(dcConfiguration map[string]interface{}) *configurationtyp
 			Path:          "",
 			Configuration: nil,
 		},
-		Regex:               configurationtypes.Regex{},
-		TTL:                 configurationtypes.Duration{},
-		DefaultCacheControl: "",
+		Regex:                   configurationtypes.Regex{},
+		TTL:                     configurationtypes.Duration{},
+		MappingEvictionInterval: configurationtypes.Duration{Duration: time.Hour},
+		DefaultCacheControl:     "",
 	}
 	for defaultCacheK, defaultCacheV := range dcConfiguration {
 		switch defaultCacheK {
@@ -195,6 +196,11 @@ func parseDefaultCache(dcConfiguration map[string]interface{}) *configurationtyp
 					}
 				}
 			}
+		case "mapping_eviction_interval":
+			eviction, err := time.ParseDuration(defaultCacheV.(string))
+			if err == nil {
+				dc.MappingEvictionInterval = configurationtypes.Duration{Duration: eviction}
+			}
 		case "mode":
 			dc.Mode, _ = defaultCacheV.(string)
 		case "nats":