Add support for multiple service deployers

Author: bhapas

internal/testrunner/runners/system/runner.go

@@ -446,26 +446,34 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext
 
 	// Setup service.
 	logger.Debug("setting up service...")
-	serviceDeployer, err := servicedeployer.Factory(serviceOptions)
+	serviceDeployers, err := servicedeployer.Factory(serviceOptions)
 	if err != nil {
 		return result.WithError(fmt.Errorf("could not create service runner: %w", err))
 	}
 
 	if config.Service != "" {
 		ctxt.Name = config.Service
 	}
-	service, err := serviceDeployer.SetUp(ctxt)
-	if err != nil {
-		return result.WithError(fmt.Errorf("could not setup service: %w", err))
-	}
-	ctxt = service.Context()
-	r.shutdownServiceHandler = func() error {
-		logger.Debug("tearing down service...")
-		if err := service.TearDown(); err != nil {
-			return fmt.Errorf("error tearing down service: %w", err)
+
+	var services []servicedeployer.DeployedService
+
+	for _, serviceDeployer := range serviceDeployers {
+
+		service, err := serviceDeployer.SetUp(ctxt)
+		if err != nil {
+			return result.WithError(fmt.Errorf("could not setup service: %w", err))
 		}
+		ctxt = service.Context()
+		r.shutdownServiceHandler = func() error {
+			logger.Debug("tearing down service...")
+			if err := service.TearDown(); err != nil {
+				return fmt.Errorf("error tearing down service: %w", err)
+			}
 
-		return nil
+			return nil
+		}
+
+		services = append(services, service)
 	}
 
 	// Reload test config with ctx variable substitution.
@@ -601,8 +609,12 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext
 
 	// Signal to the service that the agent is ready (policy is assigned).
 	if config.ServiceNotifySignal != "" {
-		if err = service.Signal(config.ServiceNotifySignal); err != nil {
-			return result.WithError(fmt.Errorf("failed to notify test service: %w", err))
+		for _, service := range services {
+			if service.Context().Name == "docker" {
+				if err = service.Signal(config.ServiceNotifySignal); err != nil {
+					return result.WithError(fmt.Errorf("failed to notify test service: %w", err))
+				}
+			}
 		}
 	}
 

internal/testrunner/runners/system/servicedeployer/factory.go

@@ -24,46 +24,59 @@ type FactoryOptions struct {
 
 // Factory chooses the appropriate service runner for the given data stream, depending
 // on service configuration files defined in the package or data stream.
-func Factory(options FactoryOptions) (ServiceDeployer, error) {
+func Factory(options FactoryOptions) (map[string]ServiceDeployer, error) {
 	devDeployPath, err := FindDevDeployPath(options)
 	if err != nil {
 		return nil, errors.Wrapf(err, "can't find \"%s\" directory", devDeployDir)
 	}
 
-	serviceDeployerName, err := findServiceDeployer(devDeployPath)
+	serviceDeployers, err := findServiceDeployer(devDeployPath)
 	if err != nil {
 		return nil, errors.Wrap(err, "can't find any valid service deployer")
 	}
 
-	serviceDeployerPath := filepath.Join(devDeployPath, serviceDeployerName)
+	serviceDeployerInstances := make(map[string]ServiceDeployer)
 
-	switch serviceDeployerName {
-	case "k8s":
-		if _, err := os.Stat(serviceDeployerPath); err == nil {
-			return NewKubernetesServiceDeployer(serviceDeployerPath)
-		}
-	case "docker":
-		dockerComposeYMLPath := filepath.Join(serviceDeployerPath, "docker-compose.yml")
-		if _, err := os.Stat(dockerComposeYMLPath); err == nil {
-			sv, err := useServiceVariant(devDeployPath, options.Variant)
-			if err != nil {
-				return nil, errors.Wrap(err, "can't use service variant")
+	for _, serviceDeployerName := range serviceDeployers {
+		serviceDeployerPath := filepath.Join(devDeployPath, serviceDeployerName)
+
+		switch serviceDeployerName {
+		case "k8s":
+			if _, err := os.Stat(serviceDeployerPath); err == nil {
+				k8sDeployer, _ := NewKubernetesServiceDeployer(serviceDeployerPath)
+				serviceDeployerInstances["k8s"] = k8sDeployer
+			}
+
+		case "docker":
+			dockerComposeYMLPath := filepath.Join(serviceDeployerPath, "docker-compose.yml")
+			if _, err := os.Stat(dockerComposeYMLPath); err == nil {
+				sv, err := useServiceVariant(devDeployPath, options.Variant)
+				if err != nil {
+					return nil, fmt.Errorf("can't use service variant: %w", err)
+				}
+				dcDeployer, _ := NewDockerComposeServiceDeployer([]string{dockerComposeYMLPath}, sv)
+				serviceDeployerInstances["docker"] = dcDeployer
+			}
+
+		case "agent":
+			customAgentCfgYMLPath := filepath.Join(serviceDeployerPath, "custom-agent.yml")
+			if _, err := os.Stat(customAgentCfgYMLPath); err != nil {
+				return nil, fmt.Errorf("can't find expected file custom-agent.yml: %w", err)
+			}
+			agentDeployer, _ := NewCustomAgentDeployer(customAgentCfgYMLPath)
+			serviceDeployerInstances["agent"] = agentDeployer
+
+		case "tf":
+			if _, err := os.Stat(serviceDeployerPath); err == nil {
+				tfDeployer, _ := NewTerraformServiceDeployer(serviceDeployerPath)
+				serviceDeployerInstances["tf"] = tfDeployer
 			}
-			return NewDockerComposeServiceDeployer([]string{dockerComposeYMLPath}, sv)
-		}
-	case "agent":
-		customAgentCfgYMLPath := filepath.Join(serviceDeployerPath, "custom-agent.yml")
-		if _, err := os.Stat(customAgentCfgYMLPath); err != nil {
-			return nil, errors.Wrap(err, "can't find expected file custom-agent.yml")
-		}
-		return NewCustomAgentDeployer(customAgentCfgYMLPath)
 
-	case "tf":
-		if _, err := os.Stat(serviceDeployerPath); err == nil {
-			return NewTerraformServiceDeployer(serviceDeployerPath)
+		default:
+			return nil, fmt.Errorf("unsupported service deployer (name: %s)", serviceDeployerName)
 		}
 	}
-	return nil, fmt.Errorf("unsupported service deployer (name: %s)", serviceDeployerName)
+	return serviceDeployerInstances, nil
 }
 
 // FindDevDeployPath function returns a path reference to the "_dev/deploy" directory.
@@ -86,10 +99,10 @@ func FindDevDeployPath(options FactoryOptions) (string, error) {
 	return "", fmt.Errorf("\"%s\" directory doesn't exist", devDeployDir)
 }
 
-func findServiceDeployer(devDeployPath string) (string, error) {
+func findServiceDeployer(devDeployPath string) ([]string, error) {
 	fis, err := os.ReadDir(devDeployPath)
 	if err != nil {
-		return "", errors.Wrapf(err, "can't read directory (path: %s)", devDeployDir)
+		return nil, errors.Wrapf(err, "can't read directory (path: %s)", devDeployDir)
 	}
 
 	var folders []os.DirEntry
@@ -99,8 +112,9 @@ func findServiceDeployer(devDeployPath string) (string, error) {
 		}
 	}
 
-	if len(folders) != 1 {
-		return "", fmt.Errorf("expected to find only one service deployer in \"%s\"", devDeployPath)
+	var folderNames []string
+	for _, fname := range folders {
+		folderNames = append(folderNames, fname.Name())
 	}
-	return folders[0].Name(), nil
+	return folderNames, nil
 }