mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-11-29 09:31:11 -05:00
4f27c28947
Follows: #19284 * The `CopyDir` is only used inside test code * Rewrite `ToSnakeCase` with more test cases * The `RedisCacher` only put strings into cache, here we use internal `toStr` to replace the legacy `ToStr` * The `UniqueQueue` can use string as ID directly, no need to call `ToStr`
104 lines
2.4 KiB
Go
104 lines
2.4 KiB
Go
// Copyright 2016 The Gogs Authors. All rights reserved.
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package sync
|
|
|
|
// UniqueQueue is a queue which guarantees only one instance of same
|
|
// identity is in the line. Instances with same identity will be
|
|
// discarded if there is already one in the line.
|
|
//
|
|
// This queue is particularly useful for preventing duplicated task
|
|
// of same purpose.
|
|
type UniqueQueue struct {
|
|
table *StatusTable
|
|
queue chan string
|
|
closed chan struct{}
|
|
}
|
|
|
|
// NewUniqueQueue initializes and returns a new UniqueQueue object.
|
|
func NewUniqueQueue(queueLength int) *UniqueQueue {
|
|
if queueLength <= 0 {
|
|
queueLength = 100
|
|
}
|
|
|
|
return &UniqueQueue{
|
|
table: NewStatusTable(),
|
|
queue: make(chan string, queueLength),
|
|
closed: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
// Close closes this queue
|
|
func (q *UniqueQueue) Close() {
|
|
select {
|
|
case <-q.closed:
|
|
default:
|
|
q.table.lock.Lock()
|
|
select {
|
|
case <-q.closed:
|
|
default:
|
|
close(q.closed)
|
|
}
|
|
q.table.lock.Unlock()
|
|
}
|
|
}
|
|
|
|
// IsClosed returns a channel that is closed when this Queue is closed
|
|
func (q *UniqueQueue) IsClosed() <-chan struct{} {
|
|
return q.closed
|
|
}
|
|
|
|
// IDs returns the current ids in the pool
|
|
func (q *UniqueQueue) IDs() []string {
|
|
q.table.lock.Lock()
|
|
defer q.table.lock.Unlock()
|
|
ids := make([]string, 0, len(q.table.pool))
|
|
for id := range q.table.pool {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
|
|
// Queue returns channel of queue for retrieving instances.
|
|
func (q *UniqueQueue) Queue() <-chan string {
|
|
return q.queue
|
|
}
|
|
|
|
// Exist returns true if there is an instance with given identity
|
|
// exists in the queue.
|
|
func (q *UniqueQueue) Exist(id string) bool {
|
|
return q.table.IsRunning(id)
|
|
}
|
|
|
|
// AddFunc adds new instance to the queue with a custom runnable function,
|
|
// the queue is blocked until the function exits.
|
|
func (q *UniqueQueue) AddFunc(id string, fn func()) {
|
|
q.table.lock.Lock()
|
|
if _, ok := q.table.pool[id]; ok {
|
|
q.table.lock.Unlock()
|
|
return
|
|
}
|
|
q.table.pool[id] = struct{}{}
|
|
if fn != nil {
|
|
fn()
|
|
}
|
|
q.table.lock.Unlock()
|
|
select {
|
|
case <-q.closed:
|
|
return
|
|
case q.queue <- id:
|
|
return
|
|
}
|
|
}
|
|
|
|
// Add adds new instance to the queue.
|
|
func (q *UniqueQueue) Add(id string) {
|
|
q.AddFunc(id, nil)
|
|
}
|
|
|
|
// Remove removes instance from the queue.
|
|
func (q *UniqueQueue) Remove(id string) {
|
|
q.table.Stop(id)
|
|
}
|