func TestHealth_ServiceChecks_FilterACL(t *testing.T) { dir, token, srv, codec := testACLFilterServer(t) defer os.RemoveAll(dir) defer srv.Shutdown() defer codec.Close() opt := structs.ServiceSpecificRequest{ Datacenter: "dc1", ServiceName: "foo", QueryOptions: structs.QueryOptions{Token: token}, } reply := structs.IndexedHealthChecks{} if err := msgpackrpc.CallWithCodec(codec, "Health.ServiceChecks", &opt, &reply); err != nil { t.Fatalf("err: %s", err) } found := false for _, chk := range reply.HealthChecks { if chk.ServiceName == "foo" { found = true break } } if !found { t.Fatalf("bad: %#v", reply.HealthChecks) } opt.ServiceName = "bar" reply = structs.IndexedHealthChecks{} if err := msgpackrpc.CallWithCodec(codec, "Health.ServiceChecks", &opt, &reply); err != nil { t.Fatalf("err: %s", err) } if len(reply.HealthChecks) != 0 { t.Fatalf("bad: %#v", reply.HealthChecks) } }
func TestHealth_ServiceNodes_FilterACL(t *testing.T) { dir, token, srv, codec := testACLFilterServer(t) defer os.RemoveAll(dir) defer srv.Shutdown() defer codec.Close() opt := structs.ServiceSpecificRequest{ Datacenter: "dc1", ServiceName: "foo", QueryOptions: structs.QueryOptions{Token: token}, } reply := structs.IndexedCheckServiceNodes{} if err := msgpackrpc.CallWithCodec(codec, "Health.ServiceNodes", &opt, &reply); err != nil { t.Fatalf("err: %s", err) } if len(reply.Nodes) != 1 { t.Fatalf("bad: %#v", reply.Nodes) } opt.ServiceName = "bar" reply = structs.IndexedCheckServiceNodes{} if err := msgpackrpc.CallWithCodec(codec, "Health.ServiceNodes", &opt, &reply); err != nil { t.Fatalf("err: %s", err) } if len(reply.Nodes) != 0 { t.Fatalf("bad: %#v", reply.Nodes) } }
func (s *HTTPServer) HealthServiceChecks(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Set default DC args := structs.ServiceSpecificRequest{} s.parseSource(req, &args.Source) if done := s.parse(resp, req, &args.Datacenter, &args.QueryOptions); done { return nil, nil } // Pull out the service name args.ServiceName = strings.TrimPrefix(req.URL.Path, "/v1/health/checks/") if args.ServiceName == "" { resp.WriteHeader(400) resp.Write([]byte("Missing service name")) return nil, nil } // Make the RPC request var out structs.IndexedHealthChecks defer setMeta(resp, &out.QueryMeta) if err := s.agent.RPC("Health.ServiceChecks", &args, &out); err != nil { return nil, err } // Use empty list instead of nil if out.HealthChecks == nil { out.HealthChecks = make(structs.HealthChecks, 0) } return out.HealthChecks, nil }
func (s *HTTPServer) HealthServiceNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Set default DC args := structs.ServiceSpecificRequest{} s.parseSource(req, &args.Source) if done := s.parse(resp, req, &args.Datacenter, &args.QueryOptions); done { return nil, nil } // Check for a tag params := req.URL.Query() if _, ok := params["tag"]; ok { args.ServiceTag = params.Get("tag") args.TagFilter = true } // Pull out the service name args.ServiceName = strings.TrimPrefix(req.URL.Path, "/v1/health/service/") if args.ServiceName == "" { resp.WriteHeader(400) resp.Write([]byte("Missing service name")) return nil, nil } // Make the RPC request var out structs.IndexedCheckServiceNodes defer setMeta(resp, &out.QueryMeta) if err := s.agent.RPC("Health.ServiceNodes", &args, &out); err != nil { return nil, err } // Filter to only passing if specified if _, ok := params["passing"]; ok { out.Nodes = filterNonPassing(out.Nodes) } // Use empty list instead of nil for i, _ := range out.Nodes { // TODO (slackpad) It's lame that this isn't a slice of pointers // but it's not a well-scoped change to fix this. We should // change this at the next opportunity. if out.Nodes[i].Checks == nil { out.Nodes[i].Checks = make(structs.HealthChecks, 0) } } if out.Nodes == nil { out.Nodes = make(structs.CheckServiceNodes, 0) } return out.Nodes, nil }
func TestCatalogListServiceNodes(t *testing.T) { dir1, s1 := testServer(t) defer os.RemoveAll(dir1) defer s1.Shutdown() codec := rpcClient(t, s1) defer codec.Close() args := structs.ServiceSpecificRequest{ Datacenter: "dc1", ServiceName: "db", ServiceTag: "slave", TagFilter: false, } var out structs.IndexedServiceNodes err := msgpackrpc.CallWithCodec(codec, "Catalog.ServiceNodes", &args, &out) if err == nil || err.Error() != "No cluster leader" { t.Fatalf("err: %v", err) } testutil.WaitForLeader(t, s1.RPC, "dc1") // Just add a node if err := s1.fsm.State().EnsureNode(1, &structs.Node{Node: "foo", Address: "127.0.0.1"}); err != nil { t.Fatalf("err: %v", err) } if err := s1.fsm.State().EnsureService(2, "foo", &structs.NodeService{ID: "db", Service: "db", Tags: []string{"primary"}, Address: "127.0.0.1", Port: 5000}); err != nil { t.Fatalf("err: %v", err) } if err := msgpackrpc.CallWithCodec(codec, "Catalog.ServiceNodes", &args, &out); err != nil { t.Fatalf("err: %v", err) } if len(out.ServiceNodes) != 1 { t.Fatalf("bad: %v", out) } // Try with a filter args.TagFilter = true out = structs.IndexedServiceNodes{} if err := msgpackrpc.CallWithCodec(codec, "Catalog.ServiceNodes", &args, &out); err != nil { t.Fatalf("err: %v", err) } if len(out.ServiceNodes) != 0 { t.Fatalf("bad: %v", out) } }
func (s *HTTPServer) CatalogServiceNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Set default DC args := structs.ServiceSpecificRequest{} s.parseSource(req, &args.Source) if done := s.parse(resp, req, &args.Datacenter, &args.QueryOptions); done { return nil, nil } // Check for a tag params := req.URL.Query() if _, ok := params["tag"]; ok { args.ServiceTag = params.Get("tag") args.TagFilter = true } // Pull out the service name args.ServiceName = strings.TrimPrefix(req.URL.Path, "/v1/catalog/service/") if args.ServiceName == "" { resp.WriteHeader(400) resp.Write([]byte("Missing service name")) return nil, nil } // Make the RPC request var out structs.IndexedServiceNodes defer setMeta(resp, &out.QueryMeta) if err := s.agent.RPC("Catalog.ServiceNodes", &args, &out); err != nil { return nil, err } // Use empty list instead of nil if out.ServiceNodes == nil { out.ServiceNodes = make(structs.ServiceNodes, 0) } return out.ServiceNodes, nil }
// serviceLookup is used to handle a service query func (d *DNSServer) serviceLookup(network, datacenter, service, tag string, req, resp *dns.Msg) { // Make an RPC request args := structs.ServiceSpecificRequest{ Datacenter: datacenter, ServiceName: service, ServiceTag: tag, TagFilter: tag != "", QueryOptions: structs.QueryOptions{ Token: d.agent.config.ACLToken, AllowStale: d.config.AllowStale, }, } var out structs.IndexedCheckServiceNodes RPC: if err := d.agent.RPC("Health.ServiceNodes", &args, &out); err != nil { d.logger.Printf("[ERR] dns: rpc error: %v", err) resp.SetRcode(req, dns.RcodeServerFailure) return } // Verify that request is not too stale, redo the request if args.AllowStale && out.LastContact > d.config.MaxStale { args.AllowStale = false d.logger.Printf("[WARN] dns: Query results too stale, re-requesting") goto RPC } // Determine the TTL var ttl time.Duration if d.config.ServiceTTL != nil { var ok bool ttl, ok = d.config.ServiceTTL[service] if !ok { ttl = d.config.ServiceTTL["*"] } } // Filter out any service nodes due to health checks out.Nodes = out.Nodes.Filter(d.config.OnlyPassing) // If we have no nodes, return not found! if len(out.Nodes) == 0 { d.addSOA(d.domain, resp) resp.SetRcode(req, dns.RcodeNameError) return } // Perform a random shuffle out.Nodes.Shuffle() // Add various responses depending on the request qType := req.Question[0].Qtype d.serviceNodeRecords(out.Nodes, req, resp, ttl) if qType == dns.TypeSRV { d.serviceSRVRecords(datacenter, out.Nodes, req, resp, ttl) } // If the network is not TCP, restrict the number of responses if network != "tcp" && len(resp.Answer) > maxServiceResponses { resp.Answer = resp.Answer[:maxServiceResponses] // Flag that there are more records to return in the UDP response if d.config.EnableTruncate { resp.Truncated = true } } // If the answer is empty, return not found if len(resp.Answer) == 0 { d.addSOA(d.domain, resp) return } }