[feature] persist worker queues to db (#3042)

* persist queued worker tasks to database on shutdown, fill worker queues from database on startup

* ensure the tasks are sorted by creation time before pushing them

* add migration to insert WorkerTask{} into database, add test for worker task persistence

* add test for recovering worker queues from database

* quick tweak

* whoops we ended up with double cleaner job scheduling

* insert each task separately, because bun is throwing some reflection error??

* add specific checking of cancelled worker contexts

* add http request signing to deliveries recovered from database

* add test for outgoing public key ID being correctly set on delivery

* replace select with Queue.PopCtx()

* get rid of loop now we don't use it

* remove field now we don't use it

* ensure that signing func is set

* header values weren't being copied over :facepalm:

* use ptr for httpclient.Request in delivery

* move worker queue filling to later in server init process

* fix rebase issues

* make logging less shouty

* use slices.Delete() instead of copying / reslicing

* have database return tasks in ascending order instead of sorting them

* add a 1 minute timeout to persisting worker queues

1 files changed, 19 insertions, 2 deletions

diff --git a/internal/workers/worker_msg.go b/internal/workers/worker_msg.go
index 92180651a..c7dc568d7 100644
--- a/internal/workers/worker_msg.go
+++ b/internal/workers/worker_msg.go
@@ -19,6 +19,7 @@ package workers
 
 import (
 	"context"
+	"errors"
 
 	"codeberg.org/gruf/go-runners"
 	"codeberg.org/gruf/go-structr"
@@ -147,9 +148,25 @@ func (w *MsgWorker[T]) process(ctx context.Context) {
 			return
 		}
 
-		// Attempt to process popped message type.
-		if err := w.Process(ctx, msg); err != nil {
+		// Attempt to process message.
+		err := w.Process(ctx, msg)
+		if err != nil {
 			log.Errorf(ctx, "%p: error processing: %v", w, err)
+
+			if errors.Is(err, context.Canceled) &&
+				ctx.Err() != nil {
+				// In the case of our own context
+				// being cancelled, push message
+				// back onto queue for persisting.
+				//
+				// Note we specifically check against
+				// context.Canceled here as it will
+				// be faster than the mutex lock of
+				// ctx.Err(), so gives an initial
+				// faster check in the if-clause.
+				w.Queue.Push(msg)
+				break
+			}
 		}
 	}
 }