mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-05-20 17:28:40 +00:00
07727753b9
* Add whereNotEmptyAndNotNull * Add GetRemoteOlderThanDays * Add GetRemoteOlderThanDays * Add PruneRemote to Manager interface * Start implementing PruneRemote * add new attachment + status to tests * fix up and test GetRemoteOlderThan * fix bad import * PruneRemote: return number pruned * add Cached column to mediaattachment * update + test pruneRemote * update mediaTest * use Cached column * upstep bun to latest version * embed structs in mediaAttachment * migrate mediaAttachment to new format * don't default cached to true * select only remote media * update db dependencies * step bun back to last working version * update pruneRemote to use Cached field * fix storage path of test attachments * add recache logic to manager * fix trimmed aspect ratio * test prune and recache * return errwithcode * tidy up different paths for emoji vs attachment * fix incorrect thumbnail type being stored * expose TransportController to media processor * implement tee-ing recached content * add thoughts of dog to test fedi attachments * test get remote files * add comment on PruneRemote * add postData cleanup to recache * test thumbnail fetching * add incredible diagram * go mod tidy * buffer pipes for recache streaming * test for client stops reading after 1kb * add media-remote-cache-days to config * add cron package * wrap logrus so it's available to cron * start and stop cron jobs gracefully
93 lines
2.1 KiB
Go
93 lines
2.1 KiB
Go
package cron
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// JobWrapper decorates the given Job with some behavior.
|
|
type JobWrapper func(Job) Job
|
|
|
|
// Chain is a sequence of JobWrappers that decorates submitted jobs with
|
|
// cross-cutting behaviors like logging or synchronization.
|
|
type Chain struct {
|
|
wrappers []JobWrapper
|
|
}
|
|
|
|
// NewChain returns a Chain consisting of the given JobWrappers.
|
|
func NewChain(c ...JobWrapper) Chain {
|
|
return Chain{c}
|
|
}
|
|
|
|
// Then decorates the given job with all JobWrappers in the chain.
|
|
//
|
|
// This:
|
|
// NewChain(m1, m2, m3).Then(job)
|
|
// is equivalent to:
|
|
// m1(m2(m3(job)))
|
|
func (c Chain) Then(j Job) Job {
|
|
for i := range c.wrappers {
|
|
j = c.wrappers[len(c.wrappers)-i-1](j)
|
|
}
|
|
return j
|
|
}
|
|
|
|
// Recover panics in wrapped jobs and log them with the provided logger.
|
|
func Recover(logger Logger) JobWrapper {
|
|
return func(j Job) Job {
|
|
return FuncJob(func() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
const size = 64 << 10
|
|
buf := make([]byte, size)
|
|
buf = buf[:runtime.Stack(buf, false)]
|
|
err, ok := r.(error)
|
|
if !ok {
|
|
err = fmt.Errorf("%v", r)
|
|
}
|
|
logger.Error(err, "panic", "stack", "...\n"+string(buf))
|
|
}
|
|
}()
|
|
j.Run()
|
|
})
|
|
}
|
|
}
|
|
|
|
// DelayIfStillRunning serializes jobs, delaying subsequent runs until the
|
|
// previous one is complete. Jobs running after a delay of more than a minute
|
|
// have the delay logged at Info.
|
|
func DelayIfStillRunning(logger Logger) JobWrapper {
|
|
return func(j Job) Job {
|
|
var mu sync.Mutex
|
|
return FuncJob(func() {
|
|
start := time.Now()
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
if dur := time.Since(start); dur > time.Minute {
|
|
logger.Info("delay", "duration", dur)
|
|
}
|
|
j.Run()
|
|
})
|
|
}
|
|
}
|
|
|
|
// SkipIfStillRunning skips an invocation of the Job if a previous invocation is
|
|
// still running. It logs skips to the given logger at Info level.
|
|
func SkipIfStillRunning(logger Logger) JobWrapper {
|
|
return func(j Job) Job {
|
|
var ch = make(chan struct{}, 1)
|
|
ch <- struct{}{}
|
|
return FuncJob(func() {
|
|
select {
|
|
case v := <-ch:
|
|
j.Run()
|
|
ch <- v
|
|
default:
|
|
logger.Info("skip")
|
|
}
|
|
})
|
|
}
|
|
}
|