c.suite.T().Helper()
c.suite.log(containerExecCommand)
byteOutput, err := exechelper.CombinedOutput(containerExecCommand)
- c.suite.assertNil(err)
+ c.suite.assertNil(err, err)
return string(byteOutput)
}
f.Close()
}
-func (c *Container) log() string {
- cmd := "docker logs " + c.name
+// Outputs logs from docker containers. Set 'maxLines' to 0 to output the full log.
+func (c *Container) log(maxLines int) (string, error) {
+ var cmd string
+ if maxLines == 0 {
+ cmd = "docker logs " + c.name
+ } else {
+ cmd = fmt.Sprintf("docker logs --tail %d %s", maxLines, c.name)
+ }
+
c.suite.log(cmd)
o, err := exechelper.CombinedOutput(cmd)
- c.suite.assertNil(err)
- return string(o)
+ return string(o), err
}
func (c *Container) stop() error {
template := template.Must(template.ParseFiles(templateName))
f, err := os.CreateTemp(logDir, "hst-config")
- c.suite.assertNil(err)
+ c.suite.assertNil(err, err)
defer os.Remove(f.Name())
err = template.Execute(f, values)
- c.suite.assertNil(err)
+ c.suite.assertNil(err, err)
err = f.Close()
- c.suite.assertNil(err)
+ c.suite.assertNil(err, err)
c.copy(f.Name(), targetConfigName)
}
serverVeth.ip4AddressString())
s.log(output)
s.assertNotEqual(len(output), 0)
- s.assertNotContains(output, "failed: timeout")
+ s.assertNotContains(output, "failed: timeout", output)
}
package main
import (
+ "bufio"
"errors"
"flag"
"fmt"
}
}
+func logVppInstance(container *Container, maxLines int){
+ if container.vppInstance == nil{
+ return
+ }
+
+ logSource := container.getHostWorkDir() + defaultLogFilePath
+ file, err := os.Open(logSource)
+
+ if err != nil{
+ return
+ }
+ defer file.Close()
+
+ scanner := bufio.NewScanner(file)
+ var lines []string
+ var counter int
+
+ for scanner.Scan(){
+ lines = append(lines, scanner.Text())
+ counter++
+ if counter > maxLines {
+ lines = lines[1:]
+ counter--
+ }
+ }
+
+ fmt.Println("vvvvvvvvvvvvvvv " + container.name + " [VPP instance]:")
+ for _, line := range lines{
+ fmt.Println(line)
+ }
+ fmt.Printf("^^^^^^^^^^^^^^^\n\n")
+
+}
+
func (s *HstSuite) hstFail() {
+ fmt.Println("Containers: " + fmt.Sprint(s.containers))
+ for _, container := range s.containers{
+ out, err := container.log(20)
+ if err != nil{
+ fmt.Printf("An error occured while obtaining '%s' container logs: %s\n", container.name, fmt.Sprint(err))
+ break
+ }
+ fmt.Printf("\nvvvvvvvvvvvvvvv " +
+ container.name + ":\n" +
+ out +
+ "^^^^^^^^^^^^^^^\n\n")
+ logVppInstance(container, 20)
+ }
s.T().FailNow()
}
err := cmd.Start()
s.log(cmd)
if err != nil {
- fmt.Println("Failed to start http server")
+ fmt.Println("Failed to start http server: " + fmt.Sprint(err))
return
}
running <- struct{}{}
go s.startWget(finished, client_ip, port, "test_file_10M", "client")
// wait for client
err := <-finished
- s.assertNil(err)
+ s.assertNil(err, err)
}
func (s *VethsSuite) TestHttpCli() {
args := fmt.Sprintf("curl --noproxy '*' --local-port 55444 --http3-only -k https://%s:8443/%s", serverAddress, query)
curlCont.extraRunningArgs = args
o, err := curlCont.combinedOutput()
- s.assertNil(err)
+ s.assertNil(err, err)
s.assertContains(o, "<http>", "<http> not found in the result!")
}
s.log(vpp.vppctl("prom enable"))
go s.startWget(finished, serverAddress, "80", query, "")
err := <-finished
- s.assertNil(err)
+ s.assertNil(err, err)
}
func (s *NoTopoSuite) TestNginxAsServer() {
o, err := abCont.combinedOutput()
rps := parseString(o, "Requests per second:")
s.log(rps, err)
- s.assertNil(err)
+ s.assertNil(err, "err: '%s', output: '%s'", err, o)
} else {
wrkCont := s.getContainerByName("wrk")
args := fmt.Sprintf("-c %d -t 2 -d 30 http://%s:80/64B.json", nClients,
o, err := wrkCont.combinedOutput()
rps := parseString(o, "requests")
s.log(rps, err)
- s.assertNil(err)
+ s.assertNil(err, "err: '%s', output: '%s'", err, o)
}
return nil
}
append("use-mq-eventfd").
append(clientAppSocketApi).close().
saveToFile(clientVclFileName)
- s.assertNil(err)
+ s.assertNil(err, err)
serverAppSocketApi := fmt.Sprintf("app-socket-api %s/var/run/app_ns_sockets/default",
serverContainer.getHostWorkDir())
append("use-mq-eventfd").
append(serverAppSocketApi).close().
saveToFile(serverVclFileName)
- s.assertNil(err)
+ s.assertNil(err, err)
s.log("attaching server to vpp")
go s.startServerApp(srvCh, stopServerCh, srvEnv)
err = <-srvCh
- s.assertNil(err)
+ s.assertNil(err, err)
s.log("attaching client to vpp")
var clnRes = make(chan string, 1)
// wait for client's result
err = <-clnCh
- s.assertNil(err)
+ s.assertNil(err, err)
// stop server
stopServerCh <- struct{}{}
go s.startServerApp(srvCh, stopServerCh, nil)
err := <-srvCh
- s.assertNil(err)
+ s.assertNil(err, err)
s.log("server running")
ipAddress := s.netInterfaces[tapInterfaceName].ip4AddressString()
s.log("client running")
s.log(<-clnRes)
err = <-clnCh
- s.assertNil(err)
+ s.assertNil(err, "err: '%s', ip: '%s'", err, ipAddress)
s.log("Test completed")
}
cmd := appendNetns(c, ns)
err := cmd.Run()
if err != nil {
- s := fmt.Sprintf("error bringing %s device %s!", dev, op)
- return errors.New(s)
+ return fmt.Errorf("error bringing %s device %s! (cmd: '%s')", dev, op, cmd)
}
return nil
}
cmd := exec.Command("ip", "netns", op, name)
_, err := cmd.CombinedOutput()
if err != nil {
- return errors.New("add/del netns failed")
+ return fmt.Errorf("add/del netns failed (cmd: '%s')", cmd)
}
return nil
}
cmd := appendNetns(c, ns)
err := cmd.Run()
if err != nil {
- s := fmt.Sprintf("%s %s failed!", op, brName)
+ s := fmt.Sprintf("%s %s failed! err: '%s'", op, brName, err)
return errors.New(s)
}
return nil
cmd := appendNetns(c, ns)
err = cmd.Run()
if err != nil {
- s := fmt.Sprintf("error adding %s to bridge %s: %v", v, brName, err)
- return errors.New(s)
+ return fmt.Errorf("error adding %s to bridge %s: %s", v, brName, err)
}
}
err = setDevUp(brName, ns)
// create test file
err := exechelper.Run(fmt.Sprintf("ip netns exec server truncate -s %s %s", srcFile, srcFile))
- s.assertNil(err, "failed to run truncate command")
+ s.assertNil(err, "failed to run truncate command: " + fmt.Sprint(err))
defer func() { os.Remove(srcFile) }()
s.log("test file created...")
c += fmt.Sprintf("%s:555/%s", clientVeth.ip4AddressString(), srcFile)
s.log(c)
_, err = exechelper.CombinedOutput(c)
- s.assertNil(err, "failed to run wget")
+ s.assertNil(err, "failed to run wget: '%s', cmd: %s", err, c)
stopServer <- struct{}{}
defer func() { os.Remove(outputFile) }()
proto := "tcp"
configureVppProxy(s, proto)
err := testProxyHttpTcp(s, proto)
- s.assertNil(err)
+ s.assertNil(err, err)
}
func (s *NsSuite) TestVppProxyHttpTls() {
proto := "tls"
configureVppProxy(s, proto)
err := testProxyHttpTcp(s, proto)
- s.assertNil(err)
+ s.assertNil(err, err)
}
func configureEnvoyProxy(s *NsSuite) {
envoyContainer := s.getContainerByName("envoy")
- envoyContainer.create()
+ err := envoyContainer.create()
+ s.assertNil(err, "Error creating envoy container: %s", err)
serverVeth := s.netInterfaces[serverInterface]
address := struct {
func (s *NsSuite) TestEnvoyProxyHttpTcp() {
configureEnvoyProxy(s)
err := testProxyHttpTcp(s, "tcp")
- s.assertNil(err)
+ s.assertNil(err, err)
}
s.assertNil(vpp.start())
idx, err := vpp.createAfPacket(s.netInterfaces[serverInterface])
- s.assertNil(err)
+ s.assertNil(err, err)
s.assertNotEqual(0, idx)
idx, err = vpp.createAfPacket(s.netInterfaces[clientInterface])
- s.assertNil(err)
+ s.assertNil(err, err)
s.assertNotEqual(0, idx)
container.exec("chmod 777 -R %s", container.getContainerWorkDir())
serverContainer := s.getContainerByName("server-vpp")
cpus := s.AllocateCpus()
- serverVpp, _ := serverContainer.newVppInstance(cpus, sessionConfig)
- s.assertNotNil(serverVpp)
+ serverVpp, err := serverContainer.newVppInstance(cpus, sessionConfig)
+ s.assertNotNil(serverVpp, err)
s.setupServerVpp()
clientContainer := s.getContainerByName("client-vpp")
cpus = s.AllocateCpus()
- clientVpp, _ := clientContainer.newVppInstance(cpus, sessionConfig)
- s.assertNotNil(clientVpp)
+ clientVpp, err := clientContainer.newVppInstance(cpus, sessionConfig)
+ s.assertNotNil(clientVpp, err)
s.setupClientVpp()
}
serverVeth := s.netInterfaces[serverInterfaceName]
idx, err := serverVpp.createAfPacket(serverVeth)
- s.assertNil(err)
+ s.assertNil(err, err)
s.assertNotEqual(0, idx)
}
clientVeth := s.netInterfaces[clientInterfaceName]
idx, err := clientVpp.createAfPacket(clientVeth)
- s.assertNil(err)
+ s.assertNil(err, err)
s.assertNotEqual(0, idx)
}