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) getSuite() *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.getSuite().log(containerExecCommand)
 185         output, err := exechelper.CombinedOutput(containerExecCommand)
 186         vpp.getSuite().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.getSuite().assertNil(1, "Timeout while waiting for app '%s'", appName)
 200 }
 201
 202 func (vpp *VppInstance) createAfPacket(
 203         veth *NetInterface,
 204 ) (interface_types.InterfaceIndex, error) {
 205         createReq := &af_packet.AfPacketCreateV2{
 206                 UseRandomHwAddr: true,
 207                 HostIfName:      veth.Name(),
 208         }
 209         if veth.hwAddress != (MacAddress{}) {
 210                 createReq.UseRandomHwAddr = false
 211                 createReq.HwAddr = veth.hwAddress
 212         }
 213         createReply := &af_packet.AfPacketCreateV2Reply{}
 214
 215         if err := vpp.apiChannel.SendRequest(createReq).ReceiveReply(createReply); err != nil {
 216                 return 0, err
 217         }
 218         veth.index = createReply.SwIfIndex
 219
 220         // Set to up
 221         upReq := &interfaces.SwInterfaceSetFlags{
 222                 SwIfIndex: veth.index,
 223                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 224         }
 225         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 226
 227         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 228                 return 0, err
 229         }
 230
 231         // Add address
 232         if veth.addressWithPrefix() == (AddressWithPrefix{}) {
 233                 var err error
 234                 var ip4Address string
 235                 if ip4Address, err = veth.addresser.newIp4Address(veth.peer.networkNumber); err == nil {
 236                         veth.ip4Address = ip4Address
 237                 } else {
 238                         return 0, err
 239                 }
 240         }
 241         addressReq := &interfaces.SwInterfaceAddDelAddress{
 242                 IsAdd:     true,
 243                 SwIfIndex: veth.index,
 244                 Prefix:    veth.addressWithPrefix(),
 245         }
 246         addressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 247
 248         if err := vpp.apiChannel.SendRequest(addressReq).ReceiveReply(addressReply); err != nil {
 249                 return 0, err
 250         }
 251
 252         return veth.index, nil
 253 }
 254
 255 func (vpp *VppInstance) addAppNamespace(
 256         secret uint64,
 257         ifx interface_types.InterfaceIndex,
 258         namespaceId string,
 259 ) error {
 260         req := &session.AppNamespaceAddDelV2{
 261                 Secret:      secret,
 262                 SwIfIndex:   ifx,
 263                 NamespaceID: namespaceId,
 264         }
 265         reply := &session.AppNamespaceAddDelV2Reply{}
 266
 267         if err := vpp.apiChannel.SendRequest(req).ReceiveReply(reply); err != nil {
 268                 return err
 269         }
 270
 271         sessionReq := &session.SessionEnableDisable{
 272                 IsEnable: true,
 273         }
 274         sessionReply := &session.SessionEnableDisableReply{}
 275
 276         if err := vpp.apiChannel.SendRequest(sessionReq).ReceiveReply(sessionReply); err != nil {
 277                 return err
 278         }
 279
 280         return nil
 281 }
 282
 283 func (vpp *VppInstance) createTap(
 284         tap *NetInterface,
 285         tapId ...uint32,
 286 ) error {
 287         var id uint32 = 1
 288         if len(tapId) > 0 {
 289                 id = tapId[0]
 290         }
 291         createTapReq := &tapv2.TapCreateV2{
 292                 ID:               id,
 293                 HostIfNameSet:    true,
 294                 HostIfName:       tap.Name(),
 295                 HostIP4PrefixSet: true,
 296                 HostIP4Prefix:    tap.ip4AddressWithPrefix(),
 297         }
 298         createTapReply := &tapv2.TapCreateV2Reply{}
 299
 300         // Create tap interface
 301         if err := vpp.apiChannel.SendRequest(createTapReq).ReceiveReply(createTapReply); err != nil {
 302                 return err
 303         }
 304
 305         // Add address
 306         addAddressReq := &interfaces.SwInterfaceAddDelAddress{
 307                 IsAdd:     true,
 308                 SwIfIndex: createTapReply.SwIfIndex,
 309                 Prefix:    tap.peer.addressWithPrefix(),
 310         }
 311         addAddressReply := &interfaces.SwInterfaceAddDelAddressReply{}
 312
 313         if err := vpp.apiChannel.SendRequest(addAddressReq).ReceiveReply(addAddressReply); err != nil {
 314                 return err
 315         }
 316
 317         // Set interface to up
 318         upReq := &interfaces.SwInterfaceSetFlags{
 319                 SwIfIndex: createTapReply.SwIfIndex,
 320                 Flags:     interface_types.IF_STATUS_API_FLAG_ADMIN_UP,
 321         }
 322         upReply := &interfaces.SwInterfaceSetFlagsReply{}
 323
 324         if err := vpp.apiChannel.SendRequest(upReq).ReceiveReply(upReply); err != nil {
 325                 return err
 326         }
 327
 328         return nil
 329 }
 330
 331 func (vpp *VppInstance) saveLogs() {
 332         logTarget := vpp.container.getLogDirPath() + "vppinstance-" + vpp.container.name + ".log"
 333         logSource := vpp.container.getHostWorkDir() + defaultLogFilePath
 334         cmd := exec.Command("cp", logSource, logTarget)
 335         vpp.getSuite().T().Helper()
 336         vpp.getSuite().log(cmd.String())
 337         cmd.Run()
 338 }
 339
 340 func (vpp *VppInstance) disconnect() {
 341         vpp.connection.Disconnect()
 342         vpp.apiChannel.Close()
 343 }