When the per-build log is missing, builds:output fell through to journalctl without checking that the build record exists. A typo'd or never-recorded id then printed nothing and exited 0. Validate the build record first and return "no such build" when it is absent. Existing records with pruned logs still use the journalctl fallback. Fixes #9031
467 lines
11 KiB
Go
467 lines
11 KiB
Go
package builds
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/dokku/dokku/plugins/common"
|
|
|
|
"github.com/ryanuber/columnize"
|
|
)
|
|
|
|
// listView holds a Build plus its computed display status, used by
|
|
// builds:list / builds:info JSON output.
|
|
type listView struct {
|
|
Build
|
|
DisplayStatus BuildStatus `json:"display_status"`
|
|
Duration string `json:"duration"`
|
|
LogPath string `json:"log_path"`
|
|
}
|
|
|
|
func toListView(b Build) listView {
|
|
return listView{
|
|
Build: b,
|
|
DisplayStatus: b.DisplayStatus(),
|
|
Duration: b.Duration().String(),
|
|
LogPath: b.LogPath(),
|
|
}
|
|
}
|
|
|
|
// CommandList lists running builds across apps (no app arg) or running + recent
|
|
// records for one app.
|
|
func CommandList(appName string, format string, kindFilter string, statusFilter string) error {
|
|
if format == "" {
|
|
format = "stdout"
|
|
}
|
|
if format != "stdout" && format != "json" {
|
|
return fmt.Errorf("Invalid format specified, supported formats: json, stdout")
|
|
}
|
|
|
|
if kindFilter != "" {
|
|
k := BuildKind(kindFilter)
|
|
if !k.Valid() {
|
|
return fmt.Errorf("Invalid --kind value %q (allowed: build, deploy)", kindFilter)
|
|
}
|
|
}
|
|
if statusFilter != "" {
|
|
if !validStatusFilter(BuildStatus(statusFilter)) {
|
|
return fmt.Errorf("Invalid --status value %q (allowed: running, succeeded, failed, canceled, abandoned)", statusFilter)
|
|
}
|
|
}
|
|
|
|
if appName == "" {
|
|
return commandListAllRunning(format, kindFilter, statusFilter)
|
|
}
|
|
|
|
if err := common.VerifyAppName(appName); err != nil {
|
|
return err
|
|
}
|
|
|
|
all, err := FetchBuilds(appName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
retention := ResolveRetention(appName)
|
|
views := make([]listView, 0, len(all))
|
|
for _, b := range all {
|
|
v := toListView(b)
|
|
if !matchesKind(b, kindFilter) {
|
|
continue
|
|
}
|
|
if !matchesStatus(v, statusFilter) {
|
|
continue
|
|
}
|
|
views = append(views, v)
|
|
}
|
|
|
|
sort.SliceStable(views, func(i, j int) bool {
|
|
// Live-running first, then by start time descending.
|
|
iLive := views[i].Build.Status == BuildStatusRunning && views[i].DisplayStatus == BuildStatusRunning
|
|
jLive := views[j].Build.Status == BuildStatusRunning && views[j].DisplayStatus == BuildStatusRunning
|
|
if iLive != jLive {
|
|
return iLive
|
|
}
|
|
return views[i].StartedAt.After(views[j].StartedAt)
|
|
})
|
|
|
|
if statusFilter == "" && kindFilter == "" && len(views) > retention {
|
|
live := 0
|
|
for _, v := range views {
|
|
if v.DisplayStatus == BuildStatusRunning {
|
|
live++
|
|
}
|
|
}
|
|
cap := live + retention
|
|
if cap < len(views) {
|
|
views = views[:cap]
|
|
}
|
|
}
|
|
|
|
if format == "json" {
|
|
body, err := json.Marshal(views)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
common.Log(string(body))
|
|
return nil
|
|
}
|
|
|
|
if len(views) == 0 {
|
|
fmt.Println("No builds recorded for this app")
|
|
return nil
|
|
}
|
|
|
|
rows := []string{"Build ID | Kind | Status | PID | Source | Started | Duration"}
|
|
for _, v := range views {
|
|
rows = append(rows, fmt.Sprintf("%s | %s | %s | %d | %s | %s | %s",
|
|
v.ID,
|
|
v.Kind,
|
|
v.DisplayStatus,
|
|
v.PID,
|
|
v.Source,
|
|
v.StartedAt.Format(time.RFC3339),
|
|
v.Duration,
|
|
))
|
|
}
|
|
fmt.Println(columnize.SimpleFormat(rows))
|
|
return nil
|
|
}
|
|
|
|
func commandListAllRunning(format, kindFilter, statusFilter string) error {
|
|
apps, err := common.DokkuApps()
|
|
if err != nil && !errors.Is(err, common.NoAppsExist) {
|
|
return err
|
|
}
|
|
|
|
views := []listView{}
|
|
for _, appName := range apps {
|
|
running, err := FetchBuilds(appName)
|
|
if err != nil {
|
|
common.LogWarn(fmt.Sprintf("Could not read builds for %s: %s", appName, err))
|
|
continue
|
|
}
|
|
for _, b := range running {
|
|
if b.Status != BuildStatusRunning {
|
|
continue
|
|
}
|
|
v := toListView(b)
|
|
if !matchesKind(b, kindFilter) {
|
|
continue
|
|
}
|
|
if !matchesStatus(v, statusFilter) {
|
|
continue
|
|
}
|
|
views = append(views, v)
|
|
}
|
|
}
|
|
|
|
sort.SliceStable(views, func(i, j int) bool {
|
|
return views[i].StartedAt.After(views[j].StartedAt)
|
|
})
|
|
|
|
if format == "json" {
|
|
body, err := json.Marshal(views)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
common.Log(string(body))
|
|
return nil
|
|
}
|
|
|
|
if len(views) == 0 {
|
|
fmt.Println("No builds currently running")
|
|
return nil
|
|
}
|
|
|
|
rows := []string{"App | Build ID | Kind | PID | Source | Started"}
|
|
for _, v := range views {
|
|
rows = append(rows, fmt.Sprintf("%s | %s | %s | %d | %s | %s",
|
|
v.App,
|
|
v.ID,
|
|
v.Kind,
|
|
v.PID,
|
|
v.Source,
|
|
v.StartedAt.Format(time.RFC3339),
|
|
))
|
|
}
|
|
fmt.Println(columnize.SimpleFormat(rows))
|
|
return nil
|
|
}
|
|
|
|
func matchesKind(b Build, filter string) bool {
|
|
if filter == "" {
|
|
return true
|
|
}
|
|
return string(b.Kind) == filter
|
|
}
|
|
|
|
func matchesStatus(v listView, filter string) bool {
|
|
if filter == "" {
|
|
return true
|
|
}
|
|
return string(v.DisplayStatus) == filter
|
|
}
|
|
|
|
func validStatusFilter(s BuildStatus) bool {
|
|
switch s {
|
|
case BuildStatusRunning, BuildStatusSucceeded, BuildStatusFailed, BuildStatusCanceled, BuildStatusAbandoned:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// CommandInfo prints details for a single build record.
|
|
func CommandInfo(appName, buildID, format string) error {
|
|
if format == "" {
|
|
format = "stdout"
|
|
}
|
|
if format != "stdout" && format != "json" {
|
|
return fmt.Errorf("Invalid format specified, supported formats: json, stdout")
|
|
}
|
|
if err := common.VerifyAppName(appName); err != nil {
|
|
return err
|
|
}
|
|
if buildID == "" {
|
|
return errors.New("Please specify a build id")
|
|
}
|
|
|
|
b, err := ReadBuild(appName, buildID)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return fmt.Errorf("No build record found for %s/%s", appName, buildID)
|
|
}
|
|
return err
|
|
}
|
|
v := toListView(b)
|
|
|
|
if format == "json" {
|
|
body, err := json.Marshal(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
common.Log(string(body))
|
|
return nil
|
|
}
|
|
|
|
rows := []string{
|
|
fmt.Sprintf("Build ID:|%s", v.ID),
|
|
fmt.Sprintf("App:|%s", v.App),
|
|
fmt.Sprintf("Kind:|%s", v.Kind),
|
|
fmt.Sprintf("Status:|%s", v.DisplayStatus),
|
|
fmt.Sprintf("PID:|%d", v.PID),
|
|
fmt.Sprintf("Source:|%s", v.Source),
|
|
fmt.Sprintf("Started:|%s", v.StartedAt.Format(time.RFC3339)),
|
|
}
|
|
if v.FinishedAt != nil {
|
|
rows = append(rows, fmt.Sprintf("Finished:|%s", v.FinishedAt.Format(time.RFC3339)))
|
|
}
|
|
rows = append(rows, fmt.Sprintf("Duration:|%s", v.Duration))
|
|
if v.ExitCode != nil {
|
|
rows = append(rows, fmt.Sprintf("Exit Code:|%d", *v.ExitCode))
|
|
}
|
|
rows = append(rows, fmt.Sprintf("Log:|%s", v.LogPath))
|
|
fmt.Println(columnize.Format(rows, &columnize.Config{Delim: "|"}))
|
|
return nil
|
|
}
|
|
|
|
// CommandCancel cancels the in-flight build for an app.
|
|
func CommandCancel(appName string) error {
|
|
if err := common.VerifyAppName(appName); err != nil {
|
|
return err
|
|
}
|
|
|
|
lockPath := deployLockPath(appName)
|
|
body, err := os.ReadFile(lockPath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
common.LogInfo1("App not currently deploying")
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
buildID := strings.TrimSpace(string(body))
|
|
if buildID == "" {
|
|
common.LogInfo1("No matching app deploy found")
|
|
return nil
|
|
}
|
|
|
|
b, err := ReadBuild(appName, buildID)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
common.LogInfo1(fmt.Sprintf("No build record for %s, removing stale lock file", buildID))
|
|
_ = os.Remove(lockPath)
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
if b.Status != BuildStatusRunning {
|
|
common.LogInfo1(fmt.Sprintf("Build %s is no longer running (status=%s); leaving record untouched", buildID, b.Status))
|
|
return nil
|
|
}
|
|
|
|
if !CheckPIDAlive(b.PID) {
|
|
common.LogInfo1("Build was already terminated, marking failed")
|
|
now := time.Now().UTC()
|
|
exitCode := -1
|
|
b.Status = BuildStatusFailed
|
|
b.FinishedAt = &now
|
|
b.ExitCode = &exitCode
|
|
if err := WriteBuild(b); err != nil {
|
|
return err
|
|
}
|
|
_ = os.Remove(lockPath)
|
|
return nil
|
|
}
|
|
|
|
common.LogInfo1("Killing app deploy")
|
|
if err := killProcessGroup(b.PID); err != nil {
|
|
common.LogWarn(fmt.Sprintf("Failed to signal process group %d: %s", b.PID, err))
|
|
}
|
|
|
|
current, err := ReadBuild(appName, buildID)
|
|
if err == nil && current.Status == BuildStatusRunning {
|
|
now := time.Now().UTC()
|
|
exitCode := -1
|
|
current.Status = BuildStatusCanceled
|
|
current.FinishedAt = &now
|
|
current.ExitCode = &exitCode
|
|
if err := WriteBuild(current); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
_ = os.Remove(lockPath)
|
|
return nil
|
|
}
|
|
|
|
func killProcessGroup(pid int) error {
|
|
pgid, err := syscall.Getpgid(pid)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return syscall.Kill(-pgid, syscall.SIGQUIT)
|
|
}
|
|
|
|
func deployLockPath(appName string) string {
|
|
return filepath.Join(common.GetAppDataDirectory("apps", appName), ".deploy.lock")
|
|
}
|
|
|
|
// CommandOutput streams the build log for a given build (or the current one).
|
|
func CommandOutput(appName, buildID string) error {
|
|
if err := common.VerifyAppName(appName); err != nil {
|
|
return err
|
|
}
|
|
|
|
if buildID == "" || buildID == "current" {
|
|
body, err := os.ReadFile(deployLockPath(appName))
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
common.LogInfo1("App not currently deploying")
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
buildID = strings.TrimSpace(string(body))
|
|
if buildID == "" {
|
|
common.LogInfo1("No matching app deploy found")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
logPath := LogPathFor(appName, buildID)
|
|
if _, err := os.Stat(logPath); err != nil {
|
|
if os.IsNotExist(err) {
|
|
// A missing log is normal after prune/rotation, but a typo'd or
|
|
// never-recorded id must not fall through to journalctl and exit 0.
|
|
if _, err := ReadBuild(appName, buildID); err != nil {
|
|
if os.IsNotExist(err) {
|
|
return fmt.Errorf("no such build %s for app %s", buildID, appName)
|
|
}
|
|
return err
|
|
}
|
|
return outputViaJournalctl(buildID)
|
|
}
|
|
return err
|
|
}
|
|
|
|
b, err := ReadBuild(appName, buildID)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
|
|
if err == nil && b.Status == BuildStatusRunning && CheckPIDAlive(b.PID) {
|
|
return execStreaming("tail", "-n", "1000", "-f", logPath)
|
|
}
|
|
return execStreaming("cat", logPath)
|
|
}
|
|
|
|
func outputViaJournalctl(buildID string) error {
|
|
if _, err := exec.LookPath("journalctl"); err != nil {
|
|
return fmt.Errorf("log file missing and journalctl not available for build %s", buildID)
|
|
}
|
|
return execStreaming("journalctl", "-n", "1000", "-a", "-o", "cat", fmt.Sprintf("SYSLOG_IDENTIFIER=dokku-%s", buildID))
|
|
}
|
|
|
|
func execStreaming(name string, args ...string) error {
|
|
cmd := exec.Command(name, args...)
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Stderr = os.Stderr
|
|
return cmd.Run()
|
|
}
|
|
|
|
// CommandPrune manually invokes PruneAppBuilds for one or every app.
|
|
func CommandPrune(appName string, allApps bool) error {
|
|
if allApps {
|
|
apps, err := common.DokkuApps()
|
|
if err != nil {
|
|
if errors.Is(err, common.NoAppsExist) {
|
|
common.LogWarn(err.Error())
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
for _, app := range apps {
|
|
if err := PruneAppBuilds(app); err != nil {
|
|
common.LogWarn(fmt.Sprintf("Prune failed for %s: %s", app, err))
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if err := common.VerifyAppName(appName); err != nil {
|
|
return err
|
|
}
|
|
return PruneAppBuilds(appName)
|
|
}
|
|
|
|
// CommandReport displays a build report for one or more apps.
|
|
func CommandReport(appName, format, infoFlag string) error {
|
|
if appName == "" {
|
|
apps, err := common.DokkuApps()
|
|
if err != nil {
|
|
if errors.Is(err, common.NoAppsExist) {
|
|
common.LogWarn(err.Error())
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
for _, app := range apps {
|
|
if err := ReportSingleApp(app, format, infoFlag); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return ReportSingleApp(appName, format, infoFlag)
|
|
}
|