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 *SyncCommand) Execute(args []string) error { client, err := rc.TargetClient(Fly.Target) if err != nil { return err } body, err := client.GetCLIReader(runtime.GOARCH, runtime.GOOS) if err != nil { return err } fmt.Printf("downloading fly from %s... ", client.URL()) err = update.Apply(body, update.Options{}) if err != nil { displayhelpers.Failf("update failed: %s", err) } fmt.Println("update successful!") return nil }
func (command *PausePipelineCommand) 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.PausePipeline(pipelineName) if err != nil { return err } if found { fmt.Printf("paused '%s'\n", pipelineName) } else { displayhelpers.Failf("pipeline '%s' not found\n", pipelineName) } return nil }
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 (atcConfig ATCConfig) Set(configPath flaghelpers.PathFlag, templateVariables template.Variables, templateVariablesFiles []flaghelpers.PathFlag) error { newConfig := atcConfig.newConfig(configPath, templateVariablesFiles, templateVariables) existingConfig, _, existingConfigVersion, _, err := atcConfig.Client.PipelineConfig(atcConfig.PipelineName) errorMessages := []string{} if err != nil { if configError, ok := err.(concourse.PipelineConfigError); ok { errorMessages = configError.ErrorMessages } else { return err } } diff(existingConfig, newConfig) if len(errorMessages) > 0 { atcConfig.showPipelineConfigErrors(errorMessages) } if !atcConfig.ApplyConfigInteraction() { displayhelpers.Failf("bailing out") } created, updated, warnings, err := atcConfig.Client.CreateOrUpdatePipelineConfig( atcConfig.PipelineName, existingConfigVersion, newConfig, ) if err != nil { return err } if len(warnings) > 0 { atcConfig.showWarnings(warnings) } atcConfig.showHelpfulMessage(created, updated) return nil }
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 { displayhelpers.Failf("update failed: %s", err) } fmt.Println("update successful!") return nil }
func (command *HijackCommand) Execute(args []string) error { target, err := rc.SelectTarget(Fly.Target) if err != nil { return err } containers, err := getContainerIDs(command) if err != nil { return err } var chosenContainer atc.Container if len(containers) == 0 { displayhelpers.Failf("no containers matched your search parameters!\n\nthey may have expired if your build hasn't recently finished.") } else if len(containers) > 1 { var choices []interact.Choice for _, container := range containers { var infos []string if container.BuildID != 0 { if container.JobName != "" { infos = append(infos, fmt.Sprintf("build #%s", container.BuildName)) } else { infos = append(infos, fmt.Sprintf("build id: %d", container.BuildID)) } } if container.StepType != "" { infos = append(infos, fmt.Sprintf("step: %s", container.StepName)) infos = append(infos, fmt.Sprintf("type: %s", container.StepType)) } else if container.ResourceName != "" { infos = append(infos, fmt.Sprintf("resource: %s", container.ResourceName)) infos = append(infos, "type: check") } else { infos = append(infos, fmt.Sprintf("step: %s", container.StepName)) infos = append(infos, "type: check") } if len(container.Attempts) != 0 { attempt := SliceItoa(container.Attempts) infos = append(infos, fmt.Sprintf("attempt: %s", attempt)) } choices = append(choices, interact.Choice{ Display: strings.Join(infos, ", "), Value: container, }) } err = interact.NewInteraction("choose a container", choices...).Resolve(&chosenContainer) if err == io.EOF { return nil } if err != nil { return err } } else { chosenContainer = containers[0] } path, args := remoteCommand(args) privileged := true reqGenerator := rata.NewRequestGenerator(target.API, atc.Routes) tlsConfig := &tls.Config{InsecureSkipVerify: target.Insecure} var ttySpec *atc.HijackTTYSpec rows, cols, err := pty.Getsize(os.Stdin) if err == nil { ttySpec = &atc.HijackTTYSpec{ WindowSize: atc.HijackWindowSize{ Columns: cols, Rows: rows, }, } } envVariables := append(chosenContainer.EnvironmentVariables, "TERM="+os.Getenv("TERM")) spec := atc.HijackProcessSpec{ Path: path, Args: args, Env: envVariables, User: chosenContainer.User, Dir: chosenContainer.WorkingDirectory, Privileged: privileged, TTY: ttySpec, } result, err := func() (int, error) { // so the term.Restore() can run before the os.Exit() var in io.Reader term, err := pty.OpenRawTerm() if err == nil { defer term.Restore() in = term } else { in = os.Stdin } io := hijacker.ProcessIO{ In: in, Out: os.Stdout, Err: os.Stderr, } h := hijacker.New(tlsConfig, reqGenerator, target.Token) return h.Hijack(chosenContainer.ID, spec, io) }() if err != nil { return err } os.Exit(result) 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) }