* Function renaming and code cleaning.

Author: dean-amar

cmd/config/templates/coordinator.yaml

@@ -48,7 +48,6 @@ validator-committer:
       - {{ . }}
       {{- end }}
 
-
 dependency-graph:
   num-of-local-dep-constructors: 1
   waiting-txs-limit: 10_000

integration/runner/runtime.go

@@ -191,41 +191,41 @@ func NewRuntime(t *testing.T, conf *Config) *CommitterRuntime {
 	c.TLSManager = tlsgen.NewSecureCommunicationManager(t)
 
 	t.Log("create clients certificates per service")
-	s.ClientsCreds.Vc = c.createClientCerts(t, "validator-committer")
-	s.ClientsCreds.Verifier = c.createClientCerts(t, "verifier")
-	s.ClientsCreds.Coordinator = c.createClientCerts(t, "coordinator")
-	s.ClientsCreds.Query = c.createClientCerts(t, "query-service")
-	s.ClientsCreds.Sidecar = c.createClientCerts(t, "sidecar")
+	s.ClientsCreds.Vc = c.createClientConfigTLS(t, "validator-committer")
+	s.ClientsCreds.Verifier = c.createClientConfigTLS(t, "verifier")
+	s.ClientsCreds.Coordinator = c.createClientConfigTLS(t, "coordinator")
+	s.ClientsCreds.Query = c.createClientConfigTLS(t, "query-service")
+	s.ClientsCreds.Sidecar = c.createClientConfigTLS(t, "sidecar")
 
 	t.Log("Create processes")
 	c.MockOrderer = newProcess(t, cmdOrderer, s.WithEndpoint(s.Endpoints.Orderer[0]))
 	for i, e := range s.Endpoints.Verifier {
 		p := cmdVerifier
 		p.Name = fmt.Sprintf("%s-%d", p.Name, i)
 		c.Verifier = append(c.Verifier, newProcess(
-			t, p, c.createServerCerts(t, e, "verifier")))
+			t, p, c.createSystemConfigWithServerCerts(t, e, "verifier")))
 	}
 
 	for i, e := range s.Endpoints.VCService {
 		p := cmdVC
 		p.Name = fmt.Sprintf("%s-%d", p.Name, i)
 		c.VcService = append(c.VcService, newProcess(
-			t, p, c.createServerCerts(t, e, "validator-committer")))
+			t, p, c.createSystemConfigWithServerCerts(t, e, "validator-committer")))
 	}
 
 	c.Coordinator = newProcess(t,
 		cmdCoordinator,
-		c.createServerCerts(t, s.Endpoints.Coordinator, "coordinator"),
+		c.createSystemConfigWithServerCerts(t, s.Endpoints.Coordinator, "coordinator"),
 	)
 
 	c.QueryService = newProcess(t,
 		cmdQuery,
-		c.createServerCerts(t, s.Endpoints.Query, "query-service"),
+		c.createSystemConfigWithServerCerts(t, s.Endpoints.Query, "query-service"),
 	)
 
 	c.Sidecar = newProcess(t,
 		cmdSidecar,
-		c.createServerCerts(t, s.Endpoints.Sidecar, "sidecar"),
+		c.createSystemConfigWithServerCerts(t, s.Endpoints.Sidecar, "sidecar"),
 	)
 
 	t.Log("Create clients")
@@ -638,25 +638,34 @@ func (c *CommitterRuntime) ensureAtLeastLastCommittedBlockNumber(t *testing.T, b
 	}, 2*time.Minute, 250*time.Millisecond)
 }
 
-func (c *CommitterRuntime) createServerCerts(
+func (c *CommitterRuntime) createSystemConfigWithServerCerts(
 	t *testing.T,
 	endpoints config.ServiceEndpoints,
 	serverName string,
 ) *config.SystemConfig {
 	t.Helper()
 	serviceCfg := c.SystemConfig
-	serviceTLSCertsPath := c.TLSManager.CreateServerCertificate(t, serverName)
-	serviceCfg.ServiceTLS = c.createTLSConfig(serviceTLSCertsPath, serverName)
+	serviceCfg.ServiceTLS = c.createServerConfigTLS(t, serverName)
 	serviceCfg.ServiceEndpoints = endpoints
 	return &serviceCfg
 }
 
-func (c *CommitterRuntime) createClientCerts(t *testing.T, forServer string) connection.ConfigTLS {
+func (c *CommitterRuntime) createServerConfigTLS(t *testing.T, asServer string) connection.ConfigTLS {
 	t.Helper()
-	return c.createTLSConfig(c.TLSManager.CreateClientCertificate(t), forServer)
+	// We pass asServer twice: first to generate the server's keys,
+	// and second to include the server name in the ConfigTLS.
+	// Note: the Server Name Indication (SNI) is not used when creating
+	// the server's transport credentials, so passing it during TLS config
+	// creation is not strictly necessary.
+	return c.createConfigTLS(c.TLSManager.CreateServerCertificate(t, asServer), asServer)
 }
 
-func (c *CommitterRuntime) createTLSConfig(paths map[string]string, serverName string) connection.ConfigTLS {
+func (c *CommitterRuntime) createClientConfigTLS(t *testing.T, forServer string) connection.ConfigTLS {
+	t.Helper()
+	return c.createConfigTLS(c.TLSManager.CreateClientCertificate(t), forServer)
+}
+
+func (c *CommitterRuntime) createConfigTLS(paths map[string]string, serverName string) connection.ConfigTLS {
 	return test.CreateTLSConfigFromPaths(c.config.TLS, paths, serverName)
 }
 

service/coordinator/coordinator_test.go

@@ -128,18 +128,8 @@ func newCoordinatorTestEnv(t *testing.T, tConfig *testConfig) *coordinatorTestEn
 
 func (e *coordinatorTestEnv) start(ctx context.Context, t *testing.T) {
 	t.Helper()
-	cs := e.coordinator
-	sc := &connection.ServerConfig{
-		Endpoint: connection.Endpoint{
-			Host: "localhost",
-			Port: 0,
-		},
-	}
-	test.RunServiceAndGrpcForTest(ctx, t, cs, sc, func(server *grpc.Server) {
-		protocoordinatorservice.RegisterCoordinatorServer(server, cs)
-	})
-
-	e.client = createCoordinatorClientWithTLS(t, &sc.Endpoint, nil)
+	e.startWithCreds(ctx, t, nil)
+	e.client = createCoordinatorClientWithTLS(t, &e.coordinator.config.Server.Endpoint, nil)
 
 	sCtx, sCancel := context.WithTimeout(ctx, 5*time.Minute)
 	t.Cleanup(sCancel)

service/sidecar/sidecar.go

@@ -94,25 +94,23 @@ func (s *Service) Run(ctx context.Context) error {
 		_ = s.metrics.StartPrometheusServer(pCtx, s.config.Monitoring.Server, s.monitorQueues)
 	}()
 
-	logger.Infof("Create coordinator client and connect to %s", connection.AddressString(
-		s.config.Committer.Config.Endpoints...),
-	)
+	coordinatorEndpoints := connection.AddressString(s.config.Committer.Config.Endpoints...)
+	logger.Infof("Create coordinator client and connect to %s", coordinatorEndpoints)
 
 	committerDialConfig, err := connection.NewLoadBalancedDialConfig(s.config.Committer.Config)
 	if err != nil {
 		return errors.Wrapf(err, "could not load coordinator dial config")
 	}
+
 	// connecting to the coordinator.
 	conn, connErr := connection.Connect(committerDialConfig)
 	if connErr != nil {
-		return errors.Wrapf(err, "failed to connect to coordinator")
+		return errors.Wrapf(connErr, "failed to connect to coordinator")
 	}
 	s.coordConn = conn
 	defer connection.CloseConnectionsLog(conn)
+	logger.Infof("sidecar connected to coordinator at %s", coordinatorEndpoints)
 
-	logger.Infof("sidecar connected to coordinator at %s", connection.AddressString(
-		s.config.Committer.Config.Endpoints...),
-	)
 	// creating coordinator client.
 	coordClient := protocoordinatorservice.NewCoordinatorClient(conn)
 

utils/test/secure_connection.go

@@ -46,7 +46,6 @@ func RunSecureConnectionTest(
 	secureConnArguments SecureConnectionFunctionArguments,
 ) {
 	t.Helper()
-
 	tlsMgr := tlsgen.NewSecureCommunicationManager(t)
 	serverCreds := tlsMgr.CreateServerCertificate(t, secureConnArguments.ServerCN)
 	serverTLS := CreateTLSConfigFromPaths(connection.TLSMutual, serverCreds, "")