package main
import (
+ "flag"
"fmt"
"io/ioutil"
"os"
+ "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 (
+ defaultNetworkNumber 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")
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
+ addresser *Addresser
+ testIds map[string]string
}
func (s *HstSuite) TearDownSuite() {
- if s.teardownSuite != nil {
- s.teardownSuite() // TODO remove this after config moved to SetupTest() for each suite
- }
-
s.unconfigureNetworkTopology()
}
func (s *HstSuite) TearDownTest() {
- if IsPersistent() {
+ if *isPersistent {
return
}
- s.ResetContainers()
- s.RemoveVolumes()
+ 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 {
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) 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 := ioutil.ReadFile(containerTopologyDir + topologyName + ".yaml")
if err != nil {
s.T().Fatalf("read error: %v", err)
}
s.containers = make(map[string]*Container)
for _, elem := range yamlTopo.Containers {
- newContainer, err := NewContainer(elem)
+ newContainer, err := newContainer(elem)
newContainer.suite = s
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 := ioutil.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.addresser = newAddresser(s)
+ 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.addresser); 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 _, veth := range s.veths {
- veth.Unconfigure()
+ for _, nc := range s.netConfigs {
+ nc.unconfigure()
}
- for _, tap := range s.taps {
- tap.Unconfigure()
+}
+
+func (s *HstSuite) getTestId() string {
+ testName := s.T().Name()
+
+ if s.testIds == nil {
+ s.testIds = map[string]string{}
}
- for _, bridge := range s.bridges {
- bridge.Unconfigure()
+
+ if _, ok := s.testIds[testName]; !ok {
+ s.testIds[testName] = time.Now().Format("2006-01-02_15-04-05")
}
+
+ return s.testIds[testName]
}
-func (s *HstSuite) NewAddress() (AddressWithPrefix, error) {
- var ipPrefix AddressWithPrefix
- var err error
+type AddressCounter = int
- if s.numberOfAddresses == 255 {
- s.T().Fatalf("no available IPv4 addresses")
+type Addresser struct {
+ networks map[int]AddressCounter
+ suite *HstSuite
+}
+
+func (a *Addresser) addNetwork(networkNumber int) {
+ a.networks[networkNumber] = 1
+}
+
+func (a *Addresser) newIp4Address(inputNetworkNumber ...int) (string, error) {
+ var networkNumber int = 0
+ if len(inputNetworkNumber) > 0 {
+ networkNumber = inputNetworkNumber[0]
}
- address := fmt.Sprintf("10.10.10.%v/24", s.numberOfAddresses+1)
- ipPrefix, err = ip_types.ParseAddressWithPrefix(address)
- if err != nil {
- return AddressWithPrefix{}, err
+ if _, ok := a.networks[networkNumber]; !ok {
+ a.addNetwork(networkNumber)
}
- s.numberOfAddresses++
- return ipPrefix, nil
+ numberOfAddresses := a.networks[networkNumber]
+
+ if numberOfAddresses == 254 {
+ return "", fmt.Errorf("no available IPv4 addresses")
+ }
+
+ address := fmt.Sprintf("10.10.%v.%v/24", networkNumber, numberOfAddresses)
+ a.networks[networkNumber] = numberOfAddresses + 1
+
+ return address, nil
+}
+
+func newAddresser(suite *HstSuite) *Addresser {
+ var addresser = new(Addresser)
+ addresser.suite = suite
+ addresser.networks = make(map[int]AddressCounter)
+ addresser.addNetwork(0)
+ return addresser
}