Bindings on runtime endpoint (#1275)

* Bindings on runtime endpoint

* wip

* wip

* wip

* wip

* wip

* wip

cmd/broker/binding_test.go

@@ -44,4 +44,8 @@ func TestBinding(t *testing.T) {
 	suite.Log(string(b))
 	suite.Log(resp.Status)
 
+	respRuntimes := suite.CallAPI("GET", "/info/runtimes?bindings=true", "")
+	b, _ = io.ReadAll(respRuntimes.Body)
+	suite.Log(string(b))
+	suite.Log(resp.Status)
 }

cmd/broker/broker_suite_test.go

@@ -259,7 +259,7 @@ func NewBrokerSuiteTestWithConfig(t *testing.T, cfg *Config, version ...string)
 	expirationHandler := expiration.NewHandler(db.Instances(), db.Operations(), deprovisioningQueue, logs)
 	expirationHandler.AttachRoutes(ts.router)
 
-	runtimeHandler := kebRuntime.NewHandler(db.Instances(), db.Operations(), db.RuntimeStates(), db.InstancesArchived(), cfg.MaxPaginationPage, cfg.DefaultRequestRegion, provisionerClient, cli, broker.KimConfig{
+	runtimeHandler := kebRuntime.NewHandler(db.Instances(), db.Operations(), db.RuntimeStates(), db.InstancesArchived(), db.Bindings(), cfg.MaxPaginationPage, cfg.DefaultRequestRegion, provisionerClient, cli, broker.KimConfig{
 		Enabled: false,
 	}, logs)
 	runtimeHandler.AttachRoutes(ts.router)

cmd/broker/main.go

@@ -375,7 +375,7 @@ func main() {
 
 	// create list runtimes endpoint
 	runtimeHandler := runtime.NewHandler(db.Instances(), db.Operations(),
-		db.RuntimeStates(), db.InstancesArchived(), cfg.MaxPaginationPage,
+		db.RuntimeStates(), db.InstancesArchived(), db.Bindings(), cfg.MaxPaginationPage,
 		cfg.DefaultRequestRegion, provisionerClient,
 		kcpK8sClient,
 		cfg.Broker.KimConfig,

common/runtime/model.go

@@ -54,6 +54,15 @@ type RuntimeDTO struct {
 	KymaConfig                  *gqlschema.KymaConfigInput     `json:"kymaConfig,omitempty"`
 	ClusterConfig               *gqlschema.GardenerConfigInput `json:"clusterConfig,omitempty"`
 	RuntimeConfig               *map[string]interface{}        `json:"runtimeConfig,omitempty"`
+	Bindings                    []BindingDTO                   `json:"bindings,omitempty"`
+}
+
+type BindingDTO struct {
+	ID                string    `json:"id"`
+	CreatedAt         time.Time `json:"createdAt"`
+	ExpirationSeconds int64     `json:"expiresInSeconds"`
+	ExpiresAt         time.Time `json:"expiresAt"`
+	Type              string    `json:"type"`
 }
 
 type RuntimeStatus struct {
@@ -121,6 +130,8 @@ const (
 	ExpiredParam         = "expired"
 	GardenerConfigParam  = "gardener_config"
 	RuntimeConfigParam   = "runtime_config"
+	BindingsParam        = "bindings"
+	WithBindingsParam    = "with_bindings" // TODO: find better name
 )
 
 type OperationDetail string

internal/runtime/handler.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"time"
 
 	"k8s.io/apimachinery/pkg/api/errors"
 
@@ -37,6 +38,7 @@ type Handler struct {
 	instancesDb         storage.Instances
 	operationsDb        storage.Operations
 	runtimeStatesDb     storage.RuntimeStates
+	bindingsDb          storage.Bindings
 	instancesArchivedDb storage.InstancesArchived
 	converter           Converter
 	defaultMaxPage      int
@@ -47,14 +49,15 @@ type Handler struct {
 }
 
 func NewHandler(instanceDb storage.Instances, operationDb storage.Operations, runtimeStatesDb storage.RuntimeStates,
-	instancesArchived storage.InstancesArchived, defaultMaxPage int, defaultRequestRegion string,
+	instancesArchived storage.InstancesArchived, bindingsDb storage.Bindings, defaultMaxPage int, defaultRequestRegion string,
 	provisionerClient provisioner.Client,
 	k8sClient client.Client, kimConfig broker.KimConfig,
 	logger logrus.FieldLogger) *Handler {
 	return &Handler{
 		instancesDb:         instanceDb,
 		operationsDb:        operationDb,
 		runtimeStatesDb:     runtimeStatesDb,
+		bindingsDb:          bindingsDb,
 		converter:           NewConverter(defaultRequestRegion),
 		defaultMaxPage:      defaultMaxPage,
 		provisionerClient:   provisionerClient,
@@ -193,6 +196,7 @@ func (h *Handler) getRuntimes(w http.ResponseWriter, req *http.Request) {
 	clusterConfig := getBoolParam(pkg.ClusterConfigParam, req)
 	gardenerConfig := getBoolParam(pkg.GardenerConfigParam, req)
 	runtimeResourceConfig := getBoolParam(pkg.RuntimeConfigParam, req)
+	bindings := getBoolParam(pkg.BindingsParam, req)
 
 	instances, count, totalCount, err := h.listInstances(filter)
 	if err != nil {
@@ -259,6 +263,15 @@ func (h *Handler) getRuntimes(w http.ResponseWriter, req *http.Request) {
 					dto.RuntimeConfig = &runtimeResourceObject.Object
 				}
 			}
+
+		}
+		if bindings {
+			err := h.addBindings(&dto)
+			if err != nil {
+				h.logger.Warn(fmt.Sprintf("unable to apply bindings: %s", err.Error()))
+				httputil.WriteErrorResponse(w, http.StatusInternalServerError, err)
+				return
+			}
 		}
 
 		toReturn = append(toReturn, dto)
@@ -506,6 +519,25 @@ func (h *Handler) getFilters(req *http.Request) dbmodel.InstanceFilter {
 	return filter
 }
 
+func (h *Handler) addBindings(p *pkg.RuntimeDTO) error {
+	bindings, err := h.bindingsDb.ListByInstanceID(p.InstanceID)
+	if err != nil {
+		return err
+	}
+	p.Bindings = make([]pkg.BindingDTO, 0, len(bindings))
+	for _, b := range bindings {
+		p.Bindings = append(p.Bindings, pkg.BindingDTO{
+			ID:                b.ID,
+			ExpirationSeconds: b.ExpirationSeconds,
+			CreatedAt:         b.CreatedAt,
+			ExpiresAt:         b.CreatedAt.Add(time.Duration(b.ExpirationSeconds) * time.Second),
+			Type:              b.BindingType,
+		})
+	}
+
+	return nil
+}
+
 func getOpDetail(req *http.Request) pkg.OperationDetail {
 	opDetail := pkg.AllOperation
 	opDetailParams := req.URL.Query()[pkg.OperationDetailParam]

internal/runtime/handler_test.go

@@ -45,6 +45,7 @@ func TestRuntimeHandler(t *testing.T) {
 		instances := db.Instances()
 		states := db.RuntimeStates()
 		archived := db.InstancesArchived()
+		bindings := db.Bindings()
 		testID1 := "Test1"
 		testID2 := "Test2"
 		testTime1 := time.Now()
@@ -65,7 +66,7 @@ func TestRuntimeHandler(t *testing.T) {
 		err = instances.Insert(testInstance2)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, bindings, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", "/runtimes?page_size=1", nil)
 		require.NoError(t, err)
@@ -120,7 +121,7 @@ func TestRuntimeHandler(t *testing.T) {
 		states := db.RuntimeStates()
 		archived := db.InstancesArchived()
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "region", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "region", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", "/runtimes?page_size=a", nil)
 		require.NoError(t, err)
@@ -179,7 +180,7 @@ func TestRuntimeHandler(t *testing.T) {
 		err = operations.InsertOperation(testOp2)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", fmt.Sprintf("/runtimes?account=%s&subaccount=%s&instance_id=%s&runtime_id=%s&region=%s&shoot=%s", testID1, testID1, testID1, testID1, testID1, fmt.Sprintf("Shoot-%s", testID1)), nil)
 		require.NoError(t, err)
@@ -255,7 +256,7 @@ func TestRuntimeHandler(t *testing.T) {
 		err = operations.InsertDeprovisioningOperation(deprovOp3)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -364,7 +365,7 @@ func TestRuntimeHandler(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", "/runtimes", nil)
 		require.NoError(t, err)
@@ -437,7 +438,7 @@ func TestRuntimeHandler(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", "/runtimes", nil)
 		require.NoError(t, err)
@@ -509,7 +510,7 @@ func TestRuntimeHandler(t *testing.T) {
 		})
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		req, err := http.NewRequest("GET", "/runtimes", nil)
 		require.NoError(t, err)
@@ -564,7 +565,7 @@ func TestRuntimeHandler(t *testing.T) {
 		err = operations.InsertUpdatingOperation(updOp)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -695,7 +696,7 @@ func TestRuntimeHandler(t *testing.T) {
 		err = states.Insert(fixOpgClusterState)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -749,7 +750,7 @@ func TestRuntimeHandler(t *testing.T) {
 		_, err = provisionerClient.ProvisionRuntimeWithIDs(operation.GlobalAccountID, operation.SubAccountID, operation.RuntimeID, operation.ID, input)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -801,7 +802,7 @@ func TestRuntimeHandler(t *testing.T) {
 		_, err = provisionerClient.ProvisionRuntimeWithIDs(operation.GlobalAccountID, operation.SubAccountID, operation.RuntimeID, operation.ID, input)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -862,7 +863,7 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 		err = operations.InsertUpdatingOperation(updOp)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -992,7 +993,7 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 		err = states.Insert(fixOpgClusterState)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -1046,7 +1047,7 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 		_, err = provisionerClient.ProvisionRuntimeWithIDs(operation.GlobalAccountID, operation.SubAccountID, operation.RuntimeID, operation.ID, input)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -1104,7 +1105,7 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 			KimOnlyPlans: []string{"no-plan"},
 		}
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimDisabledForPreview, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimDisabledForPreview, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -1158,7 +1159,7 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 		_, err = provisionerClient.ProvisionRuntimeWithIDs(operation.GlobalAccountID, operation.SubAccountID, operation.RuntimeID, operation.ID, input)
 		require.NoError(t, err)
 
-		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, nil, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
 
 		rr := httptest.NewRecorder()
 		router := mux.NewRouter()
@@ -1200,6 +1201,66 @@ func TestRuntimeHandler_WithKimOnlyDrivenInstances(t *testing.T) {
 		assert.False(t, ok)
 	})
 
+	t.Run("test bindings optional attribute", func(t *testing.T) {
+		// given
+		db := storage.NewMemoryStorage()
+		operations := db.Operations()
+		instances := db.Instances()
+		states := db.RuntimeStates()
+		archived := db.InstancesArchived()
+		bindings := db.Bindings()
+		testID := "Test1"
+		testTime := time.Now()
+		testInstance := fixInstanceForPreview(testID, testTime)
+		testInstance.Provider = "aws"
+		testInstance.RuntimeID = fmt.Sprintf("runtime-%s", testID)
+		err := instances.Insert(testInstance)
+		require.NoError(t, err)
+
+		operation := fixture.FixProvisioningOperation(fixRandomID(), testID)
+		operation.KymaResourceNamespace = "kcp-system"
+
+		err = operations.InsertOperation(operation)
+		require.NoError(t, err)
+
+		binding := fixture.FixBinding("abcd")
+		binding.InstanceID = testInstance.InstanceID
+		err = bindings.Insert(&binding)
+		require.NoError(t, err)
+
+		input, err := operation.InputCreator.CreateProvisionRuntimeInput()
+		require.NoError(t, err)
+
+		_, err = provisionerClient.ProvisionRuntimeWithIDs(operation.GlobalAccountID, operation.SubAccountID, operation.RuntimeID, operation.ID, input)
+		require.NoError(t, err)
+
+		runtimeHandler := runtime.NewHandler(instances, operations, states, archived, bindings, 2, "", provisionerClient, k8sClient, kimConfig, logrus.New())
+
+		rr := httptest.NewRecorder()
+		router := mux.NewRouter()
+		runtimeHandler.AttachRoutes(router)
+
+		// when
+		req, err := http.NewRequest("GET", "/runtimes?bindings=true", nil)
+		require.NoError(t, err)
+		router.ServeHTTP(rr, req)
+
+		// then
+		require.Equal(t, http.StatusOK, rr.Code)
+
+		var out pkg.RuntimesPage
+
+		err = json.Unmarshal(rr.Body.Bytes(), &out)
+		require.NoError(t, err)
+
+		assert.Equal(t, testID, out.Data[0].InstanceID)
+		assert.NotNil(t, out.Data[0].Bindings)
+
+		b := out.Data[0].Bindings[0]
+		assert.Equal(t, binding.BindingType, b.Type)
+
+	})
+
 }
 
 func fixInstance(id string, t time.Time) internal.Instance {

internal/storage/dbmodel/instance.go

@@ -35,6 +35,7 @@ type InstanceFilter struct {
 	States                       []InstanceState
 	Expired                      *bool
 	DeletionAttempted            *bool
+	BindingExists                *bool
 }
 
 type InstanceDTO struct {

internal/storage/driver/postsql/instance_test.go

@@ -376,6 +376,10 @@ func TestInstance(t *testing.T) {
 			fixture.FixProvisioningOperation("op3", "inst3"),
 			fixture.FixProvisioningOperation("op4", "expiredinstance"),
 		}
+		fixBinding := fixture.FixBinding("binding1")
+		fixBinding.InstanceID = fixInstances[0].InstanceID
+		err = brokerStorage.Bindings().Insert(&fixBinding)
+		require.NoError(t, err)
 		for i, v := range fixInstances {
 			v.InstanceDetails = fixture.FixInstanceDetails(v.InstanceID)
 			fixInstances[i] = v
@@ -470,6 +474,11 @@ func TestInstance(t *testing.T) {
 		require.Equal(t, 3, count)
 		require.Equal(t, 3, totalCount)
 
+		out, count, totalCount, err = brokerStorage.Instances().List(dbmodel.InstanceFilter{BindingExists: ptr.Bool(true)})
+		require.NoError(t, err)
+		require.Equal(t, 1, count)
+		require.Equal(t, 1, totalCount)
+
 	})
 
 	t.Run("Should list instances based on filters", func(t *testing.T) {

internal/storage/postsql/read.go

@@ -882,6 +882,10 @@ func addInstanceFilters(stmt *dbr.SelectStmt, filter dbmodel.InstanceFilter) {
 			stmt.Where("instances.deleted_at = '0001-01-01T00:00:00.000Z'")
 		}
 	}
+
+	if filter.BindingExists != nil && *filter.BindingExists {
+		stmt.Where("exists (select instance_id from bindings where bindings.instance_id=instances.instance_id)")
+	}
 }
 
 func addOrchestrationFilters(stmt *dbr.SelectStmt, filter dbmodel.OrchestrationFilter) {