interface_crud.go

package descriptor

import (
	"github.com/pkg/errors"

	"github.com/ligato/vpp-agent/api/models/netalloc"
	interfaces "github.com/ligato/vpp-agent/api/models/vpp/interfaces"
	"github.com/ligato/vpp-agent/pkg/models"
	kvs "github.com/ligato/vpp-agent/plugins/kvscheduler/api"
	nslinuxcalls "github.com/ligato/vpp-agent/plugins/linux/nsplugin/linuxcalls"
	"github.com/ligato/vpp-agent/plugins/vpp/ifplugin/descriptor/adapter"
	"github.com/ligato/vpp-agent/plugins/vpp/ifplugin/ifaceidx"
)

// Create creates a VPP interface.
func (d *InterfaceDescriptor) Create(key string, intf *interfaces.Interface) (metadata *ifaceidx.IfaceMetadata, err error) {
	var ifIdx uint32
	var tapHostIfName string

	// create the interface of the given type
	switch intf.Type {
	case interfaces.Interface_TAP:
		tapCfg := getTapConfig(intf)
		tapHostIfName = tapCfg.HostIfName
		ifIdx, err = d.ifHandler.AddTapInterface(intf.Name, tapCfg)
		if err != nil {
			d.log.Error(err)
			return nil, err
		}

		// TAP hardening: verify that the Linux side was created
		if d.linuxIfHandler != nil && d.nsPlugin != nil {
			// first, move to the default namespace and lock the thread
			nsCtx := nslinuxcalls.NewNamespaceMgmtCtx()
			revert, err := d.nsPlugin.SwitchToNamespace(nsCtx, nil)
			if err != nil {
				d.log.Error(err)
				return nil, err
			}
			exists, err := d.linuxIfHandler.InterfaceExists(tapHostIfName)
			revert()
			if err != nil {
				d.log.Error(err)
				return nil, err
			}
			if !exists {
				err = errors.Errorf("failed to create the Linux side (%s) of the TAP interface %s", tapHostIfName, intf.Name)
				d.log.Error(err)
				return nil, err
			}
		}

	case interfaces.Interface_MEMIF:
		var socketID uint32
		if socketID, err = d.resolveMemifSocketFilename(intf.GetMemif()); err != nil {
			d.log.Error(err)
			return nil, err
		}
		ifIdx, err = d.ifHandler.AddMemifInterface(intf.Name, intf.GetMemif(), socketID)
		if err != nil {
			d.log.Error(err)
			return nil, err
		}

	case interfaces.Interface_VXLAN_TUNNEL:
		var multicastIfIdx uint32
		multicastIf := intf.GetVxlan().GetMulticast()
		if multicastIf != "" {
			multicastMeta, found := d.intfIndex.LookupByName(multicastIf)
			if !found {
				err = errors.Errorf("failed to find multicast interface %s referenced by VXLAN %s",
					multicastIf, intf.Name)
				d.log.Error(err)
				return nil, err
			}
			multicastIfIdx = multicastMeta.SwIfIndex
		}

		if intf.GetVxlan().Gpe == nil {
			ifIdx, err = d.ifHandler.AddVxLanTunnel(intf.Name, intf.GetVrf(), multicastIfIdx, intf.GetVxlan())
		} else {
			ifIdx, err = d.ifHandler.AddVxLanGpeTunnel(intf.Name, intf.GetVrf(), multicastIfIdx, intf.GetVxlan())
		}
		if err != nil {
			d.log.Error(err)
			return nil, err
		}

	case interfaces.Interface_SOFTWARE_LOOPBACK:
		ifIdx, err = d.ifHandler.AddLoopbackInterface(intf.Name)
		if err != nil {
			d.log.Error(err)
			return nil, err
		}

	case interfaces.Interface_DPDK:
		var found bool
		ifIdx, found = d.ethernetIfs[intf.Name]
		if !found {
			err = errors.Errorf("failed to find physical interface %s", intf.Name)
			d.log.Error(err)
			return nil, err
		}

	case interfaces.Interface_AF_PACKET:
		ifIdx, err = d.ifHandler.AddAfPacketInterface(intf.Name, intf.GetPhysAddress(), intf.GetAfpacket())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
	case interfaces.Interface_IPSEC_TUNNEL:
		ifIdx, err = d.ifHandler.AddIPSecTunnelInterface(intf.Name, intf.GetIpsec())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
	case interfaces.Interface_SUB_INTERFACE:
		sub := intf.GetSub()
		parentMeta, found := d.intfIndex.LookupByName(sub.GetParentName())
		if !found {
			err = errors.Errorf("unable to find parent interface %s referenced by sub interface %s",
				sub.GetParentName(), intf.Name)
			d.log.Error(err)
			return nil, err
		}
		ifIdx, err = d.ifHandler.CreateSubif(parentMeta.SwIfIndex, sub.GetSubId())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
		err = d.ifHandler.SetInterfaceTag(intf.Name, ifIdx)
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
	case interfaces.Interface_VMXNET3_INTERFACE:
		ifIdx, err = d.ifHandler.AddVmxNet3(intf.Name, intf.GetVmxNet3())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
	case interfaces.Interface_BOND_INTERFACE:
		ifIdx, err = d.ifHandler.AddBondInterface(intf.Name, intf.PhysAddress, intf.GetBond())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
		d.bondIDs[intf.GetBond().GetId()] = intf.GetName()

	case interfaces.Interface_GRE_TUNNEL:
		ifIdx, err = d.ifHandler.AddGreTunnel(intf.Name, intf.GetGre())
		if err != nil {
			d.log.Error(err)
			return nil, err
		}
	}

	// MAC address. Note: physical interfaces cannot have the MAC address changed. The bond interface uses its own
	// binary API call to set MAC address.
	if intf.GetPhysAddress() != "" &&
		intf.GetType() != interfaces.Interface_AF_PACKET &&
		intf.GetType() != interfaces.Interface_DPDK &&
		intf.GetType() != interfaces.Interface_BOND_INTERFACE {
		if err = d.ifHandler.SetInterfaceMac(ifIdx, intf.GetPhysAddress()); err != nil {
			err = errors.Errorf("failed to set MAC address %s to interface %s: %v",
				intf.GetPhysAddress(), intf.Name, err)
			d.log.Error(err)
			return nil, err
		}
	}

	// configure MTU. Prefer value in the interface config, otherwise set the plugin-wide
	// default value if provided.
	if ifaceSupportsSetMTU(intf) {
		mtuToConfigure := intf.Mtu
		if mtuToConfigure == 0 && d.defaultMtu != 0 {
			mtuToConfigure = d.defaultMtu
		}
		if mtuToConfigure != 0 {
			if err = d.ifHandler.SetInterfaceMtu(ifIdx, mtuToConfigure); err != nil {
				err = errors.Errorf("failed to set MTU %d to interface %s: %v", mtuToConfigure, intf.Name, err)
				d.log.Error(err)
				return nil, err
			}
		}
	}

	// set vlan tag rewrite
	if intf.Type == interfaces.Interface_SUB_INTERFACE && intf.GetSub().TagRwOption != interfaces.SubInterface_DISABLED {
		if err := d.ifHandler.SetVLanTagRewrite(ifIdx, intf.GetSub()); err != nil {
			d.log.Error(err)
			return nil, err
		}
	}

	// set interface up if enabled
	if intf.Enabled {
		if err = d.ifHandler.InterfaceAdminUp(ifIdx); err != nil {
			err = errors.Errorf("failed to set interface %s up: %v", intf.Name, err)
			d.log.Error(err)
			return nil, err
		}
	}

	// fill the metadata
	metadata = &ifaceidx.IfaceMetadata{
		SwIfIndex:     ifIdx,
		Vrf:           intf.Vrf,
		IPAddresses:   intf.GetIpAddresses(),
		TAPHostIfName: tapHostIfName,
	}
	return metadata, nil
}

// Delete removes VPP interface.
func (d *InterfaceDescriptor) Delete(key string, intf *interfaces.Interface, metadata *ifaceidx.IfaceMetadata) error {
	var err error
	ifIdx := metadata.SwIfIndex

	// set interface to ADMIN_DOWN unless the type is AF_PACKET_INTERFACE
	if intf.Type != interfaces.Interface_AF_PACKET {
		if err := d.ifHandler.InterfaceAdminDown(ifIdx); err != nil {
			err = errors.Errorf("failed to set interface %s down: %v", intf.Name, err)
			d.log.Error(err)
			return err
		}
	}

	// remove the interface
	switch intf.Type {
	case interfaces.Interface_TAP:
		err = d.ifHandler.DeleteTapInterface(intf.Name, ifIdx, intf.GetTap().GetVersion())
	case interfaces.Interface_MEMIF:
		err = d.ifHandler.DeleteMemifInterface(intf.Name, ifIdx)
	case interfaces.Interface_VXLAN_TUNNEL:
		if intf.GetVxlan().Gpe == nil {
			err = d.ifHandler.DeleteVxLanTunnel(intf.Name, ifIdx, intf.Vrf, intf.GetVxlan())
		} else {
			err = d.ifHandler.DeleteVxLanGpeTunnel(intf.Name, intf.GetVxlan())
		}
	case interfaces.Interface_SOFTWARE_LOOPBACK:
		err = d.ifHandler.DeleteLoopbackInterface(intf.Name, ifIdx)
	case interfaces.Interface_DPDK:
		d.log.Debugf("Interface %s removal skipped: cannot remove (blacklist) physical interface", intf.Name) // Not an error
		return nil
	case interfaces.Interface_AF_PACKET:
		err = d.ifHandler.DeleteAfPacketInterface(intf.Name, ifIdx, intf.GetAfpacket())
	case interfaces.Interface_IPSEC_TUNNEL:
		err = d.ifHandler.DeleteIPSecTunnelInterface(intf.Name, intf.GetIpsec())
	case interfaces.Interface_SUB_INTERFACE:
		err = d.ifHandler.DeleteSubif(ifIdx)
	case interfaces.Interface_VMXNET3_INTERFACE:
		err = d.ifHandler.DeleteVmxNet3(intf.Name, ifIdx)
	case interfaces.Interface_BOND_INTERFACE:
		err = d.ifHandler.DeleteBondInterface(intf.Name, ifIdx)
		delete(d.bondIDs, intf.GetBond().GetId())
	case interfaces.Interface_GRE_TUNNEL:
		_, err = d.ifHandler.DelGreTunnel(intf.Name, intf.GetGre())
	}
	if err != nil {
		err = errors.Errorf("failed to remove interface %s, index %d: %v", intf.Name, ifIdx, err)
		d.log.Error(err)
		return err
	}

	return nil
}

// Update is able to change Type-unspecific attributes.
func (d *InterfaceDescriptor) Update(key string, oldIntf, newIntf *interfaces.Interface, oldMetadata *ifaceidx.IfaceMetadata) (newMetadata *ifaceidx.IfaceMetadata, err error) {
	ifIdx := oldMetadata.SwIfIndex

	// admin status
	if newIntf.Enabled != oldIntf.Enabled {
		if newIntf.Enabled {
			if err = d.ifHandler.InterfaceAdminUp(ifIdx); err != nil {
				err = errors.Errorf("failed to set interface %s up: %v", newIntf.Name, err)
				d.log.Error(err)
				return oldMetadata, err
			}
		} else {
			if err = d.ifHandler.InterfaceAdminDown(ifIdx); err != nil {
				err = errors.Errorf("failed to set interface %s down: %v", newIntf.Name, err)
				d.log.Error(err)
				return oldMetadata, err
			}
		}
	}

	// configure new MAC address if set (and only if it was changed and only for supported interface type)
	if newIntf.PhysAddress != "" &&
		newIntf.PhysAddress != oldIntf.PhysAddress &&
		oldIntf.Type != interfaces.Interface_AF_PACKET &&
		oldIntf.Type != interfaces.Interface_DPDK &&
		oldIntf.Type != interfaces.Interface_BOND_INTERFACE {
		if err := d.ifHandler.SetInterfaceMac(ifIdx, newIntf.PhysAddress); err != nil {
			err = errors.Errorf("setting interface %s MAC address %s failed: %v",
				newIntf.Name, newIntf.PhysAddress, err)
			d.log.Error(err)
			return oldMetadata, err
		}
	}

	// update MTU (except VxLan, IPSec)
	if ifaceSupportsSetMTU(newIntf) {
		if newIntf.Mtu != 0 && newIntf.Mtu != oldIntf.Mtu {
			if err := d.ifHandler.SetInterfaceMtu(ifIdx, newIntf.Mtu); err != nil {
				err = errors.Errorf("failed to set MTU to interface %s: %v", newIntf.Name, err)
				d.log.Error(err)
				return oldMetadata, err
			}
		} else if newIntf.Mtu == 0 && d.defaultMtu != 0 {
			if err := d.ifHandler.SetInterfaceMtu(ifIdx, d.defaultMtu); err != nil {
				err = errors.Errorf("failed to set MTU to interface %s: %v", newIntf.Name, err)
				d.log.Error(err)
				return oldMetadata, err
			}
		}
	}

	// update vlan tag rewrite
	if newIntf.Type == interfaces.Interface_SUB_INTERFACE {
		oldSub, newSub := oldIntf.GetSub(), newIntf.GetSub()
		if oldSub.TagRwOption != newSub.TagRwOption ||
			oldSub.PushDot1Q != newSub.PushDot1Q ||
			oldSub.Tag1 != newSub.Tag1 ||
			oldSub.Tag2 != newSub.Tag2 {
			if err := d.ifHandler.SetVLanTagRewrite(ifIdx, newSub); err != nil {
				d.log.Error(err)
				return nil, err
			}
		}
	}

	// update metadata
	oldMetadata.IPAddresses = newIntf.IpAddresses
	oldMetadata.Vrf = newIntf.Vrf
	return oldMetadata, nil
}

// Retrieve returns all configured VPP interfaces.
func (d *InterfaceDescriptor) Retrieve(correlate []adapter.InterfaceKVWithMetadata) (retrieved []adapter.InterfaceKVWithMetadata, err error) {
	// make sure that any checks on the Linux side are done in the default namespace with locked thread
	if d.nsPlugin != nil {
		nsCtx := nslinuxcalls.NewNamespaceMgmtCtx()
		revert, err := d.nsPlugin.SwitchToNamespace(nsCtx, nil)
		if err == nil {
			defer revert()
		}
	}

	// convert interfaces for correlation into a map
	ifCfg := make(map[string]*interfaces.Interface) // interface logical name -> interface config (as expected by correlate)
	for _, kv := range correlate {
		ifCfg[kv.Value.Name] = kv.Value
	}

	// refresh the map of memif socket IDs
	d.memifSocketToID, err = d.ifHandler.DumpMemifSocketDetails()
	if err != nil {
		err = errors.Errorf("failed to dump memif socket details: %v", err)
		d.log.Error(err)
		return retrieved, err
	}
	for socketPath, socketID := range d.memifSocketToID {
		if socketID == 0 {
			d.defaultMemifSocketPath = socketPath
		}
	}

	// clear the map of ethernet interfaces and bond IDs
	d.ethernetIfs = make(map[string]uint32)
	d.bondIDs = make(map[uint32]string)

	// dump current state of VPP interfaces
	vppIfs, err := d.ifHandler.DumpInterfaces()
	if err != nil {
		err = errors.Errorf("failed to dump interfaces: %v", err)
		d.log.Error(err)
		return retrieved, err
	}

	for ifIdx, intf := range vppIfs {
		origin := kvs.FromNB
		if ifIdx == 0 {
			// local0 is created automatically
			origin = kvs.FromSB
		}
		if intf.Interface.Type == interfaces.Interface_DPDK {
			d.ethernetIfs[intf.Interface.Name] = ifIdx
			if !intf.Interface.Enabled && len(intf.Interface.IpAddresses) == 0 {
				// unconfigured physical interface => skip (but add entry to d.ethernetIfs)
				continue
			}
		}
		if intf.Interface.Name == "" {
			// untagged interface - generate a logical name for it
			// (apart from local0 it will get removed by resync)
			intf.Interface.Name = untaggedIfPreffix + intf.Meta.InternalName
		}
		if intf.Interface.Type == interfaces.Interface_BOND_INTERFACE {
			d.bondIDs[intf.Interface.GetBond().GetId()] = intf.Interface.Name
		}

		// get TAP host interface name
		var tapHostIfName string
		if intf.Interface.Type == interfaces.Interface_TAP {
			tapHostIfName = intf.Interface.GetTap().GetHostIfName()
			if generateTAPHostName(intf.Interface.Name) == tapHostIfName {
				// if a generated TAP host name matches the dumped one, there is a premise
				// that the retrieved value was generated before and the original host name
				// was empty.
				intf.Interface.GetTap().HostIfName = ""
				// VPP 1904 BUG - host name is sometimes not properly dumped, use generated
				// value for metadata
				// TODO remove with VPP 1904 support drop
			} else if tapHostIfName == "" {
				tapHostIfName = generateTAPHostName(intf.Interface.Name)
			}
		}

		// correlate attributes that cannot be dumped
		if expCfg, hasExpCfg := ifCfg[intf.Interface.Name]; hasExpCfg {
			if expCfg.Type == interfaces.Interface_TAP && intf.Interface.GetTap() != nil {
				intf.Interface.GetTap().ToMicroservice = expCfg.GetTap().GetToMicroservice()
				intf.Interface.GetTap().RxRingSize = expCfg.GetTap().GetRxRingSize()
				intf.Interface.GetTap().TxRingSize = expCfg.GetTap().GetTxRingSize()
				// (seemingly uninitialized section of memory is returned)
				if intf.Interface.GetTap().GetVersion() == 2 {
					intf.Interface.GetTap().HostIfName = expCfg.GetTap().GetHostIfName()
					// set host name in metadata from NB data if defined
					if intf.Interface.GetTap().HostIfName != "" {
						tapHostIfName = expCfg.GetTap().GetHostIfName()
					}
				}
			}
			if expCfg.Type == interfaces.Interface_MEMIF && intf.Interface.GetMemif() != nil {
				intf.Interface.GetMemif().Secret = expCfg.GetMemif().GetSecret()
				intf.Interface.GetMemif().RxQueues = expCfg.GetMemif().GetRxQueues()
				intf.Interface.GetMemif().TxQueues = expCfg.GetMemif().GetTxQueues()
				// if memif is not connected yet, ring-size and buffer-size are
				// 1 and 0, respectively
				if intf.Interface.GetMemif().GetRingSize() == 1 {
					intf.Interface.GetMemif().RingSize = expCfg.GetMemif().GetRingSize()
				}
				if intf.Interface.GetMemif().GetBufferSize() == 0 {
					intf.Interface.GetMemif().BufferSize = expCfg.GetMemif().GetBufferSize()
				}
			}

			// remove rx-placement entries for queues with configuration not defined by NB
			rxPlacementDump := intf.Interface.GetRxPlacements()
			rxPlacementCfg := expCfg.GetRxPlacements()
			for i := 0; i < len(rxPlacementDump); {
				queue := rxPlacementDump[i].Queue
				found := false
				for j := 0; j < len(rxPlacementCfg); j++ {
					if rxPlacementCfg[j].Queue == queue {
						found = true
						break
					}
				}
				if found {
					i++
				} else {
					rxPlacementDump = append(rxPlacementDump[:i], rxPlacementDump[i+1:]...)
				}
			}
			intf.Interface.RxPlacements = rxPlacementDump

			// remove rx-mode from the dump if it is not configured by NB
			if len(expCfg.GetRxModes()) == 0 {
				intf.Interface.RxModes = []*interfaces.Interface_RxMode{}
			}

			// correlate references to allocated IP addresses
			intf.Interface.IpAddresses = d.addrAlloc.CorrelateRetrievedIPs(
				expCfg.IpAddresses, intf.Interface.IpAddresses,
				intf.Interface.Name, netalloc.IPAddressForm_ADDR_WITH_MASK)
		}

		// verify links between VPP and Linux side
		if d.linuxIfPlugin != nil && d.linuxIfHandler != nil && d.nsPlugin != nil {
			if intf.Interface.Type == interfaces.Interface_AF_PACKET {
				hostIfName := intf.Interface.GetAfpacket().HostIfName
				exists, _ := d.linuxIfHandler.InterfaceExists(hostIfName)
				if !exists {
					// the Linux interface that the AF-Packet is attached to does not exist
					// - append special suffix that will make this interface unwanted
					intf.Interface.Name += afPacketMissingAttachedIfSuffix
				}
			}
			if intf.Interface.Type == interfaces.Interface_TAP {
				exists, _ := d.linuxIfHandler.InterfaceExists(tapHostIfName)
				if !exists {
					// check if it was "stolen" by the Linux plugin
					_, _, exists = d.linuxIfPlugin.GetInterfaceIndex().LookupByVPPTap(
						intf.Interface.Name)
				}
				if !exists {
					// the Linux side of the TAP interface side was not found
					// - append special suffix that will make this interface unwanted
					intf.Interface.Name += tapMissingLinuxSideSuffix
				}
			}
		}

		// add interface record into the dump
		metadata := &ifaceidx.IfaceMetadata{
			SwIfIndex:     ifIdx,
			Vrf:           intf.Interface.Vrf,
			IPAddresses:   intf.Interface.IpAddresses,
			TAPHostIfName: tapHostIfName,
		}
		retrieved = append(retrieved, adapter.InterfaceKVWithMetadata{
			Key:      models.Key(intf.Interface),
			Value:    intf.Interface,
			Metadata: metadata,
			Origin:   origin,
		})

	}

	return retrieved, nil
}

func ifaceSupportsSetMTU(intf *interfaces.Interface) bool {
	switch intf.Type {
	case interfaces.Interface_VXLAN_TUNNEL,
		interfaces.Interface_IPSEC_TUNNEL,
		interfaces.Interface_SUB_INTERFACE:
		// MTU not supported
		return false
	}
	return true
}