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         cpus             []int
  79 }
  80
  81 func (vpp *VppInstance) getSuite() *HstSuite {
  82         return vpp.container.suite
  83 }
  84
  85 func (vpp *VppInstance) getCliSocket() string {
  86         return fmt.Sprintf("%s%s", vpp.container.getContainerWorkDir(), defaultCliSocketFilePath)
  87 }
  88
  89 func (vpp *VppInstance) getRunDir() string {
  90         return vpp.container.getContainerWorkDir() + "/var/run/vpp"
  91 }
  92
  93 func (vpp *VppInstance) getLogDir() string {
  94         return vpp.container.getContainerWorkDir() + "/var/log/vpp"
  95 }
  96
  97 func (vpp *VppInstance) getEtcDir() string {
  98         return vpp.container.getContainerWorkDir() + "/etc/vpp"
  99 }
 100
 101 func (vpp *VppInstance) start() error {
 102         // Create folders
 103         containerWorkDir := vpp.container.getContainerWorkDir()
 104
 105         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getRunDir())
 106         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getLogDir())
 107         vpp.container.exec("mkdir --mode=0700 -p " + vpp.getEtcDir())
 108
 109         // Create startup.conf inside the container
 110         configContent := fmt.Sprintf(
 111                 vppConfigTemplate,
 112                 containerWorkDir,
 113                 defaultCliSocketFilePath,
 114                 defaultApiSocketFilePath,
 115                 defaultLogFilePath,
 116         )
 117         configContent += vpp.generateCpuConfig()
 118         for _, c := range vpp.additionalConfig {
 119                 configContent += c.toString()
 120         }
 121         startupFileName := vpp.getEtcDir() + "/startup.conf"
 122         vpp.container.createFile(startupFileName, configContent)
 123
 124         // create wrapper script for vppctl with proper CLI socket path
 125         cliContent := "#!/usr/bin/bash\nvppctl -s " + vpp.getRunDir() + "/cli.sock"
 126         vppcliFileName := "/usr/bin/vppcli"
 127         vpp.container.createFile(vppcliFileName, cliContent)
 128         vpp.container.exec("chmod 0755 " + vppcliFileName)
 129
 130         if *isVppDebug {
 131                 sig := make(chan os.Signal, 1)
 132                 signal.Notify(sig, syscall.SIGINT)
 133                 cont := make(chan bool, 1)
 134                 go func() {
 135                         <-sig
 136                         cont <- true
 137                 }()
 138
 139                 // Start VPP in GDB and wait for user to attach it
 140                 vpp.container.execServer("su -c \"gdb -ex run --args vpp -c " + startupFileName + " &> /proc/1/fd/1\"")
 141                 fmt.Println("run following command in different terminal:")
 142                 fmt.Println("docker exec -it " + vpp.container.name + " gdb -ex \"attach $(docker exec " + vpp.container.name + " pidof gdb)\"")
 143                 fmt.Println("Afterwards press CTRL+C to continue")
 144                 <-cont
 145                 fmt.Println("continuing...")
 146         } else {
 147                 // Start VPP
 148                 vpp.container.execServer("su -c \"vpp -c " + startupFileName + " &> /proc/1/fd/1\"")
 149         }
 150
 151         // Connect to VPP and store the connection
 152         sockAddress := vpp.container.getHostWorkDir() + defaultApiSocketFilePath
 153         conn, connEv, err := govpp.AsyncConnect(
 154                 sockAddress,
 155                 core.DefaultMaxReconnectAttempts,
 156                 core.DefaultReconnectInterval)
 157         if err != nil {
 158                 fmt.Println("async connect error: ", err)
 159         }
 160         vpp.connection = conn
 161
 162         // ... wait for Connected event
 163         e := <-connEv
 164         if e.State != core.Connected {
 165                 fmt.Println("connecting to VPP failed: ", e.Error)
 166         }
 167
 168         // ... check compatibility of used messages
 169         ch, err := conn.NewAPIChannel()
 170         if err != nil {
 171                 fmt.Println("creating channel failed: ", err)
 172         }
 173         if err := ch.CheckCompatiblity(vpe.AllMessages()...); err != nil {
 174                 fmt.Println("compatibility error: ", err)
 175         }
 176         if err := ch.CheckCompatiblity(interfaces.AllMessages()...); err != nil {
 177                 fmt.Println("compatibility error: ", err)
 178         }
 179         vpp.apiChannel = ch
 180
 181         return nil
 182 }
 183
 184 func (vpp *VppInstance) vppctl(command string, arguments ...any) string {
 185         vppCliCommand := fmt.Sprintf(command, arguments...)
 186         containerExecCommand := fmt.Sprintf("docker exec --detach=false %[1]s vppctl -s %[2]s %[3]s",
 187                 vpp.container.name, vpp.getCliSocket(), vppCliCommand)
 188         vpp.getSuite().log(containerExecCommand)
 189         output, err := exechelper.CombinedOutput(containerExecCommand)
 190         vpp.getSuite().assertNil(err)
 191
 192         return string(output)
 193 }
 194
 195 func (vpp *VppInstance) waitForApp(appName string, timeout int) {
 196         for i := 0; i < timeout; i++ {
 197                 o := vpp.vppctl("show app")
 198                 if strings.Contains(o, appName) {
 199                         return
 200                 }
 201                 time.Sleep(1 * time.Second)
 202         }
 203         vpp.getSuite().assertNil(1, "Timeout while waiting for app '%s'", appName)
 204 }
 205
 206 func (vpp *VppInstance) createAfPacket(
 207         veth *NetInterface,
 208 ) (interface_types.InterfaceIndex, error) {
 209         createReq := &af_packet.AfPacketCreateV2{
 210                 UseRandomHwAddr: true,
 211                 HostIfName:      veth.Name(),
 212         }
 213         if veth.hwAddress != (MacAddress{}) {
 214                 createReq.UseRandomHwAddr = false
 215                 createReq.HwAddr = veth.hwAddress
 216         }
 217         createReply := &af_packet.AfPacketCreateV2Reply{}
 218
 219         if err := vpp.apiChannel.SendRequest(createReq).ReceiveReply(createReply); err != nil {
 220                 return 0, err
 221         }
 222         veth.index = createReply.SwIfIndex
 223
 224         // Set to up
 225         upReq := &interfaces.SwInterfaceSetFlags{
 226                 SwIfIndex: veth.index,
 227                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 228         }
 229         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 230
 231         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 232                 return 0, err
 233         }
 234
 235         // Add address
 236         if veth.addressWithPrefix() == (AddressWithPrefix{}) {
 237                 var err error
 238                 var ip4Address string
 239                 if ip4Address, err = veth.addresser.newIp4Address(veth.peer.networkNumber); err == nil {
 240                         veth.ip4Address = ip4Address
 241                 } else {
 242                         return 0, err
 243                 }
 244         }
 245         addressReq := &interfaces.SwInterfaceAddDelAddress{
 246                 IsAdd:     true,
 247                 SwIfIndex: veth.index,
 248                 Prefix:    veth.addressWithPrefix(),
 249         }
 250         addressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 251
 252         if err := vpp.apiChannel.SendRequest(addressReq).ReceiveReply(addressReply); err != nil {
 253                 return 0, err
 254         }
 255
 256         return veth.index, nil
 257 }
 258
 259 func (vpp *VppInstance) addAppNamespace(
 260         secret uint64,
 261         ifx interface_types.InterfaceIndex,
 262         namespaceId string,
 263 ) error {
 264         req := &session.AppNamespaceAddDelV2{
 265                 Secret:      secret,
 266                 SwIfIndex:   ifx,
 267                 NamespaceID: namespaceId,
 268         }
 269         reply := &session.AppNamespaceAddDelV2Reply{}
 270
 271         if err := vpp.apiChannel.SendRequest(req).ReceiveReply(reply); err != nil {
 272                 return err
 273         }
 274
 275         sessionReq := &session.SessionEnableDisable{
 276                 IsEnable: true,
 277         }
 278         sessionReply := &session.SessionEnableDisableReply{}
 279
 280         if err := vpp.apiChannel.SendRequest(sessionReq).ReceiveReply(sessionReply); err != nil {
 281                 return err
 282         }
 283
 284         return nil
 285 }
 286
 287 func (vpp *VppInstance) createTap(
 288         tap *NetInterface,
 289         tapId ...uint32,
 290 ) error {
 291         var id uint32 = 1
 292         if len(tapId) > 0 {
 293                 id = tapId[0]
 294         }
 295         createTapReq := &tapv2.TapCreateV2{
 296                 ID:               id,
 297                 HostIfNameSet:    true,
 298                 HostIfName:       tap.Name(),
 299                 HostIP4PrefixSet: true,
 300                 HostIP4Prefix:    tap.ip4AddressWithPrefix(),
 301         }
 302         createTapReply := &tapv2.TapCreateV2Reply{}
 303
 304         // Create tap interface
 305         if err := vpp.apiChannel.SendRequest(createTapReq).ReceiveReply(createTapReply); err != nil {
 306                 return err
 307         }
 308
 309         // Add address
 310         addAddressReq := &interfaces.SwInterfaceAddDelAddress{
 311                 IsAdd:     true,
 312                 SwIfIndex: createTapReply.SwIfIndex,
 313                 Prefix:    tap.peer.addressWithPrefix(),
 314         }
 315         addAddressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 316
 317         if err := vpp.apiChannel.SendRequest(addAddressReq).ReceiveReply(addAddressReply); err != nil {
 318                 return err
 319         }
 320
 321         // Set interface to up
 322         upReq := &interfaces.SwInterfaceSetFlags{
 323                 SwIfIndex: createTapReply.SwIfIndex,
 324                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 325         }
 326         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 327
 328         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 329                 return err
 330         }
 331
 332         return nil
 333 }
 334
 335 func (vpp *VppInstance) saveLogs() {
 336         logTarget := vpp.container.getLogDirPath() + "vppinstance-" + vpp.container.name + ".log"
 337         logSource := vpp.container.getHostWorkDir() + defaultLogFilePath
 338         cmd := exec.Command("cp", logSource, logTarget)
 339         vpp.getSuite().T().Helper()
 340         vpp.getSuite().log(cmd.String())
 341         cmd.Run()
 342 }
 343
 344 func (vpp *VppInstance) disconnect() {
 345         vpp.connection.Disconnect()
 346         vpp.apiChannel.Close()
 347 }
 348
 349 func (vpp *VppInstance) generateCpuConfig() string {
 350         var c Stanza
 351         var s string
 352         if len(vpp.cpus) < 1 {
 353                 return ""
 354         }
 355         c.newStanza("cpu").
 356                 append(fmt.Sprintf("main-core %d", vpp.cpus[0]))
 357         workers := vpp.cpus[1:]
 358
 359         if len(workers) > 0 {
 360                 for i := 0; i < len(workers); i++ {
 361                         if i != 0 {
 362                                 s = s + ", "
 363                         }
 364                         s = s + fmt.Sprintf("%d", workers[i])
 365                 }
 366                 c.append(fmt.Sprintf("corelist-workers %s", s))
 367         }
 368         return c.close().toString()
 369 }