opensourcemirror
/
concourse
mirror of https://github.com/concourse/concourse.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Rename fewest-active-tasks to limit-active-tasks. 

Rename ModifyActiveTasks() to ModifiesActiveTasks().

Signed-off-by: Alessandro Degano <alessandro.degano@pix4d.com>
This commit is contained in:
Alessandro Degano 2019-07-17 10:50:04 +02:00
parent 32bf2c03a8
commit ab15b63bea
14 changed files with 179 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
atc/atccmd/command.go
View File

@ -115,8 +115,8 @@ type RunCommand struct {
ResourceCheckingInterval time.Duration `long:"resource-checking-interval" default:"1m" description:"Interval on which to check for new versions of resources."`
ResourceTypeCheckingInterval time.Duration `long:"resource-type-checking-interval" default:"1m" description:"Interval on which to check for new versions of resource types."`
ContainerPlacementStrategy string `long:"container-placement-strategy" default:"volume-locality" choice:"volume-locality" choice:"random" choice:"fewest-build-containers" choice:"fewest-active-tasks" description:"Method by which a worker is selected during container placement."`
MaxActiveTasksPerWorker int `long:"max-active-tasks-per-worker" default:"0" description:"Maximum allowed number of active build tasks per worker. Has effect only when used with fewest-active-tasks placement strategy. 0 means no limit."`
ContainerPlacementStrategy string `long:"container-placement-strategy" default:"volume-locality" choice:"volume-locality" choice:"random" choice:"fewest-build-containers" choice:"limit-active-tasks" description:"Method by which a worker is selected during container placement."`
MaxActiveTasksPerWorker int `long:"max-active-tasks-per-worker" default:"0" description:"Maximum allowed number of active build tasks per worker. Has effect only when used with limit-active-tasks placement strategy. 0 means no limit."`
BaggageclaimResponseHeaderTimeout time.Duration `long:"baggageclaim-response-header-timeout" default:"1m" description:"How long to wait for Baggageclaim to send the response header."`
CLIArtifactsDir flag.Dir `long:"cli-artifacts-dir" description:"Directory containing downloadable CLI binaries."`
@ -1193,8 +1193,8 @@ func (cmd *RunCommand) constructLockConn(driverName string) (*sql.DB, error) {
func (cmd *RunCommand) chooseBuildContainerStrategy() (worker.ContainerPlacementStrategy, error) {
var strategy worker.ContainerPlacementStrategy
if cmd.ContainerPlacementStrategy != "fewest-active-tasks" && cmd.MaxActiveTasksPerWorker != 0 {
return nil, errors.New("max-active-tasks-per-worker has only effect with fewest-active-tasks strategy")
if cmd.ContainerPlacementStrategy != "limit-active-tasks" && cmd.MaxActiveTasksPerWorker != 0 {
return nil, errors.New("max-active-tasks-per-worker has only effect with limit-active-tasks strategy")
}
if cmd.MaxActiveTasksPerWorker < 0 {
return nil, errors.New("max-active-tasks-per-worker must be greater or equal than 0")
@ -1204,8 +1204,8 @@ func (cmd *RunCommand) chooseBuildContainerStrategy() (worker.ContainerPlacement
strategy = worker.NewRandomPlacementStrategy()
case "fewest-build-containers":
strategy = worker.NewFewestBuildContainersPlacementStrategy()
case "fewest-active-tasks":
strategy = worker.NewFewestActiveTasksPlacementStrategy(cmd.MaxActiveTasksPerWorker)
case "limit-active-tasks":
strategy = worker.NewLimitActiveTasksPlacementStrategy(cmd.MaxActiveTasksPerWorker)
default:
strategy = worker.NewVolumeLocalityPlacementStrategy()
}

4
atc/exec/task_step.go
View File

@ -199,7 +199,7 @@ func (step *TaskStep) Run(ctx context.Context, state RunState) error {
var activeTasksLock lock.Lock
for {
if step.strategy.ModifyActiveTasks() {
if step.strategy.ModifiesActiveTasks() {
var acquired bool
activeTasksLock, acquired, err = step.lockFactory.Acquire(logger, lock.NewTaskStepLockID())
if err != nil {
@ -224,7 +224,7 @@ func (step *TaskStep) Run(ctx context.Context, state RunState) error {
return err
}
if step.strategy.ModifyActiveTasks() {
if step.strategy.ModifiesActiveTasks() {
if chosenWorker == nil {
logger.Info("no-worker-available")
err = activeTasksLock.Release()

33
atc/exec/task_step_test.go
View File

@ -183,7 +183,7 @@ var _ = Describe("TaskStep", func() {
}
})
Context("when 'fewest-active-tasks' strategy is chosen and a worker found", func() {
Context("when 'limit-active-tasks' strategy is chosen and a worker found", func() {
BeforeEach(func() {
fakeWorker.NameReturns("some-worker")
fakePool.FindOrChooseWorkerForContainerReturns(fakeWorker, nil)
@ -191,7 +191,7 @@ var _ = Describe("TaskStep", func() {
fakeContainer := new(workerfakes.FakeContainer)
fakeWorker.FindOrCreateContainerReturns(fakeContainer, nil)
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("increase the active tasks on the worker", func() {
Expect(fakeWorker.ActiveTasks()).To(Equal(1))
@ -1061,9 +1061,9 @@ var _ = Describe("TaskStep", func() {
})
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1186,9 +1186,9 @@ var _ = Describe("TaskStep", func() {
Expect(sourceMap).To(ConsistOf(artifactSource1, artifactSource2, artifactSource3))
})
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1581,9 +1581,9 @@ var _ = Describe("TaskStep", func() {
Expect(taskStep.Succeeded()).To(BeFalse())
})
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1606,9 +1606,9 @@ var _ = Describe("TaskStep", func() {
It("is not successful", func() {
Expect(taskStep.Succeeded()).To(BeFalse())
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1672,9 +1672,9 @@ var _ = Describe("TaskStep", func() {
sourceMap := repo.AsMap()
Expect(sourceMap).To(BeEmpty())
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1697,9 +1697,10 @@ var _ = Describe("TaskStep", func() {
It("is not successful", func() {
Expect(taskStep.Succeeded()).To(BeFalse())
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {
@ -1724,9 +1725,9 @@ var _ = Describe("TaskStep", func() {
It("is not successful", func() {
Expect(taskStep.Succeeded()).To(BeFalse())
})
Context("when 'fewest-active-tasks' strategy is chosen", func() {
Context("when 'limit-active-tasks' strategy is chosen", func() {
BeforeEach(func() {
fakeStrategy.ModifyActiveTasksReturns(true)
fakeStrategy.ModifiesActiveTasksReturns(true)
})
It("decrements the active tasks counter on the worker", func() {

14
atc/pipelines/pipelinesfakes/fake_radar_scheduler_factory.go
View File

@ -4,7 +4,7 @@ package pipelinesfakes
import (
"sync"
"github.com/concourse/concourse/atc/creds"
"github.com/cloudfoundry/bosh-cli/director/template"
"github.com/concourse/concourse/atc/db"
"github.com/concourse/concourse/atc/pipelines"
"github.com/concourse/concourse/atc/radar"
@ -12,12 +12,12 @@ import (
)
type FakeRadarSchedulerFactory struct {
BuildScanRunnerFactoryStub func(db.Pipeline, string, creds.Variables, radar.Notifications) radar.ScanRunnerFactory
BuildScanRunnerFactoryStub func(db.Pipeline, string, template.Variables, radar.Notifications) radar.ScanRunnerFactory
buildScanRunnerFactoryMutex sync.RWMutex
buildScanRunnerFactoryArgsForCall []struct {
arg1 db.Pipeline
arg2 string
arg3 creds.Variables
arg3 template.Variables
arg4 radar.Notifications
}
buildScanRunnerFactoryReturns struct {
@ -41,13 +41,13 @@ type FakeRadarSchedulerFactory struct {
invocationsMutex sync.RWMutex
}
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactory(arg1 db.Pipeline, arg2 string, arg3 creds.Variables, arg4 radar.Notifications) radar.ScanRunnerFactory {
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactory(arg1 db.Pipeline, arg2 string, arg3 template.Variables, arg4 radar.Notifications) radar.ScanRunnerFactory {
fake.buildScanRunnerFactoryMutex.Lock()
ret, specificReturn := fake.buildScanRunnerFactoryReturnsOnCall[len(fake.buildScanRunnerFactoryArgsForCall)]
fake.buildScanRunnerFactoryArgsForCall = append(fake.buildScanRunnerFactoryArgsForCall, struct {
arg1 db.Pipeline
arg2 string
arg3 creds.Variables
arg3 template.Variables
arg4 radar.Notifications
}{arg1, arg2, arg3, arg4})
fake.recordInvocation("BuildScanRunnerFactory", []interface{}{arg1, arg2, arg3, arg4})
@ -68,13 +68,13 @@ func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactoryCallCount() int {
return len(fake.buildScanRunnerFactoryArgsForCall)
}
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactoryCalls(stub func(db.Pipeline, string, creds.Variables, radar.Notifications) radar.ScanRunnerFactory) {
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactoryCalls(stub func(db.Pipeline, string, template.Variables, radar.Notifications) radar.ScanRunnerFactory) {
fake.buildScanRunnerFactoryMutex.Lock()
defer fake.buildScanRunnerFactoryMutex.Unlock()
fake.BuildScanRunnerFactoryStub = stub
}
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactoryArgsForCall(i int) (db.Pipeline, string, creds.Variables, radar.Notifications) {
func (fake *FakeRadarSchedulerFactory) BuildScanRunnerFactoryArgsForCall(i int) (db.Pipeline, string, template.Variables, radar.Notifications) {
fake.buildScanRunnerFactoryMutex.RLock()
defer fake.buildScanRunnerFactoryMutex.RUnlock()
argsForCall := fake.buildScanRunnerFactoryArgsForCall[i]

26
atc/worker/image/imagefakes/fake_image_resource_fetcher.go
View File

@ -2,15 +2,15 @@
package imagefakes
import (
context "context"
io "io"
sync "sync"
"context"
"io"
"sync"
lager "code.cloudfoundry.org/lager"
atc "github.com/concourse/concourse/atc"
db "github.com/concourse/concourse/atc/db"
worker "github.com/concourse/concourse/atc/worker"
image "github.com/concourse/concourse/atc/worker/image"
"code.cloudfoundry.org/lager"
"github.com/concourse/concourse/atc"
"github.com/concourse/concourse/atc/db"
"github.com/concourse/concourse/atc/worker"
"github.com/concourse/concourse/atc/worker/image"
)
type FakeImageResourceFetcher struct {
@ -65,6 +65,12 @@ func (fake *FakeImageResourceFetcher) FetchCallCount() int {
return len(fake.fetchArgsForCall)
}
func (fake *FakeImageResourceFetcher) FetchCalls(stub func(context.Context, lager.Logger, db.CreatingContainer, bool) (worker.Volume, io.ReadCloser, atc.Version, error)) {
fake.fetchMutex.Lock()
defer fake.fetchMutex.Unlock()
fake.FetchStub = stub
}
func (fake *FakeImageResourceFetcher) FetchArgsForCall(i int) (context.Context, lager.Logger, db.CreatingContainer, bool) {
fake.fetchMutex.RLock()
defer fake.fetchMutex.RUnlock()
@ -73,6 +79,8 @@ func (fake *FakeImageResourceFetcher) FetchArgsForCall(i int) (context.Context,
}
func (fake *FakeImageResourceFetcher) FetchReturns(result1 worker.Volume, result2 io.ReadCloser, result3 atc.Version, result4 error) {
fake.fetchMutex.Lock()
defer fake.fetchMutex.Unlock()
fake.FetchStub = nil
fake.fetchReturns = struct {
result1 worker.Volume
@ -83,6 +91,8 @@ func (fake *FakeImageResourceFetcher) FetchReturns(result1 worker.Volume, result
}
func (fake *FakeImageResourceFetcher) FetchReturnsOnCall(i int, result1 worker.Volume, result2 io.ReadCloser, result3 atc.Version, result4 error) {
fake.fetchMutex.Lock()
defer fake.fetchMutex.Unlock()
fake.FetchStub = nil
if fake.fetchReturnsOnCall == nil {
fake.fetchReturnsOnCall = make(map[int]struct {

18
atc/worker/image/imagefakes/fake_image_resource_fetcher_factory.go
View File

@ -2,11 +2,11 @@
package imagefakes
import (
sync "sync"
"sync"
atc "github.com/concourse/concourse/atc"
worker "github.com/concourse/concourse/atc/worker"
image "github.com/concourse/concourse/atc/worker/image"
"github.com/concourse/concourse/atc"
"github.com/concourse/concourse/atc/worker"
"github.com/concourse/concourse/atc/worker/image"
)
type FakeImageResourceFetcherFactory struct {
@ -59,6 +59,12 @@ func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherCallCount()
return len(fake.newImageResourceFetcherArgsForCall)
}
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, atc.VersionedResourceTypes, worker.ImageFetchingDelegate) {
fake.newImageResourceFetcherMutex.RLock()
defer fake.newImageResourceFetcherMutex.RUnlock()
@ -67,6 +73,8 @@ func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherArgsForCall(
}
func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherReturns(result1 image.ImageResourceFetcher) {
fake.newImageResourceFetcherMutex.Lock()
defer fake.newImageResourceFetcherMutex.Unlock()
fake.NewImageResourceFetcherStub = nil
fake.newImageResourceFetcherReturns = struct {
result1 image.ImageResourceFetcher
@ -74,6 +82,8 @@ func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherReturns(resu
}
func (fake *FakeImageResourceFetcherFactory) NewImageResourceFetcherReturnsOnCall(i int, result1 image.ImageResourceFetcher) {
fake.newImageResourceFetcherMutex.Lock()
defer fake.newImageResourceFetcherMutex.Unlock()
fake.NewImageResourceFetcherStub = nil
if fake.newImageResourceFetcherReturnsOnCall == nil {
fake.newImageResourceFetcherReturnsOnCall = make(map[int]struct {

18
atc/worker/placement.go
View File

@ -12,7 +12,7 @@ type ContainerPlacementStrategy interface {
//TODO: Don't pass around container metadata since it's not guaranteed to be deterministic.
// Change this after check containers stop being reused
Choose(lager.Logger, []Worker, ContainerSpec) (Worker, error)
ModifyActiveTasks() bool
ModifiesActiveTasks() bool
}
type VolumeLocalityPlacementStrategy struct {
@ -54,7 +54,7 @@ func (strategy *VolumeLocalityPlacementStrategy) Choose(logger lager.Logger, wor
return highestLocalityWorkers[strategy.rand.Intn(len(highestLocalityWorkers))], nil
}
func (strategy *VolumeLocalityPlacementStrategy) ModifyActiveTasks() bool {
func (strategy *VolumeLocalityPlacementStrategy) ModifiesActiveTasks() bool {
return false
}
@ -84,23 +84,23 @@ func (strategy *FewestBuildContainersPlacementStrategy) Choose(logger lager.Logg
return leastBusyWorkers[strategy.rand.Intn(len(leastBusyWorkers))], nil
}
func (strategy *FewestBuildContainersPlacementStrategy) ModifyActiveTasks() bool {
func (strategy *FewestBuildContainersPlacementStrategy) ModifiesActiveTasks() bool {
return false
}
type FewestActiveTasksPlacementStrategy struct {
type LimitActiveTasksPlacementStrategy struct {
rand *rand.Rand
maxTasks int
}
func NewFewestActiveTasksPlacementStrategy(maxTasks int) ContainerPlacementStrategy {
return &FewestActiveTasksPlacementStrategy{
func NewLimitActiveTasksPlacementStrategy(maxTasks int) ContainerPlacementStrategy {
return &LimitActiveTasksPlacementStrategy{
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
maxTasks: maxTasks,
}
}
func (strategy *FewestActiveTasksPlacementStrategy) Choose(logger lager.Logger, workers []Worker, spec ContainerSpec) (Worker, error) {
func (strategy *LimitActiveTasksPlacementStrategy) Choose(logger lager.Logger, workers []Worker, spec ContainerSpec) (Worker, error) {
workersByWork := map[int][]Worker{}
minActiveTasks := -1
@ -130,7 +130,7 @@ func (strategy *FewestActiveTasksPlacementStrategy) Choose(logger lager.Logger,
return leastBusyWorkers[strategy.rand.Intn(len(leastBusyWorkers))], nil
}
func (strategy *FewestActiveTasksPlacementStrategy) ModifyActiveTasks() bool {
func (strategy *LimitActiveTasksPlacementStrategy) ModifiesActiveTasks() bool {
return true
}
@ -148,6 +148,6 @@ func (strategy *RandomPlacementStrategy) Choose(logger lager.Logger, workers []W
return workers[strategy.rand.Intn(len(workers))], nil
}
func (strategy *RandomPlacementStrategy) ModifyActiveTasks() bool {
func (strategy *RandomPlacementStrategy) ModifiesActiveTasks() bool {
return false
}

6
atc/worker/placement_test.go
View File

@ -306,7 +306,7 @@ var _ = Describe("RandomPlacementStrategy", func() {
})
})
var _ = Describe("FewestActiveTasksPlacementStrategy", func() {
var _ = Describe("LimitActiveTasksPlacementStrategy", func() {
Describe("Choose", func() {
var compatibleWorker1 *workerfakes.FakeWorker
var compatibleWorker2 *workerfakes.FakeWorker
@ -314,7 +314,7 @@ var _ = Describe("FewestActiveTasksPlacementStrategy", func() {
BeforeEach(func() {
logger = lagertest.NewTestLogger("active-tasks-equal-placement-test")
strategy = NewFewestActiveTasksPlacementStrategy(0)
strategy = NewLimitActiveTasksPlacementStrategy(0)
compatibleWorker1 = new(workerfakes.FakeWorker)
compatibleWorker2 = new(workerfakes.FakeWorker)
compatibleWorker3 = new(workerfakes.FakeWorker)
@ -390,7 +390,7 @@ var _ = Describe("FewestActiveTasksPlacementStrategy", func() {
})
Context("when max-tasks-per-worker is set to 1", func() {
BeforeEach(func() {
strategy = NewFewestActiveTasksPlacementStrategy(1)
strategy = NewLimitActiveTasksPlacementStrategy(1)
})
Context("when there are multiple workers", func() {
BeforeEach(func() {

24
atc/worker/transport/transportfakes/fake_read_closer.go
View File

@ -2,9 +2,9 @@
package transportfakes
import (
sync "sync"
"sync"
transport "github.com/concourse/concourse/atc/worker/transport"
"github.com/concourse/concourse/atc/worker/transport"
)
type FakeReadCloser struct {
@ -58,7 +58,15 @@ func (fake *FakeReadCloser) CloseCallCount() int {
return len(fake.closeArgsForCall)
}
func (fake *FakeReadCloser) CloseCalls(stub func() error) {
fake.closeMutex.Lock()
defer fake.closeMutex.Unlock()
fake.CloseStub = stub
}
func (fake *FakeReadCloser) CloseReturns(result1 error) {
fake.closeMutex.Lock()
defer fake.closeMutex.Unlock()
fake.CloseStub = nil
fake.closeReturns = struct {
result1 error
@ -66,6 +74,8 @@ func (fake *FakeReadCloser) CloseReturns(result1 error) {
}
func (fake *FakeReadCloser) CloseReturnsOnCall(i int, result1 error) {
fake.closeMutex.Lock()
defer fake.closeMutex.Unlock()
fake.CloseStub = nil
if fake.closeReturnsOnCall == nil {
fake.closeReturnsOnCall = make(map[int]struct {
@ -106,6 +116,12 @@ func (fake *FakeReadCloser) ReadCallCount() int {
return len(fake.readArgsForCall)
}
func (fake *FakeReadCloser) ReadCalls(stub func([]byte) (int, error)) {
fake.readMutex.Lock()
defer fake.readMutex.Unlock()
fake.ReadStub = stub
}
func (fake *FakeReadCloser) ReadArgsForCall(i int) []byte {
fake.readMutex.RLock()
defer fake.readMutex.RUnlock()
@ -114,6 +130,8 @@ func (fake *FakeReadCloser) ReadArgsForCall(i int) []byte {
}
func (fake *FakeReadCloser) ReadReturns(result1 int, result2 error) {
fake.readMutex.Lock()
defer fake.readMutex.Unlock()
fake.ReadStub = nil
fake.readReturns = struct {
result1 int
@ -122,6 +140,8 @@ func (fake *FakeReadCloser) ReadReturns(result1 int, result2 error) {
}
func (fake *FakeReadCloser) ReadReturnsOnCall(i int, result1 int, result2 error) {
fake.readMutex.Lock()
defer fake.readMutex.Unlock()
fake.ReadStub = nil
if fake.readReturnsOnCall == nil {
fake.readReturnsOnCall = make(map[int]struct {

20
atc/worker/transport/transportfakes/fake_request_generator.go
View File

@ -2,12 +2,12 @@
package transportfakes
import (
io "io"
http "net/http"
sync "sync"
"io"
"net/http"
"sync"
transport "github.com/concourse/concourse/atc/worker/transport"
rata "github.com/tedsuo/rata"
"github.com/concourse/concourse/atc/worker/transport"
"github.com/tedsuo/rata"
)
type FakeRequestGenerator struct {
@ -56,6 +56,12 @@ func (fake *FakeRequestGenerator) CreateRequestCallCount() int {
return len(fake.createRequestArgsForCall)
}
func (fake *FakeRequestGenerator) CreateRequestCalls(stub func(string, rata.Params, io.Reader) (*http.Request, error)) {
fake.createRequestMutex.Lock()
defer fake.createRequestMutex.Unlock()
fake.CreateRequestStub = stub
}
func (fake *FakeRequestGenerator) CreateRequestArgsForCall(i int) (string, rata.Params, io.Reader) {
fake.createRequestMutex.RLock()
defer fake.createRequestMutex.RUnlock()
@ -64,6 +70,8 @@ func (fake *FakeRequestGenerator) CreateRequestArgsForCall(i int) (string, rata.
}
func (fake *FakeRequestGenerator) CreateRequestReturns(result1 *http.Request, result2 error) {
fake.createRequestMutex.Lock()
defer fake.createRequestMutex.Unlock()
fake.CreateRequestStub = nil
fake.createRequestReturns = struct {
result1 *http.Request
@ -72,6 +80,8 @@ func (fake *FakeRequestGenerator) CreateRequestReturns(result1 *http.Request, re
}
func (fake *FakeRequestGenerator) CreateRequestReturnsOnCall(i int, result1 *http.Request, result2 error) {
fake.createRequestMutex.Lock()
defer fake.createRequestMutex.Unlock()
fake.CreateRequestStub = nil
if fake.createRequestReturnsOnCall == nil {
fake.createRequestReturnsOnCall = make(map[int]struct {

16
atc/worker/transport/transportfakes/fake_round_tripper.go
View File

@ -2,10 +2,10 @@
package transportfakes
import (
http "net/http"
sync "sync"
"net/http"
"sync"
transport "github.com/concourse/concourse/atc/worker/transport"
"github.com/concourse/concourse/atc/worker/transport"
)
type FakeRoundTripper struct {
@ -50,6 +50,12 @@ func (fake *FakeRoundTripper) RoundTripCallCount() int {
return len(fake.roundTripArgsForCall)
}
func (fake *FakeRoundTripper) RoundTripCalls(stub func(*http.Request) (*http.Response, error)) {
fake.roundTripMutex.Lock()
defer fake.roundTripMutex.Unlock()
fake.RoundTripStub = stub
}
func (fake *FakeRoundTripper) RoundTripArgsForCall(i int) *http.Request {
fake.roundTripMutex.RLock()
defer fake.roundTripMutex.RUnlock()
@ -58,6 +64,8 @@ func (fake *FakeRoundTripper) RoundTripArgsForCall(i int) *http.Request {
}
func (fake *FakeRoundTripper) RoundTripReturns(result1 *http.Response, result2 error) {
fake.roundTripMutex.Lock()
defer fake.roundTripMutex.Unlock()
fake.RoundTripStub = nil
fake.roundTripReturns = struct {
result1 *http.Response
@ -66,6 +74,8 @@ func (fake *FakeRoundTripper) RoundTripReturns(result1 *http.Response, result2 e
}
func (fake *FakeRoundTripper) RoundTripReturnsOnCall(i int, result1 *http.Response, result2 error) {
fake.roundTripMutex.Lock()
defer fake.roundTripMutex.Unlock()
fake.RoundTripStub = nil
if fake.roundTripReturnsOnCall == nil {
fake.roundTripReturnsOnCall = make(map[int]struct {

16
atc/worker/transport/transportfakes/fake_transport_db.go
View File

@ -2,10 +2,10 @@
package transportfakes
import (
sync "sync"
"sync"
db "github.com/concourse/concourse/atc/db"
transport "github.com/concourse/concourse/atc/worker/transport"
"github.com/concourse/concourse/atc/db"
"github.com/concourse/concourse/atc/worker/transport"
)
type FakeTransportDB struct {
@ -52,6 +52,12 @@ func (fake *FakeTransportDB) GetWorkerCallCount() int {
return len(fake.getWorkerArgsForCall)
}
func (fake *FakeTransportDB) GetWorkerCalls(stub func(string) (db.Worker, bool, error)) {
fake.getWorkerMutex.Lock()
defer fake.getWorkerMutex.Unlock()
fake.GetWorkerStub = stub
}
func (fake *FakeTransportDB) GetWorkerArgsForCall(i int) string {
fake.getWorkerMutex.RLock()
defer fake.getWorkerMutex.RUnlock()
@ -60,6 +66,8 @@ func (fake *FakeTransportDB) GetWorkerArgsForCall(i int) string {
}
func (fake *FakeTransportDB) GetWorkerReturns(result1 db.Worker, result2 bool, result3 error) {
fake.getWorkerMutex.Lock()
defer fake.getWorkerMutex.Unlock()
fake.GetWorkerStub = nil
fake.getWorkerReturns = struct {
result1 db.Worker
@ -69,6 +77,8 @@ func (fake *FakeTransportDB) GetWorkerReturns(result1 db.Worker, result2 bool, r
}
func (fake *FakeTransportDB) GetWorkerReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) {
fake.getWorkerMutex.Lock()
defer fake.getWorkerMutex.Unlock()
fake.GetWorkerStub = nil
if fake.getWorkerReturnsOnCall == nil {
fake.getWorkerReturnsOnCall = make(map[int]struct {

72
atc/worker/workerfakes/fake_container_placement_strategy.go
View File

@ -24,14 +24,14 @@ type FakeContainerPlacementStrategy struct {
result1 worker.Worker
result2 error
}
ModifyActiveTasksStub func() bool
modifyActiveTasksMutex sync.RWMutex
modifyActiveTasksArgsForCall []struct {
ModifiesActiveTasksStub func() bool
modifiesActiveTasksMutex sync.RWMutex
modifiesActiveTasksArgsForCall []struct {
}
modifyActiveTasksReturns struct {
modifiesActiveTasksReturns struct {
result1 bool
}
modifyActiveTasksReturnsOnCall map[int]struct {
modifiesActiveTasksReturnsOnCall map[int]struct {
result1 bool
}
invocations map[string][][]interface{}
@ -108,54 +108,54 @@ func (fake *FakeContainerPlacementStrategy) ChooseReturnsOnCall(i int, result1 w
}{result1, result2}
}
func (fake *FakeContainerPlacementStrategy) ModifyActiveTasks() bool {
fake.modifyActiveTasksMutex.Lock()
ret, specificReturn := fake.modifyActiveTasksReturnsOnCall[len(fake.modifyActiveTasksArgsForCall)]
fake.modifyActiveTasksArgsForCall = append(fake.modifyActiveTasksArgsForCall, struct {
func (fake *FakeContainerPlacementStrategy) ModifiesActiveTasks() bool {
fake.modifiesActiveTasksMutex.Lock()
ret, specificReturn := fake.modifiesActiveTasksReturnsOnCall[len(fake.modifiesActiveTasksArgsForCall)]
fake.modifiesActiveTasksArgsForCall = append(fake.modifiesActiveTasksArgsForCall, struct {
}{})
fake.recordInvocation("ModifyActiveTasks", []interface{}{})
fake.modifyActiveTasksMutex.Unlock()
if fake.ModifyActiveTasksStub != nil {
return fake.ModifyActiveTasksStub()
fake.recordInvocation("ModifiesActiveTasks", []interface{}{})
fake.modifiesActiveTasksMutex.Unlock()
if fake.ModifiesActiveTasksStub != nil {
return fake.ModifiesActiveTasksStub()
}
if specificReturn {
return ret.result1
}
fakeReturns := fake.modifyActiveTasksReturns
fakeReturns := fake.modifiesActiveTasksReturns
return fakeReturns.result1
}
func (fake *FakeContainerPlacementStrategy) ModifyActiveTasksCallCount() int {
fake.modifyActiveTasksMutex.RLock()
defer fake.modifyActiveTasksMutex.RUnlock()
return len(fake.modifyActiveTasksArgsForCall)
func (fake *FakeContainerPlacementStrategy) ModifiesActiveTasksCallCount() int {
fake.modifiesActiveTasksMutex.RLock()
defer fake.modifiesActiveTasksMutex.RUnlock()
return len(fake.modifiesActiveTasksArgsForCall)
}
func (fake *FakeContainerPlacementStrategy) ModifyActiveTasksCalls(stub func() bool) {
fake.modifyActiveTasksMutex.Lock()
defer fake.modifyActiveTasksMutex.Unlock()
fake.ModifyActiveTasksStub = stub
func (fake *FakeContainerPlacementStrategy) ModifiesActiveTasksCalls(stub func() bool) {
fake.modifiesActiveTasksMutex.Lock()
defer fake.modifiesActiveTasksMutex.Unlock()
fake.ModifiesActiveTasksStub = stub
}
func (fake *FakeContainerPlacementStrategy) ModifyActiveTasksReturns(result1 bool) {
fake.modifyActiveTasksMutex.Lock()
defer fake.modifyActiveTasksMutex.Unlock()
fake.ModifyActiveTasksStub = nil
fake.modifyActiveTasksReturns = struct {
func (fake *FakeContainerPlacementStrategy) ModifiesActiveTasksReturns(result1 bool) {
fake.modifiesActiveTasksMutex.Lock()
defer fake.modifiesActiveTasksMutex.Unlock()
fake.ModifiesActiveTasksStub = nil
fake.modifiesActiveTasksReturns = struct {
result1 bool
}{result1}
}
func (fake *FakeContainerPlacementStrategy) ModifyActiveTasksReturnsOnCall(i int, result1 bool) {
fake.modifyActiveTasksMutex.Lock()
defer fake.modifyActiveTasksMutex.Unlock()
fake.ModifyActiveTasksStub = nil
if fake.modifyActiveTasksReturnsOnCall == nil {
fake.modifyActiveTasksReturnsOnCall = make(map[int]struct {
func (fake *FakeContainerPlacementStrategy) ModifiesActiveTasksReturnsOnCall(i int, result1 bool) {
fake.modifiesActiveTasksMutex.Lock()
defer fake.modifiesActiveTasksMutex.Unlock()
fake.ModifiesActiveTasksStub = nil
if fake.modifiesActiveTasksReturnsOnCall == nil {
fake.modifiesActiveTasksReturnsOnCall = make(map[int]struct {
result1 bool
})
}
fake.modifyActiveTasksReturnsOnCall[i] = struct {
fake.modifiesActiveTasksReturnsOnCall[i] = struct {
result1 bool
}{result1}
}
@ -165,8 +165,8 @@ func (fake *FakeContainerPlacementStrategy) Invocations() map[string][][]interfa
defer fake.invocationsMutex.RUnlock()
fake.chooseMutex.RLock()
defer fake.chooseMutex.RUnlock()
fake.modifyActiveTasksMutex.RLock()
defer fake.modifyActiveTasksMutex.RUnlock()
fake.modifiesActiveTasksMutex.RLock()
defer fake.modifiesActiveTasksMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value

8
go-concourse/concourse/concoursefakes/fake_team.go
View File

@ -2,11 +2,11 @@
package concoursefakes
import (
io "io"
sync "sync"
"io"
"sync"
atc "github.com/concourse/concourse/atc"
concourse "github.com/concourse/concourse/go-concourse/concourse"
"github.com/concourse/concourse/atc"
"github.com/concourse/concourse/go-concourse/concourse"
)
type FakeTeam struct {