refactor: bubble up error handling so that standard exit codes can be set at the top-level

LogFail shouldn't be called internally if at all possible.

plugins/network/functions.go

@@ -12,7 +12,7 @@ import (
 )
 
 // attachAppToNetwork attaches a container to a network
-func attachAppToNetwork(containerID string, networkName string, appName string, phase string, processType string) {
+func attachAppToNetwork(containerID string, networkName string, appName string, phase string, processType string) error {
 	cmdParts := []string{
 		common.DockerBin(),
 		"network",
@@ -50,8 +50,10 @@ func attachAppToNetwork(containerID string, networkName string, appName string,
 	_, err := attachCmd.Output()
 	if err != nil {
 		err = errors.New(strings.TrimSpace(stderr.String()))
-		common.LogFail(fmt.Sprintf("Unable to attach container to network: %v", err.Error()))
+		return fmt.Errorf("Unable to attach container to network: %v", err.Error())
 	}
+
+	return nil
 }
 
 // isConflictingPropertyValue returns true if the other attach property has a conflicting value

plugins/network/src/subcommands/subcommands.go

@@ -68,7 +68,7 @@ func main() {
 		value := args.Arg(2)
 		err = network.CommandSet(appName, property, value)
 	default:
-		common.LogFail(fmt.Sprintf("Invalid plugin subcommand call: %s", subcommand))
+		err = fmt.Errorf("Invalid plugin subcommand call: %s", subcommand)
 	}
 
 	if err != nil {

plugins/network/src/triggers/triggers.go

@@ -19,49 +19,49 @@ func main() {
 	var err error
 	switch trigger {
 	case "install":
-		network.TriggerInstall()
+		err = network.TriggerInstall()
 	case "network-build-config":
 		appName := flag.Arg(0)
-		network.BuildConfig(appName)
+		err = network.BuildConfig(appName)
 	case "network-compute-ports":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
 		isHerokuishContainer := common.ToBool(flag.Arg(2))
-		network.TriggerNetworkComputePorts(appName, processType, isHerokuishContainer)
+		err = network.TriggerNetworkComputePorts(appName, processType, isHerokuishContainer)
 	case "network-config-exists":
 		appName := flag.Arg(0)
-		network.TriggerNetworkConfigExists(appName)
+		err = network.TriggerNetworkConfigExists(appName)
 	case "network-get-ipaddr":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
 		containerID := flag.Arg(2)
-		network.TriggerNetworkGetIppaddr(appName, processType, containerID)
+		err = network.TriggerNetworkGetIppaddr(appName, processType, containerID)
 	case "network-get-listeners":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
-		network.TriggerNetworkGetListeners(appName, processType)
+		err = network.TriggerNetworkGetListeners(appName, processType)
 	case "network-get-port":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
 		containerID := flag.Arg(2)
 		isHerokuishContainer := common.ToBool(flag.Arg(3))
-		network.TriggerNetworkGetPort(appName, processType, containerID, isHerokuishContainer)
+		err = network.TriggerNetworkGetPort(appName, processType, containerID, isHerokuishContainer)
 	case "network-get-property":
 		appName := flag.Arg(0)
 		property := flag.Arg(1)
-		network.TriggerNetworkGetProperty(appName, property)
+		err = network.TriggerNetworkGetProperty(appName, property)
 	case "network-write-ipaddr":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
 		containerIndex := flag.Arg(2)
 		ip := flag.Arg(3)
-		network.TriggerNetworkWriteIpaddr(appName, processType, containerIndex, ip)
+		err = network.TriggerNetworkWriteIpaddr(appName, processType, containerIndex, ip)
 	case "network-write-port":
 		appName := flag.Arg(0)
 		processType := flag.Arg(1)
 		containerIndex := flag.Arg(2)
 		port := flag.Arg(3)
-		network.TriggerNetworkWritePort(appName, processType, containerIndex, port)
+		err = network.TriggerNetworkWritePort(appName, processType, containerIndex, port)
 	case "post-app-clone-setup":
 		oldAppName := flag.Arg(0)
 		newAppName := flag.Arg(1)
@@ -76,21 +76,21 @@ func main() {
 		appName := flag.Arg(2)
 		phase := flag.Arg(3)
 		processType := flag.Arg(4)
-		network.TriggerPostContainerCreate(containerType, containerID, appName, phase, processType)
+		err = network.TriggerPostContainerCreate(containerType, containerID, appName, phase, processType)
 	case "post-create":
 		appName := flag.Arg(0)
-		network.TriggerPostCreate(appName)
+		err = network.TriggerPostCreate(appName)
 	case "post-delete":
 		appName := flag.Arg(0)
-		network.TriggerPostDelete(appName)
+		err = network.TriggerPostDelete(appName)
 	case "core-post-deploy":
 		appName := flag.Arg(0)
-		network.TriggerCorePostDeploy(appName)
+		err = network.TriggerCorePostDeploy(appName)
 	case "report":
 		appName := flag.Arg(0)
 		err = network.ReportSingleApp(appName, "", "")
 	default:
-		common.LogFail(fmt.Sprintf("Invalid plugin trigger call: %s", trigger))
+		err = fmt.Errorf("Invalid plugin trigger call: %s", trigger)
 	}
 
 	if err != nil {

plugins/network/subcommands.go

@@ -79,7 +79,7 @@ func CommandExists(networkName string) error {
 	if exists {
 		common.LogInfo1Quiet("Network exists")
 	} else {
-		common.LogFail("Network does not exist")
+		return errors.New("Network does not exist")
 	}
 
 	return nil

plugins/network/triggers.go

@@ -11,15 +11,16 @@ import (
 )
 
 // TriggerInstall runs the install step for the network plugin
-func TriggerInstall() {
+func TriggerInstall() error {
 	if err := common.PropertySetup("network"); err != nil {
-		common.LogFail(fmt.Sprintf("Unable to install the network plugin: %s", err.Error()))
+		return fmt.Errorf("Unable to install the network plugin: %s", err.Error())
 	}
 
 	apps, err := common.DokkuApps()
 	if err != nil {
-		return
+		return nil
 	}
+
 	for _, appName := range apps {
 		if common.PropertyExists("network", appName, "bind-all-interfaces") {
 			continue
@@ -36,10 +37,12 @@ func TriggerInstall() {
 			}
 		}
 	}
+
+	return nil
 }
 
 // TriggerNetworkComputePorts computes the ports for a given app container
-func TriggerNetworkComputePorts(appName string, processType string, isHerokuishContainer bool) {
+func TriggerNetworkComputePorts(appName string, processType string, isHerokuishContainer bool) error {
 	var dockerfilePorts []string
 	if !isHerokuishContainer {
 		dokkuDockerfilePorts := strings.Trim(config.GetWithDefault(appName, "DOKKU_DOCKERFILE_PORTS", ""), " ")
@@ -60,80 +63,91 @@ func TriggerNetworkComputePorts(appName string, processType string, isHerokuishC
 			ports = append(ports, port)
 		}
 	}
+
 	fmt.Println(strings.Join(ports, " "))
+	return nil
 }
 
 // TriggerNetworkConfigExists writes true or false to stdout whether a given app has network config
-func TriggerNetworkConfigExists(appName string) {
+func TriggerNetworkConfigExists(appName string) error {
 	if HasNetworkConfig(appName) {
 		fmt.Println("true")
-		return
+		return nil
 	}
 
 	fmt.Println("false")
+	return nil
 }
 
 // TriggerNetworkGetIppaddr writes the ipaddress to stdout for a given app container
-func TriggerNetworkGetIppaddr(appName string, processType string, containerID string) {
+func TriggerNetworkGetIppaddr(appName string, processType string, containerID string) error {
 	ipAddress := GetContainerIpaddress(appName, processType, containerID)
 	fmt.Println(ipAddress)
+	return nil
 }
 
 // TriggerNetworkGetListeners returns the listeners (host:port combinations) for a given app container
-func TriggerNetworkGetListeners(appName string, processType string) {
+func TriggerNetworkGetListeners(appName string, processType string) error {
 	if processType == "" {
 		common.LogWarn("Deprecated: Please specify a processType argument for the network-get-listeners plugin trigger")
 		processType = "web"
 	}
 	listeners := GetListeners(appName, processType)
 	fmt.Println(strings.Join(listeners, " "))
+	return nil
 }
 
 // TriggerNetworkGetPort writes the port to stdout for a given app container
-func TriggerNetworkGetPort(appName string, processType string, containerID string, isHerokuishContainer bool) {
+func TriggerNetworkGetPort(appName string, processType string, containerID string, isHerokuishContainer bool) error {
 	port := GetContainerPort(appName, processType, containerID, isHerokuishContainer)
 	fmt.Println(port)
+	return nil
 }
 
 // TriggerNetworkGetProperty writes the network property to stdout for a given app container
-func TriggerNetworkGetProperty(appName string, property string) {
+func TriggerNetworkGetProperty(appName string, property string) error {
 	defaultValue := GetDefaultValue(property)
 	value := common.PropertyGetDefault("network", appName, property, defaultValue)
 	fmt.Println(value)
+	return nil
 }
 
 // TriggerNetworkWriteIpaddr writes the ip to disk
-func TriggerNetworkWriteIpaddr(appName string, processType string, containerIndex string, ip string) {
+func TriggerNetworkWriteIpaddr(appName string, processType string, containerIndex string, ip string) error {
 	appRoot := common.AppRoot(appName)
 	filename := fmt.Sprintf("%v/IP.%v.%v", appRoot, processType, containerIndex)
 	f, err := os.Create(filename)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
 	defer f.Close()
 
 	ipBytes := []byte(ip)
 	_, err = f.Write(ipBytes)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
+
+	return nil
 }
 
 // TriggerNetworkWritePort writes the port to disk
-func TriggerNetworkWritePort(appName string, processType string, containerIndex string, port string) {
+func TriggerNetworkWritePort(appName string, processType string, containerIndex string, port string) error {
 	appRoot := common.AppRoot(appName)
 	filename := fmt.Sprintf("%v/PORT.%v.%v", appRoot, processType, containerIndex)
 	f, err := os.Create(filename)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
 	defer f.Close()
 
 	portBytes := []byte(port)
 	_, err = f.Write(portBytes)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
+
+	return nil
 }
 
 // TriggerPostAppCloneSetup creates new network files
@@ -170,75 +184,84 @@ func TriggerPostAppRenameSetup(oldAppName string, newAppName string) error {
 }
 
 // TriggerPostContainerCreate associates the container with a specified network
-func TriggerPostContainerCreate(containerType string, containerID string, appName string, phase string, processType string) {
+func TriggerPostContainerCreate(containerType string, containerID string, appName string, phase string, processType string) error {
 	if containerType != "app" {
-		return
+		return nil
+
 	}
 
 	property := "attach-post-create"
 	defaultValue := GetDefaultValue(property)
 	networkName := common.PropertyGetDefault("network", appName, property, defaultValue)
 	if networkName == "" {
-		return
+		return nil
+
 	}
 
 	exists, err := networkExists(networkName)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
 
 	if !exists {
-		common.LogFail(fmt.Sprintf("Network %v does not exist", networkName))
+		return fmt.Errorf("Network %v does not exist", networkName)
 	}
 
-	attachAppToNetwork(containerID, networkName, appName, phase, processType)
+	return attachAppToNetwork(containerID, networkName, appName, phase, processType)
 }
 
 // TriggerPostCreate sets bind-all-interfaces to false by default
-func TriggerPostCreate(appName string) {
+func TriggerPostCreate(appName string) error {
 	err := common.PropertyWrite("network", appName, "bind-all-interfaces", "false")
 	if err != nil {
 		common.LogWarn(err.Error())
 	}
+
+	return nil
 }
 
 // TriggerPostDelete destroys the network property for a given app container
-func TriggerPostDelete(appName string) {
+func TriggerPostDelete(appName string) error {
 	err := common.PropertyDestroy("network", appName)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
+
+	return nil
 }
 
 // TriggerCorePostDeploy associates the container with a specified network
-func TriggerCorePostDeploy(appName string) {
+func TriggerCorePostDeploy(appName string) error {
 	property := "attach-post-deploy"
 	defaultValue := GetDefaultValue(property)
 	networkName := common.PropertyGetDefault("network", appName, property, defaultValue)
 	if networkName == "" {
-		return
+		return nil
 	}
 
 	common.LogInfo1Quiet(fmt.Sprintf("Associating app with network %s", networkName))
 	containerIDs, err := common.GetAppRunningContainerIDs(appName, "")
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
 
 	exists, err := networkExists(networkName)
 	if err != nil {
-		common.LogFail(err.Error())
+		return err
 	}
 
 	if !exists {
-		common.LogFail(fmt.Sprintf("Network %v does not exist", networkName))
+		return fmt.Errorf("Network %v does not exist", networkName)
 	}
 
 	for _, containerID := range containerIDs {
 		processType, err := common.DockerInspect(containerID, "{{ index .Config.Labels \"com.dokku.process-type\"}}")
 		if err != nil {
-			common.LogFail(err.Error())
+			return err
+		}
+		if err := attachAppToNetwork(containerID, networkName, appName, "deploy", processType); err != nil {
+			return err
 		}
-		attachAppToNetwork(containerID, networkName, appName, "deploy", processType)
 	}
+	return nil
 }