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 configureBridge(dev NetDevConfig) error {
 256         var ifs []string
 257         for _, v := range dev["interfaces"].([]interface{}) {
 258                 ifs = append(ifs, v.(string))
 259         }
 260         return AddBridge(dev["name"].(string), ifs, dev["netns"].(string))
 261 }
 262
 263 func configureTap(dev NetDevConfig) error {
 264         return AddTap(dev["name"].(string), dev["ip4"].(string))
 265 }
 266
 267 func SetDevUp(dev, ns string) error {
 268         return setDevUpDown(dev, ns, true)
 269 }
 270
 271 func SetDevDown(dev, ns string) error {
 272         return setDevUpDown(dev, ns, false)
 273 }
 274
 275 func AddTap(ifName, ifAddress string) error {
 276         cmd := exec.Command("ip", "tuntap", "add", ifName, "mode", "tap")
 277         o, err := cmd.CombinedOutput()
 278         if err != nil {
 279                 s := fmt.Sprintf("error creating tap %s: %v: %s", ifName, err, string(o))
 280                 return errors.New(s)
 281         }
 282
 283         cmd = exec.Command("ip", "addr", "add", ifAddress, "dev", ifName)
 284         err = cmd.Run()
 285         if err != nil {
 286                 DelLink(ifName)
 287                 s := fmt.Sprintf("error setting addr for tap %s: %v", ifName, err)
 288                 return errors.New(s)
 289         }
 290
 291         err = SetDevUp(ifName, "")
 292         if err != nil {
 293                 DelLink(ifName)
 294                 return err
 295         }
 296         return nil
 297 }
 298
 299 func DelLink(ifName string) {
 300         cmd := exec.Command("ip", "link", "del", ifName)
 301         cmd.Run()
 302 }
 303
 304 func setDevUpDown(dev, ns string, isUp bool) error {
 305         var op string
 306         if isUp {
 307                 op = "up"
 308         } else {
 309                 op = "down"
 310         }
 311         c := []string{"ip", "link", "set", "dev", dev, op}
 312         cmd := appendNetns(c, ns)
 313         err := cmd.Run()
 314         if err != nil {
 315                 s := fmt.Sprintf("error bringing %s device %s!", dev, op)
 316                 return errors.New(s)
 317         }
 318         return nil
 319 }
 320
 321 func AddVethPair(ifName, peerName string) error {
 322         cmd := exec.Command("ip", "link", "add", ifName, "type", "veth", "peer", "name", peerName)
 323         err := cmd.Run()
 324         if err != nil {
 325                 return fmt.Errorf("creating veth pair failed: %v", err)
 326         }
 327         err = SetDevUp(ifName, "")
 328         if err != nil {
 329                 return fmt.Errorf("set link up failed: %v", err)
 330         }
 331         return nil
 332 }
 333
 334 func addDelNetns(name string, isAdd bool) error {
 335         var op string
 336         if isAdd {
 337                 op = "add"
 338         } else {
 339                 op = "del"
 340         }
 341         cmd := exec.Command("ip", "netns", op, name)
 342         _, err := cmd.CombinedOutput()
 343         if err != nil {
 344                 return errors.New("add/del netns failed")
 345         }
 346         return nil
 347 }
 348
 349 func AddNetns(nsName string) error {
 350         return addDelNetns(nsName, true)
 351 }
 352
 353 func DelNetns(nsName string) error {
 354         return addDelNetns(nsName, false)
 355 }
 356
 357 func LinkSetNetns(ifName, ns string) error {
 358         cmd := exec.Command("ip", "link", "set", "dev", ifName, "up", "netns", ns)
 359         err := cmd.Run()
 360         if err != nil {
 361                 return fmt.Errorf("error setting device '%s' to netns '%s: %v", ifName, ns, err)
 362         }
 363         return nil
 364 }
 365
 366 func NewCommand(s []string, ns string) *exec.Cmd {
 367         return appendNetns(s, ns)
 368 }
 369
 370 func appendNetns(s []string, ns string) *exec.Cmd {
 371         var cmd *exec.Cmd
 372         if ns == "" {
 373                 // use default namespace
 374                 cmd = exec.Command(s[0], s[1:]...)
 375         } else {
 376                 var args = []string{"netns", "exec", ns}
 377                 args = append(args, s[:]...)
 378                 cmd = exec.Command("ip", args...)
 379         }
 380         return cmd
 381 }
 382
 383 func addDelBridge(brName, ns string, isAdd bool) error {
 384         var op string
 385         if isAdd {
 386                 op = "addbr"
 387         } else {
 388                 op = "delbr"
 389         }
 390         var c = []string{"brctl", op, brName}
 391         cmd := appendNetns(c, ns)
 392         err := cmd.Run()
 393         if err != nil {
 394                 s := fmt.Sprintf("%s %s failed!", op, brName)
 395                 return errors.New(s)
 396         }
 397         return nil
 398 }
 399
 400 func AddBridge(brName string, ifs []string, ns string) error {
 401         err := addDelBridge(brName, ns, true)
 402         if err != nil {
 403                 return err
 404         }
 405
 406         for _, v := range ifs {
 407                 c := []string{"brctl", "addif", brName, v}
 408                 cmd := appendNetns(c, ns)
 409                 err = cmd.Run()
 410                 if err != nil {
 411                         s := fmt.Sprintf("error adding %s to bridge %s: %v", v, brName, err)
 412                         return errors.New(s)
 413                 }
 414         }
 415         err = SetDevUp(brName, ns)
 416         if err != nil {
 417                 return err
 418         }
 419         return nil
 420 }