gistfile1.txt

type Mesh interface {
	GetSupportedResources(ctx context.Context) (*metav1.APIResourceList, error)
	GetResourceMetrics(ctx context.Context, name, namespace, kind string, interval *metrics.Interval) (*metrics.TrafficMetricsList, error)
	GetEdgeMetrics(ctx context.Context, name, namespace, kind string, details ResourceDetails, interval *metrics.Interval) (*metrics.TrafficMetricsList, error)
}

----------
main.go

	if viper.GetString("mesh") == "linkerd" {
		queries := util.Queries{
			ResourceQueries: viper.GetStringMapString("resourceQueries"),
			EdgeQueries:     viper.GetStringMapString("edgeQueries"),
		}

		mesh, err = linkerd.NewLinkerd(queries, viper.GetString("prometheus-url"))
		if err != nil {
			log.Fatal("Couldn't create a Linkerd instance %s", err)
		}
	}
  
  	s := server.Server{
		APIPort:        viper.GetInt("api-port"),
		AdminPort:      viper.GetInt("admin-port"),
		TLSCertificate: viper.GetString("tls-cert-file"),
		TLSPrivateKey:  viper.GetString("tls-private-key"),
		Mesh:           mesh,
	}
  
  --------
  handler.go
  
  // Handler provides the routes required to serve TrafficMetrics
type Handler struct {
	mesh util.Mesh

	queries util.Queries

	render *render.Render
}

  
  // Resources returns all the supported resource types for this server
func (h *Handler) resources(w http.ResponseWriter, r *http.Request) {

	lst, err := h.mesh.GetSupportedResources(r.Context())
	if err != nil {
		h.jsonResponse(w, http.StatusBadRequest, err.Error())
	}
	h.jsonResponse(w, http.StatusOK, lst)
}

// List returns a list of TrafficMetrics for a specific resource type
func (h *Handler) list(w http.ResponseWriter, r *http.Request) {
	kind := r.Context().Value(util.DetailsKey).(*util.ResourceDetails).Kind
	interval := r.Context().Value(util.IntervalKey).(*metrics.Interval)

	namespace := chi.URLParam(r, "namespace")

	resourceMetrics, err := h.mesh.GetResourceMetrics(r.Context(), "", namespace, kind, interval)

	if err != nil {
		h.jsonResponse(w, http.StatusInternalServerError, err.Error())
		return
	}

	h.jsonResponse(w, http.StatusOK, resourceMetrics)
}

// Get a set of metrics for a specific resource
func (h *Handler) get(w http.ResponseWriter, r *http.Request) {
	interval := r.Context().Value(util.IntervalKey).(*metrics.Interval)
	kind := r.Context().Value(util.DetailsKey).(*util.ResourceDetails).Kind

	namespace := chi.URLParam(r, "namespace")
	name := chi.URLParam(r, "name")

	resourceMetrics, err := h.mesh.GetResourceMetrics(r.Context(), name, namespace, kind, interval)

	if err != nil {
		h.jsonResponse(w, http.StatusInternalServerError, err.Error())
		return
	}

	if len(resourceMetrics.Items) != 1 {
		for _, x := range resourceMetrics.Items {
			log.Info(x.Resource)
		}
		log.Errorf("Wrong number of items: %d", len(resourceMetrics.Items))
		h.jsonResponse(w, http.StatusInternalServerError, util.ErrorResponse{
			Error: "unable to lookup metrics",
		})
		return
	}

	h.jsonResponse(w, http.StatusOK, resourceMetrics.Items[0])
}

func (h *Handler) edges(w http.ResponseWriter, r *http.Request) {
	interval := r.Context().Value(util.IntervalKey).(*metrics.Interval)
	details := r.Context().Value(util.DetailsKey).(util.ResourceDetails)
	kind := details.Kind

	namespace := chi.URLParam(r, "namespace")
	name := chi.URLParam(r, "name")

	edgeMetrics, err := h.mesh.GetEdgeMetrics(r.Context(), name, namespace, kind, details, interval)
	if err != nil {
		h.jsonResponse(w, http.StatusInternalServerError, err.Error())
		return
	}

	h.jsonResponse(w, http.StatusOK, edgeMetrics)

}