A deploy that exited before releasing its lock, such as after a failed build, left `.deploy.lock` behind, so `apps:locked` reported a lock nothing held and the build record stayed running. The lock is now released and the record finalized whenever the deploy exits. `apps:lock` never actually blocked deploys, as it only created the file deploys lock. It now creates its own lock that git pushes, `ps:rebuild`, `git:sync`, and the `git:from-*` commands refuse to deploy past, and `apps:locked` only reports a lock when the app was locked via `apps:lock` or a deploy is in progress. Locks created by `apps:lock` in older versions are migrated on install.
175 lines
4.6 KiB
Go
175 lines
4.6 KiB
Go
package apps
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/dokku/dokku/plugins/common"
|
|
)
|
|
|
|
// TriggerAppCreate is a trigger to create an app
|
|
func TriggerAppCreate(appName string) error {
|
|
return createApp(appName)
|
|
}
|
|
|
|
// TriggerAppDestroy is a trigger to destroy an app
|
|
func TriggerAppDestroy(appName string) error {
|
|
return destroyApp(appName)
|
|
}
|
|
|
|
// TriggerAppExists is a trigger to check if an app exists
|
|
func TriggerAppExists(appName string) error {
|
|
return appExists(appName)
|
|
}
|
|
|
|
// TriggerAppMaybeCreate is a trigger to allow gated app creation
|
|
func TriggerAppMaybeCreate(appName string) error {
|
|
return maybeCreateApp(appName)
|
|
}
|
|
|
|
// TriggerDeploySourceSet sets the current deploy source
|
|
func TriggerDeploySourceSet(appName string, sourceType string, sourceMetadata string) error {
|
|
if err := common.PropertyWrite("apps", appName, "deploy-source", sourceType); err != nil {
|
|
return err
|
|
}
|
|
|
|
return common.PropertyWrite("apps", appName, "deploy-source-metadata", sourceMetadata)
|
|
}
|
|
|
|
// TriggerInstall runs the install step for the apps plugin
|
|
func TriggerInstall() error {
|
|
if err := common.PropertySetup("apps"); err != nil {
|
|
return fmt.Errorf("Unable to install the apps plugin: %s", err.Error())
|
|
}
|
|
|
|
if err := common.SetupAppData("apps"); err != nil {
|
|
return err
|
|
}
|
|
|
|
apps, err := common.UnfilteredDokkuApps()
|
|
if err != nil && !errors.Is(err, common.NoAppsExist) {
|
|
return nil
|
|
}
|
|
|
|
if err := common.MigrateConfigToProperties("apps", []common.MigrateConfigEntry{
|
|
{
|
|
GlobalConfigVar: "DOKKU_DISABLE_APP_AUTOCREATION",
|
|
Property: "disable-autocreation",
|
|
},
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
// migrate all created-at values from app mod-time to property
|
|
for _, appName := range apps {
|
|
if common.PropertyExists("apps", appName, "created-at") {
|
|
continue
|
|
}
|
|
|
|
fi, err := os.Stat(common.AppRoot(appName))
|
|
if err != nil {
|
|
// if we can't get the time, just write the current one out as a stub
|
|
if err := common.PropertyWrite("apps", appName, "created-at", fmt.Sprintf("%d", time.Now().Unix())); err != nil {
|
|
return err
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
if err := common.PropertyWrite("apps", appName, "created-at", fmt.Sprintf("%d", fi.ModTime().Unix())); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, appName := range apps {
|
|
if err := migrateManualLock(appName); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// migrateManualLock converts a lock created by apps:lock before manual locks
|
|
// had their own file. Deploys write their build id into the deploy lock file,
|
|
// so an empty one that no deploy holds was created by apps:lock.
|
|
func migrateManualLock(appName string) error {
|
|
lockPath := getLockPath(appName)
|
|
fi, err := os.Stat(lockPath)
|
|
if err != nil || fi.Size() != 0 || deployLockHeld(appName) {
|
|
return nil
|
|
}
|
|
|
|
if err := os.Rename(lockPath, getManualLockPath(appName)); err != nil {
|
|
return fmt.Errorf("Unable to migrate the deploy lock for %s: %w", appName, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// removeLockFiles removes the given lock files, ignoring ones that do not exist
|
|
func removeLockFiles(lockPaths ...string) error {
|
|
for _, lockPath := range lockPaths {
|
|
if err := os.Remove(lockPath); err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// TriggerPostAppCloneSetup creates new apps files
|
|
func TriggerPostAppCloneSetup(oldAppName string, newAppName string) error {
|
|
err := common.PropertyClone("apps", oldAppName, newAppName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := common.CloneAppData("apps", oldAppName, newAppName); err != nil {
|
|
return err
|
|
}
|
|
|
|
return removeLockFiles(getManualLockPath(newAppName), getLockPath(newAppName))
|
|
}
|
|
|
|
// TriggerPostAppRename removes the old app data
|
|
func TriggerPostAppRename(oldAppName string, newAppName string) error {
|
|
return common.MigrateAppDataDirectory("apps", oldAppName, newAppName)
|
|
}
|
|
|
|
// TriggerPostAppRenameSetup renames apps files
|
|
func TriggerPostAppRenameSetup(oldAppName string, newAppName string) error {
|
|
if err := common.PropertyClone("apps", oldAppName, newAppName); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := common.PropertyDestroy("apps", oldAppName); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := common.CloneAppData("apps", oldAppName, newAppName); err != nil {
|
|
return err
|
|
}
|
|
|
|
return removeLockFiles(getLockPath(newAppName))
|
|
}
|
|
|
|
// TriggerPostCreate ensures apps have the correct data directory structure
|
|
func TriggerPostCreate(appName string) error {
|
|
return common.CreateAppDataDirectory("apps", appName)
|
|
}
|
|
|
|
// TriggerPostDelete destroys the apps data for a given app container
|
|
func TriggerPostDelete(appName string) error {
|
|
dataErr := common.RemoveAppDataDirectory("apps", appName)
|
|
propertyErr := common.PropertyDestroy("apps", appName)
|
|
|
|
if dataErr != nil {
|
|
return dataErr
|
|
}
|
|
|
|
return propertyErr
|
|
}
|