Merge pull request #4419 from dokku/4392-proxy-parallelism

Add parallelism to certain proxy commands

plugins/proxy/functions.go

@@ -0,0 +1,192 @@
+package proxy
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/dokku/dokku/plugins/common"
+	"github.com/dokku/dokku/plugins/config"
+	"github.com/ryanuber/columnize"
+)
+
+func addProxyPorts(appName string, proxyPortMap []PortMap) error {
+	allPortMaps := getProxyPortMap(appName)
+	allPortMaps = append(allPortMaps, proxyPortMap...)
+
+	return setProxyPorts(appName, allPortMaps)
+}
+
+func filterAppProxyPorts(appName string, scheme string, hostPort int) []PortMap {
+	var filteredProxyMaps []PortMap
+	for _, portMap := range getProxyPortMap(appName) {
+		if portMap.Scheme == scheme && portMap.HostPort == hostPort {
+			filteredProxyMaps = append(filteredProxyMaps, portMap)
+		}
+	}
+
+	return filteredProxyMaps
+}
+
+func getAppProxyType(appName string) string {
+	return config.GetWithDefault(appName, "DOKKU_APP_PROXY_TYPE", "nginx")
+}
+
+func getProxyPortMap(appName string) []PortMap {
+	value := config.GetWithDefault(appName, "DOKKU_PROXY_PORT_MAP", "")
+	portMaps, _ := parseProxyPortMapString(value)
+	return portMaps
+}
+
+func inRange(value int, min int, max int) bool {
+	return min < value && value < max
+}
+
+func listAppProxyPorts(appName string) error {
+	proxyPortMap := getProxyPortMap(appName)
+
+	if len(proxyPortMap) == 0 {
+		return errors.New("No port mappings configured for app")
+	}
+
+	var lines []string
+	if os.Getenv("DOKKU_QUIET_OUTPUT") == "" {
+		lines = append(lines, "-----> scheme:host port:container port")
+	}
+
+	for _, portMap := range proxyPortMap {
+		lines = append(lines, portMap.String())
+	}
+
+	sort.Strings(lines)
+	common.LogInfo1Quiet(fmt.Sprintf("Port mappings for %s", appName))
+	config := columnize.DefaultConfig()
+	config.Delim = ":"
+	config.Prefix = "    "
+	config.Empty = ""
+	fmt.Println(columnize.Format(lines, config))
+	return nil
+}
+
+func parseProxyPortMapString(stringPortMap string) ([]PortMap, error) {
+	var proxyPortMap []PortMap
+
+	for _, v := range strings.Split(strings.TrimSpace(stringPortMap), " ") {
+		parts := strings.SplitN(v, ":", 3)
+		if len(parts) == 1 {
+			hostPort, err := strconv.Atoi(v)
+			if err != nil {
+				return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
+			}
+
+			if !inRange(hostPort, 0, 65536) {
+				return proxyPortMap, fmt.Errorf("Invalid port map %s [hostPort=%d]", v, hostPort)
+			}
+
+			proxyPortMap = append(proxyPortMap, PortMap{
+				HostPort: hostPort,
+				Scheme:   "__internal__",
+			})
+			continue
+		}
+
+		if len(parts) != 3 {
+			return proxyPortMap, fmt.Errorf("Invalid port map %s [len=%d]", v, len(parts))
+		}
+
+		hostPort, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
+		}
+
+		containerPort, err := strconv.Atoi(parts[2])
+		if err != nil {
+			return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
+		}
+
+		if !inRange(hostPort, 0, 65536) {
+			return proxyPortMap, fmt.Errorf("Invalid port map %s [hostPort=%d]", v, hostPort)
+		}
+
+		if !inRange(containerPort, 0, 65536) {
+			return proxyPortMap, fmt.Errorf("Invalid port map %s [containerPort=%d]", v, containerPort)
+		}
+
+		proxyPortMap = append(proxyPortMap, PortMap{
+			ContainerPort: containerPort,
+			HostPort:      hostPort,
+			Scheme:        parts[0],
+		})
+	}
+
+	return uniqueProxyPortMap(proxyPortMap), nil
+}
+
+func removeProxyPorts(appName string, proxyPortMap []PortMap) error {
+	toRemove := map[string]bool{}
+	toRemoveByPort := map[int]bool{}
+
+	for _, portMap := range proxyPortMap {
+		if portMap.AllowsPersistence() {
+			toRemoveByPort[portMap.HostPort] = true
+			continue
+		}
+		toRemove[portMap.String()] = true
+	}
+
+	var toSet []PortMap
+	for _, portMap := range getProxyPortMap(appName) {
+		if toRemove[portMap.String()] {
+			continue
+		}
+
+		if toRemoveByPort[portMap.HostPort] {
+			continue
+		}
+
+		toSet = append(toSet, portMap)
+	}
+
+	if len(toSet) == 0 {
+		keys := []string{"DOKKU_PROXY_PORT_MAP"}
+		return config.UnsetMany(appName, keys, false)
+	}
+
+	return setProxyPorts(appName, toSet)
+}
+
+func setProxyPorts(appName string, proxyPortMap []PortMap) error {
+	var value []string
+	for _, portMap := range uniqueProxyPortMap(proxyPortMap) {
+		if portMap.AllowsPersistence() {
+			continue
+		}
+
+		value = append(value, portMap.String())
+	}
+
+	sort.Strings(value)
+	entries := map[string]string{
+		"DOKKU_PROXY_PORT_MAP": strings.Join(value, " "),
+	}
+	return config.SetMany(appName, entries, false)
+}
+
+func uniqueProxyPortMap(proxyPortMap []PortMap) []PortMap {
+	var unique []PortMap
+	existingPortMaps := map[string]bool{}
+
+	for _, portMap := range proxyPortMap {
+		if existingPortMaps[portMap.String()] {
+			continue
+		}
+
+		existingPortMaps[portMap.String()] = true
+		unique = append(unique, portMap)
+	}
+
+	return unique
+}

plugins/proxy/proxy.go

@@ -1,18 +1,16 @@
 package proxy
 
 import (
-	"errors"
 	"fmt"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
 
 	"github.com/dokku/dokku/plugins/common"
 	"github.com/dokku/dokku/plugins/config"
-	"github.com/ryanuber/columnize"
 )
 
+// RunInSerial is the default value for whether to run a command in parallel or not
+// and defaults to -1 (false)
+const RunInSerial = 0
+
 // PortMap is a struct that contains a scheme:host-port:container-port mapping
 type PortMap struct {
 	ContainerPort int
@@ -29,8 +27,44 @@ func (p PortMap) AllowsPersistence() bool {
 	return p.Scheme == "__internal__"
 }
 
-func inRange(value int, min int, max int) bool {
-	return min < value && value < max
+// BuildConfig rebuilds the proxy config for the specified app
+func BuildConfig(appName string) error {
+	return common.PlugnTrigger("proxy-build-config", []string{appName}...)
+}
+
+// Disable disables proxy implementations for the specified app
+func Disable(appName string) error {
+	if !IsAppProxyEnabled(appName) {
+		common.LogInfo1("Proxy is already disable for app")
+		return nil
+	}
+
+	common.LogInfo1("Disabling proxy for app")
+	entries := map[string]string{
+		"DOKKU_DISABLE_PROXY": "1",
+	}
+
+	if err := config.SetMany(appName, entries, false); err != nil {
+		return err
+	}
+
+	return common.PlugnTrigger("proxy-disable", []string{appName}...)
+}
+
+// Enable enables proxy implementations for the specified app
+func Enable(appName string) error {
+	if IsAppProxyEnabled(appName) {
+		common.LogInfo1("Proxy is already enabled for app")
+		return nil
+	}
+
+	common.LogInfo1("Enabling proxy for app")
+	keys := []string{"DOKKU_DISABLE_PROXY"}
+	if err := config.UnsetMany(appName, keys, false); err != nil {
+		return err
+	}
+
+	return common.PlugnTrigger("proxy-enable", []string{appName}...)
 }
 
 // IsAppProxyEnabled returns true if proxy is enabled; otherwise return false
@@ -42,177 +76,3 @@ func IsAppProxyEnabled(appName string) bool {
 	}
 	return proxyEnabled
 }
-
-func addProxyPorts(appName string, proxyPortMap []PortMap) error {
-	allPortMaps := getProxyPortMap(appName)
-	allPortMaps = append(allPortMaps, proxyPortMap...)
-
-	return setProxyPorts(appName, allPortMaps)
-}
-
-func filterAppProxyPorts(appName string, scheme string, hostPort int) []PortMap {
-	var filteredProxyMaps []PortMap
-	for _, portMap := range getProxyPortMap(appName) {
-		if portMap.Scheme == scheme && portMap.HostPort == hostPort {
-			filteredProxyMaps = append(filteredProxyMaps, portMap)
-		}
-	}
-
-	return filteredProxyMaps
-}
-
-func getAppProxyType(appName string) string {
-	return config.GetWithDefault(appName, "DOKKU_APP_PROXY_TYPE", "nginx")
-}
-
-func getProxyPortMap(appName string) []PortMap {
-	value := config.GetWithDefault(appName, "DOKKU_PROXY_PORT_MAP", "")
-	portMaps, _ := parseProxyPortMapString(value)
-	return portMaps
-}
-
-func listAppProxyPorts(appName string) error {
-	proxyPortMap := getProxyPortMap(appName)
-
-	if len(proxyPortMap) == 0 {
-		return errors.New("No port mappings configured for app")
-	}
-
-	var lines []string
-	if os.Getenv("DOKKU_QUIET_OUTPUT") == "" {
-		lines = append(lines, "-----> scheme:host port:container port")
-	}
-
-	for _, portMap := range proxyPortMap {
-		lines = append(lines, portMap.String())
-	}
-
-	sort.Strings(lines)
-	common.LogInfo1Quiet(fmt.Sprintf("Port mappings for %s", appName))
-	config := columnize.DefaultConfig()
-	config.Delim = ":"
-	config.Prefix = "    "
-	config.Empty = ""
-	fmt.Println(columnize.Format(lines, config))
-	return nil
-}
-
-func setProxyPorts(appName string, proxyPortMap []PortMap) error {
-	var value []string
-	for _, portMap := range uniqueProxyPortMap(proxyPortMap) {
-		if portMap.AllowsPersistence() {
-			continue
-		}
-
-		value = append(value, portMap.String())
-	}
-
-	sort.Strings(value)
-	entries := map[string]string{
-		"DOKKU_PROXY_PORT_MAP": strings.Join(value, " "),
-	}
-	return config.SetMany(appName, entries, false)
-}
-
-func removeProxyPorts(appName string, proxyPortMap []PortMap) error {
-	toRemove := map[string]bool{}
-	toRemoveByPort := map[int]bool{}
-
-	for _, portMap := range proxyPortMap {
-		if portMap.AllowsPersistence() {
-			toRemoveByPort[portMap.HostPort] = true
-			continue
-		}
-		toRemove[portMap.String()] = true
-	}
-
-	var toSet []PortMap
-	for _, portMap := range getProxyPortMap(appName) {
-		if toRemove[portMap.String()] {
-			continue
-		}
-
-		if toRemoveByPort[portMap.HostPort] {
-			continue
-		}
-
-		toSet = append(toSet, portMap)
-	}
-
-	if len(toSet) == 0 {
-		keys := []string{"DOKKU_PROXY_PORT_MAP"}
-		return config.UnsetMany(appName, keys, false)
-	}
-
-	return setProxyPorts(appName, toSet)
-}
-
-func parseProxyPortMapString(stringPortMap string) ([]PortMap, error) {
-	var proxyPortMap []PortMap
-
-	for _, v := range strings.Split(strings.TrimSpace(stringPortMap), " ") {
-		parts := strings.SplitN(v, ":", 3)
-		if len(parts) == 1 {
-			hostPort, err := strconv.Atoi(v)
-			if err != nil {
-				return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
-			}
-
-			if !inRange(hostPort, 0, 65536) {
-				return proxyPortMap, fmt.Errorf("Invalid port map %s [hostPort=%d]", v, hostPort)
-			}
-
-			proxyPortMap = append(proxyPortMap, PortMap{
-				HostPort: hostPort,
-				Scheme:   "__internal__",
-			})
-			continue
-		}
-
-		if len(parts) != 3 {
-			return proxyPortMap, fmt.Errorf("Invalid port map %s [len=%d]", v, len(parts))
-		}
-
-		hostPort, err := strconv.Atoi(parts[1])
-		if err != nil {
-			return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
-		}
-
-		containerPort, err := strconv.Atoi(parts[2])
-		if err != nil {
-			return proxyPortMap, fmt.Errorf("Invalid port map %s [err=%s]", v, err.Error())
-		}
-
-		if !inRange(hostPort, 0, 65536) {
-			return proxyPortMap, fmt.Errorf("Invalid port map %s [hostPort=%d]", v, hostPort)
-		}
-
-		if !inRange(containerPort, 0, 65536) {
-			return proxyPortMap, fmt.Errorf("Invalid port map %s [containerPort=%d]", v, containerPort)
-		}
-
-		proxyPortMap = append(proxyPortMap, PortMap{
-			ContainerPort: containerPort,
-			HostPort:      hostPort,
-			Scheme:        parts[0],
-		})
-	}
-
-	return uniqueProxyPortMap(proxyPortMap), nil
-}
-
-func uniqueProxyPortMap(proxyPortMap []PortMap) []PortMap {
-	var unique []PortMap
-	existingPortMaps := map[string]bool{}
-
-	for _, portMap := range proxyPortMap {
-		if existingPortMaps[portMap.String()] {
-			continue
-		}
-
-		existingPortMaps[portMap.String()] = true
-		unique = append(unique, portMap)
-	}
-
-	return unique
-}

plugins/proxy/src/subcommands/subcommands.go

@@ -20,19 +20,25 @@ func main() {
 	switch subcommand {
 	case "build-config":
 		args := flag.NewFlagSet("proxy:build-config", flag.ExitOnError)
+		allApps := args.Bool("all", false, "--all: build-config for all apps")
+		parallelCount := args.Int("parallel", proxy.RunInSerial, "--parallel: number of apps to build-config for in parallel, -1 to match cpu count")
 		args.Parse(os.Args[2:])
 		appName := args.Arg(0)
-		err = proxy.CommandBuildConfig(appName)
+		err = proxy.CommandBuildConfig(appName, *allApps, *parallelCount)
 	case "disable":
 		args := flag.NewFlagSet("proxy:disable", flag.ExitOnError)
+		allApps := args.Bool("all", false, "--all: disable proxy for all apps")
+		parallelCount := args.Int("parallel", proxy.RunInSerial, "--parallel: number of apps to disable proxy for in parallel, -1 to match cpu count")
 		args.Parse(os.Args[2:])
 		appName := args.Arg(0)
-		err = proxy.CommandDisable(appName)
+		err = proxy.CommandDisable(appName, *allApps, *parallelCount)
 	case "enable":
 		args := flag.NewFlagSet("proxy:enable", flag.ExitOnError)
+		allApps := args.Bool("all", false, "--all: enable proxy for all apps")
+		parallelCount := args.Int("parallel", proxy.RunInSerial, "--parallel: number of apps to enable proxy for in parallel, -1 to match cpu count")
 		args.Parse(os.Args[2:])
 		appName := args.Arg(0)
-		err = proxy.CommandEnable(appName)
+		err = proxy.CommandEnable(appName, *allApps, *parallelCount)
 	case "ports":
 		args := flag.NewFlagSet("proxy:ports", flag.ExitOnError)
 		args.Parse(os.Args[2:])

plugins/proxy/subcommands.go

@@ -9,55 +9,42 @@ import (
 )
 
 // CommandBuildConfig rebuilds config for a given app
-func CommandBuildConfig(appName string) error {
+func CommandBuildConfig(appName string, allApps bool, parallelCount int) error {
+	if allApps {
+		return common.RunCommandAgainstAllApps(BuildConfig, "build-config", parallelCount)
+	}
+
 	if err := common.VerifyAppName(appName); err != nil {
 		return err
 	}
 
-	return common.PlugnTrigger("proxy-build-config", []string{appName}...)
+	return BuildConfig(appName)
 }
 
 // CommandDisable disables the proxy for app via command line
-func CommandDisable(appName string) error {
+func CommandDisable(appName string, allApps bool, parallelCount int) error {
+	if allApps {
+		return common.RunCommandAgainstAllApps(Disable, "disable", parallelCount)
+	}
+
 	if err := common.VerifyAppName(appName); err != nil {
 		return err
 	}
 
-	if !IsAppProxyEnabled(appName) {
-		common.LogInfo1("Proxy is already disable for app")
-		return nil
-	}
-
-	common.LogInfo1("Disabling proxy for app")
-	entries := map[string]string{
-		"DOKKU_DISABLE_PROXY": "1",
-	}
-
-	if err := config.SetMany(appName, entries, false); err != nil {
-		return err
-	}
-
-	return common.PlugnTrigger("proxy-disable", []string{appName}...)
+	return Disable(appName)
 }
 
 // CommandEnable enables the proxy for app via command line
-func CommandEnable(appName string) error {
+func CommandEnable(appName string, allApps bool, parallelCount int) error {
+	if allApps {
+		return common.RunCommandAgainstAllApps(Enable, "enable", parallelCount)
+	}
+
 	if err := common.VerifyAppName(appName); err != nil {
 		return err
 	}
 
-	if IsAppProxyEnabled(appName) {
-		common.LogInfo1("Proxy is already enabled for app")
-		return nil
-	}
-
-	common.LogInfo1("Enabling proxy for app")
-	keys := []string{"DOKKU_DISABLE_PROXY"}
-	if err := config.UnsetMany(appName, keys, false); err != nil {
-		return err
-	}
-
-	return common.PlugnTrigger("proxy-enable", []string{appName}...)
+	return Enable(appName)
 }
 
 // CommandPorts is a cmd wrapper to list proxy port mappings for an app