func (scanner *resourceScanner) scan(
logger lager.Logger,
resourceConfig atc.ResourceConfig,
resourceTypes atc.ResourceTypes,
savedResource db.SavedResource,
fromVersion atc.Version,
) error {
pipelinePaused, err := scanner.db.IsPaused()
if err != nil {
logger.Error("failed-to-check-if-pipeline-paused", err)
return err
}
if pipelinePaused {
logger.Debug("pipeline-paused")
return nil
}
if savedResource.Paused {
logger.Debug("resource-paused")
return nil
}
pipelineID := scanner.db.GetPipelineID()
var resourceTypeVersion atc.Version
_, found := resourceTypes.Lookup(resourceConfig.Type)
if found {
savedResourceType, resourceTypeFound, err := scanner.db.GetResourceType(resourceConfig.Type)
if err != nil {
logger.Error("failed-to-find-resource-type", err)
return err
}
if resourceTypeFound {
resourceTypeVersion = atc.Version(savedResourceType.Version)
}
}
session := resource.Session{
ID: worker.Identifier{
ResourceTypeVersion: resourceTypeVersion,
ResourceID: savedResource.ID,
Stage: db.ContainerStageRun,
CheckType: resourceConfig.Type,
CheckSource: resourceConfig.Source,
},
Metadata: worker.Metadata{
Type: db.ContainerTypeCheck,
PipelineID: pipelineID,
},
Ephemeral: true,
}
res, err := scanner.tracker.Init(
logger,
resource.TrackerMetadata{
ResourceName: resourceConfig.Name,
PipelineName: savedResource.PipelineName,
ExternalURL: scanner.externalURL,
},
session,
resource.ResourceType(resourceConfig.Type),
[]string{},
resourceTypes,
worker.NoopImageFetchingDelegate{},
)
if err != nil {
logger.Error("failed-to-initialize-new-resource", err)
return err
}
defer res.Release(nil)
logger.Debug("checking", lager.Data{
"from": fromVersion,
})
newVersions, err := res.Check(resourceConfig.Source, fromVersion)
setErr := scanner.db.SetResourceCheckError(savedResource, err)
if setErr != nil {
logger.Error("failed-to-set-check-error", err)
}
if err != nil {
if rErr, ok := err.(resource.ErrResourceScriptFailed); ok {
logger.Info("check-failed", lager.Data{"exit-status": rErr.ExitStatus})
return rErr
}
logger.Error("failed-to-check", err)
return err
}
if len(newVersions) == 0 {
logger.Debug("no-new-versions")
return nil
}
logger.Info("versions-found", lager.Data{
"versions": newVersions,
"total": len(newVersions),
})
err = scanner.db.SaveResourceVersions(resourceConfig, newVersions)
if err != nil {
logger.Error("failed-to-save-versions", err, lager.Data{
"versions": newVersions,
})
}
return nil
}
func (factory *gardenContainerSpecFactory) BuildContainerSpec(
spec ContainerSpec,
resourceTypes []atc.WorkerResourceType,
cancel <-chan os.Signal,
delegate ImageFetchingDelegate,
id Identifier,
metadata Metadata,
workerClient Client,
customTypes atc.ResourceTypes,
) (garden.ContainerSpec, error) {
var err error
resourceTypeContainerSpec, ok := spec.(ResourceTypeContainerSpec)
if ok {
customType, found := lookupCustomType(resourceTypeContainerSpec.Type, customTypes)
if found {
customTypes = customTypes.Without(resourceTypeContainerSpec.Type)
resourceTypeContainerSpec.ImageResourcePointer = &atc.TaskImageConfig{
Source: customType.Source,
Type: customType.Type,
}
spec = resourceTypeContainerSpec
}
}
imageResourceConfig, hasImageResource := spec.ImageResource()
var gardenSpec garden.ContainerSpec
if hasImageResource {
image, err := factory.imageFetcher.FetchImage(
factory.logger,
imageResourceConfig,
cancel,
id,
metadata,
delegate,
workerClient,
customTypes,
)
if err != nil {
return garden.ContainerSpec{}, err
}
imageVolume := image.Volume()
factory.volumeHandles = append(factory.volumeHandles, imageVolume.Handle())
factory.releaseAfterCreate = append(factory.releaseAfterCreate, image)
factory.user = image.Metadata().User
gardenSpec = garden.ContainerSpec{
Properties: garden.Properties{},
RootFSPath: path.Join(imageVolume.Path(), "rootfs"),
Env: image.Metadata().Env,
}
} else {
gardenSpec = garden.ContainerSpec{
Properties: garden.Properties{},
}
}
switch s := spec.(type) {
case ResourceTypeContainerSpec:
gardenSpec, err = factory.BuildResourceContainerSpec(s, gardenSpec, resourceTypes)
case TaskContainerSpec:
gardenSpec, err = factory.BuildTaskContainerSpec(s, gardenSpec, cancel, delegate, id, metadata, workerClient)
default:
return garden.ContainerSpec{}, fmt.Errorf("unknown container spec type: %T (%#v)", s, s)
}
if err != nil {
return garden.ContainerSpec{}, err
}
if len(factory.volumeHandles) > 0 {
volumesJSON, err := json.Marshal(factory.volumeHandles)
if err != nil {
return garden.ContainerSpec{}, err
}
gardenSpec.Properties[volumePropertyName] = string(volumesJSON)
mountsJSON, err := json.Marshal(factory.volumeMounts)
if err != nil {
return garden.ContainerSpec{}, err
}
gardenSpec.Properties[volumeMountsPropertyName] = string(mountsJSON)
}
gardenSpec.Properties["user"] = factory.user
return gardenSpec, nil
}