Graceful: Xorm, RepoIndexer, Cron and Others (#9282)

* Change graceful to use a singleton obtained through GetManager instead of a global.
* Graceful: Make TestPullRequests shutdownable
* Graceful: Make the cron tasks graceful
* Graceful: AddTestPullRequest run in graceful ctx
* Graceful: SyncMirrors shutdown
* Graceful: SetDefaultContext for Xorm to be HammerContext
* Avoid starting graceful for migrate commands and checkout
* Graceful: DeliverHooks now can be shutdown
* Fix multiple syncing errors in modules/sync/UniqueQueue &  Make UniqueQueue closable
* Begin the process of making the repo indexer shutdown gracefully

1 files changed, 47 insertions, 9 deletions

diff --git a/modules/sync/unique_queue.go b/modules/sync/unique_queue.go
index de694d8560..14644c7d4e 100644
--- a/modules/sync/unique_queue.go
+++ b/modules/sync/unique_queue.go
@@ -1,4 +1,5 @@
 // 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.
 
@@ -15,8 +16,9 @@ import (
 // This queue is particularly useful for preventing duplicated task
 // of same purpose.
 type UniqueQueue struct {
-	table *StatusTable
-	queue chan string
+	table  *StatusTable
+	queue  chan string
+	closed chan struct{}
 }
 
 // NewUniqueQueue initializes and returns a new UniqueQueue object.
@@ -26,11 +28,43 @@ func NewUniqueQueue(queueLength int) *UniqueQueue {
 	}
 
 	return &UniqueQueue{
-		table: NewStatusTable(),
-		queue: make(chan string, queueLength),
+		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() []interface{} {
+	q.table.lock.Lock()
+	defer q.table.lock.Unlock()
+	ids := make([]interface{}, 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
@@ -45,18 +79,22 @@ func (q *UniqueQueue) Exist(id interface{}) bool {
 // 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 interface{}, fn func()) {
-	if q.Exist(id) {
-		return
-	}
-
 	idStr := com.ToStr(id)
 	q.table.lock.Lock()
+	if _, ok := q.table.pool[idStr]; ok {
+		return
+	}
 	q.table.pool[idStr] = struct{}{}
 	if fn != nil {
 		fn()
 	}
 	q.table.lock.Unlock()
-	q.queue <- idStr
+	select {
+	case <-q.closed:
+		return
+	case q.queue <- idStr:
+		return
+	}
 }
 
 // Add adds new instance to the queue.