[FAB-2199] Modify peer to use common GRPC server

This is the initial commit to replace the peer
and eventhub GRPC servers with the common GRPC
server from the comm package.  This is just a
simple replace to ensure that things continue
to work.  This sets the stage for adding TLS
and other features.

Fixes FAB-2199

Change-Id: Icba1de1e984b2ef210ac2442a3b6c448e0764aa8
Signed-off-by: Gari Singh <gari.r.singh@gmail.com>

peer/node/start.go

@@ -44,7 +44,6 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
 )
 
@@ -114,36 +113,34 @@ func serve(args []string) error {
 		grpclog.Fatalf("Failed to listen: %v", err)
 	}
 
-	ehubLis, ehubGrpcServer, err := createEventHubServer()
-	if err != nil {
-		grpclog.Fatalf("Failed to create ehub server: %v", err)
-	}
-
 	logger.Infof("Security enabled status: %t", core.SecurityEnabled())
 
-	var opts []grpc.ServerOption
-	if comm.TLSEnabled() {
-		creds, err := credentials.NewServerTLSFromFile(viper.GetString("peer.tls.cert.file"),
-			viper.GetString("peer.tls.key.file"))
-
-		if err != nil {
-			grpclog.Fatalf("Failed to generate credentials %v", err)
-		}
-		opts = []grpc.ServerOption{grpc.Creds(creds)}
+	//Create GRPC server - return if an error occurs
+	secureConfig := comm.SecureServerConfig{
+		UseTLS: viper.GetBool("peer.tls.enabled"),
+	}
+	grpcServer, err := comm.NewGRPCServerFromListener(lis, secureConfig)
+	if err != nil {
+		fmt.Println("Failed to return new GRPC server: ", err)
+		return err
 	}
 
-	grpcServer := grpc.NewServer(opts...)
+	//TODO - do we need different SSL material for events ?
+	ehubGrpcServer, err := createEventHubServer(secureConfig)
+	if err != nil {
+		grpclog.Fatalf("Failed to create ehub server: %v", err)
+	}
 
-	registerChaincodeSupport(grpcServer)
+	registerChaincodeSupport(grpcServer.Server())
 
 	logger.Debugf("Running peer")
 
 	// Register the Admin server
-	pb.RegisterAdminServer(grpcServer, core.NewAdminServer())
+	pb.RegisterAdminServer(grpcServer.Server(), core.NewAdminServer())
 
 	// Register the Endorser server
 	serverEndorser := endorser.NewEndorserServer()
-	pb.RegisterEndorserServer(grpcServer, serverEndorser)
+	pb.RegisterEndorserServer(grpcServer.Server(), serverEndorser)
 
 	// Initialize gossip component
 	bootstrap := viper.GetStringSlice("peer.gossip.bootstrap")
@@ -153,7 +150,7 @@ func serve(args []string) error {
 		panic(fmt.Sprintf("Failed serializing self identity: %v", err))
 	}
 
-	service.InitGossipService(serializedIdentity, peerEndpoint.Address, grpcServer, bootstrap...)
+	service.InitGossipService(serializedIdentity, peerEndpoint.Address, grpcServer.Server(), bootstrap...)
 	defer service.GetGossipService().Stop()
 
 	//initialize the env for chainless startup
@@ -202,7 +199,7 @@ func serve(args []string) error {
 
 	go func() {
 		var grpcErr error
-		if grpcErr = grpcServer.Serve(lis); grpcErr != nil {
+		if grpcErr = grpcServer.Start(); grpcErr != nil {
 			grpcErr = fmt.Errorf("grpc server exited with error: %s", grpcErr)
 		} else {
 			logger.Info("grpc server exited")
@@ -215,8 +212,8 @@ func serve(args []string) error {
 	}
 
 	// Start the event hub server
-	if ehubGrpcServer != nil && ehubLis != nil {
-		go ehubGrpcServer.Serve(ehubLis)
+	if ehubGrpcServer != nil {
+		go ehubGrpcServer.Start()
 	}
 
 	// Start profiling http endpoint if enabled
@@ -263,35 +260,25 @@ func registerChaincodeSupport(grpcServer *grpc.Server) {
 	pb.RegisterChaincodeSupportServer(grpcServer, ccSrv)
 }
 
-func createEventHubServer() (net.Listener, *grpc.Server, error) {
+func createEventHubServer(secureConfig comm.SecureServerConfig) (comm.GRPCServer, error) {
 	var lis net.Listener
-	var grpcServer *grpc.Server
 	var err error
 	lis, err = net.Listen("tcp", viper.GetString("peer.events.address"))
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to listen: %v", err)
+		return nil, fmt.Errorf("failed to listen: %v", err)
 	}
 
-	//TODO - do we need different SSL material for events ?
-	var opts []grpc.ServerOption
-	if comm.TLSEnabled() {
-		creds, err := credentials.NewServerTLSFromFile(
-			viper.GetString("peer.tls.cert.file"),
-			viper.GetString("peer.tls.key.file"))
-
-		if err != nil {
-			return nil, nil, fmt.Errorf("Failed to generate credentials %v", err)
-		}
-		opts = []grpc.ServerOption{grpc.Creds(creds)}
+	grpcServer, err := comm.NewGRPCServerFromListener(lis, secureConfig)
+	if err != nil {
+		fmt.Println("Failed to return new GRPC server: ", err)
+		return nil, err
 	}
-
-	grpcServer = grpc.NewServer(opts...)
 	ehServer := producer.NewEventsServer(
 		uint(viper.GetInt("peer.events.buffersize")),
 		viper.GetInt("peer.events.timeout"))
 
-	pb.RegisterEventsServer(grpcServer, ehServer)
-	return lis, grpcServer, err
+	pb.RegisterEventsServer(grpcServer.Server(), ehServer)
+	return grpcServer, nil
 }
 
 func writePid(fileName string, pid int) error {