Files
dokku/plugins/builds/triggers.go
T
Martin VysnyandClaude Opus 5 dc27668e09 fix: discard the build record git:sync starts when nothing is built
cmd-git-sync calls dokku_setup_build_capture before the clone/fetch,
because it cannot know whether there is anything to deploy until it has
fetched. Both paths that then decline to build - a plain `git:sync` with
no build flag, and a `--build-if-changes` poll that finds the remote
unchanged - returned without ever finalizing that record.

The record stayed at status=running forever, which has three
consequences on an app polled on a timer:

- PruneAppBuilds only runs from builds-record-finalize, so nothing
  prunes the ticks while the app is idle; they accumulate without bound,
  invisibly, because builds:list caps output at the retention count.
- The next real deploy's ReapAbandonedBuilds finalizes each of them as
  status=failed, exit_code=-1, with finished_at stamped at the moment of
  reaping - indistinguishable on disk from a build that really failed,
  and with a duration that grew to the polling interval.
- That same deploy's prune then keeps the newest records by started_at,
  which after an idle stretch are the ticks, deleting the last real
  deploy's record and log.

Add a builds-record-discard trigger that removes a non-terminal record
and its log, and call it from both no-op paths in cmd-git-sync. The
trigger leaves missing and already-terminal records alone, so it can
never delete real history.

Fixes #9030

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-11 17:00:39 +03:00

163 lines
4.7 KiB
Go

package builds
import (
"errors"
"fmt"
"os"
"strconv"
"time"
"github.com/dokku/dokku/plugins/common"
)
// TriggerInstall sets up the builds plugin's property storage.
func TriggerInstall() error {
if err := common.PropertySetup("builds"); err != nil {
return fmt.Errorf("Unable to install the builds plugin: %s", err.Error())
}
return nil
}
// TriggerPostDelete removes all builds data and properties for the given app.
func TriggerPostDelete(appName string) error {
if err := os.RemoveAll(AppDataDir(appName)); err != nil {
common.LogWarn(fmt.Sprintf("Could not remove builds data for %s: %s", appName, err))
}
if err := common.PropertyDestroy("builds", appName); err != nil {
return err
}
return nil
}
// TriggerPostAppRenameSetup renames the per-app data directory and clones
// builds properties to the new app name.
func TriggerPostAppRenameSetup(oldAppName string, newAppName string) error {
oldDir := AppDataDir(oldAppName)
newDir := AppDataDir(newAppName)
if _, err := os.Stat(oldDir); err == nil {
if err := os.MkdirAll(common.GetAppDataDirectory("builds", ""), 0755); err == nil {
if err := os.Rename(oldDir, newDir); err != nil {
common.LogWarn(fmt.Sprintf("Could not rename builds data dir for %s: %s", oldAppName, err))
}
}
}
if err := common.PropertyClone("builds", oldAppName, newAppName); err != nil {
return err
}
if err := common.PropertyDestroy("builds", oldAppName); err != nil {
return err
}
return nil
}
// TriggerBuildsGenerateID writes a fresh build-id to stdout. The bash callers
// of this trigger consume the value via $(...) capture, so this function MUST
// emit only the build-id and nothing else - no log output, no warnings.
func TriggerBuildsGenerateID() error {
fmt.Println(GenerateBuildID())
return nil
}
// TriggerBuildsRecordStart persists the initial build record on lock-acquire.
//
// Args: <app> <build-id> <pid> <source>
//
// kind is derived from source via BuildSource.DefaultKind(); callers do not
// pass it.
func TriggerBuildsRecordStart(appName, buildID, pidStr, sourceStr string) error {
if appName == "" {
return errors.New("builds-record-start: missing app name")
}
if buildID == "" {
return errors.New("builds-record-start: missing build id")
}
pid, err := strconv.Atoi(pidStr)
if err != nil {
return fmt.Errorf("builds-record-start: invalid pid %q: %w", pidStr, err)
}
source := BuildSource(sourceStr)
if !source.Valid() {
common.LogWarn(fmt.Sprintf("builds-record-start: unknown source %q for app %s, recording as %q", sourceStr, appName, BuildSourceUnknown))
source = BuildSourceUnknown
}
b := Build{
ID: buildID,
App: appName,
Kind: source.DefaultKind(),
PID: pid,
StartedAt: time.Now().UTC(),
Status: BuildStatusRunning,
Source: source,
}
return WriteBuild(b)
}
// TriggerBuildsRecordDiscard drops a record that was started before the caller
// knew whether it would build anything - the git:sync no-op paths, which fetch
// first and only then discover there is nothing to deploy. Records that are
// missing or already terminal are left alone.
//
// Args: <app> <build-id>
func TriggerBuildsRecordDiscard(appName, buildID string) error {
if appName == "" {
return errors.New("builds-record-discard: missing app name")
}
if buildID == "" {
return errors.New("builds-record-discard: missing build id")
}
return DiscardBuild(appName, buildID)
}
// TriggerBuildsRecordFinalize writes the terminal status onto an existing
// build record. It is idempotent: records that are already terminal (or have
// been overwritten by an earlier finalize) are left untouched.
//
// Args: <app> <build-id> <exit-code>
func TriggerBuildsRecordFinalize(appName, buildID, exitStr string) error {
if appName == "" {
return errors.New("builds-record-finalize: missing app name")
}
if buildID == "" {
return errors.New("builds-record-finalize: missing build id")
}
exitCode, err := strconv.Atoi(exitStr)
if err != nil {
return fmt.Errorf("builds-record-finalize: invalid exit code %q: %w", exitStr, err)
}
b, err := ReadBuild(appName, buildID)
if err != nil {
if os.IsNotExist(err) {
common.LogWarn(fmt.Sprintf("builds-record-finalize: no record for %s/%s, skipping", appName, buildID))
return nil
}
return err
}
if b.Status.IsTerminal() {
// Idempotent path - typically hit when builds:cancel finalized the
// record before the dying process reached release_app_deploy_lock.
return PruneAppBuilds(appName)
}
now := time.Now().UTC()
b.FinishedAt = &now
b.ExitCode = &exitCode
if exitCode == 0 {
b.Status = BuildStatusSucceeded
} else {
b.Status = BuildStatusFailed
}
if err := WriteBuild(b); err != nil {
return err
}
return PruneAppBuilds(appName)
}