sdk/go/health/aggregator_test.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: Apache-2.0
   4
   5 package health
   6
   7 import (
   8         "encoding/json"
   9         "net/http"
  10         "net/http/httptest"
  11         "strings"
  12         "time"
  13
  14         "git.curoverse.com/arvados.git/sdk/go/arvados"
  15         "git.curoverse.com/arvados.git/sdk/go/arvadostest"
  16         "gopkg.in/check.v1"
  17 )
  18
  19 type AggregatorSuite struct {
  20         handler *Aggregator
  21         req     *http.Request
  22         resp    *httptest.ResponseRecorder
  23 }
  24
  25 // Gocheck boilerplate
  26 var _ = check.Suite(&AggregatorSuite{})
  27
  28 func (s *AggregatorSuite) TestInterface(c *check.C) {
  29         var _ http.Handler = &Aggregator{}
  30 }
  31
  32 func (s *AggregatorSuite) SetUpTest(c *check.C) {
  33         s.handler = &Aggregator{Config: &arvados.Config{
  34                 Clusters: map[string]arvados.Cluster{
  35                         "zzzzz": {
  36                                 ManagementToken: arvadostest.ManagementToken,
  37                                 SystemNodes:     map[string]arvados.SystemNode{},
  38                         },
  39                 },
  40         }}
  41         s.req = httptest.NewRequest("GET", "/_health/all", nil)
  42         s.req.Header.Set("Authorization", "Bearer "+arvadostest.ManagementToken)
  43         s.resp = httptest.NewRecorder()
  44 }
  45
  46 func (s *AggregatorSuite) TestNoAuth(c *check.C) {
  47         s.req.Header.Del("Authorization")
  48         s.handler.ServeHTTP(s.resp, s.req)
  49         s.checkError(c)
  50         c.Check(s.resp.Code, check.Equals, http.StatusUnauthorized)
  51 }
  52
  53 func (s *AggregatorSuite) TestBadAuth(c *check.C) {
  54         s.req.Header.Set("Authorization", "xyzzy")
  55         s.handler.ServeHTTP(s.resp, s.req)
  56         s.checkError(c)
  57         c.Check(s.resp.Code, check.Equals, http.StatusUnauthorized)
  58 }
  59
  60 func (s *AggregatorSuite) TestEmptyConfig(c *check.C) {
  61         s.handler.ServeHTTP(s.resp, s.req)
  62         s.checkOK(c)
  63 }
  64
  65 func (s *AggregatorSuite) stubServer(handler http.Handler) (*httptest.Server, string) {
  66         srv := httptest.NewServer(handler)
  67         var port string
  68         if parts := strings.Split(srv.URL, ":"); len(parts) < 3 {
  69                 panic(srv.URL)
  70         } else {
  71                 port = parts[len(parts)-1]
  72         }
  73         return srv, ":" + port
  74 }
  75
  76 type unhealthyHandler struct{}
  77
  78 func (*unhealthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
  79         if req.URL.Path == "/_health/ping" {
  80                 resp.Write([]byte(`{"health":"ERROR","error":"the bends"}`))
  81         } else {
  82                 http.Error(resp, "not found", http.StatusNotFound)
  83         }
  84 }
  85
  86 func (s *AggregatorSuite) TestUnhealthy(c *check.C) {
  87         srv, listen := s.stubServer(&unhealthyHandler{})
  88         defer srv.Close()
  89         s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
  90                 Keepstore: arvados.SystemServiceInstance{Listen: listen},
  91         }
  92         s.handler.ServeHTTP(s.resp, s.req)
  93         s.checkUnhealthy(c)
  94 }
  95
  96 type healthyHandler struct{}
  97
  98 func (*healthyHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
  99         if req.URL.Path == "/_health/ping" {
 100                 resp.Write([]byte(`{"health":"OK"}`))
 101         } else {
 102                 http.Error(resp, "not found", http.StatusNotFound)
 103         }
 104 }
 105
 106 func (s *AggregatorSuite) TestHealthy(c *check.C) {
 107         srv, listen := s.stubServer(&healthyHandler{})
 108         defer srv.Close()
 109         s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
 110                 Keepproxy:   arvados.SystemServiceInstance{Listen: listen},
 111                 Keepstore:   arvados.SystemServiceInstance{Listen: listen},
 112                 Keepweb:     arvados.SystemServiceInstance{Listen: listen},
 113                 Nodemanager: arvados.SystemServiceInstance{Listen: listen},
 114                 RailsAPI:    arvados.SystemServiceInstance{Listen: listen},
 115                 Websocket:   arvados.SystemServiceInstance{Listen: listen},
 116                 Workbench:   arvados.SystemServiceInstance{Listen: listen},
 117         }
 118         s.handler.ServeHTTP(s.resp, s.req)
 119         resp := s.checkOK(c)
 120         svc := "keepstore+http://localhost" + listen + "/_health/ping"
 121         c.Logf("%#v", resp)
 122         ep := resp.Checks[svc]
 123         c.Check(ep.Health, check.Equals, "OK")
 124         c.Check(ep.HTTPStatusCode, check.Equals, 200)
 125 }
 126
 127 func (s *AggregatorSuite) TestHealthyAndUnhealthy(c *check.C) {
 128         srvH, listenH := s.stubServer(&healthyHandler{})
 129         defer srvH.Close()
 130         srvU, listenU := s.stubServer(&unhealthyHandler{})
 131         defer srvU.Close()
 132         s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
 133                 Keepproxy:   arvados.SystemServiceInstance{Listen: listenH},
 134                 Keepstore:   arvados.SystemServiceInstance{Listen: listenH},
 135                 Keepweb:     arvados.SystemServiceInstance{Listen: listenH},
 136                 Nodemanager: arvados.SystemServiceInstance{Listen: listenH},
 137                 RailsAPI:    arvados.SystemServiceInstance{Listen: listenH},
 138                 Websocket:   arvados.SystemServiceInstance{Listen: listenH},
 139                 Workbench:   arvados.SystemServiceInstance{Listen: listenH},
 140         }
 141         s.handler.Config.Clusters["zzzzz"].SystemNodes["127.0.0.1"] = arvados.SystemNode{
 142                 Keepstore: arvados.SystemServiceInstance{Listen: listenU},
 143         }
 144         s.handler.ServeHTTP(s.resp, s.req)
 145         resp := s.checkUnhealthy(c)
 146         ep := resp.Checks["keepstore+http://localhost"+listenH+"/_health/ping"]
 147         c.Check(ep.Health, check.Equals, "OK")
 148         c.Check(ep.HTTPStatusCode, check.Equals, 200)
 149         ep = resp.Checks["keepstore+http://127.0.0.1"+listenU+"/_health/ping"]
 150         c.Check(ep.Health, check.Equals, "ERROR")
 151         c.Check(ep.HTTPStatusCode, check.Equals, 200)
 152         c.Logf("%#v", ep)
 153 }
 154
 155 func (s *AggregatorSuite) checkError(c *check.C) {
 156         c.Check(s.resp.Code, check.Not(check.Equals), http.StatusOK)
 157         var resp ClusterHealthResponse
 158         err := json.NewDecoder(s.resp.Body).Decode(&resp)
 159         c.Check(err, check.IsNil)
 160         c.Check(resp.Health, check.Not(check.Equals), "OK")
 161 }
 162
 163 func (s *AggregatorSuite) checkUnhealthy(c *check.C) ClusterHealthResponse {
 164         return s.checkResult(c, "ERROR")
 165 }
 166
 167 func (s *AggregatorSuite) checkOK(c *check.C) ClusterHealthResponse {
 168         return s.checkResult(c, "OK")
 169 }
 170
 171 func (s *AggregatorSuite) checkResult(c *check.C, health string) ClusterHealthResponse {
 172         c.Check(s.resp.Code, check.Equals, http.StatusOK)
 173         var resp ClusterHealthResponse
 174         err := json.NewDecoder(s.resp.Body).Decode(&resp)
 175         c.Check(err, check.IsNil)
 176         c.Check(resp.Health, check.Equals, health)
 177         return resp
 178 }
 179
 180 type slowHandler struct{}
 181
 182 func (*slowHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 183         if req.URL.Path == "/_health/ping" {
 184                 time.Sleep(3 * time.Second)
 185                 resp.Write([]byte(`{"health":"OK"}`))
 186         } else {
 187                 http.Error(resp, "not found", http.StatusNotFound)
 188         }
 189 }
 190
 191 func (s *AggregatorSuite) TestPingTimeout(c *check.C) {
 192         s.handler.timeout = arvados.Duration(100 * time.Millisecond)
 193         srv, listen := s.stubServer(&slowHandler{})
 194         defer srv.Close()
 195         s.handler.Config.Clusters["zzzzz"].SystemNodes["localhost"] = arvados.SystemNode{
 196                 Keepstore: arvados.SystemServiceInstance{Listen: listen},
 197         }
 198         s.handler.ServeHTTP(s.resp, s.req)
 199         resp := s.checkUnhealthy(c)
 200         ep := resp.Checks["keepstore+http://localhost"+listen+"/_health/ping"]
 201         c.Check(ep.Health, check.Equals, "ERROR")
 202         c.Check(ep.HTTPStatusCode, check.Equals, 0)
 203         rt, err := ep.ResponseTime.Float64()
 204         c.Check(err, check.IsNil)
 205         c.Check(rt > 0.005, check.Equals, true)
 206 }