package main
-import "fmt"
+import (
+ "errors"
+ "fmt"
+ "os"
+ "strings"
+
+ "github.com/edwarnicke/exechelper"
+)
type AddressCounter = int
type Ip4AddressAllocator struct {
networks map[int]AddressCounter
+ chosenOctet int
+ assignedIps []string
}
func (a *Ip4AddressAllocator) AddNetwork(networkNumber int) {
return "", fmt.Errorf("no available IPv4 addresses")
}
- address := fmt.Sprintf("10.10.%v.%v/24", networkNumber, numberOfAddresses)
+ address, err := a.createIpAddress(networkNumber, numberOfAddresses)
+
a.networks[networkNumber] = numberOfAddresses + 1
+ return address + "/24", err
+}
+
+// Creates a file every time an IP is assigned: used to keep track of addresses in use.
+// If an address is not in use, 'counter' is then copied to 'chosenOctet' and it is used for the remaining tests.
+// Also checks host IP addresses.
+func (a *Ip4AddressAllocator) createIpAddress(networkNumber int, numberOfAddresses int) (string, error){
+ hostIps, _ := exechelper.CombinedOutput("ip a")
+ counter := 10
+ var address string
+
+ for {
+ if a.chosenOctet != 0 {
+ address = fmt.Sprintf("10.%v.%v.%v", a.chosenOctet, networkNumber, numberOfAddresses)
+ file, err := os.Create(address)
+ if err != nil{
+ return "", errors.New("unable to create file: " + fmt.Sprint(err))
+ }
+ file.Close()
+ break
+ } else {
+ address = fmt.Sprintf("10.%v.%v.%v", counter, networkNumber, numberOfAddresses)
+ _, err := os.Stat(address)
+ if err == nil || strings.Contains(string(hostIps), address) {
+ counter++
+ } else if os.IsNotExist(err) {
+ file, err := os.Create(address)
+ if err != nil{
+ return "", errors.New("unable to create file: " + fmt.Sprint(err))
+ }
+ file.Close()
+ a.chosenOctet = counter
+ break
+ } else {
+ return "", errors.New("an error occured while checking if a file exists: " + fmt.Sprint(err))
+ }
+ }
+ }
+
+ a.assignedIps = append(a.assignedIps, address)
return address, nil
}
+func (a *Ip4AddressAllocator) deleteIpAddresses(){
+ for ip := range a.assignedIps{
+ os.Remove(a.assignedIps[ip])
+ }
+}
+
func NewIp4AddressAllocator() *Ip4AddressAllocator {
var ip4AddrAllocator = new(Ip4AddressAllocator)
ip4AddrAllocator.networks = make(map[int]AddressCounter)
vppInstance *VppInstance
}
-func newContainer(suite *HstSuite, yamlInput ContainerConfig) (*Container, error) {
+func newContainer(suite *HstSuite, yamlInput ContainerConfig, pid string) (*Container, error) {
containerName := yamlInput["name"].(string)
if len(containerName) == 0 {
err := fmt.Errorf("container name must not be blank")
var container = new(Container)
container.volumes = make(map[string]Volume)
container.envVars = make(map[string]string)
- container.name = containerName
+ container.name = containerName + pid
container.suite = suite
if image, ok := yamlInput["image"]; ok {
}
if _, ok := yamlInput["volumes"]; ok {
- workingVolumeDir := logDir + container.suite.T().Name() + volumeDir
+ workingVolumeDir := logDir + container.suite.T().Name() + pid + volumeDir
workDirReplacer := strings.NewReplacer("$HST_DIR", workDir)
volDirReplacer := strings.NewReplacer("$HST_VOLUME_DIR", workingVolumeDir)
for _, volu := range yamlInput["volumes"].([]interface{}) {
}
func (c *Container) createFile(destFileName string, content string) error {
- f, err := os.CreateTemp("/tmp", "hst-config")
+ f, err := os.CreateTemp("/tmp", "hst-config" + c.suite.pid)
if err != nil {
return err
}
func (s *VethsSuite) TestEchoBuiltin() {
serverVpp := s.getContainerByName("server-vpp").vppInstance
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVpp.vppctl("test echo server " +
" uri tcp://" + serverVeth.ip4AddressString() + "/1234")
func (s *VethsSuite) TestTcpWithLoss() {
serverVpp := s.getContainerByName("server-vpp").vppInstance
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVpp.vppctl("test echo server uri tcp://%s/20022",
serverVeth.ip4AddressString())
clientVpp.vppctl("set nsim poll-main-thread delay 0.01 ms bandwidth 40 gbit" +
" packet-size 1400 packets-per-drop 1000")
- clientVpp.vppctl("nsim output-feature enable-disable " + s.netInterfaces[clientInterfaceName].name)
+ clientVpp.vppctl("nsim output-feature enable-disable " + s.getInterfaceByName(clientInterfaceName).name)
// Do echo test from client-vpp container
output := clientVpp.vppctl("test echo client uri tcp://%s/20022 verbose echo-bytes mbytes 50",
cpuAllocator *CpuAllocatorT
cpuContexts []*CpuContext
cpuPerVpp int
+ pid string
}
func (s *HstSuite) SetupSuite() {
var err error
+ s.pid = fmt.Sprint(os.Getpid())
s.cpuAllocator, err = CpuAllocator()
if err != nil {
s.FailNow("failed to init cpu allocator: %v", err)
}
s.resetContainers()
s.removeVolumes()
+ s.ip4AddrAllocator.deleteIpAddresses()
}
func (s *HstSuite) skipIfUnconfiguring() {
fmt.Println(line)
}
fmt.Printf("^^^^^^^^^^^^^^^\n\n")
-
}
func (s *HstSuite) hstFail() {
}
}
+func (s *HstSuite) getNetNamespaceByName(name string) string {
+ return name + s.pid
+}
+
+func (s *HstSuite) getInterfaceByName(name string) *NetInterface {
+ return s.netInterfaces[name + s.pid]
+}
+
func (s *HstSuite) getContainerByName(name string) *Container {
- return s.containers[name]
+ return s.containers[name + s.pid]
}
/*
* 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]
+ containerCopy := *s.containers[name + s.pid]
return &containerCopy
}
for _, elem := range yamlTopo.Volumes {
volumeMap := elem["volume"].(VolumeConfig)
hostDir := volumeMap["host-dir"].(string)
- workingVolumeDir := logDir + s.T().Name() + volumeDir
+ workingVolumeDir := logDir + s.T().Name() + s.pid + volumeDir
volDirReplacer := strings.NewReplacer("$HST_VOLUME_DIR", workingVolumeDir)
hostDir = volDirReplacer.Replace(hostDir)
s.volumes = append(s.volumes, hostDir)
s.containers = make(map[string]*Container)
for _, elem := range yamlTopo.Containers {
- newContainer, err := newContainer(s, elem)
+ newContainer, err := newContainer(s, elem, s.pid)
+ newContainer.suite = s
if err != nil {
s.T().Fatalf("container config error: %v", err)
}
s.ip4AddrAllocator = NewIp4AddressAllocator()
s.netInterfaces = make(map[string]*NetInterface)
+
for _, elem := range yamlTopo.Devices {
+ if _, ok := elem["name"]; ok {
+ elem["name"] = elem["name"].(string) + s.pid
+ }
+
+ if peer, ok := elem["peer"].(NetDevConfig); ok {
+ if peer["name"].(string) != ""{
+ peer["name"] = peer["name"].(string) + s.pid
+ }
+ if _, ok := peer["netns"]; ok{
+ peer["netns"] = peer["netns"].(string) + s.pid
+ }
+ }
+
+ if _, ok := elem["netns"]; ok {
+ elem["netns"] = elem["netns"].(string) + s.pid
+ }
+
+ 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
+ }
+ }
+
switch elem["type"].(string) {
case NetNs:
{
return s.testIds[testName]
}
+// Returns last 4 digits of PID
+func (s *HstSuite) getPortFromPid() string {
+ port := s.pid
+ for len(port) < 4 {
+ port += "0"
+ }
+ return port[len(port)-4:]
+}
+
func (s *HstSuite) startServerApp(running chan error, done chan struct{}, env []string) {
- cmd := exec.Command("iperf3", "-4", "-s")
+ cmd := exec.Command("iperf3", "-4", "-s", "-p", s.getPortFromPid())
if env != nil {
cmd.Env = env
}
nTries := 0
for {
- cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g")
+ cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g", "-p", s.getPortFromPid())
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}, netNs)
+ cmd := newCommand([]string{"./http_server", addressPort, s.pid}, netNs)
err := cmd.Start()
s.log(cmd)
if err != nil {
)
func (s *NsSuite) TestHttpTps() {
- iface := s.netInterfaces[clientInterface]
+ iface := s.getInterfaceByName(clientInterface)
client_ip := iface.ip4AddressString()
port := "8080"
finished := make(chan error, 1)
- clientNetns := "cln"
+ clientNetns := s.getNetNamespaceByName("cln")
container := s.getContainerByName("vpp")
serverContainer := s.getContainerByName("server-vpp")
clientContainer := s.getContainerByName("client-vpp")
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverContainer.vppInstance.vppctl("http cli server")
vpp := s.getContainerByName("vpp").vppInstance
vpp.waitForApp("nginx-", 5)
- serverAddress := s.netInterfaces[tapInterfaceName].peer.ip4AddressString()
+ serverAddress := s.getInterfaceByName(tapInterfaceName).peer.ip4AddressString()
defer func() { os.Remove(query) }()
curlCont := s.getContainerByName("curl")
finished := make(chan error, 1)
query := "stats.prom"
vpp := s.getContainerByName("vpp").vppInstance
- serverAddress := s.netInterfaces[tapInterfaceName].peer.ip4AddressString()
+ serverAddress := s.getInterfaceByName(tapInterfaceName).peer.ip4AddressString()
s.log(vpp.vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
s.log(vpp.vppctl("prom enable"))
go s.startWget(finished, serverAddress, "80", query, "")
vpp := s.getContainerByName("vpp").vppInstance
vpp.waitForApp("nginx-", 5)
- serverAddress := s.netInterfaces[tapInterfaceName].peer.ip4AddressString()
+ serverAddress := s.getInterfaceByName(tapInterfaceName).peer.ip4AddressString()
defer func() { os.Remove(query) }()
go s.startWget(finished, serverAddress, "80", query, "")
nRequests := 1000000
nClients := 1000
- serverAddress := s.netInterfaces[tapInterfaceName].peer.ip4AddressString()
+ serverAddress := s.getInterfaceByName(tapInterfaceName).peer.ip4AddressString()
vpp := s.getContainerByName("vpp").vppInstance
s.log("attaching client to vpp")
var clnRes = make(chan string, 1)
clnEnv := append(os.Environ(), ldpreload, "VCL_CONFIG="+clientVclFileName)
- serverVethAddress := s.netInterfaces[serverInterfaceName].ip4AddressString()
+ serverVethAddress := s.getInterfaceByName(serverInterfaceName).ip4AddressString()
go s.startClientApp(serverVethAddress, clnEnv, clnCh, clnRes)
s.log(<-clnRes)
s.assertNil(err, err)
s.log("server running")
- ipAddress := s.netInterfaces[tapInterfaceName].ip4AddressString()
+ ipAddress := s.getInterfaceByName(tapInterfaceName).ip4AddressString()
go s.startClientApp(ipAddress, nil, clnCh, clnRes)
s.log("client running")
s.log(<-clnRes)
)
func (s *NginxSuite) TestMirroring() {
- proxyAddress := s.netInterfaces[mirroringClientInterfaceName].peer.ip4AddressString()
+ proxyAddress := s.getInterfaceByName(mirroringClientInterfaceName).peer.ip4AddressString()
path := "/64B.json"
)
func testProxyHttpTcp(s *NsSuite, proto string) error {
- const outputFile = "test.data"
- const srcFile = "httpTestFile"
- const fileSize = "10M"
+ var outputFile string = "test" + s.pid + ".data"
+ var srcFilePid string = "httpTestFile" + s.pid
+ const srcFileNoPid = "httpTestFile"
+ const fileSize string = "10M"
stopServer := make(chan struct{}, 1)
serverRunning := make(chan struct{}, 1)
- serverNetns := "srv"
- clientNetns := "cln"
+ serverNetns := s.getNetNamespaceByName("srv")
+ clientNetns := s.getNetNamespaceByName("cln")
// create test file
- err := exechelper.Run(fmt.Sprintf("ip netns exec %s truncate -s %s %s", serverNetns, fileSize, srcFile))
+ err := exechelper.Run(fmt.Sprintf("ip netns exec %s truncate -s %s %s", serverNetns, fileSize, srcFilePid))
s.assertNil(err, "failed to run truncate command: " + fmt.Sprint(err))
- defer func() { os.Remove(srcFile) }()
+ defer func() { os.Remove(srcFilePid) }()
s.log("test file created...")
s.log("http server started...")
- clientVeth := s.netInterfaces[clientInterface]
+ clientVeth := s.getInterfaceByName(clientInterface)
c := fmt.Sprintf("ip netns exec %s wget --no-proxy --retry-connrefused"+
" --retry-on-http-error=503 --tries=10 -O %s ", clientNetns, outputFile)
if proto == "tls" {
c += " --secure-protocol=TLSv1_3 --no-check-certificate https://"
}
- c += fmt.Sprintf("%s:555/%s", clientVeth.ip4AddressString(), srcFile)
+ c += fmt.Sprintf("%s:555/%s", clientVeth.ip4AddressString(), srcFileNoPid)
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, srcFile))
+ s.assertNil(assertFileSize(outputFile, srcFilePid))
return nil
}
func configureVppProxy(s *NsSuite, proto string) {
- serverVeth := s.netInterfaces[serverInterface]
- clientVeth := s.netInterfaces[clientInterface]
+ serverVeth := s.getInterfaceByName(serverInterface)
+ clientVeth := s.getInterfaceByName(clientInterface)
testVppProxy := s.getContainerByName("vpp").vppInstance
output := testVppProxy.vppctl(
err := envoyContainer.create()
s.assertNil(err, "Error creating envoy container: %s", err)
- serverVeth := s.netInterfaces[serverInterface]
+ serverVeth := s.getInterfaceByName(serverInterface)
address := struct {
Server string
}{
}
func (s *VethsSuite) testVppEcho(proto string) {
- serverVethAddress := s.netInterfaces[serverInterfaceName].ip4AddressString()
+ serverVethAddress := s.getInterfaceByName(serverInterfaceName).ip4AddressString()
uri := proto + "://" + serverVethAddress + "/12344"
echoSrvContainer := s.getContainerByName("server-app")
package main
+// These correspond to names used in yaml config
const (
- // These correspond to names used in yaml config
- mirroringClientInterfaceName = "hstcln"
- mirroringServerInterfaceName = "hstsrv"
vppProxyContainerName = "vpp-proxy"
nginxProxyContainerName = "nginx-proxy"
nginxServerContainerName = "nginx-server"
+ mirroringClientInterfaceName = "hstcln"
+ mirroringServerInterfaceName = "hstsrv"
)
type NginxSuite struct {
proxyVpp, _ := vppProxyContainer.newVppInstance(cpus, sessionConfig)
s.assertNil(proxyVpp.start())
- clientInterface := s.netInterfaces[mirroringClientInterfaceName]
+ clientInterface := s.getInterfaceByName(mirroringClientInterfaceName)
s.assertNil(proxyVpp.createTap(clientInterface, 1))
- serverInterface := s.netInterfaces[mirroringServerInterfaceName]
+ serverInterface := s.getInterfaceByName(mirroringServerInterfaceName)
s.assertNil(proxyVpp.createTap(serverInterface, 2))
nginxContainer := s.getTransientContainerByName(nginxProxyContainerName)
package main
const (
- singleTopoContainerVpp = "vpp"
- singleTopoContainerNginx = "nginx"
- tapInterfaceName = "htaphost"
+ singleTopoContainerVpp = "vpp"
+ singleTopoContainerNginx = "nginx"
+ tapInterfaceName = "htaphost"
)
type NoTopoSuite struct {
vpp, _ := container.newVppInstance(cpus, sessionConfig)
s.assertNil(vpp.start())
- tapInterface := s.netInterfaces[tapInterfaceName]
+ tapInterface := s.getInterfaceByName(tapInterfaceName)
s.assertNil(vpp.createTap(tapInterface), "failed to create tap interface")
}
package main
+// These correspond to names used in yaml config
const (
- // These correspond to names used in yaml config
clientInterface = "hclnvpp"
serverInterface = "hsrvvpp"
)
vpp, _ := container.newVppInstance(cpus, sessionConfig)
s.assertNil(vpp.start())
- idx, err := vpp.createAfPacket(s.netInterfaces[serverInterface])
+ idx, err := vpp.createAfPacket(s.getInterfaceByName(serverInterface))
s.assertNil(err, err)
s.assertNotEqual(0, idx)
- idx, err = vpp.createAfPacket(s.netInterfaces[clientInterface])
+ idx, err = vpp.createAfPacket(s.getInterfaceByName(clientInterface))
s.assertNil(err, err)
s.assertNotEqual(0, idx)
"time"
)
+// These correspond to names used in yaml config
const (
- // These correspond to names used in yaml config
serverInterfaceName = "srv"
clientInterfaceName = "cln"
)
s.HstSuite.SetupTest()
// Setup test conditions
-
var sessionConfig Stanza
sessionConfig.
newStanza("session").
serverVpp := s.getContainerByName("server-vpp").vppInstance
s.assertNil(serverVpp.start())
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
idx, err := serverVpp.createAfPacket(serverVeth)
s.assertNil(err, err)
s.assertNotEqual(0, idx)
clientVpp := s.getContainerByName("client-vpp").vppInstance
s.assertNil(clientVpp.start())
- clientVeth := s.netInterfaces[clientInterfaceName]
+ clientVeth := s.getInterfaceByName(clientInterfaceName)
idx, err := clientVpp.createAfPacket(clientVeth)
s.assertNil(err, err)
s.assertNotEqual(0, idx)
)
func main() {
- if len(os.Args) < 2 {
+ if len(os.Args) < 3 {
fmt.Println("arg expected")
os.Exit(1)
}
http.HandleFunc("/httpTestFile", func(w http.ResponseWriter, r *http.Request) {
- file, _ := os.Open("httpTestFile")
+ file, _ := os.Open("httpTestFile" + os.Args[2])
defer file.Close()
io.Copy(w, file)
})
port := "12345"
serverVpp := s.getContainerByName("server-vpp").vppInstance
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVpp.vppctl("test echo server uri %s://%s/%s fifo-size 64k", proto, serverVeth.ip4AddressString(), port)
echoClnContainer := s.getTransientContainerByName("client-app")
vclSrvCmd := fmt.Sprintf("vcl_test_server -p %s %s", proto, port)
srvAppCont.execServer(vclSrvCmd)
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVethAddress := serverVeth.ip4AddressString()
clientVpp := s.getContainerByName("client-vpp").vppInstance
srvAppCont.addEnvVar("VCL_CONFIG", "/vcl.conf")
srvAppCont.execServer("vcl_test_server " + port)
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVethAddress := serverVeth.ip4AddressString()
echoClnContainer := s.getTransientContainerByName("client-app")
s.log("This whole test case can take around 3 minutes to run. Please be patient.")
s.log("... Running first echo client test, before disconnect.")
- serverVeth := s.netInterfaces[serverInterfaceName]
+ serverVeth := s.getInterfaceByName(serverInterfaceName)
serverVethAddress := serverVeth.ip4AddressString()
echoClnContainer := s.getTransientContainerByName("client-app")
Code Review / vpp.git / commitdiff