func (command *WatchCommand) Execute(args []string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
build, err := GetBuild(client, command.Job.JobName, command.Build, command.Job.PipelineName)
if err != nil {
log.Fatalln(err)
}
eventSource, err := client.BuildEvents(fmt.Sprintf("%d", build.ID))
if err != nil {
log.Println("failed to attach to stream:", err)
os.Exit(1)
}
exitCode := eventstream.Render(os.Stdout, eventSource)
eventSource.Close()
os.Exit(exitCode)
return nil
}
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
}
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
webRequestGenerator := rata.NewRequestGenerator(connection.URL(), web.Routes)
atcConfig := ATCConfig{
pipelineName: pipelineName,
webRequestGenerator: webRequestGenerator,
client: client,
}
atcConfig.Set(configPath, templateVariables, templateVariablesFiles)
return nil
}
func (command *DestroyPipelineCommand) Execute(args []string) error {
pipelineName := command.Pipeline
fmt.Printf("!!! this will remove all data for pipeline `%s`\n\n", pipelineName)
confirm := false
err := interact.NewInteraction("are you sure?").Resolve(&confirm)
if err != nil || !confirm {
fmt.Println("bailing out")
return err
}
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
return err
}
client := concourse.NewClient(connection)
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 *WorkersCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
client := concourse.NewClient(connection)
workers, err := client.ListWorkers()
if err != nil {
log.Fatalln(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},
stringOrNone(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, stringOrNone(w.BaggageclaimURL))
row = append(row, stringOrNone(strings.Join(resourceTypes, ", ")))
}
table.Data = append(table.Data, row)
}
return table.Render(os.Stdout)
}
func (command *ContainersCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
client := concourse.NewClient(connection)
containers, err := client.ListContainers(map[string]string{})
if err != nil {
log.Fatalln(err)
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "handle", 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: 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 (command *GetPipelineCommand) Execute(args []string) error {
asJSON := command.JSON
pipelineName := command.Pipeline
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
client := concourse.NewClient(connection)
config, _, _, err := client.PipelineConfig(pipelineName)
if err != nil {
log.Fatalln(err)
}
dump(config, asJSON)
return nil
}
func (command *ChecklistCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
pipelineName := command.Pipeline
client := concourse.NewClient(connection)
config, _, _, err := client.PipelineConfig(pipelineName)
if err != nil {
log.Fatalln(err)
}
printCheckfile(pipelineName, config, connection.URL())
return nil
}
func (command *ContainersCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
client := concourse.NewClient(connection)
containers, err := client.ListContainers(map[string]string{})
if err != nil {
log.Fatalln(err)
}
table := ui.Table{
Headers: ui.TableRow{
{Contents: "handle", Color: color.New(color.Bold)},
{Contents: "name", Color: color.New(color.Bold)},
{Contents: "pipeline", Color: color.New(color.Bold)},
{Contents: "type", Color: color.New(color.Bold)},
{Contents: "build id", Color: color.New(color.Bold)},
{Contents: "worker", Color: color.New(color.Bold)},
},
}
sort.Sort(containersByHandle(containers))
for _, c := range containers {
row := ui.TableRow{
{Contents: c.ID},
{Contents: c.Name},
{Contents: c.PipelineName},
{Contents: c.Type},
buildIDOrNone(c.BuildID),
{Contents: c.WorkerName},
}
table.Data = append(table.Data, row)
}
return table.Render(os.Stdout)
}
func (command *UnpausePipelineCommand) Execute(args []string) error {
pipelineName := command.Pipeline
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
found, err := client.UnpausePipeline(pipelineName)
if err != nil {
return err
}
if found {
fmt.Printf("unpaused '%s'\n", pipelineName)
} else {
failf("pipeline '%s' not found\n", pipelineName)
}
return nil
}
func getContainerIDs(c *HijackCommand) []atc.Container {
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,
}
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln("failed to create client:", err)
}
client := concourse.NewClient(connection)
reqValues, err := locateContainer(client, fingerprint)
if err != nil {
log.Fatalln(err)
}
containers, err := client.ListContainers(reqValues)
if err != nil {
log.Fatalln("failed to get containers:", err)
}
return containers
}
func (command *VolumesCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
}
client := concourse.NewClient(connection)
volumes, err := client.ListVolumes()
if err != nil {
log.Fatalln(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 *PipelinesCommand) Execute([]string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
pipelines, err := client.ListPipelines()
if err != nil {
log.Fatalln(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 *SyncCommand) Execute(args []string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
body, err := client.GetCLIReader(runtime.GOARCH, runtime.GOOS)
if err != nil {
log.Fatalln(err)
}
fmt.Printf("downloading fly from %s... ", connection.URL())
err = update.Apply(body, update.Options{})
if err != nil {
failf("update failed: %s", err)
}
fmt.Println("update successful!")
return nil
}
func (command *ExecuteCommand) Execute(args []string) error {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
taskConfigFile := command.TaskConfig
excludeIgnored := command.ExcludeIgnored
atcRequester := deprecated.NewAtcRequester(connection.URL(), connection.HTTPClient())
taskConfig := config.LoadTaskConfig(string(taskConfigFile), args)
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(
atcRequester,
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(i, excludeIgnored, atcRequester)
}
}
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(o, atcRequester)
}
close(outputChan)
}(output, outputChans[i])
}
}
eventSource, err := client.BuildEvents(fmt.Sprintf("%d", build.ID))
if err != nil {
log.Println("failed to attach to stream:", err)
os.Exit(1)
}
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 {
connection, err := rc.TargetConnection(Fly.Target)
if err != nil {
log.Fatalln(err)
return nil
}
client := concourse.NewClient(connection)
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 {
log.Fatalln(err)
}
if !found {
log.Fatalln("pipleline/job not found")
}
} else {
builds, _, err = client.Builds(page)
if err != nil {
log.Fatalln(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)
}
