extras/hs-test/netconfig.go

   1 package main
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "os/exec"
   7         "strings"
   8
   9         "go.fd.io/govpp/binapi/ethernet_types"
  10         "go.fd.io/govpp/binapi/interface_types"
  11         "go.fd.io/govpp/binapi/ip_types"
  12 )
  13
  14 type (
  15         MacAddress           = ethernet_types.MacAddress
  16         AddressWithPrefix    = ip_types.AddressWithPrefix
  17         IP4AddressWithPrefix = ip_types.IP4AddressWithPrefix
  18         InterfaceIndex       = interface_types.InterfaceIndex
  19
  20         NetConfig interface {
  21                 Configure() error
  22                 Unconfigure()
  23                 Name() string
  24                 Type() string
  25         }
  26
  27         NetConfigBase struct {
  28                 name     string
  29                 category string // what else to call this when `type` is reserved?
  30         }
  31
  32         NetInterface interface {
  33                 NetConfig
  34                 SetAddress(string)
  35                 AddressWithPrefix() AddressWithPrefix
  36                 IP4AddressWithPrefix() IP4AddressWithPrefix
  37                 IP4AddressString() string
  38                 SetIndex(InterfaceIndex)
  39                 Index() InterfaceIndex
  40                 HwAddress() MacAddress
  41         }
  42
  43         NetInterfaceBase struct {
  44                 NetConfigBase
  45                 addresser  *Addresser
  46                 ip4address string // this will have form 10.10.10.1/24
  47                 index      InterfaceIndex
  48                 hwAddress  MacAddress
  49         }
  50
  51         NetworkInterfaceVeth struct {
  52                 NetInterfaceBase
  53                 peerNetworkNamespace string
  54                 peerName             string
  55                 peerIp4Address       string
  56         }
  57
  58         NetworkInterfaceTap struct {
  59                 NetInterfaceBase
  60         }
  61
  62         NetworkNamespace struct {
  63                 NetConfigBase
  64         }
  65
  66         NetworkBridge struct {
  67                 NetConfigBase
  68                 networkNamespace string
  69                 interfaces       []string
  70         }
  71 )
  72
  73 const (
  74         NetNs  string = "netns"
  75         Veth   string = "veth"
  76         Tap    string = "tap"
  77         Bridge string = "bridge"
  78 )
  79
  80 func (b *NetConfigBase) Name() string {
  81         return b.name
  82 }
  83
  84 func (b *NetConfigBase) Type() string {
  85         return b.category
  86 }
  87
  88 func (b *NetInterfaceBase) SetAddress(address string) {
  89         b.ip4address = address
  90 }
  91
  92 func (b *NetInterfaceBase) SetIndex(index InterfaceIndex) {
  93         b.index = index
  94 }
  95
  96 func (b *NetInterfaceBase) Index() InterfaceIndex {
  97         return b.index
  98 }
  99
 100 func (b *NetInterfaceBase) AddressWithPrefix() AddressWithPrefix {
 101         address, _ := ip_types.ParseAddressWithPrefix(b.ip4address)
 102         return address
 103 }
 104
 105 func (b *NetInterfaceBase) IP4AddressWithPrefix() IP4AddressWithPrefix {
 106         IP4Prefix, _ := ip_types.ParseIP4Prefix(b.ip4address)
 107         IP4AddressWithPrefix := ip_types.IP4AddressWithPrefix(IP4Prefix)
 108         return IP4AddressWithPrefix
 109 }
 110
 111 func (b *NetInterfaceBase) IP4AddressString() string {
 112         return strings.Split(b.ip4address, "/")[0]
 113 }
 114
 115 func (b *NetInterfaceBase) HwAddress() MacAddress {
 116         return b.hwAddress
 117 }
 118
 119 func (iface *NetworkInterfaceVeth) Configure() error {
 120         err := AddVethPair(iface.name, iface.peerName)
 121         if err != nil {
 122                 return err
 123         }
 124
 125         if iface.peerNetworkNamespace != "" {
 126                 err := LinkSetNetns(iface.peerName, iface.peerNetworkNamespace)
 127                 if err != nil {
 128                         return err
 129                 }
 130         }
 131
 132         if iface.peerIp4Address != "" {
 133                 err = AddAddress(iface.peerName, iface.peerIp4Address, iface.peerNetworkNamespace)
 134                 if err != nil {
 135                         return fmt.Errorf("failed to add configure address for %s: %v", iface.peerName, err)
 136                 }
 137         }
 138         return nil
 139 }
 140
 141 func NewVeth(cfg NetDevConfig, a *Addresser) (NetworkInterfaceVeth, error) {
 142         var veth NetworkInterfaceVeth
 143         var err error
 144         veth.addresser = a
 145         veth.name = cfg["name"].(string)
 146         veth.category = "veth"
 147
 148         if cfg["preset-hw-address"] != nil {
 149                 veth.hwAddress, err = ethernet_types.ParseMacAddress(cfg["preset-hw-address"].(string))
 150                 if err != nil {
 151                         return NetworkInterfaceVeth{}, err
 152                 }
 153         }
 154
 155         peer := cfg["peer"].(NetDevConfig)
 156
 157         veth.peerName = peer["name"].(string)
 158
 159         if peer["netns"] != nil {
 160                 veth.peerNetworkNamespace = peer["netns"].(string)
 161         }
 162
 163         if peer["ip4"] != nil && peer["ip4"].(bool) == true {
 164                 veth.peerIp4Address, err = veth.addresser.
 165                         NewIp4AddressWithNamespace(veth.peerNetworkNamespace)
 166                 if err != nil {
 167                         return NetworkInterfaceVeth{}, err
 168                 }
 169         }
 170
 171         return veth, nil
 172 }
 173
 174 func (iface *NetworkInterfaceVeth) Unconfigure() {
 175         DelLink(iface.name)
 176 }
 177
 178 func (iface *NetworkInterfaceVeth) PeerIp4AddressString() string {
 179         return strings.Split(iface.peerIp4Address, "/")[0]
 180 }
 181
 182 func NewTap(cfg NetDevConfig, a *Addresser) (NetworkInterfaceTap, error) {
 183         var tap NetworkInterfaceTap
 184         tap.addresser = a
 185         tap.name = cfg["name"].(string)
 186         tap.category = "tap"
 187         ip4Address, err := tap.addresser.NewIp4Address()
 188         if err != nil {
 189                 return NetworkInterfaceTap{}, err
 190         }
 191         tap.SetAddress(ip4Address)
 192         return tap, nil
 193 }
 194
 195 func (iface *NetworkInterfaceTap) Configure() error {
 196         err := AddTap(iface.name, iface.IP4AddressString())
 197         if err != nil {
 198                 return err
 199         }
 200         return nil
 201 }
 202
 203 func (iface *NetworkInterfaceTap) Unconfigure() {
 204         DelLink(iface.name)
 205 }
 206
 207 func NewNetNamespace(cfg NetDevConfig) (NetworkNamespace, error) {
 208         var networkNamespace NetworkNamespace
 209         networkNamespace.name = cfg["name"].(string)
 210         networkNamespace.category = "netns"
 211         return networkNamespace, nil
 212 }
 213
 214 func (ns *NetworkNamespace) Configure() error {
 215         return addDelNetns(ns.name, true)
 216 }
 217
 218 func (ns *NetworkNamespace) Unconfigure() {
 219         addDelNetns(ns.name, false)
 220 }
 221
 222 func NewBridge(cfg NetDevConfig) (NetworkBridge, error) {
 223         var bridge NetworkBridge
 224         bridge.name = cfg["name"].(string)
 225         bridge.category = "bridge"
 226         for _, v := range cfg["interfaces"].([]interface{}) {
 227                 bridge.interfaces = append(bridge.interfaces, v.(string))
 228         }
 229         bridge.networkNamespace = cfg["netns"].(string)
 230         return bridge, nil
 231 }
 232
 233 func (b *NetworkBridge) Configure() error {
 234         return AddBridge(b.name, b.interfaces, b.networkNamespace)
 235 }
 236
 237 func (b *NetworkBridge) Unconfigure() {
 238         DelBridge(b.name, b.networkNamespace)
 239 }
 240
 241 func DelBridge(brName, ns string) error {
 242         err := SetDevDown(brName, ns)
 243         if err != err {
 244                 return err
 245         }
 246
 247         err = addDelBridge(brName, ns, false)
 248         if err != nil {
 249                 return err
 250         }
 251
 252         return nil
 253 }
 254
 255 func SetDevUp(dev, ns string) error {
 256         return setDevUpDown(dev, ns, true)
 257 }
 258
 259 func SetDevDown(dev, ns string) error {
 260         return setDevUpDown(dev, ns, false)
 261 }
 262
 263 func AddTap(ifName, ifAddress string) error {
 264         cmd := exec.Command("ip", "tuntap", "add", ifName, "mode", "tap")
 265         o, err := cmd.CombinedOutput()
 266         if err != nil {
 267                 s := fmt.Sprintf("error creating tap %s: %v: %s", ifName, err, string(o))
 268                 return errors.New(s)
 269         }
 270
 271         cmd = exec.Command("ip", "addr", "add", ifAddress, "dev", ifName)
 272         err = cmd.Run()
 273         if err != nil {
 274                 DelLink(ifName)
 275                 s := fmt.Sprintf("error setting addr for tap %s: %v", ifName, err)
 276                 return errors.New(s)
 277         }
 278
 279         err = SetDevUp(ifName, "")
 280         if err != nil {
 281                 DelLink(ifName)
 282                 return err
 283         }
 284         return nil
 285 }
 286
 287 func DelLink(ifName string) {
 288         cmd := exec.Command("ip", "link", "del", ifName)
 289         cmd.Run()
 290 }
 291
 292 func setDevUpDown(dev, ns string, isUp bool) error {
 293         var op string
 294         if isUp {
 295                 op = "up"
 296         } else {
 297                 op = "down"
 298         }
 299         c := []string{"ip", "link", "set", "dev", dev, op}
 300         cmd := appendNetns(c, ns)
 301         err := cmd.Run()
 302         if err != nil {
 303                 s := fmt.Sprintf("error bringing %s device %s!", dev, op)
 304                 return errors.New(s)
 305         }
 306         return nil
 307 }
 308
 309 func AddVethPair(ifName, peerName string) error {
 310         cmd := exec.Command("ip", "link", "add", ifName, "type", "veth", "peer", "name", peerName)
 311         err := cmd.Run()
 312         if err != nil {
 313                 return fmt.Errorf("creating veth pair failed: %v", err)
 314         }
 315         err = SetDevUp(ifName, "")
 316         if err != nil {
 317                 return fmt.Errorf("set link up failed: %v", err)
 318         }
 319         return nil
 320 }
 321
 322 func addDelNetns(name string, isAdd bool) error {
 323         var op string
 324         if isAdd {
 325                 op = "add"
 326         } else {
 327                 op = "del"
 328         }
 329         cmd := exec.Command("ip", "netns", op, name)
 330         _, err := cmd.CombinedOutput()
 331         if err != nil {
 332                 return errors.New("add/del netns failed")
 333         }
 334         return nil
 335 }
 336
 337 func AddNetns(nsName string) error {
 338         return addDelNetns(nsName, true)
 339 }
 340
 341 func DelNetns(nsName string) error {
 342         return addDelNetns(nsName, false)
 343 }
 344
 345 func LinkSetNetns(ifName, ns string) error {
 346         cmd := exec.Command("ip", "link", "set", "dev", ifName, "up", "netns", ns)
 347         err := cmd.Run()
 348         if err != nil {
 349                 return fmt.Errorf("error setting device '%s' to netns '%s: %v", ifName, ns, err)
 350         }
 351         return nil
 352 }
 353
 354 func NewCommand(s []string, ns string) *exec.Cmd {
 355         return appendNetns(s, ns)
 356 }
 357
 358 func appendNetns(s []string, ns string) *exec.Cmd {
 359         var cmd *exec.Cmd
 360         if ns == "" {
 361                 // use default namespace
 362                 cmd = exec.Command(s[0], s[1:]...)
 363         } else {
 364                 var args = []string{"netns", "exec", ns}
 365                 args = append(args, s[:]...)
 366                 cmd = exec.Command("ip", args...)
 367         }
 368         return cmd
 369 }
 370
 371 func addDelBridge(brName, ns string, isAdd bool) error {
 372         var op string
 373         if isAdd {
 374                 op = "addbr"
 375         } else {
 376                 op = "delbr"
 377         }
 378         var c = []string{"brctl", op, brName}
 379         cmd := appendNetns(c, ns)
 380         err := cmd.Run()
 381         if err != nil {
 382                 s := fmt.Sprintf("%s %s failed!", op, brName)
 383                 return errors.New(s)
 384         }
 385         return nil
 386 }
 387
 388 func AddBridge(brName string, ifs []string, ns string) error {
 389         err := addDelBridge(brName, ns, true)
 390         if err != nil {
 391                 return err
 392         }
 393
 394         for _, v := range ifs {
 395                 c := []string{"brctl", "addif", brName, v}
 396                 cmd := appendNetns(c, ns)
 397                 err = cmd.Run()
 398                 if err != nil {
 399                         s := fmt.Sprintf("error adding %s to bridge %s: %v", v, brName, err)
 400                         return errors.New(s)
 401                 }
 402         }
 403         err = SetDevUp(brName, ns)
 404         if err != nil {
 405                 return err
 406         }
 407         return nil
 408 }