func (rsf *radarSchedulerFactory) BuildScheduler(pipelineDB db.PipelineDB) scheduler.BuildScheduler {
radar := rsf.BuildRadar(pipelineDB)
return &scheduler.Scheduler{
PipelineDB: pipelineDB,
BuildsDB: rsf.db,
Factory: factory.NewBuildFactory(
pipelineDB.GetPipelineName(),
atc.NewPlanFactory(time.Now().Unix()),
),
Engine: rsf.engine,
Scanner: radar,
}
}
FOO: bar
BAZ: buzz
X: 1
run:
path: find
args: [.]
`),
0644,
)
Expect(err).NotTo(HaveOccurred())
streaming = make(chan struct{})
events = make(chan atc.Event)
planFactory := atc.NewPlanFactory(0)
expectedPlan = planFactory.NewPlan(atc.DoPlan{
planFactory.NewPlan(atc.AggregatePlan{
planFactory.NewPlan(atc.GetPlan{
Name: filepath.Base(buildDir),
Type: "archive",
Source: atc.Source{
"uri": atcServer.URL() + "/api/v1/pipes/some-pipe-id",
},
}),
}),
planFactory.NewPlan(atc.TaskPlan{
Name: "one-off",
Config: &atc.TaskConfig{
Platform: "some-platform",
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Factory Retry Step", func() {
var (
resourceTypes atc.ResourceTypes
buildFactory factory.BuildFactory
actualPlanFactory atc.PlanFactory
expectedPlanFactory atc.PlanFactory
)
BeforeEach(func() {
actualPlanFactory = atc.NewPlanFactory(123)
expectedPlanFactory = atc.NewPlanFactory(123)
buildFactory = factory.NewBuildFactory("some-pipeline", actualPlanFactory)
resourceTypes = atc.ResourceTypes{
{
Name: "some-custom-resource",
Type: "docker-image",
Source: atc.Source{"some": "custom-source"},
},
}
})
Context("when there is a task annotated with 'attempts'", func() {
It("builds correctly", func() {
actual, err := buildFactory.Create(atc.JobConfig{
func CreateBuild(
client concourse.Client,
privileged bool,
inputs []Input,
outputs []Output,
config atc.TaskConfig,
tags []string,
target rc.TargetName,
) (atc.Build, error) {
fact := atc.NewPlanFactory(time.Now().Unix())
if err := config.Validate(); err != nil {
return atc.Build{}, err
}
targetProps, err := rc.SelectTarget(target)
if err != nil {
return atc.Build{}, err
}
buildInputs := atc.AggregatePlan{}
for _, input := range inputs {
var getPlan atc.GetPlan
if input.Path != "" {
source := atc.Source{
"uri": input.Pipe.ReadURL,
}
if auth, ok := targetAuthorization(targetProps.Token); ok {
source["authorization"] = auth
}
getPlan = atc.GetPlan{
Name: input.Name,
Type: "archive",
Source: source,
}
} else {
getPlan = atc.GetPlan{
Name: input.Name,
Type: input.BuildInput.Type,
Source: input.BuildInput.Source,
Version: input.BuildInput.Version,
Params: input.BuildInput.Params,
Tags: input.BuildInput.Tags,
}
}
buildInputs = append(buildInputs, fact.NewPlan(getPlan))
}
taskPlan := fact.NewPlan(atc.TaskPlan{
Name: "one-off",
Privileged: privileged,
Config: &config,
})
if len(tags) != 0 {
taskPlan.Task.Tags = tags
}
buildOutputs := atc.AggregatePlan{}
for _, output := range outputs {
source := atc.Source{
"uri": output.Pipe.ReadURL,
}
params := atc.Params{
"directory": output.Name,
}
if auth, ok := targetAuthorization(targetProps.Token); ok {
source["authorization"] = auth
}
buildOutputs = append(buildOutputs, fact.NewPlan(atc.PutPlan{
Name: output.Name,
Type: "archive",
Source: source,
Params: params,
}))
}
var plan atc.Plan
if len(buildOutputs) == 0 {
plan = fact.NewPlan(atc.DoPlan{
fact.NewPlan(buildInputs),
taskPlan,
})
} else {
plan = fact.NewPlan(atc.EnsurePlan{
Step: fact.NewPlan(atc.DoPlan{
fact.NewPlan(buildInputs),
taskPlan,
}),
Next: fact.NewPlan(buildOutputs),
})
}
return client.CreateBuild(plan)
}
inputStep.ResultStub = successResult(true)
inputStepFactory.UsingReturns(inputStep)
fakeFactory.GetReturns(inputStepFactory)
})
Context("constructing steps", func() {
var (
fakeDelegate *fakes.FakeBuildDelegate
fakeInputDelegate *execfakes.FakeGetDelegate
fakeExecutionDelegate *execfakes.FakeTaskDelegate
inputPlan atc.Plan
planFactory atc.PlanFactory
)
BeforeEach(func() {
planFactory = atc.NewPlanFactory(123)
fakeDelegate = new(fakes.FakeBuildDelegate)
fakeDelegateFactory.DelegateReturns(fakeDelegate)
fakeInputDelegate = new(execfakes.FakeGetDelegate)
fakeDelegate.InputDelegateReturns(fakeInputDelegate)
fakeExecutionDelegate = new(execfakes.FakeTaskDelegate)
fakeDelegate.ExecutionDelegateReturns(fakeExecutionDelegate)
inputPlan = planFactory.NewPlan(atc.GetPlan{
Name: "some-input",
Pipeline: "some-pipeline",
})
plan := planFactory.NewPlan(atc.TryPlan{
func CreateBuild(
atcRequester *deprecated.AtcRequester,
client concourse.Client,
privileged bool,
inputs []Input,
outputs []Output,
config atc.TaskConfig,
tags []string,
target string,
) (atc.Build, error) {
fact := atc.NewPlanFactory(time.Now().Unix())
if err := config.Validate(); err != nil {
return atc.Build{}, err
}
targetProps, err := rc.SelectTarget(target)
if err != nil {
return atc.Build{}, err
}
buildInputs := atc.AggregatePlan{}
for _, input := range inputs {
var getPlan atc.GetPlan
if input.Path != "" {
readPipe, err := atcRequester.CreateRequest(
atc.ReadPipe,
rata.Params{"pipe_id": input.Pipe.ID},
nil,
)
if err != nil {
return atc.Build{}, err
}
source := atc.Source{
"uri": readPipe.URL.String(),
}
if targetProps.Token != nil {
source["authorization"] = targetProps.Token.Type + " " + targetProps.Token.Value
}
getPlan = atc.GetPlan{
Name: input.Name,
Type: "archive",
Source: source,
}
} else {
getPlan = atc.GetPlan{
Name: input.Name,
Type: input.BuildInput.Type,
Source: input.BuildInput.Source,
Version: input.BuildInput.Version,
Params: input.BuildInput.Params,
Tags: input.BuildInput.Tags,
}
}
buildInputs = append(buildInputs, fact.NewPlan(getPlan))
}
taskPlan := fact.NewPlan(atc.TaskPlan{
Name: "one-off",
Privileged: privileged,
Config: &config,
})
if len(tags) != 0 {
taskPlan.Task.Tags = tags
}
buildOutputs := atc.AggregatePlan{}
for _, output := range outputs {
writePipe, err := atcRequester.CreateRequest(
atc.WritePipe,
rata.Params{"pipe_id": output.Pipe.ID},
nil,
)
if err != nil {
return atc.Build{}, err
}
source := atc.Source{
"uri": writePipe.URL.String(),
}
params := atc.Params{
"directory": output.Name,
}
if targetProps.Token != nil {
source["authorization"] = targetProps.Token.Type + " " + targetProps.Token.Value
}
buildOutputs = append(buildOutputs, fact.NewPlan(atc.PutPlan{
Name: output.Name,
Type: "archive",
Source: source,
Params: params,
}))
}
var plan atc.Plan
if len(buildOutputs) == 0 {
plan = fact.NewPlan(atc.DoPlan{
fact.NewPlan(buildInputs),
taskPlan,
})
} else {
plan = fact.NewPlan(atc.DoPlan{
fact.NewPlan(buildInputs),
fact.NewPlan(atc.EnsurePlan{
Step: taskPlan,
Next: fact.NewPlan(buildOutputs),
}),
})
}
return client.CreateBuild(plan)
}
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Factory Timeout Step", func() {
var (
resourceTypes atc.ResourceTypes
buildFactory factory.BuildFactory
actualPlanFactory atc.PlanFactory
expectedPlanFactory atc.PlanFactory
)
BeforeEach(func() {
actualPlanFactory = atc.NewPlanFactory(321)
expectedPlanFactory = atc.NewPlanFactory(321)
buildFactory = factory.NewBuildFactory("some-pipeline", actualPlanFactory)
resourceTypes = atc.ResourceTypes{
{
Name: "some-custom-resource",
Type: "docker-image",
Source: atc.Source{"some": "custom-source"},
},
}
})
Context("When there is a task with a timeout", func() {
It("builds correctly", func() {
actual, err := buildFactory.Create(atc.JobConfig{
