Merge branch 'master' into issue/3872

Signed-off-by: Jamie Klassen <cklassen@pivotal.io>

atc/api/builds_test.go

@@ -1339,8 +1339,21 @@ var _ = Describe("Builds API", func() {
 							BeforeEach(func() {
 								fakeJob.PublicReturns(true)
 							})
-							It("returns 200", func() {
+							Context("and the build has a plan", func() {
-								Expect(response.StatusCode).To(Equal(http.StatusOK))
+								BeforeEach(func() {
+									build.HasPlanReturns(true)
+								})
+								It("returns 200", func() {
+									Expect(response.StatusCode).To(Equal(http.StatusOK))
+								})
+							})
+							Context("and the build has no plan", func() {
+								BeforeEach(func() {
+									build.HasPlanReturns(false)
+								})
+								It("returns 404", func() {
+									Expect(response.StatusCode).To(Equal(http.StatusNotFound))
+								})
 							})
 						})
 
@@ -1364,6 +1377,7 @@ var _ = Describe("Builds API", func() {
 
 				Context("when the build returns a plan", func() {
 					BeforeEach(func() {
+						build.HasPlanReturns(true)
 						build.PublicPlanReturns(plan)
 						build.SchemaReturns("some-schema")
 					})
@@ -1386,6 +1400,20 @@ var _ = Describe("Builds API", func() {
 					}`))
 					})
 				})
+
+				Context("when the build has no plan", func() {
+					BeforeEach(func() {
+						build.HasPlanReturns(false)
+					})
+
+					It("returns no Content-Type header", func() {
+						Expect(response.Header.Get("Content-Type")).To(Equal(""))
+					})
+
+					It("returns not found", func() {
+						Expect(response.StatusCode).To(Equal(http.StatusNotFound))
+					})
+				})
 			})
 		})
 

atc/api/buildserver/plan.go

@@ -12,6 +12,10 @@ func (s *Server) GetBuildPlan(build db.Build) http.Handler {
 	hLog := s.logger.Session("get-build-plan")
 
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if !build.HasPlan() {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
 		w.Header().Set("Content-Type", "application/json")
 		err := json.NewEncoder(w).Encode(atc.PublicBuildPlan{
 			Schema: build.Schema(),

atc/api/containers_test.go

@@ -362,7 +362,7 @@ var _ = Describe("Containers API", func() {
 					_, err := client.Do(req)
 					Expect(err).NotTo(HaveOccurred())
 
-					_, pipelineName, resourceName, secretManager := dbTeam.FindCheckContainersArgsForCall(0)
+					pipelineName, resourceName, secretManager := dbTeam.FindCheckContainersArgsForCall(0)
 					Expect(pipelineName).To(Equal("some-pipeline"))
 					Expect(resourceName).To(Equal("some-resource"))
 					Expect(secretManager).To(Equal(fakeSecretManager))

atc/api/containerserver/list.go

@@ -32,7 +32,7 @@ func (s *Server) ListContainers(team db.Team) http.Handler {
 
 		hLog.Debug("listing-containers")
 
-		containers, checkContainersExpiresAt, err := containerLocator.Locate(hLog)
+		containers, checkContainersExpiresAt, err := containerLocator.Locate()
 		if err != nil {
 			hLog.Error("failed-to-find-containers", err)
 			w.WriteHeader(http.StatusInternalServerError)
@@ -56,7 +56,7 @@ func (s *Server) ListContainers(team db.Team) http.Handler {
 }
 
 type containerLocator interface {
-	Locate(logger lager.Logger) ([]db.Container, map[int]time.Time, error)
+	Locate() ([]db.Container, map[int]time.Time, error)
 }
 
 func createContainerLocatorFromRequest(team db.Team, r *http.Request, secretManager creds.Secrets) (containerLocator, error) {
@@ -126,8 +126,8 @@ type allContainersLocator struct {
 	team db.Team
 }
 
-func (l *allContainersLocator) Locate(logger lager.Logger) ([]db.Container, map[int]time.Time, error) {
+func (l *allContainersLocator) Locate() ([]db.Container, map[int]time.Time, error) {
-	containers, err := l.team.Containers(logger)
+	containers, err := l.team.Containers()
 	return containers, nil, err
 }
 
@@ -138,8 +138,8 @@ type checkContainerLocator struct {
 	secretManager creds.Secrets
 }
 
-func (l *checkContainerLocator) Locate(logger lager.Logger) ([]db.Container, map[int]time.Time, error) {
+func (l *checkContainerLocator) Locate() ([]db.Container, map[int]time.Time, error) {
-	return l.team.FindCheckContainers(logger, l.pipelineName, l.resourceName, l.secretManager)
+	return l.team.FindCheckContainers(l.pipelineName, l.resourceName, l.secretManager)
 }
 
 type stepContainerLocator struct {
@@ -147,7 +147,7 @@ type stepContainerLocator struct {
 	metadata db.ContainerMetadata
 }
 
-func (l *stepContainerLocator) Locate(logger lager.Logger) ([]db.Container, map[int]time.Time, error) {
+func (l *stepContainerLocator) Locate() ([]db.Container, map[int]time.Time, error) {
 	containers, err := l.team.FindContainersByMetadata(l.metadata)
 	return containers, nil, err
 }

atc/atccmd/command.go

@@ -48,7 +48,6 @@ import (
 	"github.com/concourse/concourse/skymarshal/skycmd"
 	"github.com/concourse/concourse/skymarshal/storage"
 	"github.com/concourse/concourse/web"
-	"github.com/concourse/concourse/web/indexhandler"
 	"github.com/concourse/flag"
 	"github.com/concourse/retryhttp"
 	"github.com/cppforlife/go-semi-semantic/version"
@@ -562,7 +561,7 @@ func (cmd *RunCommand) constructAPIMembers(
 		cmd.BaggageclaimResponseHeaderTimeout,
 	)
 
-	pool := worker.NewPool(workerProvider)
+	pool := worker.NewPool(clock.NewClock(), lockFactory, workerProvider)
 	workerClient := worker.NewClient(pool, workerProvider)
 
 	checkContainerStrategy := worker.NewRandomPlacementStrategy()
@@ -611,7 +610,6 @@ func (cmd *RunCommand) constructAPIMembers(
 		return nil, err
 	}
 
-	indexhandler.ClusterName = cmd.Server.ClusterName
 	webHandler, err := webHandler(logger)
 	if err != nil {
 		return nil, err
@@ -741,7 +739,7 @@ func (cmd *RunCommand) constructBackendMembers(
 		cmd.BaggageclaimResponseHeaderTimeout,
 	)
 
-	pool := worker.NewPool(workerProvider)
+	pool := worker.NewPool(clock.NewClock(), lockFactory, workerProvider)
 	workerClient := worker.NewClient(pool, workerProvider)
 
 	defaultLimits, err := cmd.parseDefaultLimits()

atc/builds/tracker.go

@@ -43,8 +43,8 @@ func (bt *Tracker) Track() {
 			"job":      build.JobName(),
 		})
 
-		engineBuild := bt.engine.LookupBuild(btLog, build)
+		engineBuild := bt.engine.NewBuild(build)
-		go engineBuild.Resume(btLog)
+		go engineBuild.Run(btLog)
 	}
 }
 

atc/builds/tracker_test.go

@@ -1,7 +1,6 @@
 package builds_test
 
 import (
-	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -37,7 +36,7 @@ var _ = Describe("Tracker", func() {
 
 	Describe("Track", func() {
 		var inFlightBuilds []*dbfakes.FakeBuild
-		var engineBuilds []*enginefakes.FakeBuild
+		var engineBuilds []*enginefakes.FakeRunnable
 
 		BeforeEach(func() {
 			inFlightBuilds = []*dbfakes.FakeBuild{
@@ -53,9 +52,9 @@ var _ = Describe("Tracker", func() {
 
 			fakeBuildFactory.GetAllStartedBuildsReturns(returnedBuilds, nil)
 
-			engineBuilds = []*enginefakes.FakeBuild{}
+			engineBuilds = []*enginefakes.FakeRunnable{}
-			fakeEngine.LookupBuildStub = func(logger lager.Logger, build db.Build) engine.Build {
+			fakeEngine.NewBuildStub = func(build db.Build) engine.Runnable {
-				engineBuild := new(enginefakes.FakeBuild)
+				engineBuild := new(enginefakes.FakeRunnable)
 				engineBuilds = append(engineBuilds, engineBuild)
 				return engineBuild
 			}
@@ -64,9 +63,9 @@ var _ = Describe("Tracker", func() {
 		It("resumes all currently in-flight builds", func() {
 			tracker.Track()
 
-			Eventually(engineBuilds[0].ResumeCallCount).Should(Equal(1))
+			Eventually(engineBuilds[0].RunCallCount).Should(Equal(1))
-			Eventually(engineBuilds[1].ResumeCallCount).Should(Equal(1))
+			Eventually(engineBuilds[1].RunCallCount).Should(Equal(1))
-			Eventually(engineBuilds[2].ResumeCallCount).Should(Equal(1))
+			Eventually(engineBuilds[2].RunCallCount).Should(Equal(1))
 		})
 	})
 

atc/creds/versioned_resource_type.go

@@ -43,3 +43,24 @@ func (types VersionedResourceTypes) Without(name string) VersionedResourceTypes
 
 	return newTypes
 }
+
+func (types VersionedResourceTypes) Evaluate() (atc.VersionedResourceTypes, error) {
+
+	var rawTypes atc.VersionedResourceTypes
+	for _, t := range types {
+		source, err := t.Source.Evaluate()
+		if err != nil {
+			return nil, err
+		}
+
+		resourceType := t.ResourceType
+		resourceType.Source = source
+
+		rawTypes = append(rawTypes, atc.VersionedResourceType{
+			ResourceType: resourceType,
+			Version:      t.Version,
+		})
+	}
+
+	return rawTypes, nil
+}

atc/db/build.go

@@ -11,7 +11,6 @@ import (
 	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/encryption"
 	"github.com/concourse/concourse/atc/db/lock"
 	"github.com/concourse/concourse/atc/event"
@@ -67,6 +66,7 @@ type Build interface {
 	Schema() string
 	PrivatePlan() atc.Plan
 	PublicPlan() *json.RawMessage
+	HasPlan() bool
 	Status() BuildStatus
 	StartTime() time.Time
 	CreateTime() time.Time
@@ -95,7 +95,7 @@ type Build interface {
 	Artifacts() ([]WorkerArtifact, error)
 	Artifact(artifactID int) (WorkerArtifact, error)
 
-	SaveOutput(lager.Logger, string, atc.Source, creds.VersionedResourceTypes, atc.Version, ResourceConfigMetadataFields, string, string) error
+	SaveOutput(string, atc.Source, atc.VersionedResourceTypes, atc.Version, ResourceConfigMetadataFields, string, string) error
 	UseInputs(inputs []BuildInput) error
 
 	Resources() ([]BuildInput, []BuildOutput, error)
@@ -170,6 +170,7 @@ func (b *build) IsManuallyTriggered() bool    { return b.isManuallyTriggered }
 func (b *build) Schema() string               { return b.schema }
 func (b *build) PrivatePlan() atc.Plan        { return b.privatePlan }
 func (b *build) PublicPlan() *json.RawMessage { return b.publicPlan }
+func (b *build) HasPlan() bool                { return string(*b.publicPlan) != "{}" }
 func (b *build) CreateTime() time.Time        { return b.createTime }
 func (b *build) StartTime() time.Time         { return b.startTime }
 func (b *build) EndTime() time.Time           { return b.endTime }
@@ -634,9 +635,29 @@ func (b *build) Preparation() (BuildPreparation, bool, error) {
 	missingInputReasons := MissingInputReasons{}
 
 	if found {
+
 		inputsSatisfiedStatus = BuildPreparationStatusNotBlocking
-		for _, buildInput := range nextBuildInputs {
+
-			inputs[buildInput.Name] = BuildPreparationStatusNotBlocking
+		if b.IsManuallyTriggered() {
+			for _, buildInput := range nextBuildInputs {
+				resource, _, err := pipeline.ResourceByID(buildInput.ResourceID)
+				if err != nil {
+					return BuildPreparation{}, false, err
+				}
+
+				// input is blocking if its last check time is before build create time
+				if resource.LastCheckEndTime().Before(b.CreateTime()) {
+					inputs[buildInput.Name] = BuildPreparationStatusBlocking
+					missingInputReasons.RegisterNoResourceCheckFinished(buildInput.Name)
+					inputsSatisfiedStatus = BuildPreparationStatusBlocking
+				} else {
+					inputs[buildInput.Name] = BuildPreparationStatusNotBlocking
+				}
+			}
+		} else {
+			for _, buildInput := range nextBuildInputs {
+				inputs[buildInput.Name] = BuildPreparationStatusNotBlocking
+			}
 		}
 	} else {
 		buildInputs, err := job.GetIndependentBuildInputs()
@@ -808,10 +829,9 @@ func (b *build) Artifacts() ([]WorkerArtifact, error) {
 }
 
 func (b *build) SaveOutput(
-	logger lager.Logger,
 	resourceType string,
 	source atc.Source,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 	version atc.Version,
 	metadata ResourceConfigMetadataFields,
 	outputName string,
@@ -854,7 +874,7 @@ func (b *build) SaveOutput(
 		return err
 	}
 
-	resourceConfig, err := resourceConfigDescriptor.findOrCreate(logger, tx, b.lockFactory, b.conn)
+	resourceConfig, err := resourceConfigDescriptor.findOrCreate(tx, b.lockFactory, b.conn)
 	if err != nil {
 		return err
 	}

atc/db/build_preparation.go

@@ -15,6 +15,7 @@ type MissingInputReasons map[string]string
 const (
 	NoVersionsSatisfiedPassedConstraints string = "no versions satisfy passed constraints"
 	NoVersionsAvailable                  string = "no versions available"
+	NoResourceCheckFinished              string = "checking for latest available versions"
 	PinnedVersionUnavailable             string = "pinned version %s is not available"
 )
 
@@ -26,6 +27,10 @@ func (mir MissingInputReasons) RegisterNoVersions(inputName string) {
 	mir[inputName] = NoVersionsAvailable
 }
 
+func (mir MissingInputReasons) RegisterNoResourceCheckFinished(inputName string) {
+	mir[inputName] = NoResourceCheckFinished
+}
+
 func (mir MissingInputReasons) RegisterPinnedVersionUnavailable(inputName string, version string) {
 	mir[inputName] = fmt.Sprintf(PinnedVersionUnavailable, version)
 }

atc/db/build_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 	"github.com/concourse/concourse/atc/event"
@@ -24,6 +23,13 @@ var _ = Describe("Build", func() {
 		Expect(err).ToNot(HaveOccurred())
 	})
 
+	It("has no plan on creation", func() {
+		var err error
+		build, err := team.CreateOneOffBuild()
+		Expect(err).ToNot(HaveOccurred())
+		Expect(build.HasPlan()).To(BeFalse())
+	})
+
 	Describe("Reload", func() {
 		It("updates the model", func() {
 			build, err := team.CreateOneOffBuild()
@@ -157,6 +163,7 @@ var _ = Describe("Build", func() {
 				found, err := build.Reload()
 				Expect(err).NotTo(HaveOccurred())
 				Expect(found).To(BeTrue())
+				Expect(build.HasPlan()).To(BeTrue())
 				Expect(build.PublicPlan()).To(Equal(plan.Public()))
 			})
 		})
@@ -407,7 +414,7 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "explicit-source"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "explicit-source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 		})
 
@@ -416,7 +423,7 @@ var _ = Describe("Build", func() {
 				build, err := job.CreateBuild()
 				Expect(err).ToNot(HaveOccurred())
 
-				err = build.SaveOutput(logger, "some-type", atc.Source{"some": "explicit-source"}, creds.VersionedResourceTypes{}, atc.Version{"some": "version"}, []db.ResourceConfigMetadataField{
+				err = build.SaveOutput("some-type", atc.Source{"some": "explicit-source"}, atc.VersionedResourceTypes{}, atc.Version{"some": "version"}, []db.ResourceConfigMetadataField{
 					{
 						Name:  "meta1",
 						Value: "data1",
@@ -457,7 +464,7 @@ var _ = Describe("Build", func() {
 				build, err := job.CreateBuild()
 				Expect(err).ToNot(HaveOccurred())
 
-				err = build.SaveOutput(logger, "some-type", atc.Source{"some": "explicit-source"}, creds.VersionedResourceTypes{}, atc.Version{"some": "version"}, []db.ResourceConfigMetadataField{
+				err = build.SaveOutput("some-type", atc.Source{"some": "explicit-source"}, atc.VersionedResourceTypes{}, atc.Version{"some": "version"}, []db.ResourceConfigMetadataField{
 					{
 						Name:  "meta1",
 						Value: "data1",
@@ -539,10 +546,10 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfigScope1, err = resource1.SetResourceConfig(logger, atc.Source{"some": "source-1"}, creds.VersionedResourceTypes{})
+			resourceConfigScope1, err = resource1.SetResourceConfig(atc.Source{"some": "source-1"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
-			_, err = resource2.SetResourceConfig(logger, atc.Source{"some": "source-2"}, creds.VersionedResourceTypes{})
+			_, err = resource2.SetResourceConfig(atc.Source{"some": "source-2"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfigScope1.SaveVersions([]atc.Version{
@@ -552,7 +559,7 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			// This version should not be returned by the Resources method because it has a check order of 0
-			created, err := resource1.SaveUncheckedVersion(atc.Version{"ver": "not-returned"}, nil, resourceConfigScope1.ResourceConfig(), creds.VersionedResourceTypes{})
+			created, err := resource1.SaveUncheckedVersion(atc.Version{"ver": "not-returned"}, nil, resourceConfigScope1.ResourceConfig(), atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(created).To(BeTrue())
 		})
@@ -572,7 +579,7 @@ var _ = Describe("Build", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			// save explicit output from 'put'
-			err = build.SaveOutput(logger, "some-type", atc.Source{"some": "source-2"}, creds.VersionedResourceTypes{}, atc.Version{"ver": "2"}, nil, "some-output-name", "some-other-resource")
+			err = build.SaveOutput("some-type", atc.Source{"some": "source-2"}, atc.VersionedResourceTypes{}, atc.Version{"ver": "2"}, nil, "some-output-name", "some-other-resource")
 			Expect(err).NotTo(HaveOccurred())
 
 			inputs, outputs, err := build.Resources()
@@ -751,6 +758,14 @@ var _ = Describe("Build", func() {
 			})
 
 			Context("when inputs are satisfied", func() {
+				var (
+					resourceConfigScope db.ResourceConfigScope
+					resource            db.Resource
+					found               bool
+					rcv                 db.ResourceConfigVersion
+					err                 error
+				)
+
 				BeforeEach(func() {
 					setupTx, err := dbConn.Begin()
 					Expect(err).ToNot(HaveOccurred())
@@ -763,109 +778,148 @@ var _ = Describe("Build", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(setupTx.Commit()).To(Succeed())
 
-					resource, found, err := pipeline.Resource("some-resource")
+					resource, found, err = pipeline.Resource("some-resource")
 					Expect(err).NotTo(HaveOccurred())
 					Expect(found).To(BeTrue())
 
-					resourceConfigScope, err := resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+					resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					err = resourceConfigScope.SaveVersions([]atc.Version{{"version": "v5"}})
 					Expect(err).NotTo(HaveOccurred())
 
-					rcv, found, err := resourceConfigScope.FindVersion(atc.Version{"version": "v5"})
+					rcv, found, err = resourceConfigScope.FindVersion(atc.Version{"version": "v5"})
 					Expect(found).To(BeTrue())
 					Expect(err).NotTo(HaveOccurred())
-
-					err = job.SaveNextInputMapping(algorithm.InputMapping{
-						"some-input": {VersionID: rcv.ID(), ResourceID: resource.ID(), FirstOccurrence: true},
-					})
-					Expect(err).NotTo(HaveOccurred())
-
-					expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{
-						"some-input": db.BuildPreparationStatusNotBlocking,
-					}
 				})
 
-				Context("when the build is started", func() {
+				Context("when resource check finished after build created", func() {
 					BeforeEach(func() {
-						started, err := build.Start(atc.Plan{})
+						updated, err := resourceConfigScope.UpdateLastCheckEndTime()
-						Expect(started).To(BeTrue())
+						Expect(err).NotTo(HaveOccurred())
+						Expect(updated).To(BeTrue())
+
+						reloaded, err := resource.Reload()
+						Expect(err).NotTo(HaveOccurred())
+						Expect(reloaded).To(BeTrue())
+
+						lastCheckEndTime := resource.LastCheckEndTime()
+						Expect(lastCheckEndTime.IsZero()).To(BeFalse())
+
+						err = job.SaveNextInputMapping(algorithm.InputMapping{
+							"some-input": {VersionID: rcv.ID(), ResourceID: resource.ID(), FirstOccurrence: true},
+						})
 						Expect(err).NotTo(HaveOccurred())
 
-						stillExists, err := build.Reload()
+						expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{
-						Expect(stillExists).To(BeTrue())
+							"some-input": db.BuildPreparationStatusNotBlocking,
-						Expect(err).NotTo(HaveOccurred())
+						}
-
-						expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{}
 					})
 
-					It("returns build preparation", func() {
+					Context("when the build is started", func() {
-						buildPrep, found, err := build.Preparation()
+						BeforeEach(func() {
-						Expect(err).NotTo(HaveOccurred())
+							started, err := build.Start(atc.Plan{})
-						Expect(found).To(BeTrue())
+							Expect(started).To(BeTrue())
-						Expect(buildPrep).To(Equal(expectedBuildPrep))
+							Expect(err).NotTo(HaveOccurred())
+
+							stillExists, err := build.Reload()
+							Expect(stillExists).To(BeTrue())
+							Expect(err).NotTo(HaveOccurred())
+
+							expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{}
+						})
+
+						It("returns build preparation", func() {
+							buildPrep, found, err := build.Preparation()
+							Expect(err).NotTo(HaveOccurred())
+							Expect(found).To(BeTrue())
+							Expect(buildPrep).To(Equal(expectedBuildPrep))
+						})
+					})
+
+					Context("when pipeline is paused", func() {
+						BeforeEach(func() {
+							err := pipeline.Pause()
+							Expect(err).NotTo(HaveOccurred())
+
+							expectedBuildPrep.PausedPipeline = db.BuildPreparationStatusBlocking
+						})
+
+						It("returns build preparation with paused pipeline", func() {
+							buildPrep, found, err := build.Preparation()
+							Expect(err).NotTo(HaveOccurred())
+							Expect(found).To(BeTrue())
+							Expect(buildPrep).To(Equal(expectedBuildPrep))
+						})
+					})
+
+					Context("when job is paused", func() {
+						BeforeEach(func() {
+							err := job.Pause()
+							Expect(err).NotTo(HaveOccurred())
+
+							expectedBuildPrep.PausedJob = db.BuildPreparationStatusBlocking
+						})
+
+						It("returns build preparation with paused pipeline", func() {
+							buildPrep, found, err := build.Preparation()
+							Expect(err).NotTo(HaveOccurred())
+							Expect(found).To(BeTrue())
+							Expect(buildPrep).To(Equal(expectedBuildPrep))
+						})
+					})
+
+					Context("when max running builds is reached", func() {
+						BeforeEach(func() {
+							err := job.SetMaxInFlightReached(true)
+							Expect(err).NotTo(HaveOccurred())
+
+							expectedBuildPrep.MaxRunningBuilds = db.BuildPreparationStatusBlocking
+						})
+
+						It("returns build preparation with max in flight reached", func() {
+							buildPrep, found, err := build.Preparation()
+							Expect(err).NotTo(HaveOccurred())
+							Expect(found).To(BeTrue())
+							Expect(buildPrep).To(Equal(expectedBuildPrep))
+						})
+					})
+
+					Context("when max running builds is de-reached", func() {
+						BeforeEach(func() {
+							err := job.SetMaxInFlightReached(true)
+							Expect(err).NotTo(HaveOccurred())
+
+							err = job.SetMaxInFlightReached(false)
+							Expect(err).NotTo(HaveOccurred())
+						})
+
+						It("returns build preparation with max in flight not reached", func() {
+							buildPrep, found, err := build.Preparation()
+							Expect(err).NotTo(HaveOccurred())
+							Expect(found).To(BeTrue())
+							Expect(buildPrep).To(Equal(expectedBuildPrep))
+						})
 					})
 				})
 
-				Context("when pipeline is paused", func() {
+				Context("when no resource check finished after build created", func() {
 					BeforeEach(func() {
-						err := pipeline.Pause()
+						err = job.SaveNextInputMapping(algorithm.InputMapping{
+							"some-input": {VersionID: rcv.ID(), ResourceID: resource.ID(), FirstOccurrence: true},
+						})
 						Expect(err).NotTo(HaveOccurred())
 
-						expectedBuildPrep.PausedPipeline = db.BuildPreparationStatusBlocking
+						expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{
+							"some-input": db.BuildPreparationStatusBlocking,
+						}
+						expectedBuildPrep.InputsSatisfied = db.BuildPreparationStatusBlocking
+						expectedBuildPrep.MissingInputReasons = db.MissingInputReasons{
+							"some-input": db.NoResourceCheckFinished,
+						}
 					})
 
-					It("returns build preparation with paused pipeline", func() {
+					It("returns build preparation with missing input reason", func() {
-						buildPrep, found, err := build.Preparation()
-						Expect(err).NotTo(HaveOccurred())
-						Expect(found).To(BeTrue())
-						Expect(buildPrep).To(Equal(expectedBuildPrep))
-					})
-				})
-
-				Context("when job is paused", func() {
-					BeforeEach(func() {
-						err := job.Pause()
-						Expect(err).NotTo(HaveOccurred())
-
-						expectedBuildPrep.PausedJob = db.BuildPreparationStatusBlocking
-					})
-
-					It("returns build preparation with paused pipeline", func() {
-						buildPrep, found, err := build.Preparation()
-						Expect(err).NotTo(HaveOccurred())
-						Expect(found).To(BeTrue())
-						Expect(buildPrep).To(Equal(expectedBuildPrep))
-					})
-				})
-
-				Context("when max running builds is reached", func() {
-					BeforeEach(func() {
-						err := job.SetMaxInFlightReached(true)
-						Expect(err).NotTo(HaveOccurred())
-
-						expectedBuildPrep.MaxRunningBuilds = db.BuildPreparationStatusBlocking
-					})
-
-					It("returns build preparation with max in flight reached", func() {
-						buildPrep, found, err := build.Preparation()
-						Expect(err).NotTo(HaveOccurred())
-						Expect(found).To(BeTrue())
-						Expect(buildPrep).To(Equal(expectedBuildPrep))
-					})
-				})
-
-				Context("when max running builds is de-reached", func() {
-					BeforeEach(func() {
-						err := job.SetMaxInFlightReached(true)
-						Expect(err).NotTo(HaveOccurred())
-
-						err = job.SetMaxInFlightReached(false)
-						Expect(err).NotTo(HaveOccurred())
-					})
-
-					It("returns build preparation with max in flight not reached", func() {
 						buildPrep, found, err := build.Preparation()
 						Expect(err).NotTo(HaveOccurred())
 						Expect(found).To(BeTrue())
@@ -876,6 +930,23 @@ var _ = Describe("Build", func() {
 
 			Context("when inputs are not satisfied", func() {
 				BeforeEach(func() {
+					pipeline, _, err = team.SavePipeline("some-pipeline", atc.Config{
+						Resources: atc.ResourceConfigs{
+							{
+								Name: "some-resource",
+								Type: "some-type",
+								Source: atc.Source{
+									"source-config": "some-value",
+								},
+							},
+						},
+						Jobs: atc.JobConfigs{
+							{
+								Name: "some-job",
+							},
+						},
+					}, db.ConfigVersion(2), db.PipelineUnpaused)
+					Expect(err).ToNot(HaveOccurred())
 					expectedBuildPrep.InputsSatisfied = db.BuildPreparationStatusBlocking
 				})
 
@@ -945,7 +1016,7 @@ var _ = Describe("Build", func() {
 					Expect(found).To(BeTrue())
 					Expect(err).NotTo(HaveOccurred())
 
-					resourceConfig6, err := resource6.SetResourceConfig(logger, atc.Source{"some": "source-6"}, creds.VersionedResourceTypes{})
+					resourceConfig6, err := resource6.SetResourceConfig(atc.Source{"some": "source-6"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					err = resourceConfig6.SaveVersions([]atc.Version{{"version": "v6"}})
@@ -959,7 +1030,7 @@ var _ = Describe("Build", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(found).To(BeTrue())
 
-					resourceConfig1, err := resource1.SetResourceConfig(logger, atc.Source{"some": "source-1"}, creds.VersionedResourceTypes{})
+					resourceConfig1, err := resource1.SetResourceConfig(atc.Source{"some": "source-1"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					err = resourceConfig1.SaveVersions([]atc.Version{{"version": "v1"}})
@@ -1117,7 +1188,7 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfig, err := resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfig, err := resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfig.SaveVersions([]atc.Version{atc.Version{"some": "version"}})
@@ -1149,7 +1220,7 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfig, err := resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfig, err := resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfig.SaveVersions([]atc.Version{atc.Version{"some": "weird-version"}})
@@ -1170,7 +1241,7 @@ var _ = Describe("Build", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			weirdRC, err := weirdResource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			weirdRC, err := weirdResource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = weirdRC.SaveVersions([]atc.Version{atc.Version{"weird": "version"}})

atc/db/container_owner_test.go

@@ -5,7 +5,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -25,8 +24,8 @@ var _ = Describe("ContainerOwner", func() {
 		)
 
 		ownerExpiries = db.ContainerOwnerExpiries{
-			Min:       5 * time.Minute,
+			Min: 5 * time.Minute,
-			Max:       5 * time.Minute,
+			Max: 5 * time.Minute,
 		}
 
 		BeforeEach(func() {
@@ -41,12 +40,12 @@ var _ = Describe("ContainerOwner", func() {
 			worker, err = workerFactory.SaveWorker(workerPayload, 0)
 			Expect(err).NotTo(HaveOccurred())
 
-			resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(logger,
+			resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(
 				defaultWorkerResourceType.Type,
 				atc.Source{
 					"some-type": "source",
 				},
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).ToNot(HaveOccurred())
 		})

atc/db/container_repository_test.go

@@ -5,7 +5,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/lib/pq"
 
@@ -22,17 +21,16 @@ var _ = Describe("ContainerRepository", func() {
 			)
 
 			expiries := db.ContainerOwnerExpiries{
-				Min:       5 * time.Minute,
+				Min: 5 * time.Minute,
-				Max:       1 * time.Hour,
+				Max: 1 * time.Hour,
 			}
 
 			BeforeEach(func() {
 				var err error
 				resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(
-					logger,
 					"some-base-resource-type",
 					atc.Source{"some": "source"},
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).NotTo(HaveOccurred())
 

atc/db/dbfakes/fake_build.go

@@ -8,7 +8,6 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/lock"
 )
@@ -123,6 +122,16 @@ type FakeBuild struct {
 	finishReturnsOnCall map[int]struct {
 		result1 error
 	}
+	HasPlanStub        func() bool
+	hasPlanMutex       sync.RWMutex
+	hasPlanArgsForCall []struct {
+	}
+	hasPlanReturns struct {
+		result1 bool
+	}
+	hasPlanReturnsOnCall map[int]struct {
+		result1 bool
+	}
 	IDStub        func() int
 	iDMutex       sync.RWMutex
 	iDArgsForCall []struct {
@@ -371,17 +380,16 @@ type FakeBuild struct {
 	saveImageResourceVersionReturnsOnCall map[int]struct {
 		result1 error
 	}
-	SaveOutputStub        func(lager.Logger, string, atc.Source, creds.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error
+	SaveOutputStub        func(string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error
 	saveOutputMutex       sync.RWMutex
 	saveOutputArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 string
-		arg2 string
+		arg2 atc.Source
-		arg3 atc.Source
+		arg3 atc.VersionedResourceTypes
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.Version
-		arg5 atc.Version
+		arg5 db.ResourceConfigMetadataFields
-		arg6 db.ResourceConfigMetadataFields
+		arg6 string
 		arg7 string
-		arg8 string
 	}
 	saveOutputReturns struct {
 		result1 error
@@ -1023,6 +1031,58 @@ func (fake *FakeBuild) FinishReturnsOnCall(i int, result1 error) {
 	}{result1}
 }
 
+func (fake *FakeBuild) HasPlan() bool {
+	fake.hasPlanMutex.Lock()
+	ret, specificReturn := fake.hasPlanReturnsOnCall[len(fake.hasPlanArgsForCall)]
+	fake.hasPlanArgsForCall = append(fake.hasPlanArgsForCall, struct {
+	}{})
+	fake.recordInvocation("HasPlan", []interface{}{})
+	fake.hasPlanMutex.Unlock()
+	if fake.HasPlanStub != nil {
+		return fake.HasPlanStub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	fakeReturns := fake.hasPlanReturns
+	return fakeReturns.result1
+}
+
+func (fake *FakeBuild) HasPlanCallCount() int {
+	fake.hasPlanMutex.RLock()
+	defer fake.hasPlanMutex.RUnlock()
+	return len(fake.hasPlanArgsForCall)
+}
+
+func (fake *FakeBuild) HasPlanCalls(stub func() bool) {
+	fake.hasPlanMutex.Lock()
+	defer fake.hasPlanMutex.Unlock()
+	fake.HasPlanStub = stub
+}
+
+func (fake *FakeBuild) HasPlanReturns(result1 bool) {
+	fake.hasPlanMutex.Lock()
+	defer fake.hasPlanMutex.Unlock()
+	fake.HasPlanStub = nil
+	fake.hasPlanReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeBuild) HasPlanReturnsOnCall(i int, result1 bool) {
+	fake.hasPlanMutex.Lock()
+	defer fake.hasPlanMutex.Unlock()
+	fake.HasPlanStub = nil
+	if fake.hasPlanReturnsOnCall == nil {
+		fake.hasPlanReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.hasPlanReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
 func (fake *FakeBuild) ID() int {
 	fake.iDMutex.Lock()
 	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
@@ -2259,23 +2319,22 @@ func (fake *FakeBuild) SaveImageResourceVersionReturnsOnCall(i int, result1 erro
 	}{result1}
 }
 
-func (fake *FakeBuild) SaveOutput(arg1 lager.Logger, arg2 string, arg3 atc.Source, arg4 creds.VersionedResourceTypes, arg5 atc.Version, arg6 db.ResourceConfigMetadataFields, arg7 string, arg8 string) error {
+func (fake *FakeBuild) SaveOutput(arg1 string, arg2 atc.Source, arg3 atc.VersionedResourceTypes, arg4 atc.Version, arg5 db.ResourceConfigMetadataFields, arg6 string, arg7 string) error {
 	fake.saveOutputMutex.Lock()
 	ret, specificReturn := fake.saveOutputReturnsOnCall[len(fake.saveOutputArgsForCall)]
 	fake.saveOutputArgsForCall = append(fake.saveOutputArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 string
-		arg2 string
+		arg2 atc.Source
-		arg3 atc.Source
+		arg3 atc.VersionedResourceTypes
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.Version
-		arg5 atc.Version
+		arg5 db.ResourceConfigMetadataFields
-		arg6 db.ResourceConfigMetadataFields
+		arg6 string
 		arg7 string
-		arg8 string
+	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
-	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8})
+	fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
-	fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8})
 	fake.saveOutputMutex.Unlock()
 	if fake.SaveOutputStub != nil {
-		return fake.SaveOutputStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+		return fake.SaveOutputStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 	}
 	if specificReturn {
 		return ret.result1
@@ -2290,17 +2349,17 @@ func (fake *FakeBuild) SaveOutputCallCount() int {
 	return len(fake.saveOutputArgsForCall)
 }
 
-func (fake *FakeBuild) SaveOutputCalls(stub func(lager.Logger, string, atc.Source, creds.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error) {
+func (fake *FakeBuild) SaveOutputCalls(stub func(string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) error) {
 	fake.saveOutputMutex.Lock()
 	defer fake.saveOutputMutex.Unlock()
 	fake.SaveOutputStub = stub
 }
 
-func (fake *FakeBuild) SaveOutputArgsForCall(i int) (lager.Logger, string, atc.Source, creds.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) {
+func (fake *FakeBuild) SaveOutputArgsForCall(i int) (string, atc.Source, atc.VersionedResourceTypes, atc.Version, db.ResourceConfigMetadataFields, string, string) {
 	fake.saveOutputMutex.RLock()
 	defer fake.saveOutputMutex.RUnlock()
 	argsForCall := fake.saveOutputArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7
 }
 
 func (fake *FakeBuild) SaveOutputReturns(result1 error) {
@@ -2910,6 +2969,8 @@ func (fake *FakeBuild) Invocations() map[string][][]interface{} {
 	defer fake.eventsMutex.RUnlock()
 	fake.finishMutex.RLock()
 	defer fake.finishMutex.RUnlock()
+	fake.hasPlanMutex.RLock()
+	defer fake.hasPlanMutex.RUnlock()
 	fake.iDMutex.RLock()
 	defer fake.iDMutex.RUnlock()
 	fake.interceptibleMutex.RLock()

atc/db/dbfakes/fake_resource.go

@@ -5,9 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 )
 
@@ -262,13 +260,13 @@ type FakeResource struct {
 		result2 bool
 		result3 error
 	}
-	SaveUncheckedVersionStub        func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, creds.VersionedResourceTypes) (bool, error)
+	SaveUncheckedVersionStub        func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) (bool, error)
 	saveUncheckedVersionMutex       sync.RWMutex
 	saveUncheckedVersionArgsForCall []struct {
 		arg1 atc.Version
 		arg2 db.ResourceConfigMetadataFields
 		arg3 db.ResourceConfig
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.VersionedResourceTypes
 	}
 	saveUncheckedVersionReturns struct {
 		result1 bool
@@ -300,12 +298,11 @@ type FakeResource struct {
 	setPinCommentReturnsOnCall map[int]struct {
 		result1 error
 	}
-	SetResourceConfigStub        func(lager.Logger, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfigScope, error)
+	SetResourceConfigStub        func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)
 	setResourceConfigMutex       sync.RWMutex
 	setResourceConfigArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 atc.Source
-		arg2 atc.Source
+		arg2 atc.VersionedResourceTypes
-		arg3 creds.VersionedResourceTypes
 	}
 	setResourceConfigReturns struct {
 		result1 db.ResourceConfigScope
@@ -365,6 +362,20 @@ type FakeResource struct {
 	unpinVersionReturnsOnCall map[int]struct {
 		result1 error
 	}
+	UpdateMetadataStub        func(atc.Version, db.ResourceConfigMetadataFields) (bool, error)
+	updateMetadataMutex       sync.RWMutex
+	updateMetadataArgsForCall []struct {
+		arg1 atc.Version
+		arg2 db.ResourceConfigMetadataFields
+	}
+	updateMetadataReturns struct {
+		result1 bool
+		result2 error
+	}
+	updateMetadataReturnsOnCall map[int]struct {
+		result1 bool
+		result2 error
+	}
 	VersionsStub        func(db.Page) ([]atc.ResourceVersion, db.Pagination, bool, error)
 	versionsMutex       sync.RWMutex
 	versionsArgsForCall []struct {
@@ -1685,14 +1696,14 @@ func (fake *FakeResource) ResourceConfigVersionIDReturnsOnCall(i int, result1 in
 	}{result1, result2, result3}
 }
 
-func (fake *FakeResource) SaveUncheckedVersion(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields, arg3 db.ResourceConfig, arg4 creds.VersionedResourceTypes) (bool, error) {
+func (fake *FakeResource) SaveUncheckedVersion(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields, arg3 db.ResourceConfig, arg4 atc.VersionedResourceTypes) (bool, error) {
 	fake.saveUncheckedVersionMutex.Lock()
 	ret, specificReturn := fake.saveUncheckedVersionReturnsOnCall[len(fake.saveUncheckedVersionArgsForCall)]
 	fake.saveUncheckedVersionArgsForCall = append(fake.saveUncheckedVersionArgsForCall, struct {
 		arg1 atc.Version
 		arg2 db.ResourceConfigMetadataFields
 		arg3 db.ResourceConfig
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.VersionedResourceTypes
 	}{arg1, arg2, arg3, arg4})
 	fake.recordInvocation("SaveUncheckedVersion", []interface{}{arg1, arg2, arg3, arg4})
 	fake.saveUncheckedVersionMutex.Unlock()
@@ -1712,13 +1723,13 @@ func (fake *FakeResource) SaveUncheckedVersionCallCount() int {
 	return len(fake.saveUncheckedVersionArgsForCall)
 }
 
-func (fake *FakeResource) SaveUncheckedVersionCalls(stub func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, creds.VersionedResourceTypes) (bool, error)) {
+func (fake *FakeResource) SaveUncheckedVersionCalls(stub func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) (bool, error)) {
 	fake.saveUncheckedVersionMutex.Lock()
 	defer fake.saveUncheckedVersionMutex.Unlock()
 	fake.SaveUncheckedVersionStub = stub
 }
 
-func (fake *FakeResource) SaveUncheckedVersionArgsForCall(i int) (atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, creds.VersionedResourceTypes) {
+func (fake *FakeResource) SaveUncheckedVersionArgsForCall(i int) (atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) {
 	fake.saveUncheckedVersionMutex.RLock()
 	defer fake.saveUncheckedVersionMutex.RUnlock()
 	argsForCall := fake.saveUncheckedVersionArgsForCall[i]
@@ -1871,18 +1882,17 @@ func (fake *FakeResource) SetPinCommentReturnsOnCall(i int, result1 error) {
 	}{result1}
 }
 
-func (fake *FakeResource) SetResourceConfig(arg1 lager.Logger, arg2 atc.Source, arg3 creds.VersionedResourceTypes) (db.ResourceConfigScope, error) {
+func (fake *FakeResource) SetResourceConfig(arg1 atc.Source, arg2 atc.VersionedResourceTypes) (db.ResourceConfigScope, error) {
 	fake.setResourceConfigMutex.Lock()
 	ret, specificReturn := fake.setResourceConfigReturnsOnCall[len(fake.setResourceConfigArgsForCall)]
 	fake.setResourceConfigArgsForCall = append(fake.setResourceConfigArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 atc.Source
-		arg2 atc.Source
+		arg2 atc.VersionedResourceTypes
-		arg3 creds.VersionedResourceTypes
+	}{arg1, arg2})
-	}{arg1, arg2, arg3})
+	fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2})
-	fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2, arg3})
 	fake.setResourceConfigMutex.Unlock()
 	if fake.SetResourceConfigStub != nil {
-		return fake.SetResourceConfigStub(arg1, arg2, arg3)
+		return fake.SetResourceConfigStub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -1897,17 +1907,17 @@ func (fake *FakeResource) SetResourceConfigCallCount() int {
 	return len(fake.setResourceConfigArgsForCall)
 }
 
-func (fake *FakeResource) SetResourceConfigCalls(stub func(lager.Logger, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfigScope, error)) {
+func (fake *FakeResource) SetResourceConfigCalls(stub func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)) {
 	fake.setResourceConfigMutex.Lock()
 	defer fake.setResourceConfigMutex.Unlock()
 	fake.SetResourceConfigStub = stub
 }
 
-func (fake *FakeResource) SetResourceConfigArgsForCall(i int) (lager.Logger, atc.Source, creds.VersionedResourceTypes) {
+func (fake *FakeResource) SetResourceConfigArgsForCall(i int) (atc.Source, atc.VersionedResourceTypes) {
 	fake.setResourceConfigMutex.RLock()
 	defer fake.setResourceConfigMutex.RUnlock()
 	argsForCall := fake.setResourceConfigArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1, argsForCall.arg2
 }
 
 func (fake *FakeResource) SetResourceConfigReturns(result1 db.ResourceConfigScope, result2 error) {
@@ -2196,6 +2206,70 @@ func (fake *FakeResource) UnpinVersionReturnsOnCall(i int, result1 error) {
 	}{result1}
 }
 
+func (fake *FakeResource) UpdateMetadata(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields) (bool, error) {
+	fake.updateMetadataMutex.Lock()
+	ret, specificReturn := fake.updateMetadataReturnsOnCall[len(fake.updateMetadataArgsForCall)]
+	fake.updateMetadataArgsForCall = append(fake.updateMetadataArgsForCall, struct {
+		arg1 atc.Version
+		arg2 db.ResourceConfigMetadataFields
+	}{arg1, arg2})
+	fake.recordInvocation("UpdateMetadata", []interface{}{arg1, arg2})
+	fake.updateMetadataMutex.Unlock()
+	if fake.UpdateMetadataStub != nil {
+		return fake.UpdateMetadataStub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	fakeReturns := fake.updateMetadataReturns
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeResource) UpdateMetadataCallCount() int {
+	fake.updateMetadataMutex.RLock()
+	defer fake.updateMetadataMutex.RUnlock()
+	return len(fake.updateMetadataArgsForCall)
+}
+
+func (fake *FakeResource) UpdateMetadataCalls(stub func(atc.Version, db.ResourceConfigMetadataFields) (bool, error)) {
+	fake.updateMetadataMutex.Lock()
+	defer fake.updateMetadataMutex.Unlock()
+	fake.UpdateMetadataStub = stub
+}
+
+func (fake *FakeResource) UpdateMetadataArgsForCall(i int) (atc.Version, db.ResourceConfigMetadataFields) {
+	fake.updateMetadataMutex.RLock()
+	defer fake.updateMetadataMutex.RUnlock()
+	argsForCall := fake.updateMetadataArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeResource) UpdateMetadataReturns(result1 bool, result2 error) {
+	fake.updateMetadataMutex.Lock()
+	defer fake.updateMetadataMutex.Unlock()
+	fake.UpdateMetadataStub = nil
+	fake.updateMetadataReturns = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeResource) UpdateMetadataReturnsOnCall(i int, result1 bool, result2 error) {
+	fake.updateMetadataMutex.Lock()
+	defer fake.updateMetadataMutex.Unlock()
+	fake.UpdateMetadataStub = nil
+	if fake.updateMetadataReturnsOnCall == nil {
+		fake.updateMetadataReturnsOnCall = make(map[int]struct {
+			result1 bool
+			result2 error
+		})
+	}
+	fake.updateMetadataReturnsOnCall[i] = struct {
+		result1 bool
+		result2 error
+	}{result1, result2}
+}
+
 func (fake *FakeResource) Versions(arg1 db.Page) ([]atc.ResourceVersion, db.Pagination, bool, error) {
 	fake.versionsMutex.Lock()
 	ret, specificReturn := fake.versionsReturnsOnCall[len(fake.versionsArgsForCall)]
@@ -2386,6 +2460,8 @@ func (fake *FakeResource) Invocations() map[string][][]interface{} {
 	defer fake.typeMutex.RUnlock()
 	fake.unpinVersionMutex.RLock()
 	defer fake.unpinVersionMutex.RUnlock()
+	fake.updateMetadataMutex.RLock()
+	defer fake.updateMetadataMutex.RUnlock()
 	fake.versionsMutex.RLock()
 	defer fake.versionsMutex.RUnlock()
 	fake.webhookTokenMutex.RLock()

atc/db/dbfakes/fake_resource_cache_factory.go

@@ -4,23 +4,20 @@ package dbfakes
 import (
 	"sync"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 )
 
 type FakeResourceCacheFactory struct {
-	FindOrCreateResourceCacheStub        func(lager.Logger, db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, creds.VersionedResourceTypes) (db.UsedResourceCache, error)
+	FindOrCreateResourceCacheStub        func(db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, atc.VersionedResourceTypes) (db.UsedResourceCache, error)
 	findOrCreateResourceCacheMutex       sync.RWMutex
 	findOrCreateResourceCacheArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 db.ResourceCacheUser
-		arg2 db.ResourceCacheUser
+		arg2 string
-		arg3 string
+		arg3 atc.Version
-		arg4 atc.Version
+		arg4 atc.Source
-		arg5 atc.Source
+		arg5 atc.Params
-		arg6 atc.Params
+		arg6 atc.VersionedResourceTypes
-		arg7 creds.VersionedResourceTypes
 	}
 	findOrCreateResourceCacheReturns struct {
 		result1 db.UsedResourceCache
@@ -59,22 +56,21 @@ type FakeResourceCacheFactory struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeResourceCacheFactory) FindOrCreateResourceCache(arg1 lager.Logger, arg2 db.ResourceCacheUser, arg3 string, arg4 atc.Version, arg5 atc.Source, arg6 atc.Params, arg7 creds.VersionedResourceTypes) (db.UsedResourceCache, error) {
+func (fake *FakeResourceCacheFactory) FindOrCreateResourceCache(arg1 db.ResourceCacheUser, arg2 string, arg3 atc.Version, arg4 atc.Source, arg5 atc.Params, arg6 atc.VersionedResourceTypes) (db.UsedResourceCache, error) {
 	fake.findOrCreateResourceCacheMutex.Lock()
 	ret, specificReturn := fake.findOrCreateResourceCacheReturnsOnCall[len(fake.findOrCreateResourceCacheArgsForCall)]
 	fake.findOrCreateResourceCacheArgsForCall = append(fake.findOrCreateResourceCacheArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 db.ResourceCacheUser
-		arg2 db.ResourceCacheUser
+		arg2 string
-		arg3 string
+		arg3 atc.Version
-		arg4 atc.Version
+		arg4 atc.Source
-		arg5 atc.Source
+		arg5 atc.Params
-		arg6 atc.Params
+		arg6 atc.VersionedResourceTypes
-		arg7 creds.VersionedResourceTypes
+	}{arg1, arg2, arg3, arg4, arg5, arg6})
-	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
+	fake.recordInvocation("FindOrCreateResourceCache", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
-	fake.recordInvocation("FindOrCreateResourceCache", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
 	fake.findOrCreateResourceCacheMutex.Unlock()
 	if fake.FindOrCreateResourceCacheStub != nil {
-		return fake.FindOrCreateResourceCacheStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+		return fake.FindOrCreateResourceCacheStub(arg1, arg2, arg3, arg4, arg5, arg6)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -89,17 +85,17 @@ func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheCallCount() int {
 	return len(fake.findOrCreateResourceCacheArgsForCall)
 }
 
-func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheCalls(stub func(lager.Logger, db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, creds.VersionedResourceTypes) (db.UsedResourceCache, error)) {
+func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheCalls(stub func(db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, atc.VersionedResourceTypes) (db.UsedResourceCache, error)) {
 	fake.findOrCreateResourceCacheMutex.Lock()
 	defer fake.findOrCreateResourceCacheMutex.Unlock()
 	fake.FindOrCreateResourceCacheStub = stub
 }
 
-func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheArgsForCall(i int) (lager.Logger, db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, creds.VersionedResourceTypes) {
+func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheArgsForCall(i int) (db.ResourceCacheUser, string, atc.Version, atc.Source, atc.Params, atc.VersionedResourceTypes) {
 	fake.findOrCreateResourceCacheMutex.RLock()
 	defer fake.findOrCreateResourceCacheMutex.RUnlock()
 	argsForCall := fake.findOrCreateResourceCacheArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
 }
 
 func (fake *FakeResourceCacheFactory) FindOrCreateResourceCacheReturns(result1 db.UsedResourceCache, result2 error) {

atc/db/dbfakes/fake_resource_config_factory.go

@@ -4,9 +4,7 @@ package dbfakes
 import (
 	"sync"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 )
 
@@ -21,13 +19,12 @@ type FakeResourceConfigFactory struct {
 	cleanUnreferencedConfigsReturnsOnCall map[int]struct {
 		result1 error
 	}
-	FindOrCreateResourceConfigStub        func(lager.Logger, string, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfig, error)
+	FindOrCreateResourceConfigStub        func(string, atc.Source, atc.VersionedResourceTypes) (db.ResourceConfig, error)
 	findOrCreateResourceConfigMutex       sync.RWMutex
 	findOrCreateResourceConfigArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 string
-		arg2 string
+		arg2 atc.Source
-		arg3 atc.Source
+		arg3 atc.VersionedResourceTypes
-		arg4 creds.VersionedResourceTypes
 	}
 	findOrCreateResourceConfigReturns struct {
 		result1 db.ResourceConfig
@@ -108,19 +105,18 @@ func (fake *FakeResourceConfigFactory) CleanUnreferencedConfigsReturnsOnCall(i i
 	}{result1}
 }
 
-func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfig(arg1 lager.Logger, arg2 string, arg3 atc.Source, arg4 creds.VersionedResourceTypes) (db.ResourceConfig, error) {
+func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfig(arg1 string, arg2 atc.Source, arg3 atc.VersionedResourceTypes) (db.ResourceConfig, error) {
 	fake.findOrCreateResourceConfigMutex.Lock()
 	ret, specificReturn := fake.findOrCreateResourceConfigReturnsOnCall[len(fake.findOrCreateResourceConfigArgsForCall)]
 	fake.findOrCreateResourceConfigArgsForCall = append(fake.findOrCreateResourceConfigArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 string
-		arg2 string
+		arg2 atc.Source
-		arg3 atc.Source
+		arg3 atc.VersionedResourceTypes
-		arg4 creds.VersionedResourceTypes
+	}{arg1, arg2, arg3})
-	}{arg1, arg2, arg3, arg4})
+	fake.recordInvocation("FindOrCreateResourceConfig", []interface{}{arg1, arg2, arg3})
-	fake.recordInvocation("FindOrCreateResourceConfig", []interface{}{arg1, arg2, arg3, arg4})
 	fake.findOrCreateResourceConfigMutex.Unlock()
 	if fake.FindOrCreateResourceConfigStub != nil {
-		return fake.FindOrCreateResourceConfigStub(arg1, arg2, arg3, arg4)
+		return fake.FindOrCreateResourceConfigStub(arg1, arg2, arg3)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -135,17 +131,17 @@ func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigCallCount() int
 	return len(fake.findOrCreateResourceConfigArgsForCall)
 }
 
-func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigCalls(stub func(lager.Logger, string, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfig, error)) {
+func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigCalls(stub func(string, atc.Source, atc.VersionedResourceTypes) (db.ResourceConfig, error)) {
 	fake.findOrCreateResourceConfigMutex.Lock()
 	defer fake.findOrCreateResourceConfigMutex.Unlock()
 	fake.FindOrCreateResourceConfigStub = stub
 }
 
-func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigArgsForCall(i int) (lager.Logger, string, atc.Source, creds.VersionedResourceTypes) {
+func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigArgsForCall(i int) (string, atc.Source, atc.VersionedResourceTypes) {
 	fake.findOrCreateResourceConfigMutex.RLock()
 	defer fake.findOrCreateResourceConfigMutex.RUnlock()
 	argsForCall := fake.findOrCreateResourceConfigArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
 }
 
 func (fake *FakeResourceConfigFactory) FindOrCreateResourceConfigReturns(result1 db.ResourceConfig, result2 error) {

atc/db/dbfakes/fake_resource_config_scope.go

@@ -12,11 +12,10 @@ import (
 )
 
 type FakeResourceConfigScope struct {
-	AcquireResourceCheckingLockStub        func(lager.Logger, time.Duration) (lock.Lock, bool, error)
+	AcquireResourceCheckingLockStub        func(lager.Logger) (lock.Lock, bool, error)
 	acquireResourceCheckingLockMutex       sync.RWMutex
 	acquireResourceCheckingLockArgsForCall []struct {
 		arg1 lager.Logger
-		arg2 time.Duration
 	}
 	acquireResourceCheckingLockReturns struct {
 		result1 lock.Lock
@@ -149,17 +148,16 @@ type FakeResourceConfigScope struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeResourceConfigScope) AcquireResourceCheckingLock(arg1 lager.Logger, arg2 time.Duration) (lock.Lock, bool, error) {
+func (fake *FakeResourceConfigScope) AcquireResourceCheckingLock(arg1 lager.Logger) (lock.Lock, bool, error) {
 	fake.acquireResourceCheckingLockMutex.Lock()
 	ret, specificReturn := fake.acquireResourceCheckingLockReturnsOnCall[len(fake.acquireResourceCheckingLockArgsForCall)]
 	fake.acquireResourceCheckingLockArgsForCall = append(fake.acquireResourceCheckingLockArgsForCall, struct {
 		arg1 lager.Logger
-		arg2 time.Duration
+	}{arg1})
-	}{arg1, arg2})
+	fake.recordInvocation("AcquireResourceCheckingLock", []interface{}{arg1})
-	fake.recordInvocation("AcquireResourceCheckingLock", []interface{}{arg1, arg2})
 	fake.acquireResourceCheckingLockMutex.Unlock()
 	if fake.AcquireResourceCheckingLockStub != nil {
-		return fake.AcquireResourceCheckingLockStub(arg1, arg2)
+		return fake.AcquireResourceCheckingLockStub(arg1)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2, ret.result3
@@ -174,17 +172,17 @@ func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockCallCount() int
 	return len(fake.acquireResourceCheckingLockArgsForCall)
 }
 
-func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockCalls(stub func(lager.Logger, time.Duration) (lock.Lock, bool, error)) {
+func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockCalls(stub func(lager.Logger) (lock.Lock, bool, error)) {
 	fake.acquireResourceCheckingLockMutex.Lock()
 	defer fake.acquireResourceCheckingLockMutex.Unlock()
 	fake.AcquireResourceCheckingLockStub = stub
 }
 
-func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockArgsForCall(i int) (lager.Logger, time.Duration) {
+func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockArgsForCall(i int) lager.Logger {
 	fake.acquireResourceCheckingLockMutex.RLock()
 	defer fake.acquireResourceCheckingLockMutex.RUnlock()
 	argsForCall := fake.acquireResourceCheckingLockArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
+	return argsForCall.arg1
 }
 
 func (fake *FakeResourceConfigScope) AcquireResourceCheckingLockReturns(result1 lock.Lock, result2 bool, result3 error) {

atc/db/dbfakes/fake_resource_type.go

@@ -4,9 +4,7 @@ package dbfakes
 import (
 	"sync"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 )
 
@@ -104,12 +102,11 @@ type FakeResourceType struct {
 	setCheckSetupErrorReturnsOnCall map[int]struct {
 		result1 error
 	}
-	SetResourceConfigStub        func(lager.Logger, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfigScope, error)
+	SetResourceConfigStub        func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)
 	setResourceConfigMutex       sync.RWMutex
 	setResourceConfigArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 atc.Source
-		arg2 atc.Source
+		arg2 atc.VersionedResourceTypes
-		arg3 creds.VersionedResourceTypes
 	}
 	setResourceConfigReturns struct {
 		result1 db.ResourceConfigScope
@@ -652,18 +649,17 @@ func (fake *FakeResourceType) SetCheckSetupErrorReturnsOnCall(i int, result1 err
 	}{result1}
 }
 
-func (fake *FakeResourceType) SetResourceConfig(arg1 lager.Logger, arg2 atc.Source, arg3 creds.VersionedResourceTypes) (db.ResourceConfigScope, error) {
+func (fake *FakeResourceType) SetResourceConfig(arg1 atc.Source, arg2 atc.VersionedResourceTypes) (db.ResourceConfigScope, error) {
 	fake.setResourceConfigMutex.Lock()
 	ret, specificReturn := fake.setResourceConfigReturnsOnCall[len(fake.setResourceConfigArgsForCall)]
 	fake.setResourceConfigArgsForCall = append(fake.setResourceConfigArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 atc.Source
-		arg2 atc.Source
+		arg2 atc.VersionedResourceTypes
-		arg3 creds.VersionedResourceTypes
+	}{arg1, arg2})
-	}{arg1, arg2, arg3})
+	fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2})
-	fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2, arg3})
 	fake.setResourceConfigMutex.Unlock()
 	if fake.SetResourceConfigStub != nil {
-		return fake.SetResourceConfigStub(arg1, arg2, arg3)
+		return fake.SetResourceConfigStub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -678,17 +674,17 @@ func (fake *FakeResourceType) SetResourceConfigCallCount() int {
 	return len(fake.setResourceConfigArgsForCall)
 }
 
-func (fake *FakeResourceType) SetResourceConfigCalls(stub func(lager.Logger, atc.Source, creds.VersionedResourceTypes) (db.ResourceConfigScope, error)) {
+func (fake *FakeResourceType) SetResourceConfigCalls(stub func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)) {
 	fake.setResourceConfigMutex.Lock()
 	defer fake.setResourceConfigMutex.Unlock()
 	fake.SetResourceConfigStub = stub
 }
 
-func (fake *FakeResourceType) SetResourceConfigArgsForCall(i int) (lager.Logger, atc.Source, creds.VersionedResourceTypes) {
+func (fake *FakeResourceType) SetResourceConfigArgsForCall(i int) (atc.Source, atc.VersionedResourceTypes) {
 	fake.setResourceConfigMutex.RLock()
 	defer fake.setResourceConfigMutex.RUnlock()
 	argsForCall := fake.setResourceConfigArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1, argsForCall.arg2
 }
 
 func (fake *FakeResourceType) SetResourceConfigReturns(result1 db.ResourceConfigScope, result2 error) {

atc/db/dbfakes/fake_team.go

@@ -5,7 +5,6 @@ import (
 	"sync"
 	"time"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
@@ -62,10 +61,9 @@ type FakeTeam struct {
 		result2 db.Pagination
 		result3 error
 	}
-	ContainersStub        func(lager.Logger) ([]db.Container, error)
+	ContainersStub        func() ([]db.Container, error)
 	containersMutex       sync.RWMutex
 	containersArgsForCall []struct {
-		arg1 lager.Logger
 	}
 	containersReturns struct {
 		result1 []db.Container
@@ -110,13 +108,12 @@ type FakeTeam struct {
 	deleteReturnsOnCall map[int]struct {
 		result1 error
 	}
-	FindCheckContainersStub        func(lager.Logger, string, string, creds.Secrets) ([]db.Container, map[int]time.Time, error)
+	FindCheckContainersStub        func(string, string, creds.Secrets) ([]db.Container, map[int]time.Time, error)
 	findCheckContainersMutex       sync.RWMutex
 	findCheckContainersArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 string
 		arg2 string
-		arg3 string
+		arg3 creds.Secrets
-		arg4 creds.Secrets
 	}
 	findCheckContainersReturns struct {
 		result1 []db.Container
@@ -646,16 +643,15 @@ func (fake *FakeTeam) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, res
 	}{result1, result2, result3}
 }
 
-func (fake *FakeTeam) Containers(arg1 lager.Logger) ([]db.Container, error) {
+func (fake *FakeTeam) Containers() ([]db.Container, error) {
 	fake.containersMutex.Lock()
 	ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)]
 	fake.containersArgsForCall = append(fake.containersArgsForCall, struct {
-		arg1 lager.Logger
+	}{})
-	}{arg1})
+	fake.recordInvocation("Containers", []interface{}{})
-	fake.recordInvocation("Containers", []interface{}{arg1})
 	fake.containersMutex.Unlock()
 	if fake.ContainersStub != nil {
-		return fake.ContainersStub(arg1)
+		return fake.ContainersStub()
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -670,19 +666,12 @@ func (fake *FakeTeam) ContainersCallCount() int {
 	return len(fake.containersArgsForCall)
 }
 
-func (fake *FakeTeam) ContainersCalls(stub func(lager.Logger) ([]db.Container, error)) {
+func (fake *FakeTeam) ContainersCalls(stub func() ([]db.Container, error)) {
 	fake.containersMutex.Lock()
 	defer fake.containersMutex.Unlock()
 	fake.ContainersStub = stub
 }
 
-func (fake *FakeTeam) ContainersArgsForCall(i int) lager.Logger {
-	fake.containersMutex.RLock()
-	defer fake.containersMutex.RUnlock()
-	argsForCall := fake.containersArgsForCall[i]
-	return argsForCall.arg1
-}
-
 func (fake *FakeTeam) ContainersReturns(result1 []db.Container, result2 error) {
 	fake.containersMutex.Lock()
 	defer fake.containersMutex.Unlock()
@@ -879,19 +868,18 @@ func (fake *FakeTeam) DeleteReturnsOnCall(i int, result1 error) {
 	}{result1}
 }
 
-func (fake *FakeTeam) FindCheckContainers(arg1 lager.Logger, arg2 string, arg3 string, arg4 creds.Secrets) ([]db.Container, map[int]time.Time, error) {
+func (fake *FakeTeam) FindCheckContainers(arg1 string, arg2 string, arg3 creds.Secrets) ([]db.Container, map[int]time.Time, error) {
 	fake.findCheckContainersMutex.Lock()
 	ret, specificReturn := fake.findCheckContainersReturnsOnCall[len(fake.findCheckContainersArgsForCall)]
 	fake.findCheckContainersArgsForCall = append(fake.findCheckContainersArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 string
 		arg2 string
-		arg3 string
+		arg3 creds.Secrets
-		arg4 creds.Secrets
+	}{arg1, arg2, arg3})
-	}{arg1, arg2, arg3, arg4})
+	fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3})
-	fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3, arg4})
 	fake.findCheckContainersMutex.Unlock()
 	if fake.FindCheckContainersStub != nil {
-		return fake.FindCheckContainersStub(arg1, arg2, arg3, arg4)
+		return fake.FindCheckContainersStub(arg1, arg2, arg3)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2, ret.result3
@@ -906,17 +894,17 @@ func (fake *FakeTeam) FindCheckContainersCallCount() int {
 	return len(fake.findCheckContainersArgsForCall)
 }
 
-func (fake *FakeTeam) FindCheckContainersCalls(stub func(lager.Logger, string, string, creds.Secrets) ([]db.Container, map[int]time.Time, error)) {
+func (fake *FakeTeam) FindCheckContainersCalls(stub func(string, string, creds.Secrets) ([]db.Container, map[int]time.Time, error)) {
 	fake.findCheckContainersMutex.Lock()
 	defer fake.findCheckContainersMutex.Unlock()
 	fake.FindCheckContainersStub = stub
 }
 
-func (fake *FakeTeam) FindCheckContainersArgsForCall(i int) (lager.Logger, string, string, creds.Secrets) {
+func (fake *FakeTeam) FindCheckContainersArgsForCall(i int) (string, string, creds.Secrets) {
 	fake.findCheckContainersMutex.RLock()
 	defer fake.findCheckContainersMutex.RUnlock()
 	argsForCall := fake.findCheckContainersArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
 }
 
 func (fake *FakeTeam) FindCheckContainersReturns(result1 []db.Container, result2 map[int]time.Time, result3 error) {

atc/db/dbfakes/fake_worker.go

@@ -94,17 +94,17 @@ type FakeWorker struct {
 	expiresAtReturnsOnCall map[int]struct {
 		result1 time.Time
 	}
-	FindContainerOnWorkerStub        func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)
+	FindContainerStub        func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)
-	findContainerOnWorkerMutex       sync.RWMutex
+	findContainerMutex       sync.RWMutex
-	findContainerOnWorkerArgsForCall []struct {
+	findContainerArgsForCall []struct {
 		arg1 db.ContainerOwner
 	}
-	findContainerOnWorkerReturns struct {
+	findContainerReturns struct {
 		result1 db.CreatingContainer
 		result2 db.CreatedContainer
 		result3 error
 	}
-	findContainerOnWorkerReturnsOnCall map[int]struct {
+	findContainerReturnsOnCall map[int]struct {
 		result1 db.CreatingContainer
 		result2 db.CreatedContainer
 		result3 error
@@ -727,66 +727,66 @@ func (fake *FakeWorker) ExpiresAtReturnsOnCall(i int, result1 time.Time) {
 	}{result1}
 }
 
-func (fake *FakeWorker) FindContainerOnWorker(arg1 db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error) {
+func (fake *FakeWorker) FindContainer(arg1 db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error) {
-	fake.findContainerOnWorkerMutex.Lock()
+	fake.findContainerMutex.Lock()
-	ret, specificReturn := fake.findContainerOnWorkerReturnsOnCall[len(fake.findContainerOnWorkerArgsForCall)]
+	ret, specificReturn := fake.findContainerReturnsOnCall[len(fake.findContainerArgsForCall)]
-	fake.findContainerOnWorkerArgsForCall = append(fake.findContainerOnWorkerArgsForCall, struct {
+	fake.findContainerArgsForCall = append(fake.findContainerArgsForCall, struct {
 		arg1 db.ContainerOwner
 	}{arg1})
-	fake.recordInvocation("FindContainerOnWorker", []interface{}{arg1})
+	fake.recordInvocation("FindContainer", []interface{}{arg1})
-	fake.findContainerOnWorkerMutex.Unlock()
+	fake.findContainerMutex.Unlock()
-	if fake.FindContainerOnWorkerStub != nil {
+	if fake.FindContainerStub != nil {
-		return fake.FindContainerOnWorkerStub(arg1)
+		return fake.FindContainerStub(arg1)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2, ret.result3
 	}
-	fakeReturns := fake.findContainerOnWorkerReturns
+	fakeReturns := fake.findContainerReturns
 	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
 }
 
-func (fake *FakeWorker) FindContainerOnWorkerCallCount() int {
+func (fake *FakeWorker) FindContainerCallCount() int {
-	fake.findContainerOnWorkerMutex.RLock()
+	fake.findContainerMutex.RLock()
-	defer fake.findContainerOnWorkerMutex.RUnlock()
+	defer fake.findContainerMutex.RUnlock()
-	return len(fake.findContainerOnWorkerArgsForCall)
+	return len(fake.findContainerArgsForCall)
 }
 
-func (fake *FakeWorker) FindContainerOnWorkerCalls(stub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)) {
+func (fake *FakeWorker) FindContainerCalls(stub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)) {
-	fake.findContainerOnWorkerMutex.Lock()
+	fake.findContainerMutex.Lock()
-	defer fake.findContainerOnWorkerMutex.Unlock()
+	defer fake.findContainerMutex.Unlock()
-	fake.FindContainerOnWorkerStub = stub
+	fake.FindContainerStub = stub
 }
 
-func (fake *FakeWorker) FindContainerOnWorkerArgsForCall(i int) db.ContainerOwner {
+func (fake *FakeWorker) FindContainerArgsForCall(i int) db.ContainerOwner {
-	fake.findContainerOnWorkerMutex.RLock()
+	fake.findContainerMutex.RLock()
-	defer fake.findContainerOnWorkerMutex.RUnlock()
+	defer fake.findContainerMutex.RUnlock()
-	argsForCall := fake.findContainerOnWorkerArgsForCall[i]
+	argsForCall := fake.findContainerArgsForCall[i]
 	return argsForCall.arg1
 }
 
-func (fake *FakeWorker) FindContainerOnWorkerReturns(result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
+func (fake *FakeWorker) FindContainerReturns(result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
-	fake.findContainerOnWorkerMutex.Lock()
+	fake.findContainerMutex.Lock()
-	defer fake.findContainerOnWorkerMutex.Unlock()
+	defer fake.findContainerMutex.Unlock()
-	fake.FindContainerOnWorkerStub = nil
+	fake.FindContainerStub = nil
-	fake.findContainerOnWorkerReturns = struct {
+	fake.findContainerReturns = struct {
 		result1 db.CreatingContainer
 		result2 db.CreatedContainer
 		result3 error
 	}{result1, result2, result3}
 }
 
-func (fake *FakeWorker) FindContainerOnWorkerReturnsOnCall(i int, result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
+func (fake *FakeWorker) FindContainerReturnsOnCall(i int, result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
-	fake.findContainerOnWorkerMutex.Lock()
+	fake.findContainerMutex.Lock()
-	defer fake.findContainerOnWorkerMutex.Unlock()
+	defer fake.findContainerMutex.Unlock()
-	fake.FindContainerOnWorkerStub = nil
+	fake.FindContainerStub = nil
-	if fake.findContainerOnWorkerReturnsOnCall == nil {
+	if fake.findContainerReturnsOnCall == nil {
-		fake.findContainerOnWorkerReturnsOnCall = make(map[int]struct {
+		fake.findContainerReturnsOnCall = make(map[int]struct {
 			result1 db.CreatingContainer
 			result2 db.CreatedContainer
 			result3 error
 		})
 	}
-	fake.findContainerOnWorkerReturnsOnCall[i] = struct {
+	fake.findContainerReturnsOnCall[i] = struct {
 		result1 db.CreatingContainer
 		result2 db.CreatedContainer
 		result3 error
@@ -1757,8 +1757,8 @@ func (fake *FakeWorker) Invocations() map[string][][]interface{} {
 	defer fake.ephemeralMutex.RUnlock()
 	fake.expiresAtMutex.RLock()
 	defer fake.expiresAtMutex.RUnlock()
-	fake.findContainerOnWorkerMutex.RLock()
+	fake.findContainerMutex.RLock()
-	defer fake.findContainerOnWorkerMutex.RUnlock()
+	defer fake.findContainerMutex.RUnlock()
 	fake.gardenAddrMutex.RLock()
 	defer fake.gardenAddrMutex.RUnlock()
 	fake.hTTPProxyURLMutex.RLock()

atc/db/job_test.go

@@ -4,7 +4,6 @@ import (
 	"time"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 	. "github.com/onsi/ginkgo"
@@ -747,7 +746,7 @@ var _ = Describe("Job", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfigScope.SaveVersions([]atc.Version{
@@ -763,7 +762,7 @@ var _ = Describe("Job", func() {
 					Name:  "name1",
 					Value: "value1",
 				},
-			}, resourceConfigScope.ResourceConfig(), creds.VersionedResourceTypes{})
+			}, resourceConfigScope.ResourceConfig(), atc.VersionedResourceTypes{})
 			Expect(err).NotTo(HaveOccurred())
 
 			reversions, _, found, err := resource.Versions(db.Page{Limit: 3})
@@ -927,7 +926,7 @@ var _ = Describe("Job", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfigScope.SaveVersions([]atc.Version{
@@ -943,7 +942,7 @@ var _ = Describe("Job", func() {
 					Name:  "name1",
 					Value: "value1",
 				},
-			}, resourceConfigScope.ResourceConfig(), creds.VersionedResourceTypes{})
+			}, resourceConfigScope.ResourceConfig(), atc.VersionedResourceTypes{})
 			Expect(err).NotTo(HaveOccurred())
 
 			reversions, _, found, err := resource.Versions(db.Page{Limit: 3})

atc/db/lock/lock.go

@@ -44,8 +44,8 @@ func NewVolumeCreatingLockID(volumeID int) LockID {
 	return LockID{LockTypeVolumeCreating, volumeID}
 }
 
-func NewContainerCreatingLockID(containerID int) LockID {
+func NewContainerCreatingLockID() LockID {
-	return LockID{LockTypeContainerCreating, containerID}
+	return LockID{LockTypeContainerCreating}
 }
 
 func NewDatabaseMigrationLockID() LockID {

atc/db/pipeline_test.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 	"github.com/concourse/concourse/atc/event"
@@ -405,13 +404,13 @@ var _ = Describe("Pipeline", func() {
 			otherPipelineResource, _, err = otherDBPipeline.Resource(otherResourceName)
 			Expect(err).ToNot(HaveOccurred())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
-			otherResourceConfigScope, err = otherPipelineResource.SetResourceConfig(logger, atc.Source{"other-source-config": "some-other-value"}, creds.VersionedResourceTypes{})
+			otherResourceConfigScope, err = otherPipelineResource.SetResourceConfig(atc.Source{"other-source-config": "some-other-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
-			_, err = reallyOtherResource.SetResourceConfig(logger, atc.Source{"source-config": "some-really-other-value"}, creds.VersionedResourceTypes{})
+			_, err = reallyOtherResource.SetResourceConfig(atc.Source{"source-config": "some-really-other-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 		})
 
@@ -553,7 +552,7 @@ var _ = Describe("Pipeline", func() {
 			build1DB, err := aJob.CreateBuild()
 			Expect(err).ToNot(HaveOccurred())
 
-			err = build1DB.SaveOutput(logger, "some-type", atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-resource")
+			err = build1DB.SaveOutput("some-type", atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
 			err = build1DB.Finish(db.BuildStatusSucceeded)
@@ -600,7 +599,7 @@ var _ = Describe("Pipeline", func() {
 			build2DB, err := aJob.CreateBuild()
 			Expect(err).ToNot(HaveOccurred())
 
-			err = build2DB.SaveOutput(logger, "some-type", atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-resource")
+			err = build2DB.SaveOutput("some-type", atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
 			err = build2DB.Finish(db.BuildStatusFailed)
@@ -649,7 +648,7 @@ var _ = Describe("Pipeline", func() {
 			otherPipelineBuild, err := anotherJob.CreateBuild()
 			Expect(err).ToNot(HaveOccurred())
 
-			err = otherPipelineBuild.SaveOutput(logger, "some-type", atc.Source{"other-source-config": "some-other-value"}, creds.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-other-resource")
+			err = otherPipelineBuild.SaveOutput("some-type", atc.Source{"other-source-config": "some-other-value"}, atc.VersionedResourceTypes{}, atc.Version{"version": "1"}, nil, "some-output-name", "some-other-resource")
 			Expect(err).ToNot(HaveOccurred())
 
 			err = otherPipelineBuild.Finish(db.BuildStatusSucceeded)
@@ -883,7 +882,7 @@ var _ = Describe("Pipeline", func() {
 				})
 				Expect(err).ToNot(HaveOccurred())
 
-				err = build.SaveOutput(logger, "some-type", atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{}, atc.Version(beforeVR.Version()), nil, "some-output-name", "some-resource")
+				err = build.SaveOutput("some-type", atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{}, atc.Version(beforeVR.Version()), nil, "some-output-name", "some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
 				versions, _, found, err := resource.Versions(db.Page{Limit: 10})
@@ -906,7 +905,7 @@ var _ = Describe("Pipeline", func() {
 				savedResource, _, err := dbPipeline.Resource("some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
-				resourceConfigScope, err = savedResource.SetResourceConfig(logger, atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{})
+				resourceConfigScope, err = savedResource.SetResourceConfig(atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				savedVR, found, err := resourceConfigScope.LatestVersion()
@@ -966,7 +965,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some-source": "some-value"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some-source": "some-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 		})
 
@@ -992,7 +991,7 @@ var _ = Describe("Pipeline", func() {
 					ResourceID: resource.ID(),
 				}
 
-				err = build1.SaveOutput(logger, "some-type", atc.Source{"some-source": "some-value"}, creds.VersionedResourceTypes{}, atc.Version{"version": "disabled"}, nil, "some-output-name", "some-resource")
+				err = build1.SaveOutput("some-type", atc.Source{"some-source": "some-value"}, atc.VersionedResourceTypes{}, atc.Version{"version": "disabled"}, nil, "some-output-name", "some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
 				err = resourceConfigScope.SaveVersions([]atc.Version{{"version": "enabled"}})
@@ -1019,7 +1018,7 @@ var _ = Describe("Pipeline", func() {
 
 				Expect(err).ToNot(HaveOccurred())
 
-				err = build1.SaveOutput(logger, "some-type", atc.Source{"some-source": "some-value"}, creds.VersionedResourceTypes{}, atc.Version{"version": "other-enabled"}, nil, "some-output-name", "some-resource")
+				err = build1.SaveOutput("some-type", atc.Source{"some-source": "some-value"}, atc.VersionedResourceTypes{}, atc.Version{"version": "other-enabled"}, nil, "some-output-name", "some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
 				err = build1.Finish(db.BuildStatusSucceeded)
@@ -1105,7 +1104,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(found).To(BeTrue())
 			Expect(err).ToNot(HaveOccurred())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			By("populating resource versions")
@@ -1135,7 +1134,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			By("populating build outputs")
-			err = build.SaveOutput(logger, "some-type", atc.Source{"some": "source"}, creds.VersionedResourceTypes{}, atc.Version{"key": "value"}, nil, "some-output-name", "some-resource")
+			err = build.SaveOutput("some-type", atc.Source{"some": "source"}, atc.VersionedResourceTypes{}, atc.Version{"key": "value"}, nil, "some-output-name", "some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
 			By("populating build events")
@@ -1221,7 +1220,7 @@ var _ = Describe("Pipeline", func() {
 				savedResource, _, err = pipeline.Resource("some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
-				resourceConfigScope, err = savedResource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+				resourceConfigScope, err = savedResource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				err = resourceConfigScope.SaveVersions([]atc.Version{{"version": "1"}})
@@ -1233,7 +1232,7 @@ var _ = Describe("Pipeline", func() {
 			})
 
 			It("will cache VersionsDB if no change has occured", func() {
-				err := build.SaveOutput(logger, "some-type", atc.Source{"some": "source"}, creds.VersionedResourceTypes{}, atc.Version(savedVR.Version()), nil, "some-output-name", "some-resource")
+				err := build.SaveOutput("some-type", atc.Source{"some": "source"}, atc.VersionedResourceTypes{}, atc.Version(savedVR.Version()), nil, "some-output-name", "some-resource")
 				Expect(err).ToNot(HaveOccurred())
 
 				versionsDB, err := pipeline.LoadVersionsDB()
@@ -1294,7 +1293,7 @@ var _ = Describe("Pipeline", func() {
 					otherSavedResource, _, err := otherPipeline.Resource("some-other-resource")
 					Expect(err).ToNot(HaveOccurred())
 
-					otherResourceConfigScope, err := otherSavedResource.SetResourceConfig(logger, atc.Source{"some-source": "some-other-value"}, creds.VersionedResourceTypes{})
+					otherResourceConfigScope, err := otherSavedResource.SetResourceConfig(atc.Source{"some-source": "some-other-value"}, atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 
 					otherResourceConfigScope.SaveVersions([]atc.Version{{"version": "1"}})
@@ -1307,7 +1306,7 @@ var _ = Describe("Pipeline", func() {
 					versionsDB, err := pipeline.LoadVersionsDB()
 					Expect(err).ToNot(HaveOccurred())
 
-					err = otherBuild.SaveOutput(logger, "some-type", atc.Source{"some-source": "some-other-value"}, creds.VersionedResourceTypes{}, atc.Version(otherSavedVR.Version()), nil, "some-output-name", "some-other-resource")
+					err = otherBuild.SaveOutput("some-type", atc.Source{"some-source": "some-other-value"}, atc.VersionedResourceTypes{}, atc.Version(otherSavedVR.Version()), nil, "some-output-name", "some-other-resource")
 					Expect(err).ToNot(HaveOccurred())
 
 					cachedVersionsDB, err := pipeline.LoadVersionsDB()
@@ -1330,10 +1329,10 @@ var _ = Describe("Pipeline", func() {
 				otherResource, _, err := pipeline.Resource("some-other-resource")
 				Expect(err).ToNot(HaveOccurred())
 
-				resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+				resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
-				otherResourceConfigScope, err = otherResource.SetResourceConfig(logger, atc.Source{"some": "other-source"}, creds.VersionedResourceTypes{})
+				otherResourceConfigScope, err = otherResource.SetResourceConfig(atc.Source{"some": "other-source"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
@@ -1369,7 +1368,7 @@ var _ = Describe("Pipeline", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				By("creating a new version but not updating the check order yet")
-				created, err := resource.SaveUncheckedVersion(atc.Version{"version": "1"}, nil, resourceConfigScope.ResourceConfig(), creds.VersionedResourceTypes{})
+				created, err := resource.SaveUncheckedVersion(atc.Version{"version": "1"}, nil, resourceConfigScope.ResourceConfig(), atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(created).To(BeTrue())
 
@@ -1397,7 +1396,7 @@ var _ = Describe("Pipeline", func() {
 					otherPipelineResource, _, err := otherPipeline.Resource("some-other-resource")
 					Expect(err).ToNot(HaveOccurred())
 
-					otherPipelineResourceConfig, err := otherPipelineResource.SetResourceConfig(logger, atc.Source{"some-source": "some-other-value"}, creds.VersionedResourceTypes{})
+					otherPipelineResourceConfig, err := otherPipelineResource.SetResourceConfig(atc.Source{"some-source": "some-other-value"}, atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 
 					err = otherPipelineResourceConfig.SaveVersions([]atc.Version{{"version": "1"}})
@@ -1695,7 +1694,7 @@ var _ = Describe("Pipeline", func() {
 			resource, _, err = pipeline.Resource("some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfigScope.SaveVersions([]atc.Version{atc.Version{"version": "v1"}})
@@ -1829,7 +1828,7 @@ var _ = Describe("Pipeline", func() {
 			resource, _, err = pipeline.Resource("some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
-			resourceConfigScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfigScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceConfigScope.SaveVersions([]atc.Version{
@@ -1838,7 +1837,7 @@ var _ = Describe("Pipeline", func() {
 			})
 			Expect(err).ToNot(HaveOccurred())
 
-			err = dbBuild.SaveOutput(logger, "some-type", atc.Source{"some": "source"}, creds.VersionedResourceTypes{}, atc.Version{"version": "v1"}, []db.ResourceConfigMetadataField{
+			err = dbBuild.SaveOutput("some-type", atc.Source{"some": "source"}, atc.VersionedResourceTypes{}, atc.Version{"version": "v1"}, []db.ResourceConfigMetadataField{
 				{
 					Name:  "some",
 					Value: "value",
@@ -1850,7 +1849,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			err = dbSecondBuild.SaveOutput(logger, "some-type", atc.Source{"some": "source"}, creds.VersionedResourceTypes{}, atc.Version{"version": "v1"}, []db.ResourceConfigMetadataField{
+			err = dbSecondBuild.SaveOutput("some-type", atc.Source{"some": "source"}, atc.VersionedResourceTypes{}, atc.Version{"version": "v1"}, []db.ResourceConfigMetadataField{
 				{
 					Name:  "some",
 					Value: "value",
@@ -1858,7 +1857,7 @@ var _ = Describe("Pipeline", func() {
 			}, "some-output-name", "some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
-			err = dbSecondBuild.SaveOutput(logger, "some-type", atc.Source{"some": "source"}, creds.VersionedResourceTypes{}, atc.Version{"version": "v3"}, nil, "some-output-name", "some-resource")
+			err = dbSecondBuild.SaveOutput("some-type", atc.Source{"some": "source"}, atc.VersionedResourceTypes{}, atc.Version{"version": "v3"}, nil, "some-output-name", "some-resource")
 			Expect(err).ToNot(HaveOccurred())
 
 			rcv1, found, err := resourceConfigScope.FindVersion(atc.Version{"version": "v1"})
@@ -2037,7 +2036,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(setupTx.Commit()).To(Succeed())
 
-			resourceTypeScope, err := resourceType.SetResourceConfig(logger, atc.Source{"some": "type-source"}, creds.VersionedResourceTypes{})
+			resourceTypeScope, err := resourceType.SetResourceConfig(atc.Source{"some": "type-source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceTypeScope.SaveVersions([]atc.Version{
@@ -2046,7 +2045,7 @@ var _ = Describe("Pipeline", func() {
 			})
 			Expect(err).ToNot(HaveOccurred())
 
-			otherResourceTypeScope, err := otherResourceType.SetResourceConfig(logger, atc.Source{"some": "other-type-source"}, creds.VersionedResourceTypes{})
+			otherResourceTypeScope, err := otherResourceType.SetResourceConfig(atc.Source{"some": "other-type-source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = otherResourceTypeScope.SaveVersions([]atc.Version{
@@ -2088,7 +2087,7 @@ var _ = Describe("Pipeline", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(found).To(BeTrue())
 
-			resourceConfig, err := resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+			resourceConfig, err := resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			version := atc.Version{"version": "1"}

atc/db/resource.go

@@ -8,10 +8,8 @@ import (
 	"strconv"
 	"time"
 
-	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/lock"
 	"github.com/lib/pq"
 )
@@ -47,7 +45,8 @@ type Resource interface {
 
 	ResourceConfigVersionID(atc.Version) (int, bool, error)
 	Versions(page Page) ([]atc.ResourceVersion, Pagination, bool, error)
-	SaveUncheckedVersion(atc.Version, ResourceConfigMetadataFields, ResourceConfig, creds.VersionedResourceTypes) (bool, error)
+	SaveUncheckedVersion(atc.Version, ResourceConfigMetadataFields, ResourceConfig, atc.VersionedResourceTypes) (bool, error)
+	UpdateMetadata(atc.Version, ResourceConfigMetadataFields) (bool, error)
 
 	EnableVersion(rcvID int) error
 	DisableVersion(rcvID int) error
@@ -55,7 +54,7 @@ type Resource interface {
 	PinVersion(rcvID int) error
 	UnpinVersion() error
 
-	SetResourceConfig(lager.Logger, atc.Source, creds.VersionedResourceTypes) (ResourceConfigScope, error)
+	SetResourceConfig(atc.Source, atc.VersionedResourceTypes) (ResourceConfigScope, error)
 	SetCheckSetupError(error) error
 	NotifyScan() error
 
@@ -177,7 +176,7 @@ func (r *resource) Reload() (bool, error) {
 	return true, nil
 }
 
-func (r *resource) SetResourceConfig(logger lager.Logger, source atc.Source, resourceTypes creds.VersionedResourceTypes) (ResourceConfigScope, error) {
+func (r *resource) SetResourceConfig(source atc.Source, resourceTypes atc.VersionedResourceTypes) (ResourceConfigScope, error) {
 	resourceConfigDescriptor, err := constructResourceConfigDescriptor(r.type_, source, resourceTypes)
 	if err != nil {
 		return nil, err
@@ -190,7 +189,7 @@ func (r *resource) SetResourceConfig(logger lager.Logger, source atc.Source, res
 
 	defer Rollback(tx)
 
-	resourceConfig, err := resourceConfigDescriptor.findOrCreate(logger, tx, r.lockFactory, r.conn)
+	resourceConfig, err := resourceConfigDescriptor.findOrCreate(tx, r.lockFactory, r.conn)
 	if err != nil {
 		return nil, err
 	}
@@ -275,7 +274,7 @@ func (r *resource) SetCheckSetupError(cause error) error {
 // index for the pipeline because we want to ignore these versions until the
 // check orders get updated. The bumping of the index will be done in
 // SaveOutput for the put step.
-func (r *resource) SaveUncheckedVersion(version atc.Version, metadata ResourceConfigMetadataFields, resourceConfig ResourceConfig, resourceTypes creds.VersionedResourceTypes) (bool, error) {
+func (r *resource) SaveUncheckedVersion(version atc.Version, metadata ResourceConfigMetadataFields, resourceConfig ResourceConfig, resourceTypes atc.VersionedResourceTypes) (bool, error) {
 	tx, err := r.conn.Begin()
 	if err != nil {
 		return false, err
@@ -296,6 +295,37 @@ func (r *resource) SaveUncheckedVersion(version atc.Version, metadata ResourceCo
 	return newVersion, tx.Commit()
 }
 
+func (r *resource) UpdateMetadata(version atc.Version, metadata ResourceConfigMetadataFields) (bool, error) {
+	versionJSON, err := json.Marshal(version)
+	if err != nil {
+		return false, err
+	}
+
+	metadataJSON, err := json.Marshal(metadata)
+	if err != nil {
+		return false, err
+	}
+
+	_, err = psql.Update("resource_config_versions").
+		Set("metadata", string(metadataJSON)).
+		Where(sq.Eq{
+			"resource_config_scope_id": r.ResourceConfigScopeID(),
+		}).
+		Where(sq.Expr(
+			"version_md5 = md5(?)", versionJSON,
+		)).
+		RunWith(r.conn).
+		Exec()
+
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
 func (r *resource) ResourceConfigVersionID(version atc.Version) (int, bool, error) {
 	requestedVersion, err := json.Marshal(version)
 	if err != nil {

atc/db/resource_cache.go

@@ -7,8 +7,6 @@ import (
 	"errors"
 	"fmt"
 
-	"code.cloudfoundry.org/lager"
-
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db/lock"
@@ -43,12 +41,11 @@ func (cache *ResourceCacheDescriptor) find(tx Tx, lockFactory lock.LockFactory,
 }
 
 func (cache *ResourceCacheDescriptor) findOrCreate(
-	logger lager.Logger,
 	tx Tx,
 	lockFactory lock.LockFactory,
 	conn Conn,
 ) (UsedResourceCache, error) {
-	resourceConfig, err := cache.ResourceConfigDescriptor.findOrCreate(logger, tx, lockFactory, conn)
+	resourceConfig, err := cache.ResourceConfigDescriptor.findOrCreate(tx, lockFactory, conn)
 	if err != nil {
 		return nil, err
 	}
@@ -98,7 +95,6 @@ func (cache *ResourceCacheDescriptor) findOrCreate(
 }
 
 func (cache *ResourceCacheDescriptor) use(
-	logger lager.Logger,
 	tx Tx,
 	rc UsedResourceCache,
 	user ResourceCacheUser,

atc/db/resource_cache_factory.go

@@ -4,10 +4,8 @@ import (
 	"database/sql"
 	"encoding/json"
 
-	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/lock"
 )
 
@@ -15,13 +13,12 @@ import (
 
 type ResourceCacheFactory interface {
 	FindOrCreateResourceCache(
-		logger lager.Logger,
 		resourceCacheUser ResourceCacheUser,
 		resourceTypeName string,
 		version atc.Version,
 		source atc.Source,
 		params atc.Params,
-		resourceTypes creds.VersionedResourceTypes,
+		resourceTypes atc.VersionedResourceTypes,
 	) (UsedResourceCache, error)
 
 	// changing resource cache to interface to allow updates on object is not feasible.
@@ -45,13 +42,12 @@ func NewResourceCacheFactory(conn Conn, lockFactory lock.LockFactory) ResourceCa
 }
 
 func (f *resourceCacheFactory) FindOrCreateResourceCache(
-	logger lager.Logger,
 	resourceCacheUser ResourceCacheUser,
 	resourceTypeName string,
 	version atc.Version,
 	source atc.Source,
 	params atc.Params,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 ) (UsedResourceCache, error) {
 	resourceConfigDescriptor, err := constructResourceConfigDescriptor(resourceTypeName, source, resourceTypes)
 	if err != nil {
@@ -71,12 +67,12 @@ func (f *resourceCacheFactory) FindOrCreateResourceCache(
 
 	defer Rollback(tx)
 
-	usedResourceCache, err := resourceCache.findOrCreate(logger, tx, f.lockFactory, f.conn)
+	usedResourceCache, err := resourceCache.findOrCreate(tx, f.lockFactory, f.conn)
 	if err != nil {
 		return nil, err
 	}
 
-	err = resourceCache.use(logger, tx, usedResourceCache, resourceCacheUser)
+	err = resourceCache.use(tx, usedResourceCache, resourceCacheUser)
 	if err != nil {
 		return nil, err
 	}

atc/db/resource_cache_factory_test.go

@@ -8,9 +8,7 @@ import (
 
 	"code.cloudfoundry.org/lager/lagertest"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -71,7 +69,7 @@ var _ = Describe("ResourceCacheFactory", func() {
 				Name: "some-type-type",
 				Type: "some-base-type",
 				Source: atc.Source{
-					"some-type-type": "((source-param))",
+					"some-type-type": "some-secret-sauce",
 				},
 			},
 			Version: atc.Version{"some-type-type": "version"},
@@ -119,7 +117,6 @@ var _ = Describe("ResourceCacheFactory", func() {
 	Describe("FindOrCreateResourceCache", func() {
 		It("creates resource cache in database", func() {
 			usedResourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type",
 				atc.Version{"some": "version"},
@@ -127,14 +124,11 @@ var _ = Describe("ResourceCacheFactory", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{
-					template.StaticVariables{"source-param": "some-secret-sauce"},
+					resourceType1,
-					atc.VersionedResourceTypes{
+					resourceType2,
-						resourceType1,
+					resourceType3,
-						resourceType2,
+				},
-						resourceType3,
-					},
-				),
 			)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(usedResourceCache.Version()).To(Equal(atc.Version{"some": "version"}))
@@ -200,7 +194,6 @@ var _ = Describe("ResourceCacheFactory", func() {
 
 		It("returns an error if base resource type does not exist", func() {
 			_, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type-using-bogus-base-type",
 				atc.Version{"some": "version"},
@@ -208,13 +201,10 @@ var _ = Describe("ResourceCacheFactory", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{
-					template.StaticVariables{"source-param": "some-secret-sauce"},
+					resourceType1,
-					atc.VersionedResourceTypes{
+					resourceTypeUsingBogusBaseType,
-						resourceType1,
+				},
-						resourceTypeUsingBogusBaseType,
-					},
-				),
 			)
 			Expect(err).To(HaveOccurred())
 			Expect(err).To(Equal(db.BaseResourceTypeNotFoundError{Name: "some-bogus-base-type"}))
@@ -222,7 +212,6 @@ var _ = Describe("ResourceCacheFactory", func() {
 
 		It("allows a base resource type to be overridden using itself", func() {
 			usedResourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-image-type",
 				atc.Version{"some": "version"},
@@ -230,12 +219,9 @@ var _ = Describe("ResourceCacheFactory", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{
-					template.StaticVariables{"source-param": "some-secret-sauce"},
+					resourceTypeOverridingBaseType,
-					atc.VersionedResourceTypes{
+				},
-						resourceTypeOverridingBaseType,
-					},
-				),
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -286,13 +272,12 @@ var _ = Describe("ResourceCacheFactory", func() {
 
 					for i := 0; i < 100; i++ {
 						_, err := resourceCacheFactory.FindOrCreateResourceCache(
-							logger,
 							db.ForBuild(build.ID()),
 							"some-base-resource-type",
 							atc.Version{"some": "version"},
 							atc.Source{"some": "source"},
 							atc.Params{"some": "params"},
-							creds.VersionedResourceTypes{},
+							atc.VersionedResourceTypes{},
 						)
 						Expect(err).ToNot(HaveOccurred())
 					}

atc/db/resource_cache_lifecycle_test.go

@@ -4,9 +4,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 
@@ -175,15 +173,11 @@ var _ = Describe("ResourceCacheLifecycle", func() {
 			BeforeEach(func() {
 				var err error
 				resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(
-					logger,
 					"some-base-resource-type",
 					atc.Source{
 						"some": "source",
 					},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{},
-						template.StaticVariables{"source-param": "some-secret-sauce"},
-						atc.VersionedResourceTypes{},
-					),
 				)
 				Expect(err).ToNot(HaveOccurred())
 
@@ -230,26 +224,22 @@ var _ = Describe("ResourceCacheLifecycle", func() {
 		Context("when the cache is for a custom resource type", func() {
 			It("does not remove the cache if the type is still configured", func() {
 				_, err := resourceConfigFactory.FindOrCreateResourceConfig(
-					logger,
 					"some-type",
 					atc.Source{
 						"some": "source",
 					},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{
-						template.StaticVariables{"source-param": "some-secret-sauce"},
+						atc.VersionedResourceType{
-						atc.VersionedResourceTypes{
+							ResourceType: atc.ResourceType{
-							atc.VersionedResourceType{
+								Name: "some-type",
-								ResourceType: atc.ResourceType{
+								Type: "some-base-resource-type",
-									Name: "some-type",
+								Source: atc.Source{
-									Type: "some-base-resource-type",
+									"some": "source",
-									Source: atc.Source{
-										"some": "source",
-									},
 								},
-								Version: atc.Version{"showme": "whatyougot"},
 							},
+							Version: atc.Version{"showme": "whatyougot"},
 						},
-					),
+					},
 				)
 				Expect(err).ToNot(HaveOccurred())
 
@@ -262,26 +252,22 @@ var _ = Describe("ResourceCacheLifecycle", func() {
 
 			It("removes the cache if the type is no longer configured", func() {
 				_, err := resourceConfigFactory.FindOrCreateResourceConfig(
-					logger,
 					"some-type",
 					atc.Source{
 						"some": "source",
 					},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{
-						template.StaticVariables{"source-param": "some-secret-sauce"},
+						atc.VersionedResourceType{
-						atc.VersionedResourceTypes{
+							ResourceType: atc.ResourceType{
-							atc.VersionedResourceType{
+								Name: "some-type",
-								ResourceType: atc.ResourceType{
+								Type: "some-base-resource-type",
-									Name: "some-type",
+								Source: atc.Source{
-									Type: "some-base-resource-type",
+									"some": "source",
-									Source: atc.Source{
-										"some": "source",
-									},
 								},
-								Version: atc.Version{"showme": "whatyougot"},
 							},
+							Version: atc.Version{"showme": "whatyougot"},
 						},
-					),
+					},
 				)
 				Expect(err).ToNot(HaveOccurred())
 
@@ -306,12 +292,8 @@ var _ = Describe("ResourceCacheLifecycle", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				resourceConfigScope, err := defaultResource.SetResourceConfig(
-					logger,
 					atc.Source{"some": "source"},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{},
-						template.StaticVariables{"source-param": "some-secret-sauce"},
-						atc.VersionedResourceTypes{},
-					),
 				)
 				Expect(err).ToNot(HaveOccurred())
 
@@ -372,7 +354,6 @@ func countResourceCaches() int {
 
 func createResourceCacheWithUser(resourceCacheUser db.ResourceCacheUser) db.UsedResourceCache {
 	usedResourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-		logger,
 		resourceCacheUser,
 		"some-base-resource-type",
 		atc.Version{"some": "version"},
@@ -380,10 +361,7 @@ func createResourceCacheWithUser(resourceCacheUser db.ResourceCacheUser) db.Used
 			"some": "source",
 		},
 		atc.Params{"some": fmt.Sprintf("param-%d", time.Now().UnixNano())},
-		creds.NewVersionedResourceTypes(
+		atc.VersionedResourceTypes{},
-			template.StaticVariables{"source-param": "some-secret-sauce"},
-			atc.VersionedResourceTypes{},
-		),
 	)
 	Expect(err).ToNot(HaveOccurred())
 

atc/db/resource_cache_test.go

@@ -2,9 +2,7 @@ package db_test
 
 import (
 	sq "github.com/Masterminds/squirrel"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/lib/pq"
 	. "github.com/onsi/ginkgo"
@@ -42,7 +40,6 @@ var _ = Describe("ResourceCache", func() {
 
 		It("can be created and used", func() {
 			urc, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-worker-resource-type",
 				atc.Version{"some": "version"},
@@ -50,10 +47,7 @@ var _ = Describe("ResourceCache", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{},
-					template.StaticVariables{"source-param": "some-secret-sauce"},
-					atc.VersionedResourceTypes{},
-				),
 			)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(urc.ID()).ToNot(BeZero())
@@ -70,7 +64,6 @@ var _ = Describe("ResourceCache", func() {
 			BeforeEach(func() {
 				var err error
 				existingResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForBuild(build.ID()),
 					"some-worker-resource-type",
 					atc.Version{"some": "version"},
@@ -78,17 +71,13 @@ var _ = Describe("ResourceCache", func() {
 						"some": "source",
 					},
 					atc.Params{"some": "params"},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{},
-						template.StaticVariables{"source-param": "some-secret-sauce"},
-						atc.VersionedResourceTypes{},
-					),
 				)
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("returns the same used resource cache", func() {
 				urc, err := resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForBuild(build.ID()),
 					"some-worker-resource-type",
 					atc.Version{"some": "version"},
@@ -96,10 +85,7 @@ var _ = Describe("ResourceCache", func() {
 						"some": "source",
 					},
 					atc.Params{"some": "params"},
-					creds.NewVersionedResourceTypes(
+					atc.VersionedResourceTypes{},
-						template.StaticVariables{"source-param": "some-secret-sauce"},
-						atc.VersionedResourceTypes{},
-					),
 				)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(urc.ID()).To(Equal(existingResourceCache.ID()))
@@ -127,7 +113,6 @@ var _ = Describe("ResourceCache", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			urc, err = resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForContainer(container.ID()),
 				"some-worker-resource-type",
 				atc.Version{"some-type": "version"},
@@ -135,9 +120,7 @@ var _ = Describe("ResourceCache", func() {
 					"cache": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+				atc.VersionedResourceTypes{},
-					atc.VersionedResourceTypes{},
-				),
 			)
 			Expect(err).NotTo(HaveOccurred())
 		})
@@ -156,7 +139,6 @@ var _ = Describe("ResourceCache", func() {
 			BeforeEach(func() {
 				var err error
 				existingResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForContainer(container.ID()),
 					"some-worker-resource-type",
 					atc.Version{"some-type": "version"},
@@ -164,9 +146,7 @@ var _ = Describe("ResourceCache", func() {
 						"cache": "source",
 					},
 					atc.Params{"some": "params"},
-					creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+					atc.VersionedResourceTypes{},
-						atc.VersionedResourceTypes{},
-					),
 				)
 				Expect(err).NotTo(HaveOccurred())
 			})

atc/db/resource_config.go

@@ -6,11 +6,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"code.cloudfoundry.org/lager"
-
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/lock"
 )
 
@@ -126,7 +123,7 @@ func (r *resourceConfig) FindResourceConfigScopeByID(resourceConfigScopeID int,
 		lockFactory:    r.lockFactory}, true, nil
 }
 
-func (r *ResourceConfigDescriptor) findOrCreate(logger lager.Logger, tx Tx, lockFactory lock.LockFactory, conn Conn) (ResourceConfig, error) {
+func (r *ResourceConfigDescriptor) findOrCreate(tx Tx, lockFactory lock.LockFactory, conn Conn) (ResourceConfig, error) {
 	rc := &resourceConfig{
 		lockFactory: lockFactory,
 		conn:        conn,
@@ -137,7 +134,7 @@ func (r *ResourceConfigDescriptor) findOrCreate(logger lager.Logger, tx Tx, lock
 	if r.CreatedByResourceCache != nil {
 		parentColumnName = "resource_cache_id"
 
-		resourceCache, err := r.CreatedByResourceCache.findOrCreate(logger, tx, lockFactory, conn)
+		resourceCache, err := r.CreatedByResourceCache.findOrCreate(tx, lockFactory, conn)
 		if err != nil {
 			return nil, err
 		}
@@ -284,7 +281,7 @@ func (r *ResourceConfigDescriptor) findWithParentID(tx Tx, parentColumnName stri
 	return id, true, nil
 }
 
-func findOrCreateResourceConfigScope(tx Tx, conn Conn, lockFactory lock.LockFactory, resourceConfig ResourceConfig, resource Resource, resourceTypes creds.VersionedResourceTypes) (ResourceConfigScope, error) {
+func findOrCreateResourceConfigScope(tx Tx, conn Conn, lockFactory lock.LockFactory, resourceConfig ResourceConfig, resource Resource, resourceTypes atc.VersionedResourceTypes) (ResourceConfigScope, error) {
 	var unique bool
 	var uniqueResource Resource
 	var resourceID *int

atc/db/resource_config_check_session_lifecycle_test.go

@@ -5,7 +5,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -23,13 +22,13 @@ var _ = Describe("ResourceConfigCheckSessionLifecycle", func() {
 
 	Describe("CleanInactiveResourceConfigCheckSessions", func() {
 		expiry := db.ContainerOwnerExpiries{
-			Min:       1 * time.Minute,
+			Min: 1 * time.Minute,
-			Max:       1 * time.Minute,
+			Max: 1 * time.Minute,
 		}
 
 		Context("for resources", func() {
 			findOrCreateSessionForDefaultResource := func() int {
-				resourceConfigScope, err := defaultResource.SetResourceConfig(logger, defaultResource.Source(), creds.VersionedResourceTypes{})
+				resourceConfigScope, err := defaultResource.SetResourceConfig(defaultResource.Source(), atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				owner := db.NewResourceConfigCheckSessionContainerOwner(resourceConfigScope.ResourceConfig(), expiry)
@@ -123,9 +122,9 @@ var _ = Describe("ResourceConfigCheckSessionLifecycle", func() {
 
 		Context("for resource types", func() {
 			findOrCreateSessionForDefaultResourceType := func() int {
-				resourceConfigScope, err := defaultResourceType.SetResourceConfig(logger,
+				resourceConfigScope, err := defaultResourceType.SetResourceConfig(
 					defaultResourceType.Source(),
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).ToNot(HaveOccurred())
 

atc/db/resource_config_factory.go

@@ -5,10 +5,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/lock"
 	"github.com/lib/pq"
 )
@@ -25,10 +23,9 @@ func (e ErrCustomResourceTypeVersionNotFound) Error() string {
 
 type ResourceConfigFactory interface {
 	FindOrCreateResourceConfig(
-		logger lager.Logger,
 		resourceType string,
 		source atc.Source,
-		resourceTypes creds.VersionedResourceTypes,
+		resourceTypes atc.VersionedResourceTypes,
 	) (ResourceConfig, error)
 
 	FindResourceConfigByID(int) (ResourceConfig, bool, error)
@@ -73,10 +70,9 @@ func (f *resourceConfigFactory) FindResourceConfigByID(resourceConfigID int) (Re
 }
 
 func (f *resourceConfigFactory) FindOrCreateResourceConfig(
-	logger lager.Logger,
 	resourceType string,
 	source atc.Source,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 ) (ResourceConfig, error) {
 
 	resourceConfigDescriptor, err := constructResourceConfigDescriptor(resourceType, source, resourceTypes)
@@ -90,7 +86,7 @@ func (f *resourceConfigFactory) FindOrCreateResourceConfig(
 	}
 	defer Rollback(tx)
 
-	resourceConfig, err := resourceConfigDescriptor.findOrCreate(logger, tx, f.lockFactory, f.conn)
+	resourceConfig, err := resourceConfigDescriptor.findOrCreate(tx, f.lockFactory, f.conn)
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +105,7 @@ func (f *resourceConfigFactory) FindOrCreateResourceConfig(
 func constructResourceConfigDescriptor(
 	resourceTypeName string,
 	source atc.Source,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 ) (ResourceConfigDescriptor, error) {
 	resourceConfigDescriptor := ResourceConfigDescriptor{
 		Source: source,
@@ -117,14 +113,9 @@ func constructResourceConfigDescriptor(
 
 	customType, found := resourceTypes.Lookup(resourceTypeName)
 	if found {
-		source, err := customType.Source.Evaluate()
-		if err != nil {
-			return ResourceConfigDescriptor{}, err
-		}
-
 		customTypeResourceConfig, err := constructResourceConfigDescriptor(
 			customType.Type,
-			source,
+			customType.Source,
 			resourceTypes.Without(customType.Name),
 		)
 		if err != nil {

atc/db/resource_config_factory_test.go

@@ -3,9 +3,7 @@ package db_test
 import (
 	"sync"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -62,7 +60,7 @@ var _ = Describe("ResourceConfigFactory", func() {
 					defer wg.Done()
 
 					for i := 0; i < 100; i++ {
-						_, err := resourceConfigFactory.FindOrCreateResourceConfig(logger, "some-base-resource-type", atc.Source{"some": "unique-source"}, creds.VersionedResourceTypes{})
+						_, err := resourceConfigFactory.FindOrCreateResourceConfig("some-base-resource-type", atc.Source{"some": "unique-source"}, atc.VersionedResourceTypes{})
 						Expect(err).ToNot(HaveOccurred())
 					}
 				}()
@@ -100,7 +98,7 @@ var _ = Describe("ResourceConfigFactory", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(setupTx.Commit()).To(Succeed())
 
-					createdResourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(logger, "base-resource-type-name", atc.Source{}, creds.VersionedResourceTypes{})
+					createdResourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig("base-resource-type-name", atc.Source{}, atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 					Expect(createdResourceConfig).ToNot(BeNil())
 
@@ -120,7 +118,7 @@ var _ = Describe("ResourceConfigFactory", func() {
 					pipelineResourceTypes, err := defaultPipeline.ResourceTypes()
 					Expect(err).ToNot(HaveOccurred())
 
-					createdResourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(logger, "some-type", atc.Source{}, creds.NewVersionedResourceTypes(template.StaticVariables{}, pipelineResourceTypes.Deserialize()))
+					createdResourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig("some-type", atc.Source{}, pipelineResourceTypes.Deserialize())
 					Expect(err).ToNot(HaveOccurred())
 					Expect(createdResourceConfig).ToNot(BeNil())
 

atc/db/resource_config_scope.go

@@ -34,7 +34,6 @@ type ResourceConfigScope interface {
 
 	AcquireResourceCheckingLock(
 		logger lager.Logger,
-		interval time.Duration,
 	) (lock.Lock, bool, error)
 
 	UpdateLastCheckStartTime(
@@ -181,7 +180,6 @@ func (r *resourceConfigScope) SetCheckError(cause error) error {
 
 func (r *resourceConfigScope) AcquireResourceCheckingLock(
 	logger lager.Logger,
-	interval time.Duration,
 ) (lock.Lock, bool, error) {
 	return r.lockFactory.Acquire(
 		logger,

atc/db/resource_config_scope_test.go

@@ -3,9 +3,7 @@ package db_test
 import (
 	"time"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/lock"
 	. "github.com/onsi/ginkgo"
@@ -44,7 +42,7 @@ var _ = Describe("Resource Config Scope", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(found).To(BeTrue())
 
-		resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+		resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 		Expect(err).NotTo(HaveOccurred())
 	})
 
@@ -202,9 +200,8 @@ var _ = Describe("Resource Config Scope", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceConfigScope, err = someResource.SetResourceConfig(
-				logger,
 				someResource.Source(),
-				creds.NewVersionedResourceTypes(template.StaticVariables{}, pipelineResourceTypes.Deserialize()),
+				pipelineResourceTypes.Deserialize(),
 			)
 			Expect(err).ToNot(HaveOccurred())
 		})
@@ -282,9 +279,8 @@ var _ = Describe("Resource Config Scope", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceConfigScope, err = someResource.SetResourceConfig(
-				logger,
 				someResource.Source(),
-				creds.NewVersionedResourceTypes(template.StaticVariables{}, pipelineResourceTypes.Deserialize()),
+				pipelineResourceTypes.Deserialize(),
 			)
 			Expect(err).ToNot(HaveOccurred())
 		})
@@ -317,9 +313,8 @@ var _ = Describe("Resource Config Scope", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceConfigScope, err = someResource.SetResourceConfig(
-				logger,
 				someResource.Source(),
-				creds.NewVersionedResourceTypes(template.StaticVariables{}, pipelineResourceTypes.Deserialize()),
+				pipelineResourceTypes.Deserialize(),
 			)
 			Expect(err).ToNot(HaveOccurred())
 		})
@@ -331,7 +326,7 @@ var _ = Describe("Resource Config Scope", func() {
 			BeforeEach(func() {
 				var err error
 				var acquired bool
-				lock, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+				lock, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(acquired).To(BeTrue())
 			})
@@ -341,7 +336,7 @@ var _ = Describe("Resource Config Scope", func() {
 			})
 
 			It("does not get the lock", func() {
-				_, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+				_, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(acquired).To(BeFalse())
 			})
@@ -353,7 +348,7 @@ var _ = Describe("Resource Config Scope", func() {
 				})
 
 				It("gets the lock", func() {
-					lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+					lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(acquired).To(BeTrue())
 
@@ -365,12 +360,12 @@ var _ = Describe("Resource Config Scope", func() {
 
 		Context("when there has not been a check recently", func() {
 			It("gets and keeps the lock and stops others from periodically getting it", func() {
-				lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+				lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(logger)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(acquired).To(BeTrue())
 
 				Consistently(func() bool {
-					_, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+					_, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger)
 					Expect(err).ToNot(HaveOccurred())
 
 					return acquired
@@ -381,7 +376,7 @@ var _ = Describe("Resource Config Scope", func() {
 
 				time.Sleep(time.Second)
 
-				lock, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger, 1*time.Second)
+				lock, acquired, err = resourceConfigScope.AcquireResourceCheckingLock(logger)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(acquired).To(BeTrue())
 

atc/db/resource_config_test.go

@@ -2,7 +2,6 @@ package db_test
 
 import (
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -12,7 +11,7 @@ import (
 var _ = Describe("ResourceConfig", func() {
 	Describe("FindResourceConfigScopeByID", func() {
 		var pipeline db.Pipeline
-		var resourceTypes creds.VersionedResourceTypes
+		var resourceTypes atc.VersionedResourceTypes
 
 		BeforeEach(func() {
 			atc.EnableGlobalResources = true
@@ -38,7 +37,7 @@ var _ = Describe("ResourceConfig", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(created).To(BeTrue())
 
-			resourceTypes = creds.VersionedResourceTypes{}
+			resourceTypes = atc.VersionedResourceTypes{}
 		})
 
 		Context("when a shared resource config scope exists", func() {
@@ -64,7 +63,7 @@ var _ = Describe("ResourceConfig", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(found).To(BeTrue())
 
-				scope, err = resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, resourceTypes)
+				scope, err = resource.SetResourceConfig(atc.Source{"some": "repository"}, resourceTypes)
 				Expect(err).ToNot(HaveOccurred())
 			})
 
@@ -101,7 +100,7 @@ var _ = Describe("ResourceConfig", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(found).To(BeTrue())
 
-				scope, err = resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, resourceTypes)
+				scope, err = resource.SetResourceConfig(atc.Source{"some": "repository"}, resourceTypes)
 				Expect(err).ToNot(HaveOccurred())
 			})
 
@@ -133,7 +132,7 @@ var _ = Describe("ResourceConfig", func() {
 				Expect(err).NotTo(HaveOccurred())
 				Expect(setupTx.Commit()).To(Succeed())
 
-				resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(logger, "some-type", atc.Source{"some": "repository"}, resourceTypes)
+				resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig("some-type", atc.Source{"some": "repository"}, resourceTypes)
 				Expect(err).ToNot(HaveOccurred())
 
 				var found bool

atc/db/resource_test.go

@@ -4,9 +4,7 @@ import (
 	"errors"
 	"strconv"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 	. "github.com/onsi/ginkgo"
@@ -138,7 +136,7 @@ var _ = Describe("Resource", func() {
 					versionsDB, err = pipeline.LoadVersionsDB()
 					Expect(err).ToNot(HaveOccurred())
 
-					resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+					resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					err = resourceScope.SetCheckError(errors.New("oops"))
@@ -165,7 +163,7 @@ var _ = Describe("Resource", func() {
 					})
 
 					It("does not bump the cache index", func() {
-						resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+						resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 						Expect(err).NotTo(HaveOccurred())
 
 						cachedVersionsDB, err := pipeline.LoadVersionsDB()
@@ -278,7 +276,7 @@ var _ = Describe("Resource", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(setupTx.Commit()).To(Succeed())
 
-					resourceScope1, err = resource1.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+					resourceScope1, err = resource1.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					err = resourceScope1.SetCheckError(errors.New("oops"))
@@ -303,7 +301,7 @@ var _ = Describe("Resource", func() {
 						Expect(err).ToNot(HaveOccurred())
 						Expect(found).To(BeTrue())
 
-						resourceScope2, err = resource2.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+						resourceScope2, err = resource2.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 						Expect(err).NotTo(HaveOccurred())
 
 						found, err = resource2.Reload()
@@ -348,7 +346,7 @@ var _ = Describe("Resource", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(setupTx.Commit()).To(Succeed())
 
-					resourceScope1, err = resource1.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+					resourceScope1, err = resource1.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					found, err = resource1.Reload()
@@ -369,7 +367,7 @@ var _ = Describe("Resource", func() {
 						Expect(err).ToNot(HaveOccurred())
 						Expect(found).To(BeTrue())
 
-						resourceScope2, err = resource2.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+						resourceScope2, err = resource2.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 						Expect(err).NotTo(HaveOccurred())
 
 						found, err = resource2.Reload()
@@ -416,7 +414,7 @@ var _ = Describe("Resource", func() {
 					resourceTypes, err = pipeline.ResourceTypes()
 					Expect(err).ToNot(HaveOccurred())
 
-					resourceScope1, err = resource1.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.NewVersionedResourceTypes(template.StaticVariables{}, resourceTypes.Deserialize()))
+					resourceScope1, err = resource1.SetResourceConfig(atc.Source{"some": "repository"}, resourceTypes.Deserialize())
 					Expect(err).NotTo(HaveOccurred())
 
 					found, err = resource1.Reload()
@@ -438,7 +436,7 @@ var _ = Describe("Resource", func() {
 						Expect(err).ToNot(HaveOccurred())
 						Expect(found).To(BeTrue())
 
-						resourceScope2, err = resource2.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.NewVersionedResourceTypes(template.StaticVariables{}, resourceTypes.Deserialize()))
+						resourceScope2, err = resource2.SetResourceConfig(atc.Source{"some": "repository"}, resourceTypes.Deserialize())
 						Expect(err).NotTo(HaveOccurred())
 
 						found, err = resource2.Reload()
@@ -470,7 +468,7 @@ var _ = Describe("Resource", func() {
 						Expect(err).ToNot(HaveOccurred())
 						Expect(found).To(BeTrue())
 
-						newResourceConfigScope, err = resource1.SetResourceConfig(logger, atc.Source{"some": "other-repo"}, creds.NewVersionedResourceTypes(template.StaticVariables{}, resourceTypes.Deserialize()))
+						newResourceConfigScope, err = resource1.SetResourceConfig(atc.Source{"some": "other-repo"}, resourceTypes.Deserialize())
 						Expect(err).NotTo(HaveOccurred())
 
 						found, err = resource1.Reload()
@@ -505,7 +503,7 @@ var _ = Describe("Resource", func() {
 						resourceTypes, err = newPipeline.ResourceTypes()
 						Expect(err).ToNot(HaveOccurred())
 
-						newResourceConfigScope, err = resource1.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.NewVersionedResourceTypes(template.StaticVariables{}, resourceTypes.Deserialize()))
+						newResourceConfigScope, err = resource1.SetResourceConfig(atc.Source{"some": "repository"}, resourceTypes.Deserialize())
 						Expect(err).NotTo(HaveOccurred())
 
 						found, err = resource1.Reload()
@@ -555,10 +553,10 @@ var _ = Describe("Resource", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(setupTx.Commit()).To(Succeed())
 
-					_, err = resource1.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+					_, err = resource1.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
-					_, err = resource2.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+					_, err = resource2.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					found, err = resource1.Reload()
@@ -664,7 +662,7 @@ var _ = Describe("Resource", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(setupTx.Commit()).To(Succeed())
 
-				resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+				resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				err = resourceScope.SaveVersions([]atc.Version{version})
@@ -685,7 +683,7 @@ var _ = Describe("Resource", func() {
 			Context("when the check order is 0", func() {
 				BeforeEach(func() {
 					version = atc.Version{"version": "2"}
-					created, err := resource.SaveUncheckedVersion(version, nil, resourceScope.ResourceConfig(), creds.VersionedResourceTypes{})
+					created, err := resource.SaveUncheckedVersion(version, nil, resourceScope.ResourceConfig(), atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 					Expect(created).To(BeTrue())
 				})
@@ -710,7 +708,7 @@ var _ = Describe("Resource", func() {
 				_, err = brt.FindOrCreate(setupTx, false)
 				Expect(err).NotTo(HaveOccurred())
 				Expect(setupTx.Commit()).To(Succeed())
-				_, err = resourceConfigFactory.FindOrCreateResourceConfig(logger, "registry-image", atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+				_, err = resourceConfigFactory.FindOrCreateResourceConfig("registry-image", atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 				Expect(err).NotTo(HaveOccurred())
 			})
 
@@ -748,7 +746,7 @@ var _ = Describe("Resource", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(found).To(BeTrue())
 
-				resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "other-repository"}, creds.VersionedResourceTypes{})
+				resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "other-repository"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				originalVersionSlice = []atc.Version{
@@ -789,6 +787,10 @@ var _ = Describe("Resource", func() {
 
 					resourceVersions = append(resourceVersions, resourceVersion)
 				}
+
+				reloaded, err := resource.Reload()
+				Expect(err).ToNot(HaveOccurred())
+				Expect(reloaded).To(BeTrue())
 			})
 
 			Context("with no since/until", func() {
@@ -861,7 +863,7 @@ var _ = Describe("Resource", func() {
 					metadata := []db.ResourceConfigMetadataField{{Name: "name1", Value: "value1"}}
 
 					// save metadata
-					_, err := resource.SaveUncheckedVersion(atc.Version(resourceVersions[9].Version), metadata, resourceScope.ResourceConfig(), creds.VersionedResourceTypes{})
+					_, err := resource.SaveUncheckedVersion(atc.Version(resourceVersions[9].Version), metadata, resourceScope.ResourceConfig(), atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 				})
 
@@ -889,6 +891,27 @@ var _ = Describe("Resource", func() {
 					Expect(historyPage).To(ConsistOf([]atc.ResourceVersion{resourceVersions[9]}))
 				})
 			})
+
+			Context("when the version metadata is updated", func() {
+				var metadata db.ResourceConfigMetadataFields
+
+				BeforeEach(func() {
+					metadata = []db.ResourceConfigMetadataField{{Name: "name1", Value: "value1"}}
+
+					updated, err := resource.UpdateMetadata(resourceVersions[9].Version, metadata)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(updated).To(BeTrue())
+				})
+
+				It("returns a version with metadata updated", func() {
+					historyPage, _, found, err := resource.Versions(db.Page{Limit: 1})
+					Expect(err).ToNot(HaveOccurred())
+					Expect(found).To(BeTrue())
+					Expect(len(historyPage)).To(Equal(1))
+					Expect(historyPage[0].Version).To(Equal(resourceVersions[9].Version))
+					Expect(historyPage[0].Metadata).To(Equal([]atc.MetadataField{{Name: "name1", Value: "value1"}}))
+				})
+			})
 		})
 
 		Context("when check orders are different than versions ids", func() {
@@ -911,7 +934,7 @@ var _ = Describe("Resource", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(found).To(BeTrue())
 
-				resourceScope, err = resource.SetResourceConfig(logger, atc.Source{"some": "other-repository"}, creds.VersionedResourceTypes{})
+				resourceScope, err = resource.SetResourceConfig(atc.Source{"some": "other-repository"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				originalVersionSlice := []atc.Version{
@@ -1044,10 +1067,10 @@ var _ = Describe("Resource", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(found).To(BeTrue())
 
-				resourceScope, err := resource.SetResourceConfig(logger, atc.Source{"some": "other-repository"}, creds.VersionedResourceTypes{})
+				resourceScope, err := resource.SetResourceConfig(atc.Source{"some": "other-repository"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
-				created, err := resource.SaveUncheckedVersion(atc.Version{"version": "not-returned"}, nil, resourceScope.ResourceConfig(), creds.VersionedResourceTypes{})
+				created, err := resource.SaveUncheckedVersion(atc.Version{"version": "not-returned"}, nil, resourceScope.ResourceConfig(), atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 				Expect(created).To(BeTrue())
 			})
@@ -1084,7 +1107,7 @@ var _ = Describe("Resource", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(setupTx.Commit()).To(Succeed())
 
-			resourceScope, err := resource.SetResourceConfig(logger, atc.Source{"some": "other-repository"}, creds.VersionedResourceTypes{})
+			resourceScope, err := resource.SetResourceConfig(atc.Source{"some": "other-repository"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = resourceScope.SaveVersions([]atc.Version{
@@ -1168,7 +1191,7 @@ var _ = Describe("Resource", func() {
 				Expect(err).NotTo(HaveOccurred())
 				Expect(setupTx.Commit()).To(Succeed())
 
-				resourceScope, err := resource.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+				resourceScope, err := resource.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				err = resourceScope.SaveVersions([]atc.Version{

atc/db/resource_type.go

@@ -6,10 +6,8 @@ import (
 	"errors"
 	"fmt"
 
-	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/lock"
 )
 
@@ -36,7 +34,7 @@ type ResourceType interface {
 	CheckError() error
 	UniqueVersionHistory() bool
 
-	SetResourceConfig(lager.Logger, atc.Source, creds.VersionedResourceTypes) (ResourceConfigScope, error)
+	SetResourceConfig(atc.Source, atc.VersionedResourceTypes) (ResourceConfigScope, error)
 	SetCheckSetupError(error) error
 
 	Version() atc.Version
@@ -146,7 +144,7 @@ func (t *resourceType) Reload() (bool, error) {
 	return true, nil
 }
 
-func (t *resourceType) SetResourceConfig(logger lager.Logger, source atc.Source, resourceTypes creds.VersionedResourceTypes) (ResourceConfigScope, error) {
+func (t *resourceType) SetResourceConfig(source atc.Source, resourceTypes atc.VersionedResourceTypes) (ResourceConfigScope, error) {
 	resourceConfigDescriptor, err := constructResourceConfigDescriptor(t.type_, source, resourceTypes)
 	if err != nil {
 		return nil, err
@@ -159,7 +157,7 @@ func (t *resourceType) SetResourceConfig(logger lager.Logger, source atc.Source,
 
 	defer Rollback(tx)
 
-	resourceConfig, err := resourceConfigDescriptor.findOrCreate(logger, tx, t.lockFactory, t.conn)
+	resourceConfig, err := resourceConfigDescriptor.findOrCreate(tx, t.lockFactory, t.conn)
 	if err != nil {
 		return nil, err
 	}

atc/db/resource_type_test.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -202,7 +201,7 @@ var _ = Describe("ResourceType", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(setupTx.Commit()).To(Succeed())
 
-			resourceTypeScope, err = resourceType.SetResourceConfig(logger, atc.Source{"some": "repository"}, creds.VersionedResourceTypes{})
+			resourceTypeScope, err = resourceType.SetResourceConfig(atc.Source{"some": "repository"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 		})
 

atc/db/team.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"time"
 
-	"code.cloudfoundry.org/lager"
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/creds"
@@ -54,12 +53,12 @@ type Team interface {
 	Workers() ([]Worker, error)
 	FindVolumeForWorkerArtifact(int) (CreatedVolume, bool, error)
 
-	Containers(lager.Logger) ([]Container, error)
+	Containers() ([]Container, error)
 	IsCheckContainer(string) (bool, error)
 	IsContainerWithinTeam(string, bool) (bool, error)
 
 	FindContainerByHandle(string) (Container, bool, error)
-	FindCheckContainers(lager.Logger, string, string, creds.Secrets) ([]Container, map[int]time.Time, error)
+	FindCheckContainers(string, string, creds.Secrets) ([]Container, map[int]time.Time, error)
 	FindContainersByMetadata(ContainerMetadata) ([]Container, error)
 	FindCreatedContainerByHandle(string) (CreatedContainer, bool, error)
 	FindWorkerForContainer(handle string) (Worker, bool, error)
@@ -152,9 +151,7 @@ func (t *team) FindWorkerForVolume(handle string) (Worker, bool, error) {
 	}))
 }
 
-func (t *team) Containers(
+func (t *team) Containers() ([]Container, error) {
-	logger lager.Logger,
-) ([]Container, error) {
 	rows, err := selectContainers("c").
 		Join("workers w ON c.worker_name = w.name").
 		Join("resource_config_check_sessions rccs ON rccs.id = c.resource_config_check_session_id").
@@ -808,7 +805,7 @@ func (t *team) UpdateProviderAuth(auth atc.TeamAuth) error {
 	return tx.Commit()
 }
 
-func (t *team) FindCheckContainers(logger lager.Logger, pipelineName string, resourceName string, secretManager creds.Secrets) ([]Container, map[int]time.Time, error) {
+func (t *team) FindCheckContainers(pipelineName string, resourceName string, secretManager creds.Secrets) ([]Container, map[int]time.Time, error) {
 	pipeline, found, err := t.Pipeline(pipelineName)
 	if err != nil {
 		return nil, nil, err
@@ -839,12 +836,16 @@ func (t *team) FindCheckContainers(logger lager.Logger, pipelineName string, res
 		return nil, nil, err
 	}
 
+	resourceTypes, err := creds.NewVersionedResourceTypes(variables, versionedResourceTypes).Evaluate()
+	if err != nil {
+		return nil, nil, err
+	}
+
 	resourceConfigFactory := NewResourceConfigFactory(t.conn, t.lockFactory)
 	resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(
-		logger,
 		resource.Type(),
 		source,
-		creds.NewVersionedResourceTypes(variables, versionedResourceTypes),
+		resourceTypes,
 	)
 	if err != nil {
 		return nil, nil, err
@@ -903,8 +904,8 @@ func (t *team) FindCheckContainers(logger lager.Logger, pipelineName string, res
 }
 
 type UpdateName struct {
-	OldName  string
+	OldName string
-	NewName  string
+	NewName string
 }
 
 func (t *team) updateName(tx Tx, jobs []atc.JobConfig, pipelineID int) error {
@@ -916,7 +917,7 @@ func (t *team) updateName(tx Tx, jobs []atc.JobConfig, pipelineID int) error {
 			err := psql.Select("COUNT(*) as count").
 				From("jobs").
 				Where(sq.Eq{
-					"name": job.OldName,
+					"name":        job.OldName,
 					"pipeline_id": pipelineID}).
 				RunWith(tx).
 				QueryRow().
@@ -947,9 +948,9 @@ func (t *team) updateName(tx Tx, jobs []atc.JobConfig, pipelineID int) error {
 	for _, updateName := range jobsToUpdate {
 		_, err := psql.Delete("jobs").
 			Where(sq.Eq{
-				"name": updateName.NewName,
+				"name":        updateName.NewName,
 				"pipeline_id": pipelineID,
-				"active": false}).
+				"active":      false}).
 			RunWith(tx).
 			Exec()
 		if err != nil {
@@ -985,10 +986,10 @@ func checkCyclic(jobNames []UpdateName, curr string, visited map[int]bool) bool
 func sortUpdateNames(jobNames []UpdateName) []UpdateName {
 	newMap := make(map[string]int)
 	for i, job := range jobNames {
-		newMap[job.NewName] = i+1
+		newMap[job.NewName] = i + 1
 
 		if newMap[job.OldName] != 0 {
-			index := newMap[job.OldName]-1
+			index := newMap[job.OldName] - 1
 
 			tempJob := jobNames[index]
 			jobNames[index] = job

atc/db/team_test.go

@@ -6,9 +6,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/creds/credsfakes"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/event"
@@ -430,14 +428,14 @@ var _ = Describe("Team", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				expiries := db.ContainerOwnerExpiries{
-					Min:       5 * time.Minute,
+					Min: 5 * time.Minute,
-					Max:       1 * time.Hour,
+					Max: 1 * time.Hour,
 				}
 
 				pipelineResourceTypes, err := defaultPipeline.ResourceTypes()
 				Expect(err).ToNot(HaveOccurred())
 
-				resourceConfigScope, err = defaultResource.SetResourceConfig(logger, defaultResource.Source(), creds.NewVersionedResourceTypes(template.StaticVariables{}, pipelineResourceTypes.Deserialize()))
+				resourceConfigScope, err = defaultResource.SetResourceConfig(defaultResource.Source(), pipelineResourceTypes.Deserialize())
 				Expect(err).ToNot(HaveOccurred())
 
 				resourceContainer, err = defaultWorker.CreateContainer(
@@ -448,7 +446,7 @@ var _ = Describe("Team", func() {
 			})
 
 			It("finds all the containers", func() {
-				containers, err := defaultTeam.Containers(logger)
+				containers, err := defaultTeam.Containers()
 				Expect(err).ToNot(HaveOccurred())
 
 				Expect(containers).To(HaveLen(2))
@@ -456,7 +454,7 @@ var _ = Describe("Team", func() {
 			})
 
 			It("does not find containers for other teams", func() {
-				containers, err := otherTeam.Containers(logger)
+				containers, err := otherTeam.Containers()
 				Expect(err).ToNot(HaveOccurred())
 				Expect(containers).To(BeEmpty())
 			})
@@ -479,11 +477,11 @@ var _ = Describe("Team", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				expiries := db.ContainerOwnerExpiries{
-					Min:       5 * time.Minute,
+					Min: 5 * time.Minute,
-					Max:       1 * time.Hour,
+					Max: 1 * time.Hour,
 				}
 
-				resourceConfigScope, err = defaultResource.SetResourceConfig(logger, defaultResource.Source(), creds.VersionedResourceTypes{})
+				resourceConfigScope, err = defaultResource.SetResourceConfig(defaultResource.Source(), atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				resourceContainer, err = worker.CreateContainer(
@@ -496,7 +494,7 @@ var _ = Describe("Team", func() {
 			})
 
 			It("finds the container", func() {
-				containers, err := defaultTeam.Containers(logger)
+				containers, err := defaultTeam.Containers()
 				Expect(err).ToNot(HaveOccurred())
 
 				Expect(containers).To(HaveLen(1))
@@ -557,11 +555,11 @@ var _ = Describe("Team", func() {
 					Expect(err).ToNot(HaveOccurred())
 
 					expiries := db.ContainerOwnerExpiries{
-						Min:       5 * time.Minute,
+						Min: 5 * time.Minute,
-						Max:       1 * time.Hour,
+						Max: 1 * time.Hour,
 					}
 
-					resourceConfigScope, err = otherResource.SetResourceConfig(logger, otherResource.Source(), creds.VersionedResourceTypes{})
+					resourceConfigScope, err = otherResource.SetResourceConfig(otherResource.Source(), atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 
 					resource2Container, err = worker.CreateContainer(
@@ -574,7 +572,7 @@ var _ = Describe("Team", func() {
 				})
 
 				It("returns the container only from the team", func() {
-					containers, err := otherTeam.Containers(logger)
+					containers, err := otherTeam.Containers()
 					Expect(err).ToNot(HaveOccurred())
 
 					Expect(containers).To(HaveLen(1))
@@ -589,11 +587,11 @@ var _ = Describe("Team", func() {
 
 				BeforeEach(func() {
 					expiries := db.ContainerOwnerExpiries{
-						Min:       5 * time.Minute,
+						Min: 5 * time.Minute,
-						Max:       1 * time.Hour,
+						Max: 1 * time.Hour,
 					}
 
-					resourceConfigScope, err := defaultResource.SetResourceConfig(logger, defaultResource.Source(), creds.VersionedResourceTypes{})
+					resourceConfigScope, err := defaultResource.SetResourceConfig(defaultResource.Source(), atc.VersionedResourceTypes{})
 					Expect(err).ToNot(HaveOccurred())
 
 					globalResourceContainer, err = defaultWorker.CreateContainer(
@@ -606,7 +604,7 @@ var _ = Describe("Team", func() {
 				})
 
 				It("returns the container only from the team worker and global worker", func() {
-					containers, err := defaultTeam.Containers(logger)
+					containers, err := defaultTeam.Containers()
 					Expect(err).ToNot(HaveOccurred())
 
 					Expect(containers).To(HaveLen(2))
@@ -620,11 +618,11 @@ var _ = Describe("Team", func() {
 
 			BeforeEach(func() {
 				expiries := db.ContainerOwnerExpiries{
-					Min:       5 * time.Minute,
+					Min: 5 * time.Minute,
-					Max:       1 * time.Hour,
+					Max: 1 * time.Hour,
 				}
 
-				resourceConfigScope, err := defaultResourceType.SetResourceConfig(logger, defaultResourceType.Source(), creds.VersionedResourceTypes{})
+				resourceConfigScope, err := defaultResourceType.SetResourceConfig(defaultResourceType.Source(), atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 
 				resourceContainer, err = defaultWorker.CreateContainer(
@@ -637,7 +635,7 @@ var _ = Describe("Team", func() {
 			})
 
 			It("finds the container", func() {
-				containers, err := defaultTeam.Containers(logger)
+				containers, err := defaultTeam.Containers()
 				Expect(err).ToNot(HaveOccurred())
 
 				Expect(containers).To(HaveLen(1))
@@ -1773,7 +1771,7 @@ var _ = Describe("Team", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(setupTx.Commit()).To(Succeed())
 
-			rc, err := resource.SetResourceConfig(logger, atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{})
+			rc, err := resource.SetResourceConfig(atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = rc.SaveVersions([]atc.Version{
@@ -1827,7 +1825,7 @@ var _ = Describe("Team", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(setupTx.Commit()).To(Succeed())
 
-			rc, err := resource.SetResourceConfig(logger, atc.Source{"source-config": "some-value"}, creds.VersionedResourceTypes{})
+			rc, err := resource.SetResourceConfig(atc.Source{"source-config": "some-value"}, atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			err = rc.SaveVersions([]atc.Version{
@@ -2579,12 +2577,11 @@ var _ = Describe("Team", func() {
 	Describe("FindCheckContainers", func() {
 		var (
 			fakeSecretManager *credsfakes.FakeSecrets
-			variables         creds.Variables
 		)
 
 		expiries := db.ContainerOwnerExpiries{
-			Min:       5 * time.Minute,
+			Min: 5 * time.Minute,
-			Max:       1 * time.Hour,
+			Max: 1 * time.Hour,
 		}
 
 		BeforeEach(func() {
@@ -2603,10 +2600,9 @@ var _ = Describe("Team", func() {
 						Expect(err).ToNot(HaveOccurred())
 
 						resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(
-							logger,
 							defaultResource.Type(),
 							defaultResource.Source(),
-							creds.NewVersionedResourceTypes(variables, pipelineResourceTypes.Deserialize()),
+							pipelineResourceTypes.Deserialize(),
 						)
 						Expect(err).ToNot(HaveOccurred())
 
@@ -2618,7 +2614,7 @@ var _ = Describe("Team", func() {
 					})
 
 					It("returns check container for resource", func() {
-						containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers(logger, "default-pipeline", "some-resource", fakeSecretManager)
+						containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers("default-pipeline", "some-resource", fakeSecretManager)
 						Expect(err).ToNot(HaveOccurred())
 						Expect(containers).To(HaveLen(1))
 						Expect(containers[0].ID()).To(Equal(resourceContainer.ID()))
@@ -2654,21 +2650,20 @@ var _ = Describe("Team", func() {
 							Expect(found).To(BeTrue())
 
 							resourceConfig, err = resourceConfigFactory.FindOrCreateResourceConfig(
-								logger,
 								otherResource.Type(),
 								otherResource.Source(),
-								creds.VersionedResourceTypes{},
+								atc.VersionedResourceTypes{},
 							)
 							Expect(err).ToNot(HaveOccurred())
 
-							otherResourceContainer, _, err = defaultWorker.FindContainerOnWorker(
+							otherResourceContainer, _, err = defaultWorker.FindContainer(
 								db.NewResourceConfigCheckSessionContainerOwner(resourceConfig, expiries),
 							)
 							Expect(err).ToNot(HaveOccurred())
 						})
 
 						It("returns the same check container", func() {
-							containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers(logger, "other-pipeline", "some-resource", fakeSecretManager)
+							containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers("other-pipeline", "some-resource", fakeSecretManager)
 							Expect(err).ToNot(HaveOccurred())
 							Expect(containers).To(HaveLen(1))
 							Expect(containers[0].ID()).To(Equal(otherResourceContainer.ID()))
@@ -2681,7 +2676,7 @@ var _ = Describe("Team", func() {
 
 				Context("when check container does not exist", func() {
 					It("returns empty list", func() {
-						containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers(logger, "default-pipeline", "some-resource", fakeSecretManager)
+						containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers("default-pipeline", "some-resource", fakeSecretManager)
 						Expect(err).ToNot(HaveOccurred())
 						Expect(containers).To(BeEmpty())
 						Expect(checkContainersExpiresAt).To(BeEmpty())
@@ -2691,7 +2686,7 @@ var _ = Describe("Team", func() {
 
 			Context("when resource does not exist", func() {
 				It("returns empty list", func() {
-					containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers(logger, "default-pipeline", "non-existent-resource", fakeSecretManager)
+					containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers("default-pipeline", "non-existent-resource", fakeSecretManager)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(containers).To(BeEmpty())
 					Expect(checkContainersExpiresAt).To(BeEmpty())
@@ -2701,7 +2696,7 @@ var _ = Describe("Team", func() {
 
 		Context("when pipeline does not exist", func() {
 			It("returns empty list", func() {
-				containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers(logger, "non-existent-pipeline", "some-resource", fakeSecretManager)
+				containers, checkContainersExpiresAt, err := defaultTeam.FindCheckContainers("non-existent-pipeline", "some-resource", fakeSecretManager)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(containers).To(BeEmpty())
 				Expect(checkContainersExpiresAt).To(BeEmpty())
@@ -2713,15 +2708,14 @@ var _ = Describe("Team", func() {
 		Context("when the container is a check container", func() {
 			var resourceContainer db.Container
 			expiries := db.ContainerOwnerExpiries{
-				Min:       5 * time.Minute,
+				Min: 5 * time.Minute,
-				Max:       1 * time.Hour,
+				Max: 1 * time.Hour,
 			}
 
 			BeforeEach(func() {
 				resourceConfigScope, err := defaultResource.SetResourceConfig(
-					logger,
 					defaultResource.Source(),
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).ToNot(HaveOccurred())
 

atc/db/volume_repository_test.go

@@ -4,9 +4,7 @@ import (
 	"time"
 
 	sq "github.com/Masterminds/squirrel"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/lib/pq"
 	. "github.com/onsi/ginkgo"
@@ -26,7 +24,6 @@ var _ = Describe("VolumeFactory", func() {
 		Expect(err).ToNot(HaveOccurred())
 
 		usedResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-			logger,
 			db.ForBuild(build.ID()),
 			"some-type",
 			atc.Version{"some": "version"},
@@ -34,21 +31,18 @@ var _ = Describe("VolumeFactory", func() {
 				"some": "source",
 			},
 			atc.Params{"some": "params"},
-			creds.NewVersionedResourceTypes(
+			atc.VersionedResourceTypes{
-				template.StaticVariables{},
+				atc.VersionedResourceType{
-				atc.VersionedResourceTypes{
+					ResourceType: atc.ResourceType{
-					atc.VersionedResourceType{
+						Name: "some-type",
-						ResourceType: atc.ResourceType{
+						Type: "some-base-resource-type",
-							Name: "some-type",
+						Source: atc.Source{
-							Type: "some-base-resource-type",
+							"some-type": "source",
-							Source: atc.Source{
-								"some-type": "source",
-							},
 						},
-						Version: atc.Version{"some-type": "version"},
 					},
+					Version: atc.Version{"some-type": "version"},
 				},
-			),
+			},
 		)
 		Expect(err).NotTo(HaveOccurred())
 	})
@@ -493,7 +487,6 @@ var _ = Describe("VolumeFactory", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			usedResourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type",
 				atc.Version{"some": "version"},
@@ -501,21 +494,18 @@ var _ = Describe("VolumeFactory", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{
-					template.StaticVariables{"source-param": "some-secret-sauce"},
+					atc.VersionedResourceType{
-					atc.VersionedResourceTypes{
+						ResourceType: atc.ResourceType{
-						atc.VersionedResourceType{
+							Name: "some-type",
-							ResourceType: atc.ResourceType{
+							Type: "some-base-resource-type",
-								Name: "some-type",
+							Source: atc.Source{
-								Type: "some-base-resource-type",
+								"some-type": "source",
-								Source: atc.Source{
-									"some-type": "source",
-								},
 							},
-							Version: atc.Version{"some-type": "version"},
 						},
+						Version: atc.Version{"some-type": "version"},
 					},
-				),
+				},
 			)
 			Expect(err).ToNot(HaveOccurred())
 		})

atc/db/volume_test.go

@@ -3,9 +3,7 @@ package db_test
 import (
 	"time"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -17,11 +15,11 @@ var _ = Describe("Volume", func() {
 
 	BeforeEach(func() {
 		expiries := db.ContainerOwnerExpiries{
-			Min:       5 * time.Minute,
+			Min: 5 * time.Minute,
-			Max:       1 * time.Hour,
+			Max: 1 * time.Hour,
 		}
 
-		resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(logger, "some-base-resource-type", atc.Source{}, creds.VersionedResourceTypes{})
+		resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig("some-base-resource-type", atc.Source{}, atc.VersionedResourceTypes{})
 		Expect(err).ToNot(HaveOccurred())
 
 		defaultCreatingContainer, err = defaultWorker.CreateContainer(db.NewResourceConfigCheckSessionContainerOwner(resourceConfig, expiries), db.ContainerMetadata{Type: "check"})
@@ -188,7 +186,6 @@ var _ = Describe("Volume", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type",
 				atc.Version{"some": "version"},
@@ -196,21 +193,18 @@ var _ = Describe("Volume", func() {
 					"some": "source",
 				},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(
+				atc.VersionedResourceTypes{
-					template.StaticVariables{"source-param": "some-secret-sauce"},
+					atc.VersionedResourceType{
-					atc.VersionedResourceTypes{
+						ResourceType: atc.ResourceType{
-						atc.VersionedResourceType{
+							Name: "some-type",
-							ResourceType: atc.ResourceType{
+							Type: "some-base-resource-type",
-								Name: "some-type",
+							Source: atc.Source{
-								Type: "some-base-resource-type",
+								"some-type": "source",
-								Source: atc.Source{
-									"some-type": "source",
-								},
 							},
-							Version: atc.Version{"some-type": "version"},
 						},
+						Version: atc.Version{"some-type": "version"},
 					},
-				),
+				},
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -414,24 +408,22 @@ var _ = Describe("Volume", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type",
 				atc.Version{"some": "version"},
 				atc.Source{"some": "source"},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+
-					atc.VersionedResourceTypes{
+				atc.VersionedResourceTypes{
-						{
+					{
-							ResourceType: atc.ResourceType{
+						ResourceType: atc.ResourceType{
-								Name:   "some-type",
+							Name:   "some-type",
-								Type:   "some-base-resource-type",
+							Type:   "some-base-resource-type",
-								Source: atc.Source{"some-type": "((source-param))"},
+							Source: atc.Source{"some-type": "((source-param))"},
-							},
-							Version: atc.Version{"some-custom-type": "version"},
 						},
+						Version: atc.Version{"some-custom-type": "version"},
 					},
-				),
+				},
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -543,24 +535,21 @@ var _ = Describe("Volume", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			usedResourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-type",
 				atc.Version{"some": "version"},
 				atc.Source{"some": "source"},
 				atc.Params{"some": "params"},
-				creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+				atc.VersionedResourceTypes{
-					atc.VersionedResourceTypes{
+					{
-						{
+						ResourceType: atc.ResourceType{
-							ResourceType: atc.ResourceType{
+							Name:   "some-type",
-								Name:   "some-type",
+							Type:   "some-base-resource-type",
-								Type:   "some-base-resource-type",
+							Source: atc.Source{"some-type": "source"},
-								Source: atc.Source{"some-type": "source"},
-							},
-							Version: atc.Version{"some-custom-type": "version"},
 						},
+						Version: atc.Version{"some-custom-type": "version"},
 					},
-				),
+				},
 			)
 			Expect(err).ToNot(HaveOccurred())
 

atc/db/worker.go

@@ -67,7 +67,7 @@ type Worker interface {
 	Prune() error
 	Delete() error
 
-	FindContainerOnWorker(owner ContainerOwner) (CreatingContainer, CreatedContainer, error)
+	FindContainer(owner ContainerOwner) (CreatingContainer, CreatedContainer, error)
 	CreateContainer(owner ContainerOwner, meta ContainerMetadata) (CreatingContainer, error)
 }
 
@@ -255,7 +255,7 @@ func (worker *worker) ResourceCerts() (*UsedWorkerResourceCerts, bool, error) {
 	return nil, false, nil
 }
 
-func (worker *worker) FindContainerOnWorker(owner ContainerOwner) (CreatingContainer, CreatedContainer, error) {
+func (worker *worker) FindContainer(owner ContainerOwner) (CreatingContainer, CreatedContainer, error) {
 	ownerQuery, found, err := owner.Find(worker.conn)
 	if err != nil {
 		return nil, nil, err

atc/db/worker_factory_test.go

@@ -5,7 +5,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 
@@ -566,8 +565,8 @@ var _ = Describe("WorkerFactory", func() {
 
 				BeforeEach(func() {
 					ownerExpiries := db.ContainerOwnerExpiries{
-						Min:       5 * time.Minute,
+						Min: 5 * time.Minute,
-						Max:       5 * time.Minute,
+						Max: 5 * time.Minute,
 					}
 
 					var err error
@@ -624,7 +623,7 @@ var _ = Describe("WorkerFactory", func() {
 					Expect(err).NotTo(HaveOccurred())
 					Expect(found).To(BeTrue())
 
-					rcs, err := otherResource.SetResourceConfig(logger, atc.Source{"some": "source"}, creds.VersionedResourceTypes{})
+					rcs, err := otherResource.SetResourceConfig(atc.Source{"some": "source"}, atc.VersionedResourceTypes{})
 					Expect(err).NotTo(HaveOccurred())
 
 					owner = db.NewResourceConfigCheckSessionContainerOwner(rcs.ResourceConfig(), ownerExpiries)

atc/db/worker_resource_cache_test.go

@@ -2,7 +2,6 @@ package db_test
 
 import (
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -18,13 +17,12 @@ var _ = Describe("WorkerResourceCache", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-base-resource-type",
 				atc.Version{"some": "version"},
 				atc.Source{"some": "source"},
 				atc.Params{},
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -82,13 +80,12 @@ var _ = Describe("WorkerResourceCache", func() {
 			Expect(err).ToNot(HaveOccurred())
 
 			resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-				logger,
 				db.ForBuild(build.ID()),
 				"some-base-resource-type",
 				atc.Version{"some": "version"},
 				atc.Source{"some": "source"},
 				atc.Params{},
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -133,13 +130,12 @@ var _ = Describe("WorkerResourceCache", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				resourceCache, err := resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForBuild(build.ID()),
 					"some-bogus-resource-type",
 					atc.Version{"some": "version"},
 					atc.Source{"some": "source"},
 					atc.Params{},
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).ToNot(HaveOccurred())
 

atc/db/worker_test.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	. "github.com/concourse/concourse/atc/db"
 
 	. "github.com/onsi/ginkgo"
@@ -206,7 +205,7 @@ var _ = Describe("Worker", func() {
 		})
 	})
 
-	Describe("FindContainerOnWorker/CreateContainer", func() {
+	Describe("FindContainer/CreateContainer", func() {
 		var (
 			containerMetadata ContainerMetadata
 			containerOwner    ContainerOwner
@@ -217,8 +216,8 @@ var _ = Describe("Worker", func() {
 		)
 
 		expiries := ContainerOwnerExpiries{
-			Min:       5 * time.Minute,
+			Min: 5 * time.Minute,
-			Max:       1 * time.Hour,
+			Max: 1 * time.Hour,
 		}
 
 		BeforeEach(func() {
@@ -237,10 +236,9 @@ var _ = Describe("Worker", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(
-				logger,
 				"some-resource-type",
 				atc.Source{"some": "source"},
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -249,7 +247,7 @@ var _ = Describe("Worker", func() {
 
 		JustBeforeEach(func() {
 			var err error
-			foundCreatingContainer, foundCreatedContainer, err = worker.FindContainerOnWorker(containerOwner)
+			foundCreatingContainer, foundCreatedContainer, err = worker.FindContainer(containerOwner)
 			Expect(err).ToNot(HaveOccurred())
 		})
 

atc/engine/builder/builder.go

@@ -2,7 +2,6 @@ package builder
 
 import (
 	"errors"
-	"fmt"
 	"strconv"
 	"strings"
 
@@ -16,9 +15,9 @@ const supportedSchema = "exec.v2"
 //go:generate counterfeiter . StepFactory
 
 type StepFactory interface {
-	GetStep(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step
+	GetStep(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step
-	PutStep(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step
+	PutStep(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step
-	TaskStep(atc.Plan, db.Build, db.ContainerMetadata, exec.TaskDelegate) exec.Step
+	TaskStep(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.TaskDelegate) exec.Step
 	ArtifactInputStep(atc.Plan, db.Build, exec.BuildStepDelegate) exec.Step
 	ArtifactOutputStep(atc.Plan, db.Build, exec.BuildStepDelegate) exec.Step
 }
@@ -254,7 +253,6 @@ func (builder *stepBuilder) buildGetStep(build db.Build, plan atc.Plan) exec.Ste
 
 	return builder.stepFactory.GetStep(
 		plan,
-		build,
 		stepMetadata,
 		containerMetadata,
 		builder.delegateFactory.GetDelegate(build, plan.ID),
@@ -277,7 +275,6 @@ func (builder *stepBuilder) buildPutStep(build db.Build, plan atc.Plan) exec.Ste
 
 	return builder.stepFactory.PutStep(
 		plan,
-		build,
 		stepMetadata,
 		containerMetadata,
 		builder.delegateFactory.PutDelegate(build, plan.ID),
@@ -293,9 +290,14 @@ func (builder *stepBuilder) buildTaskStep(build db.Build, plan atc.Plan) exec.St
 		plan.Attempts,
 	)
 
+	stepMetadata := builder.stepMetadata(
+		build,
+		builder.externalURL,
+	)
+
 	return builder.stepFactory.TaskStep(
 		plan,
-		build,
+		stepMetadata,
 		containerMetadata,
 		builder.delegateFactory.TaskDelegate(build, plan.ID),
 	)
@@ -349,49 +351,16 @@ func (builder *stepBuilder) containerMetadata(
 func (builder *stepBuilder) stepMetadata(
 	build db.Build,
 	externalURL string,
-) StepMetadata {
+) exec.StepMetadata {
-	return StepMetadata{
+	return exec.StepMetadata{
 		BuildID:      build.ID(),
 		BuildName:    build.Name(),
-		JobName:      build.JobName(),
+		TeamID:       build.TeamID(),
-		PipelineName: build.PipelineName(),
 		TeamName:     build.TeamName(),
+		JobID:        build.JobID(),
+		JobName:      build.JobName(),
+		PipelineID:   build.PipelineID(),
+		PipelineName: build.PipelineName(),
 		ExternalURL:  externalURL,
 	}
 }
-
-type StepMetadata struct {
-	BuildID int
-
-	PipelineName string
-	JobName      string
-	BuildName    string
-	ExternalURL  string
-	TeamName     string
-}
-
-func (metadata StepMetadata) Env() []string {
-	env := []string{fmt.Sprintf("BUILD_ID=%d", metadata.BuildID)}
-
-	if metadata.PipelineName != "" {
-		env = append(env, "BUILD_PIPELINE_NAME="+metadata.PipelineName)
-	}
-
-	if metadata.JobName != "" {
-		env = append(env, "BUILD_JOB_NAME="+metadata.JobName)
-	}
-
-	if metadata.BuildName != "" {
-		env = append(env, "BUILD_NAME="+metadata.BuildName)
-	}
-
-	if metadata.ExternalURL != "" {
-		env = append(env, "ATC_EXTERNAL_URL="+metadata.ExternalURL)
-	}
-
-	if metadata.TeamName != "" {
-		env = append(env, "BUILD_TEAM_NAME="+metadata.TeamName)
-	}
-
-	return env
-}

atc/engine/builder/builder_test.go

@@ -58,7 +58,7 @@ var _ = Describe("Builder", func() {
 				fakeBuild *dbfakes.FakeBuild
 
 				expectedPlan     atc.Plan
-				expectedMetadata builder.StepMetadata
+				expectedMetadata exec.StepMetadata
 			)
 
 			BeforeEach(func() {
@@ -72,12 +72,15 @@ var _ = Describe("Builder", func() {
 				fakeBuild.TeamNameReturns("some-team")
 				fakeBuild.TeamIDReturns(1111)
 
-				expectedMetadata = builder.StepMetadata{
+				expectedMetadata = exec.StepMetadata{
 					BuildID:      4444,
 					BuildName:    "42",
-					JobName:      "some-job",
+					TeamID:       1111,
-					PipelineName: "some-pipeline",
 					TeamName:     "some-team",
+					JobID:        3333,
+					JobName:      "some-job",
+					PipelineID:   2222,
+					PipelineName: "some-pipeline",
 					ExternalURL:  "http://example.com",
 				}
 			})
@@ -146,8 +149,7 @@ var _ = Describe("Builder", func() {
 
 					Context("constructing outputs", func() {
 						It("constructs the put correctly", func() {
-							plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(putPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -161,8 +163,7 @@ var _ = Describe("Builder", func() {
 								BuildName:    "42",
 							}))
 
-							plan, build, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
+							plan, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(otherPutPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -222,8 +223,7 @@ var _ = Describe("Builder", func() {
 
 					Context("constructing outputs", func() {
 						It("constructs the put correctly", func() {
-							plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(putPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -237,8 +237,7 @@ var _ = Describe("Builder", func() {
 								BuildName:    "42",
 							}))
 
-							plan, build, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
+							plan, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(otherPutPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -314,8 +313,7 @@ var _ = Describe("Builder", func() {
 					})
 
 					It("constructs the first get correctly", func() {
-						plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
+						plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
-						Expect(build).To(Equal(fakeBuild))
 						expectedPlan := getPlan
 						expectedPlan.Attempts = []int{1}
 						Expect(plan).To(Equal(expectedPlan))
@@ -334,8 +332,7 @@ var _ = Describe("Builder", func() {
 					})
 
 					It("constructs the second get correctly", func() {
-						plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(1)
+						plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(1)
-						Expect(build).To(Equal(fakeBuild))
 						expectedPlan := getPlan
 						expectedPlan.Attempts = []int{3}
 						Expect(plan).To(Equal(expectedPlan))
@@ -358,11 +355,11 @@ var _ = Describe("Builder", func() {
 					})
 
 					It("constructs nested steps correctly", func() {
-						plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
+						plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
-						Expect(build).To(Equal(fakeBuild))
 						expectedPlan := taskPlan
 						expectedPlan.Attempts = []int{2, 1}
 						Expect(plan).To(Equal(expectedPlan))
+						Expect(stepMetadata).To(Equal(expectedMetadata))
 						Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 							Type:         db.ContainerTypeTask,
 							StepName:     "some-task",
@@ -375,11 +372,11 @@ var _ = Describe("Builder", func() {
 							Attempt:      "2.1",
 						}))
 
-						plan, build, containerMetadata, _ = fakeStepFactory.TaskStepArgsForCall(1)
+						plan, stepMetadata, containerMetadata, _ = fakeStepFactory.TaskStepArgsForCall(1)
-						Expect(build).To(Equal(fakeBuild))
 						expectedPlan = taskPlan
 						expectedPlan.Attempts = []int{2, 2}
 						Expect(plan).To(Equal(expectedPlan))
+						Expect(stepMetadata).To(Equal(expectedMetadata))
 						Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 							Type:         db.ContainerTypeTask,
 							StepName:     "some-task",
@@ -474,8 +471,7 @@ var _ = Describe("Builder", func() {
 						})
 
 						It("constructs inputs correctly", func() {
-							plan, dBuild, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
-							Expect(dBuild).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(expectedPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -502,9 +498,9 @@ var _ = Describe("Builder", func() {
 						})
 
 						It("constructs tasks correctly", func() {
-							plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(expectedPlan))
+							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 								Type:         db.ContainerTypeTask,
 								StepName:     "some-task",
@@ -551,8 +547,7 @@ var _ = Describe("Builder", func() {
 						})
 
 						It("constructs the put correctly", func() {
-							plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(putPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -568,8 +563,7 @@ var _ = Describe("Builder", func() {
 						})
 
 						It("constructs the dependent get correctly", func() {
-							plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(dependentGetPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -634,8 +628,7 @@ var _ = Describe("Builder", func() {
 
 						It("constructs the step correctly", func() {
 							Expect(fakeStepFactory.GetStepCallCount()).To(Equal(1))
-							plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(inputPlan))
 							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -652,9 +645,9 @@ var _ = Describe("Builder", func() {
 
 						It("constructs the completion hook correctly", func() {
 							Expect(fakeStepFactory.TaskStepCallCount()).To(Equal(4))
-							plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(2)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(2)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(completionTaskPlan))
+							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 								PipelineID:   2222,
 								PipelineName: "some-pipeline",
@@ -669,9 +662,9 @@ var _ = Describe("Builder", func() {
 
 						It("constructs the failure hook correctly", func() {
 							Expect(fakeStepFactory.TaskStepCallCount()).To(Equal(4))
-							plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(failureTaskPlan))
+							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 								PipelineID:   2222,
 								PipelineName: "some-pipeline",
@@ -686,9 +679,9 @@ var _ = Describe("Builder", func() {
 
 						It("constructs the success hook correctly", func() {
 							Expect(fakeStepFactory.TaskStepCallCount()).To(Equal(4))
-							plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(1)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(1)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(successTaskPlan))
+							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 								PipelineID:   2222,
 								PipelineName: "some-pipeline",
@@ -703,9 +696,9 @@ var _ = Describe("Builder", func() {
 
 						It("constructs the next step correctly", func() {
 							Expect(fakeStepFactory.TaskStepCallCount()).To(Equal(4))
-							plan, build, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(3)
+							plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(3)
-							Expect(build).To(Equal(fakeBuild))
 							Expect(plan).To(Equal(nextTaskPlan))
+							Expect(stepMetadata).To(Equal(expectedMetadata))
 							Expect(containerMetadata).To(Equal(db.ContainerMetadata{
 								PipelineID:   2222,
 								PipelineName: "some-pipeline",
@@ -735,8 +728,7 @@ var _ = Describe("Builder", func() {
 
 					It("constructs the step correctly", func() {
 						Expect(fakeStepFactory.GetStepCallCount()).To(Equal(1))
-						plan, build, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
+						plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
-						Expect(build).To(Equal(fakeBuild))
 						Expect(plan).To(Equal(inputPlan))
 						Expect(stepMetadata).To(Equal(expectedMetadata))
 						Expect(containerMetadata).To(Equal(db.ContainerMetadata{
@@ -755,46 +747,4 @@ var _ = Describe("Builder", func() {
 		})
 	})
 
-	Describe("StepMetadata", func() {
-		var stepMetadata builder.StepMetadata
-
-		Describe("Env", func() {
-			Context("when populating fields", func() {
-				BeforeEach(func() {
-					stepMetadata = builder.StepMetadata{
-						BuildID:      1,
-						PipelineName: "some-pipeline-name",
-						JobName:      "some-job-name",
-						BuildName:    "42",
-						ExternalURL:  "http://www.example.com",
-						TeamName:     "some-team",
-					}
-				})
-
-				It("returns the specified values", func() {
-					Expect(stepMetadata.Env()).To(Equal([]string{
-						"BUILD_ID=1",
-						"BUILD_PIPELINE_NAME=some-pipeline-name",
-						"BUILD_JOB_NAME=some-job-name",
-						"BUILD_NAME=42",
-						"ATC_EXTERNAL_URL=http://www.example.com",
-						"BUILD_TEAM_NAME=some-team",
-					}))
-				})
-			})
-
-			Context("when fields are empty", func() {
-				BeforeEach(func() {
-					stepMetadata = builder.StepMetadata{
-						BuildID: 1,
-					}
-				})
-				It("does not include fields that are not set", func() {
-					Expect(stepMetadata.Env()).To(Equal([]string{
-						"BUILD_ID=1",
-					}))
-				})
-			})
-		})
-	})
 })

atc/engine/builder/builderfakes/fake_step_factory.go

@@ -37,14 +37,13 @@ type FakeStepFactory struct {
 	artifactOutputStepReturnsOnCall map[int]struct {
 		result1 exec.Step
 	}
-	GetStepStub        func(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step
+	GetStepStub        func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step
 	getStepMutex       sync.RWMutex
 	getStepArgsForCall []struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
-		arg3 exec.StepMetadata
+		arg3 db.ContainerMetadata
-		arg4 db.ContainerMetadata
+		arg4 exec.GetDelegate
-		arg5 exec.GetDelegate
 	}
 	getStepReturns struct {
 		result1 exec.Step
@@ -52,14 +51,13 @@ type FakeStepFactory struct {
 	getStepReturnsOnCall map[int]struct {
 		result1 exec.Step
 	}
-	PutStepStub        func(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step
+	PutStepStub        func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step
 	putStepMutex       sync.RWMutex
 	putStepArgsForCall []struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
-		arg3 exec.StepMetadata
+		arg3 db.ContainerMetadata
-		arg4 db.ContainerMetadata
+		arg4 exec.PutDelegate
-		arg5 exec.PutDelegate
 	}
 	putStepReturns struct {
 		result1 exec.Step
@@ -67,11 +65,11 @@ type FakeStepFactory struct {
 	putStepReturnsOnCall map[int]struct {
 		result1 exec.Step
 	}
-	TaskStepStub        func(atc.Plan, db.Build, db.ContainerMetadata, exec.TaskDelegate) exec.Step
+	TaskStepStub        func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.TaskDelegate) exec.Step
 	taskStepMutex       sync.RWMutex
 	taskStepArgsForCall []struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
 		arg3 db.ContainerMetadata
 		arg4 exec.TaskDelegate
 	}
@@ -209,20 +207,19 @@ func (fake *FakeStepFactory) ArtifactOutputStepReturnsOnCall(i int, result1 exec
 	}{result1}
 }
 
-func (fake *FakeStepFactory) GetStep(arg1 atc.Plan, arg2 db.Build, arg3 exec.StepMetadata, arg4 db.ContainerMetadata, arg5 exec.GetDelegate) exec.Step {
+func (fake *FakeStepFactory) GetStep(arg1 atc.Plan, arg2 exec.StepMetadata, arg3 db.ContainerMetadata, arg4 exec.GetDelegate) exec.Step {
 	fake.getStepMutex.Lock()
 	ret, specificReturn := fake.getStepReturnsOnCall[len(fake.getStepArgsForCall)]
 	fake.getStepArgsForCall = append(fake.getStepArgsForCall, struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
-		arg3 exec.StepMetadata
+		arg3 db.ContainerMetadata
-		arg4 db.ContainerMetadata
+		arg4 exec.GetDelegate
-		arg5 exec.GetDelegate
+	}{arg1, arg2, arg3, arg4})
-	}{arg1, arg2, arg3, arg4, arg5})
+	fake.recordInvocation("GetStep", []interface{}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("GetStep", []interface{}{arg1, arg2, arg3, arg4, arg5})
 	fake.getStepMutex.Unlock()
 	if fake.GetStepStub != nil {
-		return fake.GetStepStub(arg1, arg2, arg3, arg4, arg5)
+		return fake.GetStepStub(arg1, arg2, arg3, arg4)
 	}
 	if specificReturn {
 		return ret.result1
@@ -237,17 +234,17 @@ func (fake *FakeStepFactory) GetStepCallCount() int {
 	return len(fake.getStepArgsForCall)
 }
 
-func (fake *FakeStepFactory) GetStepCalls(stub func(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step) {
+func (fake *FakeStepFactory) GetStepCalls(stub func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step) {
 	fake.getStepMutex.Lock()
 	defer fake.getStepMutex.Unlock()
 	fake.GetStepStub = stub
 }
 
-func (fake *FakeStepFactory) GetStepArgsForCall(i int) (atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) {
+func (fake *FakeStepFactory) GetStepArgsForCall(i int) (atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) {
 	fake.getStepMutex.RLock()
 	defer fake.getStepMutex.RUnlock()
 	argsForCall := fake.getStepArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
 }
 
 func (fake *FakeStepFactory) GetStepReturns(result1 exec.Step) {
@@ -273,20 +270,19 @@ func (fake *FakeStepFactory) GetStepReturnsOnCall(i int, result1 exec.Step) {
 	}{result1}
 }
 
-func (fake *FakeStepFactory) PutStep(arg1 atc.Plan, arg2 db.Build, arg3 exec.StepMetadata, arg4 db.ContainerMetadata, arg5 exec.PutDelegate) exec.Step {
+func (fake *FakeStepFactory) PutStep(arg1 atc.Plan, arg2 exec.StepMetadata, arg3 db.ContainerMetadata, arg4 exec.PutDelegate) exec.Step {
 	fake.putStepMutex.Lock()
 	ret, specificReturn := fake.putStepReturnsOnCall[len(fake.putStepArgsForCall)]
 	fake.putStepArgsForCall = append(fake.putStepArgsForCall, struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
-		arg3 exec.StepMetadata
+		arg3 db.ContainerMetadata
-		arg4 db.ContainerMetadata
+		arg4 exec.PutDelegate
-		arg5 exec.PutDelegate
+	}{arg1, arg2, arg3, arg4})
-	}{arg1, arg2, arg3, arg4, arg5})
+	fake.recordInvocation("PutStep", []interface{}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("PutStep", []interface{}{arg1, arg2, arg3, arg4, arg5})
 	fake.putStepMutex.Unlock()
 	if fake.PutStepStub != nil {
-		return fake.PutStepStub(arg1, arg2, arg3, arg4, arg5)
+		return fake.PutStepStub(arg1, arg2, arg3, arg4)
 	}
 	if specificReturn {
 		return ret.result1
@@ -301,17 +297,17 @@ func (fake *FakeStepFactory) PutStepCallCount() int {
 	return len(fake.putStepArgsForCall)
 }
 
-func (fake *FakeStepFactory) PutStepCalls(stub func(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step) {
+func (fake *FakeStepFactory) PutStepCalls(stub func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step) {
 	fake.putStepMutex.Lock()
 	defer fake.putStepMutex.Unlock()
 	fake.PutStepStub = stub
 }
 
-func (fake *FakeStepFactory) PutStepArgsForCall(i int) (atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) {
+func (fake *FakeStepFactory) PutStepArgsForCall(i int) (atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) {
 	fake.putStepMutex.RLock()
 	defer fake.putStepMutex.RUnlock()
 	argsForCall := fake.putStepArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
 }
 
 func (fake *FakeStepFactory) PutStepReturns(result1 exec.Step) {
@@ -337,12 +333,12 @@ func (fake *FakeStepFactory) PutStepReturnsOnCall(i int, result1 exec.Step) {
 	}{result1}
 }
 
-func (fake *FakeStepFactory) TaskStep(arg1 atc.Plan, arg2 db.Build, arg3 db.ContainerMetadata, arg4 exec.TaskDelegate) exec.Step {
+func (fake *FakeStepFactory) TaskStep(arg1 atc.Plan, arg2 exec.StepMetadata, arg3 db.ContainerMetadata, arg4 exec.TaskDelegate) exec.Step {
 	fake.taskStepMutex.Lock()
 	ret, specificReturn := fake.taskStepReturnsOnCall[len(fake.taskStepArgsForCall)]
 	fake.taskStepArgsForCall = append(fake.taskStepArgsForCall, struct {
 		arg1 atc.Plan
-		arg2 db.Build
+		arg2 exec.StepMetadata
 		arg3 db.ContainerMetadata
 		arg4 exec.TaskDelegate
 	}{arg1, arg2, arg3, arg4})
@@ -364,13 +360,13 @@ func (fake *FakeStepFactory) TaskStepCallCount() int {
 	return len(fake.taskStepArgsForCall)
 }
 
-func (fake *FakeStepFactory) TaskStepCalls(stub func(atc.Plan, db.Build, db.ContainerMetadata, exec.TaskDelegate) exec.Step) {
+func (fake *FakeStepFactory) TaskStepCalls(stub func(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.TaskDelegate) exec.Step) {
 	fake.taskStepMutex.Lock()
 	defer fake.taskStepMutex.Unlock()
 	fake.TaskStepStub = stub
 }
 
-func (fake *FakeStepFactory) TaskStepArgsForCall(i int) (atc.Plan, db.Build, db.ContainerMetadata, exec.TaskDelegate) {
+func (fake *FakeStepFactory) TaskStepArgsForCall(i int) (atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.TaskDelegate) {
 	fake.taskStepMutex.RLock()
 	defer fake.taskStepMutex.RUnlock()
 	argsForCall := fake.taskStepArgsForCall[i]

atc/engine/builder/delegate_factory.go

@@ -95,6 +95,44 @@ func (d *getDelegate) Finished(logger lager.Logger, exitStatus exec.ExitStatus,
 	logger.Info("finished", lager.Data{"exit-status": exitStatus})
 }
 
+func (d *getDelegate) UpdateVersion(log lager.Logger, plan atc.GetPlan, info exec.VersionInfo) {
+	logger := log.WithData(lager.Data{
+		"pipeline-name": d.build.PipelineName(),
+		"pipeline-id":   d.build.PipelineID()},
+	)
+
+	pipeline, found, err := d.build.Pipeline()
+	if err != nil {
+		logger.Error("failed-to-find-pipeline", err)
+		return
+	}
+
+	if !found {
+		logger.Debug("pipeline-not-found")
+		return
+	}
+
+	resource, found, err := pipeline.Resource(plan.Resource)
+	if err != nil {
+		logger.Error("failed-to-find-resource", err)
+		return
+	}
+
+	if !found {
+		logger.Debug("resource-not-found")
+		return
+	}
+
+	_, err = resource.UpdateMetadata(
+		info.Version,
+		db.NewResourceConfigMetadataFields(info.Metadata),
+	)
+	if err != nil {
+		logger.Error("failed-to-save-resource-config-version-metadata", err)
+		return
+	}
+}
+
 func NewPutDelegate(build db.Build, planID atc.PlanID, clock clock.Clock) exec.PutDelegate {
 	return &putDelegate{
 		BuildStepDelegate: NewBuildStepDelegate(build, planID, clock),
@@ -155,6 +193,29 @@ func (d *putDelegate) Finished(logger lager.Logger, exitStatus exec.ExitStatus,
 	logger.Info("finished", lager.Data{"exit-status": exitStatus, "version-info": info})
 }
 
+func (d *putDelegate) SaveOutput(log lager.Logger, plan atc.PutPlan, source atc.Source, resourceTypes atc.VersionedResourceTypes, info exec.VersionInfo) {
+	logger := log.WithData(lager.Data{
+		"step":          plan.Name,
+		"resource":      plan.Resource,
+		"resource-type": plan.Type,
+		"version":       info.Version,
+	})
+
+	err := d.build.SaveOutput(
+		plan.Type,
+		source,
+		resourceTypes,
+		info.Version,
+		db.NewResourceConfigMetadataFields(info.Metadata),
+		plan.Name,
+		plan.Resource,
+	)
+	if err != nil {
+		logger.Error("failed-to-save-output", err)
+		return
+	}
+}
+
 func NewTaskDelegate(build db.Build, planID atc.PlanID, clock clock.Clock) exec.TaskDelegate {
 	return &taskDelegate{
 		BuildStepDelegate: NewBuildStepDelegate(build, planID, clock),

atc/engine/builder/delegate_factory_test.go

@@ -9,6 +9,7 @@ import (
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
 	"github.com/concourse/concourse/atc"
+	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	"github.com/concourse/concourse/atc/engine/builder"
 	"github.com/concourse/concourse/atc/event"
@@ -20,15 +21,19 @@ import (
 
 var _ = Describe("DelegateFactory", func() {
 	var (
-		logger    *lagertest.TestLogger
+		logger       *lagertest.TestLogger
-		fakeBuild *dbfakes.FakeBuild
+		fakeBuild    *dbfakes.FakeBuild
-		fakeClock *fakeclock.FakeClock
+		fakePipeline *dbfakes.FakePipeline
+		fakeResource *dbfakes.FakeResource
+		fakeClock    *fakeclock.FakeClock
 	)
 
 	BeforeEach(func() {
 		logger = lagertest.NewTestLogger("test")
 
 		fakeBuild = new(dbfakes.FakeBuild)
+		fakePipeline = new(dbfakes.FakePipeline)
+		fakeResource = new(dbfakes.FakeResource)
 		fakeClock = fakeclock.NewFakeClock(time.Unix(123456789, 0))
 	})
 
@@ -64,6 +69,82 @@ var _ = Describe("DelegateFactory", func() {
 				}))
 			})
 		})
+
+		Describe("UpdateVersion", func() {
+			JustBeforeEach(func() {
+				plan := atc.GetPlan{Resource: "some-resource"}
+				delegate.UpdateVersion(logger, plan, info)
+			})
+
+			Context("when retrieving the pipeline fails", func() {
+				BeforeEach(func() {
+					fakeBuild.PipelineReturns(nil, false, errors.New("nope"))
+				})
+
+				It("doesn't update the metadata", func() {
+					Expect(fakeResource.UpdateMetadataCallCount()).To(Equal(0))
+				})
+			})
+
+			Context("when retrieving the pipeline succeeds", func() {
+
+				Context("when the pipeline is not found", func() {
+					BeforeEach(func() {
+						fakeBuild.PipelineReturns(nil, false, nil)
+					})
+
+					It("doesn't update the metadata", func() {
+						Expect(fakeResource.UpdateMetadataCallCount()).To(Equal(0))
+					})
+				})
+
+				Context("when the pipeline is found", func() {
+					BeforeEach(func() {
+						fakeBuild.PipelineReturns(fakePipeline, true, nil)
+					})
+
+					Context("when retrieving the resource fails", func() {
+						BeforeEach(func() {
+							fakePipeline.ResourceReturns(nil, false, errors.New("nope"))
+						})
+
+						It("doesn't update the metadata", func() {
+							Expect(fakeResource.UpdateMetadataCallCount()).To(Equal(0))
+						})
+					})
+
+					Context("when retrieving the resource succeeds", func() {
+
+						It("retrives the resource by name", func() {
+							Expect(fakePipeline.ResourceArgsForCall(0)).To(Equal("some-resource"))
+						})
+
+						Context("when the resource is not found", func() {
+							BeforeEach(func() {
+								fakePipeline.ResourceReturns(nil, false, nil)
+							})
+
+							It("doesn't update the metadata", func() {
+								Expect(fakeResource.UpdateMetadataCallCount()).To(Equal(0))
+							})
+						})
+
+						Context("when the resource is found", func() {
+							BeforeEach(func() {
+								fakePipeline.ResourceReturns(fakeResource, true, nil)
+							})
+
+							It("updates the metadata", func() {
+								Expect(fakeResource.UpdateMetadataCallCount()).To(Equal(1))
+								version, metadata := fakeResource.UpdateMetadataArgsForCall(0)
+								Expect(version).To(Equal(info.Version))
+								Expect(metadata).To(Equal(db.NewResourceConfigMetadataFields(info.Metadata)))
+							})
+						})
+					})
+				})
+			})
+		})
 	})
 
 	Describe("PutDelegate", func() {
@@ -98,6 +179,36 @@ var _ = Describe("DelegateFactory", func() {
 				}))
 			})
 		})
+
+		Describe("SaveOutput", func() {
+			var plan atc.PutPlan
+			var source atc.Source
+			var resourceTypes atc.VersionedResourceTypes
+
+			JustBeforeEach(func() {
+				plan = atc.PutPlan{
+					Name:     "some-name",
+					Type:     "some-type",
+					Resource: "some-resource",
+				}
+				source = atc.Source{"some": "source"}
+				resourceTypes = atc.VersionedResourceTypes{}
+
+				delegate.SaveOutput(logger, plan, source, resourceTypes, info)
+			})
+
+			It("saves the build output", func() {
+				Expect(fakeBuild.SaveOutputCallCount()).To(Equal(1))
+				resourceType, sourceArg, resourceTypesArg, version, metadata, name, resource := fakeBuild.SaveOutputArgsForCall(0)
+				Expect(resourceType).To(Equal(plan.Type))
+				Expect(sourceArg).To(Equal(source))
+				Expect(resourceTypesArg).To(Equal(resourceTypes))
+				Expect(version).To(Equal(info.Version))
+				Expect(metadata).To(Equal(db.NewResourceConfigMetadataFields(info.Metadata)))
+				Expect(name).To(Equal(plan.Name))
+				Expect(resource).To(Equal(plan.Resource))
+			})
+		})
 	})
 
 	Describe("TaskDelegate", func() {

atc/engine/builder/step_factory.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"path/filepath"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
@@ -52,39 +51,23 @@ func NewStepFactory(
 
 func (factory *stepFactory) GetStep(
 	plan atc.Plan,
-	build db.Build,
 	stepMetadata exec.StepMetadata,
-	workerMetadata db.ContainerMetadata,
+	containerMetadata db.ContainerMetadata,
 	delegate exec.GetDelegate,
 ) exec.Step {
-	workerMetadata.WorkingDirectory = resource.ResourcesDir("get")
+	containerMetadata.WorkingDirectory = resource.ResourcesDir("get")
-
-	variables := creds.NewVariables(factory.secretManager, build.TeamName(), build.PipelineName())
 
 	getStep := exec.NewGetStep(
-		build,
-
-		plan.Get.Name,
-		plan.Get.Type,
-		plan.Get.Resource,
-		creds.NewSource(variables, plan.Get.Source),
-		creds.NewParams(variables, plan.Get.Params),
-		exec.NewVersionSourceFromPlan(plan.Get),
-		plan.Get.Tags,
-
-		delegate,
-		factory.resourceFetcher,
-		build.TeamID(),
-		build.ID(),
 		plan.ID,
-		workerMetadata,
+		*plan.Get,
-		factory.resourceCacheFactory,
 		stepMetadata,
-
+		containerMetadata,
-		creds.NewVersionedResourceTypes(variables, plan.Get.VersionedResourceTypes),
+		factory.secretManager,
-
+		factory.resourceFetcher,
+		factory.resourceCacheFactory,
 		factory.strategy,
 		factory.pool,
+		delegate,
 	)
 
 	return exec.LogError(getStep, delegate)
@@ -92,50 +75,23 @@ func (factory *stepFactory) GetStep(
 
 func (factory *stepFactory) PutStep(
 	plan atc.Plan,
-	build db.Build,
 	stepMetadata exec.StepMetadata,
-	workerMetadata db.ContainerMetadata,
+	containerMetadata db.ContainerMetadata,
 	delegate exec.PutDelegate,
 ) exec.Step {
-	workerMetadata.WorkingDirectory = resource.ResourcesDir("put")
+	containerMetadata.WorkingDirectory = resource.ResourcesDir("put")
-
-	variables := creds.NewVariables(factory.secretManager, build.TeamName(), build.PipelineName())
-
-	var putInputs exec.PutInputs
-	if plan.Put.Inputs == nil {
-		// Put step defaults to all inputs if not specified
-		putInputs = exec.NewAllInputs()
-	} else if plan.Put.Inputs.All {
-		putInputs = exec.NewAllInputs()
-	} else {
-		// Covers both cases where inputs are specified and when there are no
-		// inputs specified and "all" field is given a false boolean, which will
-		// result in no inputs attached
-		putInputs = exec.NewSpecificInputs(plan.Put.Inputs.Specified)
-	}
 
 	putStep := exec.NewPutStep(
-		build,
-
-		plan.Put.Name,
-		plan.Put.Type,
-		plan.Put.Resource,
-		creds.NewSource(variables, plan.Put.Source),
-		creds.NewParams(variables, plan.Put.Params),
-		plan.Put.Tags,
-		putInputs,
-
-		delegate,
-		factory.pool,
-		factory.resourceConfigFactory,
 		plan.ID,
-		workerMetadata,
+		*plan.Put,
 		stepMetadata,
-
+		containerMetadata,
-		creds.NewVersionedResourceTypes(variables, plan.Put.VersionedResourceTypes),
+		factory.secretManager,
-
-		factory.strategy,
 		factory.resourceFactory,
+		factory.resourceConfigFactory,
+		factory.strategy,
+		factory.pool,
+		delegate,
 	)
 
 	return exec.LogError(putStep, delegate)
@@ -143,66 +99,23 @@ func (factory *stepFactory) PutStep(
 
 func (factory *stepFactory) TaskStep(
 	plan atc.Plan,
-	build db.Build,
+	stepMetadata exec.StepMetadata,
 	containerMetadata db.ContainerMetadata,
 	delegate exec.TaskDelegate,
 ) exec.Step {
 	sum := sha1.Sum([]byte(plan.Task.Name))
-	workingDirectory := filepath.Join("/tmp", "build", fmt.Sprintf("%x", sum[:4]))
+	containerMetadata.WorkingDirectory = filepath.Join("/tmp", "build", fmt.Sprintf("%x", sum[:4]))
-
-	containerMetadata.WorkingDirectory = workingDirectory
-
-	credMgrVariables := creds.NewVariables(factory.secretManager, build.TeamName(), build.PipelineName())
-
-	var taskConfigSource exec.TaskConfigSource
-	var taskVars []template.Variables
-
-	if plan.Task.ConfigPath != "" {
-		// external task - construct a source which reads it from file
-		taskConfigSource = exec.FileConfigSource{ConfigPath: plan.Task.ConfigPath}
-
-		// for interpolation - use 'vars' from the pipeline, and then fill remaining with cred mgr variables
-		taskVars = []template.Variables{template.StaticVariables(plan.Task.Vars), credMgrVariables}
-	} else {
-		// embedded task - first we take it
-		taskConfigSource = exec.StaticConfigSource{Config: plan.Task.Config}
-
-		// for interpolation - use just cred mgr variables
-		taskVars = []template.Variables{credMgrVariables}
-	}
-
-	// override params
-	taskConfigSource = &exec.OverrideParamsConfigSource{ConfigSource: taskConfigSource, Params: plan.Task.Params}
-
-	// interpolate template vars
-	taskConfigSource = exec.InterpolateTemplateConfigSource{ConfigSource: taskConfigSource, Vars: taskVars}
-
-	// validate
-	taskConfigSource = exec.ValidatingConfigSource{ConfigSource: taskConfigSource}
 
 	taskStep := exec.NewTaskStep(
-		exec.Privileged(plan.Task.Privileged),
-		taskConfigSource,
-		plan.Task.Tags,
-		plan.Task.InputMapping,
-		plan.Task.OutputMapping,
-
-		workingDirectory,
-		plan.Task.ImageArtifactName,
-
-		delegate,
-
-		factory.pool,
-		build.TeamID(),
-		build.ID(),
-		build.JobID(),
-		plan.Task.Name,
 		plan.ID,
-		containerMetadata,
+		*plan.Task,
-
-		creds.NewVersionedResourceTypes(credMgrVariables, plan.Task.VersionedResourceTypes),
 		factory.defaultLimits,
+		stepMetadata,
+		containerMetadata,
+		factory.secretManager,
 		factory.strategy,
+		factory.pool,
+		delegate,
 	)
 
 	return exec.LogError(taskStep, delegate)

atc/engine/engine.go

@@ -16,14 +16,14 @@ import (
 //go:generate counterfeiter . Engine
 
 type Engine interface {
-	LookupBuild(lager.Logger, db.Build) Build
+	NewBuild(db.Build) Runnable
 	ReleaseAll(lager.Logger)
 }
 
-//go:generate counterfeiter . Build
+//go:generate counterfeiter . Runnable
 
-type Build interface {
+type Runnable interface {
-	Resume(lager.Logger)
+	Run(logger lager.Logger)
 }
 
 //go:generate counterfeiter . StepBuilder
@@ -50,7 +50,19 @@ type engine struct {
 	waitGroup     *sync.WaitGroup
 }
 
-func (engine *engine) LookupBuild(logger lager.Logger, build db.Build) Build {
+func (engine *engine) ReleaseAll(logger lager.Logger) {
+	logger.Info("calling-release-on-builds")
+
+	close(engine.release)
+
+	logger.Info("waiting-on-builds")
+
+	engine.waitGroup.Wait()
+
+	logger.Info("finished-waiting-on-builds")
+}
+
+func (engine *engine) NewBuild(build db.Build) Runnable {
 
 	ctx, cancel := context.WithCancel(context.Background())
 
@@ -65,18 +77,6 @@ func (engine *engine) LookupBuild(logger lager.Logger, build db.Build) Build {
 	)
 }
 
-func (engine *engine) ReleaseAll(logger lager.Logger) {
-	logger.Info("calling-release-on-builds")
-
-	close(engine.release)
-
-	logger.Info("waiting-on-builds")
-
-	engine.waitGroup.Wait()
-
-	logger.Info("finished-waiting-on-builds")
-}
-
 func NewBuild(
 	ctx context.Context,
 	cancel func(),
@@ -85,8 +85,8 @@ func NewBuild(
 	release chan bool,
 	trackedStates *sync.Map,
 	waitGroup *sync.WaitGroup,
-) Build {
+) Runnable {
-	return &execBuild{
+	return &engineBuild{
 		ctx:    ctx,
 		cancel: cancel,
 
@@ -99,7 +99,7 @@ func NewBuild(
 	}
 }
 
-type execBuild struct {
+type engineBuild struct {
 	ctx    context.Context
 	cancel func()
 
@@ -111,17 +111,17 @@ type execBuild struct {
 	waitGroup     *sync.WaitGroup
 }
 
-func (build *execBuild) Resume(logger lager.Logger) {
+func (b *engineBuild) Run(logger lager.Logger) {
-	build.waitGroup.Add(1)
+	b.waitGroup.Add(1)
-	defer build.waitGroup.Done()
+	defer b.waitGroup.Done()
 
 	logger = logger.WithData(lager.Data{
-		"build":    build.build.ID(),
+		"build":    b.build.ID(),
-		"pipeline": build.build.PipelineName(),
+		"pipeline": b.build.PipelineName(),
-		"job":      build.build.JobName(),
+		"job":      b.build.JobName(),
 	})
 
-	lock, acquired, err := build.build.AcquireTrackingLock(logger, time.Minute)
+	lock, acquired, err := b.build.AcquireTrackingLock(logger, time.Minute)
 	if err != nil {
 		logger.Error("failed-to-get-lock", err)
 		return
@@ -134,7 +134,7 @@ func (build *execBuild) Resume(logger lager.Logger) {
 
 	defer lock.Release()
 
-	found, err := build.build.Reload()
+	found, err := b.build.Reload()
 	if err != nil {
 		logger.Error("failed-to-load-build-from-db", err)
 		return
@@ -145,12 +145,12 @@ func (build *execBuild) Resume(logger lager.Logger) {
 		return
 	}
 
-	if !build.build.IsRunning() {
+	if !b.build.IsRunning() {
 		logger.Info("build-already-finished")
 		return
 	}
 
-	notifier, err := build.build.AbortNotifier()
+	notifier, err := b.build.AbortNotifier()
 	if err != nil {
 		logger.Error("failed-to-listen-for-aborts", err)
 		return
@@ -158,19 +158,19 @@ func (build *execBuild) Resume(logger lager.Logger) {
 
 	defer notifier.Close()
 
-	step, err := build.builder.BuildStep(build.build)
+	step, err := b.builder.BuildStep(b.build)
 	if err != nil {
 		logger.Error("failed-to-build-step", err)
 		return
 	}
 
-	build.trackStarted(logger)
+	b.trackStarted(logger)
-	defer build.trackFinished(logger)
+	defer b.trackFinished(logger)
 
 	logger.Info("running")
 
-	state := build.runState()
+	state := b.runState()
-	defer build.clearRunState()
+	defer b.clearRunState()
 
 	noleak := make(chan bool)
 	defer close(noleak)
@@ -180,62 +180,62 @@ func (build *execBuild) Resume(logger lager.Logger) {
 		case <-noleak:
 		case <-notifier.Notify():
 			logger.Info("aborting")
-			build.cancel()
+			b.cancel()
 		}
 	}()
 
 	done := make(chan error)
 	go func() {
-		ctx := lagerctx.NewContext(build.ctx, logger)
+		ctx := lagerctx.NewContext(b.ctx, logger)
 		done <- step.Run(ctx, state)
 	}()
 
 	select {
-	case <-build.release:
+	case <-b.release:
 		logger.Info("releasing")
 
 	case err = <-done:
-		build.finish(logger.Session("finish"), err, step.Succeeded())
+		b.finish(logger.Session("finish"), err, step.Succeeded())
 	}
 }
 
-func (build *execBuild) finish(logger lager.Logger, err error, succeeded bool) {
+func (b *engineBuild) finish(logger lager.Logger, err error, succeeded bool) {
 	if err == context.Canceled {
-		build.saveStatus(logger, atc.StatusAborted)
+		b.saveStatus(logger, atc.StatusAborted)
 		logger.Info("aborted")
 
 	} else if err != nil {
-		build.saveStatus(logger, atc.StatusErrored)
+		b.saveStatus(logger, atc.StatusErrored)
 		logger.Info("errored", lager.Data{"error": err.Error()})
 
 	} else if succeeded {
-		build.saveStatus(logger, atc.StatusSucceeded)
+		b.saveStatus(logger, atc.StatusSucceeded)
 		logger.Info("succeeded")
 
 	} else {
-		build.saveStatus(logger, atc.StatusFailed)
+		b.saveStatus(logger, atc.StatusFailed)
 		logger.Info("failed")
 	}
 }
 
-func (build *execBuild) saveStatus(logger lager.Logger, status atc.BuildStatus) {
+func (b *engineBuild) saveStatus(logger lager.Logger, status atc.BuildStatus) {
-	if err := build.build.Finish(db.BuildStatus(status)); err != nil {
+	if err := b.build.Finish(db.BuildStatus(status)); err != nil {
 		logger.Error("failed-to-finish-build", err)
 	}
 }
 
-func (build *execBuild) trackStarted(logger lager.Logger) {
+func (b *engineBuild) trackStarted(logger lager.Logger) {
 	metric.BuildStarted{
-		PipelineName: build.build.PipelineName(),
+		PipelineName: b.build.PipelineName(),
-		JobName:      build.build.JobName(),
+		JobName:      b.build.JobName(),
-		BuildName:    build.build.Name(),
+		BuildName:    b.build.Name(),
-		BuildID:      build.build.ID(),
+		BuildID:      b.build.ID(),
-		TeamName:     build.build.TeamName(),
+		TeamName:     b.build.TeamName(),
 	}.Emit(logger)
 }
 
-func (build *execBuild) trackFinished(logger lager.Logger) {
+func (b *engineBuild) trackFinished(logger lager.Logger) {
-	found, err := build.build.Reload()
+	found, err := b.build.Reload()
 	if err != nil {
 		logger.Error("failed-to-load-build-from-db", err)
 		return
@@ -246,24 +246,24 @@ func (build *execBuild) trackFinished(logger lager.Logger) {
 		return
 	}
 
-	if !build.build.IsRunning() {
+	if !b.build.IsRunning() {
 		metric.BuildFinished{
-			PipelineName:  build.build.PipelineName(),
+			PipelineName:  b.build.PipelineName(),
-			JobName:       build.build.JobName(),
+			JobName:       b.build.JobName(),
-			BuildName:     build.build.Name(),
+			BuildName:     b.build.Name(),
-			BuildID:       build.build.ID(),
+			BuildID:       b.build.ID(),
-			BuildStatus:   build.build.Status(),
+			BuildStatus:   b.build.Status(),
-			BuildDuration: build.build.EndTime().Sub(build.build.StartTime()),
+			BuildDuration: b.build.EndTime().Sub(b.build.StartTime()),
-			TeamName:      build.build.TeamName(),
+			TeamName:      b.build.TeamName(),
 		}.Emit(logger)
 	}
 }
 
-func (build *execBuild) runState() exec.RunState {
+func (build *engineBuild) runState() exec.RunState {
 	existingState, _ := build.trackedStates.LoadOrStore(build.build.ID(), exec.NewRunState())
 	return existingState.(exec.RunState)
 }
 
-func (build *execBuild) clearRunState() {
+func (build *engineBuild) clearRunState() {
 	build.trackedStates.Delete(build.build.ID())
 }

atc/engine/engine_test.go

@@ -22,26 +22,20 @@ import (
 
 var _ = Describe("Engine", func() {
 	var (
-		logger lager.Logger
-
 		fakeBuild       *dbfakes.FakeBuild
 		fakeStepBuilder *enginefakes.FakeStepBuilder
 	)
 
 	BeforeEach(func() {
-		logger = lagertest.NewTestLogger("test")
-
 		fakeBuild = new(dbfakes.FakeBuild)
 		fakeBuild.IDReturns(128)
 
 		fakeStepBuilder = new(enginefakes.FakeStepBuilder)
 	})
 
-	Describe("LookupBuild", func() {
+	Describe("NewBuild", func() {
 		var (
-			build Build
+			build  Runnable
-			err   error
-
 			engine Engine
 		)
 
@@ -50,12 +44,12 @@ var _ = Describe("Engine", func() {
 		})
 
 		JustBeforeEach(func() {
-			build = engine.LookupBuild(logger, fakeBuild)
+			build = engine.NewBuild(fakeBuild)
 		})
 
-		It("succeeds", func() {
+		// It("succeeds", func() {
-			Expect(err).NotTo(HaveOccurred())
+		// 	Expect(err).NotTo(HaveOccurred())
-		})
+		// })
 
 		It("returns a build", func() {
 			Expect(build).NotTo(BeNil())
@@ -64,7 +58,7 @@ var _ = Describe("Engine", func() {
 
 	Describe("Build", func() {
 		var (
-			build     Build
+			build     Runnable
 			release   chan bool
 			cancel    chan bool
 			waitGroup *sync.WaitGroup
@@ -89,7 +83,7 @@ var _ = Describe("Engine", func() {
 			)
 		})
 
-		Describe("Resume", func() {
+		Describe("Run", func() {
 			var logger lager.Logger
 
 			BeforeEach(func() {
@@ -97,7 +91,7 @@ var _ = Describe("Engine", func() {
 			})
 
 			JustBeforeEach(func() {
-				build.Resume(logger)
+				build.Run(logger)
 			})
 
 			Context("when acquiring the lock succeeds", func() {

atc/engine/enginefakes/fake_build.go

@@ -1,76 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package enginefakes
-
-import (
-	"sync"
-
-	"code.cloudfoundry.org/lager"
-	"github.com/concourse/concourse/atc/engine"
-)
-
-type FakeBuild struct {
-	ResumeStub        func(lager.Logger)
-	resumeMutex       sync.RWMutex
-	resumeArgsForCall []struct {
-		arg1 lager.Logger
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeBuild) Resume(arg1 lager.Logger) {
-	fake.resumeMutex.Lock()
-	fake.resumeArgsForCall = append(fake.resumeArgsForCall, struct {
-		arg1 lager.Logger
-	}{arg1})
-	fake.recordInvocation("Resume", []interface{}{arg1})
-	fake.resumeMutex.Unlock()
-	if fake.ResumeStub != nil {
-		fake.ResumeStub(arg1)
-	}
-}
-
-func (fake *FakeBuild) ResumeCallCount() int {
-	fake.resumeMutex.RLock()
-	defer fake.resumeMutex.RUnlock()
-	return len(fake.resumeArgsForCall)
-}
-
-func (fake *FakeBuild) ResumeCalls(stub func(lager.Logger)) {
-	fake.resumeMutex.Lock()
-	defer fake.resumeMutex.Unlock()
-	fake.ResumeStub = stub
-}
-
-func (fake *FakeBuild) ResumeArgsForCall(i int) lager.Logger {
-	fake.resumeMutex.RLock()
-	defer fake.resumeMutex.RUnlock()
-	argsForCall := fake.resumeArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *FakeBuild) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.resumeMutex.RLock()
-	defer fake.resumeMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *FakeBuild) recordInvocation(key string, args []interface{}) {
-	fake.invocationsMutex.Lock()
-	defer fake.invocationsMutex.Unlock()
-	if fake.invocations == nil {
-		fake.invocations = map[string][][]interface{}{}
-	}
-	if fake.invocations[key] == nil {
-		fake.invocations[key] = [][]interface{}{}
-	}
-	fake.invocations[key] = append(fake.invocations[key], args)
-}
-
-var _ engine.Build = new(FakeBuild)

atc/engine/enginefakes/fake_engine.go

@@ -10,17 +10,16 @@ import (
 )
 
 type FakeEngine struct {
-	LookupBuildStub        func(lager.Logger, db.Build) engine.Build
+	NewBuildStub        func(db.Build) engine.Runnable
-	lookupBuildMutex       sync.RWMutex
+	newBuildMutex       sync.RWMutex
-	lookupBuildArgsForCall []struct {
+	newBuildArgsForCall []struct {
-		arg1 lager.Logger
+		arg1 db.Build
-		arg2 db.Build
 	}
-	lookupBuildReturns struct {
+	newBuildReturns struct {
-		result1 engine.Build
+		result1 engine.Runnable
 	}
-	lookupBuildReturnsOnCall map[int]struct {
+	newBuildReturnsOnCall map[int]struct {
-		result1 engine.Build
+		result1 engine.Runnable
 	}
 	ReleaseAllStub        func(lager.Logger)
 	releaseAllMutex       sync.RWMutex
@@ -31,64 +30,63 @@ type FakeEngine struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeEngine) LookupBuild(arg1 lager.Logger, arg2 db.Build) engine.Build {
+func (fake *FakeEngine) NewBuild(arg1 db.Build) engine.Runnable {
-	fake.lookupBuildMutex.Lock()
+	fake.newBuildMutex.Lock()
-	ret, specificReturn := fake.lookupBuildReturnsOnCall[len(fake.lookupBuildArgsForCall)]
+	ret, specificReturn := fake.newBuildReturnsOnCall[len(fake.newBuildArgsForCall)]
-	fake.lookupBuildArgsForCall = append(fake.lookupBuildArgsForCall, struct {
+	fake.newBuildArgsForCall = append(fake.newBuildArgsForCall, struct {
-		arg1 lager.Logger
+		arg1 db.Build
-		arg2 db.Build
+	}{arg1})
-	}{arg1, arg2})
+	fake.recordInvocation("NewBuild", []interface{}{arg1})
-	fake.recordInvocation("LookupBuild", []interface{}{arg1, arg2})
+	fake.newBuildMutex.Unlock()
-	fake.lookupBuildMutex.Unlock()
+	if fake.NewBuildStub != nil {
-	if fake.LookupBuildStub != nil {
+		return fake.NewBuildStub(arg1)
-		return fake.LookupBuildStub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1
 	}
-	fakeReturns := fake.lookupBuildReturns
+	fakeReturns := fake.newBuildReturns
 	return fakeReturns.result1
 }
 
-func (fake *FakeEngine) LookupBuildCallCount() int {
+func (fake *FakeEngine) NewBuildCallCount() int {
-	fake.lookupBuildMutex.RLock()
+	fake.newBuildMutex.RLock()
-	defer fake.lookupBuildMutex.RUnlock()
+	defer fake.newBuildMutex.RUnlock()
-	return len(fake.lookupBuildArgsForCall)
+	return len(fake.newBuildArgsForCall)
 }
 
-func (fake *FakeEngine) LookupBuildCalls(stub func(lager.Logger, db.Build) engine.Build) {
+func (fake *FakeEngine) NewBuildCalls(stub func(db.Build) engine.Runnable) {
-	fake.lookupBuildMutex.Lock()
+	fake.newBuildMutex.Lock()
-	defer fake.lookupBuildMutex.Unlock()
+	defer fake.newBuildMutex.Unlock()
-	fake.LookupBuildStub = stub
+	fake.NewBuildStub = stub
 }
 
-func (fake *FakeEngine) LookupBuildArgsForCall(i int) (lager.Logger, db.Build) {
+func (fake *FakeEngine) NewBuildArgsForCall(i int) db.Build {
-	fake.lookupBuildMutex.RLock()
+	fake.newBuildMutex.RLock()
-	defer fake.lookupBuildMutex.RUnlock()
+	defer fake.newBuildMutex.RUnlock()
-	argsForCall := fake.lookupBuildArgsForCall[i]
+	argsForCall := fake.newBuildArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
+	return argsForCall.arg1
 }
 
-func (fake *FakeEngine) LookupBuildReturns(result1 engine.Build) {
+func (fake *FakeEngine) NewBuildReturns(result1 engine.Runnable) {
-	fake.lookupBuildMutex.Lock()
+	fake.newBuildMutex.Lock()
-	defer fake.lookupBuildMutex.Unlock()
+	defer fake.newBuildMutex.Unlock()
-	fake.LookupBuildStub = nil
+	fake.NewBuildStub = nil
-	fake.lookupBuildReturns = struct {
+	fake.newBuildReturns = struct {
-		result1 engine.Build
+		result1 engine.Runnable
 	}{result1}
 }
 
-func (fake *FakeEngine) LookupBuildReturnsOnCall(i int, result1 engine.Build) {
+func (fake *FakeEngine) NewBuildReturnsOnCall(i int, result1 engine.Runnable) {
-	fake.lookupBuildMutex.Lock()
+	fake.newBuildMutex.Lock()
-	defer fake.lookupBuildMutex.Unlock()
+	defer fake.newBuildMutex.Unlock()
-	fake.LookupBuildStub = nil
+	fake.NewBuildStub = nil
-	if fake.lookupBuildReturnsOnCall == nil {
+	if fake.newBuildReturnsOnCall == nil {
-		fake.lookupBuildReturnsOnCall = make(map[int]struct {
+		fake.newBuildReturnsOnCall = make(map[int]struct {
-			result1 engine.Build
+			result1 engine.Runnable
 		})
 	}
-	fake.lookupBuildReturnsOnCall[i] = struct {
+	fake.newBuildReturnsOnCall[i] = struct {
-		result1 engine.Build
+		result1 engine.Runnable
 	}{result1}
 }
 
@@ -126,8 +124,8 @@ func (fake *FakeEngine) ReleaseAllArgsForCall(i int) lager.Logger {
 func (fake *FakeEngine) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
-	fake.lookupBuildMutex.RLock()
+	fake.newBuildMutex.RLock()
-	defer fake.lookupBuildMutex.RUnlock()
+	defer fake.newBuildMutex.RUnlock()
 	fake.releaseAllMutex.RLock()
 	defer fake.releaseAllMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}

atc/engine/enginefakes/fake_runnable.go

@@ -0,0 +1,76 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package enginefakes
+
+import (
+	"sync"
+
+	"code.cloudfoundry.org/lager"
+	"github.com/concourse/concourse/atc/engine"
+)
+
+type FakeRunnable struct {
+	RunStub        func(lager.Logger)
+	runMutex       sync.RWMutex
+	runArgsForCall []struct {
+		arg1 lager.Logger
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeRunnable) Run(arg1 lager.Logger) {
+	fake.runMutex.Lock()
+	fake.runArgsForCall = append(fake.runArgsForCall, struct {
+		arg1 lager.Logger
+	}{arg1})
+	fake.recordInvocation("Run", []interface{}{arg1})
+	fake.runMutex.Unlock()
+	if fake.RunStub != nil {
+		fake.RunStub(arg1)
+	}
+}
+
+func (fake *FakeRunnable) RunCallCount() int {
+	fake.runMutex.RLock()
+	defer fake.runMutex.RUnlock()
+	return len(fake.runArgsForCall)
+}
+
+func (fake *FakeRunnable) RunCalls(stub func(lager.Logger)) {
+	fake.runMutex.Lock()
+	defer fake.runMutex.Unlock()
+	fake.RunStub = stub
+}
+
+func (fake *FakeRunnable) RunArgsForCall(i int) lager.Logger {
+	fake.runMutex.RLock()
+	defer fake.runMutex.RUnlock()
+	argsForCall := fake.runArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeRunnable) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.runMutex.RLock()
+	defer fake.runMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeRunnable) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ engine.Runnable = new(FakeRunnable)

atc/exec/execfakes/fake_get_delegate.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"code.cloudfoundry.org/lager"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/exec"
 )
@@ -40,6 +41,13 @@ type FakeGetDelegate struct {
 	initializingArgsForCall []struct {
 		arg1 lager.Logger
 	}
+	SaveVersionStub        func(lager.Logger, string, exec.VersionInfo)
+	saveVersionMutex       sync.RWMutex
+	saveVersionArgsForCall []struct {
+		arg1 lager.Logger
+		arg2 string
+		arg3 exec.VersionInfo
+	}
 	StartingStub        func(lager.Logger)
 	startingMutex       sync.RWMutex
 	startingArgsForCall []struct {
@@ -65,6 +73,13 @@ type FakeGetDelegate struct {
 	stdoutReturnsOnCall map[int]struct {
 		result1 io.Writer
 	}
+	UpdateVersionStub        func(lager.Logger, atc.GetPlan, exec.VersionInfo)
+	updateVersionMutex       sync.RWMutex
+	updateVersionArgsForCall []struct {
+		arg1 lager.Logger
+		arg2 atc.GetPlan
+		arg3 exec.VersionInfo
+	}
 	invocations      map[string][][]interface{}
 	invocationsMutex sync.RWMutex
 }
@@ -225,6 +240,39 @@ func (fake *FakeGetDelegate) InitializingArgsForCall(i int) lager.Logger {
 	return argsForCall.arg1
 }
 
+func (fake *FakeGetDelegate) SaveVersion(arg1 lager.Logger, arg2 string, arg3 exec.VersionInfo) {
+	fake.saveVersionMutex.Lock()
+	fake.saveVersionArgsForCall = append(fake.saveVersionArgsForCall, struct {
+		arg1 lager.Logger
+		arg2 string
+		arg3 exec.VersionInfo
+	}{arg1, arg2, arg3})
+	fake.recordInvocation("SaveVersion", []interface{}{arg1, arg2, arg3})
+	fake.saveVersionMutex.Unlock()
+	if fake.SaveVersionStub != nil {
+		fake.SaveVersionStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeGetDelegate) SaveVersionCallCount() int {
+	fake.saveVersionMutex.RLock()
+	defer fake.saveVersionMutex.RUnlock()
+	return len(fake.saveVersionArgsForCall)
+}
+
+func (fake *FakeGetDelegate) SaveVersionCalls(stub func(lager.Logger, string, exec.VersionInfo)) {
+	fake.saveVersionMutex.Lock()
+	defer fake.saveVersionMutex.Unlock()
+	fake.SaveVersionStub = stub
+}
+
+func (fake *FakeGetDelegate) SaveVersionArgsForCall(i int) (lager.Logger, string, exec.VersionInfo) {
+	fake.saveVersionMutex.RLock()
+	defer fake.saveVersionMutex.RUnlock()
+	argsForCall := fake.saveVersionArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
 func (fake *FakeGetDelegate) Starting(arg1 lager.Logger) {
 	fake.startingMutex.Lock()
 	fake.startingArgsForCall = append(fake.startingArgsForCall, struct {
@@ -360,6 +408,39 @@ func (fake *FakeGetDelegate) StdoutReturnsOnCall(i int, result1 io.Writer) {
 	}{result1}
 }
 
+func (fake *FakeGetDelegate) UpdateVersion(arg1 lager.Logger, arg2 atc.GetPlan, arg3 exec.VersionInfo) {
+	fake.updateVersionMutex.Lock()
+	fake.updateVersionArgsForCall = append(fake.updateVersionArgsForCall, struct {
+		arg1 lager.Logger
+		arg2 atc.GetPlan
+		arg3 exec.VersionInfo
+	}{arg1, arg2, arg3})
+	fake.recordInvocation("UpdateVersion", []interface{}{arg1, arg2, arg3})
+	fake.updateVersionMutex.Unlock()
+	if fake.UpdateVersionStub != nil {
+		fake.UpdateVersionStub(arg1, arg2, arg3)
+	}
+}
+
+func (fake *FakeGetDelegate) UpdateVersionCallCount() int {
+	fake.updateVersionMutex.RLock()
+	defer fake.updateVersionMutex.RUnlock()
+	return len(fake.updateVersionArgsForCall)
+}
+
+func (fake *FakeGetDelegate) UpdateVersionCalls(stub func(lager.Logger, atc.GetPlan, exec.VersionInfo)) {
+	fake.updateVersionMutex.Lock()
+	defer fake.updateVersionMutex.Unlock()
+	fake.UpdateVersionStub = stub
+}
+
+func (fake *FakeGetDelegate) UpdateVersionArgsForCall(i int) (lager.Logger, atc.GetPlan, exec.VersionInfo) {
+	fake.updateVersionMutex.RLock()
+	defer fake.updateVersionMutex.RUnlock()
+	argsForCall := fake.updateVersionArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
 func (fake *FakeGetDelegate) Invocations() map[string][][]interface{} {
 	fake.invocationsMutex.RLock()
 	defer fake.invocationsMutex.RUnlock()
@@ -371,12 +452,16 @@ func (fake *FakeGetDelegate) Invocations() map[string][][]interface{} {
 	defer fake.imageVersionDeterminedMutex.RUnlock()
 	fake.initializingMutex.RLock()
 	defer fake.initializingMutex.RUnlock()
+	fake.saveVersionMutex.RLock()
+	defer fake.saveVersionMutex.RUnlock()
 	fake.startingMutex.RLock()
 	defer fake.startingMutex.RUnlock()
 	fake.stderrMutex.RLock()
 	defer fake.stderrMutex.RUnlock()
 	fake.stdoutMutex.RLock()
 	defer fake.stdoutMutex.RUnlock()
+	fake.updateVersionMutex.RLock()
+	defer fake.updateVersionMutex.RUnlock()
 	copiedInvocations := map[string][][]interface{}{}
 	for key, value := range fake.invocations {
 		copiedInvocations[key] = value

atc/exec/execfakes/fake_put_delegate.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"code.cloudfoundry.org/lager"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/exec"
 )
@@ -40,6 +41,15 @@ type FakePutDelegate struct {
 	initializingArgsForCall []struct {
 		arg1 lager.Logger
 	}
+	SaveOutputStub        func(lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, exec.VersionInfo)
+	saveOutputMutex       sync.RWMutex
+	saveOutputArgsForCall []struct {
+		arg1 lager.Logger
+		arg2 atc.PutPlan
+		arg3 atc.Source
+		arg4 atc.VersionedResourceTypes
+		arg5 exec.VersionInfo
+	}
 	StartingStub        func(lager.Logger)
 	startingMutex       sync.RWMutex
 	startingArgsForCall []struct {
@@ -225,6 +235,41 @@ func (fake *FakePutDelegate) InitializingArgsForCall(i int) lager.Logger {
 	return argsForCall.arg1
 }
 
+func (fake *FakePutDelegate) SaveOutput(arg1 lager.Logger, arg2 atc.PutPlan, arg3 atc.Source, arg4 atc.VersionedResourceTypes, arg5 exec.VersionInfo) {
+	fake.saveOutputMutex.Lock()
+	fake.saveOutputArgsForCall = append(fake.saveOutputArgsForCall, struct {
+		arg1 lager.Logger
+		arg2 atc.PutPlan
+		arg3 atc.Source
+		arg4 atc.VersionedResourceTypes
+		arg5 exec.VersionInfo
+	}{arg1, arg2, arg3, arg4, arg5})
+	fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5})
+	fake.saveOutputMutex.Unlock()
+	if fake.SaveOutputStub != nil {
+		fake.SaveOutputStub(arg1, arg2, arg3, arg4, arg5)
+	}
+}
+
+func (fake *FakePutDelegate) SaveOutputCallCount() int {
+	fake.saveOutputMutex.RLock()
+	defer fake.saveOutputMutex.RUnlock()
+	return len(fake.saveOutputArgsForCall)
+}
+
+func (fake *FakePutDelegate) SaveOutputCalls(stub func(lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, exec.VersionInfo)) {
+	fake.saveOutputMutex.Lock()
+	defer fake.saveOutputMutex.Unlock()
+	fake.SaveOutputStub = stub
+}
+
+func (fake *FakePutDelegate) SaveOutputArgsForCall(i int) (lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, exec.VersionInfo) {
+	fake.saveOutputMutex.RLock()
+	defer fake.saveOutputMutex.RUnlock()
+	argsForCall := fake.saveOutputArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
+}
+
 func (fake *FakePutDelegate) Starting(arg1 lager.Logger) {
 	fake.startingMutex.Lock()
 	fake.startingArgsForCall = append(fake.startingArgsForCall, struct {
@@ -371,6 +416,8 @@ func (fake *FakePutDelegate) Invocations() map[string][][]interface{} {
 	defer fake.imageVersionDeterminedMutex.RUnlock()
 	fake.initializingMutex.RLock()
 	defer fake.initializingMutex.RUnlock()
+	fake.saveOutputMutex.RLock()
+	defer fake.saveOutputMutex.RUnlock()
 	fake.startingMutex.RLock()
 	defer fake.startingMutex.RUnlock()
 	fake.stderrMutex.RLock()

atc/exec/get_step.go

@@ -41,90 +41,48 @@ type GetDelegate interface {
 	Initializing(lager.Logger)
 	Starting(lager.Logger)
 	Finished(lager.Logger, ExitStatus, VersionInfo)
+	UpdateVersion(lager.Logger, atc.GetPlan, VersionInfo)
 }
 
 // GetStep will fetch a version of a resource on a worker that supports the
 // resource type.
 type GetStep struct {
-	build db.Build
+	planID               atc.PlanID
-
+	plan                 atc.GetPlan
-	name          string
+	metadata             StepMetadata
-	resourceType  string
+	containerMetadata    db.ContainerMetadata
-	resource      string
+	secrets              creds.Secrets
-	source        creds.Source
+	resourceFetcher      resource.Fetcher
-	params        creds.Params
+	resourceCacheFactory db.ResourceCacheFactory
-	versionSource VersionSource
+	strategy             worker.ContainerPlacementStrategy
-	tags          atc.Tags
+	workerPool           worker.Pool
-
+	delegate             GetDelegate
-	delegate GetDelegate
+	succeeded            bool
-
-	resourceFetcher        resource.Fetcher
-	teamID                 int
-	buildID                int
-	planID                 atc.PlanID
-	containerMetadata      db.ContainerMetadata
-	dbResourceCacheFactory db.ResourceCacheFactory
-	stepMetadata           StepMetadata
-
-	resourceTypes creds.VersionedResourceTypes
-
-	succeeded bool
-
-	strategy   worker.ContainerPlacementStrategy
-	workerPool worker.Pool
 }
 
 func NewGetStep(
-	build db.Build,
-
-	name string,
-	resourceType string,
-	resource string,
-	source creds.Source,
-	params creds.Params,
-	versionSource VersionSource,
-	tags atc.Tags,
-
-	delegate GetDelegate,
-
-	resourceFetcher resource.Fetcher,
-	teamID int,
-	buildID int,
 	planID atc.PlanID,
+	plan atc.GetPlan,
+	metadata StepMetadata,
 	containerMetadata db.ContainerMetadata,
-	dbResourceCacheFactory db.ResourceCacheFactory,
+	secrets creds.Secrets,
-	stepMetadata StepMetadata,
+	resourceFetcher resource.Fetcher,
-
+	resourceCacheFactory db.ResourceCacheFactory,
-	resourceTypes creds.VersionedResourceTypes,
-
 	strategy worker.ContainerPlacementStrategy,
 	workerPool worker.Pool,
+	delegate GetDelegate,
 ) Step {
 	return &GetStep{
-		build: build,
+		planID:               planID,
-
+		plan:                 plan,
-		name:          name,
+		metadata:             metadata,
-		resourceType:  resourceType,
+		containerMetadata:    containerMetadata,
-		resource:      resource,
+		secrets:              secrets,
-		source:        source,
+		resourceFetcher:      resourceFetcher,
-		params:        params,
+		resourceCacheFactory: resourceCacheFactory,
-		versionSource: versionSource,
+		strategy:             strategy,
-		tags:          tags,
+		workerPool:           workerPool,
-
+		delegate:             delegate,
-		delegate: delegate,
-
-		resourceFetcher:        resourceFetcher,
-		teamID:                 teamID,
-		buildID:                buildID,
-		planID:                 planID,
-		containerMetadata:      containerMetadata,
-		dbResourceCacheFactory: dbResourceCacheFactory,
-		stepMetadata:           stepMetadata,
-
-		resourceTypes: resourceTypes,
-
-		strategy:   strategy,
-		workerPool: workerPool,
 	}
 }
 
@@ -154,35 +112,56 @@ func NewGetStep(
 func (step *GetStep) Run(ctx context.Context, state RunState) error {
 	logger := lagerctx.FromContext(ctx)
 	logger = logger.Session("get-step", lager.Data{
-		"step-name": step.name,
+		"step-name": step.plan.Name,
-		"job-id":    step.build.JobID(),
+		"job-id":    step.metadata.JobID,
 	})
 
 	step.delegate.Initializing(logger)
 
-	version, err := step.versionSource.Version(state)
+	variables := creds.NewVariables(step.secrets, step.metadata.TeamName, step.metadata.PipelineName)
+
+	source, err := creds.NewSource(variables, step.plan.Source).Evaluate()
 	if err != nil {
 		return err
 	}
 
-	source, err := step.source.Evaluate()
+	params, err := creds.NewParams(variables, step.plan.Params).Evaluate()
 	if err != nil {
 		return err
 	}
 
-	params, err := step.params.Evaluate()
+	resourceTypes, err := creds.NewVersionedResourceTypes(variables, step.plan.VersionedResourceTypes).Evaluate()
 	if err != nil {
 		return err
 	}
 
-	resourceCache, err := step.dbResourceCacheFactory.FindOrCreateResourceCache(
+	version, err := NewVersionSourceFromPlan(&step.plan).Version(state)
-		logger,
+	if err != nil {
-		db.ForBuild(step.buildID),
+		return err
-		step.resourceType,
+	}
+
+	containerSpec := worker.ContainerSpec{
+		ImageSpec: worker.ImageSpec{
+			ResourceType: step.plan.Type,
+		},
+		TeamID: step.metadata.TeamID,
+		Env:    step.metadata.Env(),
+	}
+
+	workerSpec := worker.WorkerSpec{
+		ResourceType:  step.plan.Type,
+		Tags:          step.plan.Tags,
+		TeamID:        step.metadata.TeamID,
+		ResourceTypes: resourceTypes,
+	}
+
+	resourceCache, err := step.resourceCacheFactory.FindOrCreateResourceCache(
+		db.ForBuild(step.metadata.BuildID),
+		step.plan.Type,
 		version,
 		source,
 		params,
-		step.resourceTypes,
+		resourceTypes,
 	)
 	if err != nil {
 		logger.Error("failed-to-create-resource-cache", err)
@@ -190,31 +169,24 @@ func (step *GetStep) Run(ctx context.Context, state RunState) error {
 	}
 
 	resourceInstance := resource.NewResourceInstance(
-		resource.ResourceType(step.resourceType),
+		resource.ResourceType(step.plan.Type),
 		version,
 		source,
 		params,
-		step.resourceTypes,
+		resourceTypes,
 		resourceCache,
-		db.NewBuildStepContainerOwner(step.buildID, step.planID, step.teamID),
+		db.NewBuildStepContainerOwner(step.metadata.BuildID, step.planID, step.metadata.TeamID),
 	)
 
-	containerSpec := worker.ContainerSpec{
+	chosenWorker, err := step.workerPool.FindOrChooseWorkerForContainer(
-		ImageSpec: worker.ImageSpec{
+		ctx,
-			ResourceType: step.resourceType,
+		logger,
-		},
+		resourceInstance.ContainerOwner(),
-		TeamID: step.teamID,
+		containerSpec,
-		Env:    step.stepMetadata.Env(),
+		step.containerMetadata,
-	}
+		workerSpec,
-
+		step.strategy,
-	workerSpec := worker.WorkerSpec{
+	)
-		ResourceType:  step.resourceType,
-		Tags:          step.tags,
-		TeamID:        step.teamID,
-		ResourceTypes: step.resourceTypes,
-	}
-
-	chosenWorker, err := step.workerPool.FindOrChooseWorkerForContainer(logger, resourceInstance.ContainerOwner(), containerSpec, workerSpec, step.strategy)
 	if err != nil {
 		return err
 	}
@@ -229,7 +201,7 @@ func (step *GetStep) Run(ctx context.Context, state RunState) error {
 		},
 		chosenWorker,
 		containerSpec,
-		step.resourceTypes,
+		resourceTypes,
 		resourceInstance,
 		step.delegate,
 	)
@@ -244,50 +216,23 @@ func (step *GetStep) Run(ctx context.Context, state RunState) error {
 		return err
 	}
 
-	state.Artifacts().RegisterSource(artifact.Name(step.name), &getArtifactSource{
+	state.Artifacts().RegisterSource(artifact.Name(step.plan.Name), &getArtifactSource{
 		resourceInstance: resourceInstance,
 		versionedSource:  versionedSource,
 	})
 
-	if step.resource != "" {
+	versionInfo := VersionInfo{
-		pipeline, found, err := step.build.Pipeline()
+		Version:  versionedSource.Version(),
-		if err != nil {
+		Metadata: versionedSource.Metadata(),
-			logger.Error("failed-to-find-pipeline", err, lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "pipeline-id": step.build.PipelineID()})
+	}
-			return err
-		}
 
-		if !found {
+	if step.plan.Resource != "" {
-			logger.Debug("pipeline-not-found", lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "pipeline-id": step.build.PipelineID()})
+		step.delegate.UpdateVersion(logger, step.plan, versionInfo)
-			return ErrPipelineNotFound{step.build.PipelineName()}
-		}
-
-		resource, found, err := pipeline.Resource(step.resource)
-		if err != nil {
-			logger.Error("failed-to-find-resource", err, lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "resource": step.resource})
-			return err
-		}
-
-		if !found {
-			logger.Debug("resource-not-found", lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "resource": step.resource})
-			return ErrResourceNotFound{step.resource}
-		}
-
-		// Find or Save* the version used in the get step, and update the Metadata
-		// *saving will occur when the resource's config has changed, but it hasn't
-		// checked yet, so the resource config versions don't exist
-		_, err = resource.SaveUncheckedVersion(versionedSource.Version(), db.NewResourceConfigMetadataFields(versionedSource.Metadata()), resourceCache.ResourceConfig(), step.resourceTypes)
-		if err != nil {
-			logger.Error("failed-to-save-resource-config-version", err, lager.Data{"name": step.name, "resource": step.resource, "version": versionedSource.Version()})
-			return err
-		}
 	}
 
 	step.succeeded = true
 
-	step.delegate.Finished(logger, 0, VersionInfo{
+	step.delegate.Finished(logger, 0, versionInfo)
-		Version:  versionedSource.Version(),
-		Metadata: versionedSource.Metadata(),
-	})
 
 	return nil
 }

atc/exec/get_step_test.go

@@ -12,7 +12,6 @@ import (
 
 	"code.cloudfoundry.org/lager/lagertest"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/creds/credsfakes"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
@@ -40,13 +39,11 @@ var _ = Describe("GetStep", func() {
 		fakeResourceFetcher      *resourcefakes.FakeFetcher
 		fakeResourceCacheFactory *dbfakes.FakeResourceCacheFactory
 		fakeSecretManager        *credsfakes.FakeSecrets
-		variables                creds.Variables
-		fakeBuild                *dbfakes.FakeBuild
 		fakeDelegate             *execfakes.FakeGetDelegate
 		getPlan                  *atc.GetPlan
 
-		fakeVersionedSource *resourcefakes.FakeVersionedSource
+		fakeVersionedSource       *resourcefakes.FakeVersionedSource
-		resourceTypes       atc.VersionedResourceTypes
+		interpolatedResourceTypes atc.VersionedResourceTypes
 
 		artifactRepository *artifact.Repository
 		state              *execfakes.FakeRunState
@@ -55,16 +52,22 @@ var _ = Describe("GetStep", func() {
 		stepErr error
 
 		containerMetadata = db.ContainerMetadata{
-			PipelineID: 4567,
+			WorkingDirectory: resource.ResourcesDir("get"),
-			Type:       db.ContainerTypeGet,
+			PipelineID:       4567,
-			StepName:   "some-step",
+			Type:             db.ContainerTypeGet,
+			StepName:         "some-step",
 		}
 
-		stepMetadata testMetadata = []string{"a=1", "b=2"}
+		stepMetadata = exec.StepMetadata{
+			TeamID:       123,
+			TeamName:     "some-team",
+			BuildID:      42,
+			BuildName:    "some-build",
+			PipelineID:   4567,
+			PipelineName: "some-pipeline",
+		}
 
-		teamID  = 123
+		planID = 56
-		buildID = 42
-		planID  = 56
 	)
 
 	BeforeEach(func() {
@@ -79,7 +82,6 @@ var _ = Describe("GetStep", func() {
 
 		fakeSecretManager = new(credsfakes.FakeSecrets)
 		fakeSecretManager.GetReturns("super-secret-source", nil, true, nil)
-		variables = creds.NewVariables(fakeSecretManager, "team", "pipeline")
 
 		artifactRepository = artifact.NewRepository()
 		state = new(execfakes.FakeRunState)
@@ -88,19 +90,25 @@ var _ = Describe("GetStep", func() {
 		fakeVersionedSource = new(resourcefakes.FakeVersionedSource)
 		fakeResourceFetcher.FetchReturns(fakeVersionedSource, nil)
 
-		fakeBuild = new(dbfakes.FakeBuild)
-		fakeBuild.IDReturns(buildID)
-		fakeBuild.TeamIDReturns(teamID)
-		fakeBuild.PipelineNameReturns("pipeline")
-
 		fakeDelegate = new(execfakes.FakeGetDelegate)
 
-		resourceTypes = atc.VersionedResourceTypes{
+		uninterpolatedResourceTypes := atc.VersionedResourceTypes{
 			{
 				ResourceType: atc.ResourceType{
 					Name:   "custom-resource",
 					Type:   "custom-type",
-					Source: atc.Source{"some-custom": "source"},
+					Source: atc.Source{"some-custom": "((source-param))"},
+				},
+				Version: atc.Version{"some-custom": "version"},
+			},
+		}
+
+		interpolatedResourceTypes = atc.VersionedResourceTypes{
+			{
+				ResourceType: atc.ResourceType{
+					Name:   "custom-resource",
+					Type:   "custom-type",
+					Source: atc.Source{"some-custom": "super-secret-source"},
 				},
 				Version: atc.Version{"some-custom": "version"},
 			},
@@ -113,10 +121,8 @@ var _ = Describe("GetStep", func() {
 			Params:                 atc.Params{"some-param": "some-value"},
 			Tags:                   []string{"some", "tags"},
 			Version:                &atc.Version{"some-version": "some-value"},
-			VersionedResourceTypes: resourceTypes,
+			VersionedResourceTypes: uninterpolatedResourceTypes,
 		}
-
-		containerMetadata.WorkingDirectory = resource.ResourcesDir("get")
 	})
 
 	AfterEach(func() {
@@ -129,32 +135,17 @@ var _ = Describe("GetStep", func() {
 			Get: getPlan,
 		}
 
-		variables := creds.NewVariables(fakeSecretManager, fakeBuild.TeamName(), fakeBuild.PipelineName())
-
 		getStep = exec.NewGetStep(
-			fakeBuild,
-
-			plan.Get.Name,
-			plan.Get.Type,
-			plan.Get.Resource,
-			creds.NewSource(variables, plan.Get.Source),
-			creds.NewParams(variables, plan.Get.Params),
-			exec.NewVersionSourceFromPlan(plan.Get),
-			plan.Get.Tags,
-
-			fakeDelegate,
-			fakeResourceFetcher,
-			fakeBuild.TeamID(),
-			fakeBuild.ID(),
 			plan.ID,
-			containerMetadata,
+			*plan.Get,
-			fakeResourceCacheFactory,
 			stepMetadata,
-
+			containerMetadata,
-			creds.NewVersionedResourceTypes(variables, plan.Get.VersionedResourceTypes),
+			fakeSecretManager,
-
+			fakeResourceFetcher,
+			fakeResourceCacheFactory,
 			fakeStrategy,
 			fakePool,
+			fakeDelegate,
 		)
 
 		stepErr = getStep.Run(ctx, state)
@@ -162,20 +153,21 @@ var _ = Describe("GetStep", func() {
 
 	It("finds or chooses a worker", func() {
 		Expect(fakePool.FindOrChooseWorkerForContainerCallCount()).To(Equal(1))
-		_, actualOwner, actualContainerSpec, actualWorkerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+		_, _, actualOwner, actualContainerSpec, actualContainerMetadata, actualWorkerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
-		Expect(actualOwner).To(Equal(db.NewBuildStepContainerOwner(buildID, atc.PlanID(planID), teamID)))
+		Expect(actualOwner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, atc.PlanID(planID), stepMetadata.TeamID)))
 		Expect(actualContainerSpec).To(Equal(worker.ContainerSpec{
 			ImageSpec: worker.ImageSpec{
 				ResourceType: "some-resource-type",
 			},
-			TeamID: teamID,
+			TeamID: stepMetadata.TeamID,
 			Env:    stepMetadata.Env(),
 		}))
+		Expect(actualContainerMetadata).To(Equal(containerMetadata))
 		Expect(actualWorkerSpec).To(Equal(worker.WorkerSpec{
 			ResourceType:  "some-resource-type",
 			Tags:          atc.Tags{"some", "tags"},
-			TeamID:        teamID,
+			TeamID:        stepMetadata.TeamID,
-			ResourceTypes: creds.NewVersionedResourceTypes(variables, resourceTypes),
+			ResourceTypes: interpolatedResourceTypes,
 		}))
 		Expect(strategy).To(Equal(fakeStrategy))
 	})
@@ -205,7 +197,7 @@ var _ = Describe("GetStep", func() {
 				ImageSpec: worker.ImageSpec{
 					ResourceType: "some-resource-type",
 				},
-				TeamID: teamID,
+				TeamID: stepMetadata.TeamID,
 				Env:    stepMetadata.Env(),
 			}))
 			Expect(resourceInstance).To(Equal(resource.NewResourceInstance(
@@ -213,11 +205,11 @@ var _ = Describe("GetStep", func() {
 				atc.Version{"some-version": "some-value"},
 				atc.Source{"some": "super-secret-source"},
 				atc.Params{"some-param": "some-value"},
-				creds.NewVersionedResourceTypes(variables, resourceTypes),
+				interpolatedResourceTypes,
 				nil,
-				db.NewBuildStepContainerOwner(buildID, atc.PlanID(planID), teamID),
+				db.NewBuildStepContainerOwner(stepMetadata.BuildID, atc.PlanID(planID), stepMetadata.TeamID),
 			)))
-			Expect(actualResourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, resourceTypes)))
+			Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
 			Expect(delegate).To(Equal(fakeDelegate))
 			expectedLockName := fmt.Sprintf("%x",
 				sha256.Sum256([]byte(
@@ -231,7 +223,7 @@ var _ = Describe("GetStep", func() {
 		Context("when fetching resource succeeds", func() {
 			BeforeEach(func() {
 				fakeVersionedSource.VersionReturns(atc.Version{"some": "version"})
-				fakeVersionedSource.MetadataReturns([]atc.MetadataField{{"some", "metadata"}})
+				fakeVersionedSource.MetadataReturns([]atc.MetadataField{{Name: "some", Value: "metadata"}})
 			})
 
 			It("returns nil", func() {
@@ -247,132 +239,31 @@ var _ = Describe("GetStep", func() {
 				_, status, info := fakeDelegate.FinishedArgsForCall(0)
 				Expect(status).To(Equal(exec.ExitStatus(0)))
 				Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
-				Expect(info.Metadata).To(Equal([]atc.MetadataField{{"some", "metadata"}}))
+				Expect(info.Metadata).To(Equal([]atc.MetadataField{{Name: "some", Value: "metadata"}}))
 			})
 
-			Context("when getting a pipeline resource", func() {
+			Context("when the plan has a resource", func() {
-				var fakeResourceCache *dbfakes.FakeUsedResourceCache
-				var fakeResourceConfig *dbfakes.FakeResourceConfig
-
 				BeforeEach(func() {
 					getPlan.Resource = "some-pipeline-resource"
-
-					fakeResourceCache = new(dbfakes.FakeUsedResourceCache)
-					fakeResourceConfig = new(dbfakes.FakeResourceConfig)
-					fakeResourceCache.ResourceConfigReturns(fakeResourceConfig)
-					fakeResourceCacheFactory.FindOrCreateResourceCacheReturns(fakeResourceCache, nil)
 				})
 
-				It("finds the pipeline", func() {
+				It("saves a version for the resource", func() {
-					Expect(fakeBuild.PipelineCallCount()).To(Equal(1))
+					Expect(fakeDelegate.UpdateVersionCallCount()).To(Equal(1))
-				})
+					_, plan, info := fakeDelegate.UpdateVersionArgsForCall(0)
-
+					Expect(plan.Resource).To(Equal("some-pipeline-resource"))
-				Context("when finding the pipeline succeeds", func() {
+					Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
-					var fakePipeline *dbfakes.FakePipeline
+					Expect(info.Metadata).To(Equal([]atc.MetadataField{{Name: "some", Value: "metadata"}}))
-
-					BeforeEach(func() {
-						fakePipeline = new(dbfakes.FakePipeline)
-						fakeBuild.PipelineReturns(fakePipeline, true, nil)
-					})
-
-					It("finds the resource", func() {
-						Expect(fakePipeline.ResourceCallCount()).To(Equal(1))
-
-						Expect(fakePipeline.ResourceArgsForCall(0)).To(Equal(getPlan.Resource))
-					})
-
-					Context("when finding the resource succeeds", func() {
-						var fakeResource *dbfakes.FakeResource
-
-						BeforeEach(func() {
-							fakeResource = new(dbfakes.FakeResource)
-							fakePipeline.ResourceReturns(fakeResource, true, nil)
-						})
-
-						It("saves the resource config version", func() {
-							Expect(fakeResource.SaveUncheckedVersionCallCount()).To(Equal(1))
-
-							version, metadata, resourceConfig, actualResourceTypes := fakeResource.SaveUncheckedVersionArgsForCall(0)
-							Expect(version).To(Equal(atc.Version{"some": "version"}))
-							Expect(metadata).To(Equal(db.NewResourceConfigMetadataFields([]atc.MetadataField{{"some", "metadata"}})))
-							Expect(resourceConfig).To(Equal(fakeResourceConfig))
-							Expect(actualResourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, resourceTypes)))
-						})
-
-						Context("when it fails to save the version", func() {
-							disaster := errors.New("oops")
-
-							BeforeEach(func() {
-								fakeResource.SaveUncheckedVersionReturns(false, disaster)
-							})
-
-							It("returns an error", func() {
-								Expect(stepErr).To(Equal(disaster))
-							})
-						})
-					})
-
-					Context("when it fails to find the resource", func() {
-						disaster := errors.New("oops")
-
-						BeforeEach(func() {
-							fakePipeline.ResourceReturns(nil, false, disaster)
-						})
-
-						It("returns an error", func() {
-							Expect(stepErr).To(Equal(disaster))
-						})
-					})
-
-					Context("when the resource is not found", func() {
-						BeforeEach(func() {
-							fakePipeline.ResourceReturns(nil, false, nil)
-						})
-
-						It("returns an ErrResourceNotFound", func() {
-							Expect(stepErr).To(Equal(exec.ErrResourceNotFound{"some-pipeline-resource"}))
-						})
-					})
-				})
-
-				Context("when it fails to find the pipeline", func() {
-					disaster := errors.New("oops")
-
-					BeforeEach(func() {
-						fakeBuild.PipelineReturns(nil, false, disaster)
-					})
-
-					It("returns an error", func() {
-						Expect(stepErr).To(Equal(disaster))
-					})
-				})
-
-				Context("when the pipeline is not found", func() {
-					BeforeEach(func() {
-						fakeBuild.PipelineReturns(nil, false, nil)
-					})
-
-					It("returns an ErrPipelineNotFound", func() {
-						Expect(stepErr).To(Equal(exec.ErrPipelineNotFound{"pipeline"}))
-					})
 				})
 			})
 
 			Context("when getting an anonymous resource", func() {
-				var fakeResourceCache *dbfakes.FakeUsedResourceCache
+
-				var fakeResourceConfig *dbfakes.FakeResourceConfig
 				BeforeEach(func() {
 					getPlan.Resource = ""
-
-					fakeResourceCache = new(dbfakes.FakeUsedResourceCache)
-					fakeResourceConfig = new(dbfakes.FakeResourceConfig)
-					fakeResourceCache.ResourceConfigReturns(fakeResourceConfig)
-					fakeResourceCacheFactory.FindOrCreateResourceCacheReturns(fakeResourceCache, nil)
 				})
 
-				It("does not find the pipeline", func() {
+				It("does not save the version", func() {
-					// TODO: this can be removed once /check returns metadata
+					Expect(fakeDelegate.UpdateVersionCallCount()).To(Equal(0))
-					Expect(fakeBuild.PipelineCallCount()).To(Equal(0))
 				})
 			})
 

atc/exec/put_step.go

@@ -20,75 +20,48 @@ type PutDelegate interface {
 	Initializing(lager.Logger)
 	Starting(lager.Logger)
 	Finished(lager.Logger, ExitStatus, VersionInfo)
+	SaveOutput(lager.Logger, atc.PutPlan, atc.Source, atc.VersionedResourceTypes, VersionInfo)
 }
 
 // PutStep produces a resource version using preconfigured params and any data
 // available in the worker.ArtifactRepository.
 type PutStep struct {
-	build db.Build
-
-	name         string
-	resourceType string
-	resource     string
-	source       creds.Source
-	params       creds.Params
-	tags         atc.Tags
-	inputs       PutInputs
-
-	delegate              PutDelegate
-	pool                  worker.Pool
-	resourceConfigFactory db.ResourceConfigFactory
 	planID                atc.PlanID
+	plan                  atc.PutPlan
+	metadata              StepMetadata
 	containerMetadata     db.ContainerMetadata
-	stepMetadata          StepMetadata
+	secrets               creds.Secrets
-
+	resourceFactory       resource.ResourceFactory
-	resourceTypes creds.VersionedResourceTypes
+	resourceConfigFactory db.ResourceConfigFactory
-
+	strategy              worker.ContainerPlacementStrategy
-	versionInfo VersionInfo
+	pool                  worker.Pool
-	succeeded   bool
+	delegate              PutDelegate
-
+	succeeded             bool
-	strategy        worker.ContainerPlacementStrategy
-	resourceFactory resource.ResourceFactory
 }
 
 func NewPutStep(
-	build db.Build,
-	name string,
-	resourceType string,
-	resourceName string,
-	source creds.Source,
-	params creds.Params,
-	tags atc.Tags,
-	inputs PutInputs,
-	delegate PutDelegate,
-	pool worker.Pool,
-	resourceConfigFactory db.ResourceConfigFactory,
 	planID atc.PlanID,
+	plan atc.PutPlan,
+	metadata StepMetadata,
 	containerMetadata db.ContainerMetadata,
-	stepMetadata StepMetadata,
+	secrets creds.Secrets,
-	resourceTypes creds.VersionedResourceTypes,
-	strategy worker.ContainerPlacementStrategy,
 	resourceFactory resource.ResourceFactory,
+	resourceConfigFactory db.ResourceConfigFactory,
+	strategy worker.ContainerPlacementStrategy,
+	pool worker.Pool,
+	delegate PutDelegate,
 ) *PutStep {
 	return &PutStep{
-		build: build,
-
-		resourceType:          resourceType,
-		name:                  name,
-		resource:              resourceName,
-		source:                source,
-		params:                params,
-		tags:                  tags,
-		inputs:                inputs,
-		delegate:              delegate,
-		pool:                  pool,
-		resourceConfigFactory: resourceConfigFactory,
 		planID:                planID,
+		plan:                  plan,
+		metadata:              metadata,
 		containerMetadata:     containerMetadata,
-		stepMetadata:          stepMetadata,
+		secrets:               secrets,
-		resourceTypes:         resourceTypes,
-		strategy:              strategy,
 		resourceFactory:       resourceFactory,
+		resourceConfigFactory: resourceConfigFactory,
+		pool:                  pool,
+		strategy:              strategy,
+		delegate:              delegate,
 	}
 }
 
@@ -103,40 +76,79 @@ func NewPutStep(
 func (step *PutStep) Run(ctx context.Context, state RunState) error {
 	logger := lagerctx.FromContext(ctx)
 	logger = logger.Session("put-step", lager.Data{
-		"step-name": step.name,
+		"step-name": step.plan.Name,
-		"job-id":    step.build.JobID(),
+		"job-id":    step.metadata.JobID,
 	})
 
 	step.delegate.Initializing(logger)
 
-	containerInputs, err := step.inputs.FindAll(state.Artifacts())
+	variables := creds.NewVariables(step.secrets, step.metadata.TeamName, step.metadata.PipelineName)
+
+	source, err := creds.NewSource(variables, step.plan.Source).Evaluate()
+	if err != nil {
+		return err
+	}
+
+	params, err := creds.NewParams(variables, step.plan.Params).Evaluate()
+	if err != nil {
+		return err
+	}
+
+	resourceTypes, err := creds.NewVersionedResourceTypes(variables, step.plan.VersionedResourceTypes).Evaluate()
+	if err != nil {
+		return err
+	}
+
+	var putInputs PutInputs
+	if step.plan.Inputs == nil {
+		// Put step defaults to all inputs if not specified
+		putInputs = NewAllInputs()
+	} else if step.plan.Inputs.All {
+		putInputs = NewAllInputs()
+	} else {
+		// Covers both cases where inputs are specified and when there are no
+		// inputs specified and "all" field is given a false boolean, which will
+		// result in no inputs attached
+		putInputs = NewSpecificInputs(step.plan.Inputs.Specified)
+	}
+
+	containerInputs, err := putInputs.FindAll(state.Artifacts())
 	if err != nil {
 		return err
 	}
 
 	containerSpec := worker.ContainerSpec{
 		ImageSpec: worker.ImageSpec{
-			ResourceType: step.resourceType,
+			ResourceType: step.plan.Type,
 		},
-		Tags:   step.tags,
+		Tags:   step.plan.Tags,
-		TeamID: step.build.TeamID(),
+		TeamID: step.metadata.TeamID,
 
-		Dir: resource.ResourcesDir("put"),
+		Dir: step.containerMetadata.WorkingDirectory,
 
-		Env: step.stepMetadata.Env(),
+		Env: step.metadata.Env(),
 
 		Inputs: containerInputs,
 	}
 
 	workerSpec := worker.WorkerSpec{
-		ResourceType:  step.resourceType,
+		ResourceType:  step.plan.Type,
-		Tags:          step.tags,
+		Tags:          step.plan.Tags,
-		TeamID:        step.build.TeamID(),
+		TeamID:        step.metadata.TeamID,
-		ResourceTypes: step.resourceTypes,
+		ResourceTypes: resourceTypes,
 	}
 
-	owner := db.NewBuildStepContainerOwner(step.build.ID(), step.planID, step.build.TeamID())
+	owner := db.NewBuildStepContainerOwner(step.metadata.BuildID, step.planID, step.metadata.TeamID)
-	chosenWorker, err := step.pool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, step.strategy)
+
+	chosenWorker, err := step.pool.FindOrChooseWorkerForContainer(
+		ctx,
+		logger,
+		owner,
+		containerSpec,
+		step.containerMetadata,
+		workerSpec,
+		step.strategy,
+	)
 	if err != nil {
 		return err
 	}
@@ -150,24 +162,13 @@ func (step *PutStep) Run(ctx context.Context, state RunState) error {
 		logger,
 		step.delegate,
 		owner,
-		step.containerMetadata,
 		containerSpec,
-		step.resourceTypes,
+		resourceTypes,
 	)
 	if err != nil {
 		return err
 	}
 
-	source, err := step.source.Evaluate()
-	if err != nil {
-		return err
-	}
-
-	params, err := step.params.Evaluate()
-	if err != nil {
-		return err
-	}
-
 	step.delegate.Starting(logger)
 
 	putResource := step.resourceFactory.NewResourceForContainer(container)
@@ -192,34 +193,24 @@ func (step *PutStep) Run(ctx context.Context, state RunState) error {
 		return err
 	}
 
-	step.versionInfo = VersionInfo{
+	versionInfo := VersionInfo{
 		Version:  versionedSource.Version(),
 		Metadata: versionedSource.Metadata(),
 	}
 
-	if step.resource != "" {
+	if step.plan.Resource != "" {
-		logger = logger.WithData(lager.Data{"step": step.name, "resource": step.resource, "resource-type": step.resourceType, "version": step.versionInfo.Version})
+		step.delegate.SaveOutput(logger, step.plan, source, resourceTypes, versionInfo)
-		err = step.build.SaveOutput(logger, step.resourceType, source, step.resourceTypes, step.versionInfo.Version, db.NewResourceConfigMetadataFields(step.versionInfo.Metadata), step.name, step.resource)
-		if err != nil {
-			logger.Error("failed-to-save-output", err)
-			return err
-		}
 	}
 
-	state.StoreResult(step.planID, step.versionInfo)
+	state.StoreResult(step.planID, versionInfo)
 
 	step.succeeded = true
 
-	step.delegate.Finished(logger, 0, step.versionInfo)
+	step.delegate.Finished(logger, 0, versionInfo)
 
 	return nil
 }
 
-// VersionInfo returns the info of the pushed version.
-func (step *PutStep) VersionInfo() VersionInfo {
-	return step.versionInfo
-}
-
 // Succeeded returns true if the resource script exited successfully.
 func (step *PutStep) Succeeded() bool {
 	return step.succeeded

atc/exec/put_step_test.go

@@ -4,9 +4,8 @@ import (
 	"context"
 	"errors"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc/creds/credsfakes"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	"github.com/concourse/concourse/atc/exec"
@@ -26,61 +25,58 @@ var _ = Describe("PutStep", func() {
 		ctx    context.Context
 		cancel func()
 
-		fakeBuild *dbfakes.FakeBuild
-
-		pipelineResourceName string
-
-		fakeStrategy              *workerfakes.FakeContainerPlacementStrategy
-		fakePool                  *workerfakes.FakePool
 		fakeWorker                *workerfakes.FakeWorker
+		fakePool                  *workerfakes.FakePool
+		fakeStrategy              *workerfakes.FakeContainerPlacementStrategy
 		fakeResourceFactory       *resourcefakes.FakeResourceFactory
 		fakeResourceConfigFactory *dbfakes.FakeResourceConfigFactory
+		fakeSecretManager         *credsfakes.FakeSecrets
+		fakeDelegate              *execfakes.FakePutDelegate
+		putPlan                   *atc.PutPlan
 
-		variables creds.Variables
+		interpolatedResourceTypes atc.VersionedResourceTypes
-
-		stepMetadata testMetadata = []string{"a=1", "b=2"}
 
 		containerMetadata = db.ContainerMetadata{
-			Type:     db.ContainerTypePut,
+			WorkingDirectory: resource.ResourcesDir("put"),
-			StepName: "some-step",
+			Type:             db.ContainerTypePut,
+			StepName:         "some-step",
 		}
-		planID       atc.PlanID
-		fakeDelegate *execfakes.FakePutDelegate
 
-		resourceTypes creds.VersionedResourceTypes
+		stepMetadata = exec.StepMetadata{
+			TeamID:       123,
+			TeamName:     "some-team",
+			BuildID:      42,
+			BuildName:    "some-build",
+			PipelineID:   4567,
+			PipelineName: "some-pipeline",
+		}
 
 		repo  *artifact.Repository
 		state *execfakes.FakeRunState
 
-		stdoutBuf *gbytes.Buffer
-		stderrBuf *gbytes.Buffer
-
 		putStep *exec.PutStep
 		stepErr error
 
-		putInputs exec.PutInputs
+		stdoutBuf *gbytes.Buffer
+		stderrBuf *gbytes.Buffer
+
+		planID atc.PlanID
 	)
 
 	BeforeEach(func() {
 		ctx, cancel = context.WithCancel(context.Background())
 
-		fakeBuild = new(dbfakes.FakeBuild)
-		fakeBuild.IDReturns(42)
-		fakeBuild.TeamIDReturns(123)
-
 		planID = atc.PlanID("some-plan-id")
 
-		pipelineResourceName = "some-resource"
-
 		fakeStrategy = new(workerfakes.FakeContainerPlacementStrategy)
 		fakePool = new(workerfakes.FakePool)
 		fakeWorker = new(workerfakes.FakeWorker)
 		fakeResourceFactory = new(resourcefakes.FakeResourceFactory)
 		fakeResourceConfigFactory = new(dbfakes.FakeResourceConfigFactory)
-		variables = template.StaticVariables{
+
-			"custom-param": "source",
+		fakeSecretManager = new(credsfakes.FakeSecrets)
-			"source-param": "super-secret-source",
+		fakeSecretManager.GetReturnsOnCall(0, "super-secret-source", nil, true, nil)
-		}
+		fakeSecretManager.GetReturnsOnCall(1, "source", nil, true, nil)
 
 		fakeDelegate = new(execfakes.FakePutDelegate)
 		stdoutBuf = gbytes.NewBuffer()
@@ -92,7 +88,7 @@ var _ = Describe("PutStep", func() {
 		state = new(execfakes.FakeRunState)
 		state.ArtifactsReturns(repo)
 
-		resourceTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+		uninterpolatedResourceTypes := atc.VersionedResourceTypes{
 			{
 				ResourceType: atc.ResourceType{
 					Name:   "custom-resource",
@@ -101,11 +97,28 @@ var _ = Describe("PutStep", func() {
 				},
 				Version: atc.Version{"some-custom": "version"},
 			},
-		})
+		}
 
-		stepErr = nil
+		interpolatedResourceTypes = atc.VersionedResourceTypes{
+			{
+				ResourceType: atc.ResourceType{
+					Name:   "custom-resource",
+					Type:   "custom-type",
+					Source: atc.Source{"some-custom": "source"},
+				},
+				Version: atc.Version{"some-custom": "version"},
+			},
+		}
 
-		putInputs = exec.NewAllInputs()
+		putPlan = &atc.PutPlan{
+			Name:                   "some-name",
+			Resource:               "some-resource",
+			Type:                   "some-resource-type",
+			Source:                 atc.Source{"some": "((source-param))"},
+			Params:                 atc.Params{"some-param": "some-value"},
+			Tags:                   []string{"some", "tags"},
+			VersionedResourceTypes: uninterpolatedResourceTypes,
+		}
 	})
 
 	AfterEach(func() {
@@ -113,24 +126,22 @@ var _ = Describe("PutStep", func() {
 	})
 
 	JustBeforeEach(func() {
+		plan := atc.Plan{
+			ID:  atc.PlanID(planID),
+			Put: putPlan,
+		}
+
 		putStep = exec.NewPutStep(
-			fakeBuild,
+			plan.ID,
-			"some-name",
+			*plan.Put,
-			"some-resource-type",
-			pipelineResourceName,
-			creds.NewSource(variables, atc.Source{"some": "((source-param))"}),
-			creds.NewParams(variables, atc.Params{"some-param": "some-value"}),
-			[]string{"some", "tags"},
-			putInputs,
-			fakeDelegate,
-			fakePool,
-			fakeResourceConfigFactory,
-			planID,
-			containerMetadata,
 			stepMetadata,
-			resourceTypes,
+			containerMetadata,
-			fakeStrategy,
+			fakeSecretManager,
 			fakeResourceFactory,
+			fakeResourceConfigFactory,
+			fakeStrategy,
+			fakePool,
+			fakeDelegate,
 		)
 
 		stepErr = putStep.Run(ctx, state)
@@ -168,7 +179,7 @@ var _ = Describe("PutStep", func() {
 
 				fakeVersionedSource = new(resourcefakes.FakeVersionedSource)
 				fakeVersionedSource.VersionReturns(atc.Version{"some": "version"})
-				fakeVersionedSource.MetadataReturns([]atc.MetadataField{{"some", "metadata"}})
+				fakeVersionedSource.MetadataReturns([]atc.MetadataField{{Name: "some", Value: "metadata"}})
 
 				fakeWorker.NameReturns("some-worker")
 				fakePool.FindOrChooseWorkerForContainerReturns(fakeWorker, nil)
@@ -180,33 +191,33 @@ var _ = Describe("PutStep", func() {
 
 			It("finds/chooses a worker and creates a container with the correct type, session, and sources with no inputs specified (meaning it takes all artifacts)", func() {
 				Expect(fakePool.FindOrChooseWorkerForContainerCallCount()).To(Equal(1))
-				_, actualOwner, actualContainerSpec, actualWorkerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+				_, _, actualOwner, actualContainerSpec, actualContainerMetadata, actualWorkerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 				Expect(actualOwner).To(Equal(db.NewBuildStepContainerOwner(42, atc.PlanID(planID), 123)))
 				Expect(actualContainerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "some-resource-type",
 				}))
 				Expect(actualContainerSpec.Tags).To(Equal([]string{"some", "tags"}))
 				Expect(actualContainerSpec.TeamID).To(Equal(123))
-				Expect(actualContainerSpec.Env).To(Equal([]string{"a=1", "b=2"}))
+				Expect(actualContainerSpec.Env).To(Equal(stepMetadata.Env()))
 				Expect(actualContainerSpec.Dir).To(Equal("/tmp/build/put"))
 				Expect(actualContainerSpec.Inputs).To(HaveLen(3))
+				Expect(actualContainerMetadata).To(Equal(containerMetadata))
 				Expect(actualWorkerSpec).To(Equal(worker.WorkerSpec{
 					TeamID:        123,
 					Tags:          []string{"some", "tags"},
 					ResourceType:  "some-resource-type",
-					ResourceTypes: resourceTypes,
+					ResourceTypes: interpolatedResourceTypes,
 				}))
 				Expect(strategy).To(Equal(fakeStrategy))
 
-				_, _, delegate, owner, cm, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+				_, _, delegate, owner, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
-				Expect(cm).To(Equal(containerMetadata))
 				Expect(owner).To(Equal(db.NewBuildStepContainerOwner(42, atc.PlanID(planID), 123)))
 				Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "some-resource-type",
 				}))
 				Expect(containerSpec.Tags).To(Equal([]string{"some", "tags"}))
 				Expect(containerSpec.TeamID).To(Equal(123))
-				Expect(containerSpec.Env).To(Equal([]string{"a=1", "b=2"}))
+				Expect(containerSpec.Env).To(Equal(stepMetadata.Env()))
 				Expect(containerSpec.Dir).To(Equal("/tmp/build/put"))
 				Expect(containerSpec.Inputs).To(HaveLen(3))
 
@@ -219,17 +230,19 @@ var _ = Describe("PutStep", func() {
 					exec.PutResourceSource{fakeOtherSource},
 					exec.PutResourceSource{fakeMountedSource},
 				))
-				Expect(actualResourceTypes).To(Equal(resourceTypes))
+				Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
 				Expect(delegate).To(Equal(fakeDelegate))
 			})
 
 			Context("when the inputs are specified", func() {
 				BeforeEach(func() {
-					putInputs = exec.NewSpecificInputs([]string{"some-source", "some-other-source"})
+					putPlan.Inputs = &atc.InputsConfig{
+						Specified: []string{"some-source", "some-other-source"},
+					}
 				})
 
 				It("initializes the container with specified inputs", func() {
-					_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+					_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 					Expect(containerSpec.Inputs).To(HaveLen(2))
 					Expect([]worker.ArtifactSource{
 						containerSpec.Inputs[0].Source(),
@@ -267,32 +280,26 @@ var _ = Describe("PutStep", func() {
 				Expect(fakeResource.PutCallCount()).To(Equal(1))
 			})
 
-			It("reports the created version info", func() {
-				info := putStep.VersionInfo()
-				Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
-				Expect(info.Metadata).To(Equal([]atc.MetadataField{{"some", "metadata"}}))
-			})
-
 			It("is successful", func() {
 				Expect(putStep.Succeeded()).To(BeTrue())
 			})
 
 			It("saves the build output", func() {
-				Expect(fakeBuild.SaveOutputCallCount()).To(Equal(1))
+				Expect(fakeDelegate.SaveOutputCallCount()).To(Equal(1))
 
-				_, actualResourceType, actualSource, actualResourceTypes, version, metadata, outputName, resourceName := fakeBuild.SaveOutputArgsForCall(0)
+				_, plan, actualSource, actualResourceTypes, info := fakeDelegate.SaveOutputArgsForCall(0)
-				Expect(actualResourceType).To(Equal("some-resource-type"))
+				Expect(plan.Name).To(Equal("some-name"))
+				Expect(plan.Type).To(Equal("some-resource-type"))
+				Expect(plan.Resource).To(Equal("some-resource"))
 				Expect(actualSource).To(Equal(atc.Source{"some": "super-secret-source"}))
-				Expect(actualResourceTypes).To(Equal(resourceTypes))
+				Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
-				Expect(version).To(Equal(atc.Version{"some": "version"}))
+				Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
-				Expect(metadata).To(Equal(db.NewResourceConfigMetadataFields([]atc.MetadataField{{"some", "metadata"}})))
+				Expect(info.Metadata).To(Equal([]atc.MetadataField{{"some", "metadata"}}))
-				Expect(outputName).To(Equal("some-name"))
-				Expect(resourceName).To(Equal("some-resource"))
 			})
 
 			Context("when the resource is blank", func() {
 				BeforeEach(func() {
-					pipelineResourceName = ""
+					putPlan.Resource = ""
 				})
 
 				It("is successful", func() {
@@ -300,7 +307,7 @@ var _ = Describe("PutStep", func() {
 				})
 
 				It("does not save the build output", func() {
-					Expect(fakeBuild.SaveOutputCallCount()).To(Equal(0))
+					Expect(fakeDelegate.SaveOutputCallCount()).To(Equal(0))
 				})
 			})
 
@@ -309,7 +316,7 @@ var _ = Describe("PutStep", func() {
 				_, status, info := fakeDelegate.FinishedArgsForCall(0)
 				Expect(status).To(Equal(exec.ExitStatus(0)))
 				Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
-				Expect(info.Metadata).To(Equal([]atc.MetadataField{{"some", "metadata"}}))
+				Expect(info.Metadata).To(Equal([]atc.MetadataField{{Name: "some", Value: "metadata"}}))
 			})
 
 			It("stores the version info as the step result", func() {
@@ -318,22 +325,10 @@ var _ = Describe("PutStep", func() {
 				Expect(sID).To(Equal(planID))
 				Expect(sVal).To(Equal(exec.VersionInfo{
 					Version:  atc.Version{"some": "version"},
-					Metadata: []atc.MetadataField{{"some", "metadata"}},
+					Metadata: []atc.MetadataField{{Name: "some", Value: "metadata"}},
 				}))
 			})
 
-			Context("when saving the build output fails", func() {
-				disaster := errors.New("nope")
-
-				BeforeEach(func() {
-					fakeBuild.SaveOutputReturns(disaster)
-				})
-
-				It("returns the error", func() {
-					Expect(stepErr).To(Equal(disaster))
-				})
-			})
-
 			Context("when performing the put exits unsuccessfully", func() {
 				BeforeEach(func() {
 					fakeResource.PutReturns(nil, resource.ErrResourceScriptFailed{

atc/exec/step.go

@@ -66,11 +66,5 @@ type ExitStatus int
 // special privileges (i.e. as an administrator user).
 type Privileged bool
 
-// StepMetadata is used to inject metadata to make available to the step when
-// it's running.
-type StepMetadata interface {
-	Env() []string
-}
-
 type InputHandler func(io.ReadCloser) error
 type OutputHandler func(io.Writer) error

atc/exec/step_metadata.go

@@ -0,0 +1,55 @@
+package exec
+
+import (
+	"fmt"
+)
+
+type StepMetadata struct {
+	BuildID      int
+	BuildName    string
+	TeamID       int
+	TeamName     string
+	JobID        int
+	JobName      string
+	PipelineID   int
+	PipelineName string
+	ExternalURL  string
+}
+
+func (metadata StepMetadata) Env() []string {
+	env := []string{fmt.Sprintf("BUILD_ID=%d", metadata.BuildID)}
+
+	if metadata.BuildName != "" {
+		env = append(env, "BUILD_NAME="+metadata.BuildName)
+	}
+
+	if metadata.TeamID != 0 {
+		env = append(env, fmt.Sprintf("BUILD_TEAM_ID=%d", metadata.TeamID))
+	}
+
+	if metadata.TeamName != "" {
+		env = append(env, "BUILD_TEAM_NAME="+metadata.TeamName)
+	}
+
+	if metadata.JobID != 0 {
+		env = append(env, fmt.Sprintf("BUILD_JOB_ID=%d", metadata.JobID))
+	}
+
+	if metadata.JobName != "" {
+		env = append(env, "BUILD_JOB_NAME="+metadata.JobName)
+	}
+
+	if metadata.PipelineID != 0 {
+		env = append(env, fmt.Sprintf("BUILD_PIPELINE_ID=%d", metadata.PipelineID))
+	}
+
+	if metadata.PipelineName != "" {
+		env = append(env, "BUILD_PIPELINE_NAME="+metadata.PipelineName)
+	}
+
+	if metadata.ExternalURL != "" {
+		env = append(env, "ATC_EXTERNAL_URL="+metadata.ExternalURL)
+	}
+
+	return env
+}

atc/exec/step_metadata_test.go

@@ -0,0 +1,57 @@
+package exec_test
+
+import (
+	"github.com/concourse/concourse/atc/exec"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("StepMetadata", func() {
+	var stepMetadata exec.StepMetadata
+
+	Describe("Env", func() {
+		Context("when populating fields", func() {
+			BeforeEach(func() {
+				stepMetadata = exec.StepMetadata{
+					BuildID:      1,
+					BuildName:    "42",
+					TeamID:       2222,
+					TeamName:     "some-team",
+					JobID:        3333,
+					JobName:      "some-job-name",
+					PipelineID:   4444,
+					PipelineName: "some-pipeline-name",
+					ExternalURL:  "http://www.example.com",
+				}
+			})
+
+			It("returns the specified values", func() {
+				Expect(stepMetadata.Env()).To(ConsistOf(
+					"BUILD_ID=1",
+					"BUILD_NAME=42",
+					"BUILD_TEAM_ID=2222",
+					"BUILD_TEAM_NAME=some-team",
+					"BUILD_JOB_ID=3333",
+					"BUILD_JOB_NAME=some-job-name",
+					"BUILD_PIPELINE_ID=4444",
+					"BUILD_PIPELINE_NAME=some-pipeline-name",
+					"ATC_EXTERNAL_URL=http://www.example.com",
+				))
+			})
+		})
+
+		Context("when fields are empty", func() {
+			BeforeEach(func() {
+				stepMetadata = exec.StepMetadata{
+					BuildID: 1,
+				}
+			})
+			It("does not include fields that are not set", func() {
+				Expect(stepMetadata.Env()).To(Equal([]string{
+					"BUILD_ID=1",
+				}))
+			})
+		})
+	})
+})

atc/exec/task_step.go

@@ -13,7 +13,7 @@ import (
 	"code.cloudfoundry.org/garden"
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagerctx"
-	boshtemplate "github.com/cloudfoundry/bosh-cli/director/template"
+	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
@@ -66,73 +66,39 @@ type TaskDelegate interface {
 // TaskStep executes a TaskConfig, whose inputs will be fetched from the
 // artifact.Repository and outputs will be added to the artifact.Repository.
 type TaskStep struct {
-	privileged    Privileged
-	configSource  TaskConfigSource
-	tags          atc.Tags
-	inputMapping  map[string]string
-	outputMapping map[string]string
-
-	artifactsRoot     string
-	imageArtifactName string
-
-	delegate TaskDelegate
-
-	workerPool        worker.Pool
-	teamID            int
-	buildID           int
-	jobID             int
-	stepName          string
 	planID            atc.PlanID
+	plan              atc.TaskPlan
+	defaultLimits     atc.ContainerLimits
+	metadata          StepMetadata
 	containerMetadata db.ContainerMetadata
-
+	secrets           creds.Secrets
-	resourceTypes creds.VersionedResourceTypes
+	strategy          worker.ContainerPlacementStrategy
-
+	workerPool        worker.Pool
-	defaultLimits atc.ContainerLimits
+	delegate          TaskDelegate
-
+	succeeded         bool
-	succeeded bool
-
-	strategy worker.ContainerPlacementStrategy
 }
 
 func NewTaskStep(
-	privileged Privileged,
-	configSource TaskConfigSource,
-	tags atc.Tags,
-	inputMapping map[string]string,
-	outputMapping map[string]string,
-	artifactsRoot string,
-	imageArtifactName string,
-	delegate TaskDelegate,
-	workerPool worker.Pool,
-	teamID int,
-	buildID int,
-	jobID int,
-	stepName string,
 	planID atc.PlanID,
-	containerMetadata db.ContainerMetadata,
+	plan atc.TaskPlan,
-	resourceTypes creds.VersionedResourceTypes,
 	defaultLimits atc.ContainerLimits,
+	metadata StepMetadata,
+	containerMetadata db.ContainerMetadata,
+	secrets creds.Secrets,
 	strategy worker.ContainerPlacementStrategy,
+	workerPool worker.Pool,
+	delegate TaskDelegate,
 ) Step {
 	return &TaskStep{
-		privileged:        privileged,
-		configSource:      configSource,
-		tags:              tags,
-		inputMapping:      inputMapping,
-		outputMapping:     outputMapping,
-		artifactsRoot:     artifactsRoot,
-		imageArtifactName: imageArtifactName,
-		delegate:          delegate,
-		workerPool:        workerPool,
-		teamID:            teamID,
-		buildID:           buildID,
-		jobID:             jobID,
-		stepName:          stepName,
 		planID:            planID,
-		containerMetadata: containerMetadata,
+		plan:              plan,
-		resourceTypes:     resourceTypes,
 		defaultLimits:     defaultLimits,
+		metadata:          metadata,
+		containerMetadata: containerMetadata,
+		secrets:           secrets,
 		strategy:          strategy,
+		workerPool:        workerPool,
+		delegate:          delegate,
 	}
 }
 
@@ -151,45 +117,88 @@ func NewTaskStep(
 // are registered with the artifact.Repository. If no outputs are specified, the
 // task's entire working directory is registered as an ArtifactSource under the
 // name of the task.
-func (action *TaskStep) Run(ctx context.Context, state RunState) error {
+func (step *TaskStep) Run(ctx context.Context, state RunState) error {
 	logger := lagerctx.FromContext(ctx)
 	logger = logger.Session("task-step", lager.Data{
-		"step-name": action.stepName,
+		"step-name": step.plan.Name,
-		"job-id":    action.jobID,
+		"job-id":    step.metadata.JobID,
 	})
 
+	variables := creds.NewVariables(step.secrets, step.metadata.TeamName, step.metadata.PipelineName)
+
+	resourceTypes, err := creds.NewVersionedResourceTypes(variables, step.plan.VersionedResourceTypes).Evaluate()
+	if err != nil {
+		return err
+	}
+
+	var taskConfigSource TaskConfigSource
+	var taskVars []template.Variables
+
+	if step.plan.ConfigPath != "" {
+		// external task - construct a source which reads it from file
+		taskConfigSource = FileConfigSource{ConfigPath: step.plan.ConfigPath}
+
+		// for interpolation - use 'vars' from the pipeline, and then fill remaining with cred variables
+		taskVars = []template.Variables{template.StaticVariables(step.plan.Vars), variables}
+	} else {
+		// embedded task - first we take it
+		taskConfigSource = StaticConfigSource{Config: step.plan.Config}
+
+		// for interpolation - use just cred variables
+		taskVars = []template.Variables{variables}
+	}
+
+	// override params
+	taskConfigSource = &OverrideParamsConfigSource{ConfigSource: taskConfigSource, Params: step.plan.Params}
+
+	// interpolate template vars
+	taskConfigSource = InterpolateTemplateConfigSource{ConfigSource: taskConfigSource, Vars: taskVars}
+
+	// validate
+	taskConfigSource = ValidatingConfigSource{ConfigSource: taskConfigSource}
+
 	repository := state.Artifacts()
 
-	config, err := action.configSource.FetchConfig(logger, repository)
+	config, err := taskConfigSource.FetchConfig(logger, repository)
 
-	for _, warning := range action.configSource.Warnings() {
+	for _, warning := range taskConfigSource.Warnings() {
-		fmt.Fprintln(action.delegate.Stderr(), "[WARNING]", warning)
+		fmt.Fprintln(step.delegate.Stderr(), "[WARNING]", warning)
 	}
 
 	if err != nil {
 		return err
 	}
+
 	if config.Limits.CPU == nil {
-		config.Limits.CPU = action.defaultLimits.CPU
+		config.Limits.CPU = step.defaultLimits.CPU
 	}
 	if config.Limits.Memory == nil {
-		config.Limits.Memory = action.defaultLimits.Memory
+		config.Limits.Memory = step.defaultLimits.Memory
 	}
 
-	action.delegate.Initializing(logger, config)
+	step.delegate.Initializing(logger, config)
 
-	containerSpec, err := action.containerSpec(logger, repository, config)
+	workerSpec, err := step.workerSpec(logger, resourceTypes, repository, config)
 	if err != nil {
 		return err
 	}
 
-	workerSpec, err := action.workerSpec(logger, action.resourceTypes, repository, config)
+	containerSpec, err := step.containerSpec(logger, repository, config, step.containerMetadata)
 	if err != nil {
 		return err
 	}
 
-	owner := db.NewBuildStepContainerOwner(action.buildID, action.planID, action.teamID)
+	owner := db.NewBuildStepContainerOwner(step.metadata.BuildID, step.planID, step.metadata.TeamID)
-	chosenWorker, err := action.workerPool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, action.strategy)
+
+	chosenWorker, err := step.workerPool.FindOrChooseWorkerForContainer(
+		ctx,
+		logger,
+		owner,
+		containerSpec,
+		step.containerMetadata,
+		workerSpec,
+		step.strategy,
+	)
 	if err != nil {
 		return err
 	}
@@ -197,11 +206,10 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 	container, err := chosenWorker.FindOrCreateContainer(
 		ctx,
 		logger,
-		action.delegate,
+		step.delegate,
 		owner,
-		action.containerMetadata,
 		containerSpec,
-		action.resourceTypes,
+		resourceTypes,
 	)
 	if err != nil {
 		return err
@@ -216,9 +224,9 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 			return err
 		}
 
-		action.succeeded = (status == 0)
+		step.succeeded = (status == 0)
 
-		err = action.registerOutputs(logger, repository, config, container)
+		err = step.registerOutputs(logger, repository, config, container, step.containerMetadata)
 		if err != nil {
 			return err
 		}
@@ -227,8 +235,8 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 	}
 
 	processIO := garden.ProcessIO{
-		Stdout: action.delegate.Stdout(),
+		Stdout: step.delegate.Stdout(),
-		Stderr: action.delegate.Stderr(),
+		Stderr: step.delegate.Stderr(),
 	}
 
 	process, err := container.Attach(taskProcessID, processIO)
@@ -237,7 +245,7 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 	} else {
 		logger.Info("spawning")
 
-		action.delegate.Starting(logger, config)
+		step.delegate.Starting(logger, config)
 
 		process, err = container.Run(
 			garden.ProcessSpec{
@@ -246,7 +254,7 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 				Path: config.Run.Path,
 				Args: config.Run.Args,
 
-				Dir: path.Join(action.artifactsRoot, config.Run.Dir),
+				Dir: path.Join(step.containerMetadata.WorkingDirectory, config.Run.Dir),
 
 				// Guardian sets the default TTY window size to width: 80, height: 24,
 				// which creates ANSI control sequences that do not work with other window sizes
@@ -274,7 +282,7 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 
 	select {
 	case <-ctx.Done():
-		err = action.registerOutputs(logger, repository, config, container)
+		err = step.registerOutputs(logger, repository, config, container, step.containerMetadata)
 		if err != nil {
 			return err
 		}
@@ -293,39 +301,39 @@ func (action *TaskStep) Run(ctx context.Context, state RunState) error {
 			return processErr
 		}
 
-		err = action.registerOutputs(logger, repository, config, container)
+		err = step.registerOutputs(logger, repository, config, container, step.containerMetadata)
 		if err != nil {
 			return err
 		}
 
-		action.delegate.Finished(logger, ExitStatus(processStatus))
+		step.delegate.Finished(logger, ExitStatus(processStatus))
 
 		err = container.SetProperty(taskExitStatusPropertyName, fmt.Sprintf("%d", processStatus))
 		if err != nil {
 			return err
 		}
 
-		action.succeeded = processStatus == 0
+		step.succeeded = processStatus == 0
 
 		return nil
 	}
 }
 
-func (action *TaskStep) Succeeded() bool {
+func (step *TaskStep) Succeeded() bool {
-	return action.succeeded
+	return step.succeeded
 }
 
-func (action *TaskStep) imageSpec(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig) (worker.ImageSpec, error) {
+func (step *TaskStep) imageSpec(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig) (worker.ImageSpec, error) {
 	imageSpec := worker.ImageSpec{
-		Privileged: bool(action.privileged),
+		Privileged: bool(step.plan.Privileged),
 	}
 
 	// Determine the source of the container image
 	// a reference to an artifact (get step, task output) ?
-	if action.imageArtifactName != "" {
+	if step.plan.ImageArtifactName != "" {
-		source, found := repository.SourceFor(artifact.Name(action.imageArtifactName))
+		source, found := repository.SourceFor(artifact.Name(step.plan.ImageArtifactName))
 		if !found {
-			return worker.ImageSpec{}, MissingTaskImageSourceError{action.imageArtifactName}
+			return worker.ImageSpec{}, MissingTaskImageSourceError{step.plan.ImageArtifactName}
 		}
 
 		imageSpec.ImageArtifactSource = source
@@ -334,7 +342,7 @@ func (action *TaskStep) imageSpec(logger lager.Logger, repository *artifact.Repo
 	} else if config.ImageResource != nil {
 		imageSpec.ImageResource = &worker.ImageResource{
 			Type:    config.ImageResource.Type,
-			Source:  creds.NewSource(boshtemplate.StaticVariables{}, config.ImageResource.Source),
+			Source:  config.ImageResource.Source,
 			Params:  config.ImageResource.Params,
 			Version: config.ImageResource.Version,
 		}
@@ -346,13 +354,13 @@ func (action *TaskStep) imageSpec(logger lager.Logger, repository *artifact.Repo
 	return imageSpec, nil
 }
 
-func (action *TaskStep) containerInputs(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig) ([]worker.InputSource, error) {
+func (step *TaskStep) containerInputs(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig, metadata db.ContainerMetadata) ([]worker.InputSource, error) {
 	inputs := []worker.InputSource{}
 
 	var missingRequiredInputs []string
 	for _, input := range config.Inputs {
 		inputName := input.Name
-		if sourceName, ok := action.inputMapping[inputName]; ok {
+		if sourceName, ok := step.plan.InputMapping[inputName]; ok {
 			inputName = sourceName
 		}
 
@@ -367,7 +375,7 @@ func (action *TaskStep) containerInputs(logger lager.Logger, repository *artifac
 		inputs = append(inputs, &taskInputSource{
 			config:        input,
 			source:        source,
-			artifactsRoot: action.artifactsRoot,
+			artifactsRoot: metadata.WorkingDirectory,
 		})
 	}
 
@@ -376,10 +384,10 @@ func (action *TaskStep) containerInputs(logger lager.Logger, repository *artifac
 	}
 
 	for _, cacheConfig := range config.Caches {
-		source := newTaskCacheSource(logger, action.teamID, action.jobID, action.stepName, cacheConfig.Path)
+		source := newTaskCacheSource(logger, step.metadata.TeamID, step.metadata.JobID, step.plan.Name, cacheConfig.Path)
 		inputs = append(inputs, &taskCacheInputSource{
 			source:        source,
-			artifactsRoot: action.artifactsRoot,
+			artifactsRoot: metadata.WorkingDirectory,
 			cachePath:     cacheConfig.Path,
 		})
 	}
@@ -387,48 +395,48 @@ func (action *TaskStep) containerInputs(logger lager.Logger, repository *artifac
 	return inputs, nil
 }
 
-func (action *TaskStep) containerSpec(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig) (worker.ContainerSpec, error) {
+func (step *TaskStep) containerSpec(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig, metadata db.ContainerMetadata) (worker.ContainerSpec, error) {
-	imageSpec, err := action.imageSpec(logger, repository, config)
+	imageSpec, err := step.imageSpec(logger, repository, config)
 	if err != nil {
 		return worker.ContainerSpec{}, err
 	}
 
 	containerSpec := worker.ContainerSpec{
 		Platform:  config.Platform,
-		Tags:      action.tags,
+		Tags:      step.plan.Tags,
-		TeamID:    action.teamID,
+		TeamID:    step.metadata.TeamID,
 		ImageSpec: imageSpec,
 		Limits:    worker.ContainerLimits(config.Limits),
 		User:      config.Run.User,
-		Dir:       action.artifactsRoot,
+		Dir:       metadata.WorkingDirectory,
-		Env:       action.envForParams(config.Params),
+		Env:       step.envForParams(config.Params),
 
 		Inputs:  []worker.InputSource{},
 		Outputs: worker.OutputPaths{},
 	}
 
-	containerSpec.Inputs, err = action.containerInputs(logger, repository, config)
+	containerSpec.Inputs, err = step.containerInputs(logger, repository, config, metadata)
 	if err != nil {
 		return worker.ContainerSpec{}, err
 	}
 
 	for _, output := range config.Outputs {
-		path := artifactsPath(output, action.artifactsRoot)
+		path := artifactsPath(output, metadata.WorkingDirectory)
 		containerSpec.Outputs[output.Name] = path
 	}
 
 	return containerSpec, nil
 }
 
-func (action *TaskStep) workerSpec(logger lager.Logger, resourceTypes creds.VersionedResourceTypes, repository *artifact.Repository, config atc.TaskConfig) (worker.WorkerSpec, error) {
+func (step *TaskStep) workerSpec(logger lager.Logger, resourceTypes atc.VersionedResourceTypes, repository *artifact.Repository, config atc.TaskConfig) (worker.WorkerSpec, error) {
 	workerSpec := worker.WorkerSpec{
 		Platform:      config.Platform,
-		Tags:          action.tags,
+		Tags:          step.plan.Tags,
-		TeamID:        action.teamID,
+		TeamID:        step.metadata.TeamID,
 		ResourceTypes: resourceTypes,
 	}
 
-	imageSpec, err := action.imageSpec(logger, repository, config)
+	imageSpec, err := step.imageSpec(logger, repository, config)
 	if err != nil {
 		return worker.WorkerSpec{}, err
 	}
@@ -440,18 +448,18 @@ func (action *TaskStep) workerSpec(logger lager.Logger, resourceTypes creds.Vers
 	return workerSpec, nil
 }
 
-func (action *TaskStep) registerOutputs(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig, container worker.Container) error {
+func (step *TaskStep) registerOutputs(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig, container worker.Container, metadata db.ContainerMetadata) error {
 	volumeMounts := container.VolumeMounts()
 
 	logger.Debug("registering-outputs", lager.Data{"outputs": config.Outputs})
 
 	for _, output := range config.Outputs {
 		outputName := output.Name
-		if destinationName, ok := action.outputMapping[output.Name]; ok {
+		if destinationName, ok := step.plan.OutputMapping[output.Name]; ok {
 			outputName = destinationName
 		}
 
-		outputPath := artifactsPath(output, action.artifactsRoot)
+		outputPath := artifactsPath(output, metadata.WorkingDirectory)
 
 		for _, mount := range volumeMounts {
 			if filepath.Clean(mount.MountPath) == filepath.Clean(outputPath) {
@@ -462,20 +470,20 @@ func (action *TaskStep) registerOutputs(logger lager.Logger, repository *artifac
 	}
 
 	// Do not initialize caches for one-off builds
-	if action.jobID != 0 {
+	if step.metadata.JobID != 0 {
 		logger.Debug("initializing-caches", lager.Data{"caches": config.Caches})
 
 		for _, cacheConfig := range config.Caches {
 			for _, volumeMount := range volumeMounts {
-				if volumeMount.MountPath == filepath.Join(action.artifactsRoot, cacheConfig.Path) {
+				if volumeMount.MountPath == filepath.Join(metadata.WorkingDirectory, cacheConfig.Path) {
 					logger.Debug("initializing-cache", lager.Data{"path": volumeMount.MountPath})
 
 					err := volumeMount.Volume.InitializeTaskCache(
 						logger,
-						action.jobID,
+						step.metadata.JobID,
-						action.stepName,
+						step.plan.Name,
 						cacheConfig.Path,
-						bool(action.privileged))
+						bool(step.plan.Privileged))
 					if err != nil {
 						return err
 					}

atc/exec/task_step_test.go

@@ -13,9 +13,8 @@ import (
 	"code.cloudfoundry.org/garden/gardenfakes"
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc/creds/credsfakes"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/exec"
 	"github.com/concourse/concourse/atc/exec/artifact"
@@ -30,124 +29,125 @@ import (
 var _ = Describe("TaskStep", func() {
 	var (
 		ctx    context.Context
+		cancel func()
 		logger *lagertest.TestLogger
 
-		cancel func()
+		stdoutBuf *gbytes.Buffer
+		stderrBuf *gbytes.Buffer
 
 		fakePool     *workerfakes.FakePool
 		fakeWorker   *workerfakes.FakeWorker
 		fakeStrategy *workerfakes.FakeContainerPlacementStrategy
 
-		stdoutBuf *gbytes.Buffer
+		fakeSecretManager *credsfakes.FakeSecrets
-		stderrBuf *gbytes.Buffer
+		fakeDelegate      *execfakes.FakeTaskDelegate
+		taskPlan          *atc.TaskPlan
 
-		imageArtifactName string
+		interpolatedResourceTypes atc.VersionedResourceTypes
-		containerMetadata db.ContainerMetadata
-
-		fakeDelegate *execfakes.FakeTaskDelegate
-
-		privileged    exec.Privileged
-		tags          []string
-		teamID        int
-		buildID       int
-		planID        atc.PlanID
-		jobID         int
-		configSource  *execfakes.FakeTaskConfigSource
-		resourceTypes creds.VersionedResourceTypes
-		inputMapping  map[string]string
-		outputMapping map[string]string
 
 		repo  *artifact.Repository
 		state *execfakes.FakeRunState
 
 		taskStep exec.Step
+		stepErr  error
 
-		stepErr error
+		containerMetadata = db.ContainerMetadata{
+			WorkingDirectory: "some-artifact-root",
+			Type:             db.ContainerTypeTask,
+			StepName:         "some-step",
+		}
+
+		stepMetadata = exec.StepMetadata{
+			TeamID:  123,
+			BuildID: 1234,
+			JobID:   12345,
+		}
+
+		planID = atc.PlanID(42)
 	)
 
 	BeforeEach(func() {
 		ctx, cancel = context.WithCancel(context.Background())
 		logger = lagertest.NewTestLogger("task-action-test")
 
+		stdoutBuf = gbytes.NewBuffer()
+		stderrBuf = gbytes.NewBuffer()
+
 		fakeWorker = new(workerfakes.FakeWorker)
 		fakePool = new(workerfakes.FakePool)
 		fakeStrategy = new(workerfakes.FakeContainerPlacementStrategy)
 
-		stdoutBuf = gbytes.NewBuffer()
+		fakeSecretManager = new(credsfakes.FakeSecrets)
-		stderrBuf = gbytes.NewBuffer()
+		fakeSecretManager.GetReturns("super-secret-source", nil, true, nil)
 
 		fakeDelegate = new(execfakes.FakeTaskDelegate)
 		fakeDelegate.StdoutReturns(stdoutBuf)
 		fakeDelegate.StderrReturns(stderrBuf)
 
-		privileged = false
-		tags = []string{"step", "tags"}
-		teamID = 123
-		planID = atc.PlanID(42)
-		buildID = 1234
-		jobID = 12345
-		configSource = new(execfakes.FakeTaskConfigSource)
-
 		repo = artifact.NewRepository()
 		state = new(execfakes.FakeRunState)
 		state.ArtifactsReturns(repo)
 
-		resourceTypes = creds.NewVersionedResourceTypes(template.StaticVariables{}, atc.VersionedResourceTypes{
+		uninterpolatedResourceTypes := atc.VersionedResourceTypes{
 			{
 				ResourceType: atc.ResourceType{
 					Name:   "custom-resource",
 					Type:   "custom-type",
-					Source: atc.Source{"some-custom": "source"},
+					Source: atc.Source{"some-custom": "((source-param))"},
 					Params: atc.Params{"some-custom": "param"},
 				},
 				Version: atc.Version{"some-custom": "version"},
 			},
-		})
-
-		inputMapping = nil
-		outputMapping = nil
-		imageArtifactName = ""
-
-		containerMetadata = db.ContainerMetadata{
-			Type:     db.ContainerTypeTask,
-			StepName: "some-step",
 		}
 
-		stepErr = nil
+		interpolatedResourceTypes = atc.VersionedResourceTypes{
+			{
+				ResourceType: atc.ResourceType{
+					Name:   "custom-resource",
+					Type:   "custom-type",
+					Source: atc.Source{"some-custom": "super-secret-source"},
+					Params: atc.Params{"some-custom": "param"},
+				},
+				Version: atc.Version{"some-custom": "version"},
+			},
+		}
+
+		taskPlan = &atc.TaskPlan{
+			Name:                   "some-task",
+			Privileged:             false,
+			Tags:                   []string{"step", "tags"},
+			VersionedResourceTypes: uninterpolatedResourceTypes,
+		}
 	})
 
 	JustBeforeEach(func() {
+		plan := atc.Plan{
+			ID:   atc.PlanID(planID),
+			Task: taskPlan,
+		}
+
 		taskStep = exec.NewTaskStep(
-			privileged,
+			plan.ID,
-			configSource,
+			*plan.Task,
-			tags,
-			inputMapping,
-			outputMapping,
-			"some-artifact-root",
-			imageArtifactName,
-			fakeDelegate,
-			fakePool,
-			teamID,
-			buildID,
-			jobID,
-			"some-task",
-			planID,
-			containerMetadata,
-			resourceTypes,
 			atc.ContainerLimits{},
+			stepMetadata,
+			containerMetadata,
+			fakeSecretManager,
 			fakeStrategy,
+			fakePool,
+			fakeDelegate,
 		)
 
 		stepErr = taskStep.Run(ctx, state)
 	})
 
-	Context("when getting the config works", func() {
+	Context("when the plan has a config", func() {
-		var fetchedConfig atc.TaskConfig
 
 		BeforeEach(func() {
 			cpu := uint64(1024)
 			memory := uint64(1024)
-			fetchedConfig = atc.TaskConfig{
+
+			taskPlan.Config = &atc.TaskConfig{
 				Platform: "some-platform",
 				ImageResource: &atc.ImageResource{
 					Type:    "docker",
@@ -167,8 +167,6 @@ var _ = Describe("TaskStep", func() {
 					Args: []string{"some", "args"},
 				},
 			}
-
-			configSource.FetchConfigReturns(fetchedConfig, nil)
 		})
 
 		Context("when the worker is either found or chosen", func() {
@@ -182,19 +180,24 @@ var _ = Describe("TaskStep", func() {
 
 			It("finds or chooses a worker", func() {
 				Expect(fakePool.FindOrChooseWorkerForContainerCallCount()).To(Equal(1))
-				_, owner, containerSpec, workerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+				_, _, owner, containerSpec, createdMetadata, workerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
-				Expect(owner).To(Equal(db.NewBuildStepContainerOwner(buildID, planID, teamID)))
+				Expect(owner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, planID, stepMetadata.TeamID)))
+				Expect(createdMetadata).To(Equal(db.ContainerMetadata{
+					WorkingDirectory: "some-artifact-root",
+					Type:             db.ContainerTypeTask,
+					StepName:         "some-step",
+				}))
 
 				cpu := uint64(1024)
 				memory := uint64(1024)
 				Expect(containerSpec).To(Equal(worker.ContainerSpec{
 					Platform: "some-platform",
 					Tags:     []string{"step", "tags"},
-					TeamID:   teamID,
+					TeamID:   stepMetadata.TeamID,
 					ImageSpec: worker.ImageSpec{
 						ImageResource: &worker.ImageResource{
 							Type:    "docker",
-							Source:  creds.NewSource(template.StaticVariables{}, atc.Source{"some": "secret-source-param"}),
+							Source:  atc.Source{"some": "secret-source-param"},
 							Params:  &atc.Params{"some": "params"},
 							Version: &atc.Version{"some": "version"},
 						},
@@ -213,9 +216,9 @@ var _ = Describe("TaskStep", func() {
 				Expect(workerSpec).To(Equal(worker.WorkerSpec{
 					Platform:      "some-platform",
 					Tags:          []string{"step", "tags"},
-					TeamID:        teamID,
+					TeamID:        stepMetadata.TeamID,
 					ResourceType:  "docker",
-					ResourceTypes: resourceTypes,
+					ResourceTypes: interpolatedResourceTypes,
 				}))
 				Expect(strategy).To(Equal(fakeStrategy))
 			})
@@ -246,14 +249,9 @@ var _ = Describe("TaskStep", func() {
 
 				It("finds or creates a container", func() {
 					Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-					_, cancel, delegate, owner, createdMetadata, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+					_, cancel, delegate, owner, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
 					Expect(cancel).ToNot(BeNil())
-					Expect(owner).To(Equal(db.NewBuildStepContainerOwner(buildID, planID, teamID)))
+					Expect(owner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, planID, stepMetadata.TeamID)))
-					Expect(createdMetadata).To(Equal(db.ContainerMetadata{
-						Type:     db.ContainerTypeTask,
-						StepName: "some-step",
-					}))
-
 					Expect(delegate).To(Equal(fakeDelegate))
 
 					cpu := uint64(1024)
@@ -261,11 +259,11 @@ var _ = Describe("TaskStep", func() {
 					Expect(containerSpec).To(Equal(worker.ContainerSpec{
 						Platform: "some-platform",
 						Tags:     []string{"step", "tags"},
-						TeamID:   teamID,
+						TeamID:   stepMetadata.TeamID,
 						ImageSpec: worker.ImageSpec{
 							ImageResource: &worker.ImageResource{
 								Type:    "docker",
-								Source:  creds.NewSource(template.StaticVariables{}, atc.Source{"some": "secret-source-param"}),
+								Source:  atc.Source{"some": "secret-source-param"},
 								Params:  &atc.Params{"some": "params"},
 								Version: &atc.Version{"some": "version"},
 							},
@@ -280,12 +278,12 @@ var _ = Describe("TaskStep", func() {
 						Inputs:  []worker.InputSource{},
 						Outputs: worker.OutputPaths{},
 					}))
-					Expect(actualResourceTypes).To(Equal(resourceTypes))
+					Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
 				})
 
 				Context("when rootfs uri is set instead of image resource", func() {
 					BeforeEach(func() {
-						fetchedConfig = atc.TaskConfig{
+						taskPlan.Config = &atc.TaskConfig{
 							Platform:  "some-platform",
 							RootfsURI: "some-image",
 							Params:    map[string]string{"SOME": "params"},
@@ -294,26 +292,19 @@ var _ = Describe("TaskStep", func() {
 								Args: []string{"some", "args"},
 							},
 						}
-
-						configSource.FetchConfigReturns(fetchedConfig, nil)
 					})
 
 					It("finds or creates a container", func() {
 						Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-						_, cancel, delegate, owner, createdMetadata, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+						_, cancel, delegate, owner, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
 						Expect(cancel).ToNot(BeNil())
-						Expect(owner).To(Equal(db.NewBuildStepContainerOwner(buildID, planID, teamID)))
+						Expect(owner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, planID, stepMetadata.TeamID)))
-						Expect(createdMetadata).To(Equal(db.ContainerMetadata{
-							Type:     db.ContainerTypeTask,
-							StepName: "some-step",
-						}))
-
 						Expect(delegate).To(Equal(fakeDelegate))
 
 						Expect(containerSpec).To(Equal(worker.ContainerSpec{
 							Platform: "some-platform",
 							Tags:     []string{"step", "tags"},
-							TeamID:   teamID,
+							TeamID:   stepMetadata.TeamID,
 							ImageSpec: worker.ImageSpec{
 								ImageURL:   "some-image",
 								Privileged: false,
@@ -324,7 +315,7 @@ var _ = Describe("TaskStep", func() {
 							Outputs: worker.OutputPaths{},
 						}))
 
-						Expect(actualResourceTypes).To(Equal(resourceTypes))
+						Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
 					})
 				})
 
@@ -370,7 +361,7 @@ var _ = Describe("TaskStep", func() {
 						)
 
 						BeforeEach(func() {
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
 								Params:    map[string]string{"SOME": "params"},
@@ -383,7 +374,7 @@ var _ = Describe("TaskStep", func() {
 									{Name: "some-other-output"},
 									{Name: "some-trailing-slash-output", Path: "some-output-configured-path-with-trailing-slash/"},
 								},
-							}, nil)
+							}
 
 							fakeNewlyCreatedVolume1 = new(workerfakes.FakeVolume)
 							fakeNewlyCreatedVolume1.HandleReturns("some-handle-1")
@@ -518,12 +509,12 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when privileged", func() {
 						BeforeEach(func() {
-							privileged = true
+							taskPlan.Privileged = true
 						})
 
 						It("creates the container privileged", func() {
 							Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-							_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+							_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 							Expect(containerSpec.ImageSpec.Privileged).To(BeTrue())
 						})
 
@@ -549,7 +540,7 @@ var _ = Describe("TaskStep", func() {
 							inputSource = new(workerfakes.FakeArtifactSource)
 							otherInputSource = new(workerfakes.FakeArtifactSource)
 
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
 								Params:    map[string]string{"SOME": "params"},
@@ -561,7 +552,7 @@ var _ = Describe("TaskStep", func() {
 									{Name: "some-input", Path: "some-input-configured-path"},
 									{Name: "some-other-input"},
 								},
-							}, nil)
+							}
 						})
 
 						Context("when all inputs are present", func() {
@@ -571,7 +562,7 @@ var _ = Describe("TaskStep", func() {
 							})
 
 							It("creates the container with the inputs configured correctly", func() {
-								_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+								_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 								Expect(containerSpec.Inputs).To(HaveLen(2))
 								for _, input := range containerSpec.Inputs {
 									switch input.DestinationPath() {
@@ -603,16 +594,17 @@ var _ = Describe("TaskStep", func() {
 
 						BeforeEach(func() {
 							remappedInputSource = new(workerfakes.FakeArtifactSource)
-							inputMapping = map[string]string{"remapped-input": "remapped-input-src"}
+							taskPlan.InputMapping = map[string]string{"remapped-input": "remapped-input-src"}
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
+								Platform: "some-platform",
 								Run: atc.TaskRunConfig{
 									Path: "ls",
+									Args: []string{"some", "args"},
 								},
 								Inputs: []atc.TaskInputConfig{
 									{Name: "remapped-input"},
 								},
-							}, nil)
+							}
-
 						})
 
 						Context("when all inputs are present in the in source repository", func() {
@@ -621,7 +613,8 @@ var _ = Describe("TaskStep", func() {
 							})
 
 							It("uses remapped input", func() {
-								_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+								Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+								_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 								Expect(containerSpec.Inputs).To(HaveLen(1))
 								Expect(containerSpec.Inputs[0].Source()).To(Equal(remappedInputSource))
 								Expect(containerSpec.Inputs[0].DestinationPath()).To(Equal("some-artifact-root/remapped-input"))
@@ -646,7 +639,8 @@ var _ = Describe("TaskStep", func() {
 							optionalInputSource = new(workerfakes.FakeArtifactSource)
 							optionalInput2Source = new(workerfakes.FakeArtifactSource)
 							requiredInputSource = new(workerfakes.FakeArtifactSource)
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
+								Platform: "some-platform",
 								Run: atc.TaskRunConfig{
 									Path: "ls",
 								},
@@ -655,7 +649,7 @@ var _ = Describe("TaskStep", func() {
 									{Name: "optional-input-2", Optional: true},
 									{Name: "required-input"},
 								},
-							}, nil)
+							}
 						})
 
 						Context("when an optional input is missing", func() {
@@ -666,7 +660,7 @@ var _ = Describe("TaskStep", func() {
 
 							It("runs successfully without the optional input", func() {
 								Expect(stepErr).ToNot(HaveOccurred())
-								_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+								_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 								Expect(containerSpec.Inputs).To(HaveLen(2))
 								Expect(containerSpec.Inputs[0].Source()).To(Equal(optionalInput2Source))
 								Expect(containerSpec.Inputs[0].DestinationPath()).To(Equal("some-artifact-root/optional-input-2"))
@@ -695,15 +689,17 @@ var _ = Describe("TaskStep", func() {
 						)
 
 						BeforeEach(func() {
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
-								Run:       atc.TaskRunConfig{},
+								Run: atc.TaskRunConfig{
+									Path: "ls",
+								},
 								Caches: []atc.CacheConfig{
 									{Path: "some-path-1"},
 									{Path: "some-path-2"},
 								},
-							}, nil)
+							}
 
 							fakeVolume1 = new(workerfakes.FakeVolume)
 							fakeVolume2 = new(workerfakes.FakeVolume)
@@ -720,7 +716,7 @@ var _ = Describe("TaskStep", func() {
 						})
 
 						It("creates the container with the caches in the inputs", func() {
-							_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+							_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 							Expect(containerSpec.Inputs).To(HaveLen(2))
 							Expect([]string{
 								containerSpec.Inputs[0].DestinationPath(),
@@ -731,27 +727,33 @@ var _ = Describe("TaskStep", func() {
 							))
 						})
 
-						It("registers cache volumes as task caches", func() {
+						Context("when task belongs to a job", func() {
-							Expect(stepErr).ToNot(HaveOccurred())
+							BeforeEach(func() {
+								stepMetadata.JobID = 12
+							})
 
-							Expect(fakeVolume1.InitializeTaskCacheCallCount()).To(Equal(1))
+							It("registers cache volumes as task caches", func() {
-							_, jID, stepName, cachePath, p := fakeVolume1.InitializeTaskCacheArgsForCall(0)
+								Expect(stepErr).ToNot(HaveOccurred())
-							Expect(jID).To(Equal(jobID))
-							Expect(stepName).To(Equal("some-task"))
-							Expect(cachePath).To(Equal("some-path-1"))
-							Expect(p).To(Equal(bool(privileged)))
 
-							Expect(fakeVolume2.InitializeTaskCacheCallCount()).To(Equal(1))
+								Expect(fakeVolume1.InitializeTaskCacheCallCount()).To(Equal(1))
-							_, jID, stepName, cachePath, p = fakeVolume2.InitializeTaskCacheArgsForCall(0)
+								_, jID, stepName, cachePath, p := fakeVolume1.InitializeTaskCacheArgsForCall(0)
-							Expect(jID).To(Equal(jobID))
+								Expect(jID).To(Equal(stepMetadata.JobID))
-							Expect(stepName).To(Equal("some-task"))
+								Expect(stepName).To(Equal("some-task"))
-							Expect(cachePath).To(Equal("some-path-2"))
+								Expect(cachePath).To(Equal("some-path-1"))
-							Expect(p).To(Equal(bool(privileged)))
+								Expect(p).To(Equal(bool(taskPlan.Privileged)))
+
+								Expect(fakeVolume2.InitializeTaskCacheCallCount()).To(Equal(1))
+								_, jID, stepName, cachePath, p = fakeVolume2.InitializeTaskCacheArgsForCall(0)
+								Expect(jID).To(Equal(stepMetadata.JobID))
+								Expect(stepName).To(Equal("some-task"))
+								Expect(cachePath).To(Equal("some-path-2"))
+								Expect(p).To(Equal(bool(taskPlan.Privileged)))
+							})
 						})
 
 						Context("when task does not belong to job (one-off build)", func() {
 							BeforeEach(func() {
-								jobID = 0
+								stepMetadata.JobID = 0
 							})
 
 							It("does not initialize caches", func() {
@@ -764,7 +766,7 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when the configuration specifies paths for outputs", func() {
 						BeforeEach(func() {
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
 								Params:    map[string]string{"SOME": "params"},
@@ -777,11 +779,11 @@ var _ = Describe("TaskStep", func() {
 									{Name: "some-other-output"},
 									{Name: "some-trailing-slash-output", Path: "some-output-configured-path-with-trailing-slash/"},
 								},
-							}, nil)
+							}
 						})
 
 						It("configures them appropriately in the container spec", func() {
-							_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+							_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 							Expect(containerSpec.Outputs).To(Equal(worker.OutputPaths{
 								"some-output":                "some-artifact-root/some-output-configured-path/",
 								"some-other-output":          "some-artifact-root/some-other-output/",
@@ -881,7 +883,7 @@ var _ = Describe("TaskStep", func() {
 									})
 
 									It("passes existing output volumes to the resource", func() {
-										_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+										_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 										Expect(containerSpec.Outputs).To(Equal(worker.OutputPaths{
 											"some-output":                "some-artifact-root/some-output-configured-path/",
 											"some-other-output":          "some-artifact-root/some-other-output/",
@@ -1142,15 +1144,16 @@ var _ = Describe("TaskStep", func() {
 						)
 
 						BeforeEach(func() {
-							outputMapping = map[string]string{"generic-remapped-output": "specific-remapped-output"}
+							taskPlan.OutputMapping = map[string]string{"generic-remapped-output": "specific-remapped-output"}
-							configSource.FetchConfigReturns(atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
+								Platform: "some-platform",
 								Run: atc.TaskRunConfig{
 									Path: "ls",
 								},
 								Outputs: []atc.TaskOutputConfig{
 									{Name: "generic-remapped-output"},
 								},
-							}, nil)
+							}
 
 							fakeProcess.WaitReturns(0, nil)
 
@@ -1180,7 +1183,7 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when an image artifact name is specified", func() {
 						BeforeEach(func() {
-							imageArtifactName = "some-image-artifact"
+							taskPlan.ImageArtifactName = "some-image-artifact"
 
 							fakeProcess.WaitReturns(0, nil)
 						})
@@ -1194,7 +1197,7 @@ var _ = Describe("TaskStep", func() {
 							})
 
 							It("chooses a worker and creates the container with the image artifact source", func() {
-								_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+								_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 								Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 									ImageArtifactSource: imageArtifactSource,
 								}))
@@ -1216,7 +1219,7 @@ var _ = Describe("TaskStep", func() {
 
 									Context("when the task config also specifies image", func() {
 										BeforeEach(func() {
-											configWithImage := atc.TaskConfig{
+											taskPlan.Config = &atc.TaskConfig{
 												Platform:  "some-platform",
 												RootfsURI: "some-image",
 												Params:    map[string]string{"SOME": "params"},
@@ -1225,12 +1228,10 @@ var _ = Describe("TaskStep", func() {
 													Args: []string{"some", "args"},
 												},
 											}
-
-											configSource.FetchConfigReturns(configWithImage, nil)
 										})
 
 										It("still chooses a worker and creates the container with the volume and a metadata stream", func() {
-											_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+											_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 											Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 												ImageArtifactSource: imageArtifactSource,
 											}))
@@ -1241,7 +1242,7 @@ var _ = Describe("TaskStep", func() {
 
 									Context("when the task config also specifies image_resource", func() {
 										BeforeEach(func() {
-											configWithImageResource := atc.TaskConfig{
+											taskPlan.Config = &atc.TaskConfig{
 												Platform: "some-platform",
 												ImageResource: &atc.ImageResource{
 													Type:    "docker",
@@ -1255,12 +1256,10 @@ var _ = Describe("TaskStep", func() {
 													Args: []string{"some", "args"},
 												},
 											}
-
-											configSource.FetchConfigReturns(configWithImageResource, nil)
 										})
 
 										It("still chooses a worker and creates the container with the volume and a metadata stream", func() {
-											_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+											_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 											Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 												ImageArtifactSource: imageArtifactSource,
 											}))
@@ -1271,7 +1270,7 @@ var _ = Describe("TaskStep", func() {
 
 									Context("when the task config also specifies image and image_resource", func() {
 										BeforeEach(func() {
-											configWithImageAndImageResource := atc.TaskConfig{
+											taskPlan.Config = &atc.TaskConfig{
 												Platform:  "some-platform",
 												RootfsURI: "some-image",
 												ImageResource: &atc.ImageResource{
@@ -1286,12 +1285,10 @@ var _ = Describe("TaskStep", func() {
 													Args: []string{"some", "args"},
 												},
 											}
-
-											configSource.FetchConfigReturns(configWithImageAndImageResource, nil)
 										})
 
 										It("still chooses a worker and creates the container with the volume and a metadata stream", func() {
-											_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+											_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 											Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 												ImageArtifactSource: imageArtifactSource,
 											}))
@@ -1315,7 +1312,7 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when the image_resource is specified (even if RootfsURI is configured)", func() {
 						BeforeEach(func() {
-							configWithImageResource := atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
 								ImageResource: &atc.ImageResource{
@@ -1330,15 +1327,13 @@ var _ = Describe("TaskStep", func() {
 									Args: []string{"some", "args"},
 								},
 							}
-
-							configSource.FetchConfigReturns(configWithImageResource, nil)
 						})
 
 						It("creates the specs with the image resource", func() {
-							_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+							_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 							Expect(containerSpec.ImageSpec.ImageResource).To(Equal(&worker.ImageResource{
 								Type:    "docker",
-								Source:  creds.NewSource(template.StaticVariables{}, atc.Source{"some": "super-secret-source"}),
+								Source:  atc.Source{"some": "super-secret-source"},
 								Params:  &atc.Params{"some": "params"},
 								Version: &atc.Version{"some": "version"},
 							}))
@@ -1346,7 +1341,7 @@ var _ = Describe("TaskStep", func() {
 							Expect(workerSpec).To(Equal(worker.WorkerSpec{
 								TeamID:        123,
 								Platform:      "some-platform",
-								ResourceTypes: resourceTypes,
+								ResourceTypes: interpolatedResourceTypes,
 								Tags:          []string{"step", "tags"},
 								ResourceType:  "docker",
 							}))
@@ -1355,7 +1350,7 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when the RootfsURI is configured", func() {
 						BeforeEach(func() {
-							configWithRootfs := atc.TaskConfig{
+							taskPlan.Config = &atc.TaskConfig{
 								Platform:  "some-platform",
 								RootfsURI: "some-image",
 								Params:    map[string]string{"SOME": "params"},
@@ -1364,18 +1359,16 @@ var _ = Describe("TaskStep", func() {
 									Args: []string{"some", "args"},
 								},
 							}
-
-							configSource.FetchConfigReturns(configWithRootfs, nil)
 						})
 
 						It("creates the specs with the image resource", func() {
-							_, _, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+							_, _, _, containerSpec, _, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 							Expect(containerSpec.ImageSpec.ImageURL).To(Equal("some-image"))
 
 							Expect(workerSpec).To(Equal(worker.WorkerSpec{
 								TeamID:        123,
 								Platform:      "some-platform",
-								ResourceTypes: resourceTypes,
+								ResourceTypes: interpolatedResourceTypes,
 								Tags:          []string{"step", "tags"},
 							}))
 						})
@@ -1383,8 +1376,7 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when a run dir is specified", func() {
 						BeforeEach(func() {
-							fetchedConfig.Run.Dir = "/some/dir"
+							taskPlan.Config.Run.Dir = "/some/dir"
-							configSource.FetchConfigReturns(fetchedConfig, nil)
 						})
 
 						It("runs a process in the specified (custom) directory", func() {
@@ -1395,12 +1387,11 @@ var _ = Describe("TaskStep", func() {
 
 					Context("when a run user is specified", func() {
 						BeforeEach(func() {
-							fetchedConfig.Run.User = "some-user"
+							taskPlan.Config.Run.User = "some-user"
-							configSource.FetchConfigReturns(fetchedConfig, nil)
 						})
 
 						It("adds the user to the container spec", func() {
-							_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+							_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 							Expect(containerSpec.User).To(Equal("some-user"))
 						})
 
@@ -1656,15 +1647,29 @@ var _ = Describe("TaskStep", func() {
 			})
 		})
 
-		Context("when getting the config fails", func() {
+		Context("when missing the platform", func() {
-			disaster := errors.New("nope")
 
 			BeforeEach(func() {
-				configSource.FetchConfigReturns(atc.TaskConfig{}, disaster)
+				taskPlan.Config.Platform = ""
 			})
 
 			It("returns the error", func() {
-				Expect(stepErr).To(Equal(disaster))
+				Expect(stepErr).To(HaveOccurred())
+			})
+
+			It("is not successful", func() {
+				Expect(taskStep.Succeeded()).To(BeFalse())
+			})
+		})
+
+		Context("when missing the path to the executable", func() {
+
+			BeforeEach(func() {
+				taskPlan.Config.Run.Path = ""
+			})
+
+			It("returns the error", func() {
+				Expect(stepErr).To(HaveOccurred())
 			})
 
 			It("is not successful", func() {

atc/gc/resource_cache_collector_test.go

@@ -6,7 +6,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/algorithm"
 	"github.com/concourse/concourse/atc/gc"
@@ -43,7 +42,6 @@ var _ = Describe("ResourceCacheCollector", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				oneOffCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForBuild(oneOffBuild.ID()),
 					"some-base-type",
 					atc.Version{"some": "version"},
@@ -51,7 +49,7 @@ var _ = Describe("ResourceCacheCollector", func() {
 						"some": "source",
 					},
 					nil,
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).NotTo(HaveOccurred())
 
@@ -59,7 +57,6 @@ var _ = Describe("ResourceCacheCollector", func() {
 				Expect(err).ToNot(HaveOccurred())
 
 				jobCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-					logger,
 					db.ForBuild(jobBuild.ID()),
 					"some-base-type",
 					atc.Version{"some": "version"},
@@ -67,7 +64,7 @@ var _ = Describe("ResourceCacheCollector", func() {
 						"some": "source",
 					},
 					nil,
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).NotTo(HaveOccurred())
 
@@ -77,11 +74,10 @@ var _ = Describe("ResourceCacheCollector", func() {
 				Expect(found).To(BeTrue())
 
 				_, err = resource.SetResourceConfig(
-					logger,
 					atc.Source{
 						"some": "source",
 					},
-					creds.VersionedResourceTypes{})
+					atc.VersionedResourceTypes{})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
@@ -173,7 +169,6 @@ var _ = Describe("ResourceCacheCollector", func() {
 							Expect(err).ToNot(HaveOccurred())
 
 							secondJobCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-								logger,
 								db.ForBuild(secondJobBuild.ID()),
 								"some-base-type",
 								atc.Version{"some": "new-version"},
@@ -181,7 +176,7 @@ var _ = Describe("ResourceCacheCollector", func() {
 									"some": "source",
 								},
 								nil,
-								creds.VersionedResourceTypes{},
+								atc.VersionedResourceTypes{},
 							)
 							Expect(err).NotTo(HaveOccurred())
 
@@ -224,7 +219,6 @@ var _ = Describe("ResourceCacheCollector", func() {
 							Expect(err).ToNot(HaveOccurred())
 
 							secondJobCache, err = resourceCacheFactory.FindOrCreateResourceCache(
-								logger,
 								db.ForBuild(secondJobBuild.ID()),
 								"some-base-type",
 								atc.Version{"some": "new-version"},
@@ -232,7 +226,7 @@ var _ = Describe("ResourceCacheCollector", func() {
 									"some": "source",
 								},
 								nil,
-								creds.VersionedResourceTypes{},
+								atc.VersionedResourceTypes{},
 							)
 							Expect(err).NotTo(HaveOccurred())
 

atc/gc/resource_cache_use_collector_test.go

@@ -3,9 +3,7 @@ package gc_test
 import (
 	"context"
 
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/gc"
 
@@ -52,7 +50,7 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 						Name: "some-type",
 						Type: "some-base-type",
 						Source: atc.Source{
-							"some-type": "((source-param))",
+							"some-type": "source-param",
 						},
 					},
 					Version: atc.Version{"some-type": "version"},
@@ -62,7 +60,6 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 			Describe("for one-off builds", func() {
 				BeforeEach(func() {
 					_, err = resourceCacheFactory.FindOrCreateResourceCache(
-						logger,
 						db.ForBuild(defaultBuild.ID()),
 						"some-type",
 						atc.Version{"some": "version"},
@@ -70,11 +67,9 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 							"some": "source",
 						},
 						atc.Params{"some": "params"},
-						creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+						atc.VersionedResourceTypes{
-							atc.VersionedResourceTypes{
+							versionedResourceType,
-								versionedResourceType,
+						},
-							},
-						),
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})
@@ -129,7 +124,6 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 					Expect(err).ToNot(HaveOccurred())
 
 					_, err = resourceCacheFactory.FindOrCreateResourceCache(
-						logger,
 						db.ForBuild(jobBuild.ID()),
 						"some-type",
 						atc.Version{"some": "version"},
@@ -137,11 +131,9 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 							"some": "source",
 						},
 						atc.Params{"some": "params"},
-						creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+						atc.VersionedResourceTypes{
-							atc.VersionedResourceTypes{
+							versionedResourceType,
-								versionedResourceType,
+						},
-							},
-						),
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})
@@ -165,7 +157,6 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 						Expect(err).ToNot(HaveOccurred())
 
 						_, err = resourceCacheFactory.FindOrCreateResourceCache(
-							logger,
 							db.ForBuild(secondJobBuild.ID()),
 							"some-type",
 							atc.Version{"some": "version"},
@@ -173,11 +164,9 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 								"some": "source",
 							},
 							atc.Params{"some": "params"},
-							creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+							atc.VersionedResourceTypes{
-								atc.VersionedResourceTypes{
+								versionedResourceType,
-									versionedResourceType,
+							},
-								},
-							),
 						)
 						Expect(err).NotTo(HaveOccurred())
 					})
@@ -214,7 +203,6 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 					Expect(err).ToNot(HaveOccurred())
 
 					_, err = resourceCacheFactory.FindOrCreateResourceCache(
-						logger,
 						db.ForContainer(container.ID()),
 						"some-type",
 						atc.Version{"some-type": "version"},
@@ -222,11 +210,9 @@ var _ = Describe("ResourceCacheUseCollector", func() {
 							"cache": "source",
 						},
 						atc.Params{"some": "params"},
-						creds.NewVersionedResourceTypes(template.StaticVariables{"source-param": "some-secret-sauce"},
+						atc.VersionedResourceTypes{
-							atc.VersionedResourceTypes{
+							versionedResourceType,
-								versionedResourceType,
+						},
-							},
-						),
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})

atc/gc/resource_config_check_session_collector_test.go

@@ -6,7 +6,6 @@ import (
 
 	sq "github.com/Masterminds/squirrel"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/gc"
 
@@ -34,8 +33,8 @@ var _ = Describe("ResourceConfigCheckSessionCollector", func() {
 		var owner db.ContainerOwner
 
 		ownerExpiries = db.ContainerOwnerExpiries{
-			Min:       10 * time.Second,
+			Min: 10 * time.Second,
-			Max:       10 * time.Second,
+			Max: 10 * time.Second,
 		}
 
 		BeforeEach(func() {
@@ -46,11 +45,10 @@ var _ = Describe("ResourceConfigCheckSessionCollector", func() {
 			Expect(found).To(BeTrue())
 
 			resourceConfigScope, err = resource.SetResourceConfig(
-				logger,
 				atc.Source{
 					"some": "source",
 				},
-				creds.VersionedResourceTypes{})
+				atc.VersionedResourceTypes{})
 			Expect(err).ToNot(HaveOccurred())
 
 			owner = db.NewResourceConfigCheckSessionContainerOwner(resourceConfigScope.ResourceConfig(), ownerExpiries)

atc/gc/resource_config_collector_test.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/gc"
 
@@ -40,18 +39,17 @@ var _ = Describe("ResourceConfigCollector", func() {
 
 			Context("when the config is referenced in resource config check sessions", func() {
 				ownerExpiries := db.ContainerOwnerExpiries{
-					Min:       5 * time.Minute,
+					Min: 5 * time.Minute,
-					Max:       10 * time.Minute,
+					Max: 10 * time.Minute,
 				}
 
 				BeforeEach(func() {
 					resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(
-						logger,
 						"some-base-type",
 						atc.Source{
 							"some": "source",
 						},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 
@@ -84,18 +82,17 @@ var _ = Describe("ResourceConfigCollector", func() {
 
 			Context("when the config is no longer referenced in resource config check sessions", func() {
 				ownerExpiries := db.ContainerOwnerExpiries{
-					Min:       5 * time.Minute,
+					Min: 5 * time.Minute,
-					Max:       10 * time.Minute,
+					Max: 10 * time.Minute,
 				}
 
 				BeforeEach(func() {
 					resourceConfig, err := resourceConfigFactory.FindOrCreateResourceConfig(
-						logger,
 						"some-base-type",
 						atc.Source{
 							"some": "source",
 						},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 
@@ -137,7 +134,6 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is referenced in resource caches", func() {
 				BeforeEach(func() {
 					_, err = resourceCacheFactory.FindOrCreateResourceCache(
-						logger,
 						db.ForBuild(defaultBuild.ID()),
 						"some-base-type",
 						atc.Version{"some": "version"},
@@ -145,7 +141,7 @@ var _ = Describe("ResourceConfigCollector", func() {
 							"some": "source",
 						},
 						nil,
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})
@@ -160,7 +156,6 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is not referenced in resource caches", func() {
 				BeforeEach(func() {
 					_, err = resourceCacheFactory.FindOrCreateResourceCache(
-						logger,
 						db.ForBuild(defaultBuild.ID()),
 						"some-base-type",
 						atc.Version{"some": "version"},
@@ -168,7 +163,7 @@ var _ = Describe("ResourceConfigCollector", func() {
 							"some": "source",
 						},
 						nil,
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 
@@ -193,9 +188,8 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is referenced in resources", func() {
 				BeforeEach(func() {
 					_, err := usedResource.SetResourceConfig(
-						logger,
 						atc.Source{"some": "source"},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})
@@ -210,10 +204,9 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is not referenced in resources", func() {
 				BeforeEach(func() {
 					_, err := resourceConfigFactory.FindOrCreateResourceConfig(
-						logger,
 						"some-base-type",
 						atc.Source{"some": "source"},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 					_, err = usedResource.Reload()
@@ -231,9 +224,8 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is referenced in resource types", func() {
 				BeforeEach(func() {
 					_, err := usedResourceType.SetResourceConfig(
-						logger,
 						atc.Source{"some": "source-type"},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 				})
@@ -248,10 +240,9 @@ var _ = Describe("ResourceConfigCollector", func() {
 			Context("when config is not referenced in resource types", func() {
 				BeforeEach(func() {
 					_, err := resourceConfigFactory.FindOrCreateResourceConfig(
-						logger,
 						"some-base-type",
 						atc.Source{"some": "source-type"},
-						creds.VersionedResourceTypes{},
+						atc.VersionedResourceTypes{},
 					)
 					Expect(err).NotTo(HaveOccurred())
 					_, err = usedResourceType.Reload()

atc/integration/configuration_test.go

@@ -61,22 +61,6 @@ var _ = Describe("ATC Integration Test", func() {
 		})
 	})
 
-	Context("when cluster name is specified", func() {
-		BeforeEach(func() {
-			cmd.Server.ClusterName = "foobar"
-		})
-
-		It("renders cluster name into HTML template", func() {
-			resp, err := http.Get(atcURL)
-			Expect(err).NotTo(HaveOccurred())
-
-			bodyBytes, err := ioutil.ReadAll(resp.Body)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(resp.StatusCode).To(Equal(200))
-			Expect(string(bodyBytes)).To(ContainSubstring("foobar"))
-		})
-	})
-
 	It("set default team and config auth for the main team", func() {
 		client := webLogin(atcURL, "test", "test")
 

atc/radar/resource_scanner.go

@@ -154,10 +154,15 @@ func (scanner *resourceScanner) scan(logger lager.Logger, resourceID int, fromVe
 		return 0, err
 	}
 
-	versionedResourceTypes := creds.NewVersionedResourceTypes(
+	versionedResourceTypes, err := creds.NewVersionedResourceTypes(
 		scanner.variables,
 		resourceTypes.Deserialize(),
-	)
+	).Evaluate()
+	if err != nil {
+		logger.Error("failed-to-evaluate-resource-types", err)
+		scanner.setResourceCheckError(logger, savedResource, err)
+		return 0, err
+	}
 
 	source, err := creds.NewSource(scanner.variables, savedResource.Source()).Evaluate()
 	if err != nil {
@@ -167,7 +172,6 @@ func (scanner *resourceScanner) scan(logger lager.Logger, resourceID int, fromVe
 	}
 
 	resourceConfigScope, err := savedResource.SetResourceConfig(
-		logger,
 		source,
 		versionedResourceTypes,
 	)
@@ -203,7 +207,6 @@ func (scanner *resourceScanner) scan(logger lager.Logger, resourceID int, fromVe
 	for {
 		lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(
 			logger,
-			interval,
 		)
 		if err != nil {
 			lockLogger.Error("failed-to-get-lock", err, lager.Data{
@@ -265,7 +268,7 @@ func (scanner *resourceScanner) check(
 	savedResource db.Resource,
 	resourceConfigScope db.ResourceConfigScope,
 	fromVersion atc.Version,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 	source atc.Source,
 	saveGiven bool,
 	timeout time.Duration,
@@ -317,11 +320,18 @@ func (scanner *resourceScanner) check(
 	}
 
 	owner := db.NewResourceConfigCheckSessionContainerOwner(resourceConfigScope.ResourceConfig(), ContainerExpiries)
-	containerMetadata := db.ContainerMetadata{
-		Type: db.ContainerTypeCheck,
-	}
 
-	chosenWorker, err := scanner.pool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, scanner.strategy)
+	chosenWorker, err := scanner.pool.FindOrChooseWorkerForContainer(
+		context.Background(),
+		logger,
+		owner,
+		containerSpec,
+		db.ContainerMetadata{
+			Type: db.ContainerTypeCheck,
+		},
+		workerSpec,
+		scanner.strategy,
+	)
 	if err != nil {
 		logger.Error("failed-to-choose-a-worker", err)
 		chkErr := resourceConfigScope.SetCheckError(err)
@@ -330,17 +340,22 @@ func (scanner *resourceScanner) check(
 		}
 		return err
 	}
-
 	container, err := chosenWorker.FindOrCreateContainer(
 		context.Background(),
 		logger,
 		worker.NoopImageFetchingDelegate{},
 		owner,
-		containerMetadata,
 		containerSpec,
 		resourceTypes,
 	)
 	if err != nil {
+		// TODO: remove this after ephemeral check containers.
+		// Sometimes we pass in a check session thats too close to
+		// expirey into FindOrCreateContainer such that the container
+		// gced before the call is completed
+		if err == worker.ResourceConfigCheckSessionExpiredError {
+			return nil
+		}
 		logger.Error("failed-to-create-or-find-container", err)
 		chkErr := resourceConfigScope.SetCheckError(err)
 		if chkErr != nil {

atc/radar/resource_scanner_test.go

@@ -42,8 +42,8 @@ var _ = Describe("ResourceScanner", func() {
 		interval                  time.Duration
 		variables                 creds.Variables
 
-		fakeResourceType      *dbfakes.FakeResourceType
+		fakeResourceType          *dbfakes.FakeResourceType
-		versionedResourceType atc.VersionedResourceType
+		interpolatedResourceTypes atc.VersionedResourceTypes
 
 		scanner Scanner
 
@@ -73,13 +73,15 @@ var _ = Describe("ResourceScanner", func() {
 			Tags:   atc.Tags{"some-tag"},
 		}
 
-		versionedResourceType = atc.VersionedResourceType{
+		interpolatedResourceTypes = atc.VersionedResourceTypes{
-			ResourceType: atc.ResourceType{
+			{
-				Name:   "some-custom-resource",
+				ResourceType: atc.ResourceType{
-				Type:   "registry-image",
+					Name:   "some-custom-resource",
-				Source: atc.Source{"custom": "((source-params))"},
+					Type:   "registry-image",
+					Source: atc.Source{"custom": "some-secret-sauce"},
+				},
+				Version: atc.Version{"custom": "version"},
 			},
-			Version: atc.Version{"custom": "version"},
 		}
 
 		fakeContainer = new(workerfakes.FakeContainer)
@@ -165,7 +167,7 @@ var _ = Describe("ResourceScanner", func() {
 				results <- true
 				close(results)
 
-				fakeResourceConfigScope.AcquireResourceCheckingLockStub = func(logger lager.Logger, interval time.Duration) (lock.Lock, bool, error) {
+				fakeResourceConfigScope.AcquireResourceCheckingLockStub = func(logger lager.Logger) (lock.Lock, bool, error) {
 					if <-results {
 						return fakeLock, true, nil
 					} else {
@@ -178,16 +180,6 @@ var _ = Describe("ResourceScanner", func() {
 
 			It("retries every second until it is", func() {
 				Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(3))
-
-				_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-				Expect(leaseInterval).To(Equal(interval))
-
-				_, leaseInterval = fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(1)
-				Expect(leaseInterval).To(Equal(interval))
-
-				_, leaseInterval = fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(2)
-				Expect(leaseInterval).To(Equal(interval))
-
 				Expect(fakeLock.ReleaseCallCount()).To(Equal(1))
 			})
 		})
@@ -238,17 +230,15 @@ var _ = Describe("ResourceScanner", func() {
 
 				It("constructs the resource of the correct type", func() {
 					Expect(fakeDBResource.SetResourceConfigCallCount()).To(Equal(1))
-					_, resourceSource, resourceTypes := fakeDBResource.SetResourceConfigArgsForCall(0)
+					resourceSource, resourceTypes := fakeDBResource.SetResourceConfigArgsForCall(0)
 					Expect(resourceSource).To(Equal(atc.Source{"uri": "some-secret-sauce"}))
-					Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-						versionedResourceType,
-					})))
 
 					Expect(fakeDBResource.SetCheckSetupErrorCallCount()).To(Equal(1))
 					err := fakeDBResource.SetCheckSetupErrorArgsForCall(0)
 					Expect(err).To(BeNil())
 
-					_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+					_, _, owner, containerSpec, metadata, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, radar.ContainerExpiries)))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "git",
@@ -260,19 +250,19 @@ var _ = Describe("ResourceScanner", func() {
 						"RESOURCE_PIPELINE_NAME=some-pipeline",
 						"RESOURCE_NAME=some-resource",
 					}))
+					Expect(metadata).To(Equal(db.ContainerMetadata{
+						Type: db.ContainerTypeCheck,
+					}))
 					Expect(workerSpec).To(Equal(worker.WorkerSpec{
 						ResourceType:  "git",
 						Tags:          atc.Tags{"some-tag"},
-						ResourceTypes: creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{versionedResourceType}),
+						ResourceTypes: interpolatedResourceTypes,
 						TeamID:        123,
 					}))
 
 					Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-					_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+					_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
 					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, radar.ContainerExpiries)))
-					Expect(metadata).To(Equal(db.ContainerMetadata{
-						Type: db.ContainerTypeCheck,
-					}))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "git",
 					}))
@@ -283,9 +273,7 @@ var _ = Describe("ResourceScanner", func() {
 						"RESOURCE_PIPELINE_NAME=some-pipeline",
 						"RESOURCE_NAME=some-resource",
 					}))
-					Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-						versionedResourceType,
-					})))
 				})
 
 				Context("when the resource config has a specified check interval", func() {
@@ -298,9 +286,6 @@ var _ = Describe("ResourceScanner", func() {
 						Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 						Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-						_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-						Expect(leaseInterval).To(Equal(10 * time.Millisecond))
-
 						leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 						Expect(leaseInterval).To(Equal(10 * time.Millisecond))
 						Expect(immediate).To(BeFalse())
@@ -335,9 +320,6 @@ var _ = Describe("ResourceScanner", func() {
 					Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 					Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-					_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-					Expect(leaseInterval).To(Equal(interval))
-
 					leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 					Expect(leaseInterval).To(Equal(interval))
 					Expect(immediate).To(BeFalse())
@@ -670,17 +652,15 @@ var _ = Describe("ResourceScanner", func() {
 
 			It("constructs the resource of the correct type", func() {
 				Expect(fakeDBResource.SetResourceConfigCallCount()).To(Equal(1))
-				_, resourceSource, resourceTypes := fakeDBResource.SetResourceConfigArgsForCall(0)
+				resourceSource, resourceTypes := fakeDBResource.SetResourceConfigArgsForCall(0)
 				Expect(resourceSource).To(Equal(atc.Source{"uri": "some-secret-sauce"}))
-				Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+				Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-					versionedResourceType,
-				})))
 
 				Expect(fakeDBResource.SetCheckSetupErrorCallCount()).To(Equal(1))
 				err := fakeDBResource.SetCheckSetupErrorArgsForCall(0)
 				Expect(err).To(BeNil())
 
-				_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+				_, _, owner, containerSpec, metadata, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 				Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, radar.ContainerExpiries)))
 				Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "git",
@@ -692,18 +672,18 @@ var _ = Describe("ResourceScanner", func() {
 					"RESOURCE_PIPELINE_NAME=some-pipeline",
 					"RESOURCE_NAME=some-resource",
 				}))
+				Expect(metadata).To(Equal(db.ContainerMetadata{
+					Type: db.ContainerTypeCheck,
+				}))
 				Expect(workerSpec).To(Equal(worker.WorkerSpec{
 					ResourceType:  "git",
 					Tags:          atc.Tags{"some-tag"},
-					ResourceTypes: creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{versionedResourceType}),
+					ResourceTypes: interpolatedResourceTypes,
 					TeamID:        123,
 				}))
 
-				_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+				_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
 				Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, radar.ContainerExpiries)))
-				Expect(metadata).To(Equal(db.ContainerMetadata{
-					Type: db.ContainerTypeCheck,
-				}))
 				Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "git",
 				}))
@@ -714,18 +694,13 @@ var _ = Describe("ResourceScanner", func() {
 					"RESOURCE_PIPELINE_NAME=some-pipeline",
 					"RESOURCE_NAME=some-resource",
 				}))
-				Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+				Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-					versionedResourceType,
-				})))
 			})
 
 			It("grabs an immediate resource checking lock before checking, breaks lock after done", func() {
 				Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 				Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-				_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-				Expect(leaseInterval).To(Equal(interval))
-
 				leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 				Expect(leaseInterval).To(Equal(interval))
 				Expect(immediate).To(BeTrue())
@@ -785,9 +760,6 @@ var _ = Describe("ResourceScanner", func() {
 					Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 					Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-					_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-					Expect(leaseInterval).To(Equal(10 * time.Millisecond))
-
 					leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 					Expect(leaseInterval).To(Equal(10 * time.Millisecond))
 					Expect(immediate).To(BeTrue())

atc/radar/resource_type_scanner.go

@@ -115,10 +115,15 @@ func (scanner *resourceTypeScanner) scan(logger lager.Logger, resourceTypeID int
 		return 0, err
 	}
 
-	versionedResourceTypes := creds.NewVersionedResourceTypes(
+	versionedResourceTypes, err := creds.NewVersionedResourceTypes(
 		scanner.variables,
 		resourceTypes.Deserialize(),
-	)
+	).Evaluate()
+	if err != nil {
+		logger.Error("failed-to-evaluate-resource-types", err)
+		scanner.setCheckError(logger, savedResourceType, err)
+		return 0, err
+	}
 
 	source, err := creds.NewSource(scanner.variables, savedResourceType.Source()).Evaluate()
 	if err != nil {
@@ -128,7 +133,6 @@ func (scanner *resourceTypeScanner) scan(logger lager.Logger, resourceTypeID int
 	}
 
 	resourceConfigScope, err := savedResourceType.SetResourceConfig(
-		logger,
 		source,
 		versionedResourceTypes.Without(savedResourceType.Name()),
 	)
@@ -146,7 +150,6 @@ func (scanner *resourceTypeScanner) scan(logger lager.Logger, resourceTypeID int
 		reattempt = mustComplete
 		lock, acquired, err := resourceConfigScope.AcquireResourceCheckingLock(
 			logger,
-			interval,
 		)
 		if err != nil {
 			lockLogger.Error("failed-to-get-lock", err, lager.Data{
@@ -218,7 +221,7 @@ func (scanner *resourceTypeScanner) check(
 	savedResourceType db.ResourceType,
 	resourceConfigScope db.ResourceConfigScope,
 	fromVersion atc.Version,
-	versionedResourceTypes creds.VersionedResourceTypes,
+	versionedResourceTypes atc.VersionedResourceTypes,
 	source atc.Source,
 	saveGiven bool,
 ) error {
@@ -253,7 +256,17 @@ func (scanner *resourceTypeScanner) check(
 
 	owner := db.NewResourceConfigCheckSessionContainerOwner(resourceConfigScope.ResourceConfig(), ContainerExpiries)
 
-	chosenWorker, err := scanner.pool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, scanner.strategy)
+	chosenWorker, err := scanner.pool.FindOrChooseWorkerForContainer(
+		context.Background(),
+		logger,
+		owner,
+		containerSpec,
+		db.ContainerMetadata{
+			Type: db.ContainerTypeCheck,
+		},
+		workerSpec,
+		scanner.strategy,
+	)
 	if err != nil {
 		chkErr := resourceConfigScope.SetCheckError(err)
 		if chkErr != nil {
@@ -268,9 +281,6 @@ func (scanner *resourceTypeScanner) check(
 		logger,
 		worker.NoopImageFetchingDelegate{},
 		db.NewResourceConfigCheckSessionContainerOwner(resourceConfigScope.ResourceConfig(), ContainerExpiries),
-		db.ContainerMetadata{
-			Type: db.ContainerTypeCheck,
-		},
 		containerSpec,
 		versionedResourceTypes.Without(savedResourceType.Name()),
 	)

atc/radar/resource_type_scanner_test.go

@@ -42,8 +42,8 @@ var _ = Describe("ResourceTypeScanner", func() {
 		interval                  time.Duration
 		variables                 creds.Variables
 
-		fakeResourceType      *dbfakes.FakeResourceType
+		fakeResourceType          *dbfakes.FakeResourceType
-		versionedResourceType atc.VersionedResourceType
+		interpolatedResourceTypes atc.VersionedResourceTypes
 
 		scanner Scanner
 
@@ -58,14 +58,16 @@ var _ = Describe("ResourceTypeScanner", func() {
 			"source-params": "some-secret-sauce",
 		}
 
-		versionedResourceType = atc.VersionedResourceType{
+		interpolatedResourceTypes = atc.VersionedResourceTypes{
-			ResourceType: atc.ResourceType{
+			{
-				Name:   "some-custom-resource",
+				ResourceType: atc.ResourceType{
-				Type:   "registry-image",
+					Name:   "some-custom-resource",
-				Source: atc.Source{"custom": "((source-params))"},
+					Type:   "registry-image",
-				Tags:   atc.Tags{"some-tag"},
+					Source: atc.Source{"custom": "some-secret-sauce"},
+					Tags:   atc.Tags{"some-tag"},
+				},
+				Version: atc.Version{"custom": "version"},
 			},
-			Version: atc.Version{"custom": "version"},
 		}
 
 		fakeClock = fakeclock.NewFakeClock(epoch)
@@ -180,36 +182,36 @@ var _ = Describe("ResourceTypeScanner", func() {
 
 				It("constructs the resource of the correct type", func() {
 					Expect(fakeResourceType.SetResourceConfigCallCount()).To(Equal(1))
-					_, resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
+					resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
 					Expect(resourceSource).To(Equal(atc.Source{"custom": "some-secret-sauce"}))
-					Expect(resourceTypes).To(Equal(creds.VersionedResourceTypes{}))
+					Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{}))
 
-					_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+					_, _, owner, containerSpec, metadata, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "registry-image",
 					}))
 					Expect(containerSpec.Tags).To(Equal([]string{"some-tag"}))
 					Expect(containerSpec.TeamID).To(Equal(123))
+					Expect(metadata).To(Equal(db.ContainerMetadata{
+						Type: db.ContainerTypeCheck,
+					}))
 					Expect(workerSpec).To(Equal(worker.WorkerSpec{
 						ResourceType:  "registry-image",
 						Tags:          []string{"some-tag"},
-						ResourceTypes: creds.VersionedResourceTypes{},
+						ResourceTypes: atc.VersionedResourceTypes{},
 						TeamID:        123,
 					}))
 
 					Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-					_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+					_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
 					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
-					Expect(metadata).To(Equal(db.ContainerMetadata{
-						Type: db.ContainerTypeCheck,
-					}))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "registry-image",
 					}))
 					Expect(containerSpec.Tags).To(Equal([]string{"some-tag"}))
 					Expect(containerSpec.TeamID).To(Equal(123))
-					Expect(resourceTypes).To(Equal(creds.VersionedResourceTypes{}))
+					Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{}))
 				})
 
 				Context("when the resource type overrides a base resource type", func() {
@@ -233,41 +235,37 @@ var _ = Describe("ResourceTypeScanner", func() {
 
 					It("constructs the resource of the correct type", func() {
 						Expect(fakeResourceType.SetResourceConfigCallCount()).To(Equal(1))
-						_, resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
+						resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
 						Expect(resourceSource).To(Equal(atc.Source{"custom": "some-secret-sauce"}))
-						Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+						Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-							versionedResourceType,
-						})))
 
 						Expect(fakeResourceType.SetCheckSetupErrorCallCount()).To(Equal(1))
 						err := fakeResourceType.SetCheckSetupErrorArgsForCall(0)
 						Expect(err).To(BeNil())
 
-						_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+						_, _, owner, containerSpec, metadata, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 						Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 						Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 							ResourceType: "registry-image",
 						}))
 						Expect(containerSpec.TeamID).To(Equal(123))
+						Expect(metadata).To(Equal(db.ContainerMetadata{
+							Type: db.ContainerTypeCheck,
+						}))
 						Expect(workerSpec).To(Equal(worker.WorkerSpec{
 							ResourceType:  "registry-image",
-							ResourceTypes: creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{versionedResourceType}),
+							ResourceTypes: interpolatedResourceTypes,
 							TeamID:        123,
 						}))
 
 						Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-						_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+						_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
 						Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
-						Expect(metadata).To(Equal(db.ContainerMetadata{
-							Type: db.ContainerTypeCheck,
-						}))
 						Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 							ResourceType: "registry-image",
 						}))
 						Expect(containerSpec.TeamID).To(Equal(123))
-						Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+						Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-							versionedResourceType,
-						})))
 					})
 				})
 
@@ -281,9 +279,6 @@ var _ = Describe("ResourceTypeScanner", func() {
 						Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 						Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-						_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-						Expect(leaseInterval).To(Equal(10 * time.Millisecond))
-
 						leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 						Expect(leaseInterval).To(Equal(10 * time.Millisecond))
 						Expect(immediate).To(BeFalse())
@@ -318,9 +313,6 @@ var _ = Describe("ResourceTypeScanner", func() {
 					Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 					Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-					_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-					Expect(leaseInterval).To(Equal(interval))
-
 					leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 					Expect(leaseInterval).To(Equal(interval))
 					Expect(immediate).To(BeFalse())
@@ -469,40 +461,40 @@ var _ = Describe("ResourceTypeScanner", func() {
 
 			It("constructs the resource of the correct type", func() {
 				Expect(fakeResourceType.SetResourceConfigCallCount()).To(Equal(1))
-				_, resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
+				resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
 				Expect(resourceSource).To(Equal(atc.Source{"custom": "some-secret-sauce"}))
-				Expect(resourceTypes).To(Equal(creds.VersionedResourceTypes{}))
+				Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{}))
 
 				Expect(fakeResourceType.SetCheckSetupErrorCallCount()).To(Equal(1))
 				err := fakeResourceType.SetCheckSetupErrorArgsForCall(0)
 				Expect(err).To(BeNil())
 
-				_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+				_, _, owner, containerSpec, metadata,  workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 				Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 				Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "registry-image",
 				}))
 				Expect(containerSpec.Tags).To(Equal([]string{"some-tag"}))
 				Expect(containerSpec.TeamID).To(Equal(123))
+				Expect(metadata).To(Equal(db.ContainerMetadata{
+					Type: db.ContainerTypeCheck,
+				}))
 				Expect(workerSpec).To(Equal(worker.WorkerSpec{
 					ResourceType:  "registry-image",
 					Tags:          []string{"some-tag"},
-					ResourceTypes: creds.VersionedResourceTypes{},
+					ResourceTypes: atc.VersionedResourceTypes{},
 					TeamID:        123,
 				}))
 
 				Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-				_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+				_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
 				Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
-				Expect(metadata).To(Equal(db.ContainerMetadata{
-					Type: db.ContainerTypeCheck,
-				}))
 				Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 					ResourceType: "registry-image",
 				}))
 				Expect(containerSpec.Tags).To(Equal([]string{"some-tag"}))
 				Expect(containerSpec.TeamID).To(Equal(123))
-				Expect(resourceTypes).To(Equal(creds.VersionedResourceTypes{}))
+				Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{}))
 			})
 
 			Context("when the resource type depends on another custom type", func() {
@@ -597,13 +589,11 @@ var _ = Describe("ResourceTypeScanner", func() {
 
 				It("constructs the resource of the correct type", func() {
 					Expect(fakeResourceType.SetResourceConfigCallCount()).To(Equal(1))
-					_, resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
+					resourceSource, resourceTypes := fakeResourceType.SetResourceConfigArgsForCall(0)
 					Expect(resourceSource).To(Equal(atc.Source{"custom": "some-secret-sauce"}))
-					Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-						versionedResourceType,
-					})))
 
-					_, owner, containerSpec, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
+					_, _,  owner, containerSpec, metadata, workerSpec, _ := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
 					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "registry-image",
@@ -611,23 +601,21 @@ var _ = Describe("ResourceTypeScanner", func() {
 					Expect(containerSpec.TeamID).To(Equal(123))
 					Expect(workerSpec).To(Equal(worker.WorkerSpec{
 						ResourceType:  "registry-image",
-						ResourceTypes: creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{versionedResourceType}),
+						ResourceTypes: interpolatedResourceTypes,
 						TeamID:        123,
 					}))
-
-					Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-					_, _, _, owner, metadata, containerSpec, resourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
-					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 					Expect(metadata).To(Equal(db.ContainerMetadata{
 						Type: db.ContainerTypeCheck,
 					}))
+
+					Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+					_, _, _, owner, containerSpec, resourceTypes = fakeWorker.FindOrCreateContainerArgsForCall(0)
+					Expect(owner).To(Equal(db.NewResourceConfigCheckSessionContainerOwner(fakeResourceConfig, ContainerExpiries)))
 					Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 						ResourceType: "registry-image",
 					}))
 					Expect(containerSpec.TeamID).To(Equal(123))
-					Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
-						versionedResourceType,
-					})))
 				})
 			})
 
@@ -635,9 +623,6 @@ var _ = Describe("ResourceTypeScanner", func() {
 				Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(1))
 				Expect(fakeResourceConfigScope.UpdateLastCheckStartTimeCallCount()).To(Equal(1))
 
-				_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-				Expect(leaseInterval).To(Equal(interval))
-
 				leaseInterval, immediate := fakeResourceConfigScope.UpdateLastCheckStartTimeArgsForCall(0)
 				Expect(leaseInterval).To(Equal(interval))
 				Expect(immediate).To(BeTrue())
@@ -776,7 +761,7 @@ var _ = Describe("ResourceTypeScanner", func() {
 					results <- true
 					close(results)
 
-					fakeResourceConfigScope.AcquireResourceCheckingLockStub = func(logger lager.Logger, interval time.Duration) (lock.Lock, bool, error) {
+					fakeResourceConfigScope.AcquireResourceCheckingLockStub = func(logger lager.Logger) (lock.Lock, bool, error) {
 						if <-results {
 							return fakeLock, true, nil
 						} else {
@@ -789,16 +774,6 @@ var _ = Describe("ResourceTypeScanner", func() {
 
 				It("retries every second until it is", func() {
 					Expect(fakeResourceConfigScope.AcquireResourceCheckingLockCallCount()).To(Equal(3))
-
-					_, leaseInterval := fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(0)
-					Expect(leaseInterval).To(Equal(interval))
-
-					_, leaseInterval = fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(1)
-					Expect(leaseInterval).To(Equal(interval))
-
-					_, leaseInterval = fakeResourceConfigScope.AcquireResourceCheckingLockArgsForCall(2)
-					Expect(leaseInterval).To(Equal(interval))
-
 					Expect(fakeLock.ReleaseCallCount()).To(Equal(1))
 				})
 			})

atc/resource/fetcher.go

@@ -8,7 +8,7 @@ import (
 
 	"code.cloudfoundry.org/clock"
 	"code.cloudfoundry.org/lager"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db/lock"
 	"github.com/concourse/concourse/atc/worker"
 )
@@ -27,7 +27,7 @@ type Fetcher interface {
 		session Session,
 		gardenWorker worker.Worker,
 		containerSpec worker.ContainerSpec,
-		resourceTypes creds.VersionedResourceTypes,
+		resourceTypes atc.VersionedResourceTypes,
 		resourceInstance ResourceInstance,
 		imageFetchingDelegate worker.ImageFetchingDelegate,
 	) (VersionedSource, error)
@@ -57,7 +57,7 @@ func (f *fetcher) Fetch(
 	session Session,
 	gardenWorker worker.Worker,
 	containerSpec worker.ContainerSpec,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 	resourceInstance ResourceInstance,
 	imageFetchingDelegate worker.ImageFetchingDelegate,
 ) (VersionedSource, error) {

atc/resource/fetcher_test.go

@@ -8,7 +8,7 @@ import (
 	"code.cloudfoundry.org/clock/fakeclock"
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db/lock"
 	"github.com/concourse/concourse/atc/db/lock/lockfakes"
 	"github.com/concourse/concourse/atc/resource"
@@ -67,7 +67,7 @@ var _ = Describe("Fetcher", func() {
 			worker.ContainerSpec{
 				TeamID: teamID,
 			},
-			creds.VersionedResourceTypes{},
+			atc.VersionedResourceTypes{},
 			new(resourcefakes.FakeResourceInstance),
 			fakeBuildStepDelegate,
 		)

atc/resource/resource_instance.go

@@ -7,7 +7,6 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/worker"
 )
@@ -34,7 +33,7 @@ type resourceInstance struct {
 	version          atc.Version
 	source           atc.Source
 	params           atc.Params
-	resourceTypes    creds.VersionedResourceTypes
+	resourceTypes    atc.VersionedResourceTypes
 
 	resourceCache  db.UsedResourceCache
 	containerOwner db.ContainerOwner
@@ -45,7 +44,7 @@ func NewResourceInstance(
 	version atc.Version,
 	source atc.Source,
 	params atc.Params,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 
 	resourceCache db.UsedResourceCache,
 	containerOwner db.ContainerOwner,

atc/resource/resource_instance_fetch_source.go

@@ -4,7 +4,7 @@ import (
 	"context"
 
 	"code.cloudfoundry.org/lager"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/worker"
 )
@@ -24,7 +24,7 @@ type FetchSourceFactory interface {
 		logger lager.Logger,
 		worker worker.Worker,
 		resourceInstance ResourceInstance,
-		resourceTypes creds.VersionedResourceTypes,
+		resourceTypes atc.VersionedResourceTypes,
 		containerSpec worker.ContainerSpec,
 		session Session,
 		imageFetchingDelegate worker.ImageFetchingDelegate,
@@ -50,7 +50,7 @@ func (r *fetchSourceFactory) NewFetchSource(
 	logger lager.Logger,
 	worker worker.Worker,
 	resourceInstance ResourceInstance,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 	containerSpec worker.ContainerSpec,
 	session Session,
 	imageFetchingDelegate worker.ImageFetchingDelegate,
@@ -72,7 +72,7 @@ type resourceInstanceFetchSource struct {
 	logger                 lager.Logger
 	worker                 worker.Worker
 	resourceInstance       ResourceInstance
-	resourceTypes          creds.VersionedResourceTypes
+	resourceTypes          atc.VersionedResourceTypes
 	containerSpec          worker.ContainerSpec
 	session                Session
 	imageFetchingDelegate  worker.ImageFetchingDelegate
@@ -130,12 +130,21 @@ func (s *resourceInstanceFetchSource) Create(ctx context.Context) (VersionedSour
 		&worker.CertsVolumeMount{Logger: s.logger},
 	}
 
+	err = s.worker.EnsureDBContainerExists(
+		ctx,
+		s.logger,
+		s.resourceInstance.ContainerOwner(),
+		s.session.Metadata,
+	)
+	if err != nil {
+		return nil, err
+	}
+
 	container, err := s.worker.FindOrCreateContainer(
 		ctx,
 		s.logger,
 		s.imageFetchingDelegate,
 		s.resourceInstance.ContainerOwner(),
-		s.session.Metadata,
 		s.containerSpec,
 		s.resourceTypes,
 	)

atc/resource/resource_instance_fetch_source_test.go

@@ -7,9 +7,7 @@ import (
 	"code.cloudfoundry.org/garden"
 	"code.cloudfoundry.org/garden/gardenfakes"
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	"github.com/concourse/concourse/atc/resource"
@@ -33,7 +31,8 @@ var _ = Describe("ResourceInstanceFetchSource", func() {
 		fakeResourceCacheFactory *dbfakes.FakeResourceCacheFactory
 		fakeUsedResourceCache    *dbfakes.FakeUsedResourceCache
 		fakeDelegate             *workerfakes.FakeImageFetchingDelegate
-		resourceTypes            creds.VersionedResourceTypes
+		resourceTypes            atc.VersionedResourceTypes
+		metadata                 db.ContainerMetadata
 
 		ctx    context.Context
 		cancel func()
@@ -88,23 +87,20 @@ var _ = Describe("ResourceInstanceFetchSource", func() {
 
 		fakeDelegate = new(workerfakes.FakeImageFetchingDelegate)
 
-		variables := template.StaticVariables{
+		resourceTypes = atc.VersionedResourceTypes{
-			"secret-custom": "source",
-		}
-
-		resourceTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
 			{
 				ResourceType: atc.ResourceType{
 					Name:   "custom-resource",
 					Type:   "custom-type",
-					Source: atc.Source{"some-custom": "((secret-custom))"},
+					Source: atc.Source{"some-custom": "source"},
 				},
 				Version: atc.Version{"some-custom": "version"},
 			},
-		})
+		}
 
 		resourceFactory := resource.NewResourceFactory()
 		fetchSourceFactory = resource.NewFetchSourceFactory(fakeResourceCacheFactory, resourceFactory)
+		metadata = db.ContainerMetadata{Type: db.ContainerTypeGet}
 		fetchSource = fetchSourceFactory.NewFetchSource(
 			logger,
 			fakeWorker,
@@ -120,7 +116,9 @@ var _ = Describe("ResourceInstanceFetchSource", func() {
 					"resource": resource.ResourcesDir("get"),
 				},
 			},
-			resource.Session{},
+			resource.Session{
+				Metadata: metadata,
+			},
 			fakeDelegate,
 		)
 	})
@@ -204,11 +202,15 @@ var _ = Describe("ResourceInstanceFetchSource", func() {
 
 			It("creates container with volume and worker", func() {
 				Expect(initErr).NotTo(HaveOccurred())
+				Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
+				_, _, owner, actualMetadata := fakeWorker.EnsureDBContainerExistsArgsForCall(0)
+				Expect(owner).To(Equal(db.NewBuildStepContainerOwner(43, atc.PlanID("some-plan-id"), 42)))
+				Expect(actualMetadata).To(Equal(metadata))
+
 				Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
-				_, logger, delegate, owner, metadata, containerSpec, types := fakeWorker.FindOrCreateContainerArgsForCall(0)
+				_, logger, delegate, owner, containerSpec, types := fakeWorker.FindOrCreateContainerArgsForCall(0)
 				Expect(delegate).To(Equal(fakeDelegate))
 				Expect(owner).To(Equal(db.NewBuildStepContainerOwner(43, atc.PlanID("some-plan-id"), 42)))
-				Expect(metadata).To(BeZero())
 				Expect(containerSpec).To(Equal(worker.ContainerSpec{
 					TeamID: 42,
 					Tags:   []string{},

atc/resource/resource_instance_test.go

@@ -6,7 +6,6 @@ import (
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	. "github.com/concourse/concourse/atc/resource"
@@ -36,7 +35,7 @@ var _ = Describe("ResourceInstance", func() {
 			atc.Version{"some": "version"},
 			atc.Source{"some": "source"},
 			atc.Params{"some": "params"},
-			creds.VersionedResourceTypes{},
+			atc.VersionedResourceTypes{},
 			fakeResourceCache,
 			db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1),
 		)

atc/resource/resourcefakes/fake_fetch_source_factory.go

@@ -5,19 +5,19 @@ import (
 	"sync"
 
 	"code.cloudfoundry.org/lager"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/resource"
 	"github.com/concourse/concourse/atc/worker"
 )
 
 type FakeFetchSourceFactory struct {
-	NewFetchSourceStub        func(lager.Logger, worker.Worker, resource.ResourceInstance, creds.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) resource.FetchSource
+	NewFetchSourceStub        func(lager.Logger, worker.Worker, resource.ResourceInstance, atc.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) resource.FetchSource
 	newFetchSourceMutex       sync.RWMutex
 	newFetchSourceArgsForCall []struct {
 		arg1 lager.Logger
 		arg2 worker.Worker
 		arg3 resource.ResourceInstance
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.VersionedResourceTypes
 		arg5 worker.ContainerSpec
 		arg6 resource.Session
 		arg7 worker.ImageFetchingDelegate
@@ -32,14 +32,14 @@ type FakeFetchSourceFactory struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeFetchSourceFactory) NewFetchSource(arg1 lager.Logger, arg2 worker.Worker, arg3 resource.ResourceInstance, arg4 creds.VersionedResourceTypes, arg5 worker.ContainerSpec, arg6 resource.Session, arg7 worker.ImageFetchingDelegate) resource.FetchSource {
+func (fake *FakeFetchSourceFactory) NewFetchSource(arg1 lager.Logger, arg2 worker.Worker, arg3 resource.ResourceInstance, arg4 atc.VersionedResourceTypes, arg5 worker.ContainerSpec, arg6 resource.Session, arg7 worker.ImageFetchingDelegate) resource.FetchSource {
 	fake.newFetchSourceMutex.Lock()
 	ret, specificReturn := fake.newFetchSourceReturnsOnCall[len(fake.newFetchSourceArgsForCall)]
 	fake.newFetchSourceArgsForCall = append(fake.newFetchSourceArgsForCall, struct {
 		arg1 lager.Logger
 		arg2 worker.Worker
 		arg3 resource.ResourceInstance
-		arg4 creds.VersionedResourceTypes
+		arg4 atc.VersionedResourceTypes
 		arg5 worker.ContainerSpec
 		arg6 resource.Session
 		arg7 worker.ImageFetchingDelegate
@@ -62,13 +62,13 @@ func (fake *FakeFetchSourceFactory) NewFetchSourceCallCount() int {
 	return len(fake.newFetchSourceArgsForCall)
 }
 
-func (fake *FakeFetchSourceFactory) NewFetchSourceCalls(stub func(lager.Logger, worker.Worker, resource.ResourceInstance, creds.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) resource.FetchSource) {
+func (fake *FakeFetchSourceFactory) NewFetchSourceCalls(stub func(lager.Logger, worker.Worker, resource.ResourceInstance, atc.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) resource.FetchSource) {
 	fake.newFetchSourceMutex.Lock()
 	defer fake.newFetchSourceMutex.Unlock()
 	fake.NewFetchSourceStub = stub
 }
 
-func (fake *FakeFetchSourceFactory) NewFetchSourceArgsForCall(i int) (lager.Logger, worker.Worker, resource.ResourceInstance, creds.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) {
+func (fake *FakeFetchSourceFactory) NewFetchSourceArgsForCall(i int) (lager.Logger, worker.Worker, resource.ResourceInstance, atc.VersionedResourceTypes, worker.ContainerSpec, resource.Session, worker.ImageFetchingDelegate) {
 	fake.newFetchSourceMutex.RLock()
 	defer fake.newFetchSourceMutex.RUnlock()
 	argsForCall := fake.newFetchSourceArgsForCall[i]

atc/resource/resourcefakes/fake_fetcher.go

@@ -6,13 +6,13 @@ import (
 	"sync"
 
 	"code.cloudfoundry.org/lager"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc"
 	"github.com/concourse/concourse/atc/resource"
 	"github.com/concourse/concourse/atc/worker"
 )
 
 type FakeFetcher struct {
-	FetchStub        func(context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, creds.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) (resource.VersionedSource, error)
+	FetchStub        func(context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, atc.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) (resource.VersionedSource, error)
 	fetchMutex       sync.RWMutex
 	fetchArgsForCall []struct {
 		arg1 context.Context
@@ -20,7 +20,7 @@ type FakeFetcher struct {
 		arg3 resource.Session
 		arg4 worker.Worker
 		arg5 worker.ContainerSpec
-		arg6 creds.VersionedResourceTypes
+		arg6 atc.VersionedResourceTypes
 		arg7 resource.ResourceInstance
 		arg8 worker.ImageFetchingDelegate
 	}
@@ -36,7 +36,7 @@ type FakeFetcher struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeFetcher) Fetch(arg1 context.Context, arg2 lager.Logger, arg3 resource.Session, arg4 worker.Worker, arg5 worker.ContainerSpec, arg6 creds.VersionedResourceTypes, arg7 resource.ResourceInstance, arg8 worker.ImageFetchingDelegate) (resource.VersionedSource, error) {
+func (fake *FakeFetcher) Fetch(arg1 context.Context, arg2 lager.Logger, arg3 resource.Session, arg4 worker.Worker, arg5 worker.ContainerSpec, arg6 atc.VersionedResourceTypes, arg7 resource.ResourceInstance, arg8 worker.ImageFetchingDelegate) (resource.VersionedSource, error) {
 	fake.fetchMutex.Lock()
 	ret, specificReturn := fake.fetchReturnsOnCall[len(fake.fetchArgsForCall)]
 	fake.fetchArgsForCall = append(fake.fetchArgsForCall, struct {
@@ -45,7 +45,7 @@ func (fake *FakeFetcher) Fetch(arg1 context.Context, arg2 lager.Logger, arg3 res
 		arg3 resource.Session
 		arg4 worker.Worker
 		arg5 worker.ContainerSpec
-		arg6 creds.VersionedResourceTypes
+		arg6 atc.VersionedResourceTypes
 		arg7 resource.ResourceInstance
 		arg8 worker.ImageFetchingDelegate
 	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8})
@@ -67,13 +67,13 @@ func (fake *FakeFetcher) FetchCallCount() int {
 	return len(fake.fetchArgsForCall)
 }
 
-func (fake *FakeFetcher) FetchCalls(stub func(context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, creds.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) (resource.VersionedSource, error)) {
+func (fake *FakeFetcher) FetchCalls(stub func(context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, atc.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) (resource.VersionedSource, error)) {
 	fake.fetchMutex.Lock()
 	defer fake.fetchMutex.Unlock()
 	fake.FetchStub = stub
 }
 
-func (fake *FakeFetcher) FetchArgsForCall(i int) (context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, creds.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) {
+func (fake *FakeFetcher) FetchArgsForCall(i int) (context.Context, lager.Logger, resource.Session, worker.Worker, worker.ContainerSpec, atc.VersionedResourceTypes, resource.ResourceInstance, worker.ImageFetchingDelegate) {
 	fake.fetchMutex.RLock()
 	defer fake.fetchMutex.RUnlock()
 	argsForCall := fake.fetchArgsForCall[i]

atc/scheduler/buildstarter.go

@@ -80,6 +80,16 @@ func (s *buildStarter) tryStartNextPendingBuild(
 		"build-name": nextPendingBuild.Name(),
 	})
 
+	if nextPendingBuild.IsAborted() {
+		logger.Debug("cancel-aborted-pending-build")
+		err := nextPendingBuild.Finish(db.BuildStatusAborted)
+		if err != nil {
+			return false, err
+		}
+
+		return true, nil
+	}
+
 	reachedMaxInFlight, err := s.maxInFlightUpdater.UpdateMaxInFlightReached(logger, job, nextPendingBuild.ID())
 	if err != nil {
 		return false, err

atc/scheduler/buildstarter_test.go

@@ -69,6 +69,48 @@ var _ = Describe("BuildStarter", func() {
 			resource.NameReturns("some-resource")
 		})
 
+		Context("when one pending build is aborted before start", func() {
+			var abortedBuild *dbfakes.FakeBuild
+
+			BeforeEach(func() {
+				job = new(dbfakes.FakeJob)
+				job.NameReturns("some-job")
+				job.ConfigReturns(atc.JobConfig{Plan: atc.PlanSequence{{Get: "input-1", Resource: "some-resource"}, {Get: "input-2", Resource: "some-resource"}}})
+
+				abortedBuild = new(dbfakes.FakeBuild)
+				abortedBuild.IDReturns(42)
+				abortedBuild.IsAbortedReturns(true)
+
+				// make sure pending build can be started after another pending build is aborted
+				pendingBuilds = append([]db.Build{abortedBuild}, pendingBuilds...)
+				resources = db.Resources{resource}
+			})
+
+			JustBeforeEach(func() {
+				tryStartErr = buildStarter.TryStartPendingBuildsForJob(
+					lagertest.NewTestLogger("test"),
+					job,
+					resources,
+					versionedResourceTypes,
+					pendingBuilds,
+				)
+			})
+
+			It("won't try to start the aborted pending build", func() {
+				Expect(abortedBuild.FinishCallCount()).To(Equal(1))
+			})
+
+			It("will try to start the next non aborted pending build", func() {
+				Expect(fakeUpdater.UpdateMaxInFlightReachedCallCount()).To(Equal(1))
+				_, _, buildID := fakeUpdater.UpdateMaxInFlightReachedArgsForCall(0)
+				Expect(buildID).To(Equal(66))
+			})
+
+			It("returns without error", func() {
+				Expect(tryStartErr).NotTo(HaveOccurred())
+			})
+		})
+
 		Context("when manually triggered", func() {
 			BeforeEach(func() {
 				job = new(dbfakes.FakeJob)
@@ -274,7 +316,6 @@ var _ = Describe("BuildStarter", func() {
 									}}))
 								})
 							})
-
 						})
 					})
 				})

atc/worker/container_spec.go

@@ -6,7 +6,6 @@ import (
 
 	"code.cloudfoundry.org/garden"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 )
 
 type WorkerSpec struct {
@@ -14,7 +13,7 @@ type WorkerSpec struct {
 	ResourceType  string
 	Tags          []string
 	TeamID        int
-	ResourceTypes creds.VersionedResourceTypes
+	ResourceTypes atc.VersionedResourceTypes
 }
 
 type ContainerSpec struct {
@@ -71,7 +70,7 @@ type ImageSpec struct {
 
 type ImageResource struct {
 	Type    string
-	Source  creds.Source
+	Source  atc.Source
 	Params  *atc.Params
 	Version *atc.Version
 }

atc/worker/db_worker_provider_test.go

@@ -424,7 +424,14 @@ var _ = Describe("DBProvider", func() {
 
 					By("connecting to the worker")
 					fakeDBWorkerFactory.GetWorkerReturns(fakeWorker1, true, nil)
-					container, err := workers[0].FindOrCreateContainer(context.TODO(), logger, fakeImageFetchingDelegate, db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1), db.ContainerMetadata{}, containerSpec, nil)
+					container, err := workers[0].FindOrCreateContainer(
+						context.TODO(),
+						logger,
+						fakeImageFetchingDelegate,
+						db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1),
+						containerSpec,
+						nil,
+					)
 					Expect(err).NotTo(HaveOccurred())
 
 					err = container.Destroy()
@@ -463,6 +470,7 @@ var _ = Describe("DBProvider", func() {
 					fakeCreatedContainer = new(dbfakes.FakeCreatedContainer)
 					fakeCreatingContainer.CreatedReturns(fakeCreatedContainer, nil)
 					fakeWorker1.CreateContainerReturns(fakeCreatingContainer, nil)
+					fakeWorker1.FindContainerReturns(fakeCreatingContainer, nil, nil)
 
 					workerBaseResourceType := &db.UsedWorkerBaseResourceType{ID: 42}
 					fakeDBWorkerBaseResourceTypeFactory.FindReturns(workerBaseResourceType, true, nil)
@@ -481,7 +489,22 @@ var _ = Describe("DBProvider", func() {
 					fakeGardenBackend.CreateReturns(fakeContainer, nil)
 					fakeGardenBackend.LookupReturns(fakeContainer, nil)
 
-					container, err := workers[0].FindOrCreateContainer(context.TODO(), logger, fakeImageFetchingDelegate, db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1), db.ContainerMetadata{}, containerSpec, nil)
+					err := workers[0].EnsureDBContainerExists(
+						context.TODO(),
+						logger,
+						db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1),
+						db.ContainerMetadata{},
+					)
+					Expect(err).NotTo(HaveOccurred())
+
+					container, err := workers[0].FindOrCreateContainer(
+						context.TODO(),
+						logger,
+						fakeImageFetchingDelegate,
+						db.NewBuildStepContainerOwner(42, atc.PlanID("some-plan-id"), 1),
+						containerSpec,
+						nil,
+					)
 					Expect(err).NotTo(HaveOccurred())
 
 					Expect(container.Handle()).To(Equal("created-handle"))

atc/worker/image/image_factory.go

@@ -5,7 +5,6 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/worker"
 	w "github.com/concourse/concourse/atc/worker"
 )
@@ -31,7 +30,7 @@ func (f *imageFactory) GetImage(
 	imageSpec worker.ImageSpec,
 	teamID int,
 	delegate worker.ImageFetchingDelegate,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 ) (worker.Image, error) {
 	if imageSpec.ImageArtifactSource != nil {
 		artifactVolume, existsOnWorker, err := imageSpec.ImageArtifactSource.VolumeOn(logger, worker)

atc/worker/image/image_resource_fetcher.go

@@ -10,7 +10,6 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/resource"
 	"github.com/concourse/concourse/atc/worker"
@@ -32,7 +31,7 @@ type ImageResourceFetcherFactory interface {
 		worker.ImageResource,
 		atc.Version,
 		int,
-		creds.VersionedResourceTypes,
+		atc.VersionedResourceTypes,
 		worker.ImageFetchingDelegate,
 	) ImageResourceFetcher
 }
@@ -74,7 +73,7 @@ func (f *imageResourceFetcherFactory) NewImageResourceFetcher(
 	imageResource worker.ImageResource,
 	version atc.Version,
 	teamID int,
-	customTypes creds.VersionedResourceTypes,
+	customTypes atc.VersionedResourceTypes,
 	imageFetchingDelegate worker.ImageFetchingDelegate,
 ) ImageResourceFetcher {
 	return &imageResourceFetcher{
@@ -102,7 +101,7 @@ type imageResourceFetcher struct {
 	imageResource         worker.ImageResource
 	version               atc.Version
 	teamID                int
-	customTypes           creds.VersionedResourceTypes
+	customTypes           atc.VersionedResourceTypes
 	imageFetchingDelegate worker.ImageFetchingDelegate
 }
 
@@ -122,22 +121,16 @@ func (i *imageResourceFetcher) Fetch(
 		}
 	}
 
-	source, err := i.imageResource.Source.Evaluate()
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	var params atc.Params
 	if i.imageResource.Params != nil {
 		params = *i.imageResource.Params
 	}
 
 	resourceCache, err := i.dbResourceCacheFactory.FindOrCreateResourceCache(
-		logger,
 		db.ForContainer(container.ID()),
 		i.imageResource.Type,
 		version,
-		source,
+		i.imageResource.Source,
 		params,
 		i.customTypes,
 	)
@@ -149,7 +142,7 @@ func (i *imageResourceFetcher) Fetch(
 	resourceInstance := resource.NewResourceInstance(
 		resource.ResourceType(i.imageResource.Type),
 		version,
-		source,
+		i.imageResource.Source,
 		params,
 		i.customTypes,
 		resourceCache,
@@ -225,7 +218,7 @@ func (i *imageResourceFetcher) ensureVersionOfType(
 	ctx context.Context,
 	logger lager.Logger,
 	container db.CreatingContainer,
-	resourceType creds.VersionedResourceType,
+	resourceType atc.VersionedResourceType,
 ) error {
 	containerSpec := worker.ContainerSpec{
 		ImageSpec: worker.ImageSpec{
@@ -237,14 +230,24 @@ func (i *imageResourceFetcher) ensureVersionOfType(
 		},
 	}
 
+	owner := db.NewImageCheckContainerOwner(container, i.teamID)
+	err := i.worker.EnsureDBContainerExists(
+		ctx,
+		logger,
+		owner,
+		db.ContainerMetadata{
+			Type: db.ContainerTypeCheck,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
 	resourceTypeContainer, err := i.worker.FindOrCreateContainer(
 		ctx,
 		logger,
 		worker.NoopImageFetchingDelegate{},
-		db.NewImageCheckContainerOwner(container, i.teamID),
+		owner,
-		db.ContainerMetadata{
-			Type: db.ContainerTypeCheck,
-		},
 		containerSpec,
 		i.customTypes,
 	)
@@ -252,13 +255,8 @@ func (i *imageResourceFetcher) ensureVersionOfType(
 		return err
 	}
 
-	source, err := resourceType.Source.Evaluate()
-	if err != nil {
-		return err
-	}
-
 	checkResourceType := i.resourceFactory.NewResourceForContainer(resourceTypeContainer)
-	versions, err := checkResourceType.Check(context.TODO(), source, nil)
+	versions, err := checkResourceType.Check(context.TODO(), resourceType.Source, nil)
 	if err != nil {
 		return err
 	}
@@ -298,7 +296,15 @@ func (i *imageResourceFetcher) getLatestVersion(
 		},
 	}
 
-	source, err := i.imageResource.Source.Evaluate()
+	owner := db.NewImageCheckContainerOwner(container, i.teamID)
+	err := i.worker.EnsureDBContainerExists(
+		ctx,
+		logger,
+		owner,
+		db.ContainerMetadata{
+			Type: db.ContainerTypeCheck,
+		},
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -307,10 +313,7 @@ func (i *imageResourceFetcher) getLatestVersion(
 		ctx,
 		logger,
 		i.imageFetchingDelegate,
-		db.NewImageCheckContainerOwner(container, i.teamID),
+		owner,
-		db.ContainerMetadata{
-			Type: db.ContainerTypeCheck,
-		},
 		resourceSpec,
 		i.customTypes,
 	)
@@ -319,7 +322,7 @@ func (i *imageResourceFetcher) getLatestVersion(
 	}
 
 	checkingResource := i.resourceFactory.NewResourceForContainer(imageContainer)
-	versions, err := checkingResource.Check(context.TODO(), source, nil)
+	versions, err := checkingResource.Check(context.TODO(), i.imageResource.Source, nil)
 	if err != nil {
 		return nil, err
 	}

atc/worker/image/image_resource_fetcher_test.go

@@ -12,9 +12,7 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	"github.com/concourse/concourse/atc/resource"
@@ -46,7 +44,7 @@ var _ = Describe("Image", func() {
 	var fakeImageFetchingDelegate *workerfakes.FakeImageFetchingDelegate
 	var fakeWorker *workerfakes.FakeWorker
 
-	var customTypes creds.VersionedResourceTypes
+	var customTypes atc.VersionedResourceTypes
 	var privileged bool
 
 	var fetchedVolume worker.Volume
@@ -54,7 +52,6 @@ var _ = Describe("Image", func() {
 	var fetchedVersion atc.Version
 	var fetchErr error
 	var teamID int
-	var variables template.StaticVariables
 
 	BeforeEach(func() {
 		fakeResourceFactory = new(resourcefakes.FakeResourceFactory)
@@ -63,16 +60,10 @@ var _ = Describe("Image", func() {
 		fakeCreatingContainer = new(dbfakes.FakeCreatingContainer)
 		stderrBuf = gbytes.NewBuffer()
 
-		variables = template.StaticVariables{
-			"source-param":   "super-secret-sauce",
-			"a-source-param": "super-secret-a-source",
-			"b-source-param": "super-secret-b-source",
-		}
-
 		logger = lagertest.NewTestLogger("test")
 		imageResource = worker.ImageResource{
 			Type:   "docker",
-			Source: creds.NewSource(variables, atc.Source{"some": "((source-param))"}),
+			Source: atc.Source{"some": "super-secret-sauce"},
 			Params: &atc.Params{"some": "params"},
 		}
 		version = nil
@@ -84,12 +75,12 @@ var _ = Describe("Image", func() {
 		fakeWorker.TagsReturns(atc.Tags{"worker", "tags"})
 		teamID = 123
 
-		customTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+		customTypes = atc.VersionedResourceTypes{
 			{
 				ResourceType: atc.ResourceType{
 					Name:   "custom-type-a",
 					Type:   "base-type",
-					Source: atc.Source{"some": "((a-source-param))"},
+					Source: atc.Source{"some": "a-source-param"},
 				},
 				Version: atc.Version{"some": "a-version"},
 			},
@@ -97,11 +88,11 @@ var _ = Describe("Image", func() {
 				ResourceType: atc.ResourceType{
 					Name:   "custom-type-b",
 					Type:   "custom-type-a",
-					Source: atc.Source{"some": "((b-source-param))"},
+					Source: atc.Source{"some": "b-source-param"},
 				},
 				Version: atc.Version{"some": "b-version"},
 			},
-		})
+		}
 
 		fakeResourceCacheFactory = new(dbfakes.FakeResourceCacheFactory)
 	})
@@ -158,7 +149,7 @@ var _ = Describe("Image", func() {
 				BeforeEach(func() {
 					imageResource = worker.ImageResource{
 						Type:   customResourceTypeName,
-						Source: creds.NewSource(variables, atc.Source{"some": "((source-param))"}),
+						Source: atc.Source{"some": "source-param"},
 						Params: &atc.Params{"some": "params"},
 					}
 
@@ -172,7 +163,7 @@ var _ = Describe("Image", func() {
 
 				Context("and the custom type does not have a version", func() {
 					BeforeEach(func() {
-						customTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+						customTypes = atc.VersionedResourceTypes{
 							{
 								ResourceType: atc.ResourceType{
 									Name:   "custom-type-a",
@@ -181,7 +172,7 @@ var _ = Describe("Image", func() {
 								},
 								Version: nil,
 							},
-						})
+						}
 
 						fakeCheckResourceType = new(resourcefakes.FakeResource)
 						fakeWorker.FindOrCreateContainerReturns(fakeContainer, nil)
@@ -192,7 +183,7 @@ var _ = Describe("Image", func() {
 
 					It("checks for the latest version of the resource type", func() {
 						By("find or create a resource container")
-						_, _, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
+						_, _, _, _, containerSpec, _ := fakeWorker.FindOrCreateContainerArgsForCall(0)
 						Expect(containerSpec.ImageSpec.ResourceType).To(Equal("custom-type-a"))
 
 						By("calling the resource type's check script")
@@ -205,8 +196,9 @@ var _ = Describe("Image", func() {
 						})
 
 						It("uses the version of the custom type when checking for the original resource", func() {
+							Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(2))
 							Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(2))
-							_, _, _, _, _, containerSpec, customTypes := fakeWorker.FindOrCreateContainerArgsForCall(1)
+							_, _, _, _, containerSpec, customTypes := fakeWorker.FindOrCreateContainerArgsForCall(1)
 							Expect(containerSpec.ImageSpec.ResourceType).To(Equal("custom-type-a"))
 							Expect(customTypes[0].Version).To(Equal(atc.Version{"some": "version"}))
 						})
@@ -277,13 +269,17 @@ var _ = Describe("Image", func() {
 								})
 
 								It("created the 'check' resource with the correct session, with the currently fetching type removed from the set", func() {
-									Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+									Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
-									cctx, _, delegate, owner, metadata, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+									_, _, owner, metadata := fakeWorker.EnsureDBContainerExistsArgsForCall(0)
-									Expect(cctx).To(Equal(ctx))
-									Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
 									Expect(metadata).To(Equal(db.ContainerMetadata{
 										Type: db.ContainerTypeCheck,
 									}))
+									Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
+
+									Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+									cctx, _, delegate, owner, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+									Expect(cctx).To(Equal(ctx))
+									Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
 									Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 										ResourceType: "docker",
 									}))
@@ -318,13 +314,17 @@ var _ = Describe("Image", func() {
 							})
 
 							It("created the 'check' resource with the correct session, with the currently fetching type removed from the set", func() {
-								Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+								Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
-								cctx, _, delegate, owner, metadata, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+								_, _, owner, metadata := fakeWorker.EnsureDBContainerExistsArgsForCall(0)
-								Expect(cctx).To(Equal(ctx))
-								Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
 								Expect(metadata).To(Equal(db.ContainerMetadata{
 									Type: db.ContainerTypeCheck,
 								}))
+								Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
+
+								Expect(fakeWorker.FindOrCreateContainerCallCount()).To(Equal(1))
+								cctx, _, delegate, owner, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
+								Expect(cctx).To(Equal(ctx))
+								Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
 								Expect(containerSpec.ImageSpec).To(Equal(worker.ImageSpec{
 									ResourceType: "docker",
 								}))
@@ -537,6 +537,7 @@ var _ = Describe("Image", func() {
 					})
 
 					It("does not construct a new resource for checking", func() {
+						Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(BeZero())
 						Expect(fakeWorker.FindOrCreateContainerCallCount()).To(BeZero())
 						Expect(fakeResourceFactory.NewResourceForContainerCallCount()).To(BeZero())
 					})

atc/worker/image/image_test.go

@@ -6,11 +6,9 @@ import (
 	"strings"
 
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/baggageclaim"
 	"github.com/concourse/baggageclaim/baggageclaimfakes"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db/dbfakes"
 	"github.com/concourse/concourse/atc/worker"
 	"github.com/concourse/concourse/atc/worker/image"
@@ -32,7 +30,6 @@ var _ = Describe("Image", func() {
 		fakeImageFetchingDelegate       *workerfakes.FakeImageFetchingDelegate
 		fakeImageResourceFetcherFactory *imagefakes.FakeImageResourceFetcherFactory
 		fakeImageResourceFetcher        *imagefakes.FakeImageResourceFetcher
-		variables                       creds.Variables
 	)
 
 	BeforeEach(func() {
@@ -49,10 +46,6 @@ var _ = Describe("Image", func() {
 		fakeImageResourceFetcher = new(imagefakes.FakeImageResourceFetcher)
 		fakeImageResourceFetcherFactory.NewImageResourceFetcherReturns(fakeImageResourceFetcher)
 		imageFactory = image.NewImageFactory(fakeImageResourceFetcherFactory)
-
-		variables = template.StaticVariables{
-			"source-secret": "super-secret-sauce",
-		}
 	})
 
 	Describe("imageProvidedByPreviousStepOnSameWorker", func() {
@@ -88,7 +81,7 @@ var _ = Describe("Image", func() {
 				},
 				42,
 				fakeImageFetchingDelegate,
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).NotTo(HaveOccurred())
 		})
@@ -154,7 +147,7 @@ var _ = Describe("Image", func() {
 				},
 				42,
 				fakeImageFetchingDelegate,
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).NotTo(HaveOccurred())
 		})
@@ -237,13 +230,13 @@ var _ = Describe("Image", func() {
 					worker.ImageSpec{
 						ImageResource: &worker.ImageResource{
 							Type:   "some-image-resource-type",
-							Source: creds.NewSource(variables, atc.Source{"some": "source"}),
+							Source: atc.Source{"some": "source"},
 						},
 						Privileged: true,
 					},
 					42,
 					fakeImageFetchingDelegate,
-					creds.VersionedResourceTypes{},
+					atc.VersionedResourceTypes{},
 				)
 				Expect(err).NotTo(HaveOccurred())
 			})
@@ -252,10 +245,10 @@ var _ = Describe("Image", func() {
 				worker, imageResource, version, teamID, resourceTypes, delegate := fakeImageResourceFetcherFactory.NewImageResourceFetcherArgsForCall(0)
 				Expect(worker).To(Equal(fakeWorker))
 				Expect(imageResource.Type).To(Equal("some-image-resource-type"))
-				Expect(imageResource.Source).To(Equal(creds.NewSource(variables, atc.Source{"some": "source"})))
+				Expect(imageResource.Source).To(Equal(atc.Source{"some": "source"}))
 				Expect(version).To(BeNil())
 				Expect(teamID).To(Equal(42))
-				Expect(resourceTypes).To(Equal(creds.VersionedResourceTypes{}))
+				Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{}))
 				Expect(delegate).To(Equal(fakeImageFetchingDelegate))
 			})
 
@@ -302,7 +295,7 @@ var _ = Describe("Image", func() {
 					},
 					42,
 					fakeImageFetchingDelegate,
-					creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					atc.VersionedResourceTypes{
 						{
 							ResourceType: atc.ResourceType{
 								Name: "some-custom-resource-type",
@@ -324,7 +317,7 @@ var _ = Describe("Image", func() {
 							},
 							Version: atc.Version{"some": "custom-image-resource-type-version"},
 						},
-					}),
+					},
 				)
 				Expect(err).NotTo(HaveOccurred())
 			})
@@ -333,12 +326,12 @@ var _ = Describe("Image", func() {
 				worker, imageResource, version, teamID, resourceTypes, delegate := fakeImageResourceFetcherFactory.NewImageResourceFetcherArgsForCall(0)
 				Expect(worker).To(Equal(fakeWorker))
 				Expect(imageResource.Type).To(Equal("some-base-resource-type"))
-				Expect(imageResource.Source).To(Equal(creds.NewSource(variables, atc.Source{
+				Expect(imageResource.Source).To(Equal(atc.Source{
 					"some": "custom-resource-type-source",
-				})))
+				}))
 				Expect(version).To(Equal(atc.Version{"some": "custom-resource-type-version"}))
 				Expect(teamID).To(Equal(42))
-				Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+				Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{
 					{
 						ResourceType: atc.ResourceType{
 							Name: "some-custom-image-resource-type",
@@ -350,7 +343,7 @@ var _ = Describe("Image", func() {
 						},
 						Version: atc.Version{"some": "custom-image-resource-type-version"},
 					},
-				})))
+				}))
 				Expect(delegate).To(Equal(fakeImageFetchingDelegate))
 			})
 
@@ -397,7 +390,7 @@ var _ = Describe("Image", func() {
 					},
 					42,
 					fakeImageFetchingDelegate,
-					creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+					atc.VersionedResourceTypes{
 						{
 							ResourceType: atc.ResourceType{
 								Name: "some-custom-resource-type",
@@ -419,7 +412,7 @@ var _ = Describe("Image", func() {
 							},
 							Version: atc.Version{"some": "custom-image-resource-type-version"},
 						},
-					}),
+					},
 				)
 				Expect(err).NotTo(HaveOccurred())
 			})
@@ -428,12 +421,12 @@ var _ = Describe("Image", func() {
 				worker, imageResource, version, teamID, resourceTypes, delegate := fakeImageResourceFetcherFactory.NewImageResourceFetcherArgsForCall(0)
 				Expect(worker).To(Equal(fakeWorker))
 				Expect(imageResource.Type).To(Equal("some-base-image-resource-type"))
-				Expect(imageResource.Source).To(Equal(creds.NewSource(variables, atc.Source{
+				Expect(imageResource.Source).To(Equal(atc.Source{
 					"some": "custom-image-resource-type-source",
-				})))
+				}))
 				Expect(version).To(Equal(atc.Version{"some": "custom-image-resource-type-version"}))
 				Expect(teamID).To(Equal(42))
-				Expect(resourceTypes).To(Equal(creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
+				Expect(resourceTypes).To(Equal(atc.VersionedResourceTypes{
 					{
 						ResourceType: atc.ResourceType{
 							Name: "some-custom-resource-type",
@@ -444,7 +437,7 @@ var _ = Describe("Image", func() {
 						},
 						Version: atc.Version{"some": "custom-resource-type-version"},
 					},
-				})))
+				}))
 				Expect(delegate).To(Equal(fakeImageFetchingDelegate))
 			})
 
@@ -519,7 +512,7 @@ var _ = Describe("Image", func() {
 				},
 				42,
 				fakeImageFetchingDelegate,
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).NotTo(HaveOccurred())
 		})
@@ -628,7 +621,7 @@ var _ = Describe("Image", func() {
 				},
 				42,
 				fakeImageFetchingDelegate,
-				creds.VersionedResourceTypes{},
+				atc.VersionedResourceTypes{},
 			)
 			Expect(err).NotTo(HaveOccurred())
 		})

atc/worker/image/imagefakes/fake_image_resource_fetcher_factory.go

@@ -5,20 +5,19 @@ import (
 	"sync"
 
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/worker"
 	"github.com/concourse/concourse/atc/worker/image"
 )
 
 type FakeImageResourceFetcherFactory struct {
-	NewImageResourceFetcherStub        func(worker.Worker, worker.ImageResource, atc.Version, int, creds.VersionedResourceTypes, worker.ImageFetchingDelegate) image.ImageResourceFetcher
+	NewImageResourceFetcherStub        func(worker.Worker, worker.ImageResource, atc.Version, int, atc.VersionedResourceTypes, worker.ImageFetchingDelegate) image.ImageResourceFetcher
 	newImageResourceFetcherMutex       sync.RWMutex
 	newImageResourceFetcherArgsForCall []struct {
 		arg1 worker.Worker
 		arg2 worker.ImageResource
 		arg3 atc.Version
 		arg4 int
-		arg5 creds.VersionedResourceTypes
+		arg5 atc.VersionedResourceTypes
 		arg6 worker.ImageFetchingDelegate
 	}
 	newImageResourceFetcherReturns struct {
@@ -31,7 +30,7 @@ type FakeImageResourceFetcherFactory struct {
 	invocationsMutex sync.RWMutex
 }
 
-func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcher(arg1 worker.Worker, arg2 worker.ImageResource, arg3 atc.Version, arg4 int, arg5 creds.VersionedResourceTypes, arg6 worker.ImageFetchingDelegate) image.ImageResourceFetcher {
+func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcher(arg1 worker.Worker, arg2 worker.ImageResource, arg3 atc.Version, arg4 int, arg5 atc.VersionedResourceTypes, arg6 worker.ImageFetchingDelegate) image.ImageResourceFetcher {
 	fake.newImageResourceFetcherMutex.Lock()
 	ret, specificReturn := fake.newImageResourceFetcherReturnsOnCall[len(fake.newImageResourceFetcherArgsForCall)]
 	fake.newImageResourceFetcherArgsForCall = append(fake.newImageResourceFetcherArgsForCall, struct {
@@ -39,7 +38,7 @@ func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcher(arg1 worker
 		arg2 worker.ImageResource
 		arg3 atc.Version
 		arg4 int
-		arg5 creds.VersionedResourceTypes
+		arg5 atc.VersionedResourceTypes
 		arg6 worker.ImageFetchingDelegate
 	}{arg1, arg2, arg3, arg4, arg5, arg6})
 	fake.recordInvocation("NewImageResourceFetcher", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
@@ -60,13 +59,13 @@ func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherCallCount()
 	return len(fake.newImageResourceFetcherArgsForCall)
 }
 
-func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherCalls(stub func(worker.Worker, worker.ImageResource, atc.Version, int, creds.VersionedResourceTypes, worker.ImageFetchingDelegate) image.ImageResourceFetcher) {
+func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherCalls(stub func(worker.Worker, worker.ImageResource, atc.Version, int, atc.VersionedResourceTypes, worker.ImageFetchingDelegate) image.ImageResourceFetcher) {
 	fake.newImageResourceFetcherMutex.Lock()
 	defer fake.newImageResourceFetcherMutex.Unlock()
 	fake.NewImageResourceFetcherStub = stub
 }
 
-func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherArgsForCall(i int) (worker.Worker, worker.ImageResource, atc.Version, int, creds.VersionedResourceTypes, worker.ImageFetchingDelegate) {
+func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherArgsForCall(i int) (worker.Worker, worker.ImageResource, atc.Version, int, atc.VersionedResourceTypes, worker.ImageFetchingDelegate) {
 	fake.newImageResourceFetcherMutex.RLock()
 	defer fake.newImageResourceFetcherMutex.RUnlock()
 	argsForCall := fake.newImageResourceFetcherArgsForCall[i]

atc/worker/image_factory.go

@@ -7,7 +7,6 @@ import (
 
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 )
 
@@ -21,7 +20,7 @@ type ImageFactory interface {
 		imageSpec ImageSpec,
 		teamID int,
 		delegate ImageFetchingDelegate,
-		resourceTypes creds.VersionedResourceTypes,
+		resourceTypes atc.VersionedResourceTypes,
 	) (Image, error)
 }
 

atc/worker/pool.go

@@ -1,6 +1,7 @@
 package worker
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"math/rand"
@@ -9,6 +10,7 @@ import (
 	"code.cloudfoundry.org/clock"
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc/db"
+	"github.com/concourse/concourse/atc/db/lock"
 )
 
 //go:generate counterfeiter . WorkerProvider
@@ -42,7 +44,8 @@ type WorkerProvider interface {
 }
 
 var (
-	ErrNoWorkers = errors.New("no workers")
+	ErrNoWorkers             = errors.New("no workers")
+	ErrFailedAcquirePoolLock = errors.New("failed to acquire pool lock")
 )
 
 type NoCompatibleWorkersError struct {
@@ -57,9 +60,11 @@ func (err NoCompatibleWorkersError) Error() string {
 
 type Pool interface {
 	FindOrChooseWorkerForContainer(
+		context.Context,
 		lager.Logger,
 		db.ContainerOwner,
 		ContainerSpec,
+		db.ContainerMetadata,
 		WorkerSpec,
 		ContainerPlacementStrategy,
 	) (Worker, error)
@@ -68,18 +73,30 @@ type Pool interface {
 		lager.Logger,
 		WorkerSpec,
 	) (Worker, error)
+
+	AcquireContainerCreatingLock(
+		logger lager.Logger,
+	) (lock.Lock, bool, error)
 }
 
 type pool struct {
-	provider WorkerProvider
+	clock       clock.Clock
+	lockFactory lock.LockFactory
+	provider    WorkerProvider
 
 	rand *rand.Rand
 }
 
-func NewPool(provider WorkerProvider) Pool {
+func NewPool(
+	clock clock.Clock,
+	lockFactory lock.LockFactory,
+	provider WorkerProvider,
+) Pool {
 	return &pool{
-		provider: provider,
+		clock:       clock,
-		rand:     rand.New(rand.NewSource(time.Now().UnixNano())),
+		lockFactory: lockFactory,
+		provider:    provider,
+		rand:        rand.New(rand.NewSource(time.Now().UnixNano())),
 	}
 }
 
@@ -120,9 +137,11 @@ func (pool *pool) allSatisfying(logger lager.Logger, spec WorkerSpec) ([]Worker,
 }
 
 func (pool *pool) FindOrChooseWorkerForContainer(
+	ctx context.Context,
 	logger lager.Logger,
 	owner db.ContainerOwner,
 	containerSpec ContainerSpec,
+	metadata db.ContainerMetadata,
 	workerSpec WorkerSpec,
 	strategy ContainerPlacementStrategy,
 ) (Worker, error) {
@@ -150,16 +169,43 @@ dance:
 		}
 	}
 
-	if worker == nil {
+	// pool is shared by all steps running in the system,
-		worker, err = strategy.Choose(logger, compatibleWorkers, containerSpec)
+	// lock around worker placement strategies so decisions
+	// are serialized and valid at the time of creating
+	// containers in garden
+	for {
+		lock, acquired, err := pool.AcquireContainerCreatingLock(logger)
+		if err != nil {
+			return nil, ErrFailedAcquirePoolLock
+		}
+
+		if !acquired {
+			pool.clock.Sleep(time.Second)
+			continue
+		}
+		defer lock.Release()
+
+		if worker == nil {
+			worker, err = strategy.Choose(logger, compatibleWorkers, containerSpec)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		err = worker.EnsureDBContainerExists(nil, logger, owner, metadata)
 		if err != nil {
 			return nil, err
 		}
+		break
 	}
 
 	return worker, nil
 }
 
+func (pool *pool) AcquireContainerCreatingLock(logger lager.Logger) (lock.Lock, bool, error) {
+	return pool.lockFactory.Acquire(logger, lock.NewContainerCreatingLockID())
+}
+
 func (pool *pool) FindOrChooseWorker(
 	logger lager.Logger,
 	workerSpec WorkerSpec,

atc/worker/pool_test.go

@@ -1,14 +1,18 @@
 package worker_test
 
 import (
+	"context"
 	"errors"
+	"time"
 
+	"code.cloudfoundry.org/clock/fakeclock"
 	"code.cloudfoundry.org/lager"
 	"code.cloudfoundry.org/lager/lagertest"
-	"github.com/cloudfoundry/bosh-cli/director/template"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
+	"github.com/concourse/concourse/atc/db"
 	"github.com/concourse/concourse/atc/db/dbfakes"
+	"github.com/concourse/concourse/atc/db/lock"
+	"github.com/concourse/concourse/atc/db/lock/lockfakes"
 	. "github.com/concourse/concourse/atc/worker"
 	"github.com/concourse/concourse/atc/worker/workerfakes"
 	. "github.com/onsi/ginkgo"
@@ -17,24 +21,29 @@ import (
 
 var _ = Describe("Pool", func() {
 	var (
-		logger       *lagertest.TestLogger
+		fakeClock       *fakeclock.FakeClock
-		fakeProvider *workerfakes.FakeWorkerProvider
+		logger          *lagertest.TestLogger
-		pool         Pool
+		fakeProvider    *workerfakes.FakeWorkerProvider
+		fakeLockFactory *lockfakes.FakeLockFactory
+		pool            Pool
 	)
 
 	BeforeEach(func() {
 		logger = lagertest.NewTestLogger("test")
 		fakeProvider = new(workerfakes.FakeWorkerProvider)
+		fakeLockFactory = new(lockfakes.FakeLockFactory)
+		fakeClock = fakeclock.NewFakeClock(time.Unix(123, 456))
 
-		pool = NewPool(fakeProvider)
+		pool = NewPool(fakeClock, fakeLockFactory, fakeProvider)
 	})
 
 	Describe("FindOrChooseWorkerForContainer", func() {
 		var (
 			spec          ContainerSpec
 			workerSpec    WorkerSpec
-			resourceTypes creds.VersionedResourceTypes
+			resourceTypes atc.VersionedResourceTypes
 			fakeOwner     *dbfakes.FakeContainerOwner
+			fakeLock      *lockfakes.FakeLock
 
 			chosenWorker Worker
 			chooseErr    error
@@ -84,20 +93,16 @@ var _ = Describe("Pool", func() {
 				},
 			}
 
-			variables := template.StaticVariables{
+			resourceTypes = atc.VersionedResourceTypes{
-				"secret-source": "super-secret-source",
-			}
-
-			resourceTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
 				{
 					ResourceType: atc.ResourceType{
 						Name:   "custom-type-b",
 						Type:   "custom-type-a",
-						Source: atc.Source{"some": "((secret-source))"},
+						Source: atc.Source{"some": "super-secret-source"},
 					},
 					Version: atc.Version{"some": "version"},
 				},
-			})
+			}
 
 			workerSpec = WorkerSpec{
 				ResourceType:  "some-type",
@@ -111,18 +116,84 @@ var _ = Describe("Pool", func() {
 
 			compatibleWorker = new(workerfakes.FakeWorker)
 			compatibleWorker.SatisfiesReturns(true)
+
+			fakeLock = new(lockfakes.FakeLock)
+			fakeLockFactory.AcquireReturns(fakeLock, true, nil)
 		})
 
 		JustBeforeEach(func() {
 			chosenWorker, chooseErr = pool.FindOrChooseWorkerForContainer(
+				context.TODO(),
 				logger,
 				fakeOwner,
 				spec,
+				db.ContainerMetadata{},
 				workerSpec,
 				fakeStrategy,
 			)
 		})
 
+		Context("selects a worker in serial", func() {
+			var (
+				workerA *workerfakes.FakeWorker
+			)
+
+			BeforeEach(func() {
+				workerA = new(workerfakes.FakeWorker)
+				workerA.NameReturns("workerA")
+				workerA.SatisfiesReturns(true)
+
+				fakeProvider.FindWorkersForContainerByOwnerReturns([]Worker{workerA}, nil)
+				fakeProvider.RunningWorkersReturns([]Worker{workerA}, nil)
+				fakeStrategy.ChooseReturns(workerA, nil)
+			})
+
+			Context("fails to acquire the pool lock", func() {
+				BeforeEach(func() {
+					fakeLockFactory.AcquireReturns(nil, false, ErrFailedAcquirePoolLock)
+				})
+
+				It("returns an error", func() {
+					Expect(fakeLockFactory.AcquireCallCount()).To(Equal(1))
+					fakeLockFactory.AcquireReturns(nil, false, ErrFailedAcquirePoolLock)
+					Expect(chooseErr).To(HaveOccurred())
+					Expect(chooseErr.Error()).To(Equal("failed to acquire pool lock"))
+				})
+			})
+
+			Context("lock is held by another", func() {
+				BeforeEach(func() {
+					callCount := 0
+					fakeLockFactory.AcquireStub = func(logger lager.Logger, lockID lock.LockID) (lock.Lock, bool, error) {
+						callCount++
+						go fakeClock.WaitForWatcherAndIncrement(time.Second)
+
+						if callCount < 3 {
+							return nil, false, nil
+						}
+
+						return fakeLock, true, nil
+					}
+				})
+
+				It("retries every second until it is", func() {
+					Expect(fakeLockFactory.AcquireCallCount()).To(Equal(3))
+					Expect(fakeLock.ReleaseCallCount()).To(Equal(1))
+				})
+			})
+
+			Context("lock is not held by anyone", func() {
+				BeforeEach(func() {
+					fakeLockFactory.AcquireReturns(fakeLock, true, nil)
+				})
+
+				It("acquires the lock", func() {
+					Expect(fakeLockFactory.AcquireCallCount()).To(Equal(1))
+					Expect(chooseErr).ToNot(HaveOccurred())
+				})
+			})
+		})
+
 		Context("when workers are found with the container", func() {
 			var (
 				workerA *workerfakes.FakeWorker
@@ -133,6 +204,7 @@ var _ = Describe("Pool", func() {
 			BeforeEach(func() {
 				workerA = new(workerfakes.FakeWorker)
 				workerA.NameReturns("workerA")
+				workerA.SatisfiesReturns(true)
 				workerB = new(workerfakes.FakeWorker)
 				workerB.NameReturns("workerB")
 				workerC = new(workerfakes.FakeWorker)
@@ -143,6 +215,10 @@ var _ = Describe("Pool", func() {
 				fakeStrategy.ChooseReturns(workerA, nil)
 			})
 
+			It("ensures a db container exists", func() {
+				Expect(workerA.EnsureDBContainerExistsCallCount()).To(Equal(1))
+			})
+
 			Context("when one of the workers satisfy the spec", func() {
 				BeforeEach(func() {
 					workerA.SatisfiesReturns(true)
@@ -235,6 +311,7 @@ var _ = Describe("Pool", func() {
 					workerA = new(workerfakes.FakeWorker)
 					workerB = new(workerfakes.FakeWorker)
 					workerC = new(workerfakes.FakeWorker)
+					workerA.NameReturns("workerA")
 
 					workerA.SatisfiesReturns(true)
 					workerB.SatisfiesReturns(true)
@@ -244,6 +321,10 @@ var _ = Describe("Pool", func() {
 					fakeStrategy.ChooseReturns(workerA, nil)
 				})
 
+				It("ensures a db container exists", func() {
+					Expect(workerA.EnsureDBContainerExistsCallCount()).To(Equal(1))
+				})
+
 				It("checks that the workers satisfy the given worker spec", func() {
 					Expect(workerA.SatisfiesCallCount()).To(Equal(1))
 					_, actualSpec := workerA.SatisfiesArgsForCall(0)
@@ -390,6 +471,9 @@ var _ = Describe("Pool", func() {
 						fakeStrategy.ChooseReturns(compatibleWorker, nil)
 					})
 
+					It("ensures a db container exists", func() {
+						Expect(compatibleWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
+					})
 					It("chooses a worker", func() {
 						Expect(chooseErr).ToNot(HaveOccurred())
 						Expect(fakeStrategy.ChooseCallCount()).To(Equal(1))

atc/worker/worker.go

@@ -2,6 +2,7 @@ package worker
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"sort"
@@ -14,13 +15,14 @@ import (
 	"code.cloudfoundry.org/garden"
 	"code.cloudfoundry.org/lager"
 	"github.com/concourse/concourse/atc"
-	"github.com/concourse/concourse/atc/creds"
 	"github.com/concourse/concourse/atc/db"
 	"github.com/cppforlife/go-semi-semantic/version"
 )
 
 const userPropertyName = "user"
 
+var ResourceConfigCheckSessionExpiredError = errors.New("no db container was found for owner")
+
 //go:generate counterfeiter . Worker
 
 type Worker interface {
@@ -36,15 +38,21 @@ type Worker interface {
 	IsVersionCompatible(lager.Logger, version.Version) bool
 	Satisfies(lager.Logger, WorkerSpec) bool
 
+	EnsureDBContainerExists(
+		context.Context,
+		lager.Logger,
+		db.ContainerOwner,
+		db.ContainerMetadata,
+	) error
+
 	FindContainerByHandle(lager.Logger, int, string) (Container, bool, error)
 	FindOrCreateContainer(
 		context.Context,
 		lager.Logger,
 		ImageFetchingDelegate,
 		db.ContainerOwner,
-		db.ContainerMetadata,
 		ContainerSpec,
-		creds.VersionedResourceTypes,
+		atc.VersionedResourceTypes,
 	) (Container, error)
 
 	FindVolumeForResourceCache(logger lager.Logger, resourceCache db.UsedResourceCache) (Volume, bool, error)
@@ -170,9 +178,8 @@ func (worker *gardenWorker) FindOrCreateContainer(
 	logger lager.Logger,
 	delegate ImageFetchingDelegate,
 	owner db.ContainerOwner,
-	metadata db.ContainerMetadata,
 	containerSpec ContainerSpec,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 ) (Container, error) {
 
 	var (
@@ -183,11 +190,18 @@ func (worker *gardenWorker) FindOrCreateContainer(
 		err               error
 	)
 
-	creatingContainer, createdContainer, containerHandle, err = worker.helper.findOrInitializeContainer(logger, owner, metadata)
+	creatingContainer, createdContainer, err = worker.dbWorker.FindContainer(owner)
 	if err != nil {
 		logger.Error("failed-to-find-container-in-db", err)
 		return nil, err
 	}
+	if creatingContainer != nil {
+		containerHandle = creatingContainer.Handle()
+	} else if createdContainer != nil {
+		containerHandle = createdContainer.Handle()
+	} else {
+		return nil, ResourceConfigCheckSessionExpiredError
+	}
 
 	gardenContainer, err = worker.gardenClient.Lookup(containerHandle)
 	if err != nil {
@@ -202,7 +216,7 @@ func (worker *gardenWorker) FindOrCreateContainer(
 		logger.Debug("found-created-container-in-db")
 
 		if gardenContainer == nil {
-			return nil, garden.ContainerNotFoundError{containerHandle}
+			return nil, garden.ContainerNotFoundError{Handle: containerHandle}
 		}
 		return worker.helper.constructGardenWorkerContainer(
 			logger,
@@ -212,8 +226,15 @@ func (worker *gardenWorker) FindOrCreateContainer(
 	}
 
 	if gardenContainer == nil {
-
+		fetchedImage, err := worker.fetchImageForContainer(
-		fetchedImage, err := worker.fetchImageForContainer(ctx, logger, containerSpec.ImageSpec, containerSpec.TeamID, delegate, resourceTypes, creatingContainer)
+			ctx,
+			logger,
+			containerSpec.ImageSpec,
+			containerSpec.TeamID,
+			delegate,
+			resourceTypes,
+			creatingContainer,
+		)
 		if err != nil {
 			creatingContainer.Failed()
 			logger.Error("failed-to-fetch-image-for-container", err)
@@ -294,13 +315,45 @@ func (worker *gardenWorker) getBindMounts(volumeMounts []VolumeMount, bindMountS
 	return bindMounts, nil
 }
 
+func (worker *gardenWorker) EnsureDBContainerExists(
+	ctx context.Context,
+	logger lager.Logger,
+	owner db.ContainerOwner,
+	metadata db.ContainerMetadata,
+) error {
+
+	creatingContainer, createdContainer, err := worker.dbWorker.FindContainer(owner)
+	if err != nil {
+		return err
+	}
+
+	if creatingContainer != nil || createdContainer != nil {
+		return nil
+	}
+
+	logger.Debug("creating-container-in-db")
+	creatingContainer, err = worker.dbWorker.CreateContainer(
+		owner,
+		metadata,
+	)
+	if err != nil {
+		logger.Error("failed-to-create-container-in-db", err)
+		return err
+	}
+
+	logger = logger.WithData(lager.Data{"container": creatingContainer.Handle()})
+	logger.Debug("created-creating-container-in-db")
+
+	return nil
+}
+
 func (worker *gardenWorker) fetchImageForContainer(
 	ctx context.Context,
 	logger lager.Logger,
 	spec ImageSpec,
 	teamID int,
 	delegate ImageFetchingDelegate,
-	resourceTypes creds.VersionedResourceTypes,
+	resourceTypes atc.VersionedResourceTypes,
 	creatingContainer db.CreatingContainer,
 ) (FetchedImage, error) {
 	image, err := worker.imageFactory.GetImage(
@@ -320,7 +373,12 @@ func (worker *gardenWorker) fetchImageForContainer(
 	return image.FetchForContainer(ctx, logger, creatingContainer)
 }
 
-func (worker *gardenWorker) createVolumes(logger lager.Logger, isPrivileged bool, creatingContainer db.CreatingContainer, spec ContainerSpec) ([]VolumeMount, error) {
+func (worker *gardenWorker) createVolumes(
+	logger lager.Logger,
+	isPrivileged bool,
+	creatingContainer db.CreatingContainer,
+	spec ContainerSpec,
+) ([]VolumeMount, error) {
 	var volumeMounts []VolumeMount
 	var ioVolumeMounts []VolumeMount
 
@@ -550,8 +608,8 @@ func (worker *gardenWorker) Satisfies(logger lager.Logger, spec WorkerSpec) bool
 	return true
 }
 
-func determineUnderlyingTypeName(typeName string, resourceTypes creds.VersionedResourceTypes) string {
+func determineUnderlyingTypeName(typeName string, resourceTypes atc.VersionedResourceTypes) string {
-	resourceTypesMap := make(map[string]creds.VersionedResourceType)
+	resourceTypesMap := make(map[string]atc.VersionedResourceType)
 	for _, resourceType := range resourceTypes {
 		resourceTypesMap[resourceType.Name] = resourceType
 	}