Simplify grpc client a bit. (#80)

cmd/grpc.go

@@ -5,7 +5,6 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"errors"
-	"io"
 	"time"
 
 	v1 "github.com/metal-stack/metal-api/pkg/api/v1"
@@ -17,9 +16,8 @@ import (
 )
 
 type GrpcClient struct {
-	addr     string
-	dialOpts []grpc.DialOption
-	log      *zap.SugaredLogger
+	log  *zap.SugaredLogger
+	conn grpc.ClientConnInterface
 }
 
 // NewGrpcClient fetches the address and certificates from metal-core needed to communicate with metal-api via grpc,
@@ -53,49 +51,35 @@ func NewGrpcClient(log *zap.SugaredLogger, certsClient certs.ClientService) (*Gr
 		Certificates: []tls.Certificate{clientCert},
 		MinVersion:   tls.VersionTLS12,
 	}
-	return &GrpcClient{
-		addr: resp.Payload.Address,
-		log:  log,
-		dialOpts: []grpc.DialOption{
-			grpc.WithKeepaliveParams(kacp),
-			grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
-			grpc.WithBlock(),
-		},
-	}, nil
-}
-
-func (c *GrpcClient) NewEventClient() (v1.EventServiceClient, io.Closer, error) {
-	conn, err := c.newConnection()
-	if err != nil {
-		return nil, nil, err
-	}
-	return v1.NewEventServiceClient(conn), conn, nil
-}
 
-func (c *GrpcClient) NewWaitClient() (v1.WaitClient, io.Closer, error) {
-	conn, err := c.newConnection()
-	if err != nil {
-		return nil, nil, err
+	grpcOpts := []grpc.DialOption{
+		grpc.WithKeepaliveParams(kacp),
+		grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
+		grpc.WithBlock(),
 	}
-	return v1.NewWaitClient(conn), conn, nil
-}
 
-func (c *GrpcClient) newSuperUserPasswordClient() (v1.SuperUserPasswordClient, io.Closer, error) {
-	conn, err := c.newConnection()
-	if err != nil {
-		return nil, nil, err
-	}
-	return v1.NewSuperUserPasswordClient(conn), conn, nil
-}
-
-func (c *GrpcClient) newConnection() (*grpc.ClientConn, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
 
-	conn, err := grpc.DialContext(ctx, c.addr, c.dialOpts...)
+	conn, err := grpc.DialContext(ctx, resp.Payload.Address, grpcOpts...)
 	if err != nil {
 		return nil, err
 	}
 
-	return conn, err
+	return &GrpcClient{
+		log:  log,
+		conn: conn,
+	}, nil
+}
+
+func (c *GrpcClient) Event() v1.EventServiceClient {
+	return v1.NewEventServiceClient(c.conn)
+}
+
+func (c *GrpcClient) Wait() v1.WaitClient {
+	return v1.NewWaitClient(c.conn)
+}
+
+func (c *GrpcClient) SuperUserPassword() v1.SuperUserPasswordClient {
+	return v1.NewSuperUserPasswordClient(c.conn)
 }

cmd/root.go

@@ -53,14 +53,8 @@ func Run(log *zap.SugaredLogger, spec *Specification, hal hal.InBand) (*event.Ev
 		log.Errorw("failed to fetch GRPC certificates", "error", err)
 		return nil, err
 	}
-	eventClient, eventCloser, err := grpcClient.NewEventClient()
-	if err != nil {
-		log.Errorw("failed to create event client", "error", err)
-		return nil, err
-	}
-	defer eventCloser.Close()
 
-	eventEmitter := event.NewEventEmitter(log, eventClient, spec.MachineUUID)
+	eventEmitter := event.NewEventEmitter(log, grpcClient.Event(), spec.MachineUUID)
 
 	eventEmitter.Emit(event.ProvisioningEventPreparing, fmt.Sprintf("starting metal-hammer version:%q", v.V))
 

cmd/supwd.go

@@ -10,14 +10,8 @@ import (
 
 // createBmcSuperuser creates the bmc super user.
 func (h *Hammer) createBmcSuperuser() error {
-	client, closer, err := h.GrpcClient.newSuperUserPasswordClient()
-	if err != nil {
-		return err
-	}
-	defer closer.Close()
-
 	req := &v1.SuperUserPasswordRequest{}
-	resp, err := client.FetchSuperUserPassword(context.Background(), req)
+	resp, err := h.GrpcClient.SuperUserPassword().FetchSuperUserPassword(context.Background(), req)
 	if err != nil {
 		return fmt.Errorf("failed to fetch SuperUser password %w", err)
 	}

cmd/wait.go

@@ -13,19 +13,13 @@ import (
 const defaultWaitTimeOut = 2 * time.Second
 
 func (c *GrpcClient) WaitForAllocation(e *event.EventEmitter, machineID string) error {
-	client, closer, err := c.NewWaitClient()
-	if err != nil {
-		return err
-	}
-	defer closer.Close()
-
 	e.Emit(event.ProvisioningEventWaiting, "waiting for allocation")
 
 	req := &v1.WaitRequest{
 		MachineID: machineID,
 	}
 	for {
-		stream, err := client.Wait(context.Background(), req)
+		stream, err := c.Wait().Wait(context.Background(), req)
 		if err != nil {
 			c.log.Errorw("failed waiting for allocation", "retry after", defaultWaitTimeOut, "error", err)
 			time.Sleep(defaultWaitTimeOut)