code: func (s *Server) peerQuery(ctx context.Context, data cluster.Traceable, name, path string) (map[string]PeerResponse, error) {
  
  	peers := cluster.Manager.MemberList(false, true)
  	log.Debugf("HTTP %s across %d instances", name, len(peers)-1)
  
  	reqCtx, cancel := context.WithCancel(ctx)
  	defer cancel()
  
  	responses := make(chan struct {
  		data PeerResponse
  		err  error
  	}, 1)
  	var wg sync.WaitGroup
  	for _, peer := range peers {
  		if peer.IsLocal() {
  			continue
  		}
  		wg.Add(1)
  		go func(peer cluster.Node) {
  			defer wg.Done()
  			log.Debugf("HTTP Render querying %s%s", peer.GetName(), path)
  			buf, err := peer.Post(reqCtx, name, path, data)
  			if err != nil {
  				cancel()
  				log.Errorf("HTTP Render error querying %s%s: %q", peer.GetName(), path, err.Error())
  			}
  			responses <- struct {
  				data PeerResponse
  				err  error
  			}{PeerResponse{peer, buf}, err}
  		}(peer)
  	}
  	// wait for all list goroutines to end, then close our responses channel
  	go func() {
  		wg.Wait()
  		close(responses)
  	}()
  
  	result := make(map[string]PeerResponse)
  	for resp := range responses {
  		if resp.err != nil {
  			return nil, resp.err
  		}
  		result[resp.data.peer.GetName()] = resp.data
  	}
  
  	return result, nil
  }
docs: // peerQuery takes a request and the path to request it on, then fans it out
  // across the cluster, except to the local peer or peers without data.
  // Note: unlike the other peerQuery methods, we include peers that are not ready
  // If any peer fails requests to
  // other peers are aborted.
  // ctx:          request context
  // data:         request to be submitted
  // name:         name to be used in logging & tracing
  // path:         path to request on