mirror of
https://github.com/argoproj/argo-cd
synced 2026-05-24 09:50:08 +00:00
106 lines
3.4 KiB
Go
106 lines
3.4 KiB
Go
// The MIT License (MIT)
|
|
|
|
// Copyright (c) 2018 Rémy Mathieu
|
|
|
|
// 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.
|
|
// https://github.com/remeh/sizedwaitgroup
|
|
|
|
// Based upon sync.WaitGroup, SizedWaitGroup allows to start multiple
|
|
// routines and to wait for their end using the simple API.
|
|
|
|
// Package util SizedWaitGroup adds the feature of limiting the maximum number of
|
|
// concurrently started routines. It could for example be used to start
|
|
// multiples routines querying a database but without sending too much
|
|
// queries in order to not overload the given database.
|
|
//
|
|
// Rémy Mathieu © 2016
|
|
package util
|
|
|
|
import (
|
|
"context"
|
|
"math"
|
|
"sync"
|
|
)
|
|
|
|
// SizedWaitGroup has the same role and close to the
|
|
// same API as the Golang sync.WaitGroup but adds a limit of
|
|
// the amount of goroutines started concurrently.
|
|
type SizedWaitGroup struct {
|
|
Size int
|
|
|
|
current chan struct{}
|
|
wg sync.WaitGroup
|
|
}
|
|
|
|
// New creates a SizedWaitGroup.
|
|
// The limit parameter is the maximum amount of
|
|
// goroutines which can be started concurrently.
|
|
func New(limit int) SizedWaitGroup {
|
|
size := math.MaxInt32 // 2^31 - 1
|
|
if limit > 0 {
|
|
size = limit
|
|
}
|
|
return SizedWaitGroup{
|
|
Size: size,
|
|
|
|
current: make(chan struct{}, size),
|
|
wg: sync.WaitGroup{},
|
|
}
|
|
}
|
|
|
|
// Add increments the internal WaitGroup counter.
|
|
// It can be blocking if the limit of spawned goroutines
|
|
// has been reached. It will stop blocking when Done is
|
|
// been called.
|
|
//
|
|
// See sync.WaitGroup documentation for more information.
|
|
func (s *SizedWaitGroup) Add() {
|
|
_ = s.AddWithContext(context.Background())
|
|
}
|
|
|
|
// AddWithContext increments the internal WaitGroup counter.
|
|
// It can be blocking if the limit of spawned goroutines
|
|
// has been reached. It will stop blocking when Done is
|
|
// been called, or when the context is canceled. Returns nil on
|
|
// success or an error if the context is canceled before the lock
|
|
// is acquired.
|
|
//
|
|
// See sync.WaitGroup documentation for more information.
|
|
func (s *SizedWaitGroup) AddWithContext(ctx context.Context) error {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case s.current <- struct{}{}:
|
|
}
|
|
s.wg.Add(1)
|
|
return nil
|
|
}
|
|
|
|
// Done decrements the SizedWaitGroup counter.
|
|
// See sync.WaitGroup documentation for more information.
|
|
func (s *SizedWaitGroup) Done() {
|
|
<-s.current
|
|
s.wg.Done()
|
|
}
|
|
|
|
// Wait blocks until the SizedWaitGroup counter is zero.
|
|
// See sync.WaitGroup documentation for more information.
|
|
func (s *SizedWaitGroup) Wait() {
|
|
s.wg.Wait()
|
|
}
|