cache impl for both types of room address

Gopkg.toml

@@ -81,6 +81,6 @@
   name = "github.com/spf13/viper"
   version = "v1.1.0"
 
-[[constraint]]
+[[override]]
   name = "github.com/topfreegames/go-extensions-k8s-client-go"
-  version = "v2.0.4"
+  version = "kubernetes-1.11.7"

api/app.go

@@ -446,6 +446,9 @@ func (a *App) loadConfigurationDefaults() {
 	a.Config.SetDefault("api.limitManager.keyTimeout", 1*time.Minute)
 	a.Config.SetDefault("jaeger.disabled", false)
 	a.Config.SetDefault("jaeger.samplingProbability", 1.0)
+	a.Config.SetDefault("addrGetter.cache.use", true)
+	a.Config.SetDefault("addrGetter.cache.expirationInterval", "10m")
+	a.Config.SetDefault("addrGetter.cache.cleanupInterval", "30s")
 	a.Config.SetDefault(EnvironmentConfig, ProdEnvironment)
 }
 
@@ -568,11 +571,21 @@ func (a *App) configureServer(showProfile bool) {
 }
 
 func (a *App) configureEnvironment() {
-	a.RoomAddrGetter = models.NewRoomAddressesFromHostPort(a.Config.GetString(Ipv6KubernetesLabelKey))
+	a.RoomAddrGetter = models.NewRoomAddressesFromHostPort(
+		a.Config.GetString(Ipv6KubernetesLabelKey),
+		a.Config.GetBool("addrGetter.cache.use"),
+		a.Config.GetDuration("addrGetter.cache.expirationInterval"),
+		a.Config.GetDuration("addrGetter.cache.cleanupInterval"),
+	)
 	a.RoomManager = &models.GameRoom{}
 
 	if a.Config.GetString(EnvironmentConfig) == DevEnvironment {
-		a.RoomAddrGetter = models.NewRoomAddressesFromNodePort(a.Config.GetString(Ipv6KubernetesLabelKey))
+		a.RoomAddrGetter = models.NewRoomAddressesFromNodePort(
+			a.Config.GetString(Ipv6KubernetesLabelKey),
+			a.Config.GetBool("addrGetter.cache.use"),
+			a.Config.GetDuration("addrGetter.cache.expirationInterval"),
+			a.Config.GetDuration("addrGetter.cache.cleanupInterval"),
+		)
 		a.RoomManager = &models.GameRoomWithService{}
 		a.Logger.Info("development environment")
 		return

api/room_handler.go

@@ -291,7 +291,7 @@ func (g *RoomStatusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	_, err = eventforwarder.ForwardRoomEvent(
-		r.Context(),
+		ctx,
 		g.App.Forwarders,
 		g.App.DBClient.WithContext(ctx),
 		kubernetesClient,

config/local.yaml

@@ -73,3 +73,8 @@ api:
   limitManager:
     keyTimeout: 1h
 ipv6KubernetesLabelKey: "local.io/ipv6"
+addrGetter:
+  cache:
+    use: true
+    expirationInterval: 10m
+    cleanupInterval: 30s

controller/controller.go

@@ -25,7 +25,7 @@ import (
 	"github.com/topfreegames/maestro/reporters"
 	reportersConstants "github.com/topfreegames/maestro/reporters/constants"
 	yaml "gopkg.in/yaml.v2"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/sirupsen/logrus"

eventforwarder/eventforwarder_suite_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/topfreegames/maestro/eventforwarder"
 	"github.com/topfreegames/maestro/models"
 	"github.com/topfreegames/maestro/reporters"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/kubernetes/fake"
 
 	"testing"
@@ -114,5 +114,5 @@ var _ = BeforeEach(func() {
 	_, err = clientset.CoreV1().Nodes().Create(node)
 
 	room = models.NewRoom(roomName, schedulerName)
-	roomAddrGetter = models.NewRoomAddressesFromHostPort(ipv6KubernetesLabelKey)
+	roomAddrGetter = models.NewRoomAddressesFromHostPort(ipv6KubernetesLabelKey, false, 0, 0)
 })

eventforwarder/forward_test.go

@@ -155,7 +155,7 @@ var _ = Describe("Forward", func() {
 		It("should report fail if event forward fails", func() {
 			errMsg := "event forward failed"
 			ctx := context.Background()
-			noIpv6roomAddrGetter := models.NewRoomAddressesFromHostPort("")
+			noIpv6roomAddrGetter := models.NewRoomAddressesFromHostPort("", false, 0, 0)
 			mockEventForwarder.EXPECT().Forward(
 				ctx,
 				models.StatusReady,

models/room_address.go

@@ -9,47 +9,101 @@ package models
 
 import (
 	"errors"
+	"fmt"
+	"time"
 
 	"github.com/btcsuite/btcutil/base58"
-
+	"github.com/pmylund/go-cache"
 	maestroErrors "github.com/topfreegames/maestro/errors"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 )
 
 // RoomAddressesFromHostPort is the struct that defines room addresses in production (using node HostPort)
 type RoomAddressesFromHostPort struct {
+	cache                  *cache.Cache
 	ipv6KubernetesLabelKey string
 }
 
 // NewRoomAddressesFromHostPort is the RoomAddressesFromHostPort constructor
-func NewRoomAddressesFromHostPort(ipv6KubernetesLabelKey string) *RoomAddressesFromHostPort {
+func NewRoomAddressesFromHostPort(
+	ipv6KubernetesLabelKey string,
+	useCache bool,
+	cacheExpirationInterval, cacheCleanupInterval time.Duration,
+) *RoomAddressesFromHostPort {
+	var c *cache.Cache
+	if useCache {
+		c = cache.New(cacheExpirationInterval, cacheCleanupInterval)
+	}
 	return &RoomAddressesFromHostPort{
 		ipv6KubernetesLabelKey: ipv6KubernetesLabelKey,
+		cache:                  c,
 	}
 }
 
 // Get gets room public addresses
 func (r *RoomAddressesFromHostPort) Get(room *Room, kubernetesClient kubernetes.Interface) (*RoomAddresses, error) {
-	return getRoomAddresses(false, r.ipv6KubernetesLabelKey, room, kubernetesClient)
+	if r.cache != nil {
+		if cached, found := r.cache.Get(r.buildCacheKey(room)); found {
+			return cached.(*RoomAddresses), nil
+		}
+	}
+	addrs, err := getRoomAddresses(false, r.ipv6KubernetesLabelKey, room, kubernetesClient)
+	if err != nil {
+		return nil, err
+	}
+	if r.cache != nil {
+		r.cache.Set(r.buildCacheKey(room), addrs, 0)
+	}
+	return addrs, nil
+}
+
+func (r *RoomAddressesFromHostPort) buildCacheKey(room *Room) string {
+	return fmt.Sprintf("%s-%s", room.SchedulerName, room.ID)
 }
 
 // RoomAddressesFromNodePort is the struct that defines room addresses in development (using NodePort service)
 type RoomAddressesFromNodePort struct {
+	cache                  *cache.Cache
 	ipv6KubernetesLabelKey string
 }
 
 // NewRoomAddressesFromNodePort is the RoomAddressesFromNodePort constructor
-func NewRoomAddressesFromNodePort(ipv6KubernetesLabelKey string) *RoomAddressesFromNodePort {
+func NewRoomAddressesFromNodePort(
+	ipv6KubernetesLabelKey string,
+	useCache bool,
+	cacheExpirationInterval, cacheCleanupInterval time.Duration,
+) *RoomAddressesFromNodePort {
+	var c *cache.Cache
+	if useCache {
+		c = cache.New(cacheExpirationInterval, cacheCleanupInterval)
+	}
 	return &RoomAddressesFromNodePort{
 		ipv6KubernetesLabelKey: ipv6KubernetesLabelKey,
+		cache:                  c,
 	}
 }
 
 // Get gets room public addresses
 func (r *RoomAddressesFromNodePort) Get(room *Room, kubernetesClient kubernetes.Interface) (*RoomAddresses, error) {
-	return getRoomAddresses(true, r.ipv6KubernetesLabelKey, room, kubernetesClient)
+	if r.cache != nil {
+		if cached, found := r.cache.Get(r.buildCacheKey(room)); found {
+			return cached.(*RoomAddresses), nil
+		}
+	}
+	addrs, err := getRoomAddresses(true, r.ipv6KubernetesLabelKey, room, kubernetesClient)
+	if err != nil {
+		return nil, err
+	}
+	if r.cache != nil {
+		r.cache.Set(r.buildCacheKey(room), addrs, 0)
+	}
+	return addrs, nil
+}
+
+func (r *RoomAddressesFromNodePort) buildCacheKey(room *Room) string {
+	return fmt.Sprintf("%s-%s", room.SchedulerName, room.ID)
 }
 
 func getRoomAddresses(IsNodePort bool, ipv6KubernetesLabelKey string, room *Room, kubernetesClient kubernetes.Interface) (*RoomAddresses, error) {