Make the diego healthcheck work on Windows

Because Windows "containers" don't have network namespaces, we have to
map the internal port for health check to the external port that is
actually used by Windows applications.

This is in an effort to bring the windows_app_lifecycle in line with the
buildpackapplifecycle, and ultimately get rid of the WAL.

Signed-off-by: Natalie Arellano <[email protected]>

Author: mhoran

cmd/healthcheck/healthcheck_test.go

@@ -1,3 +1,5 @@
+// +build !windows
+
 package main_test
 
 import (

cmd/healthcheck/healthcheck_windows_test.go

@@ -0,0 +1,141 @@
+package main_test
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"strconv"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/gbytes"
+	"github.com/onsi/gomega/gexec"
+	"github.com/onsi/gomega/ghttp"
+)
+
+var _ = Describe("HealthCheck", func() {
+	var (
+		server     *ghttp.Server
+		serverAddr string
+	)
+
+	itExitsWithCode := func(healthCheck func() *gexec.Session, code int, reason string) {
+		It("exits with code "+strconv.Itoa(code)+" and logs reason", func() {
+			session := healthCheck()
+			Eventually(session).Should(gexec.Exit(code))
+			Expect(session.Out).To(gbytes.Say(reason))
+		})
+	}
+
+	BeforeEach(func() {
+		ip := getNonLoopbackIP()
+		server = ghttp.NewUnstartedServer()
+		listener, err := net.Listen("tcp", ip+":0")
+		Expect(err).NotTo(HaveOccurred())
+
+		server.HTTPTestServer.Listener = listener
+		serverAddr = listener.Addr().String()
+		server.Start()
+	})
+
+	Describe("fails when parsing flags", func() {
+		It("exits with code 2", func() {
+			session, _ := gexec.Start(exec.Command(healthCheck, "-invalid_flag"), GinkgoWriter, GinkgoWriter)
+			Eventually(session).Should(gexec.Exit(2))
+		})
+	})
+
+	Describe("port healthcheck", func() {
+		var port string
+		var err error
+
+		portHealthCheck := func() *gexec.Session {
+			command := exec.Command(healthCheck, "-port", "8080", "-timeout", "100ms")
+			command.Env = append(
+				os.Environ(),
+				fmt.Sprintf(`CF_INSTANCE_PORTS=[{"external":%s,"internal":%s}]`, port, "8080"),
+			)
+			session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
+			Expect(err).NotTo(HaveOccurred())
+			return session
+		}
+
+		BeforeEach(func() {
+			_, port, err = net.SplitHostPort(serverAddr)
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		Context("when the address is listening", func() {
+			itExitsWithCode(portHealthCheck, 0, "healthcheck passed")
+		})
+
+		Context("when the address is not listening", func() {
+			BeforeEach(func() {
+				port = "-1"
+			})
+
+			itExitsWithCode(portHealthCheck, 4, "failure to make TCP connection")
+		})
+	})
+
+	Describe("http healthcheck", func() {
+		var port string
+		var err error
+
+		httpHealthCheck := func() *gexec.Session {
+			command := exec.Command(healthCheck, "-uri", "/api/_ping", "-port", "8080", "-timeout", "100ms")
+			command.Env = append(
+				os.Environ(),
+				fmt.Sprintf(`CF_INSTANCE_PORTS=[{"external":%s,"internal":%s}]`, port, "8080"),
+			)
+			session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
+			Expect(err).NotTo(HaveOccurred())
+			return session
+		}
+
+		BeforeEach(func() {
+			_, port, err = net.SplitHostPort(serverAddr)
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		Context("when the healthcheck is properly invoked", func() {
+			BeforeEach(func() {
+				server.RouteToHandler("GET", "/api/_ping", ghttp.VerifyRequest("GET", "/api/_ping"))
+			})
+
+			Context("when the address is listening", func() {
+				itExitsWithCode(httpHealthCheck, 0, "healthcheck passed")
+			})
+
+			Context("when the address returns error http code", func() {
+				BeforeEach(func() {
+					server.RouteToHandler("GET", "/api/_ping", ghttp.RespondWith(500, ""))
+				})
+
+				itExitsWithCode(httpHealthCheck, 6, "failure to get valid HTTP status code: 500")
+			})
+		})
+	})
+})
+
+func getNonLoopbackIP() string {
+	interfaces, err := net.Interfaces()
+	Expect(err).NotTo(HaveOccurred())
+	for _, intf := range interfaces {
+		addrs, err := intf.Addrs()
+		if err != nil {
+			continue
+		}
+
+		for _, a := range addrs {
+			if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+				if ipnet.IP.To4() != nil {
+					return ipnet.IP.String()
+				}
+			}
+		}
+	}
+	Fail("no non-loopback address found")
+	panic("non-reachable")
+}

cmd/healthcheck/main.go

@@ -44,7 +44,7 @@ func main() {
 		return
 	}
 
-	h := healthcheck.NewHealthCheck(*network, *uri, *port, *timeout)
+	h := newHealthCheck(*network, *uri, *port, *timeout)
 	err = h.CheckInterfaces(interfaces)
 	if err == nil {
 		fmt.Println("healthcheck passed")

cmd/healthcheck/main_unix.go

@@ -0,0 +1,16 @@
+// +build !windows
+
+package main
+
+import (
+	"time"
+
+	"code.cloudfoundry.org/healthcheck"
+)
+
+func newHealthCheck(
+	network, uri, port string,
+	timeout time.Duration,
+) healthcheck.HealthCheck {
+	return healthcheck.NewHealthCheck(network, uri, port, timeout)
+}

cmd/healthcheck/main_windows.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"strconv"
+	"time"
+
+	"code.cloudfoundry.org/healthcheck"
+)
+
+type PortMapping struct {
+	Internal int `json:"internal"`
+	External int `json:"external"`
+}
+
+func newHealthCheck(
+	network, uri, port string,
+	timeout time.Duration,
+) healthcheck.HealthCheck {
+	jsonPortMappings := os.Getenv("CF_INSTANCE_PORTS")
+	var portMappings []PortMapping
+	json.Unmarshal([]byte(jsonPortMappings), &portMappings)
+	for _, mapping := range portMappings {
+		if strconv.Itoa(mapping.Internal) == port {
+			port = strconv.Itoa(mapping.External)
+		}
+	}
+	return healthcheck.NewHealthCheck(network, uri, port, timeout)
+}