func (src *containerSource) VolumeOn(w worker.Worker) (baggageclaim.Volume, bool, error) {
if baggageclaimClient, found := w.VolumeManager(); len(src.volumeHandle) > 0 && found {
volume, found, err := baggageclaimClient.LookupVolume(src.logger, src.volumeHandle)
if err != nil {
return nil, false, err
}
return volume, found, nil
}
return nil, false, nil
}
// VolumeOn locates the cache for the GetStep's resource and version on the
// given worker.
func (step *GetStep) VolumeOn(worker worker.Worker) (baggageclaim.Volume, bool, error) {
vm, hasVM := worker.VolumeManager()
if !hasVM {
return nil, false, nil
}
return step.cacheIdentifier.FindOn(step.logger.Session("volume-on"), vm)
}
func (tracker *tracker) InitWithSources(
logger lager.Logger,
metadata Metadata,
session Session,
typ ResourceType,
tags atc.Tags,
sources map[string]ArtifactSource,
) (Resource, []string, error) {
logger = logger.Session("init-with-sources")
logger.Debug("start")
defer logger.Debug("done")
container, found, err := tracker.workerClient.FindContainerForIdentifier(logger, session.ID)
if err != nil {
logger.Error("failed-to-look-for-existing-container", err)
return nil, nil, err
}
if found {
logger.Debug("found-existing-container", lager.Data{"container": container.Handle()})
missingNames := []string{}
for name, _ := range sources {
missingNames = append(missingNames, name)
}
return NewResource(container), missingNames, nil
}
resourceSpec := worker.ResourceTypeContainerSpec{
Type: string(typ),
Ephemeral: session.Ephemeral,
Tags: tags,
Env: metadata.Env(),
}
compatibleWorkers, err := tracker.workerClient.AllSatisfying(resourceSpec.WorkerSpec())
if err != nil {
return nil, nil, err
}
// find the worker with the most volumes
mounts := []worker.VolumeMount{}
missingSources := []string{}
var chosenWorker worker.Worker
for _, w := range compatibleWorkers {
candidateMounts := []worker.VolumeMount{}
missing := []string{}
for name, source := range sources {
volume, found, err := source.VolumeOn(w)
if err != nil {
return nil, nil, err
}
if found {
candidateMounts = append(candidateMounts, worker.VolumeMount{
Volume: volume,
MountPath: ResourcesDir("put/" + name),
})
} else {
missing = append(missing, name)
}
}
if len(candidateMounts) >= len(mounts) {
for _, mount := range mounts {
mount.Volume.Release(0)
}
mounts = candidateMounts
missingSources = missing
chosenWorker = w
} else {
for _, mount := range candidateMounts {
mount.Volume.Release(0)
}
}
}
resourceSpec.Mounts = mounts
container, err = chosenWorker.CreateContainer(logger, session.ID, resourceSpec)
if err != nil {
logger.Error("failed-to-create-container", err)
return nil, nil, err
}
logger.Info("created", lager.Data{"container": container.Handle()})
for _, mount := range mounts {
mount.Volume.Release(0)
}
return NewResource(container), missingSources, nil
}
func (src *containerSource) VolumeOn(w worker.Worker) (worker.Volume, bool, error) {
return w.LookupVolume(src.logger, src.volumeHandle)
}