hs-test: retry command on test setup failure
[vpp.git] / extras / hs-test / container.go
index 40dc082..812198d 100644 (file)
@@ -6,6 +6,7 @@ import (
        "os/exec"
        "strings"
        "text/template"
+       "time"
 
        "github.com/edwarnicke/exechelper"
 )
@@ -27,6 +28,7 @@ type Volume struct {
 type Container struct {
        suite            *HstSuite
        isOptional       bool
+       runDetached      bool
        name             string
        image            string
        extraRunningArgs string
@@ -35,7 +37,7 @@ type Container struct {
        vppInstance      *VppInstance
 }
 
-func NewContainer(yamlInput ContainerConfig) (*Container, error) {
+func newContainer(yamlInput ContainerConfig) (*Container, error) {
        containerName := yamlInput["name"].(string)
        if len(containerName) == 0 {
                err := fmt.Errorf("container name must not be blank")
@@ -65,6 +67,12 @@ func NewContainer(yamlInput ContainerConfig) (*Container, error) {
                container.isOptional = false
        }
 
+       if runDetached, ok := yamlInput["run-detached"]; ok {
+               container.runDetached = runDetached.(bool)
+       } else {
+               container.runDetached = true
+       }
+
        if _, ok := yamlInput["volumes"]; ok {
                r := strings.NewReplacer("$HST_DIR", workDir)
                for _, volu := range yamlInput["volumes"].([]interface{}) {
@@ -93,10 +101,6 @@ func NewContainer(yamlInput ContainerConfig) (*Container, error) {
        return container, nil
 }
 
-func (c *Container) Suite() *HstSuite {
-       return c.suite
-}
-
 func (c *Container) getWorkDirVolume() (res Volume, exists bool) {
        for _, v := range c.volumes {
                if v.isDefaultWorkDir {
@@ -108,14 +112,14 @@ func (c *Container) getWorkDirVolume() (res Volume, exists bool) {
        return
 }
 
-func (c *Container) GetHostWorkDir() (res string) {
+func (c *Container) getHostWorkDir() (res string) {
        if v, ok := c.getWorkDirVolume(); ok {
                res = v.hostDir
        }
        return
 }
 
-func (c *Container) GetContainerWorkDir() (res string) {
+func (c *Container) getContainerWorkDir() (res string) {
        if v, ok := c.getWorkDirVolume(); ok {
                res = v.containerDir
        }
@@ -123,36 +127,72 @@ func (c *Container) GetContainerWorkDir() (res string) {
 }
 
 func (c *Container) getContainerArguments() string {
-       args := "--cap-add=all --privileged --network host --rm"
+       args := "--ulimit nofile=90000:90000 --cap-add=all --privileged --network host --rm"
        args += c.getVolumesAsCliOption()
        args += c.getEnvVarsAsCliOption()
+       if *vppSourceFileDir != "" {
+               args += fmt.Sprintf(" -v %s:%s", *vppSourceFileDir, *vppSourceFileDir)
+       }
        args += " --name " + c.name + " " + c.image
+       args += " " + c.extraRunningArgs
        return args
 }
 
-func (c *Container) create() {
+func (c *Container) runWithRetry(cmd string) error {
+       nTries := 5
+       for i := 0; i < nTries; i++ {
+               err := exechelper.Run(cmd)
+               if err == nil {
+                       return nil
+               }
+               time.Sleep(1 * time.Second)
+       }
+       return fmt.Errorf("failed to run container command")
+}
+
+func (c *Container) create() error {
        cmd := "docker create " + c.getContainerArguments()
-       exechelper.Run(cmd)
+       c.suite.log(cmd)
+       return exechelper.Run(cmd)
 }
 
-func (c *Container) start() {
+func (c *Container) start() error {
        cmd := "docker start " + c.name
-       exechelper.Run(cmd)
+       c.suite.log(cmd)
+       return c.runWithRetry(cmd)
 }
 
-func (c *Container) run() error {
+func (c *Container) prepareCommand() (string, error) {
        if c.name == "" {
-               return fmt.Errorf("run container failed: name is blank")
+               return "", fmt.Errorf("run container failed: name is blank")
        }
 
-       cmd := "docker run -d " + c.getContainerArguments() + " " + c.extraRunningArgs
-       c.Suite().log(cmd)
-       err := exechelper.Run(cmd)
+       cmd := "docker run "
+       if c.runDetached {
+               cmd += " -d"
+       }
+       cmd += " " + c.getContainerArguments()
+
+       c.suite.log(cmd)
+       return cmd, nil
+}
+
+func (c *Container) combinedOutput() (string, error) {
+       cmd, err := c.prepareCommand()
        if err != nil {
-               return fmt.Errorf("container run failed: %s", err)
+               return "", err
        }
 
-       return nil
+       byteOutput, err := exechelper.CombinedOutput(cmd)
+       return string(byteOutput), err
+}
+
+func (c *Container) run() error {
+       cmd, err := c.prepareCommand()
+       if err != nil {
+               return err
+       }
+       return c.runWithRetry(cmd)
 }
 
 func (c *Container) addVolume(hostDir string, containerDir string, isDefaultWorkDir bool) {
@@ -191,16 +231,12 @@ func (c *Container) getEnvVarsAsCliOption() string {
        return cliOption
 }
 
-func (c *Container) newVppInstance(additionalConfig ...Stanza) (*VppInstance, error) {
+func (c *Container) newVppInstance(cpus []int, additionalConfigs ...Stanza) (*VppInstance, error) {
        vpp := new(VppInstance)
        vpp.container = c
-
-       if len(additionalConfig) > 0 {
-               vpp.additionalConfig = additionalConfig[0]
-       }
-
+       vpp.cpus = cpus
+       vpp.additionalConfig = append(vpp.additionalConfig, additionalConfigs...)
        c.vppInstance = vpp
-
        return vpp, nil
 }
 
@@ -234,30 +270,30 @@ func (c *Container) execServer(command string, arguments ...any) {
        serverCommand := fmt.Sprintf(command, arguments...)
        containerExecCommand := "docker exec -d" + c.getEnvVarsAsCliOption() +
                " " + c.name + " " + serverCommand
-       c.Suite().T().Helper()
-       c.Suite().log(containerExecCommand)
-       c.Suite().assertNil(exechelper.Run(containerExecCommand))
+       c.suite.T().Helper()
+       c.suite.log(containerExecCommand)
+       c.suite.assertNil(exechelper.Run(containerExecCommand))
 }
 
 func (c *Container) exec(command string, arguments ...any) string {
        cliCommand := fmt.Sprintf(command, arguments...)
        containerExecCommand := "docker exec" + c.getEnvVarsAsCliOption() +
                " " + c.name + " " + cliCommand
-       c.Suite().T().Helper()
-       c.Suite().log(containerExecCommand)
+       c.suite.T().Helper()
+       c.suite.log(containerExecCommand)
        byteOutput, err := exechelper.CombinedOutput(containerExecCommand)
-       c.Suite().assertNil(err)
+       c.suite.assertNil(err)
        return string(byteOutput)
 }
 
 func (c *Container) getLogDirPath() string {
-       testId := c.Suite().getTestId()
-       testName := c.Suite().T().Name()
+       testId := c.suite.getTestId()
+       testName := c.suite.T().Name()
        logDirPath := logDir + testName + "/" + testId + "/"
 
        cmd := exec.Command("mkdir", "-p", logDirPath)
        if err := cmd.Run(); err != nil {
-               c.Suite().T().Fatalf("mkdir error: %v", err)
+               c.suite.T().Fatalf("mkdir error: %v", err)
        }
 
        return logDirPath
@@ -274,22 +310,22 @@ func (c *Container) saveLogs() {
        cmd = exec.Command("docker", "logs", "--details", "-t", c.name)
        output, err := cmd.CombinedOutput()
        if err != nil {
-               c.Suite().T().Fatalf("fetching logs error: %v", err)
+               c.suite.T().Fatalf("fetching logs error: %v", err)
        }
 
        f, err := os.Create(testLogFilePath)
        if err != nil {
-               c.Suite().T().Fatalf("file create error: %v", err)
+               c.suite.T().Fatalf("file create error: %v", err)
        }
-       fmt.Fprintf(f, string(output))
+       fmt.Fprint(f, string(output))
        f.Close()
 }
 
 func (c *Container) log() string {
        cmd := "docker logs " + c.name
-       c.Suite().log(cmd)
+       c.suite.log(cmd)
        o, err := exechelper.CombinedOutput(cmd)
-       c.Suite().assertNil(err)
+       c.suite.assertNil(err)
        return string(o)
 }
 
@@ -307,14 +343,21 @@ func (c *Container) createConfig(targetConfigName string, templateName string, v
        template := template.Must(template.ParseFiles(templateName))
 
        f, err := os.CreateTemp("/tmp/hs-test/", "hst-config")
-       c.Suite().assertNil(err)
+       c.suite.assertNil(err)
        defer os.Remove(f.Name())
 
        err = template.Execute(f, values)
-       c.Suite().assertNil(err)
+       c.suite.assertNil(err)
 
        err = f.Close()
-       c.Suite().assertNil(err)
+       c.suite.assertNil(err)
 
        c.copy(f.Name(), targetConfigName)
 }
+
+func init() {
+       cmd := exec.Command("mkdir", "-p", logDir)
+       if err := cmd.Run(); err != nil {
+               panic(err)
+       }
+}