extras/hs-test/vppinstance.go

   1 package main
   2
   3 import (
   4         "fmt"
   5         "os"
   6         "os/exec"
   7         "os/signal"
   8         "strings"
   9         "syscall"
  10         "time"
  11
  12         "github.com/edwarnicke/exechelper"
  13
  14         "go.fd.io/govpp"
  15         "go.fd.io/govpp/api"
  16         "go.fd.io/govpp/binapi/af_packet"
  17         interfaces "go.fd.io/govpp/binapi/interface"
  18         "go.fd.io/govpp/binapi/interface_types"
  19         "go.fd.io/govpp/binapi/session"
  20         "go.fd.io/govpp/binapi/tapv2"
  21         "go.fd.io/govpp/binapi/vpe"
  22         "go.fd.io/govpp/core"
  23 )
  24
  25 const vppConfigTemplate = `unix {
  26   nodaemon
  27   log %[1]s%[4]s
  28   full-coredump
  29   cli-listen %[1]s%[2]s
  30   runtime-dir %[1]s/var/run
  31   gid vpp
  32 }
  33
  34 api-trace {
  35   on
  36 }
  37
  38 api-segment {
  39   gid vpp
  40 }
  41
  42 socksvr {
  43   socket-name %[1]s%[3]s
  44 }
  45
  46 statseg {
  47   socket-name %[1]s/var/run/vpp/stats.sock
  48 }
  49
  50 plugins {
  51   plugin default { disable }
  52
  53   plugin unittest_plugin.so { enable }
  54   plugin quic_plugin.so { enable }
  55   plugin af_packet_plugin.so { enable }
  56   plugin hs_apps_plugin.so { enable }
  57   plugin http_plugin.so { enable }
  58 }
  59
  60 logging {
  61   default-log-level debug
  62   default-syslog-log-level debug
  63 }
  64
  65 `
  66
  67 const (
  68         defaultCliSocketFilePath = "/var/run/vpp/cli.sock"
  69         defaultApiSocketFilePath = "/var/run/vpp/api.sock"
  70         defaultLogFilePath       = "/var/log/vpp/vpp.log"
  71 )
  72
  73 type VppInstance struct {
  74         container        *Container
  75         additionalConfig Stanza
  76         connection       *core.Connection
  77         apiChannel       api.Channel
  78 }
  79
  80 func (vpp *VppInstance) Suite() *HstSuite {
  81         return vpp.container.suite
  82 }
  83
  84 func (vpp *VppInstance) getCliSocket() string {
  85         return fmt.Sprintf("%s%s", vpp.container.GetContainerWorkDir(), defaultCliSocketFilePath)
  86 }
  87
  88 func (vpp *VppInstance) getRunDir() string {
  89         return vpp.container.GetContainerWorkDir() + "/var/run/vpp"
  90 }
  91
  92 func (vpp *VppInstance) getLogDir() string {
  93         return vpp.container.GetContainerWorkDir() + "/var/log/vpp"
  94 }
  95
  96 func (vpp *VppInstance) getEtcDir() string {
  97         return vpp.container.GetContainerWorkDir() + "/etc/vpp"
  98 }
  99
 100 func (vpp *VppInstance) start() error {
 101         // Create folders
 102         containerWorkDir := vpp.container.GetContainerWorkDir()
 103
 104         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getRunDir())
 105         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getLogDir())
 106         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getEtcDir())
 107
 108         // Create startup.conf inside the container
 109         configContent := fmt.Sprintf(
 110                 vppConfigTemplate,
 111                 containerWorkDir,
 112                 defaultCliSocketFilePath,
 113                 defaultApiSocketFilePath,
 114                 defaultLogFilePath,
 115         )
 116         configContent += vpp.additionalConfig.ToString()
 117         startupFileName := vpp.getEtcDir() + "/startup.conf"
 118         vpp.container.createFile(startupFileName, configContent)
 119
 120         // create wrapper script for vppctl with proper CLI socket path
 121         cliContent := "#!/usr/bin/bash\nvppctl -s " + vpp.getRunDir() + "/cli.sock"
 122         vppcliFileName := "/usr/bin/vppcli"
 123         vpp.container.createFile(vppcliFileName, cliContent)
 124         vpp.container.exec("chmod 0755 " + vppcliFileName)
 125
 126         if *IsVppDebug {
 127                 sig := make(chan os.Signal, 1)
 128                 signal.Notify(sig, syscall.SIGINT)
 129                 cont := make(chan bool, 1)
 130                 go func() {
 131                         <-sig
 132                         cont <- true
 133                 }()
 134
 135                 // Start VPP in GDB and wait for user to attach it
 136                 vpp.container.execServer("su -c \"gdb -ex run --args vpp -c " + startupFileName + " &> /proc/1/fd/1\"")
 137                 fmt.Println("run following command in different terminal:")
 138                 fmt.Println("docker exec -it " + vpp.container.name + " gdb -ex \"attach $(docker exec " + vpp.container.name + " pidof gdb)\"")
 139                 fmt.Println("Afterwards press CTRL+C to continue")
 140                 <-cont
 141                 fmt.Println("continuing...")
 142         } else {
 143                 // Start VPP
 144                 vpp.container.execServer("su -c \"vpp -c " + startupFileName + " &> /proc/1/fd/1\"")
 145         }
 146
 147         // Connect to VPP and store the connection
 148         sockAddress := vpp.container.GetHostWorkDir() + defaultApiSocketFilePath
 149         conn, connEv, err := govpp.AsyncConnect(
 150                 sockAddress,
 151                 core.DefaultMaxReconnectAttempts,
 152                 core.DefaultReconnectInterval)
 153         if err != nil {
 154                 fmt.Println("async connect error: ", err)
 155         }
 156         vpp.connection = conn
 157
 158         // ... wait for Connected event
 159         e := <-connEv
 160         if e.State != core.Connected {
 161                 fmt.Println("connecting to VPP failed: ", e.Error)
 162         }
 163
 164         // ... check compatibility of used messages
 165         ch, err := conn.NewAPIChannel()
 166         if err != nil {
 167                 fmt.Println("creating channel failed: ", err)
 168         }
 169         if err := ch.CheckCompatiblity(vpe.AllMessages()...); err != nil {
 170                 fmt.Println("compatibility error: ", err)
 171         }
 172         if err := ch.CheckCompatiblity(interfaces.AllMessages()...); err != nil {
 173                 fmt.Println("compatibility error: ", err)
 174         }
 175         vpp.apiChannel = ch
 176
 177         return nil
 178 }
 179
 180 func (vpp *VppInstance) vppctl(command string, arguments ...any) string {
 181         vppCliCommand := fmt.Sprintf(command, arguments...)
 182         containerExecCommand := fmt.Sprintf("docker exec --detach=false %[1]s vppctl -s %[2]s %[3]s",
 183                 vpp.container.name, vpp.getCliSocket(), vppCliCommand)
 184         vpp.Suite().log(containerExecCommand)
 185         output, err := exechelper.CombinedOutput(containerExecCommand)
 186         vpp.Suite().assertNil(err)
 187
 188         return string(output)
 189 }
 190
 191 func (vpp *VppInstance) waitForApp(appName string, timeout int) {
 192         for i := 0; i < timeout; i++ {
 193                 o := vpp.vppctl("show app")
 194                 if strings.Contains(o, appName) {
 195                         return
 196                 }
 197                 time.Sleep(1 * time.Second)
 198         }
 199         vpp.Suite().assertNil(1, "Timeout while waiting for app '%s'", appName)
 200         return
 201 }
 202
 203 func (vpp *VppInstance) createAfPacket(
 204         veth *NetInterface,
 205 ) (interface_types.InterfaceIndex, error) {
 206         createReq := &af_packet.AfPacketCreateV2{
 207                 UseRandomHwAddr: true,
 208                 HostIfName:      veth.Name(),
 209         }
 210         if veth.HwAddress() != (MacAddress{}) {
 211                 createReq.UseRandomHwAddr = false
 212                 createReq.HwAddr = veth.HwAddress()
 213         }
 214         createReply := &af_packet.AfPacketCreateV2Reply{}
 215
 216         if err := vpp.apiChannel.SendRequest(createReq).ReceiveReply(createReply); err != nil {
 217                 return 0, err
 218         }
 219         veth.SetIndex(createReply.SwIfIndex)
 220
 221         // Set to up
 222         upReq := &interfaces.SwInterfaceSetFlags{
 223                 SwIfIndex: veth.Index(),
 224                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 225         }
 226         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 227
 228         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 229                 return 0, err
 230         }
 231
 232         // Add address
 233         if veth.AddressWithPrefix() == (AddressWithPrefix{}) {
 234                 var err error
 235                 var ip4Address string
 236                 if ip4Address, err = veth.addresser.NewIp4Address(veth.Peer().networkNumber); err == nil {
 237                         veth.SetAddress(ip4Address)
 238                 } else {
 239                         return 0, err
 240                 }
 241         }
 242         addressReq := &interfaces.SwInterfaceAddDelAddress{
 243                 IsAdd:     true,
 244                 SwIfIndex: veth.Index(),
 245                 Prefix:    veth.AddressWithPrefix(),
 246         }
 247         addressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 248
 249         if err := vpp.apiChannel.SendRequest(addressReq).ReceiveReply(addressReply); err != nil {
 250                 return 0, err
 251         }
 252
 253         return veth.Index(), nil
 254 }
 255
 256 func (vpp *VppInstance) addAppNamespace(
 257         secret uint64,
 258         ifx interface_types.InterfaceIndex,
 259         namespaceId string,
 260 ) error {
 261         req := &session.AppNamespaceAddDelV2{
 262                 Secret:      secret,
 263                 SwIfIndex:   ifx,
 264                 NamespaceID: namespaceId,
 265         }
 266         reply := &session.AppNamespaceAddDelV2Reply{}
 267
 268         if err := vpp.apiChannel.SendRequest(req).ReceiveReply(reply); err != nil {
 269                 return err
 270         }
 271
 272         sessionReq := &session.SessionEnableDisable{
 273                 IsEnable: true,
 274         }
 275         sessionReply := &session.SessionEnableDisableReply{}
 276
 277         if err := vpp.apiChannel.SendRequest(sessionReq).ReceiveReply(sessionReply); err != nil {
 278                 return err
 279         }
 280
 281         return nil
 282 }
 283
 284 func (vpp *VppInstance) createTap(
 285         tap *NetInterface,
 286         tapId ...uint32,
 287 ) error {
 288         var id uint32 = 1
 289         if len(tapId) > 0 {
 290                 id = tapId[0]
 291         }
 292         createTapReq := &tapv2.TapCreateV2{
 293                 ID:               id,
 294                 HostIfNameSet:    true,
 295                 HostIfName:       tap.Name(),
 296                 HostIP4PrefixSet: true,
 297                 HostIP4Prefix:    tap.IP4AddressWithPrefix(),
 298         }
 299         createTapReply := &tapv2.TapCreateV2Reply{}
 300
 301         // Create tap interface
 302         if err := vpp.apiChannel.SendRequest(createTapReq).ReceiveReply(createTapReply); err != nil {
 303                 return err
 304         }
 305
 306         // Add address
 307         addAddressReq := &interfaces.SwInterfaceAddDelAddress{
 308                 IsAdd:     true,
 309                 SwIfIndex: createTapReply.SwIfIndex,
 310                 Prefix:    tap.Peer().AddressWithPrefix(),
 311         }
 312         addAddressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 313
 314         if err := vpp.apiChannel.SendRequest(addAddressReq).ReceiveReply(addAddressReply); err != nil {
 315                 return err
 316         }
 317
 318         // Set interface to up
 319         upReq := &interfaces.SwInterfaceSetFlags{
 320                 SwIfIndex: createTapReply.SwIfIndex,
 321                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 322         }
 323         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 324
 325         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 326                 return err
 327         }
 328
 329         return nil
 330 }
 331
 332 func (vpp *VppInstance) saveLogs() {
 333         logTarget := vpp.container.getLogDirPath() + "vppinstance-" + vpp.container.name + ".log"
 334         logSource := vpp.container.GetHostWorkDir() + defaultLogFilePath
 335         cmd := exec.Command("cp", logSource, logTarget)
 336         vpp.Suite().T().Helper()
 337         vpp.Suite().log(cmd.String())
 338         cmd.Run()
 339 }
 340
 341 func (vpp *VppInstance) disconnect() {
 342         vpp.connection.Disconnect()
 343         vpp.apiChannel.Close()
 344 }