mirror of
https://gitea.com/Lydanne/buildx.git
synced 2025-07-10 13:37:08 +08:00
vendor: update buildkit to v0.19.0-rc1
Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>
This commit is contained in:
153
vendor/k8s.io/client-go/util/workqueue/queue.go
generated
vendored
153
vendor/k8s.io/client-go/util/workqueue/queue.go
generated
vendored
@ -23,18 +23,66 @@ import (
|
||||
"k8s.io/utils/clock"
|
||||
)
|
||||
|
||||
type Interface interface {
|
||||
Add(item interface{})
|
||||
// Deprecated: Interface is deprecated, use TypedInterface instead.
|
||||
type Interface TypedInterface[any]
|
||||
|
||||
type TypedInterface[T comparable] interface {
|
||||
Add(item T)
|
||||
Len() int
|
||||
Get() (item interface{}, shutdown bool)
|
||||
Done(item interface{})
|
||||
Get() (item T, shutdown bool)
|
||||
Done(item T)
|
||||
ShutDown()
|
||||
ShutDownWithDrain()
|
||||
ShuttingDown() bool
|
||||
}
|
||||
|
||||
// Queue is the underlying storage for items. The functions below are always
|
||||
// called from the same goroutine.
|
||||
type Queue[T comparable] interface {
|
||||
// Touch can be hooked when an existing item is added again. This may be
|
||||
// useful if the implementation allows priority change for the given item.
|
||||
Touch(item T)
|
||||
// Push adds a new item.
|
||||
Push(item T)
|
||||
// Len tells the total number of items.
|
||||
Len() int
|
||||
// Pop retrieves an item.
|
||||
Pop() (item T)
|
||||
}
|
||||
|
||||
// DefaultQueue is a slice based FIFO queue.
|
||||
func DefaultQueue[T comparable]() Queue[T] {
|
||||
return new(queue[T])
|
||||
}
|
||||
|
||||
// queue is a slice which implements Queue.
|
||||
type queue[T comparable] []T
|
||||
|
||||
func (q *queue[T]) Touch(item T) {}
|
||||
|
||||
func (q *queue[T]) Push(item T) {
|
||||
*q = append(*q, item)
|
||||
}
|
||||
|
||||
func (q *queue[T]) Len() int {
|
||||
return len(*q)
|
||||
}
|
||||
|
||||
func (q *queue[T]) Pop() (item T) {
|
||||
item = (*q)[0]
|
||||
|
||||
// The underlying array still exists and reference this object, so the object will not be garbage collected.
|
||||
(*q)[0] = *new(T)
|
||||
*q = (*q)[1:]
|
||||
|
||||
return item
|
||||
}
|
||||
|
||||
// QueueConfig specifies optional configurations to customize an Interface.
|
||||
type QueueConfig struct {
|
||||
// Deprecated: use TypedQueueConfig instead.
|
||||
type QueueConfig = TypedQueueConfig[any]
|
||||
|
||||
type TypedQueueConfig[T comparable] struct {
|
||||
// Name for the queue. If unnamed, the metrics will not be registered.
|
||||
Name string
|
||||
|
||||
@ -44,18 +92,38 @@ type QueueConfig struct {
|
||||
|
||||
// Clock ability to inject real or fake clock for testing purposes.
|
||||
Clock clock.WithTicker
|
||||
|
||||
// Queue provides the underlying queue to use. It is optional and defaults to slice based FIFO queue.
|
||||
Queue Queue[T]
|
||||
}
|
||||
|
||||
// New constructs a new work queue (see the package comment).
|
||||
//
|
||||
// Deprecated: use NewTyped instead.
|
||||
func New() *Type {
|
||||
return NewWithConfig(QueueConfig{
|
||||
Name: "",
|
||||
})
|
||||
}
|
||||
|
||||
// NewTyped constructs a new work queue (see the package comment).
|
||||
func NewTyped[T comparable]() *Typed[T] {
|
||||
return NewTypedWithConfig(TypedQueueConfig[T]{
|
||||
Name: "",
|
||||
})
|
||||
}
|
||||
|
||||
// NewWithConfig constructs a new workqueue with ability to
|
||||
// customize different properties.
|
||||
//
|
||||
// Deprecated: use NewTypedWithConfig instead.
|
||||
func NewWithConfig(config QueueConfig) *Type {
|
||||
return NewTypedWithConfig(config)
|
||||
}
|
||||
|
||||
// NewTypedWithConfig constructs a new workqueue with ability to
|
||||
// customize different properties.
|
||||
func NewTypedWithConfig[T comparable](config TypedQueueConfig[T]) *Typed[T] {
|
||||
return newQueueWithConfig(config, defaultUnfinishedWorkUpdatePeriod)
|
||||
}
|
||||
|
||||
@ -69,7 +137,7 @@ func NewNamed(name string) *Type {
|
||||
|
||||
// newQueueWithConfig constructs a new named workqueue
|
||||
// with the ability to customize different properties for testing purposes
|
||||
func newQueueWithConfig(config QueueConfig, updatePeriod time.Duration) *Type {
|
||||
func newQueueWithConfig[T comparable](config TypedQueueConfig[T], updatePeriod time.Duration) *Typed[T] {
|
||||
var metricsFactory *queueMetricsFactory
|
||||
if config.MetricsProvider != nil {
|
||||
metricsFactory = &queueMetricsFactory{
|
||||
@ -83,18 +151,24 @@ func newQueueWithConfig(config QueueConfig, updatePeriod time.Duration) *Type {
|
||||
config.Clock = clock.RealClock{}
|
||||
}
|
||||
|
||||
if config.Queue == nil {
|
||||
config.Queue = DefaultQueue[T]()
|
||||
}
|
||||
|
||||
return newQueue(
|
||||
config.Clock,
|
||||
config.Queue,
|
||||
metricsFactory.newQueueMetrics(config.Name, config.Clock),
|
||||
updatePeriod,
|
||||
)
|
||||
}
|
||||
|
||||
func newQueue(c clock.WithTicker, metrics queueMetrics, updatePeriod time.Duration) *Type {
|
||||
t := &Type{
|
||||
func newQueue[T comparable](c clock.WithTicker, queue Queue[T], metrics queueMetrics, updatePeriod time.Duration) *Typed[T] {
|
||||
t := &Typed[T]{
|
||||
clock: c,
|
||||
dirty: set{},
|
||||
processing: set{},
|
||||
queue: queue,
|
||||
dirty: set[T]{},
|
||||
processing: set[T]{},
|
||||
cond: sync.NewCond(&sync.Mutex{}),
|
||||
metrics: metrics,
|
||||
unfinishedWorkUpdatePeriod: updatePeriod,
|
||||
@ -112,20 +186,23 @@ func newQueue(c clock.WithTicker, metrics queueMetrics, updatePeriod time.Durati
|
||||
const defaultUnfinishedWorkUpdatePeriod = 500 * time.Millisecond
|
||||
|
||||
// Type is a work queue (see the package comment).
|
||||
type Type struct {
|
||||
// Deprecated: Use Typed instead.
|
||||
type Type = Typed[any]
|
||||
|
||||
type Typed[t comparable] struct {
|
||||
// queue defines the order in which we will work on items. Every
|
||||
// element of queue should be in the dirty set and not in the
|
||||
// processing set.
|
||||
queue []t
|
||||
queue Queue[t]
|
||||
|
||||
// dirty defines all of the items that need to be processed.
|
||||
dirty set
|
||||
dirty set[t]
|
||||
|
||||
// Things that are currently being processed are in the processing set.
|
||||
// These things may be simultaneously in the dirty set. When we finish
|
||||
// processing something and remove it from this set, we'll check if
|
||||
// it's in the dirty set, and if so, add it to the queue.
|
||||
processing set
|
||||
processing set[t]
|
||||
|
||||
cond *sync.Cond
|
||||
|
||||
@ -140,33 +217,38 @@ type Type struct {
|
||||
|
||||
type empty struct{}
|
||||
type t interface{}
|
||||
type set map[t]empty
|
||||
type set[t comparable] map[t]empty
|
||||
|
||||
func (s set) has(item t) bool {
|
||||
func (s set[t]) has(item t) bool {
|
||||
_, exists := s[item]
|
||||
return exists
|
||||
}
|
||||
|
||||
func (s set) insert(item t) {
|
||||
func (s set[t]) insert(item t) {
|
||||
s[item] = empty{}
|
||||
}
|
||||
|
||||
func (s set) delete(item t) {
|
||||
func (s set[t]) delete(item t) {
|
||||
delete(s, item)
|
||||
}
|
||||
|
||||
func (s set) len() int {
|
||||
func (s set[t]) len() int {
|
||||
return len(s)
|
||||
}
|
||||
|
||||
// Add marks item as needing processing.
|
||||
func (q *Type) Add(item interface{}) {
|
||||
func (q *Typed[T]) Add(item T) {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
if q.shuttingDown {
|
||||
return
|
||||
}
|
||||
if q.dirty.has(item) {
|
||||
// the same item is added again before it is processed, call the Touch
|
||||
// function if the queue cares about it (for e.g, reset its priority)
|
||||
if !q.processing.has(item) {
|
||||
q.queue.Touch(item)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@ -177,37 +259,34 @@ func (q *Type) Add(item interface{}) {
|
||||
return
|
||||
}
|
||||
|
||||
q.queue = append(q.queue, item)
|
||||
q.queue.Push(item)
|
||||
q.cond.Signal()
|
||||
}
|
||||
|
||||
// Len returns the current queue length, for informational purposes only. You
|
||||
// shouldn't e.g. gate a call to Add() or Get() on Len() being a particular
|
||||
// value, that can't be synchronized properly.
|
||||
func (q *Type) Len() int {
|
||||
func (q *Typed[T]) Len() int {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
return len(q.queue)
|
||||
return q.queue.Len()
|
||||
}
|
||||
|
||||
// Get blocks until it can return an item to be processed. If shutdown = true,
|
||||
// the caller should end their goroutine. You must call Done with item when you
|
||||
// have finished processing it.
|
||||
func (q *Type) Get() (item interface{}, shutdown bool) {
|
||||
func (q *Typed[T]) Get() (item T, shutdown bool) {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
for len(q.queue) == 0 && !q.shuttingDown {
|
||||
for q.queue.Len() == 0 && !q.shuttingDown {
|
||||
q.cond.Wait()
|
||||
}
|
||||
if len(q.queue) == 0 {
|
||||
if q.queue.Len() == 0 {
|
||||
// We must be shutting down.
|
||||
return nil, true
|
||||
return *new(T), true
|
||||
}
|
||||
|
||||
item = q.queue[0]
|
||||
// The underlying array still exists and reference this object, so the object will not be garbage collected.
|
||||
q.queue[0] = nil
|
||||
q.queue = q.queue[1:]
|
||||
item = q.queue.Pop()
|
||||
|
||||
q.metrics.get(item)
|
||||
|
||||
@ -220,7 +299,7 @@ func (q *Type) Get() (item interface{}, shutdown bool) {
|
||||
// Done marks item as done processing, and if it has been marked as dirty again
|
||||
// while it was being processed, it will be re-added to the queue for
|
||||
// re-processing.
|
||||
func (q *Type) Done(item interface{}) {
|
||||
func (q *Typed[T]) Done(item T) {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
|
||||
@ -228,7 +307,7 @@ func (q *Type) Done(item interface{}) {
|
||||
|
||||
q.processing.delete(item)
|
||||
if q.dirty.has(item) {
|
||||
q.queue = append(q.queue, item)
|
||||
q.queue.Push(item)
|
||||
q.cond.Signal()
|
||||
} else if q.processing.len() == 0 {
|
||||
q.cond.Signal()
|
||||
@ -237,7 +316,7 @@ func (q *Type) Done(item interface{}) {
|
||||
|
||||
// ShutDown will cause q to ignore all new items added to it and
|
||||
// immediately instruct the worker goroutines to exit.
|
||||
func (q *Type) ShutDown() {
|
||||
func (q *Typed[T]) ShutDown() {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
|
||||
@ -255,7 +334,7 @@ func (q *Type) ShutDown() {
|
||||
// indefinitely. It is, however, safe to call ShutDown after having called
|
||||
// ShutDownWithDrain, as to force the queue shut down to terminate immediately
|
||||
// without waiting for the drainage.
|
||||
func (q *Type) ShutDownWithDrain() {
|
||||
func (q *Typed[T]) ShutDownWithDrain() {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
|
||||
@ -268,14 +347,14 @@ func (q *Type) ShutDownWithDrain() {
|
||||
}
|
||||
}
|
||||
|
||||
func (q *Type) ShuttingDown() bool {
|
||||
func (q *Typed[T]) ShuttingDown() bool {
|
||||
q.cond.L.Lock()
|
||||
defer q.cond.L.Unlock()
|
||||
|
||||
return q.shuttingDown
|
||||
}
|
||||
|
||||
func (q *Type) updateUnfinishedWorkLoop() {
|
||||
func (q *Typed[T]) updateUnfinishedWorkLoop() {
|
||||
t := q.clock.NewTicker(q.unfinishedWorkUpdatePeriod)
|
||||
defer t.Stop()
|
||||
for range t.C() {
|
||||
|
Reference in New Issue
Block a user