Files
dokku/plugins/ports/triggers.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

230 lines
5.4 KiB
Go

package ports
import (
"encoding/json"
"fmt"
"sort"
"github.com/dokku/dokku/plugins/common"
)
// TriggerInstall migrates the ports config to properties
func TriggerInstall() error {
if err := common.PropertySetup("ports"); err != nil {
return fmt.Errorf("Unable to install the ports plugin: %s", err.Error())
}
if err := common.MigrateConfigToProperties("ports", []common.MigrateConfigEntry{
{
ConfigVar: "DOKKU_PROXY_PORT_MAP",
Property: "map",
ListProperty: true,
Transform: transformPortMap,
},
}); err != nil {
return err
}
return nil
}
// TriggerPortsClear removes all ports for the specified app
func TriggerPortsClear(appName string) error {
return clearPorts(appName)
}
// TriggerPortsConfigure ensures we have a port mapping
func TriggerPortsConfigure(appName string) error {
if err := initializeProxyPort(appName); err != nil {
return err
}
if err := initializeProxySSLPort(appName); err != nil {
return err
}
return nil
}
// TriggerPortsGet prints out the port mapping for a given app
func TriggerPortsGet(appName string, format string) error {
if format == "" {
format = "stdout"
}
if format != "json" && format != "stdout" {
return fmt.Errorf("Invalid format specified: %s", format)
}
portMaps := getPortMaps(appName)
if len(portMaps) == 0 {
portMaps = getDetectedPortMaps(appName)
}
persisted := []PortMap{}
for _, portMap := range portMaps {
if portMap.AllowsPersistence() {
continue
}
persisted = append(persisted, portMap)
}
persisted = uniquePortMaps(persisted)
if format == "json" {
b, err := json.Marshal(persisted)
if err != nil {
return fmt.Errorf("Unable to marshal port mapping: %s", err.Error())
}
fmt.Println(string(b))
return nil
}
for _, portMap := range persisted {
fmt.Println(portMap)
}
return nil
}
// TriggerPortsGetAvailable prints out an available port greater than 1024
func TriggerPortsGetAvailable() error {
port := getAvailablePort()
if port > 0 {
common.Log(fmt.Sprint(port))
}
return nil
}
// TriggerPortsGetProperty writes the ports key to stdout for a given app container
func TriggerPortsGetProperty(appName string, key string) error {
if key == "proxy-port" {
fmt.Println(getComputedProxyPort(appName))
return nil
}
if key == "proxy-ssl-port" {
fmt.Println(getComputedProxySSLPort(appName))
return nil
}
fmt.Println(common.PropertyGet("ports", appName, key))
return nil
}
// TriggerPortsSetDetected writes out detected ports
func TriggerPortsSetDetected(appName string, portMapString string) error {
portMaps, _ := parsePortMapString(portMapString)
var value []string
for _, portMap := range uniquePortMaps(portMaps) {
if portMap.AllowsPersistence() {
continue
}
value = append(value, portMap.String())
}
sort.Strings(value)
return common.PropertyListWrite("ports", appName, "map-detected", value)
}
// TriggerPostAppCloneSetup creates new ports files
func TriggerPostAppCloneSetup(oldAppName string, newAppName string) error {
err := common.PropertyClone("ports", oldAppName, newAppName)
if err != nil {
return err
}
return nil
}
// TriggerPostAppRenameSetup renames ports files
func TriggerPostAppRenameSetup(oldAppName string, newAppName string) error {
if err := common.PropertyClone("ports", oldAppName, newAppName); err != nil {
return err
}
if err := common.PropertyDestroy("ports", oldAppName); err != nil {
return err
}
return nil
}
// TriggerPostCertsRemove unsets port properties after SSL cert is removed
func TriggerPostCertsRemove(appName string) error {
if err := common.PropertyDelete("proxy", appName, "proxy-ssl-port"); err != nil {
return err
}
return common.PropertyLock("ports", appName, func(p *common.LockedProperties) error {
return removePortMapsWithLock(p, appName, filterAppPortMaps(appName, "https", 443))
})
}
// TriggerPostCertsUpdate sets port properties after SSL cert is added
func TriggerPostCertsUpdate(appName string) error {
return common.PropertyLock("ports", appName, func(p *common.LockedProperties) error {
return postCertsUpdateWithLock(p, appName)
})
}
// postCertsUpdateWithLock adds https:443 port maps mirroring the app's http:80
// port maps. The caller must hold the app's ports property lock.
func postCertsUpdateWithLock(p *common.LockedProperties, appName string) error {
port := common.PropertyGet("proxy", appName, "proxy-port")
sslPort := common.PropertyGet("proxy", appName, "proxy-ssl-port")
portMaps := getPortMaps(appName)
if port == "80" {
common.PropertyDelete("proxy", appName, "proxy-port")
}
if sslPort == "443" {
common.PropertyDelete("proxy", appName, "proxy-ssl-port")
}
for _, portMap := range portMaps {
if portMap.Scheme == "https" && portMap.HostPort == 443 {
return nil
}
}
var http80Ports []PortMap
for _, portMap := range portMaps {
if portMap.Scheme == "http" && portMap.HostPort == 80 {
http80Ports = append(http80Ports, portMap)
}
}
http80Ports = uniquePortMaps(http80Ports)
if len(http80Ports) > 0 {
var toAdd []PortMap
for _, portMap := range http80Ports {
toAdd = append(toAdd, PortMap{
Scheme: "https",
HostPort: 443,
ContainerPort: portMap.ContainerPort,
})
}
if err := addPortMapsWithLock(p, appName, toAdd); err != nil {
return err
}
}
return nil
}
// TriggerPostDelete is the ports post-delete plugin trigger
func TriggerPostDelete(appName string) error {
if err := common.PropertyDestroy("ports", appName); err != nil {
common.LogWarn(err.Error())
}
return nil
}