Release 0.5.1 (#354)

* Hotfix for grpc proxy

* Bump version to 0.5.1

Makefile

@@ -46,7 +46,7 @@
 ##
 # http://makefiletutorial.com/
 
-BASE_VERSION = 0.5.0-rc.2
+BASE_VERSION = 0.5.1
 VERSION_SUFFIX = $(shell git rev-parse --short=7 HEAD | tr -d [:punct:])
 BRANCH_NAME = $(shell git rev-parse --abbrev-ref HEAD | tr -d [:punct:])
 VERSION = $(BASE_VERSION)-$(VERSION_SUFFIX)
@@ -706,6 +706,13 @@ proxy-prometheus: build/toolchain/bin/kubectl$(EXE_EXTENSION)
 proxy-dashboard: build/toolchain/bin/kubectl$(EXE_EXTENSION)
 	$(KUBECTL) port-forward --namespace kube-system $(shell $(KUBECTL) get pod --namespace kube-system --selector="app=kubernetes-dashboard" --output jsonpath='{.items[0].metadata.name}') $(DASHBOARD_PORT):9090 $(PORT_FORWARD_ADDRESS_FLAG)
 
+update-deps:
+	$(GO) mod tidy
+	cd site && $(GO) mod tidy
+
+proxy-frontend: build/toolchain/bin/kubectl$(EXE_EXTENSION)
+	$(KUBECTL) port-forward --namespace $(OPEN_MATCH_KUBERNETES_NAMESPACE) $(shell $(KUBECTL) get pod --namespace $(OPEN_MATCH_KUBERNETES_NAMESPACE) --selector="app=open-match,component=frontend,release=$(OPEN_MATCH_CHART_NAME)" --output jsonpath='{.items[0].metadata.name}') 51504:51504 $(PORT_FORWARD_ADDRESS_FLAG) 
+
 sync-deps:
 	$(GO) mod download
 
@@ -725,4 +732,3 @@ endif
 endif
 
 .PHONY: docker gcloud deploy-redirect-site sync-deps sleep-10 proxy-dashboard proxy-prometheus proxy-grafana clean clean-toolchain clean-binaries clean-protos presubmit test test-in-ci vet
-

README.md

@@ -40,7 +40,7 @@ kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-ad
 kubectl create namespace open-match
 
 # Install the core Open Match and monitoring services.
-kubectl apply -f https://github.com/GoogleCloudPlatform/open-match/releases/download/0.5.0-rc.2/install.yaml --namespace open-match
+kubectl apply -f https://github.com/GoogleCloudPlatform/open-match/releases/download/0.5.1/install.yaml --namespace open-match
 ```
 
 ### Deploy demo components
@@ -48,17 +48,17 @@ kubectl apply -f https://github.com/GoogleCloudPlatform/open-match/releases/down
 Open Match framework requires the user to author a custom match function and an evaluator that are invoked to create matches. For demo purposes, we will use an example MMF and Evaluator. The following command deploys these in the kubernetes cluster:
 
 ```bash
-kubectl apply -f https://github.com/GoogleCloudPlatform/open-match/releases/download/0.5.0-rc.2/install-example.yaml --namespace open-match
+kubectl apply -f https://github.com/GoogleCloudPlatform/open-match/releases/download/0.5.1/install-example.yaml --namespace open-match
 ```
 
 This command also deploys a component that continuously generates players with different properties and adds them to Open Match state storage. This is because a populated player pool is required to generate matches.
 
 ### Generate Matches!
 
-The in a real setup, a game backend (Director / DGS etc.) will request Open Match for mathes. For demo purposes, this is simulated by a backend client that requests Open Match to continuously list matches till it runs out of players.
+In a real setup, a game backend (Director / DGS etc.) will request matches from Open Match. For demo purposes, this is simulated by a backend client that requests Open Match to continuously list matches until it runs out of players.
 
 ```bash
-kubectl run om-backendclient --rm --restart=Never --image-pull-policy=Always -i --tty --image=gcr.io/open-match-public-images/openmatch-backendclient:0.5.0-rc.2 --namespace=open-match
+kubectl run om-backendclient --rm --restart=Never --image-pull-policy=Always -i --tty --image=gcr.io/open-match-public-images/openmatch-backendclient:0.5.1 --namespace=open-match
 ```
 
 If successful, the backend client should successfully generate matches, displaying players populated in Rosters.

cloudbuild.yaml

@@ -189,7 +189,7 @@ images:
 - 'gcr.io/$PROJECT_ID/openmatch-clientloadgen:${_OM_VERSION}-${SHORT_SHA}'
 - 'gcr.io/$PROJECT_ID/openmatch-frontendclient:${_OM_VERSION}-${SHORT_SHA}'
 substitutions:
-    _OM_VERSION: "0.5.0-rc.2"
+    _OM_VERSION: "0.5.1"
     _GCB_POST_SUBMIT: "0"
 logsBucket: 'gs://open-match-build-logs/'
 options:

cmd/backendapi/Dockerfile

@@ -19,5 +19,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
 
 FROM gcr.io/distroless/static
 COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/cmd/backendapi/backendapi .
+# TODO: Use go-bindata to embed the json file
+COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/api/protobuf-spec/backend.swagger.json .
 
 ENTRYPOINT ["/backendapi"]

cmd/frontendapi/Dockerfile

@@ -19,5 +19,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
 
 FROM gcr.io/distroless/static
 COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/cmd/frontendapi/frontendapi .
+# TODO: Use go-bindata to embed the json file
+COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/api/protobuf-spec/frontend.swagger.json .
 
 ENTRYPOINT ["/frontendapi"]

cmd/mmlogicapi/Dockerfile

@@ -19,5 +19,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo .
 
 FROM gcr.io/distroless/static
 COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/cmd/mmlogicapi/mmlogicapi .
+# TODO: Use go-bindata to embed the json file
+COPY --from=builder /go/src/github.com/GoogleCloudPlatform/open-match/api/protobuf-spec/mmlogic.swagger.json .
 
 ENTRYPOINT ["/mmlogicapi"]

install/helm/open-match-example/Chart.yaml

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 apiVersion: v1
-appVersion: "0.5.0-rc.2"
-version: 0.5.0-rc.2
+appVersion: "0.5.1"
+version: 0.5.1
 name: open-match-example
 description: Flexible, extensible, and scalable video game matchmaking.
 keywords:

install/helm/open-match-example/values.yaml

@@ -39,7 +39,7 @@ openmatch:
     testprofile: /profiles
   image:
     registry: gcr.io/open-match-public-images
-    tag: 0.5.0-rc.2
+    tag: 0.5.1
     backendclient:
       name: openmatch-backendclient
       pullPolicy: Always

install/helm/open-match/Chart.yaml

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 apiVersion: v1
-appVersion: "0.5.0-rc.2"
-version: 0.5.0-rc.2
+appVersion: "0.5.1"
+version: 0.5.1
 name: open-match
 description: Flexible, extensible, and scalable video game matchmaking.
 keywords:

install/helm/open-match/templates/_helpers.tpl

@@ -74,3 +74,14 @@ prometheus.io/port: {{ .Values.openmatch.metrics.port | quote }}
 prometheus.io/path: {{ .Values.openmatch.metrics.path }}
 {{- end -}}
 {{- end -}}
+
+
+{{- define "probe.readiness" -}}
+readinessProbe:
+  httpGet:
+    path: /healthz
+    port: {{ .port }}
+  initialDelaySeconds: 5
+  periodSeconds: 5
+  failureThreshold: 3
+{{- end -}}

install/helm/open-match/templates/backendapi.yaml

@@ -73,6 +73,8 @@ spec:
           containerPort: {{ .Values.openmatch.backendapi.proxy.port }}
         - name: metrics
           containerPort: {{ .Values.openmatch.metrics.port }}
+        {{- $port := dict "port" .Values.openmatch.backendapi.proxy.port -}}
+        {{- include "probe.readiness" $port | nindent 8 }}
         resources:
           requests:
             memory: 100Mi

install/helm/open-match/templates/frontendapi.yaml

@@ -74,6 +74,8 @@ spec:
           containerPort: {{ .Values.openmatch.frontendapi.proxy.port }}
         - name: metrics
           containerPort: {{ .Values.openmatch.metrics.port }}
+        {{- $port := dict "port" .Values.openmatch.frontendapi.proxy.port -}}
+        {{- include "probe.readiness" $port | nindent 8 }}
         resources:
           requests:
             memory: 100Mi

install/helm/open-match/templates/mmlogicapi.yaml

@@ -74,6 +74,8 @@ spec:
           containerPort: {{ .Values.openmatch.mmlogicapi.proxy.port }}
         - name: metrics
           containerPort: {{ .Values.openmatch.metrics.port }}
+        {{- $port := dict "port" .Values.openmatch.mmlogicapi.proxy.port -}}
+        {{- include "probe.readiness" $port | nindent 8 }}
         resources:
           requests:
             memory: 100Mi

install/helm/open-match/values.yaml

@@ -47,7 +47,7 @@ openmatch:
         # You can refer to other chart values using the Helm templates syntax here.
   image:
     registry: gcr.io/open-match-public-images
-    tag: 0.5.0-rc.2
+    tag: 0.5.1
     backendapi:
       name: openmatch-backendapi
       pullPolicy: Always

internal/app/backendapi/apisrv/apisrv.go

@@ -72,7 +72,7 @@ func Bind(omSrv *serving.OpenMatchServer) {
 	omSrv.GrpcServer.AddService(func(server *grpc.Server) {
 		pb.RegisterBackendServer(server, handler)
 	})
-	omSrv.GrpcServer.AddProxy(pb.RegisterBackendHandlerFromEndpoint)
+	omSrv.GrpcServer.AddProxy(pb.RegisterBackendHandler)
 }
 
 // CreateMatch is this service's implementation of the CreateMatch gRPC method

internal/app/frontendapi/apisrv/apisrv.go

@@ -60,7 +60,7 @@ func Bind(omSrv *serving.OpenMatchServer) {
 	omSrv.GrpcServer.AddService(func(server *grpc.Server) {
 		pb.RegisterFrontendServer(server, handler)
 	})
-	omSrv.GrpcServer.AddProxy(pb.RegisterFrontendHandlerFromEndpoint)
+	omSrv.GrpcServer.AddProxy(pb.RegisterFrontendHandler)
 }
 
 // CreatePlayer is this service's implementation of the CreatePlayer gRPC method defined in frontend.proto

internal/app/mmlogicapi/apisrv/apisrv.go

@@ -64,7 +64,7 @@ func Bind(omSrv *serving.OpenMatchServer) {
 	omSrv.GrpcServer.AddService(func(server *grpc.Server) {
 		pb.RegisterMmLogicServer(server, handler)
 	})
-	omSrv.GrpcServer.AddProxy(pb.RegisterMmLogicHandlerFromEndpoint)
+	omSrv.GrpcServer.AddProxy(pb.RegisterMmLogicHandler)
 }
 
 // GetProfile is this service's implementation of the gRPC call defined in

internal/harness/matchfunction/golang/harness.go

@@ -71,7 +71,7 @@ func ServeMatchFunction(params *HarnessParams) {
 	grpcServer.AddService(func(server *grpc.Server) {
 		pb.RegisterMatchFunctionServer(server, mfServer)
 	})
-	grpcServer.AddProxy(pb.RegisterMatchFunctionHandlerFromEndpoint)
+	grpcServer.AddProxy(pb.RegisterMatchFunctionHandler)
 
 	defer func() {
 		err := grpcServer.Stop()

internal/serving/grpcserver.go

@@ -1,28 +1,36 @@
 package serving
 
 import (
+	"fmt"
 	"net"
 	"net/http"
+	"path"
+	"strings"
+	"sync"
 
 	"github.com/GoogleCloudPlatform/open-match/internal/util/netlistener"
+	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 	"go.opencensus.io/plugin/ocgrpc"
+	"go.opencensus.io/zpages"
 
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
 )
 
 // GrpcWrapper is a decoration around the standard GRPC server that sets up a bunch of things common to Open Match servers.
 type GrpcWrapper struct {
 	serviceLh, proxyLh        *netlistener.ListenerHolder
 	serviceHandlerFuncs       []func(*grpc.Server)
-	proxyHandlerFunc          func(proxyEndpoint string) (*runtime.ServeMux, error)
+	proxyHandlerFuncs         []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) error
 	server                    *grpc.Server
 	proxy                     *http.Server
 	serviceLn, proxyLn        net.Listener
 	logger                    *log.Entry
 	grpcAwaiter, proxyAwaiter chan error
+	grpcClient                *grpc.ClientConn
 }
 
 // NewGrpcServer creates a new GrpcWrapper.
@@ -32,6 +40,7 @@ func NewGrpcServer(serviceLh, proxyLh *netlistener.ListenerHolder, logger *log.E
 		proxyLh:             proxyLh,
 		logger:              logger,
 		serviceHandlerFuncs: []func(*grpc.Server){},
+		proxyHandlerFuncs:   []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) error{},
 	}
 }
 
@@ -40,92 +49,23 @@ func (gw *GrpcWrapper) AddService(handlerFunc func(*grpc.Server)) {
 	gw.serviceHandlerFuncs = append(gw.serviceHandlerFuncs, handlerFunc)
 }
 
-func (gw *GrpcWrapper) AddProxy(proxyHandlerFunc func(context.Context, *runtime.ServeMux, string, []grpc.DialOption) error) {
-	gw.proxyHandlerFunc = func(endpoint string) (*runtime.ServeMux, error) {
-		ctx := context.Background()
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
-
-		mux := runtime.NewServeMux()
-		return mux, proxyHandlerFunc(ctx, mux, endpoint, []grpc.DialOption{grpc.WithInsecure()})
-	}
+// AddProxy registers a reverse proxy from REST to gRPC when server is created.
+func (gw *GrpcWrapper) AddProxy(handlerFunc func(context.Context, *runtime.ServeMux, *grpc.ClientConn) error) {
+	gw.proxyHandlerFuncs = append(gw.proxyHandlerFuncs, handlerFunc)
 }
 
 // Start begins the gRPC server.
 func (gw *GrpcWrapper) Start() error {
-	// Starting gRPC server
-	if gw.serviceLn != nil {
-		return nil
-	}
-
-	serviceLn, err := gw.serviceLh.Obtain()
-	if err != nil {
-		gw.logger.WithFields(log.Fields{
-			"error":       err.Error(),
-			"servicePort": gw.serviceLh.Number(),
-		}).Error("net.Listen() error")
-		return err
-	}
-	gw.serviceLn = serviceLn
-
-	gw.logger.WithFields(log.Fields{"servicePort": gw.serviceLh.Number()}).Info("TCP net listener initialized")
-
-	server := grpc.NewServer(grpc.StatsHandler(&ocgrpc.ServerHandler{}))
-	for _, handlerFunc := range gw.serviceHandlerFuncs {
-		handlerFunc(server)
-	}
-	gw.server = server
-	gw.grpcAwaiter = make(chan error)
-
-	go func() {
-		gw.logger.Infof("Serving gRPC on :%d", gw.serviceLh.Number())
-		err := gw.server.Serve(serviceLn)
-		gw.grpcAwaiter <- err
-		if err != nil {
-			gw.logger.WithFields(log.Fields{"error": err.Error()}).Error("gRPC serve() error")
-		}
-	}()
-
-	// Starting proxy server
-	if gw.proxyLn != nil {
-		return nil
-	}
-
-	proxyLn, err := gw.proxyLh.Obtain()
-
-	if err != nil {
-		gw.logger.WithFields(log.Fields{
-			"error":     err.Error(),
-			"proxyPort": gw.proxyLh.Number(),
-		}).Error("net.Listen() error")
-		return err
-	}
-	gw.proxyLn = proxyLn
-
-	gw.logger.WithFields(log.Fields{"proxyPort": gw.proxyLh.Number()}).Info("TCP net listener initialized")
-
-	proxyEndpoint := gw.proxyLn.Addr().String()
-	mux, err := gw.proxyHandlerFunc(proxyEndpoint)
-	gw.proxy = &http.Server{Addr: proxyEndpoint, Handler: mux}
-	gw.proxyAwaiter = make(chan error)
-
-	if err != nil {
-		gw.logger.WithFields(log.Fields{
-			"error":     err.Error(),
-			"proxyPort": gw.proxyLh.Number(),
-		}).Error("RegisterHandlerFromEndpoint() error")
+	var wg sync.WaitGroup
+	if err := gw.startGrpcServer(&wg); err != nil {
 		return err
 	}
 
-	go func() {
-		gw.logger.Infof("Serving proxy on :%d", gw.proxyLh.Number())
-		err := gw.proxy.ListenAndServe()
-		gw.proxyAwaiter <- err
-		if err != nil {
-			gw.logger.WithFields(log.Fields{"error": err.Error()}).Error("proxy ListenAndServe() error")
-		}
-	}()
+	if err := gw.startHTTPProxy(&wg); err != nil {
+		return err
+	}
 
+	wg.Wait()
 	return nil
 }
 
@@ -153,11 +93,26 @@ func (gw *GrpcWrapper) Stop() error {
 		return nil
 	}
 	gw.server.GracefulStop()
-	gw.proxy.Shutdown(context.Background())
 
-	portErr := gw.serviceLn.Close()
-	_ = gw.proxyLn.Close()
+	if gw.proxy == nil {
+		return nil
+	}
 
+	err := gw.proxy.Shutdown(context.Background())
+	if err != nil {
+		return err
+	}
+
+	err = gw.serviceLn.Close()
+	if err != nil {
+		return err
+	}
+	err = gw.proxyLn.Close()
+	if err != nil {
+		return err
+	}
+
+	grpcClientErr := gw.grpcClient.Close()
 	grpcErr, proxyErr := gw.WaitForTermination()
 
 	gw.server = nil
@@ -165,11 +120,150 @@ func (gw *GrpcWrapper) Stop() error {
 	gw.proxy = nil
 	gw.proxyLn = nil
 
+	if grpcClientErr != nil {
+		return grpcClientErr
+	}
 	if grpcErr != nil {
 		return grpcErr
 	}
 	if proxyErr != nil {
 		return proxyErr
 	}
-	return portErr
+	return nil
+}
+
+func (gw *GrpcWrapper) startHTTPProxy(wg *sync.WaitGroup) error {
+	// Starting proxy server
+	if gw.proxyLn != nil {
+		return nil
+	}
+
+	wg.Add(1)
+
+	proxyLn, err := gw.proxyLh.Obtain()
+
+	if err != nil {
+		gw.logger.WithFields(log.Fields{
+			"error":     err.Error(),
+			"proxyPort": gw.proxyLh.Number(),
+		}).Error("net.Listen() error")
+		return err
+	}
+	gw.proxyLn = proxyLn
+
+	gw.logger.WithFields(log.Fields{"proxyPort": gw.proxyLh.Number()}).Info("TCP net listener initialized")
+
+	ctx := context.Background()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	proxyMux := runtime.NewServeMux()
+
+	serviceEndpoint := fmt.Sprintf("localhost:%d", gw.serviceLh.Number())
+	gw.grpcClient, err = grpc.DialContext(ctx, serviceEndpoint, grpc.WithInsecure(), grpc.WithBlock())
+	if err != nil {
+		gw.logger.WithFields(log.Fields{
+			"error":           err.Error(),
+			"serviceEndpoint": serviceEndpoint,
+		}).Error("grpc Dialing error")
+		return err
+	}
+
+	for _, handlerFunc := range gw.proxyHandlerFuncs {
+		if err := handlerFunc(ctx, proxyMux, gw.grpcClient); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+
+	httpMux := http.NewServeMux()
+	httpMux.HandleFunc("/healthz", healthzServer(gw.grpcClient))
+	httpMux.HandleFunc("/swagger/", swaggerServer("."))
+	httpMux.Handle("/", proxyMux)
+	zpages.Handle(httpMux, "/debug")
+
+	gw.proxy = &http.Server{Handler: httpMux}
+	gw.proxyAwaiter = make(chan error)
+
+	go func() {
+		wg.Done()
+		gw.logger.Infof("Serving proxy on :%d", gw.proxyLh.Number())
+		err := gw.proxy.Serve(proxyLn)
+		gw.proxyAwaiter <- err
+		if err != nil {
+			gw.logger.WithFields(log.Fields{
+				"error":           err.Error(),
+				"serviceEndpoint": serviceEndpoint,
+				"proxyPort":       gw.proxyLh.Number(),
+			}).Error("proxy ListenAndServe() error")
+		}
+	}()
+
+	return nil
+}
+
+func (gw *GrpcWrapper) startGrpcServer(wg *sync.WaitGroup) error {
+	// Starting gRPC server
+	if gw.serviceLn != nil {
+		return nil
+	}
+
+	wg.Add(1)
+	serviceLn, err := gw.serviceLh.Obtain()
+	if err != nil {
+		gw.logger.WithFields(log.Fields{
+			"error":       err.Error(),
+			"servicePort": gw.serviceLh.Number(),
+		}).Error("net.Listen() error")
+		return err
+	}
+	gw.serviceLn = serviceLn
+
+	gw.logger.WithFields(log.Fields{
+		"servicePort": gw.serviceLh.Number(),
+	}).Info("TCP net listener initialized")
+
+	server := grpc.NewServer(grpc.StatsHandler(&ocgrpc.ServerHandler{}))
+	for _, handlerFunc := range gw.serviceHandlerFuncs {
+		handlerFunc(server)
+	}
+	gw.server = server
+	gw.grpcAwaiter = make(chan error)
+
+	go func() {
+		wg.Done()
+		gw.logger.Infof("Serving gRPC on :%d", gw.serviceLh.Number())
+		err := gw.server.Serve(serviceLn)
+		gw.grpcAwaiter <- err
+		if err != nil {
+			gw.logger.WithFields(log.Fields{"error": err.Error()}).Error("gRPC serve() error")
+		}
+	}()
+
+	return nil
+}
+
+// healthzServer returns a simple health handler which returns ok.
+func healthzServer(conn *grpc.ClientConn) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		if s := conn.GetState(); s != connectivity.Ready {
+			http.Error(w, fmt.Sprintf("Service Unavailable: ClientConn is %s", s), http.StatusServiceUnavailable)
+			return
+		}
+		fmt.Fprintln(w, "ok")
+	}
+}
+
+// swaggerServer returns a file serving handler for .swagger.json files
+func swaggerServer(dir string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasSuffix(r.URL.Path, ".swagger.json") {
+			http.NotFound(w, r)
+			return
+		}
+
+		p := strings.TrimPrefix(r.URL.Path, "/swagger/")
+		p = path.Join(dir, p)
+		http.ServeFile(w, r, p)
+	}
 }

internal/serving/testing/fake_frontendapi.go

@@ -7,6 +7,7 @@ import (
 	"github.com/GoogleCloudPlatform/open-match/internal/pb"
 )
 
+// FakeFrontend with empty method impl used for testing
 type FakeFrontend struct {
 }
 

internal/serving/testing/minimatch.go

@@ -2,6 +2,7 @@ package testing
 
 import (
 	"fmt"
+	"net/http"
 	"time"
 
 	"github.com/GoogleCloudPlatform/open-match/config"
@@ -36,6 +37,17 @@ func (mm *MiniMatchServer) GetFrontendClient() (pb.FrontendClient, error) {
 	return pb.NewFrontendClient(conn), nil
 }
 
+// GetFrontendProxyClient gets the REST proxy of the frontend client
+func (mm *MiniMatchServer) GetFrontendProxyClient() (*http.Client, string) {
+	httpClient := &http.Client{
+		Timeout: time.Second * 3,
+	}
+
+	baseURL := fmt.Sprintf("http://localhost:%d", mm.Config.GetInt("api.frontend.proxyport"))
+
+	return httpClient, baseURL
+}
+
 // GetBackendClient gets the backend client.
 func (mm *MiniMatchServer) GetBackendClient() (pb.BackendClient, error) {
 	port := mm.Config.GetInt("api.backend.port")
@@ -46,6 +58,17 @@ func (mm *MiniMatchServer) GetBackendClient() (pb.BackendClient, error) {
 	return pb.NewBackendClient(conn), nil
 }
 
+// GetBackendProxyClient gets the REST proxy of the backend client
+func (mm *MiniMatchServer) GetBackendProxyClient() (*http.Client, string) {
+	httpClient := &http.Client{
+		Timeout: time.Second * 3,
+	}
+
+	baseURL := fmt.Sprintf("http://localhost:%d", mm.Config.GetInt("api.backend.proxyport"))
+
+	return httpClient, baseURL
+}
+
 // Stop shuts down Mini Match
 func (mm *MiniMatchServer) Stop() {
 	mm.OpenMatchServer.Stop()

internal/serving/testing/minimatch_test.go

@@ -2,6 +2,10 @@ package testing
 
 import (
 	"context"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
 	goTesting "testing"
 
 	pb "github.com/GoogleCloudPlatform/open-match/internal/pb"
@@ -25,12 +29,11 @@ func TestNewMiniMatch(t *goTesting.T) {
 					omServer.GrpcServer.AddService(func(server *grpc.Server) {
 						pb.RegisterFrontendServer(server, ff)
 					})
-					omServer.GrpcServer.AddProxy(pb.RegisterFrontendHandlerFromEndpoint)
+					omServer.GrpcServer.AddProxy(pb.RegisterFrontendHandler)
 				},
 			},
 		},
 	})
-	defer closer()
 	if err != nil {
 		t.Errorf("could not create Mini Match context %s", err)
 	}
@@ -38,16 +41,79 @@ func TestNewMiniMatch(t *goTesting.T) {
 	if err != nil {
 		t.Errorf("could not start Mini Match %s", err)
 	}
-	defer mm.Stop()
+
 	feClient, err := mm.GetFrontendClient()
+	t.Run("FrontendClient Test", func(t *goTesting.T) {
+		if err != nil {
+			t.Errorf("could not get frontend client %s", err)
+		}
+		result, err := feClient.CreatePlayer(context.Background(), &pb.CreatePlayerRequest{})
+		if err != nil {
+			t.Errorf("could not start Mini Match %s", err)
+		}
+		if result == nil {
+			t.Errorf("insert player was not successful %v", result)
+		}
+	})
+
+	proxyTests := []struct {
+		method   string
+		endpoint string
+		response string
+	}{
+		// Health check fails when running test cases in parallel
+		{
+			method:   "GET",
+			endpoint: "healthz",
+			response: "ok\n",
+		},
+		{
+			method:   "GET",
+			endpoint: "nowhere",
+			response: "Not Found\n",
+		},
+	}
+
+	feProxyClient, feBaseURL := mm.GetFrontendProxyClient()
+	for _, tt := range proxyTests {
+		endpoint := fmt.Sprintf(feBaseURL+"/%s", tt.endpoint)
+		t.Run(fmt.Sprintf("ProxyTest-%s-%s", tt.method, endpoint), func(t *goTesting.T) {
+			req, err := http.NewRequest(tt.method, endpoint, nil)
+			if err != nil {
+				t.Errorf("Failed to create new request %v", req)
+			}
+
+			resp, err := feProxyClient.Do(req)
+			if err != nil {
+				t.Errorf("Failed to ping the proxy server %s", err)
+			}
+			defer resp.Body.Close()
+
+			body, err := ioutil.ReadAll(resp.Body)
+			if err != nil {
+				t.Errorf("Failed to read response body %s", err)
+			}
+
+			if string(body) != tt.response {
+				t.Errorf("Response incorrect, got: %s, expect: %s.", body, tt.response)
+			}
+		})
+
+	}
+	closer()
+
+	// Re-open the port to ensure it's free.
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", mm.Config.GetInt("api.frontend.port")))
 	if err != nil {
-		t.Errorf("could not get frontend client %s", err)
+		t.Errorf("grpc server is still running! Result= %v Error= %s", ln, err)
 	}
 	result, err := feClient.CreatePlayer(context.Background(), &pb.CreatePlayerRequest{})
-	if err != nil {
-		t.Errorf("could not start Mini Match %s", err)
+	if err == nil {
+		t.Errorf("grpc server is still running! Result= %v Error= %s", result, err)
 	}
-	if result == nil {
-		t.Errorf("insert player was not successful %v", result)
+	// Re-open the proxyPort to ensure it's free.
+	ln, err = net.Listen("tcp", fmt.Sprintf(":%d", mm.Config.GetInt("api.frontend.proxyport")))
+	if err != nil {
+		t.Errorf("grpc proxy is still running! Result= %v Error= %s", ln, err)
 	}
 }

internal/statestorage/redis/redishelpers.go

@@ -60,24 +60,16 @@ func ConnectionPool(cfg config.View) (*redis.Pool, error) {
 		MaxIdle:     cfg.GetInt("redis.pool.maxIdle"),
 		MaxActive:   cfg.GetInt("redis.pool.maxActive"),
 		IdleTimeout: cfg.GetDuration("redis.pool.idleTimeout") * time.Second,
-		Dial:        func() (redis.Conn, error) { return redis.DialURL(redisURL) },
+		Dial: func() (redis.Conn, error) {
+			return redis.DialURL(
+				redisURL,
+				redis.DialConnectTimeout(5*time.Second),
+				redis.DialReadTimeout(3*time.Second),
+			)
+		},
 	}
 
-	// Sanity check that connection works before passing it back.  Redigo
-	// always returns a valid connection, and will just fail on the first
-	// query: https://godoc.org/github.com/gomodule/redigo/redis#Pool.Get
-	redisConn := pool.Get()
-	defer redisConn.Close()
-	_, err := redisConn.Do("SELECT", "0")
-	// Encountered an issue getting a connection from the pool.
-	if err != nil {
-		rhLog.WithFields(log.Fields{
-			"error": err.Error(),
-			"query": "SELECT 0"}).Error("state storage connection error")
-		return nil, fmt.Errorf("cannot connect to Redis at %s, %s", maskedURL, err)
-	}
-
-	rhLog.Info("Connected to Redis")
+	rhLog.Info("Created Redis Client Pool")
 	return pool, nil
 }
 

site/config.toml

@@ -72,8 +72,8 @@ github_repo = "https://github.com/GoogleCloudPlatform/open-match"
 # Google Custom Search Engine ID. Remove or comment out to disable search.
 gcs_engine_id = "008748710159674449076:sqoelpnrdoe"
 
-release_branch = "release-0.5.0-rc.2"
-release_version = "0.5.0-rc.2"
+release_branch = "release-0.5.1"
+release_version = "0.5.1"
 
 # User interface configuration
 [params.ui]

test/e2e/grpcserver_test.go

@@ -41,7 +41,7 @@ func TestOpenClose(t *testing.T) {
 	server.AddService(func(server *grpc.Server) {
 		pb.RegisterFrontendServer(server, fakeService)
 	})
-	server.AddProxy(pb.RegisterFrontendHandlerFromEndpoint)
+	server.AddProxy(pb.RegisterFrontendHandler)
 
 	err := server.Start()
 	if err != nil {