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)
}