mirror of
https://github.com/containers/podman.git
synced 2025-06-10 09:47:25 +08:00
89a1e7db39
This code will run container operations in parallel, up to a given maximum number of threads. Currently, it has only been enabled for local `podman rm` as a proof of concept. Signed-off-by: Matthew Heon <matthew.heon@pm.me>
58 lines
1.4 KiB
Go
58 lines
1.4 KiB
Go
package parallel
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"github.com/containers/libpod/libpod"
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// ParallelContainerOp performs the given function on the given set of
|
|
// containers, using a number of parallel threads.
|
|
// If no error is returned, each container specified in ctrs will have an entry
|
|
// in the resulting map; containers with no error will be set to nil.
|
|
func ParallelContainerOp(ctx context.Context, ctrs []*libpod.Container, applyFunc func(*libpod.Container) error) (map[*libpod.Container]error, error) {
|
|
jobControlLock.RLock()
|
|
defer jobControlLock.RUnlock()
|
|
|
|
// We could use a sync.Map but given Go's lack of generic I'd rather
|
|
// just use a lock on a normal map...
|
|
// The expectation is that most of the time is spent in applyFunc
|
|
// anyways.
|
|
var (
|
|
errMap map[*libpod.Container]error = make(map[*libpod.Container]error)
|
|
errLock sync.Mutex
|
|
allDone sync.WaitGroup
|
|
)
|
|
|
|
for _, ctr := range ctrs {
|
|
// Block until a thread is available
|
|
if err := jobControl.Acquire(ctx, 1); err != nil {
|
|
return nil, errors.Wrapf(err, "error acquiring job control semaphore")
|
|
}
|
|
|
|
allDone.Add(1)
|
|
|
|
c := ctr
|
|
go func() {
|
|
logrus.Debugf("Launching job on container %s", c.ID())
|
|
|
|
err := applyFunc(c)
|
|
errLock.Lock()
|
|
errMap[c] = err
|
|
errLock.Unlock()
|
|
|
|
allDone.Done()
|
|
jobControl.Release(1)
|
|
}()
|
|
}
|
|
|
|
allDone.Wait()
|
|
|
|
return errMap, nil
|
|
}
|
|
|
|
// TODO: Add an Enqueue() function that returns a promise
|