fix config options

Author: wxiaoguang

custom/conf/app.example.ini

@@ -926,12 +926,6 @@ ROUTER = console
 ;; Global limit of repositories per user, applied at creation time. -1 means no limit
 ;MAX_CREATION_LIMIT = -1
 ;;
-;; Mirror sync queue length, increase if mirror syncing starts hanging (DEPRECATED: please use [queue.mirror] LENGTH instead)
-;MIRROR_QUEUE_LENGTH = 1000
-;;
-;; Patch test queue length, increase if pull request patch testing starts hanging (DEPRECATED: please use [queue.pr_patch_checker] LENGTH instead)
-;PULL_REQUEST_QUEUE_LENGTH = 1000
-;;
 ;; Preferred Licenses to place at the top of the List
 ;; The name here must match the filename in options/license or custom/options/license
 ;PREFERRED_LICENSES = Apache License 2.0,MIT License
@@ -1376,22 +1370,6 @@ ROUTER = console
 ;; Set to -1 to disable timeout.
 ;STARTUP_TIMEOUT = 30s
 ;;
-;; Issue indexer queue, currently support: channel, levelqueue or redis, default is levelqueue (deprecated - use [queue.issue_indexer])
-;ISSUE_INDEXER_QUEUE_TYPE = levelqueue; **DEPRECATED** use settings in `[queue.issue_indexer]`.
-;;
-;; When ISSUE_INDEXER_QUEUE_TYPE is levelqueue, this will be the path where the queue will be saved.
-;; This can be overridden by `ISSUE_INDEXER_QUEUE_CONN_STR`.
-;; default is queues/common
-;ISSUE_INDEXER_QUEUE_DIR = queues/common; **DEPRECATED** use settings in `[queue.issue_indexer]`. Relative paths will be made absolute against `%(APP_DATA_PATH)s`.
-;;
-;; When `ISSUE_INDEXER_QUEUE_TYPE` is `redis`, this will store the redis connection string.
-;; When `ISSUE_INDEXER_QUEUE_TYPE` is `levelqueue`, this is a directory or additional options of
-;; the form `leveldb://path/to/db?option=value&....`, and overrides `ISSUE_INDEXER_QUEUE_DIR`.
-;ISSUE_INDEXER_QUEUE_CONN_STR = "addrs=127.0.0.1:6379 db=0"; **DEPRECATED** use settings in `[queue.issue_indexer]`.
-;;
-;; Batch queue number, default is 20
-;ISSUE_INDEXER_QUEUE_BATCH_NUMBER = 20; **DEPRECATED** use settings in `[queue.issue_indexer]`.
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Repository Indexer settings
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1418,8 +1396,6 @@ ROUTER = console
 ;; A comma separated list of glob patterns to exclude from the index; ; default is empty
 ;REPO_INDEXER_EXCLUDE =
 ;;
-;;
-;UPDATE_BUFFER_LEN = 20; **DEPRECATED** use settings in `[queue.issue_indexer]`.
 ;MAX_FILE_SIZE = 1048576
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1449,37 +1425,16 @@ ROUTER = console
 ;; Connection string for redis queues this will store the redis connection string.
 ;; When `TYPE` is `persistable-channel`, this provides a directory for the underlying leveldb
 ;; or additional options of the form `leveldb://path/to/db?option=value&....`, and will override `DATADIR`.
-;CONN_STR = "addrs=127.0.0.1:6379 db=0"
+;CONN_STR = "redis://127.0.0.1:6379/0"
 ;;
 ;; Provides the suffix of the default redis/disk queue name - specific queues can be overridden within in their [queue.name] sections.
 ;QUEUE_NAME = "_queue"
 ;;
 ;; Provides the suffix of the default redis/disk unique queue set name - specific queues can be overridden within in their [queue.name] sections.
 ;SET_NAME = "_unique"
 ;;
-;; If the queue cannot be created at startup - level queues may need a timeout at startup - wrap the queue:
-;WRAP_IF_NECESSARY = true
-;;
-;; Attempt to create the wrapped queue at max
-;MAX_ATTEMPTS = 10
-;;
-;; Timeout queue creation
-;TIMEOUT = 15m30s
-;;
-;; Create a pool with this many workers
-;WORKERS = 0
-;;
 ;; Dynamically scale the worker pool to at this many workers
 ;MAX_WORKERS = 10
-;;
-;; Add boost workers when the queue blocks for BLOCK_TIMEOUT
-;BLOCK_TIMEOUT = 1s
-;;
-;; Remove the boost workers after BOOST_TIMEOUT
-;BOOST_TIMEOUT = 5m
-;;
-;; During a boost add BOOST_WORKERS
-;BOOST_WORKERS = 1
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

docs/content/doc/administration/config-cheat-sheet.en-us.md

@@ -89,10 +89,6 @@ In addition there is _`StaticRootPath`_ which can be set as a built-in at build
 - `DEFAULT_PUSH_CREATE_PRIVATE`: **true**: Default private when creating a new repository with push-to-create.
 - `MAX_CREATION_LIMIT`: **-1**: Global maximum creation limit of repositories per user,
    `-1` means no limit.
-- `PULL_REQUEST_QUEUE_LENGTH`: **1000**: Length of pull request patch test queue, make it. **DEPRECATED** use `LENGTH` in `[queue.pr_patch_checker]`.
-   as large as possible. Use caution when editing this value.
-- `MIRROR_QUEUE_LENGTH`: **1000**: Patch test queue length, increase if pull request patch
-   testing starts hanging. **DEPRECATED** use `LENGTH` in `[queue.mirror]`.
 - `PREFERRED_LICENSES`: **Apache License 2.0,MIT License**: Preferred Licenses to place at
    the top of the list. Name must match file name in options/license or custom/options/license.
 - `DISABLE_HTTP_GIT`: **false**: Disable the ability to interact with repositories over the
@@ -466,10 +462,6 @@ relation to port exhaustion.
 - `ISSUE_INDEXER_NAME`: **gitea_issues**: Issue indexer name, available when ISSUE_INDEXER_TYPE is elasticsearch
 - `ISSUE_INDEXER_PATH`: **indexers/issues.bleve**: Index file used for issue search; available when ISSUE_INDEXER_TYPE is bleve and elasticsearch. Relative paths will be made absolute against _`AppWorkPath`_.
 - The next 4 configuration values are deprecated and should be set in `queue.issue_indexer` however are kept for backwards compatibility:
-- `ISSUE_INDEXER_QUEUE_TYPE`: **levelqueue**: Issue indexer queue, currently supports:`channel`, `levelqueue`, `redis`. **DEPRECATED** use settings in `[queue.issue_indexer]`.
-- `ISSUE_INDEXER_QUEUE_DIR`: **queues/common**: When `ISSUE_INDEXER_QUEUE_TYPE` is `levelqueue`, this will be the path where the queue will be saved. **DEPRECATED** use settings in `[queue.issue_indexer]`. Relative paths will be made absolute against `%(APP_DATA_PATH)s`.
-- `ISSUE_INDEXER_QUEUE_CONN_STR`: **addrs=127.0.0.1:6379 db=0**: When `ISSUE_INDEXER_QUEUE_TYPE` is `redis`, this will store the redis connection string. When `ISSUE_INDEXER_QUEUE_TYPE` is `levelqueue`, this is a directory or additional options of the form `leveldb://path/to/db?option=value&....`, and overrides `ISSUE_INDEXER_QUEUE_DIR`. **DEPRECATED** use settings in `[queue.issue_indexer]`.
-- `ISSUE_INDEXER_QUEUE_BATCH_NUMBER`: **20**: Batch queue number. **DEPRECATED** use settings in `[queue.issue_indexer]`.
 
 - `REPO_INDEXER_ENABLED`: **false**: Enables code search (uses a lot of disk space, about 6 times more than the repository size).
 - `REPO_INDEXER_TYPE`: **bleve**: Code search engine type, could be `bleve` or `elasticsearch`.
@@ -480,7 +472,6 @@ relation to port exhaustion.
 - `REPO_INDEXER_INCLUDE`: **empty**: A comma separated list of glob patterns (see https://github.com/gobwas/glob) to **include** in the index. Use `**.txt` to match any files with .txt extension. An empty list means include all files.
 - `REPO_INDEXER_EXCLUDE`: **empty**: A comma separated list of glob patterns (see https://github.com/gobwas/glob) to **exclude** from the index. Files that match this list will not be indexed, even if they match in `REPO_INDEXER_INCLUDE`.
 - `REPO_INDEXER_EXCLUDE_VENDORED`: **true**: Exclude vendored files from index.
-- `UPDATE_BUFFER_LEN`: **20**: Buffer length of index request. **DEPRECATED** use settings in `[queue.issue_indexer]`.
 - `MAX_FILE_SIZE`: **1048576**: Maximum size in bytes of files to be indexed.
 - `STARTUP_TIMEOUT`: **30s**: If the indexer takes longer than this timeout to start - fail. (This timeout will be added to the hammer time above for child processes - as bleve will not start until the previous parent is shutdown.) Set to -1 to never timeout.
 
@@ -496,15 +487,7 @@ Configuration at `[queue]` will set defaults for queues with overrides for indiv
 - `QUEUE_NAME`: **_queue**: The suffix for default redis and disk queue name. Individual queues will default to **`name`**`QUEUE_NAME` but can be overridden in the specific `queue.name` section.
 - `SET_NAME`: **_unique**: The suffix that will be added to the default redis and disk queue `set` name for unique queues. Individual queues will default to
  **`name`**`QUEUE_NAME`_`SET_NAME`_ but can be overridden in the specific `queue.name` section.
-- `WRAP_IF_NECESSARY`: **true**: Will wrap queues with a timeoutable queue if the selected queue is not ready to be created - (Only relevant for the level queue.)
-- `MAX_ATTEMPTS`: **10**: Maximum number of attempts to create the wrapped queue
-- `TIMEOUT`: **GRACEFUL_HAMMER_TIME + 30s**: Timeout the creation of the wrapped queue if it takes longer than this to create.
-- Queues by default come with a dynamically scaling worker pool. The following settings configure this:
-- `WORKERS`: **0**: Number of initial workers for the queue.
 - `MAX_WORKERS`: **10**: Maximum number of worker go-routines for the queue.
-- `BLOCK_TIMEOUT`: **1s**: If the queue blocks for this time, boost the number of workers - the `BLOCK_TIMEOUT` will then be doubled before boosting again whilst the boost is ongoing.
-- `BOOST_TIMEOUT`: **5m**: Boost workers will timeout after this long.
-- `BOOST_WORKERS`: **1**: This many workers will be added to the worker pool if there is a boost.
 
 Gitea creates the following non-unique queues:
 

modules/queue/base_levelqueue_test.go

@@ -16,6 +16,6 @@ func TestBaseLevelDB(t *testing.T) {
 		setting.AppDataPath = oldAppDataPath
 	}()
 
-	testQueueBasic(t, newBaseLevelQueueSimple, toBaseConfig("baseLevelQueue", &IniConfig{Length: 10}), false)
-	testQueueBasic(t, newBaseLevelQueueUnique, toBaseConfig("baseLevelQueueUnique", &IniConfig{Length: 10}), true)
+	testQueueBasic(t, newBaseLevelQueueSimple, toBaseConfig("baseLevelQueue", setting.QueueSettings{Length: 10}), false)
+	testQueueBasic(t, newBaseLevelQueueUnique, toBaseConfig("baseLevelQueueUnique", setting.QueueSettings{Length: 10}), true)
 }

modules/queue/base_redis_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"code.gitea.io/gitea/modules/nosql"
+	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -65,6 +66,6 @@ func TestBaseRedis(t *testing.T) {
 		}
 	}
 
-	testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", &IniConfig{Length: 10}), false)
-	testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", &IniConfig{Length: 10}), true)
+	testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", setting.QueueSettings{Length: 10}), false)
+	testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", setting.QueueSettings{Length: 10}), true)
 }

modules/queue/config.go

@@ -5,7 +5,6 @@ package queue
 
 import (
 	"path/filepath"
-	"unicode"
 
 	"code.gitea.io/gitea/modules/setting"
 )
@@ -20,48 +19,15 @@ type BaseConfig struct {
 	QueueFullName, SetFullName string
 }
 
-type IniConfig struct {
-	Type    string
-	Datadir string
-	ConnStr string
-	Length  int
-
-	QueueName, SetName string
-
-	BatchLength int
-	Workers     int
-}
-
-var iniConfigDefault = IniConfig{
-	Type:    "level",   // dummy, channel, level(leveldb,levelqueue,persistable-channel), redis
-	Datadir: "queues/", // relative to AppDataPath
-	Length:  1000,      // queue length before a channel queue will block
-
-	QueueName:   "_queue",  // the suffix of the default redis/disk queue name
-	SetName:     "_unique", // the suffix of the default redis/disk unique queue set name (for unique queue)
-	BatchLength: 20,
-	Workers:     1,
-}
-
-func joinQueueFullName(managedName, suffixOrName, suffixDefault string) string {
-	if suffixOrName == "" {
-		suffixOrName = suffixDefault
-	}
-	if unicode.IsLetter(rune(suffixOrName[0])) {
-		return suffixOrName
-	}
-	return managedName + suffixOrName
-}
-
-func toBaseConfig(managedName string, iniCfg *IniConfig) *BaseConfig {
+func toBaseConfig(managedName string, queueSetting setting.QueueSettings) *BaseConfig {
 	baseConfig := &BaseConfig{
 		ManagedName: managedName,
 
-		ConnStr: iniCfg.ConnStr,
-		Length:  iniCfg.Length,
+		ConnStr: queueSetting.ConnStr,
+		Length:  queueSetting.Length,
 	}
 	// data dir
-	baseConfig.DataFullDir = iniCfg.Datadir
+	baseConfig.DataFullDir = queueSetting.Datadir
 	if baseConfig.DataFullDir == "" {
 		baseConfig.DataFullDir = "queues/"
 	}
@@ -71,7 +37,10 @@ func toBaseConfig(managedName string, iniCfg *IniConfig) *BaseConfig {
 	}
 
 	// queue name and set name
-	baseConfig.QueueFullName = joinQueueFullName(managedName, iniCfg.QueueName, "_queue")
-	baseConfig.SetFullName = joinQueueFullName(managedName, iniCfg.SetName, "_unique")
+	baseConfig.QueueFullName = managedName + queueSetting.QueueName
+	baseConfig.SetFullName = baseConfig.QueueFullName + queueSetting.SetName
+	if baseConfig.SetFullName == baseConfig.QueueFullName {
+		baseConfig.SetFullName += "_unique"
+	}
 	return baseConfig
 }

modules/queue/manager_test.go

@@ -28,18 +28,16 @@ LENGTH = 100
 BATCH_LENGTH = 20
 CONN_STR = "addrs=127.0.0.1:6379 db=0"
 QUEUE_NAME = "_queue1"
-SET_NAME = "_unique1"
-WORKERS = 1
 
 [queue.sub]
 TYPE = level
 DATADIR = queues-dir2
 LENGTH = 102
 BATCH_LENGTH = 22
 CONN_STR =
-QUEUE_NAME = "q2"
-SET_NAME = "u2"
-WORKERS = 2
+QUEUE_NAME = "_q2"
+SET_NAME = "_u2"
+MAX_WORKERS = 2
 `)
 
 	assert.NoError(t, err)
@@ -52,8 +50,8 @@ WORKERS = 2
 	assert.Equal(t, 20, q1.batchLength)
 	assert.Equal(t, "addrs=127.0.0.1:6379 db=0", q1.baseConfig.ConnStr)
 	assert.Equal(t, "default_queue1", q1.baseConfig.QueueFullName)
-	assert.Equal(t, "default_unique1", q1.baseConfig.SetFullName)
-	assert.Equal(t, 1, q1.GetWorkerMaxNumber())
+	assert.Equal(t, "default_queue1_unique", q1.baseConfig.SetFullName)
+	assert.Equal(t, 10, q1.GetWorkerMaxNumber())
 	assert.Equal(t, 0, q1.GetWorkerNumber())
 	assert.Equal(t, 0, q1.GetWorkerActiveNumber())
 	assert.Equal(t, 0, q1.GetQueueItemNumber())
@@ -67,8 +65,8 @@ WORKERS = 2
 	assert.Equal(t, 102, q2.baseConfig.Length)
 	assert.Equal(t, 22, q2.batchLength)
 	assert.Equal(t, "", q2.baseConfig.ConnStr)
-	assert.Equal(t, "q2", q2.baseConfig.QueueFullName)
-	assert.Equal(t, "u2", q2.baseConfig.SetFullName)
+	assert.Equal(t, "sub_q2", q2.baseConfig.QueueFullName)
+	assert.Equal(t, "sub_q2_u2", q2.baseConfig.SetFullName)
 	assert.Equal(t, 2, q2.GetWorkerMaxNumber())
 	assert.Equal(t, 0, q2.GetWorkerNumber())
 	assert.Equal(t, 0, q2.GetWorkerActiveNumber())

modules/queue/workerqueue.go

@@ -182,27 +182,17 @@ func getNewQueueFn(t string) (string, func(cfg *BaseConfig, unique bool) (baseQu
 	}
 }
 
-func NewWorkerPoolQueueByIniConfig[T any](name string, iniCfg IniConfig, handler HandlerFuncT[T], unique bool) *WorkerPoolQueue[T] {
+func NewWorkerPoolQueueByIniConfig[T any](name string, queueSetting setting.QueueSettings, handler HandlerFuncT[T], unique bool) *WorkerPoolQueue[T] {
 	if handler == nil {
 		log.Debug("Use dummy queue for %q because handler is nil and caller doesn't want to process the queue items", name)
-		iniCfg.Type = "dummy"
-	}
-
-	if iniCfg.Length <= 0 {
-		iniCfg.Length = iniConfigDefault.Length
-	}
-	if iniCfg.Workers <= 0 {
-		iniCfg.Workers = iniConfigDefault.Workers
-	}
-	if iniCfg.BatchLength <= 0 {
-		iniCfg.BatchLength = iniConfigDefault.BatchLength
+		queueSetting.Type = "dummy"
 	}
 
 	var w WorkerPoolQueue[T]
 	var err error
-	queueType, newQueueFn := getNewQueueFn(iniCfg.Type)
+	queueType, newQueueFn := getNewQueueFn(queueSetting.Type)
 	w.baseQueueType = queueType
-	w.baseConfig = toBaseConfig(name, &iniCfg)
+	w.baseConfig = toBaseConfig(name, queueSetting)
 	w.baseQueue, err = newQueueFn(w.baseConfig, unique)
 	if err != nil {
 		log.Error("Failed to create queue %q: %v", name, err)
@@ -213,8 +203,8 @@ func NewWorkerPoolQueueByIniConfig[T any](name string, iniCfg IniConfig, handler
 	w.ctxRun, w.ctxRunCancel = context.WithCancel(graceful.GetManager().ShutdownContext())
 	w.batchChan = make(chan []T)
 	w.flushChan = make(chan flushChanType)
-	w.workerMaxNum = iniCfg.Workers
-	w.batchLength = iniCfg.BatchLength
+	w.workerMaxNum = queueSetting.MaxWorkers
+	w.batchLength = queueSetting.BatchLength
 
 	w.origHandler = handler
 	w.safeHandler = func(t ...T) (unhandled []T) {
@@ -239,24 +229,12 @@ func CreateUniqueQueue[T any](name string, handler HandlerFuncT[T]) *WorkerPoolQ
 }
 
 func createWorkerPoolQueue[T any](name string, cfgProvider setting.ConfigProvider, handler HandlerFuncT[T], unique bool) *WorkerPoolQueue[T] {
-	// FIXME: legacy ini options should be dropped and removed
-	iniCfg := iniConfigDefault
-	if sec, err := cfgProvider.GetSection("queue"); err == nil {
-		if err = sec.MapTo(&iniCfg); err != nil {
-			log.Error("Failed to map queue common config for %q: %v", name, err)
-			return nil
-		}
-	}
-	if sec, err := cfgProvider.GetSection("queue." + name); err == nil {
-		if err = sec.MapTo(&iniCfg); err != nil {
-			log.Error("Failed to map queue spec config for %q: %v", name, err)
-			return nil
-		}
-		if sec.HasKey("CONN_STR") {
-			iniCfg.ConnStr = sec.Key("CONN_STR").String()
-		}
+	queueSetting, err := setting.GetQueueSettings(cfgProvider, name)
+	if err != nil {
+		log.Error("Failed to get queue settings for %q: %v", name, err)
+		return nil
 	}
-	w := NewWorkerPoolQueueByIniConfig(name, iniCfg, handler, unique)
+	w := NewWorkerPoolQueueByIniConfig(name, queueSetting, handler, unique)
 	GetManager().AddManagedQueue(w)
 	return w
 }