Add etcd to the list of services to validate.

Also add minions.

pkg/apiserver/apiserver.go

@@ -84,6 +84,15 @@ func NewAPIGroup(storage map[string]RESTStorage, codec runtime.Codec, canonicalP
 	}}
 }
 
+func InstallValidator(mux Mux, servers map[string]Server) {
+	validator, err := NewValidator(servers)
+	if err != nil {
+		glog.Errorf("failed to set up validator: %v", err)
+		return
+	}
+	mux.Handle("/validate", validator)
+}
+
 // InstallREST registers the REST handlers (storage, watch, and operations) into a mux.
 // It is expected that the provided prefix will serve all operations. Path MUST NOT end
 // in a slash.
@@ -93,16 +102,6 @@ func (g *APIGroup) InstallREST(mux Mux, paths ...string) {
 	redirectHandler := &RedirectHandler{g.handler.storage, g.handler.codec}
 	opHandler := &OperationHandler{g.handler.ops, g.handler.codec}
 
-	servers := map[string]string{
-		"controller-manager": "127.0.0.1:10252",
-		"scheduler":          "127.0.0.1:10251",
-		// TODO: Add minion health checks here too.
-	}
-	validator, err := NewValidator(servers)
-	if err != nil {
-		glog.Errorf("failed to set up validator: %v", err)
-		validator = nil
-	}
 	for _, prefix := range paths {
 		prefix = strings.TrimRight(prefix, "/")
 		proxyHandler := &ProxyHandler{prefix + "/proxy/", g.handler.storage, g.handler.codec}
@@ -112,9 +111,6 @@ func (g *APIGroup) InstallREST(mux Mux, paths ...string) {
 		mux.Handle(prefix+"/redirect/", http.StripPrefix(prefix+"/redirect/", redirectHandler))
 		mux.Handle(prefix+"/operations", http.StripPrefix(prefix+"/operations", opHandler))
 		mux.Handle(prefix+"/operations/", http.StripPrefix(prefix+"/operations/", opHandler))
-		if validator != nil {
-			mux.Handle(prefix+"/validate", validator)
-		}
 	}
 }
 

pkg/apiserver/validator.go

@@ -20,7 +20,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"net"
 	"net/http"
 	"strconv"
@@ -33,20 +32,21 @@ type httpGet interface {
 	Get(url string) (*http.Response, error)
 }
 
-type server struct {
-	addr string
-	port int
+type Server struct {
+	Addr string
+	Port int
+	Path string
 }
 
 // validator is responsible for validating the cluster and serving
 type validator struct {
 	// a list of servers to health check
-	servers map[string]server
+	servers map[string]Server
 	client  httpGet
 }
 
-func (s *server) check(client httpGet) (health.Status, string, error) {
-	resp, err := client.Get("http://" + net.JoinHostPort(s.addr, strconv.Itoa(s.port)) + "/healthz")
+func (s *Server) check(client httpGet) (health.Status, string, error) {
+	resp, err := client.Get("http://" + net.JoinHostPort(s.Addr, strconv.Itoa(s.Port)) + s.Path)
 	if err != nil {
 		return health.Unknown, "", err
 	}
@@ -82,8 +82,7 @@ func (v *validator) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		}
 		reply = append(reply, ServerStatus{name, status.String(), status, msg, errorMsg})
 	}
-	data, err := json.Marshal(reply)
-	log.Printf("FOO: %s", string(data))
+	data, err := json.MarshalIndent(reply, "", "  ")
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte(err.Error()))
@@ -94,8 +93,15 @@ func (v *validator) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 }
 
 // NewValidator creates a validator for a set of servers.
-func NewValidator(servers map[string]string) (http.Handler, error) {
-	result := map[string]server{}
+func NewValidator(servers map[string]Server) (http.Handler, error) {
+	return &validator{
+		servers: servers,
+		client:  &http.Client{},
+	}, nil
+}
+
+func makeTestValidator(servers map[string]string, get httpGet) (http.Handler, error) {
+	result := map[string]Server{}
 	for name, value := range servers {
 		host, port, err := net.SplitHostPort(value)
 		if err != nil {
@@ -105,16 +111,10 @@ func NewValidator(servers map[string]string) (http.Handler, error) {
 		if err != nil {
 			return nil, fmt.Errorf("invalid server spec: %s (%v)", port, err)
 		}
-		result[name] = server{host, val}
+		result[name] = Server{Addr: host, Port: val, Path: "/healthz"}
 	}
-	return &validator{
-		servers: result,
-		client:  &http.Client{},
-	}, nil
-}
 
-func makeTestValidator(servers map[string]string, get httpGet) (http.Handler, error) {
-	v, e := NewValidator(servers)
+	v, e := NewValidator(result)
 	if e == nil {
 		v.(*validator).client = get
 	}

pkg/apiserver/validator_test.go

@@ -63,12 +63,12 @@ func TestValidate(t *testing.T) {
 		{nil, "foo", health.Unhealthy, 500, true},
 	}
 
-	s := server{addr: "foo.com", port: 8080}
+	s := Server{Addr: "foo.com", Port: 8080, Path: "/healthz"}
 
 	for _, test := range tests {
 		fake := makeFake(test.data, test.code, test.err)
 		status, data, err := s.check(fake)
-		expect := fmt.Sprintf("http://%s:%d/healthz", s.addr, s.port)
+		expect := fmt.Sprintf("http://%s:%d/healthz", s.Addr, s.Port)
 		if fake.url != expect {
 			t.Errorf("expected %s, got %s", expect, fake.url)
 		}