Changed HTTPGetAction to allow user-defined schemes

pkg/kubelet/prober/prober.go

@@ -18,7 +18,10 @@ package prober
 
 import (
 	"fmt"
+	"net"
+	"net/url"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
@@ -200,13 +203,19 @@ func (pb *prober) runProbe(p *api.Probe, pod *api.Pod, status api.PodStatus, con
 		return pb.exec.Probe(pb.newExecInContainer(pod, container, containerID, p.Exec.Command))
 	}
 	if p.HTTPGet != nil {
+		scheme := strings.ToLower(string(p.HTTPGet.Scheme))
+		host := p.HTTPGet.Host
+		if host == "" {
+			host = status.PodIP
+		}
 		port, err := extractPort(p.HTTPGet.Port, container)
 		if err != nil {
 			return probe.Unknown, "", err
 		}
-		host, port, path := extractGetParams(p.HTTPGet, status, port)
-		glog.V(4).Infof("HTTP-Probe Host: %v, Port: %v, Path: %v", host, port, path)
-		return pb.http.Probe(host, port, path, timeout)
+		path := p.HTTPGet.Path
+		glog.V(4).Infof("HTTP-Probe Host: %v://%v, Port: %v, Path: %v", scheme, host, port, path)
+		url := formatURL(scheme, host, port, path)
+		return pb.http.Probe(url, timeout)
 	}
 	if p.TCPSocket != nil {
 		port, err := extractPort(p.TCPSocket.Port, container)
@@ -220,50 +229,45 @@ func (pb *prober) runProbe(p *api.Probe, pod *api.Pod, status api.PodStatus, con
 	return probe.Unknown, "", nil
 }
 
-func extractGetParams(action *api.HTTPGetAction, status api.PodStatus, port int) (string, int, string) {
-	host := action.Host
-	if host == "" {
-		host = status.PodIP
-	}
-	return host, port, action.Path
-}
-
 func extractPort(param util.IntOrString, container api.Container) (int, error) {
 	port := -1
 	var err error
 	switch param.Kind {
 	case util.IntstrInt:
-		port := param.IntVal
-		if port > 0 && port < 65536 {
-			return port, nil
-		}
-		return port, fmt.Errorf("invalid port number: %v", port)
+		port = param.IntVal
 	case util.IntstrString:
-		port = findPortByName(container, param.StrVal)
-		if port == -1 {
+		if port, err = findPortByName(container, param.StrVal); err != nil {
 			// Last ditch effort - maybe it was an int stored as string?
 			if port, err = strconv.Atoi(param.StrVal); err != nil {
 				return port, err
 			}
 		}
-		if port > 0 && port < 65536 {
-			return port, nil
-		}
-		return port, fmt.Errorf("invalid port number: %v", port)
 	default:
 		return port, fmt.Errorf("IntOrString had no kind: %+v", param)
 	}
+	if port > 0 && port < 65536 {
+		return port, nil
+	}
+	return port, fmt.Errorf("invalid port number: %v", port)
 }
 
 // findPortByName is a helper function to look up a port in a container by name.
-// Returns the HostPort if found, -1 if not found.
-func findPortByName(container api.Container, portName string) int {
+func findPortByName(container api.Container, portName string) (int, error) {
 	for _, port := range container.Ports {
 		if port.Name == portName {
-			return port.HostPort
+			return port.HostPort, nil
 		}
 	}
-	return -1
+	return 0, fmt.Errorf("port %s not found", portName)
+}
+
+// formatURL formats a URL from args.  For testability.
+func formatURL(scheme string, host string, port int, path string) *url.URL {
+	return &url.URL{
+		Scheme: scheme,
+		Host:   net.JoinHostPort(host, strconv.Itoa(port)),
+		Path:   path,
+	}
 }
 
 type execInContainer struct {

pkg/kubelet/prober/prober_test.go

@@ -25,6 +25,25 @@ import (
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/exec"
 )
 
+func TestFormatURL(t *testing.T) {
+	testCases := []struct {
+		scheme string
+		host   string
+		port   int
+		path   string
+		result string
+	}{
+		{"http", "localhost", 93, "", "http://localhost:93"},
+		{"https", "localhost", 93, "/path", "https://localhost:93/path"},
+	}
+	for _, test := range testCases {
+		url := formatURL(test.scheme, test.host, test.port, test.path)
+		if url.String() != test.result {
+			t.Errorf("Expected %s, got %s", test.result, url.String())
+		}
+	}
+}
+
 func TestFindPortByName(t *testing.T) {
 	container := api.Container{
 		Ports: []api.ContainerPort{
@@ -39,9 +58,9 @@ func TestFindPortByName(t *testing.T) {
 		},
 	}
 	want := 8080
-	got := findPortByName(container, "foo")
-	if got != want {
-		t.Errorf("Expected %v, got %v", want, got)
+	got, err := findPortByName(container, "foo")
+	if got != want || err != nil {
+		t.Errorf("Expected %v, got %v, err: %v", want, got, err)
 	}
 }
 
@@ -73,13 +92,23 @@ func TestGetURLParts(t *testing.T) {
 				},
 			},
 		}
-		p, err := extractPort(test.probe.Port, container)
+
+		scheme := test.probe.Scheme
+		if scheme == "" {
+			scheme = api.URISchemeHTTP
+		}
+		host := test.probe.Host
+		if host == "" {
+			host = state.PodIP
+		}
+		port, err := extractPort(test.probe.Port, container)
 		if test.ok && err != nil {
 			t.Errorf("Unexpected error: %v", err)
 		}
-		host, port, path := extractGetParams(test.probe, state, p)
+		path := test.probe.Path
+
 		if !test.ok && err == nil {
-			t.Errorf("Expected error for %+v, got %s:%d/%s", test, host, port, path)
+			t.Errorf("Expected error for %+v, got %s%s:%d/%s", test, scheme, host, port, path)
 		}
 		if test.ok {
 			if host != test.host || port != test.port || path != test.path {