In-Memory Cache for CF Resources

go.mod

@@ -19,6 +19,7 @@ require (
 
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/caarlos0/env/v11 v11.2.2
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect

go.sum

@@ -1,5 +1,7 @@
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/caarlos0/env/v11 v11.2.2 h1:95fApNrUyueipoZN/EhA8mMxiNxrBwDa+oAZrMWl3Kg=
+github.com/caarlos0/env/v11 v11.2.2/go.mod h1:JBfcdeQiBoI3Zh1QRAWfe+tpiNTmDtcCj/hHHHMx0vc=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=

internal/cf/client.go

@@ -6,13 +6,16 @@ SPDX-License-Identifier: Apache-2.0
 package cf
 
 import (
+	"context"
 	"fmt"
+	"log"
 	"sync"
 
 	cfclient "github.com/cloudfoundry-community/go-cfclient/v3/client"
 	cfconfig "github.com/cloudfoundry-community/go-cfclient/v3/config"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 
+	"github.com/sap/cf-service-operator/internal/config"
 	"github.com/sap/cf-service-operator/internal/facade"
 	cfmetrics "github.com/sap/cf-service-operator/pkg/metrics"
 )
@@ -31,11 +34,13 @@ const (
 type organizationClient struct {
 	organizationName string
 	client           cfclient.Client
+	//resourceCache   *facade.Cache
 }
 
 type spaceClient struct {
-	spaceGuid string
-	client    cfclient.Client
+	spaceGuid     string
+	client        cfclient.Client
+	resourceCache *facade.ResourceCache
 }
 
 type clientIdentifier struct {
@@ -51,8 +56,10 @@ type clientCacheEntry struct {
 }
 
 var (
-	cacheMutex  = &sync.Mutex{}
-	clientCache = make(map[clientIdentifier]*clientCacheEntry)
+	clientCacheMutex          = &sync.Mutex{}
+	clientCache               = make(map[clientIdentifier]*clientCacheEntry)
+	cfResourceCache           *facade.ResourceCache
+	refreshResourceCacheMutex = &sync.Mutex{}
 )
 
 func newOrganizationClient(organizationName string, url string, username string, password string) (*organizationClient, error) {
@@ -83,6 +90,8 @@ func newOrganizationClient(organizationName string, url string, username string,
 	if err != nil {
 		return nil, err
 	}
+	// TODO:Populate resource cache for ORg client
+
 	return &organizationClient{organizationName: organizationName, client: *c}, nil
 }
 
@@ -114,12 +123,13 @@ func newSpaceClient(spaceGuid string, url string, username string, password stri
 	if err != nil {
 		return nil, err
 	}
+
 	return &spaceClient{spaceGuid: spaceGuid, client: *c}, nil
 }
 
 func NewOrganizationClient(organizationName string, url string, username string, password string) (facade.OrganizationClient, error) {
-	cacheMutex.Lock()
-	defer cacheMutex.Unlock()
+	clientCacheMutex.Lock()
+	defer clientCacheMutex.Unlock()
 
 	// look up CF client in cache
 	identifier := clientIdentifier{url: url, username: username}
@@ -149,9 +159,9 @@ func NewOrganizationClient(organizationName string, url string, username string,
 	return client, err
 }
 
-func NewSpaceClient(spaceGuid string, url string, username string, password string) (facade.SpaceClient, error) {
-	cacheMutex.Lock()
-	defer cacheMutex.Unlock()
+func NewSpaceClient(spaceGuid string, url string, username string, password string, config config.Config) (facade.SpaceClient, error) {
+	clientCacheMutex.Lock()
+	defer clientCacheMutex.Unlock()
 
 	// look up CF client in cache
 	identifier := clientIdentifier{url: url, username: username}
@@ -161,7 +171,7 @@ func NewSpaceClient(spaceGuid string, url string, username string, password stri
 	var client *spaceClient = nil
 	if isInCache {
 		// re-use CF client from cache and wrap it as spaceClient
-		client = &spaceClient{spaceGuid: spaceGuid, client: cacheEntry.client}
+		client = &spaceClient{spaceGuid: spaceGuid, client: cacheEntry.client, resourceCache: cfResourceCache}
 		if cacheEntry.password != password {
 			// password was rotated => delete client from cache and create a new one below
 			delete(clientCache, identifier)
@@ -178,12 +188,20 @@ func NewSpaceClient(spaceGuid string, url string, username string, password stri
 		}
 	}
 
+	if config.IsResourceCacheEnabled && client.resourceCache == nil {
+		client.resourceCache = facade.InitResourceCache()
+		client.resourceCache.SetResourceCacheEnabled(config.IsResourceCacheEnabled)
+		client.resourceCache.SetCacheTimeOut(config.CacheTimeOut)
+		client.populateResourceCache()
+	}
+
 	return client, err
+
 }
 
 func NewSpaceHealthChecker(spaceGuid string, url string, username string, password string) (facade.SpaceHealthChecker, error) {
-	cacheMutex.Lock()
-	defer cacheMutex.Unlock()
+	clientCacheMutex.Lock()
+	defer clientCacheMutex.Unlock()
 
 	// look up CF client in cache
 	identifier := clientIdentifier{url: url, username: username}
@@ -212,3 +230,46 @@ func NewSpaceHealthChecker(spaceGuid string, url string, username string, passwo
 
 	return client, err
 }
+
+func (c *spaceClient) populateResourceCache() {
+	// TODO: Create the space options
+	// TODO: Add for loop for space
+	refreshResourceCacheMutex.Lock()
+	defer refreshResourceCacheMutex.Unlock()
+	if c.resourceCache.IsCacheExpired() {
+		instanceOptions := cfclient.NewServiceInstanceListOptions()
+		instanceOptions.ListOptions.LabelSelector.EqualTo(labelOwner)
+		instanceOptions.Page = 1
+		instanceOptions.PerPage = 500
+		//instanceOptions.OrganizationGUIDs.EqualTo("21dc8fd6-ea17-49df-99e9-cacf57b479fc")
+
+		ctx := context.Background()
+		// populate instance cache
+		for {
+			srvInstanes, pager, err := c.client.ServiceInstances.List(ctx, instanceOptions)
+			if err != nil {
+				log.Fatalf("Error listing service instances: %s", err)
+			}
+
+			// Cache the service instance
+			for _, serviceInstance := range srvInstanes {
+				// ... some caching logic
+				instance, err := InitInstance(serviceInstance)
+				// instance is added to cache only if error is nil
+				if err == nil {
+					c.resourceCache.AddInstanceInCache(*serviceInstance.Metadata.Labels[labelOwner], instance)
+				}
+			}
+
+			if !pager.HasNextPage() {
+				fmt.Printf("No more pages\n")
+				break
+			}
+
+			pager.NextPage(instanceOptions)
+		}
+		c.resourceCache.SetLastCacheTime()
+		cfResourceCache = c.resourceCache
+	}
+	// TODO: Add for loop for bindings
+}

internal/cf/client_test.go

@@ -14,6 +14,7 @@ import (
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/ghttp"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sap/cf-service-operator/internal/config"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 )
 
@@ -49,6 +50,15 @@ func TestCFClient(t *testing.T) {
 	RunSpecs(t, "CF Client Test Suite")
 }
 
+// is resource cache enabled and cache timeout
+var resourceCacheEnabled = false
+var resourceCacheTimeout = 5 * time.Minute
+
+var cfg = &config.Config{
+	IsResourceCacheEnabled: resourceCacheEnabled,
+	CacheTimeOut:           resourceCacheTimeout.String(),
+}
+
 // -----------------------------------------------------------------------------------------------
 // Tests
 // -----------------------------------------------------------------------------------------------
@@ -224,7 +234,7 @@ var _ = Describe("CF Client tests", Ordered, func() {
 		})
 
 		It("should create SpaceClient", func() {
-			NewSpaceClient(OrgName, url, Username, Password)
+			NewSpaceClient(OrgName, url, Username, Password, *cfg)
 
 			// Discover UAA endpoint
 			Expect(server.ReceivedRequests()[0].Method).To(Equal("GET"))
@@ -234,7 +244,7 @@ var _ = Describe("CF Client tests", Ordered, func() {
 		})
 
 		It("should be able to query some space", func() {
-			spaceClient, err := NewSpaceClient(OrgName, url, Username, Password)
+			spaceClient, err := NewSpaceClient(OrgName, url, Username, Password, *cfg)
 			Expect(err).To(BeNil())
 
 			spaceClient.GetInstance(ctx, map[string]string{"owner": Owner})
@@ -266,11 +276,11 @@ var _ = Describe("CF Client tests", Ordered, func() {
 		})
 
 		It("should be able to query some space twice", func() {
-			spaceClient, err := NewSpaceClient(OrgName, url, Username, Password)
+			spaceClient, err := NewSpaceClient(OrgName, url, Username, Password, *cfg)
 			Expect(err).To(BeNil())
 
 			spaceClient.GetInstance(ctx, map[string]string{"owner": Owner})
-			spaceClient, err = NewSpaceClient(OrgName, url, Username, Password)
+			spaceClient, err = NewSpaceClient(OrgName, url, Username, Password, *cfg)
 			Expect(err).To(BeNil())
 			spaceClient.GetInstance(ctx, map[string]string{"owner": Owner})
 
@@ -293,7 +303,7 @@ var _ = Describe("CF Client tests", Ordered, func() {
 
 		It("should be able to query two different spaces", func() {
 			// test space 1
-			spaceClient1, err1 := NewSpaceClient(SpaceName, url, Username, Password)
+			spaceClient1, err1 := NewSpaceClient(SpaceName, url, Username, Password, *cfg)
 			Expect(err1).To(BeNil())
 			spaceClient1.GetInstance(ctx, map[string]string{"owner": Owner})
 			// Discover UAA endpoint
@@ -307,7 +317,7 @@ var _ = Describe("CF Client tests", Ordered, func() {
 			Expect(server.ReceivedRequests()[2].RequestURI).To(ContainSubstring(Owner))
 
 			// test space 2
-			spaceClient2, err2 := NewSpaceClient(SpaceName2, url, Username, Password)
+			spaceClient2, err2 := NewSpaceClient(SpaceName2, url, Username, Password, *cfg)
 			Expect(err2).To(BeNil())
 			spaceClient2.GetInstance(ctx, map[string]string{"owner": Owner2})
 			// no discovery of UAA endpoint or oAuth token here due to caching
@@ -336,7 +346,7 @@ var _ = Describe("CF Client tests", Ordered, func() {
 		})
 
 		It("should register prometheus metrics for SpaceClient", func() {
-			spaceClient, err := NewSpaceClient(SpaceName, url, Username, Password)
+			spaceClient, err := NewSpaceClient(SpaceName, url, Username, Password, *cfg)
 			Expect(err).To(BeNil())
 			Expect(spaceClient).ToNot(BeNil())