extras/hs-test/vppinstance.go

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