feat(kuma-cp) add GlobalInsights api endpoint

pkg/api-server/global_insights_endpoints.go

@@ -0,0 +1,77 @@
+package api_server
+
+import (
+	"time"
+
+	"github.com/emicklei/go-restful"
+
+	"github.com/kumahq/kuma/pkg/core"
+	"github.com/kumahq/kuma/pkg/core/resources/apis/mesh"
+	"github.com/kumahq/kuma/pkg/core/resources/apis/system"
+	"github.com/kumahq/kuma/pkg/core/resources/manager"
+	"github.com/kumahq/kuma/pkg/core/resources/rbac"
+	rest_errors "github.com/kumahq/kuma/pkg/core/rest/errors"
+)
+
+type globalInsightsEndpoints struct {
+	resManager     manager.ResourceManager
+	resourceAccess rbac.ResourceAccess
+}
+
+type globalInsightsStat struct {
+	Total uint32 `json:"total"`
+}
+
+type globalInsightsResponse struct {
+	Type          string             `json:"type"`
+	CreationTime  time.Time          `json:"creationTime"`
+	Meshes        globalInsightsStat `json:"meshes"`
+	Zones         globalInsightsStat `json:"zones"`
+	ZoneIngresses globalInsightsStat `json:"zoneIngresses"`
+}
+
+func newGlobalInsightsResponse(meshes, zones, zoneIngresses globalInsightsStat) *globalInsightsResponse {
+	return &globalInsightsResponse{
+		Type:          "GlobalInsights",
+		CreationTime:  core.Now(),
+		Meshes:        meshes,
+		Zones:         zones,
+		ZoneIngresses: zoneIngresses,
+	}
+}
+
+func (r *globalInsightsEndpoints) addEndpoint(ws *restful.WebService) {
+	ws.Route(ws.GET("/global-insights").To(r.inspectGlobalResources).
+		Doc("Inspect all global resources").
+		Returns(200, "OK", nil))
+}
+
+func (r *globalInsightsEndpoints) inspectGlobalResources(request *restful.Request, response *restful.Response) {
+	meshes := &mesh.MeshResourceList{}
+	if err := r.resManager.List(request.Request.Context(), meshes); err != nil {
+		rest_errors.HandleError(response, err, "Could not retrieve global insights")
+		return
+	}
+
+	zones := &system.ZoneResourceList{}
+	if err := r.resManager.List(request.Request.Context(), zones); err != nil {
+		rest_errors.HandleError(response, err, "Could not retrieve global insights")
+		return
+	}
+
+	zoneIngresses := &mesh.ZoneIngressResourceList{}
+	if err := r.resManager.List(request.Request.Context(), zoneIngresses); err != nil {
+		rest_errors.HandleError(response, err, "Could not retrieve global insights")
+		return
+	}
+
+	insights := newGlobalInsightsResponse(
+		globalInsightsStat{Total: uint32(len(meshes.Items))},
+		globalInsightsStat{Total: uint32(len(zones.Items))},
+		globalInsightsStat{Total: uint32(len(zoneIngresses.Items))},
+	)
+
+	if err := response.WriteAsJson(insights); err != nil {
+		rest_errors.HandleError(response, err, "Could not retrieve global insights")
+	}
+}

pkg/api-server/global_insights_endpoints_test.go

@@ -0,0 +1,128 @@
+package api_server_test
+
+import (
+	"context"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	api_server "github.com/kumahq/kuma/pkg/api-server"
+	config "github.com/kumahq/kuma/pkg/config/api-server"
+	"github.com/kumahq/kuma/pkg/core"
+	core_mesh "github.com/kumahq/kuma/pkg/core/resources/apis/mesh"
+	"github.com/kumahq/kuma/pkg/core/resources/apis/system"
+	core_model "github.com/kumahq/kuma/pkg/core/resources/model"
+	"github.com/kumahq/kuma/pkg/core/resources/store"
+	"github.com/kumahq/kuma/pkg/metrics"
+	"github.com/kumahq/kuma/pkg/plugins/resources/memory"
+)
+
+var _ = Describe("Global Insights Endpoints", func() {
+	var apiServer *api_server.ApiServer
+	var resourceStore store.ResourceStore
+	var stop chan struct{}
+
+	BeforeEach(func() {
+		core.Now = func() time.Time {
+			now, _ := time.Parse(time.RFC3339, "2018-07-17T16:05:36.995+00:00")
+			return now
+		}
+
+		resourceStore = memory.NewStore()
+
+		metrics, err := metrics.NewMetrics("Standalone")
+		Expect(err).ToNot(HaveOccurred())
+
+		apiServer = createTestApiServer(resourceStore, config.DefaultApiServerConfig(), true, metrics)
+
+		client := resourceApiClient{
+			address: apiServer.Address(),
+			path:    "/global-insights",
+		}
+
+		stop = make(chan struct{})
+
+		go func() {
+			defer GinkgoRecover()
+			Expect(apiServer.Start(stop)).To(Succeed())
+		}()
+
+		waitForServer(&client)
+	}, 5)
+
+	AfterEach(func() {
+		close(stop)
+		core.Now = time.Now
+	})
+
+	BeforeEach(func() {
+		Expect(resourceStore.Create(
+			context.Background(),
+			system.NewZoneResource(),
+			store.CreateByKey("zone-1", core_model.NoMesh),
+		)).To(Succeed())
+
+		Expect(resourceStore.Create(
+			context.Background(),
+			system.NewZoneResource(),
+			store.CreateByKey("zone-2", core_model.NoMesh),
+		)).To(Succeed())
+
+		Expect(resourceStore.Create(
+			context.Background(),
+			core_mesh.NewZoneIngressResource(),
+			store.CreateByKey("zone-ingress-1", core_model.NoMesh),
+		)).To(Succeed())
+
+		Expect(resourceStore.Create(
+			context.Background(),
+			core_mesh.NewMeshResource(),
+			store.CreateByKey("mesh-1", core_model.NoMesh),
+		)).To(Succeed())
+
+		Expect(resourceStore.Create(
+			context.Background(),
+			core_mesh.NewMeshResource(),
+			store.CreateByKey("mesh-2", core_model.NoMesh),
+		)).To(Succeed())
+
+		Expect(resourceStore.Create(
+			context.Background(),
+			core_mesh.NewMeshResource(),
+			store.CreateByKey("mesh-3", core_model.NoMesh),
+		)).To(Succeed())
+	})
+
+	globalInsightsJSON := `
+{
+  "type": "GlobalInsights",
+  "creationTime": "2018-07-17T16:05:36.995Z",
+  "meshes": {
+    "total": 3
+  },
+  "zones": {
+    "total": 2
+  },
+  "zoneIngresses": {
+    "total": 1
+  }
+}
+`
+
+	Describe("On GET", func() {
+		It("should return an existing resource", func() {
+			// when
+			response, err := http.Get("http://" + apiServer.Address() + "/global-insights")
+			Expect(err).ToNot(HaveOccurred())
+
+			// then
+			Expect(response.StatusCode).To(Equal(200))
+			body, err := ioutil.ReadAll(response.Body)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(body).To(MatchJSON(globalInsightsJSON))
+		})
+	})
+})

pkg/api-server/server.go

@@ -183,6 +183,12 @@ func addResourcesEndpoints(ws *restful.WebService, defs []model.ResourceTypeDesc
 	zoneIngressOverviewEndpoints.addFindEndpoint(ws)
 	zoneIngressOverviewEndpoints.addListEndpoint(ws)
 
+	globalInsightsEndpoints := globalInsightsEndpoints{
+		resManager:     resManager,
+		resourceAccess: resourceAccess,
+	}
+	globalInsightsEndpoints.addEndpoint(ws)
+
 	for _, definition := range defs {
 		defType := definition.Name
 		if cfg.ApiServer.ReadOnly || (defType == mesh.DataplaneType && cfg.Mode == config_core.Global) || (defType != mesh.DataplaneType && cfg.Mode == config_core.Zone) {