Implement /v1/agent/health/service/<service name> endpoint

agent/agent_endpoint.go

@@ -20,6 +20,7 @@ import (
 	"github.com/hashicorp/consul/agent/checks"
 	"github.com/hashicorp/consul/agent/config"
 	"github.com/hashicorp/consul/agent/debug"
+	"github.com/hashicorp/consul/agent/local"
 	"github.com/hashicorp/consul/agent/structs"
 	"github.com/hashicorp/consul/api"
 	"github.com/hashicorp/consul/ipaddr"
@@ -153,6 +154,62 @@ func (s *HTTPServer) AgentReload(resp http.ResponseWriter, req *http.Request) (i
 	}
 }
 
+func buildAgentService(s *structs.NodeService, proxies map[string]*local.ManagedProxy) api.AgentService {
+	weights := api.AgentWeights{Passing: 1, Warning: 1}
+	if s.Weights != nil {
+		if s.Weights.Passing > 0 {
+			weights.Passing = s.Weights.Passing
+		}
+		weights.Warning = s.Weights.Warning
+	}
+	as := api.AgentService{
+		Kind:              api.ServiceKind(s.Kind),
+		ID:                s.ID,
+		Service:           s.Service,
+		Tags:              s.Tags,
+		Meta:              s.Meta,
+		Port:              s.Port,
+		Address:           s.Address,
+		EnableTagOverride: s.EnableTagOverride,
+		CreateIndex:       s.CreateIndex,
+		ModifyIndex:       s.ModifyIndex,
+		Weights:           weights,
+	}
+
+	if as.Tags == nil {
+		as.Tags = []string{}
+	}
+	if as.Meta == nil {
+		as.Meta = map[string]string{}
+	}
+	// Attach Unmanaged Proxy config if exists
+	if s.Kind == structs.ServiceKindConnectProxy {
+		as.Proxy = s.Proxy.ToAPI()
+		// DEPRECATED (ProxyDestination) - remove this when removing ProxyDestination
+		// Also set the deprecated ProxyDestination
+		as.ProxyDestination = as.Proxy.DestinationServiceName
+	}
+
+	// Attach Connect configs if they exist. We use the actual proxy state since
+	// that may have had defaults filled in compared to the config that was
+	// provided with the service as stored in the NodeService here.
+	if proxy, ok := proxies[s.ID+"-proxy"]; ok {
+		as.Connect = &api.AgentServiceConnect{
+			Proxy: &api.AgentServiceConnectProxy{
+				ExecMode:  api.ProxyExecMode(proxy.Proxy.ExecMode.String()),
+				Command:   proxy.Proxy.Command,
+				Config:    proxy.Proxy.Config,
+				Upstreams: proxy.Proxy.Upstreams.ToAPI(),
+			},
+		}
+	} else if s.Connect.Native {
+		as.Connect = &api.AgentServiceConnect{
+			Native: true,
+		}
+	}
+	return as
+}
+
 func (s *HTTPServer) AgentServices(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
 	// Fetch the ACL token, if any.
 	var token string
@@ -173,59 +230,8 @@ func (s *HTTPServer) AgentServices(resp http.ResponseWriter, req *http.Request)
 
 	// Use empty list instead of nil
 	for id, s := range services {
-		weights := api.AgentWeights{Passing: 1, Warning: 1}
-		if s.Weights != nil {
-			if s.Weights.Passing > 0 {
-				weights.Passing = s.Weights.Passing
-			}
-			weights.Warning = s.Weights.Warning
-		}
-		as := &api.AgentService{
-			Kind:              api.ServiceKind(s.Kind),
-			ID:                s.ID,
-			Service:           s.Service,
-			Tags:              s.Tags,
-			Meta:              s.Meta,
-			Port:              s.Port,
-			Address:           s.Address,
-			EnableTagOverride: s.EnableTagOverride,
-			CreateIndex:       s.CreateIndex,
-			ModifyIndex:       s.ModifyIndex,
-			Weights:           weights,
-		}
-
-		if as.Tags == nil {
-			as.Tags = []string{}
-		}
-		if as.Meta == nil {
-			as.Meta = map[string]string{}
-		}
-		// Attach Unmanaged Proxy config if exists
-		if s.Kind == structs.ServiceKindConnectProxy {
-			as.Proxy = s.Proxy.ToAPI()
-			// DEPRECATED (ProxyDestination) - remove this when removing ProxyDestination
-			// Also set the deprecated ProxyDestination
-			as.ProxyDestination = as.Proxy.DestinationServiceName
-		}
-
-		// Attach Connect configs if they exist. We use the actual proxy state since
-		// that may have had defaults filled in compared to the config that was
-		// provided with the service as stored in the NodeService here.
-		if proxy, ok := proxies[id+"-proxy"]; ok {
-			as.Connect = &api.AgentServiceConnect{
-				Proxy: &api.AgentServiceConnectProxy{
-					ExecMode:  api.ProxyExecMode(proxy.Proxy.ExecMode.String()),
-					Command:   proxy.Proxy.Command,
-					Config:    proxy.Proxy.Config,
-					Upstreams: proxy.Proxy.Upstreams.ToAPI(),
-				},
-			}
-		} else if s.Connect.Native {
-			as.Connect = &api.AgentServiceConnect{
-				Native: true,
-			}
-		}
-		agentSvcs[id] = as
+		agentService := buildAgentService(s, proxies)
+		agentSvcs[id] = &agentService
 	}
 
 	return agentSvcs, nil
@@ -704,6 +710,124 @@ func (s *HTTPServer) AgentCheckUpdate(resp http.ResponseWriter, req *http.Reques
 	return nil, nil
 }
 
+// agentHealthService Returns Health for a given service ID
+func agentHealthService(serviceID string, s *HTTPServer) (int, string, api.HealthChecks) {
+	checks := s.agent.State.Checks()
+	serviceChecks := make(api.HealthChecks, 0)
+	for _, c := range checks {
+		if c.ServiceID == serviceID || c.ServiceID == "" {
+			// TODO: harmonize struct.HealthCheck and api.HealthCheck (or at least extract conversion function)
+			healthCheck := &api.HealthCheck{
+				Node:        c.Node,
+				CheckID:     string(c.CheckID),
+				Name:        c.Name,
+				Status:      c.Status,
+				Notes:       c.Notes,
+				Output:      c.Output,
+				ServiceID:   c.ServiceID,
+				ServiceName: c.ServiceName,
+				ServiceTags: c.ServiceTags,
+			}
+			serviceChecks = append(serviceChecks, healthCheck)
+		}
+	}
+	status := serviceChecks.AggregatedStatus()
+	switch status {
+	case api.HealthWarning:
+		return http.StatusTooManyRequests, status, serviceChecks
+	case api.HealthPassing:
+		return http.StatusOK, status, serviceChecks
+	default:
+		return http.StatusServiceUnavailable, status, serviceChecks
+	}
+}
+
+func returnTextPlain(req *http.Request) bool {
+	if contentType := req.Header.Get("Accept"); strings.HasPrefix(contentType, "text/plain") {
+		return true
+	}
+	if format := req.URL.Query().Get("format"); format != "" {
+		return format == "text"
+	}
+	return false
+}
+
+// AgentHealthServiceByID return the local Service Health given its ID
+func (s *HTTPServer) AgentHealthServiceByID(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
+	// Pull out the service id (service id since there may be several instance of the same service on this host)
+	serviceID := strings.TrimPrefix(req.URL.Path, "/v1/agent/health/service/id/")
+	if serviceID == "" {
+		return nil, &BadRequestError{Reason: "Missing serviceID"}
+	}
+	services := s.agent.State.Services()
+	proxies := s.agent.State.Proxies()
+	for _, service := range services {
+		if service.ID == serviceID {
+			code, status, healthChecks := agentHealthService(serviceID, s)
+			if returnTextPlain(req) {
+				return status, api.CodeWithPayloadError{StatusCode: code, Reason: status, ContentType: "text/plain"}
+			}
+			serviceInfo := buildAgentService(service, proxies)
+			result := &api.AgentServiceChecksInfo{
+				AggregatedStatus: status,
+				Checks:           healthChecks,
+				Service:          &serviceInfo,
+			}
+			return result, api.CodeWithPayloadError{StatusCode: code, Reason: status, ContentType: "application/json"}
+		}
+	}
+	notFoundReason := fmt.Sprintf("ServiceId %s not found", serviceID)
+	if returnTextPlain(req) {
+		return notFoundReason, api.CodeWithPayloadError{StatusCode: http.StatusNotFound, Reason: fmt.Sprintf("ServiceId %s not found", serviceID), ContentType: "application/json"}
+	}
+	return &api.AgentServiceChecksInfo{
+		AggregatedStatus: api.HealthCritical,
+		Checks:           nil,
+		Service:          nil,
+	}, api.CodeWithPayloadError{StatusCode: http.StatusNotFound, Reason: notFoundReason, ContentType: "application/json"}
+}
+
+// AgentHealthServiceByName return the worse status of all the services with given name on an agent
+func (s *HTTPServer) AgentHealthServiceByName(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
+	// Pull out the service name
+	serviceName := strings.TrimPrefix(req.URL.Path, "/v1/agent/health/service/name/")
+	if serviceName == "" {
+		return nil, &BadRequestError{Reason: "Missing service Name"}
+	}
+	code := http.StatusNotFound
+	status := fmt.Sprintf("ServiceName %s Not Found", serviceName)
+	services := s.agent.State.Services()
+	result := make([]api.AgentServiceChecksInfo, 0, 16)
+	proxies := s.agent.State.Proxies()
+	for _, service := range services {
+		if service.Service == serviceName {
+			scode, sstatus, healthChecks := agentHealthService(service.ID, s)
+			serviceInfo := buildAgentService(service, proxies)
+			res := api.AgentServiceChecksInfo{
+				AggregatedStatus: sstatus,
+				Checks:           healthChecks,
+				Service:          &serviceInfo,
+			}
+			result = append(result, res)
+			// When service is not found, we ignore it and keep existing HTTP status
+			if code == http.StatusNotFound {
+				code = scode
+				status = sstatus
+			}
+			// We take the worst of all statuses, so we keep iterating
+			// passing: 200 < warning: 429 < critical: 503
+			if code < scode {
+				code = scode
+				status = sstatus
+			}
+		}
+	}
+	if returnTextPlain(req) {
+		return status, api.CodeWithPayloadError{StatusCode: code, Reason: status, ContentType: "text/plain"}
+	}
+	return result, api.CodeWithPayloadError{StatusCode: code, Reason: status, ContentType: "application/json"}
+}
+
 func (s *HTTPServer) AgentRegisterService(resp http.ResponseWriter, req *http.Request) (interface{}, error) {
 	var args structs.ServiceDefinition
 	// Fixup the type decode of TTL or Interval if a check if provided.