// setupTapDevice creates persistent macvtap device
// and returns a newly created netlink.Link structure
// using part of pod hash and interface number in interface name
func setupMacVTapDevice(podID types.UUID, config MacVTapNetConf, interfaceNumber int) (netlink.Link, error) {
master, err := netlink.LinkByName(config.Master)
if err != nil {
return nil, errwrap.Wrap(fmt.Errorf("cannot find master device '%v'", config.Master), err)
}
var mode netlink.MacvlanMode
switch config.Mode {
// if not set - defaults to bridge mode as in:
// https://github.com/coreos/rkt/blob/master/Documentation/networking.md#macvlan
case "", "bridge":
mode = netlink.MACVLAN_MODE_BRIDGE
case "private":
mode = netlink.MACVLAN_MODE_PRIVATE
case "vepa":
mode = netlink.MACVLAN_MODE_VEPA
case "passthru":
mode = netlink.MACVLAN_MODE_PASSTHRU
default:
return nil, fmt.Errorf("unsupported macvtap mode: %v", config.Mode)
}
mtu := master.Attrs().MTU
if config.MTU != 0 {
mtu = config.MTU
}
interfaceName := fmt.Sprintf("rkt-%s-vtap%d", podID.String()[0:4], interfaceNumber)
link := &netlink.Macvtap{
Macvlan: netlink.Macvlan{
LinkAttrs: netlink.LinkAttrs{
Name: interfaceName,
MTU: mtu,
ParentIndex: master.Attrs().Index,
},
Mode: mode,
},
}
if err := netlink.LinkAdd(link); err != nil {
return nil, errwrap.Wrap(errors.New("cannot create macvtap interface"), err)
}
// TODO: duplicate following lines for ipv6 support, when it will be added in other places
ipv4SysctlValueName := fmt.Sprintf(IPv4InterfaceArpProxySysctlTemplate, interfaceName)
if _, err := cnisysctl.Sysctl(ipv4SysctlValueName, "1"); err != nil {
// remove the newly added link and ignore errors, because we already are in a failed state
_ = netlink.LinkDel(link)
return nil, errwrap.Wrap(fmt.Errorf("failed to set proxy_arp on newly added interface %q", interfaceName), err)
}
if err := netlink.LinkSetUp(link); err != nil {
// remove the newly added link and ignore errors, because we already are in a failed state
_ = netlink.LinkDel(link)
return nil, errwrap.Wrap(errors.New("cannot set up macvtap interface"), err)
}
return link, nil
}
func createMacvlan(conf *NetConf, ifName string, netns ns.NetNS) error {
mode, err := modeFromString(conf.Mode)
if err != nil {
return err
}
m, err := netlink.LinkByName(conf.Master)
if err != nil {
return fmt.Errorf("failed to lookup master %q: %v", conf.Master, err)
}
// due to kernel bug we have to create with tmpName or it might
// collide with the name on the host and error out
tmpName, err := ip.RandomVethName()
if err != nil {
return err
}
mv := &netlink.Macvlan{
LinkAttrs: netlink.LinkAttrs{
MTU: conf.MTU,
Name: tmpName,
ParentIndex: m.Attrs().Index,
Namespace: netlink.NsFd(int(netns.Fd())),
},
Mode: mode,
}
if err := netlink.LinkAdd(mv); err != nil {
return fmt.Errorf("failed to create macvlan: %v", err)
}
return netns.Do(func(_ ns.NetNS) error {
// TODO: duplicate following lines for ipv6 support, when it will be added in other places
ipv4SysctlValueName := fmt.Sprintf(IPv4InterfaceArpProxySysctlTemplate, tmpName)
if _, err := sysctl.Sysctl(ipv4SysctlValueName, "1"); err != nil {
// remove the newly added link and ignore errors, because we already are in a failed state
_ = netlink.LinkDel(mv)
return fmt.Errorf("failed to set proxy_arp on newly added interface %q: %v", tmpName, err)
}
err := renameLink(tmpName, ifName)
if err != nil {
_ = netlink.LinkDel(mv)
return fmt.Errorf("failed to rename macvlan to %q: %v", ifName, err)
}
return nil
})
}
func (driver *driver) deleteEndpoint(w http.ResponseWriter, r *http.Request) {
var delete endpointDelete
if err := json.NewDecoder(r.Body).Decode(&delete); err != nil {
sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
return
}
log.Debugf("Delete endpoint request: %+v", &delete)
emptyResponse(w)
// null check cidr in case driver restarted and doesn't know the network to avoid panic
if driver.cidr == nil {
return
}
// ReleaseIP releases an ip back to a network
if err := driver.ipAllocator.ReleaseIP(driver.cidr, driver.cidr.IP); err != nil {
log.Warnf("Error releasing IP: %s", err)
}
log.Debugf("Delete endpoint %s", delete.EndpointID)
containerLink := delete.EndpointID[:5]
// Check the interface to delete exists to avoid a netlink panic
if ok := validateHostIface(containerLink); !ok {
log.Errorf("The requested interface to delete [ %s ] was not found on the host.", containerLink)
return
}
link, err := netlink.LinkByName(containerLink)
if err != nil {
log.Errorf("Error looking up link [ %s ] object: [ %v ] error: [ %s ]", link.Attrs().Name, link, err)
return
}
log.Infof("Deleting the unused macvlan link [ %s ] from the removed container", link.Attrs().Name)
if err := netlink.LinkDel(link); err != nil {
log.Errorf("unable to delete the Macvlan link [ %s ] on leave: %s", link.Attrs().Name, err)
}
}
func (s *NetSetup) TearDownTest(c *C) {
s.newNS.Close()
s.cmd.Process.Kill()
netns.Set(s.globalNS)
s.globalNS.Close()
netlink.LinkDel(s.link)
}
// addUplink adds a dummy uplink to ofnet agent
func addUplink(ofa *OfnetAgent, linkName string, ofpPortNo uint32) (*netlink.Veth, error) {
link := &netlink.Veth{
LinkAttrs: netlink.LinkAttrs{
Name: linkName,
TxQLen: 100,
MTU: 1400,
},
PeerName: linkName + "peer",
}
// delete old link if it exists.. and ignore error
netlink.LinkDel(link)
time.Sleep(100 * time.Millisecond)
if err := netlink.LinkAdd(link); err != nil {
return nil, err
}
// add it to ofnet
err := ofa.AddUplink(ofpPortNo, linkName)
if err != nil {
return nil, err
}
time.Sleep(time.Second)
// mark the link as up
if err := netlink.LinkSetUp(link); err != nil {
return nil, err
}
return link, nil
}
func (driver *driver) deleteEndpoint(w http.ResponseWriter, r *http.Request) {
var delete endpointDelete
if err := json.NewDecoder(r.Body).Decode(&delete); err != nil {
sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
return
}
log.Debugf("Delete endpoint request: %+v", &delete)
emptyResponse(w)
// null check cidr in case driver restarted and doesnt know the network to avoid panic
if driver.cidr == nil {
return
}
// ReleaseIP releases an ip back to a network
if err := driver.ipAllocator.ReleaseIP(driver.cidr, driver.cidr.IP); err != nil {
log.Warnf("error releasing IP: %s", err)
}
log.Debugf("Delete endpoint %s", delete.EndpointID)
containerLink := delete.EndpointID[:5]
log.Infof("Removing unused link [ %s ]", containerLink)
clink, err := netlink.LinkByName(containerLink)
if err != nil {
log.Warnf("Error looking up link [ %s ] object: [ %v ] error: [ %s ]", clink.Attrs().Name, clink, err)
}
if err := netlink.LinkDel(clink); err != nil {
log.Errorf("unable to delete the container's link [ %s ] on leave: %s", clink, err)
}
}
func (d *Driver) DeleteEndpoint(r *network.DeleteEndpointRequest) error {
log.Debugf("Delete endpoint request: %+v", r)
// Delete the macvlan interface
linkName := "macvlan_" + r.EndpointID[:7]
vlanLink, err := netlink.LinkByName(linkName)
if err != nil {
log.Errorf("Error getting vlan link: %v", err)
return err
}
// verify a parent interface isn't being deleted
if vlanLink.Attrs().ParentIndex == 0 {
log.Errorf("Endpoint does not appear to be a slave interface")
return fmt.Errorf("interface %s does not appear to be a slave device: %v", linkName, err)
}
// delete the macvlan slave device
if err := netlink.LinkDel(vlanLink); err != nil {
log.Errorf("Error deleting link: %v", err)
return err
}
log.Debugf("Deleted subinterface: %s", linkName)
// Asynchronously check and remove the vxlan interface if nothing else is using it.
go d.cleanup(r.NetworkID)
return nil
}
func testBridgeSimpleSetup(t *testing.T, nsPrefix string, br *netlink.Bridge) (
*netlink.Bridge, []*netlink.Veth, []netns.NsHandle, func()) {
links, nets, cleanup := testNetnsPair(t, nsPrefix)
if br == nil {
br = &netlink.Bridge{
LinkAttrs: netlink.LinkAttrs{
Name: "br0",
},
}
if err := netlink.LinkAdd(br); err != nil {
cleanup()
t.Fatal(err)
}
}
cleanup2 := func() {
netlink.LinkDel(br)
cleanup()
}
if err := netlink.LinkSetMaster(links[0], br); err != nil {
cleanup2()
t.Fatal(err)
}
if err := netlink.LinkSetMaster(links[1], br); err != nil {
cleanup2()
t.Fatal(err)
}
if err := netlink.LinkSetUp(br); err != nil {
cleanup2()
t.Fatal(err)
}
return br, links, nets, cleanup2
}
func (driver *driver) deleteEndpoint(w http.ResponseWriter, r *http.Request) {
var delete endpointDelete
if err := json.NewDecoder(r.Body).Decode(&delete); err != nil {
sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
return
}
log.Debugf("Delete endpoint request: %+v", &delete)
emptyResponse(w)
log.Debugf("Delete endpoint %s", delete.EndpointID)
containerLink := delete.EndpointID[:5]
// Check the interface to delete exists to avoid a panic if nil
if ok := validateHostIface(containerLink); !ok {
log.Errorf("The requested interface to delete [ %s ] was not found on the host.", containerLink)
return
}
// Get the link handle
link, err := netlink.LinkByName(containerLink)
if err != nil {
log.Errorf("Error looking up link [ %s ] object: [ %v ] error: [ %s ]", link.Attrs().Name, link, err)
return
}
log.Infof("Deleting the unused ipvlan link [ %s ] from the removed container", link.Attrs().Name)
// Delete the link
if err := netlink.LinkDel(link); err != nil {
log.Errorf("Unable to delete the ipvlan link named [ %s ] for the exiting container: %s", link.Attrs().Name, err)
}
}
func resourceLXCBridgeDelete(d *schema.ResourceData, meta interface{}) error {
bridgeIndex, err := strconv.Atoi(d.Id())
if err != nil {
return fmt.Errorf("Internal error reading resource ID: %v", err)
}
bridge, err := netlink.LinkByIndex(bridgeIndex)
if err != nil {
return fmt.Errorf("Unable to find bridge %v: %v", bridgeIndex, err)
}
links, err := netlink.LinkList()
if err != nil {
return fmt.Errorf("Error listing interfaces: %v", err)
}
bridgeEmpty := true
for _, link := range links {
if link.Attrs().MasterIndex == bridge.Attrs().Index {
bridgeEmpty = false
log.Printf("[INFO] Link %s is still attached to bridge %s", link.Attrs().Name, bridge.Attrs().Name)
}
}
if bridgeEmpty == false {
return fmt.Errorf("Unable to delete bridge %s. Interfaces are still attached to it.", bridge.Attrs().Name)
} else {
if err := netlink.LinkDel(bridge); err != nil {
return fmt.Errorf("Error deleting bridge: %s", err)
}
}
return nil
}
func (c *CNIPlugin) CmdDel(args *skel.CmdArgs) error {
conf, err := loadNetConf(args.StdinData)
if err != nil {
return err
}
ns, err := netns.GetFromPath(args.Netns)
if err != nil {
return err
}
defer ns.Close()
err = weavenet.WithNetNSUnsafe(ns, func() error {
link, err := netlink.LinkByName(args.IfName)
if err != nil {
return err
}
return netlink.LinkDel(link)
})
if err != nil {
return fmt.Errorf("error removing interface: %s", err)
}
// Default IPAM is Weave's own
if conf.IPAM.Type == "" {
err = ipamplugin.NewIpam(c.weave).Release(args)
} else {
err = ipam.ExecDel(conf.IPAM.Type, args.StdinData)
}
if err != nil {
return fmt.Errorf("unable to release IP address: %s", err)
}
return nil
}
// Remove default bridge interface if present (--bridge=none use case)
func removeDefaultBridgeInterface() {
if lnk, err := netlink.LinkByName(bridge.DefaultBridgeName); err == nil {
if err := netlink.LinkDel(lnk); err != nil {
logrus.Warnf("Failed to remove bridge interface (%s): %v", bridge.DefaultBridgeName, err)
}
}
}
// delVlanLink verifies only sub-interfaces with a vlan id get deleted
func delVlanLink(linkName string) error {
if strings.Contains(linkName, ".") {
_, _, err := parseVlan(linkName)
if err != nil {
return err
}
// delete the vlan subinterface
vlanLink, err := netlink.LinkByName(linkName)
if err != nil {
return fmt.Errorf("failed to find interface %s on the Docker host : %v", linkName, err)
}
// verify a parent interface isn't being deleted
if vlanLink.Attrs().ParentIndex == 0 {
return fmt.Errorf("interface %s does not appear to be a slave device: %v", linkName, err)
}
// delete the macvlan slave device
if err := netlink.LinkDel(vlanLink); err != nil {
return fmt.Errorf("failed to delete %s link: %v", linkName, err)
}
logrus.Debugf("Deleted a vlan tagged netlink subinterface: %s", linkName)
}
// if the subinterface doesn't parse to iface.vlan_id leave the interface in
// place since it could be a user specified name not created by the driver.
return nil
}
func (v *veth) create(n *network, nspid int) (err error) {
tmpName, err := v.generateTempPeerName()
if err != nil {
return err
}
n.TempVethPeerName = tmpName
if n.Bridge == "" {
return fmt.Errorf("bridge is not specified")
}
veth := &netlink.Veth{
LinkAttrs: netlink.LinkAttrs{
Name: n.HostInterfaceName,
TxQLen: n.TxQueueLen,
},
PeerName: n.TempVethPeerName,
}
if err := netlink.LinkAdd(veth); err != nil {
return err
}
defer func() {
if err != nil {
netlink.LinkDel(veth)
}
}()
if err := v.attach(&n.Network); err != nil {
return err
}
child, err := netlink.LinkByName(n.TempVethPeerName)
if err != nil {
return err
}
return netlink.LinkSetNsPid(child, nspid)
}
func (d *driver) DeleteEndpoint(nid, eid string) error {
if err := validateID(nid, eid); err != nil {
return err
}
n := d.network(nid)
if n == nil {
return fmt.Errorf("network id %q not found", nid)
}
ep := n.endpoint(eid)
if ep == nil {
return fmt.Errorf("endpoint id %q not found", eid)
}
n.deleteEndpoint(eid)
if ep.ifName == "" {
return nil
}
link, err := netlink.LinkByName(ep.ifName)
if err != nil {
log.Debugf("Failed to retrieve interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
return nil
}
if err := netlink.LinkDel(link); err != nil {
log.Debugf("Failed to delete interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
}
return nil
}
func (d *driver) DeleteEndpoint(nid, eid string) error {
var err error
defer osl.InitOSContext()()
// Get the network handler and make sure it exists
d.Lock()
n, ok := d.networks[nid]
d.Unlock()
if !ok {
return types.InternalMaskableErrorf("network %s does not exist", nid)
}
if n == nil {
return driverapi.ErrNoNetwork(nid)
}
// Sanity Check
n.Lock()
if n.id != nid {
n.Unlock()
return InvalidNetworkIDError(nid)
}
n.Unlock()
// Check endpoint id and if an endpoint is actually there
ep, err := n.getEndpoint(eid)
if err != nil {
return err
}
if ep == nil {
return EndpointNotFoundError(eid)
}
// Remove it
n.Lock()
delete(n.endpoints, eid)
n.Unlock()
// On failure make sure to set back ep in n.endpoints, but only
// if it hasn't been taken over already by some other thread.
defer func() {
if err != nil {
n.Lock()
if _, ok := n.endpoints[eid]; !ok {
n.endpoints[eid] = ep
}
n.Unlock()
}
}()
// Try removal of link. Discard error: it is a best effort.
// Also make sure defer does not see this error either.
if link, err := netlink.LinkByName(ep.srcName); err == nil {
netlink.LinkDel(link)
}
return nil
}
// create and attach a veth to the Weave bridge
func CreateAndAttachVeth(name, peerName, bridgeName string, mtu int, keepTXOn bool, init func(peer netlink.Link) error) (*netlink.Veth, error) {
bridge, err := netlink.LinkByName(bridgeName)
if err != nil {
return nil, fmt.Errorf(`bridge "%s" not present; did you launch weave?`, bridgeName)
}
if mtu == 0 {
mtu = bridge.Attrs().MTU
}
veth := &netlink.Veth{
LinkAttrs: netlink.LinkAttrs{
Name: name,
MTU: mtu},
PeerName: peerName,
}
if err := netlink.LinkAdd(veth); err != nil {
return nil, fmt.Errorf(`could not create veth pair %s-%s: %s`, name, peerName, err)
}
cleanup := func(format string, a ...interface{}) (*netlink.Veth, error) {
netlink.LinkDel(veth)
return nil, fmt.Errorf(format, a...)
}
switch bridgeType := DetectBridgeType(bridgeName, DatapathName); bridgeType {
case Bridge, BridgedFastdp:
if err := netlink.LinkSetMasterByIndex(veth, bridge.Attrs().Index); err != nil {
return cleanup(`unable to set master of %s: %s`, name, err)
}
if bridgeType == Bridge && !keepTXOn {
if err := EthtoolTXOff(peerName); err != nil {
return cleanup(`unable to set tx off on %q: %s`, peerName, err)
}
}
case Fastdp:
if err := odp.AddDatapathInterface(bridgeName, name); err != nil {
return cleanup(`failed to attach %s to device "%s": %s`, name, bridgeName, err)
}
default:
return cleanup(`invalid bridge configuration`)
}
if init != nil {
peer, err := netlink.LinkByName(peerName)
if err != nil {
return cleanup("unable to find peer veth %s: %s", peerName, err)
}
if err := init(peer); err != nil {
return cleanup("initializing veth: %s", err)
}
}
if err := netlink.LinkSetUp(veth); err != nil {
return cleanup("unable to bring veth up: %s", err)
}
return veth, nil
}
func (driver *driver) LeaveEndpoint(leave *api.LeaveRequest) error {
Log.Debugf("Leave request: %+v", leave)
local := vethPair(leave.EndpointID[:5])
if err := netlink.LinkDel(local); err != nil {
Log.Warningf("unable to delete veth on leave: %s", err)
}
Log.Infof("Leave %s:%s", leave.NetworkID, leave.EndpointID)
return nil
}
/* Delete interface */
func Del(iface string) {
dev, err := netlink.LinkByName(iface)
if err != nil {
log.Fatalf("failed to look up interface %s: %s", iface, err)
}
log.Printf("removing interface %s", iface)
if err := netlink.LinkDel(dev); err != nil {
log.Fatalf("failed to remove interface %s: %s", iface, err)
}
}
func cleanup(intfName string) error {
if _, err := net.InterfaceByName(intfName); err == nil {
link, err := netlink.LinkByName(intfName)
if err != nil {
return err
}
return netlink.LinkDel(link)
}
return nil
}
func Del(name string) {
br, err := netlink.LinkByName(name)
if err != nil {
log.Printf("not removing bridge %s: %s", name, err)
}
log.Printf("removing bridge %s", name)
if err := netlink.LinkDel(&netlink.Bridge{*br.Attrs()}); err != nil {
log.Fatalf("failed to remove bridge %s: %s", name, err)
}
}
func (n *networks) deleteLink(config networkConfig) error {
if li, err := netlink.LinkByName(config.BridgeName); err == nil {
if err := netlink.LinkSetDown(li); err != nil {
return ErrNetlinkError{"bring bridge down", err}
}
if err := netlink.LinkDel(li); err != nil {
return ErrNetlinkError{"delete bridge", err}
}
}
if li, err := netlink.LinkByName(config.LinkName); err == nil {
if err := netlink.LinkSetDown(li); err != nil {
return ErrNetlinkError{"bring vlan down", err}
}
if err := netlink.LinkDel(li); err != nil {
return ErrNetlinkError{"delete vlan", err}
}
}
return nil
}
func DetachContainer(ns netns.NsHandle, id, ifName string, cidrs []*net.IPNet) error {
ipt, err := iptables.New()
if err != nil {
return err
}
return WithNetNSLinkUnsafe(ns, ifName, func(veth netlink.Link) error {
existingAddrs, err := netlink.AddrList(veth, netlink.FAMILY_V4)
if err != nil {
return fmt.Errorf("failed to get IP address for %q: %v", veth.Attrs().Name, err)
}
for _, ipnet := range cidrs {
if !contains(existingAddrs, ipnet) {
continue
}
if err := netlink.AddrDel(veth, &netlink.Addr{IPNet: ipnet}); err != nil {
return fmt.Errorf("failed to remove IP address from %q: %v", veth.Attrs().Name, err)
}
}
addrs, err := netlink.AddrList(veth, netlink.FAMILY_V4)
if err != nil {
return fmt.Errorf("failed to get IP address for %q: %v", veth.Attrs().Name, err)
}
// Remove multicast ACCEPT rules for subnets we no longer have addresses in
subnets := subnets(addrs)
rules, err := ipt.List("filter", "INPUT")
if err != nil {
return err
}
for _, rule := range rules {
ps := strings.Split(rule, " ")
if len(ps) == 10 &&
ps[0] == "-A" && ps[2] == "-s" && ps[4] == "-d" && ps[5] == "224.0.0.0/4" &&
ps[6] == "-i" && ps[7] == ifName && ps[8] == "-j" && ps[9] == "ACCEPT" {
if _, found := subnets[ps[3]]; !found {
if err := ipt.Delete("filter", "INPUT", ps[2:]...); err != nil {
return err
}
}
}
}
if len(addrs) == 0 { // all addresses gone: remove the interface
if err := ipt.Delete("filter", "INPUT", "-i", ifName, "-d", "224.0.0.0/4", "-j", "DROP"); err != nil {
return err
}
if err := netlink.LinkDel(veth); err != nil {
return err
}
}
return nil
})
}
/* setup()
*/
func setup(pid int, brName string) error {
br, e := netlink.LinkByName(brName)
if e != nil {
return fmt.Errorf("Host bridge not found: %v", e)
}
// Network interface names.
hsIfName := fmt.Sprintf("veth%d", pid) // Host side interface
nsIfName := "veth0"
// Assign host side interface to bridge.
linkAttrs := netlink.NewLinkAttrs()
linkAttrs.Name = hsIfName
linkAttrs.MasterIndex = br.Attrs().Index
// Create interface pair.
hsIf := &netlink.Veth{LinkAttrs: linkAttrs, PeerName: nsIfName}
if e := netlink.LinkAdd(hsIf); e != nil {
return fmt.Errorf("Failed to create veth pair: %v", e)
}
// Get namespace side interface handle.
nsIf, e := netlink.LinkByName(nsIfName)
if e != nil {
netlink.LinkDel(hsIf)
return fmt.Errorf("Failed to get namespace iface: %v", e)
}
// Attach network interface to namespace.
if e := netlink.LinkSetNsPid(nsIf, pid); e != nil {
netlink.LinkDel(hsIf)
return fmt.Errorf("Failed to attach namespace iface: %v", e)
}
// Bring up host side interface.
if e := netlink.LinkSetUp(hsIf); e != nil {
netlink.LinkDel(hsIf)
return fmt.Errorf("Failed to bring up host iface: %v", e)
}
return nil
}
// leave call
func (driver *driver) leaveEndpoint(w http.ResponseWriter, r *http.Request) {
var l api.LeaveRequest
if err := json.NewDecoder(r.Body).Decode(&l); err != nil {
sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
return
}
Log.Infof("Leave request: %+v", &l)
if_local_name := "tap" + l.EndpointID[:5]
//getting mac address of tap...
cmdStr0 := "ifconfig " + if_local_name + " | awk '/HWaddr/ {print $NF}'"
Log.Infof("mac address cmd: %s", cmdStr0)
cmd0 := exec.Command("/bin/sh", "-c", cmdStr0)
var out0 bytes.Buffer
cmd0.Stdout = &out0
err0 := cmd0.Run()
if err0 != nil {
Log.Error("Error thrown: ", err0)
}
mac := out0.String()
Log.Infof("output of cmd: %s\n", mac)
//first command {adding port on plumgrid}
cmdStr1 := "sudo /opt/pg/bin/ifc_ctl gateway ifdown " + if_local_name + " access_vm vm_" + l.EndpointID[:5] + " " + mac[:17]
Log.Infof("second cmd: %s", cmdStr1)
cmd1 := exec.Command("/bin/sh", "-c", cmdStr1)
var out1 bytes.Buffer
cmd1.Stdout = &out1
err1 := cmd1.Run()
if err1 != nil {
Log.Error("Error thrown: ", err1)
}
Log.Infof("output of cmd: %+v\n", out1.String())
//second command {up the port on plumgrid}
cmdStr2 := "sudo /opt/pg/bin/ifc_ctl gateway del_port " + if_local_name
Log.Infof("third cmd: %s", cmdStr2)
cmd2 := exec.Command("/bin/sh", "-c", cmdStr2)
var out2 bytes.Buffer
cmd2.Stdout = &out2
err2 := cmd2.Run()
if err2 != nil {
Log.Error("Error thrown: ", err2)
}
Log.Infof("output of cmd: %+v\n", out2.String())
local := vethPair(l.EndpointID[:5])
if err := netlink.LinkDel(local); err != nil {
Log.Warningf("unable to delete veth on leave: %s", err)
}
emptyResponse(w)
Log.Infof("Leave %s:%s", l.NetworkID, l.EndpointID)
}
func endpointDestroy() {
hostInt, err := netlink.LinkByName("myveth0")
if err != nil {
panic(err)
}
err = netlink.LinkDel(hostInt)
if err != nil {
panic(err)
}
}
func deleteVxlan(name string) error {
link, err := netlink.LinkByName(name)
if err != nil {
return fmt.Errorf("failed to find vxlan interface with name %s: %v", name, err)
}
if err := netlink.LinkDel(link); err != nil {
return fmt.Errorf("error deleting vxlan interface: %v", err)
}
return nil
}
// DelLinkByName removes an interface link.
func DelLinkByName(ifName string) error {
iface, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup %q: %v", ifName, err)
}
if err = netlink.LinkDel(iface); err != nil {
return fmt.Errorf("failed to delete %q: %v", ifName, err)
}
return nil
}
func (i *nwIface) Remove() error {
i.Lock()
n := i.ns
i.Unlock()
n.Lock()
path := n.path
isDefault := n.isDefault
n.Unlock()
return nsInvoke(path, func(nsFD int) error { return nil }, func(callerFD int) error {
// Find the network inteerface identified by the DstName attribute.
iface, err := netlink.LinkByName(i.DstName())
if err != nil {
return err
}
// Down the interface before configuring
if err := netlink.LinkSetDown(iface); err != nil {
return err
}
err = netlink.LinkSetName(iface, i.SrcName())
if err != nil {
fmt.Println("LinkSetName failed: ", err)
return err
}
// if it is a bridge just delete it.
if i.Bridge() {
if err := netlink.LinkDel(iface); err != nil {
return fmt.Errorf("failed deleting bridge %q: %v", i.SrcName(), err)
}
} else if !isDefault {
// Move the network interface to caller namespace.
if err := netlink.LinkSetNsFd(iface, callerFD); err != nil {
fmt.Println("LinkSetNsPid failed: ", err)
return err
}
}
n.Lock()
for index, intf := range n.iFaces {
if intf == i {
n.iFaces = append(n.iFaces[:index], n.iFaces[index+1:]...)
break
}
}
n.Unlock()
return nil
})
}
func RemoveVeth(vethNameHost string) error {
if ok, err := IsVethExists(vethNameHost); err != nil {
return errors.Wrap(err, "Veth removal error")
} else if !ok {
return nil
}
return netlink.LinkDel(&netlink.Veth{
LinkAttrs: netlink.LinkAttrs{
Name: vethNameHost,
},
})
}