dockercompose: make compose wrapper an object, use commandLogger

newrelic-integration-e2e/internal/agent/agent.go

@@ -24,7 +24,7 @@ const (
 	integrationsBinDirEnv = "E2E_NRI_BIN"
 	dockerCompose         = "docker-compose.yml"
 	defConfigFile         = "nri-config.yml"
-	container             = "agent"
+	agentContainerName    = "agent"
 )
 
 //go:embed resources/docker-compose.yml
@@ -39,7 +39,6 @@ type Agent interface {
 type agent struct {
 	agentBuildContext string
 	configsDir        string
-	containerName     string
 	exportersDir      string
 	binsDir           string
 	licenseKey        string
@@ -49,14 +48,14 @@ type agent struct {
 	ExtraIntegrations map[string]string
 	ExtraEnvVars      map[string]string
 	customTagKey      string
+	compose           *dockercompose.Compose
 }
 
 func NewAgent(settings e2e.Settings) *agent {
 	agentBuildContext := settings.AgentBuildContext()
 
 	a := agent{
 		specParentDir:     settings.SpecParentDir(),
-		containerName:     container,
 		agentBuildContext: agentBuildContext,
 		dockerComposePath: filepath.Join(agentBuildContext, dockerCompose),
 		licenseKey:        settings.LicenseKey(),
@@ -103,7 +102,7 @@ func (a *agent) initDefaultCompose() error {
 // the same dir where the agent compose file is located.
 func (a *agent) initialize() error {
 	// dockerComposePath can be in a temporal dir if using default or inside the
-	// agentBuildContext dir if using custom agent container.
+	// agentBuildContext dir if using custom agent agentContainerName.
 	parentDir := filepath.Dir(a.dockerComposePath)
 
 	configDir, err := ioutil.TempDir(parentDir, IntegrationsCfgDir)
@@ -130,6 +129,8 @@ func (a *agent) initialize() error {
 	a.logger.Debugf("bins dir: %s", binsDir)
 	a.binsDir = binsDir
 
+	a.compose = dockercompose.New(a.dockerComposePath)
+
 	return nil
 }
 
@@ -225,15 +226,20 @@ func (a *agent) Run(scenarioTag string) error {
 		return fmt.Errorf("fail to set %s env: %w", exportersDirEnv, err)
 	}
 
-	return dockercompose.Run(a.dockerComposePath, a.containerName, envVars)
+	// TODO: Distinguish between these two.
+	a.compose.Env(envVars)
+	a.compose.BuildArgs(envVars)
+
+	return a.compose.Run(agentContainerName)
 }
 
 func (a *agent) Stop() error {
+	logrus.Debugf("Stopping container")
 	if a.logger.GetLevel() == logrus.DebugLevel {
-		a.logger.Debug(dockercompose.Logs(a.dockerComposePath, a.containerName))
+		_ = a.compose.Logs(agentContainerName)
 	}
 
-	if err := dockercompose.Down(a.dockerComposePath); err != nil {
+	if err := a.compose.Down(); err != nil {
 		return err
 	}
 

newrelic-integration-e2e/pkg/dockercompose/docker.go

@@ -4,59 +4,90 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+
+	"github.com/newrelic/newrelic-integration-e2e-action/newrelic-integration-e2e/internal/runtime/logger"
 )
 
 const (
 	dockerComposeBin = "docker-compose"
 	dockerBin        = "docker"
 )
 
-func Run(path string, container string, envVars map[string]string) error {
-	if err := Build(path, container, envVars); err != nil {
-		return err
-	}
-	args := []string{"-f", path, "run"}
-	for k, v := range envVars {
-		args = append(args, "-e", fmt.Sprintf("%s=%s", k, v))
+type Compose struct {
+	path      string
+	env       map[string]string
+	buildArgs map[string]string
+
+	cmdLogger logger.CommandLogger
+}
+
+// New creates a new docker-compose wrapper given the path to a docker-compose.yml file.
+func New(filepath string) *Compose {
+	return &Compose{
+		path:      filepath,
+		cmdLogger: logger.NewGHALogger(os.Stderr),
 	}
-	args = append(args, "-d", container)
-	cmd := exec.Command(dockerComposeBin, args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
 }
 
-func Down(path string) error {
-	args := []string{"-f", path, "down", "-v"}
-	cmd := exec.Command(dockerComposeBin, args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+func (c *Compose) Logger(commandLogger logger.CommandLogger) {
+	c.cmdLogger = commandLogger
+}
+
+func (c *Compose) Env(env map[string]string) {
+	c.env = env
+}
+
+func (c *Compose) BuildArgs(args map[string]string) {
+	c.buildArgs = args
+}
+
+func (c *Compose) command(args ...string) error {
+	cmdArgs := []string{"-f", c.path}
+	cmdArgs = append(cmdArgs, args...)
+	cmd := exec.Command(dockerComposeBin, cmdArgs...)
 
+	logWriter := c.cmdLogger.Open(cmd.String())
+	defer c.cmdLogger.Close()
+
+	cmd.Stdout = logWriter
+	cmd.Stderr = logWriter
 	return cmd.Run()
 }
 
-func Build(path, container string, envVars map[string]string) error {
-	args := []string{"-f", path, "build", "--no-cache"}
-	for k, v := range envVars {
-		args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, v))
+func (c *Compose) Run(container string) error {
+	if err := c.Build(); err != nil {
+		return fmt.Errorf("building before run: %w", err)
 	}
-	args = append(args, container)
-	cmd := exec.Command(dockerComposeBin, args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
+
+	args := []string{"run", "-d", container}
+	args = append(args, asFlags("-e", c.env)...)
+
+	return c.command(args...)
+}
+
+func (c *Compose) Down() error {
+	return c.command("down", "-v")
+}
+
+func (c *Compose) Build() error {
+	args := []string{"build", "--no-cache"}
+	args = append(args, asFlags("--build-arg", c.buildArgs)...)
+
+	return c.command(args...)
 }
 
-func Logs(path, containerName string) string {
-	containerID := getContainerID(path, containerName)
+func (c *Compose) Logs(containerName string) error {
+	containerID := getContainerID(c.path, containerName)
 
 	args := []string{"logs", containerID}
 	cmd := exec.Command(dockerBin, args...)
-	stdout, err := cmd.Output()
-	if ee, ok := err.(*exec.ExitError); ok {
-		fmt.Print(string(ee.Stderr))
-	}
-	return string(stdout)
+
+	logWriter := c.cmdLogger.Open(cmd.String())
+	defer c.cmdLogger.Close()
+
+	cmd.Stdout = logWriter
+	cmd.Stderr = logWriter
+	return cmd.Run()
 }
 
 func getContainerID(path, containerName string) string {
@@ -69,3 +100,11 @@ func getContainerID(path, containerName string) string {
 	}
 	return string(containerID)
 }
+
+func asFlags(flag string, vars map[string]string) (args []string) {
+	for k, v := range vars {
+		args = append(args, flag, fmt.Sprintf("%s=%s", k, v))
+	}
+
+	return
+}