ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hs-test: abstract away topology from test cases

Browse Source 
Definition of shared volumes and containers has been moved
to yaml files to be together with network topology.
Containers are automatically run at the beginning of each test case
and stopped afterward.

Type: test
Signed-off-by: Maros Ondrejicka <maros.ondrejicka@pantheon.tech>
Change-Id: I264cbb4f1355f8bd7aade221e9609fb5b9bd693e
This commit is contained in:
Maros Ondrejicka
2022-12-14 16:30:04 +01:00
committed by Florin Coras
parent aff4d320f0
commit db823ed6e9
22 changed files with 491 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extras/hs-test/Dockerfile.vpp
View File

@ -12,7 +12,7 @@ COPY vpp-data/lib/vpp_plugins/ /usr/lib/x86_64-linux-gnu/vpp_plugins/
COPY vpp-data/bin/* /usr/bin/
COPY vpp-data/lib/* /usr/lib/
COPY hs-test /hs-test
COPY hs-test /usr/local/bin/hs-test
RUN addgroup vpp

101
extras/hs-test/README.rst
View File

@ -44,19 +44,18 @@ For adding a new suite, please see `Modifying the framework`_ below.
#. Declare method whose name starts with ``Test`` and specifies its receiver as a pointer to the suite's struct (defined in ``framework_test.go``)
#. Implement test behaviour inside the test method. This typically includes the following:
#. Start docker container(s) as needed. Function ``dockerRun(instance, args string)``
from ``utils.go`` serves this purpose. Alternatively use suite struct's ``NewContainer(name string)`` method to create
#. Retrieve a running container in which to run some action. Function ``getContainerByName(name string)``
from ``HstSuite`` struct serves this purpose
an object representing a container and start it with ``run()`` method
#. Execute *hs-test* action(s) inside any of the running containers.
Function ``hstExec`` from ``utils.go`` does this by using ``docker exec`` command to run ``hs-test`` executable.
For starting an VPP instance inside a container, the ``VppInstance`` struct can be used as a forward-looking alternative
#. Run arbitrary commands inside the containers with ``dockerExec(cmd string, instance string)``
Function ``execAction(args string)`` from ``container.go`` does this by using ``docker exec`` command to run ``hs-test`` executable.
For starting an VPP instance inside a container, the ``VppInstance`` struct can be used instead
#. Run arbitrary commands inside the containers with ``exec(cmd string)``
#. Run other external tool with one of the preexisting functions in the ``utils.go`` file.
For example, use ``wget`` with ``startWget(..)`` function
#. Use ``exechelper`` or just plain ``exec`` packages to run whatever else
#. ``defer func() { exechelper.Run("docker stop <container-name>) }()`` inside the method body,
to stop the running container(s). It's not necessary to do this if containers were created
with suite's ``NewContainer(..)`` method
#. Verify results of your tests using ``assert`` methods provided by the test suite,
implemented by HstSuite struct
**Example test case**
@ -69,51 +68,24 @@ This can be put in file ``extras/hs-test/my_test.go`` and run with command ``./t
import (
"fmt"
"github.com/edwarnicke/exechelper"
)
func (s *MySuite) TestMyCase() {
t := s.T()
serverVppContainer := s.getContainerByName("server-vpp")
vpp1Instance := "vpp-1"
vpp2Instance := "vpp-2"
serverVpp := NewVppInstance(serverContainer)
serverVpp.set2VethsServer()
serverVpp.start()
err := dockerRun(vpp1Instance, "")
if err != nil {
t.Errorf("%v", err)
return
}
defer func() { exechelper.Run("docker stop " + vpp1Instance) }()
clientVppContainer := s.getContainerByName("client-vpp")
err = dockerRun(vpp2Instance, "")
if err != nil {
t.Errorf("%v", err)
return
}
defer func() { exechelper.Run("docker stop " + vpp2Instance) }()
clientVpp:= NewVppInstance(clientContainer)
serverVpp.set2VethsClient()
clientVpp.start()
_, err = hstExec("Configure2Veths srv", vpp1Instance)
if err != nil {
t.Errorf("%v", err)
return
}
_, err = hstExec("Configure2Veths cln", vpp2Instance)
if err != nil {
t.Errorf("%v", err)
return
}
// ping one VPP from the other
//
// not using dockerExec because it executes in detached mode
// and we want to capture output from ping and show it
command := "docker exec --detach=false vpp-1 vppctl -s /tmp/2veths/var/run/vpp/cli.sock ping 10.10.10.2"
output, err := exechelper.CombinedOutput(command)
if err != nil {
t.Errorf("ping failed: %v", err)
}
fmt.Println(string(output))
result, err := clientVpp.vppctl("ping 10.10.10.2")
s.assertNil(err, "ping resulted in error")
fmt.Println(result)
}
Modifying the framework
@ -123,7 +95,9 @@ Modifying the framework
.. _test-convention:
#. Adding a new suite takes place in ``framework_test.go``
#. Adding a new suite takes place in ``framework_test.go`` and by creating a new file for the suite.
Naming convention for the suite files is ``suite-name-test.go`` where *name* will be replaced
by the actual name
#. Make a ``struct`` with at least ``HstSuite`` struct as its member.
HstSuite provides functionality that can be shared for all suites, like starting containers
@ -136,8 +110,12 @@ Modifying the framework
#. Implement SetupSuite method which testify runs before running the tests.
It's important here to call ``setupSuite(s *suite.Suite, topologyName string)`` and assign its result to the suite's ``teardownSuite`` member.
Pass the topology name to the function in the form of file name of one of the *yaml* files in ``topo`` folder.
Without the extension. In this example, *myTopology* corresponds to file ``extras/hs-test/topo/myTopology.yaml``
Pass the topology name to the function in the form of file name of one of the *yaml* files in ``topo-network`` folder.
Without the extension. In this example, *myTopology* corresponds to file ``extras/hs-test/topo-network/myTopology.yaml``
This will ensure network topology, such as network interfaces and namespaces, will be created.
Another important method to call is ``loadContainerTopology(topologyName string)`` which will load
containers and shared volumes used by the suite. This time the name passed to method corresponds
to file in ``extras/hs-test/topo-containers`` folder
::
@ -145,9 +123,11 @@ Modifying the framework
// Add custom setup code here
s.teardownSuite = setupSuite(&s.Suite, "myTopology")
s.loadContainerTopology("2peerVeth")
}
#. In order for ``go test`` to run this suite, we need to create a normal test function and pass our suite to ``suite.Run``
#. In order for ``go test`` to run this suite, we need to create a normal test function and pass our suite to ``suite.Run``.
This is being at the end of ``framework_test.go``
::
@ -160,20 +140,27 @@ Modifying the framework
**Adding a topology element**
Topology configuration exists as ``yaml`` files in the ``extras/hs-test/topo`` folder.
Processing of a file for a particular test suite is started by the ``setupSuite`` function depending on which file's name is passed to it.
Topology configuration exists as ``yaml`` files in the ``extras/hs-test/topo-network`` and
``extras/hs-test/topo-containers`` folders. Processing of a network topology file for a particular test suite
is started by the ``setupSuite`` function depending on which file's name is passed to it.
Specified file is loaded by ``LoadTopology()`` function and converted into internal data structures which represent various elements of the topology.
After parsing the configuration, ``Configure()`` method loops over array of topology elements and configures them one by one.
These are currently supported types of elements.
These are currently supported types of network elements.
* ``netns`` - network namespace
* ``veth`` - veth network interface, optionally with target network namespace or IPv4 address
* ``bridge`` - ethernet bridge to connect created interfaces, optionally with target network namespace
* ``tap`` - tap network interface with IP address
Similarly, container topology is started by ``loadContainerTopology()``, configuration file is processed
so that test suite retains map of defined containers and uses that to start them at the beginning
of each test case and stop containers after the test finishes. Container configuration can specify
also volumes which allow to share data between containers or between host system and containers.
Supporting a new type of topology element requires adding code to recognize the new element type during loading.
And adding code to set up the element in the host system with some Linux tool, such as *ip*. This should be implemented in ``netconfig.go``.
And adding code to set up the element in the host system with some Linux tool, such as *ip*.
This should be implemented in ``netconfig.go`` for network and in ``container.go`` for containers and volumes.
**Communicating between containers**
@ -193,13 +180,13 @@ For example, starting up VPP or running VCL echo client.
The actions are located in ``extras/hs-test/actions.go``. To add one, create a new method that has its receiver as a pointer to ``Actions`` struct.
Run it from test case with ``hstExec(args, instance)`` where ``args`` is the action method's name and ``instance`` is target Docker container's name.
Run it from test case with container's method ``execAction(args)`` where ``args`` is the action method's name.
This then executes the ``hs-test`` binary inside of the container and it then runs selected action.
Action is specified by its name as first argument for the binary.
*Note*: When ``hstExec(..)`` runs some action from a test case, the execution of ``hs-test`` inside the container
*Note*: When ``execAction(args)`` runs some action from a test case, the execution of ``hs-test`` inside the container
is asynchronous. The action might take many seconds to finish, while the test case execution context continues to run.
To mitigate this, ``hstExec(..)`` waits pre-defined arbitrary number of seconds for a *sync file* to be written by ``hs-test``
To mitigate this, ``execAction(args)`` waits pre-defined arbitrary number of seconds for a *sync file* to be written by ``hs-test``
at the end of its run. The test case context and container use Docker volume to share the file.
**Adding an external tool**

47
extras/hs-test/actions.go
View File

@ -19,6 +19,10 @@ import (
"github.com/edwarnicke/vpphelper"
)
var (
workDir, _ = os.Getwd()
)
type ConfFn func(context.Context, api.Connection) error
type Actions struct {
@ -44,20 +48,22 @@ func configureProxyTcp(ifName0, ipAddr0, ifName1, ipAddr1 string) ConfFn {
func (a *Actions) RunHttpCliSrv(args []string) *ActionResult {
cmd := fmt.Sprintf("http cli server")
return ApiCliInband("/tmp/Configure2Veths", cmd)
return ApiCliInband(workDir, cmd)
}
func (a *Actions) RunHttpCliCln(args []string) *ActionResult {
cmd := fmt.Sprintf("http cli client uri http://10.10.10.1/80 query %s", getArgs())
fmt.Println(cmd)
return ApiCliInband("/tmp/Configure2Veths", cmd)
return ApiCliInband(workDir, cmd)
}
func (a *Actions) ConfigureVppProxy(args []string) *ActionResult {
ctx, cancel := newVppContext()
defer cancel()
con, vppErrCh := vpphelper.StartAndDialContext(ctx, vpphelper.WithVppConfig(configTemplate))
con, vppErrCh := vpphelper.StartAndDialContext(ctx,
vpphelper.WithVppConfig(configTemplate),
vpphelper.WithRootDir(workDir))
exitOnErrCh(ctx, cancel, vppErrCh)
confFn := configureProxyTcp("vpp0", "10.0.0.2/24", "vpp1", "10.0.1.2/24")
@ -83,7 +89,7 @@ func (a *Actions) ConfigureEnvoyProxy(args []string) *ActionResult {
con, vppErrCh := vpphelper.StartAndDialContext(ctx,
vpphelper.WithVppConfig(configTemplate+startup.ToString()),
vpphelper.WithRootDir("/tmp/vpp-envoy"))
vpphelper.WithRootDir(workDir))
exitOnErrCh(ctx, cancel, vppErrCh)
confFn := configureProxyTcp("vpp0", "10.0.0.2/24", "vpp1", "10.0.1.2/24")
@ -91,7 +97,7 @@ func (a *Actions) ConfigureEnvoyProxy(args []string) *ActionResult {
if err != nil {
return NewActionResult(err, ActionResultWithDesc("configuration failed"))
}
err0 := exechelper.Run("chmod 777 -R /tmp/vpp-envoy")
err0 := exechelper.Run("chmod 777 -R " + workDir)
if err0 != nil {
return NewActionResult(err, ActionResultWithDesc("setting permissions failed"))
}
@ -120,7 +126,7 @@ func (a *Actions) RunEchoClient(args []string) *ActionResult {
outBuff := bytes.NewBuffer([]byte{})
errBuff := bytes.NewBuffer([]byte{})
cmd := fmt.Sprintf("vpp_echo client socket-name /tmp/echo-cln/var/run/app_ns_sockets/2 use-app-socket-api uri %s://10.10.10.1/12344", args[2])
cmd := fmt.Sprintf("vpp_echo client socket-name %s/var/run/app_ns_sockets/2 use-app-socket-api uri %s://10.10.10.1/12344", workDir, args[2])
err := exechelper.Run(cmd,
exechelper.WithStdout(outBuff), exechelper.WithStderr(errBuff),
exechelper.WithStdout(os.Stdout), exechelper.WithStderr(os.Stderr))
@ -130,7 +136,7 @@ func (a *Actions) RunEchoClient(args []string) *ActionResult {
}
func (a *Actions) RunEchoServer(args []string) *ActionResult {
cmd := fmt.Sprintf("vpp_echo server TX=RX socket-name /tmp/echo-srv/var/run/app_ns_sockets/1 use-app-socket-api uri %s://10.10.10.1/12344", args[2])
cmd := fmt.Sprintf("vpp_echo server TX=RX socket-name %s/var/run/app_ns_sockets/1 use-app-socket-api uri %s://10.10.10.1/12344", workDir, args[2])
errCh := exechelper.Start(cmd)
select {
case err := <-errCh:
@ -143,12 +149,12 @@ func (a *Actions) RunEchoServer(args []string) *ActionResult {
func (a *Actions) RunEchoSrvInternal(args []string) *ActionResult {
cmd := fmt.Sprintf("test echo server %s uri tcp://10.10.10.1/1234", getArgs())
return ApiCliInband("/tmp/Configure2Veths", cmd)
return ApiCliInband(workDir, cmd)
}
func (a *Actions) RunEchoClnInternal(args []string) *ActionResult {
cmd := fmt.Sprintf("test echo client %s uri tcp://10.10.10.1/1234", getArgs())
return ApiCliInband("/tmp/Configure2Veths", cmd)
return ApiCliInband(workDir, cmd)
}
func (a *Actions) RunVclEchoServer(args []string) *ActionResult {
@ -156,10 +162,11 @@ func (a *Actions) RunVclEchoServer(args []string) *ActionResult {
if err != nil {
return NewActionResult(err, ActionResultWithStderr(("create vcl config: ")))
}
fmt.Fprintf(f, vclTemplate, "/tmp/echo-srv/var/run/app_ns_sockets/1", "1")
socketPath := fmt.Sprintf("%s/var/run/app_ns_sockets/1", workDir)
fmt.Fprintf(f, vclTemplate, socketPath, "1")
f.Close()
os.Setenv("VCL_CONFIG", "/vcl_1.conf")
os.Setenv("VCL_CONFIG", "./vcl_1.conf")
cmd := fmt.Sprintf("vcl_test_server -p %s 12346", args[2])
errCh := exechelper.Start(cmd)
select {
@ -179,10 +186,11 @@ func (a *Actions) RunVclEchoClient(args []string) *ActionResult {
if err != nil {
return NewActionResult(err, ActionResultWithStderr(("create vcl config: ")))
}
fmt.Fprintf(f, vclTemplate, "/tmp/echo-cln/var/run/app_ns_sockets/2", "2")
socketPath := fmt.Sprintf("%s/var/run/app_ns_sockets/2", workDir)
fmt.Fprintf(f, vclTemplate, socketPath, "2")
f.Close()
os.Setenv("VCL_CONFIG", "/vcl_2.conf")
os.Setenv("VCL_CONFIG", "./vcl_2.conf")
cmd := fmt.Sprintf("vcl_test_client -U -p %s 10.10.10.1 12346", args[2])
err = exechelper.Run(cmd,
exechelper.WithStdout(outBuff), exechelper.WithStderr(errBuff),
@ -237,22 +245,25 @@ func (a *Actions) Configure2Veths(args []string) *ActionResult {
ctx, cancel := newVppContext()
defer cancel()
vppConfig, err := DeserializeVppConfig(args[2])
vppConfig, err := deserializeVppConfig(args[2])
if err != nil {
return NewActionResult(err, ActionResultWithDesc("deserializing configuration failed"))
}
con, vppErrCh := vpphelper.StartAndDialContext(ctx,
vpphelper.WithVppConfig(vppConfig.getTemplate()+startup.ToString()),
vpphelper.WithRootDir(fmt.Sprintf("/tmp/%s", args[1])))
vpphelper.WithRootDir(workDir))
exitOnErrCh(ctx, cancel, vppErrCh)
var fn func(context.Context, api.Connection) error
if vppConfig.Variant == "srv" {
switch vppConfig.Variant {
case "srv":
fn = configure2vethsTopo("vppsrv", "10.10.10.1/24", "1", 1)
} else if vppConfig.Variant == "srv-with-preset-hw-addr" {
case "srv-with-preset-hw-addr":
fn = configure2vethsTopo("vppsrv", "10.10.10.1/24", "1", 1, "00:00:5e:00:53:01")
} else {
case "cln":
fallthrough
default:
fn = configure2vethsTopo("vppcln", "10.10.10.2/24", "2", 2)
}
err = fn(ctx, con)

153
extras/hs-test/container.go
View File

@ -2,18 +2,73 @@ package main
import (
"fmt"
"os"
"strings"
"github.com/edwarnicke/exechelper"
)
type Volume struct {
name string
path string
hostDir string
containerDir string
}
type Container struct {
name string
volumes []*Volume
isOptional bool
name string
image string
workDir string
volumes map[string]Volume
envVars map[string]string
}
func NewContainer(yamlInput ContainerConfig) (*Container, error) {
containerName := yamlInput["name"].(string)
if len(containerName) == 0 {
err := fmt.Errorf("container name must not be blank")
return nil, err
}
var container = new(Container)
container.volumes = make(map[string]Volume)
container.envVars = make(map[string]string)
container.name = containerName
if image, ok := yamlInput["image"]; ok {
container.image = image.(string)
} else {
container.image = "hs-test/vpp"
}
if isOptional, ok := yamlInput["is-optional"]; ok {
container.isOptional = isOptional.(bool)
} else {
container.isOptional = false
}
if _, ok := yamlInput["volumes"]; ok {
r:= strings.NewReplacer("$HST_DIR", workDir)
for _, volu := range yamlInput["volumes"].([]interface{}) {
volumeMap := volu.(ContainerConfig)
hostDir := r.Replace(volumeMap["host-dir"].(string))
containerDir := volumeMap["container-dir"].(string)
container.addVolume(hostDir, containerDir)
if isDefaultWorkDir, ok := volumeMap["is-default-work-dir"]; ok &&
isDefaultWorkDir.(bool) &&
len(container.workDir) == 0 {
container.workDir = containerDir
}
}
}
if _, ok := yamlInput["vars"]; ok {
for _, envVar := range yamlInput["vars"].([]interface{}) {
container.addEnvVar(envVar)
}
}
return container, nil
}
func (c *Container) run() error {
@ -22,34 +77,102 @@ func (c *Container) run() error {
}
exechelper.Run(fmt.Sprintf("mkdir -p /tmp/%s/sync", c.name))
syncPath := fmt.Sprintf("-v /tmp/%s/sync:/tmp/sync", c.name)
cmd := "docker run --cap-add=all -d --privileged --network host --rm "
syncPath := fmt.Sprintf(" -v %s:/tmp/sync", c.getSyncPath())
cmd := "docker run --cap-add=all -d --privileged --network host --rm"
cmd += syncPath
cmd += c.getVolumes()
cmd += " --name " + c.name + " hs-test/vpp"
cmd += c.getVolumesAsCliOption()
cmd += c.getEnvVarsAsCliOption()
cmd += " --name " + c.name + " " + c.image
fmt.Println(cmd)
err := exechelper.Run(cmd)
if err != nil {
return fmt.Errorf("create volume failed: %s", err)
return fmt.Errorf("container run failed: %s", err)
}
return nil
}
func (c *Container) addVolume(name string, containerPath string) {
c.volumes = append(c.volumes, &Volume{name, containerPath})
func (c *Container) addVolume(hostDir string, containerDir string) {
var volume Volume
volume.hostDir = hostDir
volume.containerDir = containerDir
c.volumes[hostDir] = volume
}
func (c *Container) getVolumes() string {
dockerOption := ""
func (c *Container) getVolumeByHostDir(hostDir string) Volume {
return c.volumes[hostDir]
}
func (c *Container) getVolumesAsCliOption() string {
cliOption := ""
if len(c.volumes) > 0 {
for _, volume := range c.volumes {
dockerOption += fmt.Sprintf(" -v %s:%s", volume.name, volume.path)
cliOption += fmt.Sprintf(" -v %s:%s", volume.hostDir, volume.containerDir)
}
}
return dockerOption
return cliOption
}
func (c *Container) getWorkDirAsCliOption() string {
if len(c.workDir) == 0 {
return ""
}
return fmt.Sprintf(" --workdir=\"%s\"", c.workDir)
}
func (c *Container) addEnvVar(envVar interface{}) {
envVarMap := envVar.(ContainerConfig)
name := envVarMap["name"].(string)
value := envVarMap["value"].(string)
c.envVars[name] = value
}
func (c *Container) getEnvVarsAsCliOption() string {
cliOption := ""
if len(c.envVars) == 0 {
return cliOption
}
for name, value := range c.envVars {
cliOption += fmt.Sprintf(" -e %s=%s", name, value)
}
return cliOption
}
func (c *Container) getSyncPath() string {
return fmt.Sprintf("/tmp/%s/sync", c.name)
}
func (c *Container) exec(command string) (string, error) {
cliCommand := "docker exec -d " + c.name + " " + command
byteOutput, err := exechelper.CombinedOutput(cliCommand)
return string(byteOutput), err
}
func (c *Container) execAction(args string) (string, error) {
syncFile := c.getSyncPath() + "/rc"
os.Remove(syncFile)
workDir := c.getWorkDirAsCliOption()
cmd := fmt.Sprintf("docker exec -d %s %s hs-test %s",
workDir,
c.name,
args)
err := exechelper.Run(cmd)
if err != nil {
return "", err
}
res, err := waitForSyncFile(syncFile)
if err != nil {
return "", fmt.Errorf("failed to read sync file while executing 'hs-test %s': %v", args, err)
}
o := res.StdOutput + res.ErrOutput
if res.Code != 0 {
return o, fmt.Errorf("cmd resulted in non-zero value %d: %s", res.Code, res.Desc)
}
return o, err
}
func (c *Container) stop() error {

21
extras/hs-test/echo_test.go
View File

@ -2,30 +2,21 @@ package main
import (
"fmt"
"github.com/edwarnicke/exechelper"
)
func (s *VethsSuite) TestEchoBuiltin() {
srvInstance := "echo-srv-internal"
clnInstance := "echo-cln-internal"
s.assertNil(dockerRun(srvInstance, ""), "failed to start docker (srv)")
defer func() { exechelper.Run("docker stop " + srvInstance) }()
s.assertNil(dockerRun(clnInstance, ""), "failed to start docker (cln)")
defer func() { exechelper.Run("docker stop " + clnInstance) }()
_, err := hstExec("Configure2Veths srv", srvInstance)
serverContainer := s.getContainerByName("server-vpp")
_, err := serverContainer.execAction("Configure2Veths srv")
s.assertNil(err)
_, err = hstExec("Configure2Veths cln", clnInstance)
clientContainer := s.getContainerByName("client-vpp")
_, err = clientContainer.execAction("Configure2Veths cln")
s.assertNil(err)
_, err = hstExec("RunEchoSrvInternal private-segment-size 1g fifo-size 4 no-echo", srvInstance)
_, err = serverContainer.execAction("RunEchoSrvInternal private-segment-size 1g fifo-size 4 no-echo")
s.assertNil(err)
o, err := hstExec("RunEchoClnInternal nclients 10000 bytes 1 syn-timeout 100 test-timeout 100 no-return private-segment-size 1g fifo-size 4", clnInstance)
o, err := clientContainer.execAction("RunEchoClnInternal nclients 10000 bytes 1 syn-timeout 100 test-timeout 100 no-return private-segment-size 1g fifo-size 4")
s.assertNil(err)
fmt.Println(o)
}

86
extras/hs-test/framework_test.go
View File

@ -3,26 +3,43 @@ package main
import (
"fmt"
"testing"
"time"
"io/ioutil"
"github.com/edwarnicke/exechelper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
"gopkg.in/yaml.v3"
)
type HstSuite struct {
suite.Suite
teardownSuite func()
containers []*Container
containers map[string]*Container
volumes []string
}
func (s *HstSuite) TearDownSuite() {
s.teardownSuite()
s.StopContainers()
}
func (s *HstSuite) TearDownTest() {
s.ResetContainers()
s.RemoveVolumes()
}
func (s *HstSuite) SetupTest() {
for _, volume := range s.volumes {
cmd := "docker volume create --name=" + volume
fmt.Println(cmd)
exechelper.Run(cmd)
}
for _, container := range s.containers {
if container.isOptional == false {
container.run()
}
}
}
func (s *HstSuite) hstFail() {
s.T().FailNow()
}
@ -63,20 +80,7 @@ func (s *HstSuite) assertNotContains(testString, contains interface{}, msgAndArg
}
}
func (s *HstSuite) NewContainer(name string) (*Container, error) {
if name == "" {
return nil, fmt.Errorf("creating container failed: name must not be blank")
}
container := new(Container)
container.name = name
s.containers = append(s.containers, container)
return container, nil
}
func (s *HstSuite) StopContainers() {
func (s *HstSuite) ResetContainers() {
for _, container := range s.containers {
container.stop()
}
@ -94,39 +98,43 @@ func (s *HstSuite) NewVolume(name string) error {
func (s *HstSuite) RemoveVolumes() {
for _, volumeName := range s.volumes {
exechelper.Run("docker volume rm " + volumeName)
cmd := "docker volume rm " + volumeName
exechelper.Run(cmd)
}
}
type TapSuite struct {
HstSuite
func (s *HstSuite) getContainerByName(name string) *Container {
return s.containers[name]
}
func (s *TapSuite) SetupSuite() {
time.Sleep(1 * time.Second)
s.teardownSuite = setupSuite(&s.Suite, "tap")
}
func (s *HstSuite) loadContainerTopology(topologyName string) {
data, err := ioutil.ReadFile(ContainerTopologyDir + topologyName + ".yaml")
if err != nil {
s.T().Fatalf("read error: %v", err)
}
var yamlTopo YamlTopology
err = yaml.Unmarshal(data, &yamlTopo)
if err != nil {
s.T().Fatalf("unmarshal error: %v", err)
}
type VethsSuite struct {
HstSuite
}
for _, elem := range yamlTopo.Volumes {
s.volumes = append(s.volumes, elem)
}
func (s *VethsSuite) SetupSuite() {
time.Sleep(1 * time.Second)
s.teardownSuite = setupSuite(&s.Suite, "2peerVeth")
}
type NsSuite struct {
HstSuite
}
func (s *NsSuite) SetupSuite() {
s.teardownSuite = setupSuite(&s.Suite, "ns")
s.containers = make(map[string]*Container)
for _, elem := range yamlTopo.Containers {
newContainer, err := NewContainer(elem)
if err != nil {
s.T().Fatalf("config error: %v", err)
}
s.containers[newContainer.name] = newContainer
}
}
func setupSuite(s *suite.Suite, topologyName string) func() {
t := s.T()
topology, err := LoadTopology(TopologyDir, topologyName)
topology, err := LoadTopology(NetworkTopologyDir, topologyName)
if err != nil {
t.Fatalf("error on loading topology '%s': %v", topologyName, err)
}

29
extras/hs-test/http_test.go
View File

@ -1,23 +1,17 @@
package main
import (
"github.com/edwarnicke/exechelper"
)
func (s *NsSuite) TestHttpTps() {
t := s.T()
finished := make(chan error, 1)
server_ip := "10.0.0.2"
port := "8080"
dockerInstance := "http-tps"
container := s.getContainerByName("vpp")
t.Log("starting vpp..")
s.assertNil(dockerRun(dockerInstance, ""), "failed to start docker")
defer func() { exechelper.Run("docker stop " + dockerInstance) }()
// start & configure vpp in the container
_, err := hstExec("ConfigureHttpTps", dockerInstance)
_, err := container.execAction("ConfigureHttpTps")
s.assertNil(err)
go startWget(finished, server_ip, port, "client")
@ -29,28 +23,23 @@ func (s *NsSuite) TestHttpTps() {
func (s *VethsSuite) TestHttpCli() {
t := s.T()
srvInstance := "http-cli-srv"
clnInstance := "http-cli-cln"
s.assertNil(dockerRun(srvInstance, ""), "failed to start docker (srv)")
defer func() { exechelper.Run("docker stop " + srvInstance) }()
serverContainer := s.getContainerByName("server-vpp")
clientContainer := s.getContainerByName("client-vpp")
s.assertNil(dockerRun(clnInstance, ""), "failed to start docker (cln)")
defer func() { exechelper.Run("docker stop " + clnInstance) }()
_, err := hstExec("Configure2Veths srv", srvInstance)
_, err := serverContainer.execAction("Configure2Veths srv")
s.assertNil(err)
_, err = hstExec("Configure2Veths cln", clnInstance)
_, err = clientContainer.execAction("Configure2Veths cln")
s.assertNil(err)
t.Log("configured IPs...")
_, err = hstExec("RunHttpCliSrv", srvInstance)
_, err = serverContainer.execAction("RunHttpCliSrv")
s.assertNil(err)
t.Log("configured http server")
o, err := hstExec("RunHttpCliCln /show/version", clnInstance)
o, err := clientContainer.execAction("RunHttpCliCln /show/version")
s.assertNil(err)
s.assertContains(o, "<html>", "<html> not found in the result!")

40
extras/hs-test/ldp_test.go
View File

@ -4,22 +4,18 @@ import (
"fmt"
"os"
"time"
"github.com/edwarnicke/exechelper"
)
func (s *VethsSuite) TestLDPreloadIperfVpp() {
var clnVclConf, srvVclConf Stanza
srvInstance := "vpp-ldp-srv"
clnInstance := "vpp-ldp-cln"
srvPath := "/tmp/" + srvInstance
clnPath := "/tmp/" + clnInstance
srvVcl := srvPath + "/vcl_srv.conf"
clnVcl := clnPath + "/vcl_cln.conf"
serverContainer := s.getContainerByName("server-vpp")
serverVolume := serverContainer.getVolumeByHostDir("/tmp/server")
srvVcl := serverVolume.containerDir + "/vcl_srv.conf"
exechelper.Run("mkdir " + srvPath)
exechelper.Run("mkdir " + clnPath)
clientContainer := s.getContainerByName("client-vpp")
clientVolume := clientContainer.getVolumeByHostDir("/tmp/client")
clnVcl := clientVolume.containerDir + "/vcl_cln.conf"
ldpreload := os.Getenv("HST_LDPRELOAD")
s.assertNotEqual("", ldpreload)
@ -32,18 +28,20 @@ func (s *VethsSuite) TestLDPreloadIperfVpp() {
fmt.Println("starting VPPs")
s.assertNil(dockerRun(srvInstance, fmt.Sprintf("-v /tmp/%s:/tmp", srvInstance)), "failed to start docker (srv)")
defer func() { exechelper.Run("docker stop " + srvInstance) }()
s.assertNil(dockerRun(clnInstance, fmt.Sprintf("-v /tmp/%s:/tmp", clnInstance)), "failed to start docker (cln)")
defer func() { exechelper.Run("docker stop " + clnInstance) }()
_, err := hstExec("Configure2Veths srv", srvInstance)
originalWorkDir := serverContainer.workDir
serverContainer.workDir = serverVolume.containerDir
_, err := serverContainer.execAction("Configure2Veths srv")
s.assertNil(err)
serverContainer.workDir = originalWorkDir
_, err = hstExec("Configure2Veths cln", clnInstance)
originalWorkDir = clientContainer.workDir
clientContainer.workDir = clientVolume.containerDir
_, err = clientContainer.execAction("Configure2Veths cln")
s.assertNil(err)
clientContainer.workDir = originalWorkDir
clientAppSocketApi := fmt.Sprintf("app-socket-api %s/var/run/app_ns_sockets/2",
clientVolume.containerDir)
err = clnVclConf.
NewStanza("vcl").
Append("rx-fifo-size 4000000").
@ -51,10 +49,12 @@ func (s *VethsSuite) TestLDPreloadIperfVpp() {
Append("app-scope-local").
Append("app-scope-global").
Append("use-mq-eventfd").
Append(fmt.Sprintf("app-socket-api /tmp/%s/Configure2Veths/var/run/app_ns_sockets/2", clnInstance)).Close().
Append(clientAppSocketApi).Close().
SaveToFile(clnVcl)
s.assertNil(err)
serverAppSocketApi := fmt.Sprintf("app-socket-api %s/var/run/app_ns_sockets/1",
serverVolume.containerDir)
err = srvVclConf.
NewStanza("vcl").
Append("rx-fifo-size 4000000").
@ -62,7 +62,7 @@ func (s *VethsSuite) TestLDPreloadIperfVpp() {
Append("app-scope-local").
Append("app-scope-global").
Append("use-mq-eventfd").
Append(fmt.Sprintf("app-socket-api /tmp/%s/Configure2Veths/var/run/app_ns_sockets/1", srvInstance)).Close().
Append(serverAppSocketApi).Close().
SaveToFile(srvVcl)
s.assertNil(err)

2
extras/hs-test/main.go
View File

@ -133,7 +133,7 @@ func main() {
}
if os.Args[1] == "rm" {
topology, err := LoadTopology(TopologyDir, os.Args[2])
topology, err := LoadTopology(NetworkTopologyDir, os.Args[2])
if err != nil {
fmt.Printf("falied to load topologies: %v\n", err)
os.Exit(1)

79
extras/hs-test/proxy_test.go
View File

@ -1,34 +1,22 @@
package main
import (
"context"
"fmt"
"os"
"github.com/edwarnicke/exechelper"
)
func testProxyHttpTcp(s *NsSuite, dockerInstance, action string, proxySetup func() error) error {
func testProxyHttpTcp(s *NsSuite, proxySetup func() error) error {
const outputFile = "test.data"
const srcFile = "10M"
stopServer := make(chan struct{}, 1)
serverRunning := make(chan struct{}, 1)
volumeArgs := fmt.Sprintf("-v shared-vol:/tmp/%s", dockerInstance)
s.assertNil(dockerRun(dockerInstance, volumeArgs), "failed to start container")
defer func() { exechelper.Run("docker stop " + dockerInstance) }()
// start & configure vpp in the container
_, err := hstExec(action, dockerInstance)
s.assertNil(err)
fmt.Println("VPP running and configured...")
s.assertNil(proxySetup(), "failed to setup proxy")
fmt.Println("Proxy configured...")
// create test file
err = exechelper.Run(fmt.Sprintf("ip netns exec server truncate -s %s %s", srcFile, srcFile))
err := exechelper.Run(fmt.Sprintf("ip netns exec server truncate -s %s %s", srcFile, srcFile))
s.assertNil(err, "failed to run truncate command")
defer func() { os.Remove(srcFile) }()
@ -55,50 +43,43 @@ func testProxyHttpTcp(s *NsSuite, dockerInstance, action string, proxySetup func
return nil
}
func setupEnvoy(ctx context.Context, dockerInstance string) error {
errCh := startEnvoy(ctx, dockerInstance)
select {
case err := <-errCh:
return err
default:
}
func configureVppProxy(s *NsSuite) error {
container := s.getContainerByName("vpp")
testVppProxy := NewVppInstance(container)
testVppProxy.setVppProxy()
err := testVppProxy.start()
s.assertNil(err, "failed to start and configure VPP")
fmt.Println("VPP running and configured...")
go func(ctx context.Context, errCh <-chan error) {
for {
select {
// handle cancel() call from outside to gracefully stop the routine
case <-ctx.Done():
return
default:
select {
case err := <-errCh:
fmt.Printf("error while running envoy: %v", err)
default:
}
}
}
}(ctx, errCh)
output, err := testVppProxy.vppctl("test proxy server server-uri tcp://10.0.0.2/555 client-uri tcp://10.0.1.1/666")
fmt.Println("Proxy configured...", string(output))
return nil
}
func (s *NsSuite) TestVppProxyHttpTcp() {
dockerInstance := "vpp-proxy"
err := testProxyHttpTcp(s, dockerInstance, "ConfigureVppProxy", configureVppProxy)
err := testProxyHttpTcp(s, func() error {
return configureVppProxy(s)
})
s.assertNil(err)
}
func configureEnvoyProxy(s *NsSuite) error {
vppContainer := s.getContainerByName("vpp")
testVppForEnvoyProxy := NewVppInstance(vppContainer)
testVppForEnvoyProxy.setEnvoyProxy()
err := testVppForEnvoyProxy.start()
s.assertNil(err, "failed to start and configure VPP")
envoyContainer := s.getContainerByName("envoy")
envoyContainer.run()
fmt.Println("VPP running and configured...")
return nil
}
func (s *NsSuite) TestEnvoyProxyHttpTcp() {
exechelper.Run("docker volume create --name=shared-vol")
defer func() {
exechelper.Run("docker stop envoy")
}()
ctx, cancel := context.WithCancel(context.Background())
dockerInstance := "vpp-envoy"
err := testProxyHttpTcp(s, dockerInstance, "ConfigureEnvoyProxy", func() error {
return setupEnvoy(ctx, dockerInstance)
err := testProxyHttpTcp(s, func() error {
return configureEnvoyProxy(s)
})
s.assertNil(err)
cancel()
}

11
extras/hs-test/suite_ns_test.go Normal file
View File

@ -0,0 +1,11 @@
package main
type NsSuite struct {
HstSuite
}
func (s *NsSuite) SetupSuite() {
s.teardownSuite = setupSuite(&s.Suite, "ns")
s.loadContainerTopology("ns")
}

15
extras/hs-test/suite_tap_test.go Normal file
View File

@ -0,0 +1,15 @@
package main
import (
"time"
)
type TapSuite struct {
HstSuite
}
func (s *TapSuite) SetupSuite() {
time.Sleep(1 * time.Second)
s.teardownSuite = setupSuite(&s.Suite, "tap")
}

16
extras/hs-test/suite_veth_test.go Normal file
View File

@ -0,0 +1,16 @@
package main
import (
"time"
)
type VethsSuite struct {
HstSuite
}
func (s *VethsSuite) SetupSuite() {
time.Sleep(1 * time.Second)
s.teardownSuite = setupSuite(&s.Suite, "2peerVeth")
s.loadContainerTopology("2peerVeth")
}

31
extras/hs-test/topo-containers/2peerVeth.yaml Executable file
View File

@ -0,0 +1,31 @@
---
volumes:
- server-share
- client-share
containers:
- name: "server-vpp"
volumes:
- host-dir: "server-share"
container-dir: "/tmp/server-share"
is-default-work-dir: true
- host-dir: "/tmp/server"
container-dir: "/tmp/server"
- name: "client-vpp"
volumes:
- host-dir: "client-share"
container-dir: "/tmp/client-share"
is-default-work-dir: true
- host-dir: "/tmp/client"
container-dir: "/tmp/client"
- name: "server-application"
volumes:
- host-dir: "server-share"
container-dir: "/tmp/server-share"
is-default-work-dir: true
- name: "client-application"
volumes:
- host-dir: "client-share"
container-dir: "/tmp/client-share"
is-default-work-dir: true

27
extras/hs-test/topo-containers/ns.yaml Executable file
View File

@ -0,0 +1,27 @@
---
volumes:
- shared-vol
# $HST_DIR will be replaced during runtime by path to hs-test directory
containers:
- name: "vpp"
volumes:
- host-dir: "shared-vol"
container-dir: "/tmp/vpp"
is-default-work-dir: true
- name: "envoy"
volumes:
- host-dir: "$HST_DIR/envoy/proxy.yaml"
container-dir: "/etc/envoy/envoy.yaml"
- host-dir: "shared-vol"
container-dir: "/tmp/vpp-envoy"
is-default-work-dir: true
- host-dir: "$HST_DIR/envoy"
container-dir: "/tmp"
vars:
- name: "ENVOY_UID"
value: "0"
- name: "VCL_CONFIG"
value: "/tmp/vcl.conf"
image: "envoyproxy/envoy-contrib:v1.21-latest"
is-optional: true

1
extras/hs-test/topo/2peerVeth.yaml → extras/hs-test/topo-network/2peerVeth.yaml
View File

@ -21,3 +21,4 @@ devices:
interfaces:
- vppsrv_veth
- vppcln_veth

2
extras/hs-test/topo/ns.yaml → extras/hs-test/topo-network/ns.yaml
View File

@ -18,4 +18,4 @@ devices:
peer:
name: "server"
netns: "server"
ip4: "10.0.1.1/24"
ip4: "10.0.1.1/24"

0
extras/hs-test/topo/tap.yaml → extras/hs-test/topo-network/tap.yaml
View File

3
extras/hs-test/topo.go
View File

@ -10,9 +10,12 @@ import (
)
type NetDevConfig map[string]interface{}
type ContainerConfig map[string]interface{}
type YamlTopology struct {
Devices []NetDevConfig `yaml:"devices"`
Containers []ContainerConfig `yaml:"containers"`
Volumes []string `yaml:"volumes"`
}
func AddAddress(device, address, ns string) error {

97
extras/hs-test/utils.go
View File

@ -1,7 +1,6 @@
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
@ -11,8 +10,6 @@ import (
"os/exec"
"strings"
"time"
"github.com/edwarnicke/exechelper"
)
// TODO remove `configTemplate` once its usage has been replaced everywhere with VppConfig
@ -61,7 +58,8 @@ const vclTemplate = `vcl {
}
`
const TopologyDir string = "topo/"
const NetworkTopologyDir string = "topo-network/"
const ContainerTopologyDir string = "topo-containers/"
type Stanza struct {
content string
@ -126,30 +124,6 @@ func StartClientApp(env []string, clnCh chan error) {
}
}
// run vpphelper in docker
func hstExec(args string, instance string) (string, error) {
syncFile := fmt.Sprintf("/tmp/%s/sync/rc", instance)
os.Remove(syncFile)
c := "docker exec -d " + instance + " /hs-test " + args
err := exechelper.Run(c)
if err != nil {
return "", err
}
res, err := waitForSyncFile(syncFile)
if err != nil {
return "", fmt.Errorf("failed to read sync file while executing './hs-test %s': %v", args, err)
}
o := res.StdOutput + res.ErrOutput
if res.Code != 0 {
return o, fmt.Errorf("cmd resulted in non-zero value %d: %s", res.Code, res.Desc)
}
return o, err
}
func waitForSyncFile(fname string) (*JsonResult, error) {
var res JsonResult
@ -173,17 +147,6 @@ func waitForSyncFile(fname string) (*JsonResult, error) {
return nil, fmt.Errorf("no sync file found")
}
func dockerRun(instance, args string) error {
exechelper.Run(fmt.Sprintf("mkdir -p /tmp/%s/sync", instance))
syncPath := fmt.Sprintf("-v /tmp/%s/sync:/tmp/sync", instance)
cmd := "docker run --cap-add=all -d --privileged --network host --rm "
cmd += syncPath
cmd += " " + args
cmd += " --name " + instance + " hs-test/vpp"
fmt.Println(cmd)
return exechelper.Run(cmd)
}
func assertFileSize(f1, f2 string) error {
fi1, err := os.Stat(f1)
if err != nil {
@ -201,62 +164,6 @@ func assertFileSize(f1, f2 string) error {
return nil
}
func dockerExec(cmd string, instance string) ([]byte, error) {
c := "docker exec -d " + instance + " " + cmd
return exechelper.CombinedOutput(c)
}
func startEnvoy(ctx context.Context, dockerInstance string) <-chan error {
errCh := make(chan error)
wd, err := os.Getwd()
if err != nil {
errCh <- err
return errCh
}
c := []string{"docker", "run", "--rm", "--name", "envoy",
"-v", fmt.Sprintf("%s/envoy/proxy.yaml:/etc/envoy/envoy.yaml", wd),
"-v", fmt.Sprintf("shared-vol:/tmp/%s", dockerInstance),
"-v", fmt.Sprintf("%s/envoy:/tmp", wd),
"-e", "ENVOY_UID=0",
"-e", "VCL_CONFIG=/tmp/vcl.conf",
"envoyproxy/envoy-contrib:v1.21-latest"}
fmt.Println(c)
go func(errCh chan error) {
count := 0
var cmd *exec.Cmd
for ; ; count++ {
cmd = NewCommand(c, "")
err = cmd.Start()
if err == nil {
break
}
if count > 5 {
errCh <- fmt.Errorf("failed to start envoy docker after %d attempts", count)
return
}
}
err = cmd.Wait()
if err != nil {
errCh <- fmt.Errorf("failed to start docker: %v", err)
return
}
<-ctx.Done()
}(errCh)
return errCh
}
func configureVppProxy() error {
_, err := dockerExec("vppctl test proxy server server-uri tcp://10.0.0.2/555 client-uri tcp://10.0.1.1/666",
"vpp-proxy")
if err != nil {
return fmt.Errorf("error while configuring vpp proxy test: %v", err)
}
return nil
}
func startHttpServer(running chan struct{}, done chan struct{}, addressPort, netNs string) {
cmd := NewCommand([]string{"./http_server", addressPort}, netNs)
err := cmd.Start()

109
extras/hs-test/vcl_test.go
View File

@ -3,7 +3,6 @@ package main
import (
"fmt"
"time"
)
func (s *VethsSuite) TestVclEchoQuic() {
@ -21,47 +20,25 @@ func (s *VethsSuite) TestVclEchoTcp() {
}
func (s *VethsSuite) testVclEcho(proto string) {
serverVolume := "echo-srv-vol"
s.NewVolume(serverVolume)
srvVppContainer := s.getContainerByName("server-vpp")
clientVolume := "echo-cln-vol"
s.NewVolume(clientVolume)
srvInstance := "vpp-vcl-test-srv"
serverVppContainer, err := s.NewContainer(srvInstance)
s.assertNil(err)
serverVppContainer.addVolume(serverVolume, "/tmp/Configure2Veths")
s.assertNil(serverVppContainer.run())
clnInstance := "vpp-vcl-test-cln"
clientVppContainer, err := s.NewContainer(clnInstance)
s.assertNil(err)
clientVppContainer.addVolume(clientVolume, "/tmp/Configure2Veths")
s.assertNil(clientVppContainer.run())
echoSrv := "echo-srv"
serverEchoContainer, err := s.NewContainer(echoSrv)
s.assertNil(err)
serverEchoContainer.addVolume(serverVolume, "/tmp/" + echoSrv)
s.assertNil(serverEchoContainer.run())
echoCln := "echo-cln"
clientEchoContainer, err := s.NewContainer(echoCln)
s.assertNil(err)
clientEchoContainer.addVolume(clientVolume, "/tmp/" + echoCln)
s.assertNil(clientEchoContainer.run())
_, err = hstExec("Configure2Veths srv", srvInstance)
_, err := srvVppContainer.execAction("Configure2Veths srv")
s.assertNil(err)
_, err = hstExec("Configure2Veths cln", clnInstance)
clnVppContainer := s.getContainerByName("client-vpp")
_, err = clnVppContainer.execAction("Configure2Veths cln")
s.assertNil(err)
echoSrvContainer := s.getContainerByName("server-application")
// run server app
_, err = hstExec("RunEchoServer "+proto, echoSrv)
_, err = echoSrvContainer.execAction("RunEchoServer "+proto)
s.assertNil(err)
o, err := hstExec("RunEchoClient "+proto, echoCln)
echoClnContainer := s.getContainerByName("client-application")
o, err := echoClnContainer.execAction("RunEchoClient "+proto)
s.assertNil(err)
fmt.Println(o)
@ -73,95 +50,63 @@ func (s *VethsSuite) TestVclRetryAttach() {
}
func (s *VethsSuite) testRetryAttach(proto string) {
serverVolume := "echo-srv-vol"
s.NewVolume(serverVolume)
srvVppContainer := s.getContainerByName("server-vpp")
clientVolume := "echo-cln-vol"
s.NewVolume(clientVolume)
srvInstance := "vpp-vcl-test-srv"
serverVppContainer, err := s.NewContainer(srvInstance)
s.assertNil(err)
serverVppContainer.addVolume(serverVolume, "/tmp/Configure2Veths")
s.assertNil(serverVppContainer.run())
clnInstance := "vpp-vcl-test-cln"
clientVppContainer, err := s.NewContainer(clnInstance)
s.assertNil(err)
clientVppContainer.addVolume(clientVolume, "/tmp/Configure2Veths")
s.assertNil(clientVppContainer.run())
echoSrv := "echo-srv"
serverEchoContainer, err := s.NewContainer(echoSrv)
s.assertNil(err)
serverEchoContainer.addVolume(serverVolume, "/tmp/" + echoSrv)
s.assertNil(serverEchoContainer.run())
echoCln := "echo-cln"
clientEchoContainer, err := s.NewContainer(echoCln)
s.assertNil(err)
clientEchoContainer.addVolume(clientVolume, "/tmp/" + echoCln)
s.assertNil(clientEchoContainer.run())
_, err = hstExec("Configure2Veths srv-with-preset-hw-addr", srvInstance)
_, err := srvVppContainer.execAction("Configure2Veths srv-with-preset-hw-addr")
s.assertNil(err)
_, err = hstExec("Configure2Veths cln", clnInstance)
clnVppContainer := s.getContainerByName("client-vpp")
_, err = clnVppContainer.execAction("Configure2Veths cln")
s.assertNil(err)
_, err = hstExec("RunVclEchoServer "+proto, echoSrv)
echoSrvContainer := s.getContainerByName("server-application")
_, err = echoSrvContainer.execAction("RunVclEchoServer "+proto)
s.assertNil(err)
fmt.Println("This whole test case can take around 3 minutes to run. Please be patient.")
fmt.Println("... Running first echo client test, before disconnect.")
_, err = hstExec("RunVclEchoClient "+proto, echoCln)
echoClnContainer := s.getContainerByName("client-application")
_, err = echoClnContainer.execAction("RunVclEchoClient "+proto)
s.assertNil(err)
fmt.Println("... First test ended. Stopping VPP server now.")
// Stop server-vpp-instance, start it again and then run vcl-test-client once more
stopVppCommand := "/bin/bash -c 'ps -C vpp_main -o pid= | xargs kill -9'"
_, err = dockerExec(stopVppCommand, srvInstance)
_, err = srvVppContainer.exec(stopVppCommand)
s.assertNil(err)
time.Sleep(5 * time.Second) // Give parent process time to reap the killed child process
stopVppCommand = "/bin/bash -c 'ps -C hs-test -o pid= | xargs kill -9'"
_, err = dockerExec(stopVppCommand, srvInstance)
_, err = srvVppContainer.exec(stopVppCommand)
s.assertNil(err)
_, err = hstExec("Configure2Veths srv-with-preset-hw-addr", srvInstance)
_, err = srvVppContainer.execAction("Configure2Veths srv-with-preset-hw-addr")
s.assertNil(err)
fmt.Println("... VPP server is starting again, so waiting for a bit.")
time.Sleep(30 * time.Second) // Wait a moment for the re-attachment to happen
fmt.Println("... Running second echo client test, after disconnect and re-attachment.")
_, err = hstExec("RunVclEchoClient "+proto, echoCln)
_, err = echoClnContainer.execAction("RunVclEchoClient "+proto)
s.assertNil(err)
fmt.Println("Done.")
}
func (s *VethsSuite) TestTcpWithLoss() {
serverContainer, err := s.NewContainer("server")
s.assertNil(err, "creating container failed")
err = serverContainer.run()
s.assertNil(err)
serverContainer := s.getContainerByName("server-vpp")
serverVpp := NewVppInstance(serverContainer)
s.assertNotNil(serverVpp)
serverVpp.setCliSocket("/var/run/vpp/cli.sock")
serverVpp.set2VethsServer()
err = serverVpp.start()
err := serverVpp.start()
s.assertNil(err, "starting VPP failed")
_, err = serverVpp.vppctl("test echo server uri tcp://10.10.10.1/20022")
s.assertNil(err, "starting echo server failed")
clientContainer, err := s.NewContainer("client")
s.assertNil(err, "creating container failed")
err = clientContainer.run()
s.assertNil(err, "starting container failed")
clientContainer := s.getContainerByName("client-vpp")
clientVpp := NewVppInstance(clientContainer)
s.assertNotNil(clientVpp)
clientVpp.setCliSocket("/var/run/vpp/cli.sock")
clientVpp.set2VethsClient()
err = clientVpp.start()
s.assertNil(err, "starting VPP failed")

47
extras/hs-test/vppinstance.go
View File

@ -40,6 +40,10 @@ plugins {
`
const (
defaultCliSocketFilePath = "/var/run/vpp/cli.sock"
)
type VppInstance struct {
container *Container
config VppConfig
@ -65,28 +69,30 @@ func (vpp *VppInstance) set2VethsClient() {
vpp.config.Variant = "cln"
}
func (vpp *VppInstance) setVppProxy() {
vpp.actionFuncName = "ConfigureVppProxy"
}
func (vpp *VppInstance) setEnvoyProxy() {
vpp.actionFuncName = "ConfigureEnvoyProxy"
}
func (vpp *VppInstance) setCliSocket(filePath string) {
vpp.config.CliSocketFilePath = filePath
}
func (vpp *VppInstance) getCliSocket() string {
return fmt.Sprintf("/tmp/%s/%s", vpp.actionFuncName, vpp.config.CliSocketFilePath)
return fmt.Sprintf("%s%s", vpp.container.workDir, vpp.config.CliSocketFilePath)
}
func (vpp *VppInstance) start() error {
if vpp.config.Variant == "" {
return fmt.Errorf("vpp start failed: variant must not be blank")
}
if vpp.actionFuncName == "" {
return fmt.Errorf("vpp start failed: action function name must not be blank")
}
serializedConfig, err := json.Marshal(vpp.config)
if err != nil {
return fmt.Errorf("vpp start failed: serializing configuration failed: %s", err)
}
args := fmt.Sprintf("%s '%s'", vpp.actionFuncName, string(serializedConfig))
_, err = hstExec(args, vpp.container.name)
serializedConfig, err := serializeVppConfig(vpp.config)
args := fmt.Sprintf("%s '%s'", vpp.actionFuncName, serializedConfig)
_, err = vpp.container.execAction(args)
if err != nil {
return fmt.Errorf("vpp start failed: %s", err)
}
@ -95,9 +101,9 @@ func (vpp *VppInstance) start() error {
}
func (vpp *VppInstance) vppctl(command string) (string, error) {
dockerExecCommand := fmt.Sprintf("docker exec --detach=false %[1]s vppctl -s %[2]s %[3]s",
cliExecCommand := fmt.Sprintf("docker exec --detach=false %[1]s vppctl -s %[2]s %[3]s",
vpp.container.name, vpp.getCliSocket(), command)
output, err := exechelper.CombinedOutput(dockerExecCommand)
output, err := exechelper.CombinedOutput(cliExecCommand)
if err != nil {
return "", fmt.Errorf("vppctl failed: %s", err)
}
@ -106,19 +112,30 @@ func (vpp *VppInstance) vppctl(command string) (string, error) {
}
func NewVppInstance(c *Container) *VppInstance {
var vppConfig VppConfig
vppConfig.CliSocketFilePath = defaultCliSocketFilePath
vpp := new(VppInstance)
vpp.container = c
vpp.config = vppConfig
return vpp
}
func DeserializeVppConfig(input string) (VppConfig, error) {
func serializeVppConfig(vppConfig VppConfig) (string, error) {
serializedConfig, err := json.Marshal(vppConfig)
if err != nil {
return "", fmt.Errorf("vpp start failed: serializing configuration failed: %s", err)
}
return string(serializedConfig), nil
}
func deserializeVppConfig(input string) (VppConfig, error) {
var vppConfig VppConfig
err := json.Unmarshal([]byte(input), &vppConfig)
if err != nil {
// Since input is not a valid JSON it is going be used as variant value
// Since input is not a valid JSON it is going be used as a variant value
// for compatibility reasons
vppConfig.Variant = input
vppConfig.CliSocketFilePath = "/var/run/vpp/cli.sock"
vppConfig.CliSocketFilePath = defaultCliSocketFilePath
}
return vppConfig, nil
}