Platforms connection in health-check

api/healthcheck/healthcheck_controller.go

@@ -17,10 +17,12 @@
 package healthcheck
 
 import (
+	"context"
 	h "github.com/InVisionApp/go-health"
 	"github.com/Peripli/service-manager/pkg/health"
 	"github.com/Peripli/service-manager/pkg/util"
 	"net/http"
+	"strings"
 
 	"github.com/Peripli/service-manager/pkg/log"
 	"github.com/Peripli/service-manager/pkg/web"
@@ -46,7 +48,7 @@ func (c *controller) healthCheck(r *web.Request) (*web.Response, error) {
 	logger := log.C(ctx)
 	logger.Debugf("Performing health check...")
 	healthState, _, _ := c.health.State()
-	healthResult := c.aggregate(healthState)
+	healthResult := c.aggregate(ctx, healthState)
 	var status int
 	if healthResult.Status == health.StatusUp {
 		status = http.StatusOK
@@ -56,7 +58,7 @@ func (c *controller) healthCheck(r *web.Request) (*web.Response, error) {
 	return util.NewJSONResponse(status, healthResult)
 }
 
-func (c *controller) aggregate(overallState map[string]h.State) *health.Health {
+func (c *controller) aggregate(ctx context.Context, overallState map[string]h.State) *health.Health {
 	if len(overallState) == 0 {
 		return health.New().WithStatus(health.StatusUp)
 	}
@@ -70,6 +72,9 @@ func (c *controller) aggregate(overallState map[string]h.State) *health.Health {
 	details := make(map[string]interface{})
 	for name, state := range overallState {
 		state.Status = convertStatus(state.Status)
+		if strings.Contains(name, health.PlatformIndicatorSuffix) && !web.IsAuthorized(ctx) {
+			state.Details = nil
+		}
 		details[name] = state
 	}
 	return health.New().WithStatus(overallStatus).WithDetails(details)

api/healthcheck/healthcheck_controller_test.go

@@ -13,9 +13,11 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
+
 package healthcheck
 
 import (
+	"context"
 	"fmt"
 	h "github.com/InVisionApp/go-health"
 	"github.com/Peripli/service-manager/pkg/health"
@@ -60,14 +62,20 @@ var _ = Describe("Healthcheck controller", func() {
 	})
 
 	Describe("aggregation", func() {
+		var ctx context.Context
 		var c *controller
 		var healths map[string]h.State
+		var platformHealths map[string]h.State
 		var thresholds map[string]int64
 
 		BeforeEach(func() {
+			ctx = context.TODO()
 			healths = map[string]h.State{
-				"test1": {Status: "ok"},
-				"test2": {Status: "ok"},
+				"test1": {Status: "ok", Details: "details"},
+				"test2": {Status: "ok", Details: "details"},
+			}
+			platformHealths = map[string]h.State{
+				"k8s_platforms": {Status: "ok", Details: "details"},
 			}
 			thresholds = map[string]int64{
 				"test1": 3,
@@ -81,7 +89,7 @@ var _ = Describe("Healthcheck controller", func() {
 
 		When("No healths are provided", func() {
 			It("Returns UP", func() {
-				aggregatedHealth := c.aggregate(nil)
+				aggregatedHealth := c.aggregate(ctx, nil)
 				Expect(aggregatedHealth.Status).To(Equal(health.StatusUp))
 			})
 		})
@@ -90,15 +98,15 @@ var _ = Describe("Healthcheck controller", func() {
 			It("Returns DOWN", func() {
 				healths["test3"] = h.State{Status: "failed", Fatal: true, ContiguousFailures: 4}
 				c.thresholds["test3"] = 3
-				aggregatedHealth := c.aggregate(healths)
+				aggregatedHealth := c.aggregate(ctx, healths)
 				Expect(aggregatedHealth.Status).To(Equal(health.StatusDown))
 			})
 		})
 
 		When("At least one health is DOWN and is not Fatal", func() {
 			It("Returns UP", func() {
 				healths["test3"] = h.State{Status: "failed", Fatal: false, ContiguousFailures: 4}
-				aggregatedHealth := c.aggregate(healths)
+				aggregatedHealth := c.aggregate(ctx, healths)
 				Expect(aggregatedHealth.Status).To(Equal(health.StatusUp))
 			})
 		})
@@ -107,27 +115,49 @@ var _ = Describe("Healthcheck controller", func() {
 			It("Returns UP", func() {
 				healths["test3"] = h.State{Status: "failed"}
 				c.thresholds["test3"] = 3
-				aggregatedHealth := c.aggregate(healths)
+				aggregatedHealth := c.aggregate(ctx, healths)
 				Expect(aggregatedHealth.Status).To(Equal(health.StatusUp))
 			})
 		})
 
 		When("All healths are UP", func() {
 			It("Returns UP", func() {
-				aggregatedHealth := c.aggregate(healths)
+				aggregatedHealth := c.aggregate(ctx, healths)
 				Expect(aggregatedHealth.Status).To(Equal(health.StatusUp))
 			})
 		})
 
 		When("Aggregating healths", func() {
 			It("Includes them as overall details", func() {
-				aggregatedHealth := c.aggregate(healths)
+				aggregatedHealth := c.aggregate(ctx, healths)
 				for name, h := range healths {
 					h.Status = convertStatus(h.Status)
 					Expect(aggregatedHealth.Details[name]).To(Equal(h))
 				}
 			})
 		})
+
+		When("Aggregating platforms health as unauthorized user", func() {
+			It("should strip platform details", func() {
+				aggregatedHealth := c.aggregate(ctx, platformHealths)
+				for name, h := range platformHealths {
+					h.Status = convertStatus(h.Status)
+					h.Details = nil
+					Expect(aggregatedHealth.Details[name]).To(Equal(h))
+				}
+			})
+		})
+
+		When("Aggregating platforms health as authorized user", func() {
+			It("should include all platform details", func() {
+				ctx = web.ContextWithAuthorization(ctx)
+				aggregatedHealth := c.aggregate(ctx, platformHealths)
+				for name, h := range platformHealths {
+					h.Status = convertStatus(h.Status)
+					Expect(aggregatedHealth.Details[name]).To(Equal(h))
+				}
+			})
+		})
 	})
 })
 

api/healthcheck/platform_indicator.go

@@ -0,0 +1,72 @@
+/*
+ *    Copyright 2018 The Service Manager Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package healthcheck
+
+import (
+	"context"
+	"fmt"
+	"github.com/Peripli/service-manager/pkg/health"
+	"github.com/Peripli/service-manager/pkg/query"
+	"github.com/Peripli/service-manager/pkg/types"
+	"github.com/Peripli/service-manager/storage"
+)
+
+// NewPlatformIndicator returns new health indicator for platforms of given type
+func NewPlatformIndicator(ctx context.Context, repository storage.Repository, platformType string) health.Indicator {
+	return &platformIndicator{
+		ctx:          ctx,
+		repository:   repository,
+		platformType: platformType,
+	}
+}
+
+type platformIndicator struct {
+	repository   storage.Repository
+	ctx          context.Context
+	platformType string
+}
+
+// Name returns the name of the indicator
+func (pi *platformIndicator) Name() string {
+	return pi.platformType + health.PlatformIndicatorSuffix // e.g. cf_platforms, k8s_platforms ...
+}
+
+// Status returns status of the health check
+func (pi *platformIndicator) Status() (interface{}, error) {
+	typeCriteria := query.Criterion{
+		LeftOp:   "type",
+		Operator: query.EqualsOperator,
+		RightOp:  []string{pi.platformType},
+		Type:     query.FieldQuery,
+	}
+	objList, err := pi.repository.List(pi.ctx, types.PlatformType, typeCriteria)
+	if err != nil {
+		return nil, fmt.Errorf("could not fetch platforms health from storage: %v", err)
+	}
+
+	details := make(map[string]interface{})
+	for i := 0; i < objList.Len(); i++ {
+		platform := objList.ItemAt(i).(*types.Platform)
+		if platform.Active {
+			details[platform.Name] = health.New().WithStatus(health.StatusUp)
+		} else {
+			details[platform.Name] = health.New().WithStatus(health.StatusDown).WithDetail("since", platform.LastActive)
+			err = fmt.Errorf("there is inactive %s platforms", pi.platformType)
+		}
+	}
+	return details, err
+}

api/healthcheck/platform_indicator_test.go

@@ -0,0 +1,93 @@
+/*
+ *    Copyright 2018 The Service Manager Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+package healthcheck
+
+import (
+	"context"
+	"errors"
+	"github.com/Peripli/service-manager/pkg/health"
+	"github.com/Peripli/service-manager/pkg/types"
+	storagefakes2 "github.com/Peripli/service-manager/storage/storagefakes"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"time"
+)
+
+var _ = Describe("Platforms Indicator", func() {
+	var indicator health.Indicator
+	var repository *storagefakes2.FakeStorage
+	var platformType string
+	var ctx context.Context
+	var platform *types.Platform
+
+	BeforeEach(func() {
+		ctx = context.TODO()
+		repository = &storagefakes2.FakeStorage{}
+		platformType = "kubernetes"
+		platform = &types.Platform{
+			Name:       "test-platform",
+			Type:       platformType,
+			Active:     false,
+			LastActive: time.Now(),
+		}
+		indicator = NewPlatformIndicator(ctx, repository, platformType)
+	})
+
+	Context("Name", func() {
+		It("should contain platform type in it", func() {
+			Expect(indicator.Name()).Should(ContainSubstring(platformType))
+		})
+	})
+
+	Context("There is inactive platforms", func() {
+		BeforeEach(func() {
+			objectList := &types.Platforms{[]*types.Platform{platform}}
+			repository.ListReturns(objectList, nil)
+		})
+		It("should return error", func() {
+			details, err := indicator.Status()
+			health := details.(map[string]interface{})[platform.Name].(*health.Health)
+			Expect(err).Should(HaveOccurred())
+			Expect(health.Details["since"]).ShouldNot(BeNil())
+		})
+	})
+
+	Context("Storage returns error", func() {
+		var expectedErr error
+		BeforeEach(func() {
+			expectedErr = errors.New("storage err")
+			repository.ListReturns(nil, expectedErr)
+		})
+		It("should return error", func() {
+			_, err := indicator.Status()
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring(expectedErr.Error()))
+		})
+	})
+
+	Context("All platforms are active", func() {
+		BeforeEach(func() {
+			platform.Active = true
+			objectList := &types.Platforms{[]*types.Platform{platform}}
+			repository.ListReturns(objectList, nil)
+		})
+		It("should not return error", func() {
+			_, err := indicator.Status()
+			Expect(err).ShouldNot(HaveOccurred())
+		})
+	})
+})