func (command *WatchCommand) Execute(args []string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
build, err := GetBuild(client, command.Job.JobName, command.Build, command.Job.PipelineName)
if err != nil {
return err
}
eventSource, err := client.BuildEvents(fmt.Sprintf("%d", build.ID))
if err != nil {
return err
}
exitCode := eventstream.Render(os.Stdout, eventSource)
eventSource.Close()
os.Exit(exitCode)
return nil
}
func (command *DestroyPipelineCommand) Execute(args []string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
pipelineName := command.Pipeline
fmt.Printf("!!! this will remove all data for pipeline `%s`\n\n", pipelineName)
confirm := command.SkipInteractive
if !confirm {
err := interact.NewInteraction("are you sure?").Resolve(&confirm)
if err != nil || !confirm {
fmt.Println("bailing out")
return err
}
}
found, err := client.DeletePipeline(pipelineName)
if err != nil {
return err
}
if !found {
fmt.Printf("`%s` does not exist\n", pipelineName)
} else {
fmt.Printf("`%s` deleted\n", pipelineName)
}
return nil
}
func (command *UnpausePipelineCommand) Execute(args []string) error {
pipelineName := command.Pipeline
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
found, err := client.UnpausePipeline(pipelineName)
if err != nil {
return err
}
if found {
fmt.Printf("unpaused '%s'\n", pipelineName)
} else {
displayhelpers.Failf("pipeline '%s' not found\n", pipelineName)
}
return nil
}
func (command *GetPipelineCommand) Execute(args []string) error {
asJSON := command.JSON
pipelineName := command.Pipeline
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
config, rawConfig, _, _, err := client.PipelineConfig(pipelineName)
if err != nil {
if _, ok := err.(concourse.PipelineConfigError); ok {
dumpRawConfig(rawConfig, asJSON)
command.showConfigWarning()
return err
} else {
return err
}
}
return dump(config, asJSON)
}
func (command *SetPipelineCommand) Execute(args []string) error {
configPath := command.Config
templateVariablesFiles := command.VarsFrom
pipelineName := command.Pipeline
templateVariables := template.Variables{}
for _, v := range command.Var {
templateVariables[v.Name] = v.Value
}
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
webRequestGenerator := rata.NewRequestGenerator(client.URL(), web.Routes)
atcConfig := setpipelinehelpers.ATCConfig{
PipelineName: pipelineName,
WebRequestGenerator: webRequestGenerator,
Client: client,
SkipInteraction: command.SkipInteractive,
}
return atcConfig.Set(configPath, templateVariables, templateVariablesFiles)
}
func (command *AbortBuildCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
build, exists, err := client.JobBuild(command.Job.PipelineName, command.Job.JobName, command.Build)
if err != nil {
return fmt.Errorf("failed to get job build")
}
if !exists {
return fmt.Errorf("job build does not exist")
}
if err := client.AbortBuild(strconv.Itoa(build.ID)); err != nil {
return fmt.Errorf("failed to abort build")
}
fmt.Println("build successfully aborted")
return nil
}
func (command *WorkersCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
workers, err := client.ListWorkers()
if err != nil {
return err
}
headers := ui.TableRow{
{Contents: "name", Color: color.New(color.Bold)},
{Contents: "containers", Color: color.New(color.Bold)},
{Contents: "platform", Color: color.New(color.Bold)},
{Contents: "tags", Color: color.New(color.Bold)},
}
if command.Details {
headers = append(headers,
ui.TableCell{Contents: "garden address", Color: color.New(color.Bold)},
ui.TableCell{Contents: "baggageclaim url", Color: color.New(color.Bold)},
ui.TableCell{Contents: "resource types", Color: color.New(color.Bold)},
)
}
table := ui.Table{Headers: headers}
sort.Sort(byWorkerName(workers))
for _, w := range workers {
row := ui.TableRow{
{Contents: w.Name},
{Contents: strconv.Itoa(w.ActiveContainers)},
{Contents: w.Platform},
stringOrDefault(strings.Join(w.Tags, ", ")),
}
if command.Details {
var resourceTypes []string
for _, t := range w.ResourceTypes {
resourceTypes = append(resourceTypes, t.Type)
}
row = append(row, ui.TableCell{Contents: w.GardenAddr})
row = append(row, stringOrDefault(w.BaggageclaimURL))
row = append(row, stringOrDefault(strings.Join(resourceTypes, ", ")))
}
table.Data = append(table.Data, row)
}
return table.Render(os.Stdout)
}
func (command *ContainersCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
containers, err := client.ListContainers(map[string]string{})
if err != nil {
return err
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "handle", Color: color.New(color.Bold)},
{Contents: "ttl", Color: color.New(color.Bold)},
{Contents: "validity", Color: color.New(color.Bold)},
{Contents: "worker", Color: color.New(color.Bold)},
{Contents: "pipeline", Color: color.New(color.Bold)},
{Contents: "job", Color: color.New(color.Bold)},
{Contents: "build #", Color: color.New(color.Bold)},
{Contents: "build id", Color: color.New(color.Bold)},
{Contents: "type", Color: color.New(color.Bold)},
{Contents: "name", Color: color.New(color.Bold)},
{Contents: "attempt", Color: color.New(color.Bold)},
},
}
sort.Sort(containersByHandle(containers))
for _, c := range containers {
row := ui.TableRow{
{Contents: c.ID},
{Contents: formatTTL(c.TTLInSeconds)},
{Contents: formatTTL(c.ValidityInSeconds)},
{Contents: c.WorkerName},
stringOrDefault(c.PipelineName),
stringOrDefault(c.JobName),
stringOrDefault(c.BuildName),
buildIDOrNone(c.BuildID),
stringOrDefault(c.StepType, "check"),
{Contents: (c.StepName + c.ResourceName)},
stringOrDefault(SliceItoa(c.Attempts), "n/a"),
}
table.Data = append(table.Data, row)
}
return table.Render(os.Stdout)
}
func getContainerIDs(c *HijackCommand) ([]atc.Container, error) {
var pipelineName string
if c.Job.PipelineName != "" {
pipelineName = c.Job.PipelineName
} else {
pipelineName = c.Check.PipelineName
}
buildNameOrID := c.Build
stepName := c.StepName
jobName := c.Job.JobName
check := c.Check.ResourceName
attempt := c.Attempt
fingerprint := containerFingerprint{
pipelineName: pipelineName,
jobName: jobName,
buildNameOrID: buildNameOrID,
stepName: stepName,
checkName: check,
attempt: attempt,
}
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return nil, err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return nil, err
}
reqValues, err := locateContainer(client, fingerprint)
if err != nil {
return nil, err
}
containers, err := client.ListContainers(reqValues)
if err != nil {
return nil, err
}
sort.Sort(hijackhelpers.ContainerSorter(containers))
return containers, nil
}
func (command *PauseJobCommand) Execute(args []string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
_, err = client.PauseJob(command.Job.PipelineName, command.Job.JobName)
if err != nil {
return err
}
fmt.Printf("paused '%s'\n", command.Job.JobName)
return nil
}
func (command *TriggerJobCommand) Execute(args []string) error {
pipelineName, jobName := command.Job.PipelineName, command.Job.JobName
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
_, err = client.CreateJobBuild(pipelineName, jobName)
if err != nil {
displayhelpers.FailWithErrorf("pipeline/job '%s/%s' not found\n", err, pipelineName, jobName)
}
fmt.Printf("started '%s/%s'\n", pipelineName, jobName)
return nil
}
func (command *VolumesCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
volumes, err := client.ListVolumes()
if err != nil {
return err
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "handle", Color: color.New(color.Bold)},
{Contents: "ttl", Color: color.New(color.Bold)},
{Contents: "validity", Color: color.New(color.Bold)},
{Contents: "worker", Color: color.New(color.Bold)},
{Contents: "version", Color: color.New(color.Bold)},
},
}
sort.Sort(volumesByWorkerAndHandle(volumes))
for _, c := range volumes {
row := ui.TableRow{
{Contents: c.ID},
{Contents: formatTTL(c.TTLInSeconds)},
{Contents: formatTTL(c.ValidityInSeconds)},
{Contents: c.WorkerName},
versionCell(c.ResourceVersion),
}
table.Data = append(table.Data, row)
}
return table.Render(os.Stdout)
}
func (command *ChecklistCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
pipelineName := command.Pipeline
config, _, _, _, err := client.PipelineConfig(pipelineName)
if err != nil {
return err
}
printCheckfile(pipelineName, config, client.URL())
return nil
}
func (command *PipelinesCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
pipelines, err := client.ListPipelines()
if err != nil {
return err
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "name", Color: color.New(color.Bold)},
{Contents: "paused", Color: color.New(color.Bold)},
},
}
for _, p := range pipelines {
var pausedColumn ui.TableCell
if p.Paused {
pausedColumn.Contents = "yes"
pausedColumn.Color = color.New(color.FgCyan)
} else {
pausedColumn.Contents = "no"
}
table.Data = append(table.Data, []ui.TableCell{
{Contents: p.Name},
pausedColumn,
})
}
return table.Render(os.Stdout)
}
func (command *SetTeamCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
hasBasicAuth, hasGitHubAuth, err := command.ValidateFlags()
if err != nil {
return err
}
fmt.Println("Team Name:", command.TeamName)
fmt.Println("Basic Auth:", authMethodStatusDescription(hasBasicAuth))
fmt.Println("GitHub Auth:", authMethodStatusDescription(hasGitHubAuth))
confirm := false
err = interact.NewInteraction("apply configuration?").Resolve(&confirm)
if err != nil {
return err
}
if !confirm {
displayhelpers.Failf("bailing out")
}
team := command.GetTeam(hasBasicAuth, hasGitHubAuth)
_, _, _, err = client.SetTeam(command.TeamName, team)
if err != nil {
return err
}
fmt.Println("team created")
return nil
}
func (rp *RenamePipelineCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
renamed, err := client.RenamePipeline(rp.Pipeline, rp.Name)
if err != nil {
return fmt.Errorf("client failed with error: %s\n", err)
}
if !renamed {
return fmt.Errorf("failed to find pipeline")
}
fmt.Printf("pipeline successfully renamed to %s\n", rp.Name)
return nil
}
func (command *LoginCommand) Execute(args []string) error {
if Fly.Target == "" {
return errors.New("name for the target must be specified (--target/-t)")
}
var client concourse.Client
var err error
if command.ATCURL != "" {
client = rc.NewUnauthenticatedClient(command.ATCURL, command.Insecure)
} else {
client, err = rc.CommandTargetClient(Fly.Target, &command.Insecure)
}
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
authMethods, err := client.ListAuthMethods()
if err != nil {
return err
}
var chosenMethod atc.AuthMethod
if command.Username != "" && command.Password != "" {
for _, method := range authMethods {
if method.Type == atc.AuthTypeBasic {
chosenMethod = method
break
}
}
if chosenMethod.Type == "" {
return errors.New("basic auth is not available")
}
} else {
switch len(authMethods) {
case 0:
return command.saveTarget(
client.URL(),
&rc.TargetToken{},
)
case 1:
chosenMethod = authMethods[0]
default:
choices := make([]interact.Choice, len(authMethods))
for i, method := range authMethods {
choices[i] = interact.Choice{
Display: method.DisplayName,
Value: method,
}
}
err = interact.NewInteraction("choose an auth method", choices...).Resolve(&chosenMethod)
if err != nil {
return err
}
}
}
return command.loginWith(chosenMethod, client)
}
func (command *ExecuteCommand) Execute(args []string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
taskConfigFile := command.TaskConfig
excludeIgnored := command.ExcludeIgnored
taskConfig, err := config.LoadTaskConfig(string(taskConfigFile), args)
if err != nil {
return err
}
inputs, err := executehelpers.DetermineInputs(
client,
taskConfig.Inputs,
command.Inputs,
command.InputsFrom,
)
if err != nil {
return err
}
outputs, err := executehelpers.DetermineOutputs(
client,
taskConfig.Outputs,
command.Outputs,
)
if err != nil {
return err
}
build, err := executehelpers.CreateBuild(
client,
command.Privileged,
inputs,
outputs,
taskConfig,
command.Tags,
Fly.Target,
)
if err != nil {
return err
}
fmt.Println("executing build", build.ID)
terminate := make(chan os.Signal, 1)
go abortOnSignal(client, terminate, build)
signal.Notify(terminate, syscall.SIGINT, syscall.SIGTERM)
inputChan := make(chan interface{})
go func() {
for _, i := range inputs {
if i.Path != "" {
executehelpers.Upload(client, i, excludeIgnored)
}
}
close(inputChan)
}()
var outputChans []chan (interface{})
if len(outputs) > 0 {
for i, output := range outputs {
outputChans = append(outputChans, make(chan interface{}, 1))
go func(o executehelpers.Output, outputChan chan<- interface{}) {
if o.Path != "" {
executehelpers.Download(client, o)
}
close(outputChan)
}(output, outputChans[i])
}
}
eventSource, err := client.BuildEvents(fmt.Sprintf("%d", build.ID))
if err != nil {
return err
}
exitCode := eventstream.Render(os.Stdout, eventSource)
eventSource.Close()
<-inputChan
if len(outputs) > 0 {
for _, outputChan := range outputChans {
<-outputChan
}
}
os.Exit(exitCode)
return nil
}
func (command *BuildsCommand) Execute([]string) error {
client, err := rc.TargetClient(Fly.Target)
if err != nil {
return err
}
err = rc.ValidateClient(client, Fly.Target)
if err != nil {
return err
}
page := concourse.Page{Limit: command.Count}
var builds []atc.Build
if command.Job.PipelineName != "" && command.Job.JobName != "" {
var found bool
builds, _, found, err = client.JobBuilds(
command.Job.PipelineName,
command.Job.JobName,
page,
)
if err != nil {
return err
}
if !found {
displayhelpers.Failf("pipeline/job not found")
}
} else {
builds, _, err = client.Builds(page)
if err != nil {
return err
}
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "id", Color: color.New(color.Bold)},
{Contents: "pipeline/job", Color: color.New(color.Bold)},
{Contents: "build", Color: color.New(color.Bold)},
{Contents: "status", Color: color.New(color.Bold)},
{Contents: "start", Color: color.New(color.Bold)},
{Contents: "end", Color: color.New(color.Bold)},
{Contents: "duration", Color: color.New(color.Bold)},
},
}
var rangeUntil int
if command.Count < len(builds) {
rangeUntil = command.Count
} else {
rangeUntil = len(builds)
}
for _, b := range builds[:rangeUntil] {
startTimeCell, endTimeCell, durationCell := populateTimeCells(time.Unix(b.StartTime, 0), time.Unix(b.EndTime, 0))
var pipelineJobCell, buildCell ui.TableCell
if b.PipelineName == "" {
pipelineJobCell.Contents = "one-off"
buildCell.Contents = "n/a"
} else {
pipelineJobCell.Contents = fmt.Sprintf("%s/%s", b.PipelineName, b.JobName)
buildCell.Contents = b.Name
}
var statusCell ui.TableCell
statusCell.Contents = b.Status
switch b.Status {
case "pending":
statusCell.Color = ui.PendingColor
case "started":
statusCell.Color = ui.StartedColor
case "succeeded":
statusCell.Color = ui.SucceededColor
case "failed":
statusCell.Color = ui.FailedColor
case "errored":
statusCell.Color = ui.ErroredColor
case "aborted":
statusCell.Color = ui.AbortedColor
case "paused":
statusCell.Color = ui.PausedColor
}
table.Data = append(table.Data, []ui.TableCell{
{Contents: strconv.Itoa(b.ID)},
pipelineJobCell,
buildCell,
statusCell,
startTimeCell,
endTimeCell,
durationCell,
})
}
return table.Render(os.Stdout)
}