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 }