}
if _, ok := yamlInput["volumes"]; ok {
- workingVolumeDir := logDir + CurrentSpecReport().LeafNodeText + volumeDir
+ workingVolumeDir := logDir + suite.getCurrentTestName() + volumeDir
workDirReplacer := strings.NewReplacer("$HST_DIR", workDir)
volDirReplacer := strings.NewReplacer("$HST_VOLUME_DIR", workingVolumeDir)
for _, volu := range yamlInput["volumes"].([]interface{}) {
}
func (c *Container) getContainerArguments() string {
- args := "--ulimit nofile=90000:90000 --cap-add=all --privileged --network host --rm"
+ args := "--ulimit nofile=90000:90000 --cap-add=all --privileged --network host"
+ c.allocateCpus()
+ args += fmt.Sprintf(" --cpuset-cpus=\"%d-%d\"", c.allocatedCpus[0], c.allocatedCpus[len(c.allocatedCpus)-1])
args += c.getVolumesAsCliOption()
args += c.getEnvVarsAsCliOption()
if *vppSourceFileDir != "" {
cmd := "docker run "
if c.runDetached {
- cmd += " -dt"
+ cmd += " -d"
}
- c.allocateCpus()
- cmd += fmt.Sprintf(" --cpuset-cpus=\"%d-%d\"", c.allocatedCpus[0], c.allocatedCpus[len(c.allocatedCpus)-1])
cmd += " " + c.getContainerArguments()
c.suite.log(cmd)
}
func (c *Container) createFile(destFileName string, content string) error {
- f, err := os.CreateTemp("/tmp", "hst-config"+c.suite.pid)
+ f, err := os.CreateTemp("/tmp", "hst-config"+c.suite.ppid)
if err != nil {
return err
}
func (c *Container) getLogDirPath() string {
testId := c.suite.getTestId()
- testName := CurrentSpecReport().LeafNodeText
+ testName := c.suite.getCurrentTestName()
logDirPath := logDir + testName + "/" + testId + "/"
cmd := exec.Command("mkdir", "-p", logDirPath)
}
func (c *Container) saveLogs() {
- cmd := exec.Command("docker", "inspect", "--format='{{.State.Status}}'", c.name)
- if output, _ := cmd.CombinedOutput(); !strings.Contains(string(output), "running") {
- return
- }
-
testLogFilePath := c.getLogDirPath() + "container-" + c.name + ".log"
- cmd = exec.Command("docker", "logs", "--details", "-t", c.name)
+ cmd := exec.Command("docker", "logs", "--details", "-t", c.name)
+ c.suite.log(cmd)
output, err := cmd.CombinedOutput()
if err != nil {
- Fail("fetching logs error: " + fmt.Sprint(err))
+ c.suite.log(err)
}
f, err := os.Create(testLogFilePath)
}
c.vppInstance = nil
c.saveLogs()
+ c.suite.log("docker stop " + c.name + " -t 0")
return exechelper.Run("docker stop " + c.name + " -t 0")
}
cpuAllocator *CpuAllocatorT
cpuContexts []*CpuContext
cpuPerVpp int
- pid string
+ ppid string
+ processIndex string
logger *log.Logger
logFile *os.File
}
Fail(message, callerSkip...)
})
var err error
- s.pid = fmt.Sprint(os.Getpid())
+ s.ppid = fmt.Sprint(os.Getppid())
+ // remove last number so we have space to prepend a process index (interfaces have a char limit)
+ s.ppid = s.ppid[:len(s.ppid)-1]
+ s.processIndex = fmt.Sprint(GinkgoParallelProcess())
s.cpuAllocator, err = CpuAllocator()
if err != nil {
Fail("failed to init cpu allocator: " + fmt.Sprint(err))
}
func (s *HstSuite) createLogger() {
- suiteName := CurrentSpecReport().ContainerHierarchyTexts[0]
+ suiteName := s.getCurrentSuiteName()
var err error
s.logFile, err = os.Create("summary/" + suiteName + ".log")
if err != nil {
}
func (s *HstSuite) resetContainers() {
- for _, container := range s.containers {
+ for _, container := range s.startedContainers {
container.stop()
+ exechelper.Run("docker rm " + container.name)
}
}
}
func (s *HstSuite) getNetNamespaceByName(name string) string {
- return name + s.pid
+ return s.processIndex + name + s.ppid
}
func (s *HstSuite) getInterfaceByName(name string) *NetInterface {
- return s.netInterfaces[name+s.pid]
+ return s.netInterfaces[s.processIndex+name+s.ppid]
}
func (s *HstSuite) getContainerByName(name string) *Container {
- return s.containers[name+s.pid]
+ return s.containers[s.processIndex+name+s.ppid]
}
/*
* are not able to modify the original container and affect other tests by doing that
*/
func (s *HstSuite) getTransientContainerByName(name string) *Container {
- containerCopy := *s.containers[name+s.pid]
+ containerCopy := *s.containers[s.processIndex+name+s.ppid]
return &containerCopy
}
for _, elem := range yamlTopo.Volumes {
volumeMap := elem["volume"].(VolumeConfig)
hostDir := volumeMap["host-dir"].(string)
- workingVolumeDir := logDir + CurrentSpecReport().LeafNodeText + volumeDir
+ workingVolumeDir := logDir + s.getCurrentTestName() + volumeDir
volDirReplacer := strings.NewReplacer("$HST_VOLUME_DIR", workingVolumeDir)
hostDir = volDirReplacer.Replace(hostDir)
s.volumes = append(s.volumes, hostDir)
for _, elem := range yamlTopo.Containers {
newContainer, err := newContainer(s, elem)
newContainer.suite = s
- newContainer.name += newContainer.suite.pid
+ newContainer.name = newContainer.suite.processIndex + newContainer.name + newContainer.suite.ppid
if err != nil {
Fail("container config error: " + fmt.Sprint(err))
}
for _, elem := range yamlTopo.Devices {
if _, ok := elem["name"]; ok {
- elem["name"] = elem["name"].(string) + s.pid
+ elem["name"] = s.processIndex + elem["name"].(string) + s.ppid
}
if peer, ok := elem["peer"].(NetDevConfig); ok {
if peer["name"].(string) != "" {
- peer["name"] = peer["name"].(string) + s.pid
+ peer["name"] = s.processIndex + peer["name"].(string) + s.ppid
}
if _, ok := peer["netns"]; ok {
- peer["netns"] = peer["netns"].(string) + s.pid
+ peer["netns"] = s.processIndex + peer["netns"].(string) + s.ppid
}
}
if _, ok := elem["netns"]; ok {
- elem["netns"] = elem["netns"].(string) + s.pid
+ elem["netns"] = s.processIndex + elem["netns"].(string) + s.ppid
}
if _, ok := elem["interfaces"]; ok {
interfaceCount := len(elem["interfaces"].([]interface{}))
for i := 0; i < interfaceCount; i++ {
- elem["interfaces"].([]interface{})[i] = elem["interfaces"].([]interface{})[i].(string) + s.pid
+ elem["interfaces"].([]interface{})[i] = s.processIndex + elem["interfaces"].([]interface{})[i].(string) + s.ppid
}
}
}
func (s *HstSuite) getTestId() string {
- testName := CurrentSpecReport().LeafNodeText
+ testName := s.getCurrentTestName()
if s.testIds == nil {
s.testIds = map[string]string{}
return s.testIds[testName]
}
-// Returns last 4 digits of PID
-func (s *HstSuite) getPortFromPid() string {
- port := s.pid
- for len(port) < 4 {
+func (s *HstSuite) getCurrentTestName() string {
+ return strings.Split(CurrentSpecReport().LeafNodeText, "/")[1]
+}
+
+func (s *HstSuite) getCurrentSuiteName() string {
+ return CurrentSpecReport().ContainerHierarchyTexts[0]
+}
+
+// Returns last 3 digits of PID + Ginkgo process index as the 4th digit
+func (s *HstSuite) getPortFromPpid() string {
+ port := s.ppid
+ for len(port) < 3 {
port += "0"
}
- return port[len(port)-4:]
+ return port[len(port)-3:] + s.processIndex
}
func (s *HstSuite) startServerApp(running chan error, done chan struct{}, env []string) {
- cmd := exec.Command("iperf3", "-4", "-s", "-p", s.getPortFromPid())
+ cmd := exec.Command("iperf3", "-4", "-s", "-p", s.getPortFromPpid())
if env != nil {
cmd.Env = env
}
nTries := 0
for {
- cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g", "-p", s.getPortFromPid())
+ cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g", "-p", s.getPortFromPpid())
if env != nil {
cmd.Env = env
}
}
func (s *HstSuite) startHttpServer(running chan struct{}, done chan struct{}, addressPort, netNs string) {
- cmd := newCommand([]string{"./http_server", addressPort, s.pid}, netNs)
+ cmd := newCommand([]string{"./http_server", addressPort, s.ppid, s.processIndex}, netNs)
err := cmd.Start()
s.log(cmd)
if err != nil {
}
func testProxyHttpTcp(s *NsSuite, proto string) error {
- var outputFile string = "test" + s.pid + ".data"
- var srcFilePid string = "httpTestFile" + s.pid
- const srcFileNoPid = "httpTestFile"
+ var outputFile string = s.processIndex + "test" + s.ppid + ".data"
+ var srcFilePpid string = s.processIndex + "httpTestFile" + s.ppid
+ const srcFileNoPpid = "httpTestFile"
const fileSize string = "10M"
stopServer := make(chan struct{}, 1)
serverRunning := make(chan struct{}, 1)
clientNetns := s.getNetNamespaceByName("cln")
// create test file
- err := exechelper.Run(fmt.Sprintf("ip netns exec %s truncate -s %s %s", serverNetns, fileSize, srcFilePid))
+ err := exechelper.Run(fmt.Sprintf("ip netns exec %s truncate -s %s %s", serverNetns, fileSize, srcFilePpid))
s.assertNil(err, "failed to run truncate command: "+fmt.Sprint(err))
- defer func() { os.Remove(srcFilePid) }()
+ defer func() { os.Remove(srcFilePpid) }()
s.log("test file created...")
if proto == "tls" {
c += " --secure-protocol=TLSv1_3 --no-check-certificate https://"
}
- c += fmt.Sprintf("%s:555/%s", clientVeth.ip4AddressString(), srcFileNoPid)
+ c += fmt.Sprintf("%s:555/%s", clientVeth.ip4AddressString(), srcFileNoPpid)
s.log(c)
_, err = exechelper.CombinedOutput(c)
s.assertNil(err, "failed to run wget: '%s', cmd: %s", err, c)
stopServer <- struct{}{}
- s.assertNil(assertFileSize(outputFile, srcFilePid))
+ s.assertNil(assertFileSize(outputFile, srcFilePpid))
return nil
}
Code Review / vpp.git / commitdiff