Merge branch 'master' into issue/3872

Signed-off-by: Jamie Klassen <cklassen@pivotal.io>
This commit is contained in:
Jamie Klassen 2019-06-25 10:29:12 -04:00
commit 48740aaf19
153 changed files with 4842 additions and 3654 deletions

View File

@ -1339,8 +1339,21 @@ var _ = Describe("Builds API", func() {
BeforeEach(func() {
fakeJob.PublicReturns(true)
})
It("returns 200", func() {
Expect(response.StatusCode).To(Equal(http.StatusOK))
Context("and the build has a plan", func() {
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))
})
})
})
})

View File

@ -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(),

View File

@ -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))

View File

@ -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) {
containers, err := l.team.Containers(logger)
func (l *allContainersLocator) Locate() ([]db.Container, map[int]time.Time, error) {
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) {
return l.team.FindCheckContainers(logger, l.pipelineName, l.resourceName, l.secretManager)
func (l *checkContainerLocator) Locate() ([]db.Container, map[int]time.Time, error) {
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
}

View File

@ -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()

View File

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

View File

@ -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{}
fakeEngine.LookupBuildStub = func(logger lager.Logger, build db.Build) engine.Build {
engineBuild := new(enginefakes.FakeBuild)
engineBuilds = []*enginefakes.FakeRunnable{}
fakeEngine.NewBuildStub = func(build db.Build) engine.Runnable {
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[1].ResumeCallCount).Should(Equal(1))
Eventually(engineBuilds[2].ResumeCallCount).Should(Equal(1))
Eventually(engineBuilds[0].RunCallCount).Should(Equal(1))
Eventually(engineBuilds[1].RunCallCount).Should(Equal(1))
Eventually(engineBuilds[2].RunCallCount).Should(Equal(1))
})
})

View File

@ -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
}

View File

@ -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
}

View File

@ -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)
}

View File

@ -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{})
Expect(started).To(BeTrue())
updated, err := resourceConfigScope.UpdateLastCheckEndTime()
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()
Expect(stillExists).To(BeTrue())
Expect(err).NotTo(HaveOccurred())
expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{}
expectedBuildPrep.Inputs = map[string]db.BuildPreparationStatus{
"some-input": db.BuildPreparationStatusNotBlocking,
}
})
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 the build is started", func() {
BeforeEach(func() {
started, err := build.Start(atc.Plan{})
Expect(started).To(BeTrue())
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() {
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() {
It("returns build preparation with missing input reason", 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"}})

View File

@ -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,
Max: 5 * time.Minute,
Min: 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())
})

View File

@ -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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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())

View File

@ -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
arg2 string
arg3 atc.Source
arg4 creds.VersionedResourceTypes
arg5 atc.Version
arg6 db.ResourceConfigMetadataFields
arg1 string
arg2 atc.Source
arg3 atc.VersionedResourceTypes
arg4 atc.Version
arg5 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
arg2 string
arg3 atc.Source
arg4 creds.VersionedResourceTypes
arg5 atc.Version
arg6 db.ResourceConfigMetadataFields
arg1 string
arg2 atc.Source
arg3 atc.VersionedResourceTypes
arg4 atc.Version
arg5 db.ResourceConfigMetadataFields
arg6 string
arg7 string
arg8 string
}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8})
fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8})
}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
fake.recordInvocation("SaveOutput", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
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()

View File

@ -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
arg2 atc.Source
arg3 creds.VersionedResourceTypes
arg1 atc.Source
arg2 atc.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
arg2 atc.Source
arg3 creds.VersionedResourceTypes
}{arg1, arg2, arg3})
fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2, arg3})
arg1 atc.Source
arg2 atc.VersionedResourceTypes
}{arg1, arg2})
fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2})
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()

View File

@ -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
arg2 db.ResourceCacheUser
arg3 string
arg4 atc.Version
arg5 atc.Source
arg6 atc.Params
arg7 creds.VersionedResourceTypes
arg1 db.ResourceCacheUser
arg2 string
arg3 atc.Version
arg4 atc.Source
arg5 atc.Params
arg6 atc.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
arg2 db.ResourceCacheUser
arg3 string
arg4 atc.Version
arg5 atc.Source
arg6 atc.Params
arg7 creds.VersionedResourceTypes
}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
fake.recordInvocation("FindOrCreateResourceCache", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
arg1 db.ResourceCacheUser
arg2 string
arg3 atc.Version
arg4 atc.Source
arg5 atc.Params
arg6 atc.VersionedResourceTypes
}{arg1, arg2, arg3, arg4, arg5, arg6})
fake.recordInvocation("FindOrCreateResourceCache", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
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) {

View File

@ -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
arg2 string
arg3 atc.Source
arg4 creds.VersionedResourceTypes
arg1 string
arg2 atc.Source
arg3 atc.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
arg2 string
arg3 atc.Source
arg4 creds.VersionedResourceTypes
}{arg1, arg2, arg3, arg4})
fake.recordInvocation("FindOrCreateResourceConfig", []interface{}{arg1, arg2, arg3, arg4})
arg1 string
arg2 atc.Source
arg3 atc.VersionedResourceTypes
}{arg1, arg2, arg3})
fake.recordInvocation("FindOrCreateResourceConfig", []interface{}{arg1, arg2, arg3})
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) {

View File

@ -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, arg2})
fake.recordInvocation("AcquireResourceCheckingLock", []interface{}{arg1, arg2})
}{arg1})
fake.recordInvocation("AcquireResourceCheckingLock", []interface{}{arg1})
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) {

View File

@ -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
arg2 atc.Source
arg3 creds.VersionedResourceTypes
arg1 atc.Source
arg2 atc.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
arg2 atc.Source
arg3 creds.VersionedResourceTypes
}{arg1, arg2, arg3})
fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2, arg3})
arg1 atc.Source
arg2 atc.VersionedResourceTypes
}{arg1, arg2})
fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2})
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) {

View File

@ -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
arg4 creds.Secrets
arg3 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{}{arg1})
}{})
fake.recordInvocation("Containers", []interface{}{})
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
arg4 creds.Secrets
}{arg1, arg2, arg3, arg4})
fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3, arg4})
arg3 creds.Secrets
}{arg1, arg2, arg3})
fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3})
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) {

View File

@ -94,17 +94,17 @@ type FakeWorker struct {
expiresAtReturnsOnCall map[int]struct {
result1 time.Time
}
FindContainerOnWorkerStub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)
findContainerOnWorkerMutex sync.RWMutex
findContainerOnWorkerArgsForCall []struct {
FindContainerStub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)
findContainerMutex sync.RWMutex
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) {
fake.findContainerOnWorkerMutex.Lock()
ret, specificReturn := fake.findContainerOnWorkerReturnsOnCall[len(fake.findContainerOnWorkerArgsForCall)]
fake.findContainerOnWorkerArgsForCall = append(fake.findContainerOnWorkerArgsForCall, struct {
func (fake *FakeWorker) FindContainer(arg1 db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error) {
fake.findContainerMutex.Lock()
ret, specificReturn := fake.findContainerReturnsOnCall[len(fake.findContainerArgsForCall)]
fake.findContainerArgsForCall = append(fake.findContainerArgsForCall, struct {
arg1 db.ContainerOwner
}{arg1})
fake.recordInvocation("FindContainerOnWorker", []interface{}{arg1})
fake.findContainerOnWorkerMutex.Unlock()
if fake.FindContainerOnWorkerStub != nil {
return fake.FindContainerOnWorkerStub(arg1)
fake.recordInvocation("FindContainer", []interface{}{arg1})
fake.findContainerMutex.Unlock()
if fake.FindContainerStub != nil {
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 {
fake.findContainerOnWorkerMutex.RLock()
defer fake.findContainerOnWorkerMutex.RUnlock()
return len(fake.findContainerOnWorkerArgsForCall)
func (fake *FakeWorker) FindContainerCallCount() int {
fake.findContainerMutex.RLock()
defer fake.findContainerMutex.RUnlock()
return len(fake.findContainerArgsForCall)
}
func (fake *FakeWorker) FindContainerOnWorkerCalls(stub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)) {
fake.findContainerOnWorkerMutex.Lock()
defer fake.findContainerOnWorkerMutex.Unlock()
fake.FindContainerOnWorkerStub = stub
func (fake *FakeWorker) FindContainerCalls(stub func(db.ContainerOwner) (db.CreatingContainer, db.CreatedContainer, error)) {
fake.findContainerMutex.Lock()
defer fake.findContainerMutex.Unlock()
fake.FindContainerStub = stub
}
func (fake *FakeWorker) FindContainerOnWorkerArgsForCall(i int) db.ContainerOwner {
fake.findContainerOnWorkerMutex.RLock()
defer fake.findContainerOnWorkerMutex.RUnlock()
argsForCall := fake.findContainerOnWorkerArgsForCall[i]
func (fake *FakeWorker) FindContainerArgsForCall(i int) db.ContainerOwner {
fake.findContainerMutex.RLock()
defer fake.findContainerMutex.RUnlock()
argsForCall := fake.findContainerArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeWorker) FindContainerOnWorkerReturns(result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
fake.findContainerOnWorkerMutex.Lock()
defer fake.findContainerOnWorkerMutex.Unlock()
fake.FindContainerOnWorkerStub = nil
fake.findContainerOnWorkerReturns = struct {
func (fake *FakeWorker) FindContainerReturns(result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
fake.findContainerMutex.Lock()
defer fake.findContainerMutex.Unlock()
fake.FindContainerStub = nil
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) {
fake.findContainerOnWorkerMutex.Lock()
defer fake.findContainerOnWorkerMutex.Unlock()
fake.FindContainerOnWorkerStub = nil
if fake.findContainerOnWorkerReturnsOnCall == nil {
fake.findContainerOnWorkerReturnsOnCall = make(map[int]struct {
func (fake *FakeWorker) FindContainerReturnsOnCall(i int, result1 db.CreatingContainer, result2 db.CreatedContainer, result3 error) {
fake.findContainerMutex.Lock()
defer fake.findContainerMutex.Unlock()
fake.FindContainerStub = nil
if fake.findContainerReturnsOnCall == nil {
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()
defer fake.findContainerOnWorkerMutex.RUnlock()
fake.findContainerMutex.RLock()
defer fake.findContainerMutex.RUnlock()
fake.gardenAddrMutex.RLock()
defer fake.gardenAddrMutex.RUnlock()
fake.hTTPProxyURLMutex.RLock()

View File

@ -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})

View File

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

View File

@ -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"}

View File

@ -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 {

View File

@ -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,

View File

@ -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
}

View File

@ -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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
resourceType1,
resourceType2,
resourceType3,
},
),
atc.VersionedResourceTypes{
resourceType1,
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
resourceType1,
resourceTypeUsingBogusBaseType,
},
),
atc.VersionedResourceTypes{
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
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())
}

View File

@ -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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some": "source",
},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some": "source",
},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
atc.VersionedResourceTypes{},
)
Expect(err).ToNot(HaveOccurred())

View File

@ -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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{},
),
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())
})

View File

@ -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

View File

@ -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,
Max: 1 * time.Minute,
Min: 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())

View File

@ -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 {

View File

@ -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())

View File

@ -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,

View File

@ -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())

View File

@ -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

View File

@ -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{

View File

@ -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
}

View File

@ -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())
})

View File

@ -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(
logger lager.Logger,
) ([]Container, error) {
func (t *team) Containers() ([]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
NewName string
OldName 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

View File

@ -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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
Max: 1 * time.Hour,
}
BeforeEach(func() {
resourceConfigScope, err := defaultResource.SetResourceConfig(
logger,
defaultResource.Source(),
creds.VersionedResourceTypes{},
atc.VersionedResourceTypes{},
)
Expect(err).ToNot(HaveOccurred())

View File

@ -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(
template.StaticVariables{},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some-type": "source",
},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some-type": "source",
},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some-type": "source",
},
Version: atc.Version{"some-type": "version"},
},
Version: atc.Version{"some-type": "version"},
},
),
},
)
Expect(err).ToNot(HaveOccurred())
})

View File

@ -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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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(
template.StaticVariables{"source-param": "some-secret-sauce"},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{
"some-type": "source",
},
atc.VersionedResourceTypes{
atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
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{
{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{"some-type": "((source-param))"},
},
Version: atc.Version{"some-custom-type": "version"},
atc.VersionedResourceTypes{
{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{"some-type": "((source-param))"},
},
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{
{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{"some-type": "source"},
},
Version: atc.Version{"some-custom-type": "version"},
atc.VersionedResourceTypes{
{
ResourceType: atc.ResourceType{
Name: "some-type",
Type: "some-base-resource-type",
Source: atc.Source{"some-type": "source"},
},
Version: atc.Version{"some-custom-type": "version"},
},
),
},
)
Expect(err).ToNot(HaveOccurred())

View File

@ -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

View File

@ -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,
Max: 5 * time.Minute,
Min: 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)

View File

@ -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())

View File

@ -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,
Max: 1 * time.Hour,
Min: 5 * time.Minute,
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())
})

View File

@ -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
PutStep(atc.Plan, db.Build, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) exec.Step
TaskStep(atc.Plan, db.Build, db.ContainerMetadata, exec.TaskDelegate) exec.Step
GetStep(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.GetDelegate) exec.Step
PutStep(atc.Plan, exec.StepMetadata, db.ContainerMetadata, exec.PutDelegate) 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 {
return StepMetadata{
) exec.StepMetadata {
return exec.StepMetadata{
BuildID: build.ID(),
BuildName: build.Name(),
JobName: build.JobName(),
PipelineName: build.PipelineName(),
TeamID: build.TeamID(),
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
}

View File

@ -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",
PipelineName: "some-pipeline",
TeamID: 1111,
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ = fakeStepFactory.PutStepArgsForCall(1)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(1)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ = fakeStepFactory.TaskStepArgsForCall(1)
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)
Expect(dBuild).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.PutStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(2)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(0)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(1)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.TaskStepArgsForCall(3)
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)
Expect(build).To(Equal(fakeBuild))
plan, stepMetadata, containerMetadata, _ := fakeStepFactory.GetStepArgsForCall(0)
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",
}))
})
})
})
})
})

View File

@ -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
arg3 exec.StepMetadata
arg4 db.ContainerMetadata
arg5 exec.GetDelegate
arg2 exec.StepMetadata
arg3 db.ContainerMetadata
arg4 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
arg3 exec.StepMetadata
arg4 db.ContainerMetadata
arg5 exec.PutDelegate
arg2 exec.StepMetadata
arg3 db.ContainerMetadata
arg4 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
arg3 exec.StepMetadata
arg4 db.ContainerMetadata
arg5 exec.GetDelegate
}{arg1, arg2, arg3, arg4, arg5})
fake.recordInvocation("GetStep", []interface{}{arg1, arg2, arg3, arg4, arg5})
arg2 exec.StepMetadata
arg3 db.ContainerMetadata
arg4 exec.GetDelegate
}{arg1, arg2, arg3, arg4})
fake.recordInvocation("GetStep", []interface{}{arg1, arg2, arg3, arg4})
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
arg3 exec.StepMetadata
arg4 db.ContainerMetadata
arg5 exec.PutDelegate
}{arg1, arg2, arg3, arg4, arg5})
fake.recordInvocation("PutStep", []interface{}{arg1, arg2, arg3, arg4, arg5})
arg2 exec.StepMetadata
arg3 db.ContainerMetadata
arg4 exec.PutDelegate
}{arg1, arg2, arg3, arg4})
fake.recordInvocation("PutStep", []interface{}{arg1, arg2, arg3, arg4})
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]

View File

@ -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),

View File

@ -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
fakeBuild *dbfakes.FakeBuild
fakeClock *fakeclock.FakeClock
logger *lagertest.TestLogger
fakeBuild *dbfakes.FakeBuild
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() {

View File

@ -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")
variables := creds.NewVariables(factory.secretManager, build.TeamName(), build.PipelineName())
containerMetadata.WorkingDirectory = resource.ResourcesDir("get")
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,
factory.resourceCacheFactory,
*plan.Get,
stepMetadata,
creds.NewVersionedResourceTypes(variables, plan.Get.VersionedResourceTypes),
containerMetadata,
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")
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)
}
containerMetadata.WorkingDirectory = resource.ResourcesDir("put")
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,
creds.NewVersionedResourceTypes(variables, plan.Put.VersionedResourceTypes),
factory.strategy,
containerMetadata,
factory.secretManager,
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 = 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}
containerMetadata.WorkingDirectory = filepath.Join("/tmp", "build", fmt.Sprintf("%x", sum[:4]))
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,
creds.NewVersionedResourceTypes(credMgrVariables, plan.Task.VersionedResourceTypes),
*plan.Task,
factory.defaultLimits,
stepMetadata,
containerMetadata,
factory.secretManager,
factory.strategy,
factory.pool,
delegate,
)
return exec.LogError(taskStep, delegate)

View File

@ -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 {
Resume(lager.Logger)
type Runnable interface {
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 {
return &execBuild{
) Runnable {
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) {
build.waitGroup.Add(1)
defer build.waitGroup.Done()
func (b *engineBuild) Run(logger lager.Logger) {
b.waitGroup.Add(1)
defer b.waitGroup.Done()
logger = logger.WithData(lager.Data{
"build": build.build.ID(),
"pipeline": build.build.PipelineName(),
"job": build.build.JobName(),
"build": b.build.ID(),
"pipeline": b.build.PipelineName(),
"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)
defer build.trackFinished(logger)
b.trackStarted(logger)
defer b.trackFinished(logger)
logger.Info("running")
state := build.runState()
defer build.clearRunState()
state := b.runState()
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) {
if err := build.build.Finish(db.BuildStatus(status)); err != nil {
func (b *engineBuild) saveStatus(logger lager.Logger, status atc.BuildStatus) {
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(),
JobName: build.build.JobName(),
BuildName: build.build.Name(),
BuildID: build.build.ID(),
TeamName: build.build.TeamName(),
PipelineName: b.build.PipelineName(),
JobName: b.build.JobName(),
BuildName: b.build.Name(),
BuildID: b.build.ID(),
TeamName: b.build.TeamName(),
}.Emit(logger)
}
func (build *execBuild) trackFinished(logger lager.Logger) {
found, err := build.build.Reload()
func (b *engineBuild) trackFinished(logger lager.Logger) {
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(),
JobName: build.build.JobName(),
BuildName: build.build.Name(),
BuildID: build.build.ID(),
BuildStatus: build.build.Status(),
BuildDuration: build.build.EndTime().Sub(build.build.StartTime()),
TeamName: build.build.TeamName(),
PipelineName: b.build.PipelineName(),
JobName: b.build.JobName(),
BuildName: b.build.Name(),
BuildID: b.build.ID(),
BuildStatus: b.build.Status(),
BuildDuration: b.build.EndTime().Sub(b.build.StartTime()),
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())
}

View File

@ -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
err error
build Runnable
engine Engine
)
@ -50,12 +44,12 @@ var _ = Describe("Engine", func() {
})
JustBeforeEach(func() {
build = engine.LookupBuild(logger, fakeBuild)
build = engine.NewBuild(fakeBuild)
})
It("succeeds", func() {
Expect(err).NotTo(HaveOccurred())
})
// It("succeeds", func() {
// 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() {

View File

@ -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)

View File

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

View File

@ -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)

View File

@ -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

View File

@ -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()

View File

@ -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
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
containerMetadata db.ContainerMetadata
dbResourceCacheFactory db.ResourceCacheFactory
stepMetadata StepMetadata
resourceTypes creds.VersionedResourceTypes
succeeded bool
strategy worker.ContainerPlacementStrategy
workerPool worker.Pool
planID atc.PlanID
plan atc.GetPlan
metadata StepMetadata
containerMetadata db.ContainerMetadata
secrets creds.Secrets
resourceFetcher resource.Fetcher
resourceCacheFactory db.ResourceCacheFactory
strategy worker.ContainerPlacementStrategy
workerPool worker.Pool
delegate GetDelegate
succeeded bool
}
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,
stepMetadata StepMetadata,
resourceTypes creds.VersionedResourceTypes,
secrets creds.Secrets,
resourceFetcher resource.Fetcher,
resourceCacheFactory db.ResourceCacheFactory,
strategy worker.ContainerPlacementStrategy,
workerPool worker.Pool,
delegate GetDelegate,
) Step {
return &GetStep{
build: build,
name: name,
resourceType: resourceType,
resource: resource,
source: source,
params: params,
versionSource: versionSource,
tags: tags,
delegate: delegate,
resourceFetcher: resourceFetcher,
teamID: teamID,
buildID: buildID,
planID: planID,
containerMetadata: containerMetadata,
dbResourceCacheFactory: dbResourceCacheFactory,
stepMetadata: stepMetadata,
resourceTypes: resourceTypes,
strategy: strategy,
workerPool: workerPool,
planID: planID,
plan: plan,
metadata: metadata,
containerMetadata: containerMetadata,
secrets: secrets,
resourceFetcher: resourceFetcher,
resourceCacheFactory: resourceCacheFactory,
strategy: strategy,
workerPool: workerPool,
delegate: delegate,
}
}
@ -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,
"job-id": step.build.JobID(),
"step-name": step.plan.Name,
"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(
logger,
db.ForBuild(step.buildID),
step.resourceType,
version, err := NewVersionSourceFromPlan(&step.plan).Version(state)
if err != nil {
return err
}
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{
ImageSpec: worker.ImageSpec{
ResourceType: step.resourceType,
},
TeamID: step.teamID,
Env: step.stepMetadata.Env(),
}
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)
chosenWorker, err := step.workerPool.FindOrChooseWorkerForContainer(
ctx,
logger,
resourceInstance.ContainerOwner(),
containerSpec,
step.containerMetadata,
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 != "" {
pipeline, found, err := step.build.Pipeline()
if err != nil {
logger.Error("failed-to-find-pipeline", err, lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "pipeline-id": step.build.PipelineID()})
return err
}
versionInfo := VersionInfo{
Version: versionedSource.Version(),
Metadata: versionedSource.Metadata(),
}
if !found {
logger.Debug("pipeline-not-found", lager.Data{"name": step.name, "pipeline-name": step.build.PipelineName(), "pipeline-id": step.build.PipelineID()})
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
}
if step.plan.Resource != "" {
step.delegate.UpdateVersion(logger, step.plan, versionInfo)
}
step.succeeded = true
step.delegate.Finished(logger, 0, VersionInfo{
Version: versionedSource.Version(),
Metadata: versionedSource.Metadata(),
})
step.delegate.Finished(logger, 0, versionInfo)
return nil
}

View File

@ -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
resourceTypes atc.VersionedResourceTypes
fakeVersionedSource *resourcefakes.FakeVersionedSource
interpolatedResourceTypes atc.VersionedResourceTypes
artifactRepository *artifact.Repository
state *execfakes.FakeRunState
@ -55,16 +52,22 @@ var _ = Describe("GetStep", func() {
stepErr error
containerMetadata = db.ContainerMetadata{
PipelineID: 4567,
Type: db.ContainerTypeGet,
StepName: "some-step",
WorkingDirectory: resource.ResourcesDir("get"),
PipelineID: 4567,
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
buildID = 42
planID = 56
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,
fakeResourceCacheFactory,
*plan.Get,
stepMetadata,
creds.NewVersionedResourceTypes(variables, plan.Get.VersionedResourceTypes),
containerMetadata,
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)
Expect(actualOwner).To(Equal(db.NewBuildStepContainerOwner(buildID, atc.PlanID(planID), teamID)))
_, _, actualOwner, actualContainerSpec, actualContainerMetadata, actualWorkerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
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,
ResourceTypes: creds.NewVersionedResourceTypes(variables, resourceTypes),
TeamID: stepMetadata.TeamID,
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() {
var fakeResourceCache *dbfakes.FakeUsedResourceCache
var fakeResourceConfig *dbfakes.FakeResourceConfig
Context("when the plan has a resource", func() {
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() {
Expect(fakeBuild.PipelineCallCount()).To(Equal(1))
})
Context("when finding the pipeline succeeds", func() {
var fakePipeline *dbfakes.FakePipeline
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"}))
})
It("saves a version for the resource", func() {
Expect(fakeDelegate.UpdateVersionCallCount()).To(Equal(1))
_, plan, info := fakeDelegate.UpdateVersionArgsForCall(0)
Expect(plan.Resource).To(Equal("some-pipeline-resource"))
Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
Expect(info.Metadata).To(Equal([]atc.MetadataField{{Name: "some", Value: "metadata"}}))
})
})
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() {
// TODO: this can be removed once /check returns metadata
Expect(fakeBuild.PipelineCallCount()).To(Equal(0))
It("does not save the version", func() {
Expect(fakeDelegate.UpdateVersionCallCount()).To(Equal(0))
})
})

View File

@ -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
resourceTypes creds.VersionedResourceTypes
versionInfo VersionInfo
succeeded bool
strategy worker.ContainerPlacementStrategy
resourceFactory resource.ResourceFactory
secrets creds.Secrets
resourceFactory resource.ResourceFactory
resourceConfigFactory db.ResourceConfigFactory
strategy worker.ContainerPlacementStrategy
pool worker.Pool
delegate PutDelegate
succeeded bool
}
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,
resourceTypes creds.VersionedResourceTypes,
strategy worker.ContainerPlacementStrategy,
secrets creds.Secrets,
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,
resourceTypes: resourceTypes,
strategy: strategy,
secrets: secrets,
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,
"job-id": step.build.JobID(),
"step-name": step.plan.Name,
"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,
TeamID: step.build.TeamID(),
Tags: step.plan.Tags,
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,
Tags: step.tags,
TeamID: step.build.TeamID(),
ResourceTypes: step.resourceTypes,
ResourceType: step.plan.Type,
Tags: step.plan.Tags,
TeamID: step.metadata.TeamID,
ResourceTypes: resourceTypes,
}
owner := db.NewBuildStepContainerOwner(step.build.ID(), step.planID, step.build.TeamID())
chosenWorker, err := step.pool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, step.strategy)
owner := db.NewBuildStepContainerOwner(step.metadata.BuildID, step.planID, step.metadata.TeamID)
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 != "" {
logger = logger.WithData(lager.Data{"step": step.name, "resource": step.resource, "resource-type": step.resourceType, "version": step.versionInfo.Version})
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
}
if step.plan.Resource != "" {
step.delegate.SaveOutput(logger, step.plan, source, resourceTypes, versionInfo)
}
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

View File

@ -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
stepMetadata testMetadata = []string{"a=1", "b=2"}
interpolatedResourceTypes atc.VersionedResourceTypes
containerMetadata = db.ContainerMetadata{
Type: db.ContainerTypePut,
StepName: "some-step",
WorkingDirectory: resource.ResourcesDir("put"),
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",
"source-param": "super-secret-source",
}
fakeSecretManager = new(credsfakes.FakeSecrets)
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,
"some-name",
"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,
plan.ID,
*plan.Put,
stepMetadata,
resourceTypes,
fakeStrategy,
containerMetadata,
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)
Expect(cm).To(Equal(containerMetadata))
_, _, delegate, owner, containerSpec, actualResourceTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
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)
Expect(actualResourceType).To(Equal("some-resource-type"))
_, plan, actualSource, actualResourceTypes, info := fakeDelegate.SaveOutputArgsForCall(0)
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(version).To(Equal(atc.Version{"some": "version"}))
Expect(metadata).To(Equal(db.NewResourceConfigMetadataFields([]atc.MetadataField{{"some", "metadata"}})))
Expect(outputName).To(Equal("some-name"))
Expect(resourceName).To(Equal("some-resource"))
Expect(actualResourceTypes).To(Equal(interpolatedResourceTypes))
Expect(info.Version).To(Equal(atc.Version{"some": "version"}))
Expect(info.Metadata).To(Equal([]atc.MetadataField{{"some", "metadata"}}))
})
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{

View File

@ -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

55
atc/exec/step_metadata.go Normal file
View File

@ -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
}

View File

@ -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",
}))
})
})
})
})

View File

@ -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
resourceTypes creds.VersionedResourceTypes
defaultLimits atc.ContainerLimits
succeeded bool
strategy worker.ContainerPlacementStrategy
secrets creds.Secrets
strategy worker.ContainerPlacementStrategy
workerPool worker.Pool
delegate TaskDelegate
succeeded bool
}
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,
resourceTypes creds.VersionedResourceTypes,
plan atc.TaskPlan,
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,
resourceTypes: resourceTypes,
plan: plan,
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,
"job-id": action.jobID,
"step-name": step.plan.Name,
"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() {
fmt.Fprintln(action.delegate.Stderr(), "[WARNING]", warning)
for _, warning := range taskConfigSource.Warnings() {
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)
chosenWorker, err := action.workerPool.FindOrChooseWorkerForContainer(logger, owner, containerSpec, workerSpec, action.strategy)
owner := db.NewBuildStepContainerOwner(step.metadata.BuildID, step.planID, step.metadata.TeamID)
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(),
Stderr: action.delegate.Stderr(),
Stdout: step.delegate.Stdout(),
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 {
return action.succeeded
func (step *TaskStep) Succeeded() bool {
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 != "" {
source, found := repository.SourceFor(artifact.Name(action.imageArtifactName))
if step.plan.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) {
imageSpec, err := action.imageSpec(logger, repository, config)
func (step *TaskStep) containerSpec(logger lager.Logger, repository *artifact.Repository, config atc.TaskConfig, metadata db.ContainerMetadata) (worker.ContainerSpec, error) {
imageSpec, err := step.imageSpec(logger, repository, config)
if err != nil {
return worker.ContainerSpec{}, err
}
containerSpec := worker.ContainerSpec{
Platform: config.Platform,
Tags: action.tags,
TeamID: action.teamID,
Tags: step.plan.Tags,
TeamID: step.metadata.TeamID,
ImageSpec: imageSpec,
Limits: worker.ContainerLimits(config.Limits),
User: config.Run.User,
Dir: action.artifactsRoot,
Env: action.envForParams(config.Params),
Dir: metadata.WorkingDirectory,
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,
TeamID: action.teamID,
Tags: step.plan.Tags,
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,
action.stepName,
step.metadata.JobID,
step.plan.Name,
cacheConfig.Path,
bool(action.privileged))
bool(step.plan.Privileged))
if err != nil {
return err
}

View File

@ -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
stderrBuf *gbytes.Buffer
fakeSecretManager *credsfakes.FakeSecrets
fakeDelegate *execfakes.FakeTaskDelegate
taskPlan *atc.TaskPlan
imageArtifactName string
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
interpolatedResourceTypes atc.VersionedResourceTypes
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()
stderrBuf = gbytes.NewBuffer()
fakeSecretManager = new(credsfakes.FakeSecrets)
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,
configSource,
tags,
inputMapping,
outputMapping,
"some-artifact-root",
imageArtifactName,
fakeDelegate,
fakePool,
teamID,
buildID,
jobID,
"some-task",
planID,
containerMetadata,
resourceTypes,
plan.ID,
*plan.Task,
atc.ContainerLimits{},
stepMetadata,
containerMetadata,
fakeSecretManager,
fakeStrategy,
fakePool,
fakeDelegate,
)
stepErr = taskStep.Run(ctx, state)
})
Context("when getting the config works", func() {
var fetchedConfig atc.TaskConfig
Context("when the plan has a config", func() {
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)
Expect(owner).To(Equal(db.NewBuildStepContainerOwner(buildID, planID, teamID)))
_, _, owner, containerSpec, createdMetadata, workerSpec, strategy := fakePool.FindOrChooseWorkerForContainerArgsForCall(0)
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(createdMetadata).To(Equal(db.ContainerMetadata{
Type: db.ContainerTypeTask,
StepName: "some-step",
}))
Expect(owner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, planID, stepMetadata.TeamID)))
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(createdMetadata).To(Equal(db.ContainerMetadata{
Type: db.ContainerTypeTask,
StepName: "some-step",
}))
Expect(owner).To(Equal(db.NewBuildStepContainerOwner(stepMetadata.BuildID, planID, stepMetadata.TeamID)))
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"}
configSource.FetchConfigReturns(atc.TaskConfig{
taskPlan.InputMapping = map[string]string{"remapped-input": "remapped-input-src"}
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() {
Expect(stepErr).ToNot(HaveOccurred())
Context("when task belongs to a job", func() {
BeforeEach(func() {
stepMetadata.JobID = 12
})
Expect(fakeVolume1.InitializeTaskCacheCallCount()).To(Equal(1))
_, jID, stepName, cachePath, p := fakeVolume1.InitializeTaskCacheArgsForCall(0)
Expect(jID).To(Equal(jobID))
Expect(stepName).To(Equal("some-task"))
Expect(cachePath).To(Equal("some-path-1"))
Expect(p).To(Equal(bool(privileged)))
It("registers cache volumes as task caches", func() {
Expect(stepErr).ToNot(HaveOccurred())
Expect(fakeVolume2.InitializeTaskCacheCallCount()).To(Equal(1))
_, jID, stepName, cachePath, p = fakeVolume2.InitializeTaskCacheArgsForCall(0)
Expect(jID).To(Equal(jobID))
Expect(stepName).To(Equal("some-task"))
Expect(cachePath).To(Equal("some-path-2"))
Expect(p).To(Equal(bool(privileged)))
Expect(fakeVolume1.InitializeTaskCacheCallCount()).To(Equal(1))
_, jID, stepName, cachePath, p := fakeVolume1.InitializeTaskCacheArgsForCall(0)
Expect(jID).To(Equal(stepMetadata.JobID))
Expect(stepName).To(Equal("some-task"))
Expect(cachePath).To(Equal("some-path-1"))
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"}
configSource.FetchConfigReturns(atc.TaskConfig{
taskPlan.OutputMapping = map[string]string{"generic-remapped-output": "specific-remapped-output"}
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"
configSource.FetchConfigReturns(fetchedConfig, nil)
taskPlan.Config.Run.Dir = "/some/dir"
})
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"
configSource.FetchConfigReturns(fetchedConfig, nil)
taskPlan.Config.Run.User = "some-user"
})
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() {
disaster := errors.New("nope")
Context("when missing the platform", func() {
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() {

View File

@ -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())

View File

@ -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{
versionedResourceType,
},
),
atc.VersionedResourceTypes{
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{
versionedResourceType,
},
),
atc.VersionedResourceTypes{
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{
versionedResourceType,
},
),
atc.VersionedResourceTypes{
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{
versionedResourceType,
},
),
atc.VersionedResourceTypes{
versionedResourceType,
},
)
Expect(err).NotTo(HaveOccurred())
})

View File

@ -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,
Max: 10 * time.Second,
Min: 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)

View File

@ -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,
Max: 10 * time.Minute,
Min: 5 * 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,
Max: 10 * time.Minute,
Min: 5 * 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()

View File

@ -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")

View File

@ -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 {

View File

@ -42,8 +42,8 @@ var _ = Describe("ResourceScanner", func() {
interval time.Duration
variables creds.Variables
fakeResourceType *dbfakes.FakeResourceType
versionedResourceType atc.VersionedResourceType
fakeResourceType *dbfakes.FakeResourceType
interpolatedResourceTypes atc.VersionedResourceTypes
scanner Scanner
@ -73,13 +73,15 @@ var _ = Describe("ResourceScanner", func() {
Tags: atc.Tags{"some-tag"},
}
versionedResourceType = atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-custom-resource",
Type: "registry-image",
Source: atc.Source{"custom": "((source-params))"},
interpolatedResourceTypes = atc.VersionedResourceTypes{
{
ResourceType: atc.ResourceType{
Name: "some-custom-resource",
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
})
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
})
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())

View File

@ -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()),
)

View File

@ -42,8 +42,8 @@ var _ = Describe("ResourceTypeScanner", func() {
interval time.Duration
variables creds.Variables
fakeResourceType *dbfakes.FakeResourceType
versionedResourceType atc.VersionedResourceType
fakeResourceType *dbfakes.FakeResourceType
interpolatedResourceTypes atc.VersionedResourceTypes
scanner Scanner
@ -58,14 +58,16 @@ var _ = Describe("ResourceTypeScanner", func() {
"source-params": "some-secret-sauce",
}
versionedResourceType = atc.VersionedResourceType{
ResourceType: atc.ResourceType{
Name: "some-custom-resource",
Type: "registry-image",
Source: atc.Source{"custom": "((source-params))"},
Tags: atc.Tags{"some-tag"},
interpolatedResourceTypes = atc.VersionedResourceTypes{
{
ResourceType: atc.ResourceType{
Name: "some-custom-resource",
Type: "registry-image",
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
})
})
@ -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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
_, 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{
versionedResourceType,
})))
Expect(resourceTypes).To(Equal(interpolatedResourceTypes))
})
})
@ -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))
})
})

View File

@ -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) {

View File

@ -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,
)

View File

@ -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,

View File

@ -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,
)

View File

@ -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{
"secret-custom": "source",
}
resourceTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
resourceTypes = 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{},

View File

@ -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),
)

View File

@ -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]

View File

@ -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]

View File

@ -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

View File

@ -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() {
}}))
})
})
})
})
})

View File

@ -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
}

View File

@ -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"))

View File

@ -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)

View File

@ -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),
db.ContainerMetadata{
Type: db.ContainerTypeCheck,
},
owner,
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),
db.ContainerMetadata{
Type: db.ContainerTypeCheck,
},
owner,
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
}

View File

@ -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))
cctx, _, delegate, owner, metadata, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
Expect(cctx).To(Equal(ctx))
Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
_, _, owner, metadata := fakeWorker.EnsureDBContainerExistsArgsForCall(0)
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))
cctx, _, delegate, owner, metadata, containerSpec, actualCustomTypes := fakeWorker.FindOrCreateContainerArgsForCall(0)
Expect(cctx).To(Equal(ctx))
Expect(owner).To(Equal(db.NewImageCheckContainerOwner(fakeCreatingContainer, 123)))
Expect(fakeWorker.EnsureDBContainerExistsCallCount()).To(Equal(1))
_, _, owner, metadata := fakeWorker.EnsureDBContainerExistsArgsForCall(0)
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())
})

View File

@ -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())
})

View File

@ -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]

View File

@ -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)
}

View File

@ -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,
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
clock: clock,
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 {
worker, err = strategy.Choose(logger, compatibleWorkers, containerSpec)
// pool is shared by all steps running in the system,
// 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,

View File

@ -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
fakeProvider *workerfakes.FakeWorkerProvider
pool Pool
fakeClock *fakeclock.FakeClock
logger *lagertest.TestLogger
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{
"secret-source": "super-secret-source",
}
resourceTypes = creds.NewVersionedResourceTypes(variables, atc.VersionedResourceTypes{
resourceTypes = 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))

View File

@ -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(ctx, logger, containerSpec.ImageSpec, containerSpec.TeamID, delegate, resourceTypes, creatingContainer)
fetchedImage, err := worker.fetchImageForContainer(
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 {
resourceTypesMap := make(map[string]creds.VersionedResourceType)
func determineUnderlyingTypeName(typeName string, resourceTypes atc.VersionedResourceTypes) string {
resourceTypesMap := make(map[string]atc.VersionedResourceType)
for _, resourceType := range resourceTypes {
resourceTypesMap[resourceType.Name] = resourceType
}

Some files were not shown because too many files have changed in this diff Show More