refactor: move go-chi/cache into Gitea (#39530)

The `gitea.com/go-chi/cache` package only exists for Gitea, so it moves
into `modules/cache`.

- `ITEM_TTL = -1` disables caching as documented
- Sub-second TTLs round up instead of never expiring
- The Redis adapter no longer grows a `MacaronCache` hash
- Use two-queue cache for in-memory cache

Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>

custom/conf/app.example.ini

@@ -1981,7 +1981,7 @@ LEVEL = Info
 ;; Either "memory", "redis", "memcache", or "twoqueue". default is "memory"
 ;ADAPTER = memory
 ;;
-;; For "memory" only, GC interval in seconds, default is 60
+;; For "memory" and "twoqueue", GC interval in seconds, default is 60
 ;INTERVAL = 60
 ;;
 ;; For "redis" and "memcache", connection host address

go.mod

@@ -6,7 +6,6 @@ toolchain go1.27.1
 
 require (
 	connectrpc.com/connect v1.21.0
-	gitea.com/go-chi/cache v0.2.1
 	gitea.com/go-chi/session v0.0.0-20260708011333-ebced8a7a2d6
 	gitea.com/lunny/dingtalk_webhook v0.0.0-20171025031554-e3534c89ef96
 	gitea.com/lunny/levelqueue v0.4.2-0.20230414023320-3c0159fe0fe4
@@ -23,6 +22,7 @@ require (
 	github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb
 	github.com/blevesearch/bleve/v2 v2.6.1
 	github.com/bohde/codel v0.2.0
+	github.com/bradfitz/gomemcache v0.0.0-20260422231931-4d751bb6e37c
 	github.com/buildkite/terminal-to-html/v3 v3.17.1
 	github.com/caddyserver/certmagic v0.25.4
 	github.com/charmbracelet/git-lfs-transfer v0.1.1-0.20260812203852-971c0284dc33
@@ -146,7 +146,6 @@ require (
 	github.com/bodgit/sevenzip v1.6.4 // indirect
 	github.com/bodgit/windows v1.0.1 // indirect
 	github.com/boombuler/barcode v1.1.0 // indirect
-	github.com/bradfitz/gomemcache v0.0.0-20260422231931-4d751bb6e37c // indirect
 	github.com/caddyserver/zerossl v0.1.5 // indirect
 	github.com/cention-sany/utf7 v0.0.0-20170124080048-26cad61bd60a // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -236,7 +235,6 @@ require (
 	github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf // indirect
 	github.com/stangelandcl/ppmd v0.1.1 // indirect
 	github.com/tinylib/msgp v1.6.4 // indirect
-	github.com/unknwon/com v1.0.1 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect

go.sum

@@ -8,8 +8,6 @@ dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
 filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
-gitea.com/go-chi/cache v0.2.1 h1:bfAPkvXlbcZxPCpcmDVCWoHgiBSBmZN/QosnZvEC0+g=
-gitea.com/go-chi/cache v0.2.1/go.mod h1:Qic0HZ8hOHW62ETGbonpwz8WYypj9NieU9659wFUJ8Q=
 gitea.com/go-chi/session v0.0.0-20260708011333-ebced8a7a2d6 h1:YWzVGeC/8SZThrJS48ZmQYLkzssdeABxHPhbdnxPDIU=
 gitea.com/go-chi/session v0.0.0-20260708011333-ebced8a7a2d6/go.mod h1:KDvcfMUoXfATPHs2mbMoXFTXT45/FAFAS39waz9tPk0=
 gitea.com/lunny/dingtalk_webhook v0.0.0-20171025031554-e3534c89ef96 h1:+wWBi6Qfruqu7xJgjOIrKVQGiLUZdpKYCZewJ4clqhw=
@@ -398,7 +396,6 @@ github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7X
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
@@ -576,7 +573,6 @@ github.com/skeema/knownhosts v1.3.2 h1:EDL9mgf4NzwMXCTfaxSD/o/a5fxDw/xL9nkU28Jjd
 github.com/skeema/knownhosts v1.3.2/go.mod h1:bEg3iQAuw+jyiw+484wwFJoKSLwcfd7fqRy+N0QTiow=
 github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304 h1:Jpy1PXuP99tXNrhbq2BaPz9B+jNAvH1JPQQpG/9GCXY=
 github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/sorairolake/lzip-go v0.3.8 h1:j5Q2313INdTA80ureWYRhX+1K78mUXfMoPZCw/ivWik=
@@ -615,8 +611,6 @@ github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77ro
 github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.17 h1:flR0y/x1hgM8EGV1AW3Xll6T413G0glV8UfBwR617V4=
 github.com/ulikunitz/xz v0.5.17/go.mod h1:H9Rt/W6/Qj27PGauhQc6nfCDy7vHpzsOThBSaYDoEhw=
-github.com/unknwon/com v1.0.1 h1:3d1LTxD+Lnf3soQiD4Cp/0BRB+Rsa/+RTvz8GMMzIXs=
-github.com/unknwon/com v1.0.1/go.mod h1:tOOxU81rwgoCLoOVVPHb6T/wt8HZygqH5id+GNnlCXM=
 github.com/urfave/cli-docs/v3 v3.1.0 h1:Sa5xm19IpE5gpm6tZzXdfjdFxn67PnEsE4dpXF7vsKw=
 github.com/urfave/cli-docs/v3 v3.1.0/go.mod h1:59d+5Hz1h6GSGJ10cvcEkbIe3j233t4XDqI72UIx7to=
 github.com/urfave/cli/v3 v3.13.0 h1:Dr6jqMfIyyFsRVn7Nz5mqLsMY+ZMpfh3a0aMs+umPVY=

modules/cache/cache.go

@@ -13,8 +13,6 @@ import (
 
 	"gitea.dev/modules/setting"
 	"gitea.dev/modules/util"
-
-	_ "gitea.com/go-chi/cache/memcache" //nolint:depguard // memcache plugin for cache, it is required for config "ADAPTER=memcache"
 )
 
 var defaultCache StringCache
@@ -83,7 +81,7 @@ func GetCache() StringCache {
 
 // GetString returns the key value from cache with callback when no key exists in cache
 func GetString(key string, getFunc func() (string, error)) (string, error) {
-	if defaultCache == nil || setting.CacheService.TTL == 0 {
+	if defaultCache == nil || setting.CacheService.TTL <= 0 {
 		return getFunc()
 	}
 	cached, exist := defaultCache.Get(key)

modules/cache/cache_memcache.go

@@ -0,0 +1,70 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package cache
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/bradfitz/gomemcache/memcache"
+)
+
+const memcacheMaxRelativeTTL = 30 * 24 * 60 * 60
+
+type memcacheCache struct {
+	client *memcache.Client
+}
+
+func newMemcacheCache(conn string) (backend, error) {
+	if conn == "" {
+		return nil, errors.New("cache adapter memcache requires [cache] HOST, e.g. 127.0.0.1:11211")
+	}
+	servers := &memcache.ServerList{}
+	if err := servers.SetServers(strings.Split(conn, ";")...); err != nil {
+		return nil, fmt.Errorf("invalid memcache HOST %q: %w", conn, err)
+	}
+	return &memcacheCache{client: memcache.NewFromSelector(servers)}, nil
+}
+
+// memcacheExpiration converts a TTL beyond memcached's 30-day relative limit into an absolute unix time
+func memcacheExpiration(ttl int64) int32 {
+	if ttl > memcacheMaxRelativeTTL {
+		ttl += timeNow().Unix()
+	}
+	return int32(min(ttl, math.MaxInt32))
+}
+
+func (c *memcacheCache) Get(key string) (string, bool) {
+	item, err := c.client.Get(key)
+	if err != nil {
+		return "", false
+	}
+	return string(item.Value), true
+}
+
+func (c *memcacheCache) Put(key, value string, ttl int64) error {
+	return c.client.Set(&memcache.Item{Key: key, Value: []byte(value), Expiration: memcacheExpiration(ttl)})
+}
+
+func (c *memcacheCache) Delete(key string) error {
+	if err := c.client.Delete(key); err != nil && !errors.Is(err, memcache.ErrCacheMiss) {
+		return err
+	}
+	return nil
+}
+
+func (c *memcacheCache) IsExist(key string) bool {
+	_, err := c.client.Get(key)
+	return err == nil
+}
+
+func (c *memcacheCache) Ping() error {
+	const key = "__gitea_cache_ping"
+	if err := c.Put(key, "ping", 10); err != nil {
+		return err
+	}
+	return c.Delete(key)
+}

modules/cache/cache_redis.go

@@ -4,159 +4,44 @@
 package cache
 
 import (
-	"fmt"
-	"strconv"
 	"time"
 
 	"gitea.dev/modules/graceful"
 	"gitea.dev/modules/nosql"
 
-	"gitea.com/go-chi/cache" //nolint:depguard // we wrap this package here
 	"github.com/redis/go-redis/v9"
 )
 
-// RedisCacher represents a redis cache adapter implementation.
-type RedisCacher struct {
-	c          redis.UniversalClient
-	prefix     string
-	hsetName   string
-	occupyMode bool
+type redisCache struct {
+	client redis.UniversalClient
+	prefix string
 }
 
-// toStr convert string/int/int64 interface to string. it's only used by the RedisCacher.Put internally
-func toStr(v any) string {
-	if v == nil {
-		return ""
-	}
-	switch v := v.(type) {
-	case string:
-		return v
-	case []byte:
-		return string(v)
-	case int:
-		return strconv.FormatInt(int64(v), 10)
-	case int64:
-		return strconv.FormatInt(v, 10)
-	default:
-		return fmt.Sprint(v) // as what the old com.ToStr does in most cases
+func newRedisCache(conn string) backend {
+	uri := nosql.ToRedisURI(conn)
+	return &redisCache{
+		client: nosql.GetManager().GetRedisClient(uri.String()),
+		prefix: uri.Query().Get("prefix"),
 	}
 }
 
-// Put puts value (string type) into cache with key and expire time.
-// If expired is 0, it lives forever.
-func (c *RedisCacher) Put(key string, val any, expire int64) error {
-	// this function is not well-designed, it only puts string values into cache
-	key = c.prefix + key
-	if expire == 0 {
-		if err := c.c.Set(graceful.GetManager().HammerContext(), key, toStr(val), 0).Err(); err != nil {
-			return err
-		}
-	} else {
-		dur := time.Duration(expire) * time.Second
-		if err := c.c.Set(graceful.GetManager().HammerContext(), key, toStr(val), dur).Err(); err != nil {
-			return err
-		}
-	}
-
-	if c.occupyMode {
-		return nil
-	}
-	return c.c.HSet(graceful.GetManager().HammerContext(), c.hsetName, key, "0").Err()
+func (c *redisCache) Get(key string) (string, bool) {
+	value, err := c.client.Get(graceful.GetManager().HammerContext(), c.prefix+key).Result()
+	return value, err == nil
 }
 
-// Get gets cached value by given key.
-func (c *RedisCacher) Get(key string) any {
-	val, err := c.c.Get(graceful.GetManager().HammerContext(), c.prefix+key).Result()
-	if err != nil {
-		return nil
-	}
-	return val
+func (c *redisCache) Put(key, value string, ttl int64) error {
+	return c.client.Set(graceful.GetManager().HammerContext(), c.prefix+key, value, time.Duration(ttl)*time.Second).Err()
 }
 
-// Delete deletes cached value by given key.
-func (c *RedisCacher) Delete(key string) error {
-	key = c.prefix + key
-	if err := c.c.Del(graceful.GetManager().HammerContext(), key).Err(); err != nil {
-		return err
-	}
-
-	if c.occupyMode {
-		return nil
-	}
-	return c.c.HDel(graceful.GetManager().HammerContext(), c.hsetName, key).Err()
+func (c *redisCache) Delete(key string) error {
+	return c.client.Del(graceful.GetManager().HammerContext(), c.prefix+key).Err()
 }
 
-// Incr increases cached int-type value by given key as a counter.
-func (c *RedisCacher) Incr(key string) error {
-	if !c.IsExist(key) {
-		return fmt.Errorf("key '%s' not exist", key)
-	}
-	return c.c.Incr(graceful.GetManager().HammerContext(), c.prefix+key).Err()
+func (c *redisCache) IsExist(key string) bool {
+	return c.client.Exists(graceful.GetManager().HammerContext(), c.prefix+key).Val() == 1
 }
 
-// Decr decreases cached int-type value by given key as a counter.
-func (c *RedisCacher) Decr(key string) error {
-	if !c.IsExist(key) {
-		return fmt.Errorf("key '%s' not exist", key)
-	}
-	return c.c.Decr(graceful.GetManager().HammerContext(), c.prefix+key).Err()
-}
-
-// IsExist returns true if cached value exists.
-func (c *RedisCacher) IsExist(key string) bool {
-	if c.c.Exists(graceful.GetManager().HammerContext(), c.prefix+key).Val() == 1 {
-		return true
-	}
-
-	if !c.occupyMode {
-		c.c.HDel(graceful.GetManager().HammerContext(), c.hsetName, c.prefix+key)
-	}
-	return false
-}
-
-// Flush deletes all cached data.
-func (c *RedisCacher) Flush() error {
-	if c.occupyMode {
-		return c.c.FlushDB(graceful.GetManager().HammerContext()).Err()
-	}
-
-	keys, err := c.c.HKeys(graceful.GetManager().HammerContext(), c.hsetName).Result()
-	if err != nil {
-		return err
-	}
-	if err = c.c.Del(graceful.GetManager().HammerContext(), keys...).Err(); err != nil {
-		return err
-	}
-	return c.c.Del(graceful.GetManager().HammerContext(), c.hsetName).Err()
-}
-
-// StartAndGC starts GC routine based on config string settings.
-// AdapterConfig: network=tcp,addr=:6379,password=macaron,db=0,pool_size=100,idle_timeout=180,hset_name=MacaronCache,prefix=cache:
-func (c *RedisCacher) StartAndGC(opts cache.Options) error {
-	c.hsetName = "MacaronCache"
-	c.occupyMode = opts.OccupyMode
-
-	uri := nosql.ToRedisURI(opts.AdapterConfig)
-
-	c.c = nosql.GetManager().GetRedisClient(uri.String())
-
-	for k, v := range uri.Query() {
-		switch k {
-		case "hset_name":
-			c.hsetName = v[0]
-		case "prefix":
-			c.prefix = v[0]
-		}
-	}
-
-	return c.c.Ping(graceful.GetManager().HammerContext()).Err()
-}
-
-// Ping tests if the cache is alive.
-func (c *RedisCacher) Ping() error {
-	return c.c.Ping(graceful.GetManager().HammerContext()).Err()
-}
-
-func init() {
-	cache.Register("redis", &RedisCacher{})
+func (c *redisCache) Ping() error {
+	return c.client.Ping(graceful.GetManager().HammerContext()).Err()
 }

modules/cache/cache_test.go

@@ -8,9 +8,12 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dev/modules/nosql"
 	"gitea.dev/modules/setting"
+	"gitea.dev/modules/test"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func createTestCache() {
@@ -32,6 +35,98 @@ func TestNewContext(t *testing.T) {
 	})
 	assert.Error(t, err)
 	assert.Nil(t, con)
+
+	_, err = NewStringCache(setting.Cache{Adapter: "memcache"})
+	assert.ErrorContains(t, err, "requires [cache] HOST")
+}
+
+func TestStringCacheAdapters(t *testing.T) {
+	now := time.Now()
+	defer test.MockVariableValue(&timeNow, func() time.Time { return now })()
+	cases := []struct {
+		adapter string
+		conns   func(t *testing.T) (string, string)
+	}{
+		{adapter: "memory", conns: func(*testing.T) (string, string) { return "", "" }},
+		{adapter: "twoqueue", conns: func(*testing.T) (string, string) { return "100", `{"size":100}` }},
+		{adapter: "redis", conns: func(t *testing.T) (string, string) {
+			conn := test.PrepareTestRedis(t) + "?prefix=gitea-test-cache-"
+			return conn + "first:", conn + "second:"
+		}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.adapter, func(t *testing.T) {
+			firstConn, secondConn := tc.conns(t)
+			first, err := NewStringCache(setting.Cache{Adapter: tc.adapter, Conn: firstConn, Interval: -1})
+			require.NoError(t, err)
+			second, err := NewStringCache(setting.Cache{Adapter: tc.adapter, Conn: secondConn, Interval: -1})
+			require.NoError(t, err)
+			require.NoError(t, first.Ping())
+
+			require.NoError(t, first.Put("key", "value", 0))
+			value, ok := first.Get("key")
+			assert.True(t, ok)
+			assert.Equal(t, "value", value)
+			assert.True(t, first.IsExist("key"))
+			assert.False(t, second.IsExist("key"))
+
+			require.NoError(t, first.Delete("key"))
+			_, ok = first.Get("key")
+			assert.False(t, ok)
+			assert.False(t, first.IsExist("key"))
+			require.NoError(t, first.Delete("key"))
+
+			require.NoError(t, first.Put("expiring", "value", 10))
+			if tc.adapter == "redis" {
+				uri := nosql.ToRedisURI(firstConn)
+				ttl := nosql.GetManager().GetRedisClient(uri.String()).TTL(t.Context(), uri.Query().Get("prefix")+"expiring").Val()
+				assert.Positive(t, ttl)
+				assert.LessOrEqual(t, ttl, 10*time.Second)
+				require.NoError(t, first.Delete("expiring"))
+				return
+			}
+			now = now.Add(9 * time.Second)
+			assert.True(t, first.IsExist("expiring"))
+			now = now.Add(time.Second)
+			assert.False(t, first.IsExist("expiring"))
+			_, ok = first.Get("expiring")
+			assert.False(t, ok)
+			require.NoError(t, first.Put("expiring", "renewed", 0))
+			value, ok = first.Get("expiring")
+			assert.True(t, ok)
+			assert.Equal(t, "renewed", value)
+		})
+	}
+}
+
+func TestNegativeItemTTLDisablesOnlyItemTTLCaching(t *testing.T) {
+	createTestCache()
+	defer test.MockVariableValue(&setting.CacheService.TTL, -1)()
+
+	require.NoError(t, defaultCache.Put("key", "stale", 0))
+	require.NoError(t, defaultCache.Put("key", "value", setting.CacheService.TTLSeconds()))
+	assert.False(t, defaultCache.IsExist("key"))
+
+	calls := 0
+	for range 2 {
+		data, err := GetString("key", func() (string, error) {
+			calls++
+			return "value", nil
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, "value", data)
+	}
+	assert.Equal(t, 2, calls)
+	assert.False(t, defaultCache.IsExist("key"))
+
+	require.NoError(t, defaultCache.Put("captcha", "value", 600))
+	assert.True(t, defaultCache.IsExist("captcha"))
+}
+
+func TestMemcacheExpiration(t *testing.T) {
+	defer test.MockVariableValue(&timeNow, func() time.Time { return time.Unix(1000, 0) })()
+	assert.EqualValues(t, memcacheMaxRelativeTTL, memcacheExpiration(memcacheMaxRelativeTTL))
+	assert.EqualValues(t, 1000+memcacheMaxRelativeTTL+1, memcacheExpiration(memcacheMaxRelativeTTL+1))
 }
 
 func TestTest(t *testing.T) {

modules/cache/cache_twoqueue.go

@@ -4,205 +4,123 @@
 package cache
 
 import (
+	"fmt"
 	"strconv"
-	"sync"
 	"time"
 
 	"gitea.dev/modules/json"
 
-	mc "gitea.com/go-chi/cache" //nolint:depguard // we wrap this package here
 	lru "github.com/hashicorp/golang-lru/v2"
 )
 
-// TwoQueueCache represents a LRU 2Q cache adapter implementation
-type TwoQueueCache struct {
-	lock     sync.Mutex
-	cache    *lru.TwoQueueCache[string, any]
-	interval int
+const twoQueueDefaultSize = 50000
+
+type twoQueueCache struct {
+	cache *lru.TwoQueueCache[string, memoryItem] // wrap the existing thread-safe 2Q (two-queue) cache directly
 }
 
-// TwoQueueCacheConfig describes the configuration for TwoQueueCache
-type TwoQueueCacheConfig struct {
-	Size        int     `ini:"SIZE" json:"size"`
-	RecentRatio float64 `ini:"RECENT_RATIO" json:"recent_ratio"`
-	GhostRatio  float64 `ini:"GHOST_RATIO" json:"ghost_ratio"`
+type twoQueueCacheConfig struct {
+	Size        int     `json:"size"`
+	RecentRatio float64 `json:"recent_ratio"`
+	GhostRatio  float64 `json:"ghost_ratio"`
 }
 
-// MemoryItem represents a memory cache item.
-type MemoryItem struct {
-	Val     any
-	Created int64
-	Timeout int64
-}
-
-func (item *MemoryItem) hasExpired() bool {
-	return item.Timeout > 0 &&
-		(time.Now().Unix()-item.Created) >= item.Timeout
-}
-
-var _ mc.Cache = &TwoQueueCache{}
-
-// Put puts value into cache with key and expire time.
-func (c *TwoQueueCache) Put(key string, val any, timeout int64) error {
-	item := &MemoryItem{
-		Val:     val,
-		Created: time.Now().Unix(),
-		Timeout: timeout,
+func newTwoQueueCache(conn string, gcInterval time.Duration) (backend, error) {
+	lruCache, err := newTwoQueueLRU(conn)
+	if err != nil {
+		return nil, err
 	}
-	c.lock.Lock()
-	defer c.lock.Unlock()
+	cache := &twoQueueCache{cache: lruCache}
+	startGC(gcInterval, cache.deleteExpired)
+	return cache, nil
+}
+
+func newTwoQueueLRU(conn string) (*lru.TwoQueueCache[string, memoryItem], error) {
+	if conn == "" {
+		return lru.New2Q[string, memoryItem](twoQueueDefaultSize)
+	}
+	if size, err := strconv.Atoi(conn); err == nil {
+		return lru.New2Q[string, memoryItem](size)
+	}
+	if !json.Valid([]byte(conn)) {
+		return nil, fmt.Errorf("invalid two-queue cache HOST %q, expected a size or a JSON config", conn)
+	}
+	config := twoQueueCacheConfig{
+		Size:        twoQueueDefaultSize,
+		RecentRatio: lru.Default2QRecentRatio,
+		GhostRatio:  lru.Default2QGhostEntries,
+	}
+	_ = json.Unmarshal([]byte(conn), &config)
+	return lru.New2QParams[string, memoryItem](config.Size, config.RecentRatio, config.GhostRatio)
+}
+
+func (c *twoQueueCache) Get(key string) (string, bool) {
+	item, ok := c.cache.Get(key)
+	if !ok {
+		return "", false
+	}
+	if item.expired(timeNow()) {
+		c.cache.Remove(key)
+		return "", false
+	}
+	return item.value, true
+}
+
+func (c *twoQueueCache) Put(key, value string, ttl int64) error {
+	item := newMemoryItem(value, ttl)
 	c.cache.Add(key, item)
 	return nil
 }
 
-// Get gets cached value by given key.
-func (c *TwoQueueCache) Get(key string) any {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	cached, ok := c.cache.Get(key)
-	if !ok {
-		return nil
-	}
-	item, ok := cached.(*MemoryItem)
-
-	if !ok || item.hasExpired() {
-		c.cache.Remove(key)
-		return nil
-	}
-
-	return item.Val
-}
-
-// Delete deletes cached value by given key.
-func (c *TwoQueueCache) Delete(key string) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
+func (c *twoQueueCache) Delete(key string) error {
 	c.cache.Remove(key)
 	return nil
 }
 
-// Incr increases cached int-type value by given key as a counter.
-func (c *TwoQueueCache) Incr(key string) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	cached, ok := c.cache.Get(key)
-	if !ok {
-		return nil
-	}
-	item, ok := cached.(*MemoryItem)
-
-	if !ok || item.hasExpired() {
-		c.cache.Remove(key)
-		return nil
-	}
-
-	var err error
-	item.Val, err = mc.Incr(item.Val)
-	return err
+func (c *twoQueueCache) IsExist(key string) bool {
+	item, ok := c.cache.Peek(key)
+	return ok && !item.expired(timeNow())
 }
 
-// Decr decreases cached int-type value by given key as a counter.
-func (c *TwoQueueCache) Decr(key string) error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	cached, ok := c.cache.Get(key)
-	if !ok {
-		return nil
-	}
-	item, ok := cached.(*MemoryItem)
-
-	if !ok || item.hasExpired() {
-		c.cache.Remove(key)
-		return nil
-	}
-
-	var err error
-	item.Val, err = mc.Decr(item.Val)
-	return err
-}
-
-// IsExist returns true if cached value exists.
-func (c *TwoQueueCache) IsExist(key string) bool {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	cached, ok := c.cache.Peek(key)
-	if !ok {
-		return false
-	}
-	item, ok := cached.(*MemoryItem)
-	if !ok || item.hasExpired() {
-		c.cache.Remove(key)
-		return false
-	}
-
-	return true
-}
-
-// Flush deletes all cached data.
-func (c *TwoQueueCache) Flush() error {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.cache.Purge()
+func (c *twoQueueCache) Ping() error {
 	return nil
 }
 
-func (c *TwoQueueCache) checkAndInvalidate(key string) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	cached, ok := c.cache.Peek(key)
-	if !ok {
-		return
-	}
-	item, ok := cached.(*MemoryItem)
-	if !ok || item.hasExpired() {
-		c.cache.Remove(key)
-	}
-}
-
-func (c *TwoQueueCache) startGC() {
-	if c.interval < 0 {
-		return
-	}
+func (c *twoQueueCache) deleteExpired() {
+	now := timeNow()
 	for _, key := range c.cache.Keys() {
-		c.checkAndInvalidate(key)
-	}
-	time.AfterFunc(time.Duration(c.interval)*time.Second, c.startGC)
-}
-
-// StartAndGC starts GC routine based on config string settings.
-func (c *TwoQueueCache) StartAndGC(opts mc.Options) error {
-	var err error
-	size := 50000
-	if opts.AdapterConfig != "" {
-		size, err = strconv.Atoi(opts.AdapterConfig)
-	}
-	if err != nil {
-		if !json.Valid([]byte(opts.AdapterConfig)) {
-			return err
+		if item, ok := c.cache.Peek(key); ok && item.expired(now) {
+			// here might be a slight data-race: the item might have been removed or updated by another goroutine between the Peek and Remove calls,
+			// but it's acceptable since the cache is not guaranteed to be 100% accurate and any item can be evicted at any time
+			c.cache.Remove(key)
 		}
+	}
+}
 
-		cfg := &TwoQueueCacheConfig{
-			Size:        50000,
-			RecentRatio: lru.Default2QRecentRatio,
-			GhostRatio:  lru.Default2QGhostEntries,
+type memoryItem struct {
+	value     string
+	expiresAt time.Time
+}
+
+func newMemoryItem(value string, ttl int64) memoryItem {
+	item := memoryItem{value: value}
+	if ttl > 0 {
+		item.expiresAt = timeNow().Add(time.Duration(ttl) * time.Second)
+	}
+	return item
+}
+
+func (item memoryItem) expired(now time.Time) bool {
+	return !item.expiresAt.IsZero() && !now.Before(item.expiresAt)
+}
+
+func startGC(interval time.Duration, deleteExpired func()) {
+	if interval <= 0 {
+		return
+	}
+	go func() {
+		for range time.Tick(interval) {
+			deleteExpired()
 		}
-		_ = json.Unmarshal([]byte(opts.AdapterConfig), cfg)
-		c.cache, err = lru.New2QParams[string, any](cfg.Size, cfg.RecentRatio, cfg.GhostRatio)
-	} else {
-		c.cache, err = lru.New2Q[string, any](size)
-	}
-	c.interval = opts.Interval
-	if c.interval > 0 {
-		go c.startGC()
-	}
-	return err
-}
-
-// Ping tests if the cache is alive.
-func (c *TwoQueueCache) Ping() error {
-	return mc.GenericPing(c)
-}
-
-func init() {
-	mc.Register("twoqueue", &TwoQueueCache{})
+	}()
 }

modules/cache/string_cache.go

@@ -5,13 +5,14 @@ package cache
 
 import (
 	"errors"
+	"fmt"
+	"strconv"
 	"strings"
+	"time"
 
 	"gitea.dev/modules/json"
 	"gitea.dev/modules/setting"
 	"gitea.dev/modules/util"
-
-	chi_cache "gitea.com/go-chi/cache" //nolint:depguard // we wrap this package here
 )
 
 type GetJSONError struct {
@@ -30,57 +31,57 @@ type StringCache interface {
 	Ping() error
 
 	Get(key string) (string, bool)
-	Put(key, value string, ttl int64) error
+	Put(key, value string, ttl int64) error // ttl in seconds, 0 never expires, negative removes the key
 	Delete(key string) error
 	IsExist(key string) bool
 
 	PutJSON(key string, v any, ttl int64) error
 	GetJSON(key string, ptr any) (exist bool, err *GetJSONError)
+}
 
-	ChiCache() chi_cache.Cache
+type backend interface {
+	Get(key string) (string, bool)
+	Put(key, value string, ttl int64) error
+	Delete(key string) error
+	IsExist(key string) bool
+	Ping() error
 }
 
 type stringCache struct {
-	chiCache chi_cache.Cache
+	backend
 }
 
 func NewStringCache(cacheConfig setting.Cache) (StringCache, error) {
-	adapter := util.IfZero(cacheConfig.Adapter, "memory")
-	interval := util.IfZero(cacheConfig.Interval, 60)
-	cc, err := chi_cache.NewCacher(chi_cache.Options{
-		Adapter:       adapter,
-		AdapterConfig: cacheConfig.Conn,
-		Interval:      interval,
-	})
+	cacheBackend, err := newBackend(cacheConfig)
 	if err != nil {
 		return nil, err
 	}
-	return &stringCache{chiCache: cc}, nil
+	return &stringCache{backend: cacheBackend}, nil
 }
 
-func (sc *stringCache) Ping() error {
-	return sc.chiCache.Ping()
-}
-
-func (sc *stringCache) Get(key string) (string, bool) {
-	v := sc.chiCache.Get(key)
-	if v == nil {
-		return "", false
+func newBackend(cacheConfig setting.Cache) (backend, error) {
+	gcInterval := time.Duration(util.IfZero(cacheConfig.Interval, 60)) * time.Second
+	switch adapter := util.IfZero(cacheConfig.Adapter, "memory"); adapter {
+	case "memory":
+		// the old "memory" adapter doesn't have a limit, which can lead to OOM
+		// now, use two-queue cache for in-memory cache with items limit, at most a few GB of memory will be used
+		return newTwoQueueCache(strconv.FormatInt(10*1024*1024, 10), gcInterval)
+	case "twoqueue":
+		return newTwoQueueCache(cacheConfig.Conn, gcInterval)
+	case "redis":
+		return newRedisCache(cacheConfig.Conn), nil
+	case "memcache":
+		return newMemcacheCache(cacheConfig.Conn)
+	default:
+		return nil, fmt.Errorf("unknown cache adapter %q", adapter)
 	}
-	s, ok := v.(string)
-	return s, ok
 }
 
 func (sc *stringCache) Put(key, value string, ttl int64) error {
-	return sc.chiCache.Put(key, value, ttl)
-}
-
-func (sc *stringCache) Delete(key string) error {
-	return sc.chiCache.Delete(key)
-}
-
-func (sc *stringCache) IsExist(key string) bool {
-	return sc.chiCache.IsExist(key)
+	if ttl < 0 {
+		return sc.backend.Delete(key)
+	}
+	return sc.backend.Put(key, value, ttl)
 }
 
 const cachedErrorPrefix = "<CACHED-ERROR>:"
@@ -97,7 +98,7 @@ func (sc *stringCache) PutJSON(key string, v any, ttl int64) error {
 		}
 		s = util.UnsafeBytesToString(b)
 	}
-	return sc.chiCache.Put(key, s, ttl)
+	return sc.Put(key, s, ttl)
 }
 
 func (sc *stringCache) GetJSON(key string, ptr any) (exist bool, getErr *GetJSONError) {
@@ -114,7 +115,3 @@ func (sc *stringCache) GetJSON(key string, ptr any) (exist bool, getErr *GetJSON
 	}
 	return true, nil
 }
-
-func (sc *stringCache) ChiCache() chi_cache.Cache {
-	return sc.chiCache
-}

modules/git/last_commit_cache.go

@@ -25,14 +25,20 @@ type LastCommitCache struct {
 
 // Put puts the last commit id with commit and entry path
 func (c *LastCommitCache) Put(ref, entryPath, commitID string) error {
+	if c.ttlFn() < 0 {
+		return nil
+	}
 	log.Debug("LastCommitCache save: [%s:%s:%s]", ref, entryPath, commitID)
 	return c.cache.Put(getCacheKey(c.repo, ref, entryPath), commitID, c.ttlFn())
 }
 
 // Get gets the last commit information by commit id and entry path
 func (c *LastCommitCache) Get(ctx context.Context, ref, entryPath string) (*Commit, error) {
-	lastCommitID, ok := c.cache.Get(getCacheKey(c.repo, ref, entryPath))
-	if !ok || lastCommitID == "" {
+	var lastCommitID string
+	if c.ttlFn() >= 0 {
+		lastCommitID, _ = c.cache.Get(getCacheKey(c.repo, ref, entryPath))
+	}
+	if lastCommitID == "" {
 		return nil, nil //nolint:nilnil // return nil when cache miss
 	}
 

modules/setting/cache.go

@@ -4,6 +4,7 @@
 package setting
 
 import (
+	"math"
 	"time"
 
 	"gitea.dev/modules/log"
@@ -37,9 +38,6 @@ var CacheService = struct {
 	},
 }
 
-// MemcacheMaxTTL represents the maximum memcache TTL
-const MemcacheMaxTTL = 30 * 24 * time.Hour
-
 func loadCacheFrom(rootCfg ConfigProvider) {
 	sec := rootCfg.Section("cache")
 	if err := sec.MapTo(&CacheService); err != nil {
@@ -60,18 +58,19 @@ func loadCacheFrom(rootCfg ConfigProvider) {
 	}
 }
 
-// TTLSeconds returns the TTLSeconds or unix timestamp for memcache
+// TTLSeconds returns the item TTL in seconds, negative when ITEM_TTL disables caching
 func (c Cache) TTLSeconds() int64 {
-	if c.Adapter == "memcache" && c.TTL > MemcacheMaxTTL {
-		return time.Now().Add(c.TTL).Unix()
-	}
-	return int64(c.TTL.Seconds())
+	return ttlSeconds(c.TTL)
 }
 
-// LastCommitCacheTTLSeconds returns the TTLSeconds or unix timestamp for memcache
+// LastCommitCacheTTLSeconds returns the last commit item TTL in seconds, negative when ITEM_TTL disables caching
 func LastCommitCacheTTLSeconds() int64 {
-	if CacheService.Adapter == "memcache" && CacheService.LastCommit.TTL > MemcacheMaxTTL {
-		return time.Now().Add(CacheService.LastCommit.TTL).Unix()
+	return ttlSeconds(CacheService.LastCommit.TTL)
+}
+
+func ttlSeconds(ttl time.Duration) int64 {
+	if ttl < 0 {
+		return -1
 	}
-	return int64(CacheService.LastCommit.TTL.Seconds())
+	return int64(math.Ceil(ttl.Seconds()))
 }

modules/setting/cache_test.go

@@ -69,3 +69,14 @@ ADAPTER = memcache
 		})
 	}
 }
+
+func TestCacheItemTTLSeconds(t *testing.T) {
+	defer test.MockVariableValue(&CacheService)()
+	for ttl, want := range map[string]int64{"-1": -1, "500ms": 1} {
+		cfg, err := NewConfigProviderFromData("[cache]\nITEM_TTL = " + ttl + "\n[cache.last_commit]\nITEM_TTL = " + ttl)
+		assert.NoError(t, err)
+		loadCacheFrom(cfg)
+		assert.Equal(t, want, CacheService.TTLSeconds())
+		assert.Equal(t, want, LastCommitCacheTTLSeconds())
+	}
+}

templates/admin/config.tmpl

@@ -237,7 +237,7 @@
 			<dl class="admin-dl-horizontal">
 				<dt>{{ctx.Locale.Tr "admin.config.cache_adapter"}}</dt>
 				<dd>{{.CacheAdapter}}</dd>
-				{{if eq .CacheAdapter "memory"}}
+				{{if or (eq .CacheAdapter "memory") (eq .CacheAdapter "twoqueue")}}
 					<dt>{{ctx.Locale.Tr "admin.config.cache_interval"}}</dt>
 					<dd>{{.CacheInterval}} {{ctx.Locale.Tr "tool.raw_seconds"}}</dd>
 				{{end}}