package main
import (
+ "errors"
+ "flag"
"fmt"
- "io/ioutil"
"os"
+ "os/exec"
+ "strings"
+ "time"
"github.com/edwarnicke/exechelper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
- "go.fd.io/govpp/binapi/ip_types"
"gopkg.in/yaml.v3"
)
-func IsPersistent() bool {
- return os.Getenv("HST_PERSIST") == "1"
-}
+const (
+ DEFAULT_NETWORK_NUM int = 1
+)
-func IsVerbose() bool {
- return os.Getenv("HST_VERBOSE") == "1"
-}
+var isPersistent = flag.Bool("persist", false, "persists topology config")
+var isVerbose = flag.Bool("verbose", false, "verbose test output")
+var isUnconfiguring = flag.Bool("unconfigure", false, "remove topology")
+var isVppDebug = flag.Bool("debug", false, "attach gdb to vpp")
+var nConfiguredCpus = flag.Int("cpus", 1, "number of CPUs assigned to vpp")
+var vppSourceFileDir = flag.String("vppsrc", "", "vpp source file directory")
type HstSuite struct {
suite.Suite
- teardownSuite func()
- containers map[string]*Container
- volumes []string
- networkNamespaces map[string]*NetworkNamespace
- veths map[string]*NetworkInterfaceVeth
- taps map[string]*NetworkInterfaceTap
- bridges map[string]*NetworkBridge
- numberOfAddresses int
+ containers map[string]*Container
+ volumes []string
+ netConfigs []NetConfig
+ netInterfaces map[string]*NetInterface
+ ip4AddrAllocator *Ip4AddressAllocator
+ testIds map[string]string
+ cpuAllocator *CpuAllocatorT
+ cpuContexts []*CpuContext
+ cpuPerVpp int
}
-func (s *HstSuite) TearDownSuite() {
- if s.teardownSuite != nil {
- s.teardownSuite() // TODO remove this after config moved to SetupTest() for each suite
+func (s *HstSuite) SetupSuite() {
+ var err error
+ s.cpuAllocator, err = CpuAllocator()
+ if err != nil {
+ s.FailNow("failed to init cpu allocator: %v", err)
}
+ s.cpuPerVpp = *nConfiguredCpus
+}
+
+func (s *HstSuite) AllocateCpus() []int {
+ cpuCtx, err := s.cpuAllocator.Allocate(s.cpuPerVpp)
+ s.assertNil(err)
+ s.AddCpuContext(cpuCtx)
+ return cpuCtx.cpus
+}
+func (s *HstSuite) AddCpuContext(cpuCtx *CpuContext) {
+ s.cpuContexts = append(s.cpuContexts, cpuCtx)
+}
+
+func (s *HstSuite) TearDownSuite() {
s.unconfigureNetworkTopology()
}
func (s *HstSuite) TearDownTest() {
- if IsPersistent() {
+ if *isPersistent {
return
}
- s.ResetContainers()
- s.RemoveVolumes()
+ for _, c := range s.cpuContexts {
+ c.Release()
+ }
+ s.resetContainers()
+ s.removeVolumes()
+}
+
+func (s *HstSuite) skipIfUnconfiguring() {
+ if *isUnconfiguring {
+ s.skip("skipping to unconfigure")
+ }
}
func (s *HstSuite) SetupTest() {
- s.SetupVolumes()
- s.SetupContainers()
+ s.skipIfUnconfiguring()
+ s.setupVolumes()
+ s.setupContainers()
}
-func (s *HstSuite) SetupVolumes() {
+func (s *HstSuite) setupVolumes() {
for _, volume := range s.volumes {
cmd := "docker volume create --name=" + volume
s.log(cmd)
}
}
-func (s *HstSuite) SetupContainers() {
+func (s *HstSuite) setupContainers() {
for _, container := range s.containers {
- if container.isOptional == false {
+ if !container.isOptional {
container.run()
}
}
}
}
+func (s *HstSuite) assertNotEmpty(object interface{}, msgAndArgs ...interface{}) {
+ if !assert.NotEmpty(s.T(), object, msgAndArgs...) {
+ s.hstFail()
+ }
+}
+
func (s *HstSuite) log(args ...any) {
- if IsVerbose() {
+ if *isVerbose {
+ s.T().Helper()
s.T().Log(args...)
}
}
s.T().SkipNow()
}
-func (s *HstSuite) ResetContainers() {
+func (s *HstSuite) SkipIfMultiWorker(args ...any) {
+ if *nConfiguredCpus > 1 {
+ s.skip("test case not supported with multiple vpp workers")
+ }
+}
+
+func (s *HstSuite) SkipUnlessExtendedTestsBuilt() {
+ imageName := "hs-test/nginx-http3"
+
+ cmd := exec.Command("docker", "images", imageName)
+ byteOutput, err := cmd.CombinedOutput()
+ if err != nil {
+ s.log("error while searching for docker image")
+ return
+ }
+ if !strings.Contains(string(byteOutput), imageName) {
+ s.skip("extended tests not built")
+ }
+}
+
+func (s *HstSuite) resetContainers() {
for _, container := range s.containers {
container.stop()
}
}
-func (s *HstSuite) RemoveVolumes() {
+func (s *HstSuite) removeVolumes() {
for _, volumeName := range s.volumes {
cmd := "docker volume rm " + volumeName
exechelper.Run(cmd)
return s.containers[name]
}
-func (s *HstSuite) getContainerCopyByName(name string) *Container {
- // Create a copy and return its address, so that individial tests which call this
- // are not able to modify the original container and affect other tests by doing that
+/*
+ * Create a copy and return its address, so that individial tests which call this
+ * 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]
return &containerCopy
}
func (s *HstSuite) loadContainerTopology(topologyName string) {
- data, err := ioutil.ReadFile(ContainerTopologyDir + topologyName + ".yaml")
+ data, err := os.ReadFile(containerTopologyDir + topologyName + ".yaml")
if err != nil {
s.T().Fatalf("read error: %v", err)
}
for _, elem := range yamlTopo.Volumes {
volumeMap := elem["volume"].(VolumeConfig)
hostDir := volumeMap["host-dir"].(string)
+ workingVolumeDir := logDir + s.T().Name() + 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(elem)
- newContainer.suite = s
+ newContainer, err := newContainer(s, elem)
if err != nil {
s.T().Fatalf("container config error: %v", err)
}
- s.log(newContainer.getRunCommand())
s.containers[newContainer.name] = newContainer
}
}
func (s *HstSuite) loadNetworkTopology(topologyName string) {
- data, err := ioutil.ReadFile(NetworkTopologyDir + topologyName + ".yaml")
+ data, err := os.ReadFile(networkTopologyDir + topologyName + ".yaml")
if err != nil {
s.T().Fatalf("read error: %v", err)
}
s.T().Fatalf("unmarshal error: %v", err)
}
- s.networkNamespaces = make(map[string]*NetworkNamespace)
- s.veths = make(map[string]*NetworkInterfaceVeth)
- s.taps = make(map[string]*NetworkInterfaceTap)
- s.bridges = make(map[string]*NetworkBridge)
+ s.ip4AddrAllocator = NewIp4AddressAllocator()
+ s.netInterfaces = make(map[string]*NetInterface)
for _, elem := range yamlTopo.Devices {
switch elem["type"].(string) {
case NetNs:
{
- if namespace, err := NewNetNamespace(elem); err == nil {
- s.networkNamespaces[namespace.Name()] = &namespace
- } else {
- s.T().Fatalf("network config error: %v", err)
- }
- }
- case Veth:
- {
- if veth, err := NewVeth(elem); err == nil {
- s.veths[veth.Name()] = &veth
+ if namespace, err := newNetNamespace(elem); err == nil {
+ s.netConfigs = append(s.netConfigs, &namespace)
} else {
s.T().Fatalf("network config error: %v", err)
}
}
- case Tap:
+ case Veth, Tap:
{
- if tap, err := NewTap(elem); err == nil {
- s.taps[tap.Name()] = &tap
+ if netIf, err := newNetworkInterface(elem, s.ip4AddrAllocator); err == nil {
+ s.netConfigs = append(s.netConfigs, netIf)
+ s.netInterfaces[netIf.Name()] = netIf
} else {
s.T().Fatalf("network config error: %v", err)
}
}
case Bridge:
{
- if bridge, err := NewBridge(elem); err == nil {
- s.bridges[bridge.Name()] = &bridge
+ if bridge, err := newBridge(elem); err == nil {
+ s.netConfigs = append(s.netConfigs, &bridge)
} else {
s.T().Fatalf("network config error: %v", err)
}
func (s *HstSuite) configureNetworkTopology(topologyName string) {
s.loadNetworkTopology(topologyName)
- for _, ns := range s.networkNamespaces {
- if err := ns.Configure(); err != nil {
- s.T().Fatalf("network config error: %v", err)
- }
- }
- for _, veth := range s.veths {
- if err := veth.Configure(); err != nil {
- s.T().Fatalf("network config error: %v", err)
- }
- }
- for _, tap := range s.taps {
- if err := tap.Configure(); err != nil {
- s.T().Fatalf("network config error: %v", err)
- }
+ if *isUnconfiguring {
+ return
}
- for _, bridge := range s.bridges {
- if err := bridge.Configure(); err != nil {
+
+ for _, nc := range s.netConfigs {
+ if err := nc.configure(); err != nil {
s.T().Fatalf("network config error: %v", err)
}
}
}
func (s *HstSuite) unconfigureNetworkTopology() {
- if IsPersistent() {
+ if *isPersistent {
return
}
- for _, ns := range s.networkNamespaces {
- ns.Unconfigure()
+ for _, nc := range s.netConfigs {
+ nc.unconfigure()
}
- for _, veth := range s.veths {
- veth.Unconfigure()
+}
+
+func (s *HstSuite) getTestId() string {
+ testName := s.T().Name()
+
+ if s.testIds == nil {
+ s.testIds = map[string]string{}
}
- for _, tap := range s.taps {
- tap.Unconfigure()
+
+ if _, ok := s.testIds[testName]; !ok {
+ s.testIds[testName] = time.Now().Format("2006-01-02_15-04-05")
}
- for _, bridge := range s.bridges {
- bridge.Unconfigure()
+
+ return s.testIds[testName]
+}
+
+func (s *HstSuite) startServerApp(running chan error, done chan struct{}, env []string) {
+ cmd := exec.Command("iperf3", "-4", "-s")
+ if env != nil {
+ cmd.Env = env
}
+ s.log(cmd)
+ err := cmd.Start()
+ if err != nil {
+ msg := fmt.Errorf("failed to start iperf server: %v", err)
+ running <- msg
+ return
+ }
+ running <- nil
+ <-done
+ cmd.Process.Kill()
}
-func (s *HstSuite) NewAddress() (AddressWithPrefix, error) {
- var ipPrefix AddressWithPrefix
- var err error
+func (s *HstSuite) startClientApp(ipAddress string, env []string, clnCh chan error, clnRes chan string) {
+ defer func() {
+ clnCh <- nil
+ }()
- if s.numberOfAddresses == 255 {
- s.T().Fatalf("no available IPv4 addresses")
+ nTries := 0
+
+ for {
+ cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g")
+ if env != nil {
+ cmd.Env = env
+ }
+ s.log(cmd)
+ o, err := cmd.CombinedOutput()
+ if err != nil {
+ if nTries > 5 {
+ clnCh <- fmt.Errorf("failed to start client app '%s'.\n%s", err, o)
+ return
+ }
+ time.Sleep(1 * time.Second)
+ nTries++
+ continue
+ } else {
+ clnRes <- fmt.Sprintf("Client output: %s", o)
+ }
+ break
}
+}
- address := fmt.Sprintf("10.10.10.%v/24", s.numberOfAddresses+1)
- ipPrefix, err = ip_types.ParseAddressWithPrefix(address)
+func (s *HstSuite) startHttpServer(running chan struct{}, done chan struct{}, addressPort, netNs string) {
+ cmd := newCommand([]string{"./http_server", addressPort}, netNs)
+ err := cmd.Start()
+ s.log(cmd)
if err != nil {
- return AddressWithPrefix{}, err
+ fmt.Println("Failed to start http server")
+ return
}
- s.numberOfAddresses++
+ running <- struct{}{}
+ <-done
+ cmd.Process.Kill()
+}
+
+func (s *HstSuite) startWget(finished chan error, server_ip, port, query, netNs string) {
+ defer func() {
+ finished <- errors.New("wget error")
+ }()
- return ipPrefix, nil
+ cmd := newCommand([]string{"wget", "--timeout=10", "--no-proxy", "--tries=5", "-O", "/dev/null", server_ip + ":" + port + "/" + query},
+ netNs)
+ s.log(cmd)
+ o, err := cmd.CombinedOutput()
+ if err != nil {
+ finished <- fmt.Errorf("wget error: '%v\n\n%s'", err, o)
+ return
+ } else if !strings.Contains(string(o), "200 OK") {
+ finished <- fmt.Errorf("wget error: response not 200 OK")
+ return
+ }
+ finished <- nil
}