5 files changed, 0 insertions, 387 deletions
diff --git a/vendor/codeberg.org/gruf/go-nowish/LICENSE b/vendor/codeberg.org/gruf/go-nowish/LICENSE
deleted file mode 100644
index b7c4417ac..000000000
--- a/vendor/codeberg.org/gruf/go-nowish/LICENSE
+++ /dev/null
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2021 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-nowish/README.md b/vendor/codeberg.org/gruf/go-nowish/README.md
deleted file mode 100644
index 4070e5013..000000000
--- a/vendor/codeberg.org/gruf/go-nowish/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-a simple Go library with useful time utiities:
-- Clock: a high performance clock giving a good "ish" representation of "now" (hence the name!)
-- Timeout: a reusable structure for enforcing timeouts with a cancel
diff --git a/vendor/codeberg.org/gruf/go-nowish/clock.go b/vendor/codeberg.org/gruf/go-nowish/clock.go
deleted file mode 100644
index 781e59f18..000000000
--- a/vendor/codeberg.org/gruf/go-nowish/clock.go
+++ /dev/null
@@ -1,132 +0,0 @@
-package nowish
-
-import (
-	"sync"
-	"sync/atomic"
-	"time"
-	"unsafe"
-)
-
-// Start returns a new Clock instance initialized and
-// started with the provided precision, along with the
-// stop function for it's underlying timer
-func Start(precision time.Duration) (*Clock, func()) {
-	c := Clock{}
-	return &c, c.Start(precision)
-}
-
-type Clock struct {
-	// format stores the time formatting style string
-	format string
-
-	// valid indicates whether the current value stored in .Format is valid
-	valid uint32
-
-	// mutex protects writes to .Format, not because it would be unsafe, but
-	// because we want to minimize unnnecessary allocations
-	mutex sync.Mutex
-
-	// nowfmt is an unsafe pointer to the last-updated time format string
-	nowfmt unsafe.Pointer
-
-	// now is an unsafe pointer to the last-updated time.Time object
-	now unsafe.Pointer
-}
-
-// Start starts the clock with the provided precision, the returned
-// function is the stop function for the underlying timer. For >= 2ms,
-// actual precision is usually within AT LEAST 10% of requested precision,
-// less than this and the actual precision very quickly deteriorates.
-func (c *Clock) Start(precision time.Duration) func() {
-	// Create ticker from duration
-	tick := time.NewTicker(precision / 10)
-
-	// Set initial time
-	t := time.Now()
-	atomic.StorePointer(&c.now, unsafe.Pointer(&t))
-
-	// Set initial format
-	s := ""
-	atomic.StorePointer(&c.nowfmt, unsafe.Pointer(&s))
-
-	// If formatting string unset, set default
-	c.mutex.Lock()
-	if c.format == "" {
-		c.format = time.RFC822
-	}
-	c.mutex.Unlock()
-
-	// Start main routine
-	go c.run(tick)
-
-	// Return stop fn
-	return tick.Stop
-}
-
-// run is the internal clock ticking loop.
-func (c *Clock) run(tick *time.Ticker) {
-	for {
-		// Wait on tick
-		_, ok := <-tick.C
-
-		// Channel closed
-		if !ok {
-			break
-		}
-
-		// Update time
-		t := time.Now()
-		atomic.StorePointer(&c.now, unsafe.Pointer(&t))
-
-		// Invalidate format string
-		atomic.StoreUint32(&c.valid, 0)
-	}
-}
-
-// Now returns a good (ish) estimate of the current 'now' time.
-func (c *Clock) Now() time.Time {
-	return *(*time.Time)(atomic.LoadPointer(&c.now))
-}
-
-// NowFormat returns the formatted "now" time, cached until next tick and "now" updates.
-func (c *Clock) NowFormat() string {
-	// If format still valid, return this
-	if atomic.LoadUint32(&c.valid) == 1 {
-		return *(*string)(atomic.LoadPointer(&c.nowfmt))
-	}
-
-	// Get mutex lock
-	c.mutex.Lock()
-
-	// Double check still invalid
-	if atomic.LoadUint32(&c.valid) == 1 {
-		c.mutex.Unlock()
-		return *(*string)(atomic.LoadPointer(&c.nowfmt))
-	}
-
-	// Calculate time format
-	nowfmt := c.Now().Format(c.format)
-
-	// Update the stored value and set valid!
-	atomic.StorePointer(&c.nowfmt, unsafe.Pointer(&nowfmt))
-	atomic.StoreUint32(&c.valid, 1)
-
-	// Unlock and return
-	c.mutex.Unlock()
-	return nowfmt
-}
-
-// SetFormat sets the time format string used by .NowFormat().
-func (c *Clock) SetFormat(format string) {
-	// Get mutex lock
-	c.mutex.Lock()
-
-	// Update time format
-	c.format = format
-
-	// Invalidate current format string
-	atomic.StoreUint32(&c.valid, 0)
-
-	// Unlock
-	c.mutex.Unlock()
-}
diff --git a/vendor/codeberg.org/gruf/go-nowish/timeout.go b/vendor/codeberg.org/gruf/go-nowish/timeout.go
deleted file mode 100644
index 7fe3e1d1d..000000000
--- a/vendor/codeberg.org/gruf/go-nowish/timeout.go
+++ /dev/null
@@ -1,233 +0,0 @@
-package nowish
-
-import (
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// Timeout provides a reusable structure for enforcing timeouts with a cancel.
-type Timeout struct {
-	timer *time.Timer // timer is the underlying timeout-timer
-	cncl  syncer      // cncl is the cancel synchronization channel
-	next  int64       // next is the next timeout duration to run on
-	state uint32      // state stores the current timeout state
-	mu    sync.Mutex  // mu protects state, and helps synchronize return of .Start()
-}
-
-// NewTimeout returns a new Timeout instance.
-func NewTimeout() Timeout {
-	timer := time.NewTimer(time.Minute)
-	timer.Stop() // don't keep it running
-	return Timeout{
-		timer: timer,
-		cncl:  make(syncer),
-	}
-}
-
-// startTimeout is the main timeout routine, handling starting the
-// timeout runner at first and upon any time extensions, and handling
-// any received cancels by stopping the running timer.
-func (t *Timeout) startTimeout(hook func()) {
-	var cancelled bool
-
-	// Receive first timeout duration
-	d := atomic.SwapInt64(&t.next, 0)
-
-	// Indicate finished starting, this
-	// was left locked by t.start().
-	t.mu.Unlock()
-
-	for {
-		// Run supplied timeout
-		cancelled = t.runTimeout(d)
-		if cancelled {
-			break
-		}
-
-		// Check for extension or set timed out
-		d = atomic.SwapInt64(&t.next, 0)
-		if d < 1 {
-			if t.timedOut() {
-				// timeout reached
-				hook()
-				break
-			} else {
-				// already cancelled
-				t.cncl.wait()
-				cancelled = true
-				break
-			}
-		}
-
-		if !t.extend() {
-			// already cancelled
-			t.cncl.wait()
-			cancelled = true
-			break
-		}
-	}
-
-	if cancelled {
-		// Release the .Cancel()
-		defer t.cncl.notify()
-	}
-
-	// Mark as done
-	t.reset()
-}
-
-// runTimeout will until supplied timeout or cancel called.
-func (t *Timeout) runTimeout(d int64) (cancelled bool) {
-	// Start the timer for 'd'
-	t.timer.Reset(time.Duration(d))
-
-	select {
-	// Timeout reached
-	case <-t.timer.C:
-		if !t.timingOut() {
-			// a sneaky cancel!
-			t.cncl.wait()
-			cancelled = true
-		}
-
-	// Cancel called
-	case <-t.cncl.wait():
-		cancelled = true
-		if !t.timer.Stop() {
-			<-t.timer.C
-		}
-	}
-
-	return cancelled
-}
-
-// Start starts the timer with supplied timeout. If timeout is reached before
-// cancel then supplied timeout hook will be called. Panic will be called if
-// Timeout is already running when calling this function.
-func (t *Timeout) Start(d time.Duration, hook func()) {
-	if !t.start() {
-		t.mu.Unlock() // need to unlock
-		panic("timeout already started")
-	}
-
-	// Start the timeout
-	atomic.StoreInt64(&t.next, int64(d))
-	go t.startTimeout(hook)
-
-	// Wait until start
-	t.mu.Lock()
-	t.mu.Unlock()
-}
-
-// Extend will attempt to extend the timeout runner's time, returns false if not running.
-func (t *Timeout) Extend(d time.Duration) bool {
-	var ok bool
-	if ok = t.running(); ok {
-		atomic.AddInt64(&t.next, int64(d))
-	}
-	return ok
-}
-
-// Cancel cancels the currently running timer. If a cancel is achieved, then
-// this function will return after the timeout goroutine is finished.
-func (t *Timeout) Cancel() {
-	if !t.cancel() {
-		return
-	}
-	t.cncl.notify()
-	<-t.cncl.wait()
-}
-
-// possible timeout states.
-const (
-	stopped   = 0
-	started   = 1
-	timingOut = 2
-	cancelled = 3
-	timedOut  = 4
-)
-
-// cas will perform a compare and swap where the compare is a provided function.
-func (t *Timeout) cas(check func(uint32) bool, swap uint32) bool {
-	var cas bool
-
-	t.mu.Lock()
-	if cas = check(t.state); cas {
-		t.state = swap
-	}
-	t.mu.Unlock()
-
-	return cas
-}
-
-// start attempts to mark the timeout state as 'started', note DOES NOT unlock Timeout.mu.
-func (t *Timeout) start() bool {
-	var ok bool
-
-	t.mu.Lock()
-	if ok = (t.state == stopped); ok {
-		t.state = started
-	}
-
-	// don't unlock
-	return ok
-}
-
-// timingOut attempts to mark the timeout state as 'timing out'.
-func (t *Timeout) timingOut() bool {
-	return t.cas(func(u uint32) bool {
-		return (u == started)
-	}, timingOut)
-}
-
-// timedOut attempts mark the 'timing out' state as 'timed out'.
-func (t *Timeout) timedOut() bool {
-	return t.cas(func(u uint32) bool {
-		return (u == timingOut)
-	}, timedOut)
-}
-
-// extend attempts to extend a 'timing out' state by moving it back to 'started'.
-func (t *Timeout) extend() bool {
-	return t.cas(func(u uint32) bool {
-		return (u == started) ||
-			(u == timingOut)
-	}, started)
-}
-
-// running returns whether the state is anything other than 'stopped'.
-func (t *Timeout) running() bool {
-	t.mu.Lock()
-	running := (t.state != stopped)
-	t.mu.Unlock()
-	return running
-}
-
-// cancel attempts to mark the timeout state as 'cancelled'.
-func (t *Timeout) cancel() bool {
-	return t.cas(func(u uint32) bool {
-		return (u == started) ||
-			(u == timingOut)
-	}, cancelled)
-}
-
-// reset marks the timeout state as 'stopped'.
-func (t *Timeout) reset() {
-	t.mu.Lock()
-	t.state = stopped
-	t.mu.Unlock()
-}
-
-// syncer provides helpful receiver methods for a synchronization channel.
-type syncer (chan struct{})
-
-// notify blocks on sending an empty value down channel.
-func (s syncer) notify() {
-	s <- struct{}{}
-}
-
-// wait returns the underlying channel for blocking until '.notify()'.
-func (s syncer) wait() <-chan struct{} {
-	return s
-}
diff --git a/vendor/codeberg.org/gruf/go-nowish/util.go b/vendor/codeberg.org/gruf/go-nowish/util.go
deleted file mode 100644
index 31fe9050e..000000000
--- a/vendor/codeberg.org/gruf/go-nowish/util.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package nowish
-
-//nolint
-type noCopy struct{}
-
-//nolint
-func (*noCopy) Lock() {}
-
-//nolint
-func (*noCopy) Unlock() {}