Files
dokku/plugins/config/migrate.go
T
Jose Diaz-Gonzalez 9df45f6a6e fix: serialize concurrent property updates
Concurrent commands for the same app could each read a setting, change it, and write it back, so all of them exited successfully while silently dropping changes made by the others. Updates to app settings are now serialized so every change is kept, and readers never see a partially written value.
2026-10-21 21:21:57 -04:00

194 lines
6.7 KiB
Go

package config
import (
"fmt"
"os"
"path/filepath"
"strings"
"github.com/dokku/dokku/plugins/common"
)
// envMigratedProperty records that an ENV file has been drained out of the
// pre-0.38 location into the config property path.
const envMigratedProperty = "env-migrated"
// MigrateEnvFiles drains the pre-0.38 ENV files - $DOKKU_ROOT/ENV and
// $DOKKU_ROOT/<app>/ENV - into the config property path, removing each file as
// soon as it has been drained.
//
// It is safe to call from any plugin's install trigger, and does so via the
// config-migrate-env plugin trigger. Plugins whose enabled-directory name sorts
// before "config" - apps, builder and checks among them - run their deprecated
// DOKKU_* config var to property migrations before the config plugin's own
// install trigger would have relocated these files, and would otherwise read an
// empty environment and silently migrate nothing. Nothing here may assume the
// config install trigger has already run.
func MigrateEnvFiles() error {
if err := common.PropertySetup("config"); err != nil {
return fmt.Errorf("Unable to setup config properties: %s", err.Error())
}
if err := migrateGlobalEnv(); err != nil {
return fmt.Errorf("Unable to migrate global environment: %s", err.Error())
}
apps, err := common.UnfilteredDokkuApps()
if err != nil {
return nil
}
for _, appName := range apps {
if err := migrateAppEnv(appName); err != nil {
return fmt.Errorf("Unable to migrate environment for %s: %s", appName, err.Error())
}
}
return nil
}
// migrateGlobalEnv drains $DOKKU_ROOT/ENV into the global config property path.
func migrateGlobalEnv() error {
if err := common.PropertySetup("--global"); err != nil {
return fmt.Errorf("Unable to setup global environment: %s", err.Error())
}
oldGlobalEnvFile := filepath.Join(common.MustGetEnv("DOKKU_ROOT"), "ENV")
return common.LockDirectory(filepath.Dir(getGlobalFile()), func() error {
globalEnv, err := LoadGlobalEnv()
if err != nil {
return fmt.Errorf("Unable to load global environment: %s", err.Error())
}
return drainLegacyEnvFile("--global", oldGlobalEnvFile, globalEnv)
})
}
// migrateAppEnv drains $DOKKU_ROOT/<app>/ENV into the app's config property path.
func migrateAppEnv(appName string) error {
if err := common.PropertySetupApp("config", appName); err != nil {
return fmt.Errorf("Unable to setup app environment: %s", err.Error())
}
if err := setupAppConfigDir(appName); err != nil {
return fmt.Errorf("Unable to setup app config directory: %s", err.Error())
}
appFile, err := getAppFile(appName)
if err != nil {
return err
}
oldEnvFile := filepath.Join(common.AppRoot(appName), "ENV")
return common.LockDirectory(filepath.Dir(appFile), func() error {
env, err := LoadAppEnv(appName)
if err != nil {
return fmt.Errorf("Unable to load app environment: %s", err.Error())
}
return drainLegacyEnvFile(appName, oldEnvFile, env)
})
}
// drainLegacyEnvFile merges the legacy ENV file at oldEnvFile into env, records
// the migration against name, and removes the legacy file. The file is only
// removed once the merged environment has been written successfully, so a parse
// or write failure leaves the original in place.
//
// The merge happens once and only once. A legacy file that is still there when
// the migration is already on record is handed to preserveStaleEnvFile instead:
// releases 0.38.0 through 0.38.25 recorded the migration and left the file
// behind on purpose, so importing it would replay the environment as it stood
// at that upgrade over every config:set and config:unset made since.
func drainLegacyEnvFile(name string, oldEnvFile string, env *Env) error {
migrated := common.PropertyGetDefault("config", name, envMigratedProperty, "") == "true"
if !common.FileExists(oldEnvFile) {
if migrated {
return nil
}
return writeEnvMigrated(name)
}
if migrated {
return preserveStaleEnvFile(name, oldEnvFile, env)
}
oldEnv, err := loadFromFile(name, oldEnvFile)
if err != nil {
return fmt.Errorf("Unable to load old environment: %s", err.Error())
}
env.Merge(oldEnv)
if err := env.Write(); err != nil {
return fmt.Errorf("Unable to write environment: %s", err.Error())
}
if err := writeEnvMigrated(name); err != nil {
return err
}
if err := os.Remove(oldEnvFile); err != nil {
return fmt.Errorf("Unable to remove migrated file %s: %s", oldEnvFile, err.Error())
}
return nil
}
// preserveStaleEnvFile clears a legacy ENV file that outlived its own migration
// out of the way without importing any of it. A file whose values all match the
// current environment has nothing left to give and is removed outright;
// otherwise it is moved alongside itself with a .migrated suffix and the keys it
// disagrees on are named, so an operator who did write it by hand can still
// recover the values through `dokku config:set`.
//
// The preserved copy is the operator's to delete. It holds everything the file
// was not allowed to import, which includes keys that were unset on purpose, so
// leaving a revoked secret sitting in a file dokku no longer reads is not what
// anyone wants once its contents have been reviewed.
func preserveStaleEnvFile(name string, oldEnvFile string, env *Env) error {
staleEnv, err := loadFromFile(name, oldEnvFile)
if err != nil {
return fmt.Errorf("Unable to load stale environment: %s", err.Error())
}
diverged := divergedKeys(staleEnv, env)
if len(diverged) == 0 {
if err := os.Remove(oldEnvFile); err != nil {
return fmt.Errorf("Unable to remove stale file %s: %s", oldEnvFile, err.Error())
}
return nil
}
preservedFile := oldEnvFile + ".migrated"
common.LogWarn(fmt.Sprintf("Not importing already-migrated ENV file %s: the current config takes precedence for %s", oldEnvFile, strings.Join(diverged, " ")))
common.LogWarn(fmt.Sprintf("Preserved at %s: re-apply anything still needed with dokku config:set, then delete it - dokku does not read it and it may hold values that were unset on purpose", preservedFile))
if err := os.Rename(oldEnvFile, preservedFile); err != nil {
return fmt.Errorf("Unable to preserve stale file %s: %s", oldEnvFile, err.Error())
}
return nil
}
// divergedKeys returns the keys stale holds that env either does not have at all
// or holds a different value for.
func divergedKeys(stale *Env, env *Env) []string {
diverged := []string{}
for _, key := range stale.Keys() {
staleValue, _ := stale.Get(key)
if value, ok := env.Get(key); !ok || value != staleValue {
diverged = append(diverged, key)
}
}
return diverged
}
func writeEnvMigrated(name string) error {
if err := common.PropertyWrite("config", name, envMigratedProperty, "true"); err != nil {
return fmt.Errorf("Unable to set %s property: %s", envMigratedProperty, err.Error())
}
return nil
}