5 files changed, 0 insertions, 539 deletions
diff --git a/vendor/codeberg.org/gruf/go-sched/LICENSE b/vendor/codeberg.org/gruf/go-sched/LICENSE
deleted file mode 100644
index e4163ae35..000000000
--- a/vendor/codeberg.org/gruf/go-sched/LICENSE
+++ /dev/null
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2022 gruf
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/codeberg.org/gruf/go-sched/README.md b/vendor/codeberg.org/gruf/go-sched/README.md
deleted file mode 100644
index d32a961ae..000000000
--- a/vendor/codeberg.org/gruf/go-sched/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# go-sched
-
-A simple job (both run-once and recurring) queueing library with down-to millisecond precision.
-
-Precision estimates based on test output (running on i7-11800h): 1ms precision with 80% tolerance.
-\ No newline at end of file
diff --git a/vendor/codeberg.org/gruf/go-sched/job.go b/vendor/codeberg.org/gruf/go-sched/job.go
deleted file mode 100644
index 2531769d6..000000000
--- a/vendor/codeberg.org/gruf/go-sched/job.go
+++ /dev/null
@@ -1,143 +0,0 @@
-package sched
-
-import (
-	"reflect"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"time"
-	"unsafe"
-)
-
-// Job encapsulates logic for a scheduled job to be run according
-// to a set Timing, executing the job with a set panic handler, and
-// holding onto a next execution time safely in a concurrent environment.
-type Job struct {
-	id     uint64
-	next   unsafe.Pointer // *time.Time
-	timing Timing
-	call   func(time.Time)
-	panic  func(interface{})
-}
-
-// NewJob returns a new Job to run given function.
-func NewJob(fn func(now time.Time)) *Job {
-	if fn == nil {
-		// Ensure a function
-		panic("nil func")
-	}
-
-	j := &Job{ // set defaults
-		timing: emptytiming, // i.e. fire immediately
-		call:   fn,
-		panic:  func(i interface{}) { panic(i) },
-	}
-
-	return j
-}
-
-// At sets this Job to execute at time, by passing (*sched.Once)(&at) to .With(). See .With() for details.
-func (job *Job) At(at time.Time) *Job {
-	return job.With((*Once)(&at))
-}
-
-// Every sets this Job to execute every period, by passing sched.Period(period) to .With(). See .With() for details.
-func (job *Job) Every(period time.Duration) *Job {
-	return job.With(Periodic(period))
-}
-
-// EveryAt sets this Job to execute every period starting at time, by passing &PeriodicAt{once: Once(at), period: Periodic(period)} to .With(). See .With() for details.
-func (job *Job) EveryAt(at time.Time, period time.Duration) *Job {
-	return job.With(&PeriodicAt{Once: Once(at), Period: Periodic(period)})
-}
-
-// With sets this Job's timing to given implementation, or if already set will wrap existing using sched.TimingWrap{}.
-func (job *Job) With(t Timing) *Job {
-	if t == nil {
-		// Ensure a timing
-		panic("nil Timing")
-	}
-
-	if job.id != 0 {
-		// Cannot update scheduled job
-		panic("job already scheduled")
-	}
-
-	if job.timing == emptytiming {
-		// Set new timing
-		job.timing = t
-	} else {
-		// Wrap old timing
-		old := job.timing
-		job.timing = &TimingWrap{
-			Outer: t,
-			Inner: old,
-		}
-	}
-
-	return job
-}
-
-// OnPanic specifies how this job handles panics, default is an actual panic.
-func (job *Job) OnPanic(fn func(interface{})) *Job {
-	if fn == nil {
-		// Ensure a function
-		panic("nil func")
-	}
-
-	if job.id != 0 {
-		// Cannot update scheduled job
-		panic("job already scheduled")
-	}
-
-	job.panic = fn
-	return job
-}
-
-// Next returns the next time this Job is expected to run.
-func (job *Job) Next() time.Time {
-	return loadTime(&job.next)
-}
-
-// Run will execute this Job and pass through given now time.
-func (job *Job) Run(now time.Time) {
-	defer func() {
-		switch r := recover(); {
-		case r == nil:
-			// no panic
-		case job != nil &&
-			job.panic != nil:
-			job.panic(r)
-		default:
-			panic(r)
-		}
-	}()
-	job.call(now)
-}
-
-// String provides a debuggable string representation of Job including ID, next time and Timing type.
-func (job *Job) String() string {
-	var buf strings.Builder
-	buf.WriteByte('{')
-	buf.WriteString("id=")
-	buf.WriteString(strconv.FormatUint(job.id, 10))
-	buf.WriteByte(' ')
-	buf.WriteString("next=")
-	buf.WriteString(loadTime(&job.next).Format(time.StampMicro))
-	buf.WriteByte(' ')
-	buf.WriteString("timing=")
-	buf.WriteString(reflect.TypeOf(job.timing).String())
-	buf.WriteByte('}')
-	return buf.String()
-}
-
-func loadTime(p *unsafe.Pointer) time.Time {
-	if p := atomic.LoadPointer(p); p != nil {
-		return *(*time.Time)(p)
-	}
-	return zerotime
-}
-
-func storeTime(p *unsafe.Pointer, t time.Time) {
-	atomic.StorePointer(p, unsafe.Pointer(&t))
-}
diff --git a/vendor/codeberg.org/gruf/go-sched/scheduler.go b/vendor/codeberg.org/gruf/go-sched/scheduler.go
deleted file mode 100644
index 79913a9b3..000000000
--- a/vendor/codeberg.org/gruf/go-sched/scheduler.go
+++ /dev/null
@@ -1,290 +0,0 @@
-package sched
-
-import (
-	"context"
-	"sort"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"codeberg.org/gruf/go-runners"
-)
-
-// precision is the maximum time we can offer scheduler run-time precision down to.
-const precision = time.Millisecond
-
-var (
-	// neverticks is a timer channel that never ticks (it's starved).
-	neverticks = make(chan time.Time)
-
-	// alwaysticks is a timer channel that always ticks (it's closed).
-	alwaysticks = func() chan time.Time {
-		ch := make(chan time.Time)
-		close(ch)
-		return ch
-	}()
-)
-
-// Scheduler provides a means of running jobs at specific times and
-// regular intervals, all while sharing a single underlying timer.
-type Scheduler struct {
-	jobs []*Job           // jobs is a list of tracked Jobs to be executed
-	jch  chan interface{} // jch accepts either Jobs or job IDs to notify new/removed jobs
-	svc  runners.Service  // svc manages the main scheduler routine
-	jid  atomic.Uint64    // jid is used to iteratively generate unique IDs for jobs
-	rgo  func(func())     // goroutine runner, allows using goroutine pool to launch jobs
-}
-
-// Start will attempt to start the Scheduler. Immediately returns false if the Service is already running, and true after completed run.
-func (sch *Scheduler) Start(gorun func(func())) bool {
-	var block sync.Mutex
-
-	// Use mutex to synchronize between started
-	// goroutine and ourselves, to ensure that
-	// we don't return before Scheduler init'd.
-	block.Lock()
-	defer block.Unlock()
-
-	ok := sch.svc.GoRun(func(ctx context.Context) {
-		// Create Scheduler job channel
-		sch.jch = make(chan interface{})
-
-		// Set goroutine runner function
-		if sch.rgo = gorun; sch.rgo == nil {
-			sch.rgo = func(f func()) { go f() }
-		}
-
-		// Unlock start routine
-		block.Unlock()
-
-		// Enter main loop
-		sch.run(ctx)
-	})
-
-	if ok {
-		// Wait on goroutine
-		block.Lock()
-	}
-
-	return ok
-}
-
-// Stop will attempt to stop the Scheduler. Immediately returns false if not running, and true only after Scheduler is fully stopped.
-func (sch *Scheduler) Stop() bool {
-	return sch.svc.Stop()
-}
-
-// Running will return whether Scheduler is running (i.e. NOT stopped / stopping).
-func (sch *Scheduler) Running() bool {
-	return sch.svc.Running()
-}
-
-// Done returns a channel that's closed when Scheduler.Stop() is called.
-func (sch *Scheduler) Done() <-chan struct{} {
-	return sch.svc.Done()
-}
-
-// Schedule will add provided Job to the Scheduler, returning a cancel function.
-func (sch *Scheduler) Schedule(job *Job) (cancel func()) {
-	switch {
-	// Check a job was passed
-	case job == nil:
-		panic("nil job")
-
-	// Check we are running
-	case !sch.Running():
-		panic("scheduler not running")
-	}
-
-	// Calculate next job ID
-	last := sch.jid.Load()
-	next := sch.jid.Add(1)
-	if next < last {
-		panic("job id overflow")
-	}
-
-	// Pass job to scheduler
-	job.id = next
-	sch.jch <- job
-
-	// Take ptrs to current state chs
-	ctx := sch.svc.Done()
-	jch := sch.jch
-
-	// Return cancel function for job ID
-	return func() {
-		select {
-		// Sched stopped
-		case <-ctx:
-
-		// Cancel this job
-		case jch <- next:
-		}
-	}
-}
-
-// run is the main scheduler run routine, which runs for as long as ctx is valid.
-func (sch *Scheduler) run(ctx context.Context) {
-	var (
-		// now stores the current time, and will only be
-		// set when the timer channel is set to be the
-		// 'alwaysticks' channel. this allows minimizing
-		// the number of calls required to time.Now().
-		now time.Time
-
-		// timerset represents whether timer was running
-		// for a particular run of the loop. false means
-		// that tch == neverticks || tch == alwaysticks.
-		timerset bool
-
-		// timer tick channel (or always / never ticks).
-		tch <-chan time.Time
-
-		// timer notifies this main routine to wake when
-		// the job queued needs to be checked for executions.
-		timer *time.Timer
-
-		// stopdrain will stop and drain the timer
-		// if it has been running (i.e. timerset == true).
-		stopdrain = func() {
-			if timerset && !timer.Stop() {
-				<-timer.C
-			}
-		}
-	)
-
-	// Create a stopped timer.
-	timer = time.NewTimer(1)
-	<-timer.C
-
-	for {
-		// Reset timer state.
-		timerset = false
-
-		if len(sch.jobs) > 0 {
-			// Get now time.
-			now = time.Now()
-
-			// Sort jobs by next occurring.
-			sort.Sort(byNext(sch.jobs))
-
-			// Get next job time.
-			next := sch.jobs[0].Next()
-
-			// If this job is _just_ about to be ready, we don't bother
-			// sleeping. It's wasted cycles only sleeping for some obscenely
-			// tiny amount of time we can't guarantee precision for.
-			if until := next.Sub(now); until <= precision/1e3 {
-				// This job is behind,
-				// set to always tick.
-				tch = alwaysticks
-			} else {
-				// Reset timer to period.
-				timer.Reset(until)
-				tch = timer.C
-				timerset = true
-			}
-		} else {
-			// Unset timer
-			tch = neverticks
-		}
-
-		select {
-		// Scheduler stopped
-		case <-ctx.Done():
-			stopdrain()
-			return
-
-		// Timer ticked, run scheduled
-		case t := <-tch:
-			if !timerset {
-				// 'alwaysticks' returns zero
-				// times, BUT 'now' will have
-				// been set during above sort.
-				t = now
-			}
-			sch.schedule(t)
-
-		// Received update, handle job/id
-		case v := <-sch.jch:
-			sch.handle(v)
-			stopdrain()
-		}
-	}
-}
-
-// handle takes an interfaces received from Scheduler.jch and handles either:
-// - Job --> new job to add.
-// - uint64 --> job ID to remove.
-func (sch *Scheduler) handle(v interface{}) {
-	switch v := v.(type) {
-	// New job added
-	case *Job:
-		// Get current time
-		now := time.Now()
-
-		// Update the next call time
-		next := v.timing.Next(now)
-		storeTime(&v.next, next)
-
-		// Append this job to queued
-		sch.jobs = append(sch.jobs, v)
-
-	// Job removed
-	case uint64:
-		for i := 0; i < len(sch.jobs); i++ {
-			if sch.jobs[i].id == v {
-				// This is the job we're looking for! Drop this
-				sch.jobs = append(sch.jobs[:i], sch.jobs[i+1:]...)
-				return
-			}
-		}
-	}
-}
-
-// schedule will iterate through the scheduler jobs and execute those necessary, updating their next call time.
-func (sch *Scheduler) schedule(now time.Time) {
-	for i := 0; i < len(sch.jobs); {
-		// Scope our own var
-		job := sch.jobs[i]
-
-		// We know these jobs are ordered by .Next(), so as soon
-		// as we reach one with .Next() after now, we can return
-		if job.Next().After(now) {
-			return
-		}
-
-		// Pass to runner
-		sch.rgo(func() {
-			job.Run(now)
-		})
-
-		// Update the next call time
-		next := job.timing.Next(now)
-		storeTime(&job.next, next)
-
-		if next.IsZero() {
-			// Zero time, this job is done and can be dropped
-			sch.jobs = append(sch.jobs[:i], sch.jobs[i+1:]...)
-			continue
-		}
-
-		// Iter
-		i++
-	}
-}
-
-// byNext is an implementation of sort.Interface to sort Jobs by their .Next() time.
-type byNext []*Job
-
-func (by byNext) Len() int {
-	return len(by)
-}
-
-func (by byNext) Less(i int, j int) bool {
-	return by[i].Next().Before(by[j].Next())
-}
-
-func (by byNext) Swap(i int, j int) {
-	by[i], by[j] = by[j], by[i]
-}
diff --git a/vendor/codeberg.org/gruf/go-sched/timing.go b/vendor/codeberg.org/gruf/go-sched/timing.go
deleted file mode 100644
index 33c230fa5..000000000
--- a/vendor/codeberg.org/gruf/go-sched/timing.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package sched
-
-import (
-	"time"
-)
-
-var (
-	// zerotime is zero time.Time (unix epoch).
-	zerotime = time.Time{}
-
-	// emptytiming is a global timingempty to check against.
-	emptytiming = timingempty{}
-)
-
-// Timing provides scheduling for a Job, determining the next time
-// for given current time that execution is required. Please note that
-// calls to .Next() may alter the results of the next call, and should
-// only be called by the Scheduler.
-type Timing interface {
-	Next(time.Time) time.Time
-}
-
-// timingempty is a 'zero' Timing implementation that always returns zero time.
-type timingempty struct{}
-
-func (timingempty) Next(time.Time) time.Time {
-	return zerotime
-}
-
-// Once implements Timing to provide a run-once Job execution.
-type Once time.Time
-
-func (o *Once) Next(time.Time) time.Time {
-	ret := *(*time.Time)(o)
-	*o = Once(zerotime) // reset
-	return ret
-}
-
-// Periodic implements Timing to provide a recurring Job execution.
-type Periodic time.Duration
-
-func (p Periodic) Next(now time.Time) time.Time {
-	return now.Add(time.Duration(p))
-}
-
-// PeriodicAt implements Timing to provide a recurring Job execution starting at 'Once' time.
-type PeriodicAt struct {
-	Once   Once
-	Period Periodic
-}
-
-func (p *PeriodicAt) Next(now time.Time) time.Time {
-	if next := p.Once.Next(now); !next.IsZero() {
-		return next
-	}
-	return p.Period.Next(now)
-}
-
-// TimingWrap allows combining two different Timing implementations.
-type TimingWrap struct {
-	Outer Timing
-	Inner Timing
-
-	// determined next times
-	outerNext time.Time
-	innerNext time.Time
-}
-
-func (t *TimingWrap) Next(now time.Time) time.Time {
-	if t.outerNext.IsZero() {
-		// Regenerate outermost next run time
-		t.outerNext = t.Outer.Next(now)
-	}
-
-	if t.innerNext.IsZero() {
-		// Regenerate innermost next run time
-		t.innerNext = t.Inner.Next(now)
-	}
-
-	// If outer comes before inner, return outer
-	if t.outerNext != zerotime &&
-		t.outerNext.Before(t.innerNext) {
-		next := t.outerNext
-		t.outerNext = zerotime
-		return next
-	}
-
-	// Else, return inner
-	next := t.innerNext
-	t.innerNext = zerotime
-	return next
-}