extras/hs-test/container.go

   1 package main
   2
   3 import (
   4         "fmt"
   5         "os"
   6         "os/exec"
   7         "strings"
   8
   9         "github.com/edwarnicke/exechelper"
  10 )
  11
  12 var (
  13         workDir, _ = os.Getwd()
  14 )
  15
  16 type Volume struct {
  17         hostDir          string
  18         containerDir     string
  19         isDefaultWorkDir bool
  20 }
  21
  22 type Container struct {
  23         suite            *HstSuite
  24         isOptional       bool
  25         name             string
  26         image            string
  27         extraRunningArgs string
  28         volumes          map[string]Volume
  29         envVars          map[string]string
  30         vppInstance      *VppInstance
  31 }
  32
  33 func NewContainer(yamlInput ContainerConfig) (*Container, error) {
  34         containerName := yamlInput["name"].(string)
  35         if len(containerName) == 0 {
  36                 err := fmt.Errorf("container name must not be blank")
  37                 return nil, err
  38         }
  39
  40         var container = new(Container)
  41         container.volumes = make(map[string]Volume)
  42         container.envVars = make(map[string]string)
  43         container.name = containerName
  44
  45         if image, ok := yamlInput["image"]; ok {
  46                 container.image = image.(string)
  47         } else {
  48                 container.image = "hs-test/vpp"
  49         }
  50
  51         if args, ok := yamlInput["extra-args"]; ok {
  52                 container.extraRunningArgs = args.(string)
  53         } else {
  54                 container.extraRunningArgs = ""
  55         }
  56
  57         if isOptional, ok := yamlInput["is-optional"]; ok {
  58                 container.isOptional = isOptional.(bool)
  59         } else {
  60                 container.isOptional = false
  61         }
  62
  63         if _, ok := yamlInput["volumes"]; ok {
  64                 r := strings.NewReplacer("$HST_DIR", workDir)
  65                 for _, volu := range yamlInput["volumes"].([]interface{}) {
  66                         volumeMap := volu.(ContainerConfig)
  67                         hostDir := r.Replace(volumeMap["host-dir"].(string))
  68                         containerDir := volumeMap["container-dir"].(string)
  69                         isDefaultWorkDir := false
  70
  71                         if isDefault, ok := volumeMap["is-default-work-dir"]; ok {
  72                                 isDefaultWorkDir = isDefault.(bool)
  73                         }
  74
  75                         container.addVolume(hostDir, containerDir, isDefaultWorkDir)
  76
  77                 }
  78         }
  79
  80         if _, ok := yamlInput["vars"]; ok {
  81                 for _, envVar := range yamlInput["vars"].([]interface{}) {
  82                         envVarMap := envVar.(ContainerConfig)
  83                         name := envVarMap["name"].(string)
  84                         value := envVarMap["value"].(string)
  85                         container.addEnvVar(name, value)
  86                 }
  87         }
  88         return container, nil
  89 }
  90
  91 func (c *Container) Suite() *HstSuite {
  92         return c.suite
  93 }
  94
  95 func (c *Container) getWorkDirVolume() (res Volume, exists bool) {
  96         for _, v := range c.volumes {
  97                 if v.isDefaultWorkDir {
  98                         res = v
  99                         exists = true
 100                         return
 101                 }
 102         }
 103         return
 104 }
 105
 106 func (c *Container) GetHostWorkDir() (res string) {
 107         if v, ok := c.getWorkDirVolume(); ok {
 108                 res = v.hostDir
 109         }
 110         return
 111 }
 112
 113 func (c *Container) GetContainerWorkDir() (res string) {
 114         if v, ok := c.getWorkDirVolume(); ok {
 115                 res = v.containerDir
 116         }
 117         return
 118 }
 119
 120 func (c *Container) getRunCommand() string {
 121         cmd := "docker run --cap-add=all -d --privileged --network host --rm"
 122         cmd += c.getVolumesAsCliOption()
 123         cmd += c.getEnvVarsAsCliOption()
 124         cmd += " --name " + c.name + " " + c.image + " " + c.extraRunningArgs
 125         return cmd
 126 }
 127
 128 func (c *Container) run() error {
 129         if c.name == "" {
 130                 return fmt.Errorf("run container failed: name is blank")
 131         }
 132
 133         cmd := c.getRunCommand()
 134         err := exechelper.Run(cmd)
 135         if err != nil {
 136                 return fmt.Errorf("container run failed: %s", err)
 137         }
 138
 139         return nil
 140 }
 141
 142 func (c *Container) addVolume(hostDir string, containerDir string, isDefaultWorkDir bool) {
 143         var volume Volume
 144         volume.hostDir = hostDir
 145         volume.containerDir = containerDir
 146         volume.isDefaultWorkDir = isDefaultWorkDir
 147         c.volumes[hostDir] = volume
 148 }
 149
 150 func (c *Container) getVolumesAsCliOption() string {
 151         cliOption := ""
 152
 153         if len(c.volumes) > 0 {
 154                 for _, volume := range c.volumes {
 155                         cliOption += fmt.Sprintf(" -v %s:%s", volume.hostDir, volume.containerDir)
 156                 }
 157         }
 158
 159         return cliOption
 160 }
 161
 162 func (c *Container) addEnvVar(name string, value string) {
 163         c.envVars[name] = value
 164 }
 165
 166 func (c *Container) getEnvVarsAsCliOption() string {
 167         cliOption := ""
 168         if len(c.envVars) == 0 {
 169                 return cliOption
 170         }
 171
 172         for name, value := range c.envVars {
 173                 cliOption += fmt.Sprintf(" -e %s=%s", name, value)
 174         }
 175         return cliOption
 176 }
 177
 178 func (c *Container) newVppInstance(additionalConfig ...Stanza) (*VppInstance, error) {
 179         vpp := new(VppInstance)
 180         vpp.container = c
 181
 182         if len(additionalConfig) > 0 {
 183                 vpp.additionalConfig = additionalConfig[0]
 184         }
 185
 186         c.vppInstance = vpp
 187
 188         return vpp, nil
 189 }
 190
 191 func (c *Container) copy(sourceFileName string, targetFileName string) error {
 192         cmd := exec.Command("docker", "cp", sourceFileName, c.name+":"+targetFileName)
 193         return cmd.Run()
 194 }
 195
 196 func (c *Container) createFile(destFileName string, content string) error {
 197         f, err := os.CreateTemp("/tmp", "hst-config")
 198         if err != nil {
 199                 return err
 200         }
 201         defer os.Remove(f.Name())
 202
 203         if _, err := f.Write([]byte(content)); err != nil {
 204                 return err
 205         }
 206         if err := f.Close(); err != nil {
 207                 return err
 208         }
 209         c.copy(f.Name(), destFileName)
 210         return nil
 211 }
 212
 213 /*
 214  * Executes in detached mode so that the started application can continue to run
 215  * without blocking execution of test
 216  */
 217 func (c *Container) execServer(command string, arguments ...any) {
 218         serverCommand := fmt.Sprintf(command, arguments...)
 219         containerExecCommand := "docker exec -d" + c.getEnvVarsAsCliOption() +
 220                 " " + c.name + " " + serverCommand
 221         c.Suite().log(containerExecCommand)
 222         c.Suite().assertNil(exechelper.Run(containerExecCommand))
 223 }
 224
 225 func (c *Container) exec(command string, arguments ...any) string {
 226         cliCommand := fmt.Sprintf(command, arguments...)
 227         containerExecCommand := "docker exec" + c.getEnvVarsAsCliOption() +
 228                 " " + c.name + " " + cliCommand
 229         c.Suite().log(containerExecCommand)
 230         byteOutput, err := exechelper.CombinedOutput(containerExecCommand)
 231         c.Suite().assertNil(err)
 232         return string(byteOutput)
 233 }
 234
 235 func (c *Container) stop() error {
 236         if c.vppInstance != nil && c.vppInstance.apiChannel != nil {
 237                 c.vppInstance.disconnect()
 238         }
 239         c.vppInstance = nil
 240         return exechelper.Run("docker stop " + c.name + " -t 0")
 241 }