func main() {
path := os.Args[1]
file, err := ioutil.ReadFile(path)
if err != nil {
fmt.Println("could not read file: ", err.Error())
os.Exit(1)
}
fmt.Println("checking " + path + "...")
var config atc.TaskConfig
if err := yaml.Unmarshal(file, &config); err != nil {
fmt.Println("could not unmarshal file: ", err.Error())
os.Exit(1)
}
if err := config.Validate(); err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
}
// FetchConfig reads the specified file from the SourceRepository and loads the
// TaskConfig contained therein (expecting it to be YAML format).
//
// The path must be in the format SOURCE_NAME/FILE/PATH.yml. The SOURCE_NAME
// will be used to determine the ArtifactSource in the SourceRepository to
// stream the file out of.
//
// If the source name is missing (i.e. if the path is just "foo.yml"),
// UnspecifiedArtifactSourceError is returned.
//
// If the specified source name cannot be found, UnknownArtifactSourceError is
// returned.
//
// If the task config file is not found, or is invalid YAML, or is an invalid
// task configuration, the respective errors will be bubbled up.
func (configSource FileConfigSource) FetchConfig(repo *SourceRepository) (atc.TaskConfig, error) {
segs := strings.SplitN(configSource.Path, "/", 2)
if len(segs) != 2 {
return atc.TaskConfig{}, UnspecifiedArtifactSourceError{configSource.Path}
}
sourceName := SourceName(segs[0])
filePath := segs[1]
source, found := repo.SourceFor(sourceName)
if !found {
return atc.TaskConfig{}, UnknownArtifactSourceError{sourceName}
}
stream, err := source.StreamFile(filePath)
if err != nil {
return atc.TaskConfig{}, err
}
defer stream.Close()
streamedFile, err := ioutil.ReadAll(stream)
if err != nil {
return atc.TaskConfig{}, err
}
var config atc.TaskConfig
if err := yaml.Unmarshal(streamedFile, &config); err != nil {
return atc.TaskConfig{}, err
}
err = config.Validate()
if err != nil {
return atc.TaskConfig{}, err
}
return config, nil
}
func CreateBuild(
atcRequester *deprecated.AtcRequester,
client concourse.Client,
privileged bool,
inputs []Input,
outputs []Output,
config atc.TaskConfig,
tags []string,
target string,
) (atc.Build, error) {
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 i, 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, atc.Plan{
Location: &atc.Location{
// offset by 2 because aggregate gets parallelgroup ID 1
ID: uint(i) + 2,
ParentID: 0,
ParallelGroup: 1,
},
Get: &getPlan,
})
}
taskPlan := atc.Plan{
Location: &atc.Location{
// offset by 1 because aggregate gets parallelgroup ID 1
ID: uint(len(inputs)) + 2,
ParentID: 0,
},
Task: &atc.TaskPlan{
Name: "one-off",
Privileged: privileged,
Config: &config,
},
}
if len(tags) != 0 {
taskPlan.Task.Tags = tags
}
buildOutputs := atc.AggregatePlan{}
for i, 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, atc.Plan{
Location: &atc.Location{
ID: taskPlan.Location.ID + 2 + uint(i),
ParentID: 0,
ParallelGroup: taskPlan.Location.ID + 1,
},
Put: &atc.PutPlan{
Name: output.Name,
Type: "archive",
Source: source,
Params: params,
},
})
}
var plan atc.Plan
if len(buildOutputs) == 0 {
plan = atc.Plan{
OnSuccess: &atc.OnSuccessPlan{
Step: atc.Plan{
Aggregate: &buildInputs,
},
Next: taskPlan,
},
}
} else {
plan = atc.Plan{
OnSuccess: &atc.OnSuccessPlan{
Step: atc.Plan{
Aggregate: &buildInputs,
},
Next: atc.Plan{
Ensure: &atc.EnsurePlan{
Step: taskPlan,
Next: atc.Plan{
Aggregate: &buildOutputs,
},
},
},
},
}
}
return client.CreateBuild(plan)
}
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)
}
func createBuild(
atcRequester *atcRequester,
privileged bool,
inputs []Input,
config atc.TaskConfig,
) atc.Build {
if err := config.Validate(); err != nil {
println(err.Error())
os.Exit(1)
}
buffer := &bytes.Buffer{}
buildInputs := atc.AggregatePlan{}
for i, input := range inputs {
readPipe, err := atcRequester.CreateRequest(
atc.ReadPipe,
rata.Params{"pipe_id": input.Pipe.ID},
nil,
)
if err != nil {
log.Fatalln(err)
}
buildInputs = append(buildInputs, atc.Plan{
Location: &atc.Location{
// offset by 2 because aggregate gets parallelgroup ID 1
ID: uint(i) + 2,
ParentID: 0,
ParallelGroup: 1,
},
Get: &atc.GetPlan{
Name: input.Name,
Type: "archive",
Source: atc.Source{
"uri": readPipe.URL.String(),
},
},
})
}
plan := atc.Plan{
Compose: &atc.ComposePlan{
A: atc.Plan{
Aggregate: &buildInputs,
},
B: atc.Plan{
Location: &atc.Location{
// offset by 1 because aggregate gets parallelgroup ID 1
ID: uint(len(inputs)) + 2,
ParentID: 0,
},
Task: &atc.TaskPlan{
Name: "build",
Privileged: privileged,
Config: &config,
},
},
},
}
err := json.NewEncoder(buffer).Encode(plan)
if err != nil {
log.Fatalln("encoding build failed:", err)
}
createBuild, err := atcRequester.CreateRequest(atc.CreateBuild, nil, buffer)
if err != nil {
log.Fatalln(err)
}
createBuild.Header.Set("Content-Type", "application/json")
response, err := atcRequester.httpClient.Do(createBuild)
if err != nil {
log.Fatalln("request failed:", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusCreated {
log.Println("bad response when creating build:", response)
response.Write(os.Stderr)
os.Exit(1)
}
var build atc.Build
err = json.NewDecoder(response.Body).Decode(&build)
if err != nil {
log.Fatalln("response decoding failed:", err)
}
return build
}
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)
}