X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/ec0c244be178aed7af0cf990a256dda557034b68..5d56a1af42f64df57ef7a1bcef6d016ff2310900:/sdk/go/health/aggregator_test.go

diff --git a/sdk/go/health/aggregator_test.go b/sdk/go/health/aggregator_test.go
index 048886af30..04106caa44 100644
--- a/sdk/go/health/aggregator_test.go
+++ b/sdk/go/health/aggregator_test.go
@@ -1,16 +1,18 @@
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+
 package health
 
 import (
 	"encoding/json"
-	"fmt"
-	"net"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"time"
 
-	"git.curoverse.com/arvados.git/sdk/go/arvados"
-	"git.curoverse.com/arvados.git/sdk/go/arvadostest"
+	"git.arvados.org/arvados.git/sdk/go/arvados"
+	"git.arvados.org/arvados.git/sdk/go/arvadostest"
 	"gopkg.in/check.v1"
 )
 
@@ -28,13 +30,8 @@ func (s *AggregatorSuite) TestInterface(c *check.C) {
 }
 
 func (s *AggregatorSuite) SetUpTest(c *check.C) {
-	s.handler = &Aggregator{Config: &arvados.Config{
-		Clusters: map[string]arvados.Cluster{
-			"zzzzz": {
-				ManagementToken: arvadostest.ManagementToken,
-				SystemNodes:     map[string]arvados.SystemNode{},
-			},
-		},
+	s.handler = &Aggregator{Cluster: &arvados.Cluster{
+		ManagementToken: arvadostest.ManagementToken,
 	}}
 	s.req = httptest.NewRequest("GET", "/_health/all", nil)
 	s.req.Header.Set("Authorization", "Bearer "+arvadostest.ManagementToken)
@@ -55,9 +52,9 @@ func (s *AggregatorSuite) TestBadAuth(c *check.C) {
 	c.Check(s.resp.Code, check.Equals, http.StatusUnauthorized)
 }
 
-func (s *AggregatorSuite) TestEmptyConfig(c *check.C) {
+func (s *AggregatorSuite) TestNoServicesConfigured(c *check.C) {
 	s.handler.ServeHTTP(s.resp, s.req)
-	s.checkOK(c)
+	s.checkUnhealthy(c)
 }
 
 func (s *AggregatorSuite) stubServer(handler http.Handler) (*httptest.Server, string) {
@@ -71,77 +68,64 @@ func (s *AggregatorSuite) stubServer(handler http.Handler) (*httptest.Server, st
 	return srv, ":" + port
 }
 
-type unhealthyHandler struct{}
-
-func (*unhealthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
-	if req.URL.Path == "/_health/ping" {
-		resp.Write([]byte(`{"health":"ERROR","error":"the bends"}`))
-	} else {
-		http.Error(resp, "not found", http.StatusNotFound)
-	}
-}
-
 func (s *AggregatorSuite) TestUnhealthy(c *check.C) {
 	srv, listen := s.stubServer(&unhealthyHandler{})
 	defer srv.Close()
-	s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
-		Keepstore: arvados.Keepstore{Listen: listen},
-	}
+	arvadostest.SetServiceURL(&s.handler.Cluster.Services.Keepstore, "http://localhost"+listen+"/")
 	s.handler.ServeHTTP(s.resp, s.req)
 	s.checkUnhealthy(c)
 }
 
-type healthyHandler struct{}
-
-func (*healthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
-	if req.URL.Path == "/_health/ping" {
-		resp.Write([]byte(`{"health":"OK"}`))
-	} else {
-		http.Error(resp, "not found", http.StatusNotFound)
-	}
-}
-
 func (s *AggregatorSuite) TestHealthy(c *check.C) {
 	srv, listen := s.stubServer(&healthyHandler{})
 	defer srv.Close()
-	_, port, _ := net.SplitHostPort(listen)
-	s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
-		Keepstore: arvados.Keepstore{Listen: listen},
-	}
+	s.setAllServiceURLs(listen)
 	s.handler.ServeHTTP(s.resp, s.req)
 	resp := s.checkOK(c)
-	ep := resp.Checks[fmt.Sprintf("keepstore+http://localhost:%d/_health/ping", port)]
+	svc := "keepstore+http://localhost" + listen + "/_health/ping"
+	c.Logf("%#v", resp)
+	ep := resp.Checks[svc]
 	c.Check(ep.Health, check.Equals, "OK")
-	c.Check(ep.Status, check.Equals, 200)
+	c.Check(ep.HTTPStatusCode, check.Equals, 200)
 }
 
 func (s *AggregatorSuite) TestHealthyAndUnhealthy(c *check.C) {
 	srvH, listenH := s.stubServer(&healthyHandler{})
 	defer srvH.Close()
-	_, portH, _ := net.SplitHostPort(listenH)
 	srvU, listenU := s.stubServer(&unhealthyHandler{})
 	defer srvU.Close()
-	_, portU, _ := net.SplitHostPort(listenU)
-	s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
-		Keepstore: arvados.Keepstore{Listen: listenH},
-	}
-	s.handler.Config.Clusters["zzzzz"].SystemNodes["127.0.0.1"] = arvados.SystemNode{
-		Keepstore: arvados.Keepstore{Listen: listenU},
-	}
+	s.setAllServiceURLs(listenH)
+	arvadostest.SetServiceURL(&s.handler.Cluster.Services.Keepstore, "http://localhost"+listenH+"/", "http://127.0.0.1"+listenU+"/")
 	s.handler.ServeHTTP(s.resp, s.req)
 	resp := s.checkUnhealthy(c)
-	ep := resp.Checks[fmt.Sprintf("keepstore+http://localhost:%d/_health/ping", portH)]
+	ep := resp.Checks["keepstore+http://localhost"+listenH+"/_health/ping"]
 	c.Check(ep.Health, check.Equals, "OK")
-	c.Check(ep.Status, check.Equals, 200)
-	ep = resp.Checks[fmt.Sprintf("keepstore+http://127.0.0.1:%d/_health/ping", portU)]
+	c.Check(ep.HTTPStatusCode, check.Equals, 200)
+	ep = resp.Checks["keepstore+http://127.0.0.1"+listenU+"/_health/ping"]
+	c.Check(ep.Health, check.Equals, "ERROR")
+	c.Check(ep.HTTPStatusCode, check.Equals, 200)
+	c.Logf("%#v", ep)
+}
+
+func (s *AggregatorSuite) TestPingTimeout(c *check.C) {
+	s.handler.timeout = arvados.Duration(100 * time.Millisecond)
+	srv, listen := s.stubServer(&slowHandler{})
+	defer srv.Close()
+	arvadostest.SetServiceURL(&s.handler.Cluster.Services.Keepstore, "http://localhost"+listen+"/")
+	s.handler.ServeHTTP(s.resp, s.req)
+	resp := s.checkUnhealthy(c)
+	ep := resp.Checks["keepstore+http://localhost"+listen+"/_health/ping"]
 	c.Check(ep.Health, check.Equals, "ERROR")
-	c.Check(ep.Status, check.Equals, 200)
+	c.Check(ep.HTTPStatusCode, check.Equals, 0)
+	rt, err := ep.ResponseTime.Float64()
+	c.Check(err, check.IsNil)
+	c.Check(rt > 0.005, check.Equals, true)
 }
 
 func (s *AggregatorSuite) checkError(c *check.C) {
 	c.Check(s.resp.Code, check.Not(check.Equals), http.StatusOK)
 	var resp ClusterHealthResponse
-	err := json.NewDecoder(s.resp.Body).Decode(&resp)
+	err := json.Unmarshal(s.resp.Body.Bytes(), &resp)
 	c.Check(err, check.IsNil)
 	c.Check(resp.Health, check.Not(check.Equals), "OK")
 }
@@ -157,36 +141,60 @@ func (s *AggregatorSuite) checkOK(c *check.C) ClusterHealthResponse {
 func (s *AggregatorSuite) checkResult(c *check.C, health string) ClusterHealthResponse {
 	c.Check(s.resp.Code, check.Equals, http.StatusOK)
 	var resp ClusterHealthResponse
-	err := json.NewDecoder(s.resp.Body).Decode(&resp)
+	c.Log(s.resp.Body.String())
+	err := json.Unmarshal(s.resp.Body.Bytes(), &resp)
 	c.Check(err, check.IsNil)
 	c.Check(resp.Health, check.Equals, health)
 	return resp
 }
 
-type slowHandler struct{}
+func (s *AggregatorSuite) setAllServiceURLs(listen string) {
+	svcs := &s.handler.Cluster.Services
+	for _, svc := range []*arvados.Service{
+		&svcs.Controller,
+		&svcs.DispatchCloud,
+		&svcs.DispatchLSF,
+		&svcs.Keepbalance,
+		&svcs.Keepproxy,
+		&svcs.Keepstore,
+		&svcs.Health,
+		&svcs.RailsAPI,
+		&svcs.WebDAV,
+		&svcs.Websocket,
+		&svcs.Workbench1,
+		&svcs.Workbench2,
+	} {
+		arvadostest.SetServiceURL(svc, "http://localhost"+listen+"/")
+	}
+}
 
-func (*slowHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
+type unhealthyHandler struct{}
+
+func (*unhealthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
+	if req.URL.Path == "/_health/ping" {
+		resp.Write([]byte(`{"health":"ERROR","error":"the bends"}`))
+	} else {
+		http.Error(resp, "not found", http.StatusNotFound)
+	}
+}
+
+type healthyHandler struct{}
+
+func (*healthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 	if req.URL.Path == "/_health/ping" {
-		time.Sleep(3 * time.Second)
 		resp.Write([]byte(`{"health":"OK"}`))
 	} else {
 		http.Error(resp, "not found", http.StatusNotFound)
 	}
 }
 
-func (s *AggregatorSuite) TestPingTimeout(c *check.C) {
-	s.handler.timeout = arvados.Duration(100 * time.Millisecond)
-	srv, listen := s.stubServer(&slowHandler{})
-	defer srv.Close()
-	s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
-		Keepstore: arvados.Keepstore{Listen: listen},
+type slowHandler struct{}
+
+func (*slowHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
+	if req.URL.Path == "/_health/ping" {
+		time.Sleep(3 * time.Second)
+		resp.Write([]byte(`{"health":"OK"}`))
+	} else {
+		http.Error(resp, "not found", http.StatusNotFound)
 	}
-	s.handler.ServeHTTP(s.resp, s.req)
-	resp := s.checkUnhealthy(c)
-	ep := resp.Checks["localhost/keepstore/_health/ping"]
-	c.Check(ep.Health, check.Equals, "ERROR")
-	c.Check(ep.Status, check.Equals, 0)
-	rt, err := ep.ResponseTime.Float64()
-	c.Check(err, check.IsNil)
-	c.Check(rt > 0.005, check.Equals, true)
 }