Simplify

Author: imogenkraak

gateway/middleware.go

@@ -39,24 +39,14 @@ import (
 
 const (
 	DEFAULT_ORG_SESSION_EXPIRATION = int64(604800)
-	orgSessionSoftExpiry           = 10 * time.Minute
-	orgSessionHardExpiry           = 1 * time.Hour
-	orgSessionMaxStale             = 24 * time.Hour
 	orgSessionFetchTimeout         = 2 * time.Second
 )
 
 var (
 	GlobalRate            = ratecounter.NewRateCounter(1 * time.Second)
 	orgSessionExpiryCache singleflight.Group
-	orgRefreshInProgress  sync.Map
 )
 
-// orgCacheEntry holds org session with timestamp for stale-while-revalidate
-type orgCacheEntry struct {
-	session  user.SessionState
-	cachedAt int64
-}
-
 type TykMiddleware interface {
 	Base() *BaseMiddleware
 	GetSpec() *APISpec
@@ -404,114 +394,31 @@ func (t *BaseMiddleware) fetchOrgSessionWithTimeout(orgID string) (user.SessionS
 	}
 }
 
-// refreshOrgSession refreshes org session in the background
-func (t *BaseMiddleware) refreshOrgSession(orgID string) {
-	defer orgRefreshInProgress.Delete(orgID)
-
-	t.Logger().Debug("Background refresh started for org session")
-
-	session, found := t.fetchOrgSessionWithTimeout(orgID)
-	if !found {
-		t.Logger().Warning("Background refresh timed out after 2s")
-		return
-	}
-
-	t.cacheOrgSession(orgID, session)
-	t.Logger().Debug("Background refresh completed successfully")
-}
-
-// cacheOrgSession stores org session with timestamp for stale-while-revalidate
-func (t *BaseMiddleware) cacheOrgSession(orgID string, session user.SessionState) {
-	entry := orgCacheEntry{
-		session:  session.Clone(),
-		cachedAt: time.Now().UnixNano(),
-	}
-
-	cacheKey := "org:" + orgID
-	t.Gw.SessionCache.Set(cacheKey, entry, int64(orgSessionMaxStale))
-	t.Logger().Debug("Cached org session")
-}
-
-// OrgSession implements stale-while-revalidate pattern for org sessions:
-// - Soft expiry (10 min): Return stale data, trigger background refresh
-// - Hard expiry (1 hour): Try to fetch fresh data, fall back to serving stale data
-// - Max stale (24 hours): Gateway cache TTL prevents indefinite memory growth
 func (t *BaseMiddleware) OrgSession(orgID string) (user.SessionState, bool) {
 	if rpc.IsEmergencyMode() {
 		return user.SessionState{}, false
 	}
 
 	cacheKey := "org:" + orgID
 
-	// Check Gateway cache
-	if cached, found := t.Gw.SessionCache.Get(cacheKey); found {
-		entry, ok := cached.(orgCacheEntry)
-		if !ok {
-			t.Logger().Error("Invalid org cache entry type")
-			t.Gw.SessionCache.Delete(cacheKey)
-			// Fall through to fetch fresh
-		} else {
-			now := time.Now()
-			age := now.Sub(time.Unix(0, entry.cachedAt))
-
-			if age < orgSessionSoftExpiry {
-				// Fresh, return immediately
-				t.Logger().Debug("Using fresh org session from cache")
-				return entry.session.Clone(), true
-			}
-
-			if age < orgSessionHardExpiry {
-				// Stale but within hard expiry, trigger background refresh
-				t.Logger().Debug("Using stale org session, triggering background refresh")
-
-				if _, inProgress := orgRefreshInProgress.LoadOrStore(orgID, true); !inProgress {
-					go func() {
-						defer func() {
-							if r := recover(); r != nil {
-								t.Logger().Errorf("Panic recovered during org session refresh for org %s: %v", orgID, r)
-							}
-						}()
-						t.refreshOrgSession(orgID)
-					}()
-				}
-
-				return entry.session.Clone(), true
-			}
-
-			// Beyond hard expiry, check if refresh is already in progress
-			if _, inProgress := orgRefreshInProgress.Load(orgID); inProgress {
-				// Background refresh already running, serve stale data to avoid duplicate fetch
-				t.Logger().Debug("Background refresh in progress, serving stale data beyond hard expiry")
-				return entry.session.Clone(), true
-			}
-
-			// No refresh in progress, try to fetch fresh
-			t.Logger().Debug("Org session beyond hard expiry, attempting fresh fetch")
-			session, found := t.fetchOrgSessionWithTimeout(orgID)
-
-			if !found {
-				// Fetch failed, serve stale data to maintain org limits
-				t.Logger().Warning("Org session fetch failed, serving stale data beyond hard expiry to maintain limits")
-				return entry.session.Clone(), true
-			}
-
-			// Fresh fetch succeeded, update cache and return
-			t.cacheOrgSession(orgID, session)
-			return session, true
+	// Check Gateway cache first
+	if !t.Spec.GlobalConfig.LocalSessionCache.DisableCacheSessionState {
+		if cached, found := t.Gw.SessionCache.Get(cacheKey); found {
+			t.Logger().Debug("Using cached org session")
+			return cached.(user.SessionState).Clone(), true
 		}
 	}
 
-	// No cache, fetch fresh with timeout
-	t.Logger().Debug("No cached org session, attempting fresh fetch with timeout")
+	// Not in cache, fetch with timeout to prevent blocking
+	t.Logger().Debug("Fetching org session with timeout")
 	session, found := t.fetchOrgSessionWithTimeout(orgID)
 
-	if !found {
-		t.Logger().Warning("Org session fetch timed out after 2s")
-		return user.SessionState{}, false
+	// Cache the result if found
+	if found && !t.Spec.GlobalConfig.LocalSessionCache.DisableCacheSessionState {
+		t.Gw.SessionCache.Set(cacheKey, session.Clone(), cache.DefaultExpiration)
 	}
 
-	t.cacheOrgSession(orgID, session)
-	return session, true
+	return session, found
 }
 
 func (t *BaseMiddleware) SetOrgExpiry(orgid string, expiry int64) {
@@ -521,27 +428,40 @@ func (t *BaseMiddleware) SetOrgExpiry(orgid string, expiry int64) {
 func (t *BaseMiddleware) OrgSessionExpiry(orgid string) int64 {
 	t.Logger().Debug("Checking: ", orgid)
 
-	// Cache failed attempt
-	id, err, _ := orgSessionExpiryCache.Do(orgid, func() (interface{}, error) {
-		cachedVal, found := t.Gw.ExpiryCache.Get(orgid)
-		if found {
-			return cachedVal, nil
+	// Check cache first
+	cachedVal, found := t.Gw.ExpiryCache.Get(orgid)
+	if found {
+		val, ok := cachedVal.(int64)
+		if !ok {
+			t.Logger().Error("Type assertion failed")
+			return DEFAULT_ORG_SESSION_EXPIRATION
 		}
+		return val
+	}
 
-		s, found := t.OrgSession(orgid)
-		if found && t.Spec.GlobalConfig.EnforceOrgDataAge {
-			return s.DataExpires, nil
+	// Cache miss, start async refresh in background, return default immediately
+	go t.refreshOrgSessionExpiry(orgid)
+
+	t.Logger().Debug("no cached entry found, returning 7 days (async refresh started)")
+	return DEFAULT_ORG_SESSION_EXPIRATION
+}
+
+// refreshOrgSessionExpiry fetches org session expiry in the background
+func (t *BaseMiddleware) refreshOrgSessionExpiry(orgid string) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Logger().Errorf("Panic recovered during org session expiry refresh for org %s: %v", orgid, r)
 		}
-		return 0, errors.New("missing session")
-	})
+	}()
 
-	if err != nil {
-		t.Logger().Debug("no cached entry found, returning 7 days")
+	s, found := t.OrgSession(orgid) // RPC call happens in background
+	if found && t.Spec.GlobalConfig.EnforceOrgDataAge {
+		t.Logger().Debug("Background refresh: setting data expiry for org: ", orgid)
+		t.SetOrgExpiry(orgid, s.DataExpires)
+	} else {
+		t.Logger().Debug("Background refresh: org session not found, setting default expiry")
 		t.SetOrgExpiry(orgid, DEFAULT_ORG_SESSION_EXPIRATION)
-		return DEFAULT_ORG_SESSION_EXPIRATION
 	}
-
-	return id.(int64)
 }
 
 func (t *BaseMiddleware) UpdateRequestSession(r *http.Request) bool {