4499

Committed 31 Mar 2021 10:00PM UTC coverage: 59.222%. First build

Build # 4499

Build Type

push

travis-ci-com

Committed by

jayaramsatya

Commit Message

<a href="https://github.com/noironetworks/aci-containers/commit/<a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a">3d6732a96">&lt;a href=&quot;https://github.com/noironetworks/aci-containers/commit/</a><a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a">3d6732a96</a><a href="https://github.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a">&lt;a href=&quot;https://github.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/noironetworks/aci-containers/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a&amp;quot;&amp;gt;3d6732a96&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/noironetworks/aci-containers/commit/3d6732a96ecebc05a71bc1eb2fc987aef0f31d6a&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;quot;&amp;amp;amp;gt;Openshift cluster Pod mac address is set to default.
Pod is coming up with link-local ipv6 address along with V4 ... (continued)

Run Details

8 of 8 new or added lines in 1 file covered. (100.0%)

11315 of 19106 relevant lines covered (59.22%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.19

/pkg/hostagent/setup.go

// Copyright 2016-2017 Cisco Systems, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hostagent

import (
        "errors"
        "fmt"
        "net"
        "os"

        cnicur "github.com/containernetworking/cni/pkg/types/current"
        "github.com/containernetworking/plugins/pkg/ip"
        "github.com/containernetworking/plugins/pkg/ipam"
        "github.com/containernetworking/plugins/pkg/ns"
        "github.com/natefinch/pie"
        "github.com/sirupsen/logrus"
        "github.com/vishvananda/netlink"

        md "github.com/noironetworks/aci-containers/pkg/metadata"
)

func StartPlugin(log *logrus.Logger) {
        p := pie.NewProvider()
        if err := p.Register(&ClientRPC{}); err != nil {
                log.Fatalf("failed to register Plugin: %s", err)
                return
        }

        log.Debug("Starting plugin provider")
        p.Serve()
}

// Cloner encapsulate a binary cloner for executing in a different process
// context
type Cloner struct {
        Stub bool
}

var PluginCloner Cloner

// runPluginCmd runs the command from a cloned instance of the
// executable in order to address name space binding needs
//func (c *Cloner) runPluginCmd(method, fsuid string, args interface{},
func (c *Cloner) runPluginCmd(method string, args interface{},
        reply interface{}) error {

        if c.Stub {
                // if we are in stub mode, just return success
                return nil
        }

        exe, err := os.Executable()
        if err != nil {
                return err
        }

        client, err := pie.StartProvider(os.Stderr, exe, "-child-mode")
        if err != nil {
                return err
        }
        defer client.Close()

        return client.Call(method, args, reply)
}

type ClientRPC struct{}

type SetupVethArgs struct {
        Sandbox string
        IfName  string
        Mtu     int
        Ip      net.IP
}

type SetupVethResult struct {
        HostVethName string
        Mac          string
}

func runSetupVeth(sandbox string, ifName string,
        mtu int, ip net.IP) (string, string, error) {
        result := &SetupVethResult{}
        err := PluginCloner.runPluginCmd("ClientRPC.SetupVeth",
                &SetupVethArgs{sandbox, ifName, mtu, ip}, result)
        return result.HostVethName, result.Mac, err
}

func (*ClientRPC) SetupVeth(args *SetupVethArgs, result *SetupVethResult) error {
        netns, err := ns.GetNS(args.Sandbox)
        if err != nil {
                return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)
        }
        defer netns.Close()

        return netns.Do(func(hostNS ns.NetNS) error {
                // create the veth pair in the container and move host end
                // into host netns
                hostVeth, _, err := ip.SetupVeth(args.IfName, args.Mtu, hostNS)
                if err != nil {
                        return err
                }

                result.HostVethName = hostVeth.Name

                // Force a consistent MAC address based on the IPv4 address
                // Currently we dont have a support for V6 based mac allocation. Upstream doesn't support yet :-(
                // This code has to be revisted if upstream drops SetHWAddrByIP in future
                // https://github.com/containernetworking/plugins/blob/e1517e2498fe4774435bc4be6bdd39fa735b469b/pkg/ip/link_linux.go#L228

                if args.Ip.To4() != nil {
                        if err := ip.SetHWAddrByIP(args.IfName, args.Ip, nil); err != nil {
                                return fmt.Errorf("failed Ip based MAC address allocation for v4: %v", err)
                        }
                }

                contVeth, err := netlink.LinkByName(args.IfName)
                if err != nil {
                        return err
                }

                result.Mac = contVeth.Attrs().HardwareAddr.String()
                return nil
        })
}

type ClearVethArgs struct {
        Sandbox string
        IfName  string
}

func runClearVeth(sandbox string, ifName string) error {
        ack := false
        err := PluginCloner.runPluginCmd("ClientRPC.ClearVeth",
                &ClearVethArgs{sandbox, ifName}, &ack)
        return err
}

func (c *ClientRPC) ClearVeth(args *ClearVethArgs, ack *bool) error {
        netns, err := ns.GetNS(args.Sandbox)
        if err != nil {
                return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)
        }
        defer netns.Close()

        *ack = false
        if err := netns.Do(func(_ ns.NetNS) error {
                iface, err := netlink.LinkByName(args.IfName)
                if err != nil {
                        return fmt.Errorf("failed to lookup %q: %v", args.IfName, err)
                }

                err = netlink.LinkDel(iface)
                if err != nil {
                        return fmt.Errorf("failed to delete %q: %v", args.IfName, err)
                }

                return nil
        }); err != nil {
                return err
        }

        *ack = true
        return nil
}

type SetupNetworkArgs struct {
        Sandbox string
        IfName  string
        Result  *cnicur.Result
}

func runSetupNetwork(sandbox string, ifName string,
        result *cnicur.Result) error {

        ack := false
        err := PluginCloner.runPluginCmd("ClientRPC.SetupNetwork",
                &SetupNetworkArgs{sandbox, ifName, result}, &ack)
        return err
}

func (*ClientRPC) SetupNetwork(args *SetupNetworkArgs, ack *bool) error {
        netns, err := ns.GetNS(args.Sandbox)
        if err != nil {
                return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)
        }
        defer netns.Close()

        // in gob encoding, pointer to 0 gets turned into a nil pointer.
        // This is a bug in the design of gob that will not be fixed:
        // See https://github.com/golang/go/issues/4609
        // Fix it to workaround I guess.
        index := 0
        for _, ip := range args.Result.IPs {
                if ip.Interface == nil {
                        ip.Interface = &index
                }
        }

        *ack = false
        if err := netns.Do(func(_ ns.NetNS) error {
                return ipam.ConfigureIface(args.IfName, args.Result)
        }); err != nil {
                return err
        }

        *ack = true
        return nil
}

func (agent *HostAgent) addToResult(iface *md.ContainerIfaceMd,
        index int, result *cnicur.Result) {

        result.Interfaces = append(result.Interfaces,
                &cnicur.Interface{
                        Name:    iface.Name,
                        Sandbox: iface.Sandbox,
                        Mac:     iface.Mac,
                })
        for _, ip := range iface.IPs {
                var version string
                if ip.Address.IP == nil {
                        continue
                }
                if ip.Address.IP.To4() != nil {
                        version = "4"
                } else if ip.Address.IP.To16() != nil {
                        version = "6"
                } else {
                        continue
                }

                ind := index
                result.IPs = append(result.IPs,
                        &cnicur.IPConfig{
                                Interface: &ind,
                                Version:   version,
                                Address:   ip.Address,
                                Gateway:   ip.Gateway,
                        })
        }

}

func (agent *HostAgent) configureContainerIfaces(metadata *md.ContainerMetadata) (*cnicur.Result, error) {
        logger := agent.log.WithFields(logrus.Fields{
                "pod":       metadata.Id.Pod,
                "namespace": metadata.Id.Namespace,
                "container": metadata.Id.ContId,
        })

        podKey := makePodKey(metadata.Id.Namespace, metadata.Id.Pod)
        logger.Debug("Setting up veth")
        if len(metadata.Ifaces) == 0 {
                return nil, errors.New("No interfaces specified")
        }
        result := &cnicur.Result{}

        for _, nc := range agent.config.NetConfig {
                result.Routes =
                        append(result.Routes, convertRoutes(nc.Routes)...)
        }

        for ifaceind, iface := range metadata.Ifaces {
                var err error
                var mtu int
                if agent.config.InterfaceMtu == 0 {
                        // MTU not explicitly set in config or discovered
                        mtu = 1500
                } else {
                        mtu = agent.config.InterfaceMtu
                }

                if len(iface.IPs) == 0 {
                        // We're doing ip address management

                        logger.Debug("Allocating IP address(es) for ", iface.Name)
                        err = agent.allocateIps(iface, podKey)
                        if err != nil {
                                return nil, err
                        }
                }
                for _, ip := range iface.IPs {
                        //There are 4 cases: IPv4-only, IPv6-only, dual stack with either IPv4 or IPv6 as the first address.
                        //We are guaranteed to derive the MAC address from IPv4 if it is assigned
                        if ip.Address.IP != nil && ip.Address.IP.To4() != nil {
                                iface.HostVethName, iface.Mac, err =
                                        runSetupVeth(iface.Sandbox, iface.Name, mtu, ip.Address.IP)
                                if err != nil {
                                        return nil, err
                                } else {
                                        break
                                }
                        }
                }
                // if no mac is assigned, set it to the default Mac.
                if len(iface.Mac) == 0 {
                        iface.HostVethName, iface.Mac, err =
                                runSetupVeth(iface.Sandbox, iface.Name, agent.config.InterfaceMtu, nil)
                        if err != nil {
                                return nil, err
                        }
                }

                agent.addToResult(iface, ifaceind, result)

                logger.Debug("Configuring network for ", iface.Name, ": ", *result)
                err = runSetupNetwork(iface.Sandbox, iface.Name, result)
                if err != nil {
                        agent.ipamMutex.Lock()
                        agent.deallocateIpsLocked(iface)
                        agent.ipamMutex.Unlock()
                        return nil, err
                }
        }
        var StaleContMetadata []md.ContainerMetadata
        podid := metadata.Id.Namespace + "/" + metadata.Id.Pod
        agent.indexMutex.Lock()
        if len(agent.epMetadata[podid]) > 1 {
                logger.Warnf("There is a Stale metadata present for the pod")
        }
        if val, ok := agent.epMetadata[podid]; ok {
                // check for any stale entry present.
                // this is possible if we miss any register events for unconfiguring the POD
                //  ideally epMetadata[podid] Map should contain only one entry of containerID
                // As every pod contains one network namespace for all the containers with in the pod
                // (i.e pause container ==> metadata.Id.ContId)
                // if there are any stale which doesn't match the ContainerID remove it
                for key, v := range val {
                        if metadata.Id.ContId != key {
                                logger.Warnf("Stale metadata present clean the entry: %s", key)
                                StaleContMetadata = append(StaleContMetadata, *v)
                        }
                }
        }
        agent.indexMutex.Unlock()

        for _, v := range StaleContMetadata {
                err := agent.cleanStatleMetadata(v.Id.ContId)
                if err == nil {
                        agent.deallocateMdIps(&v)
                        agent.ipamMutex.Lock()
                        delete(agent.epMetadata[podid], v.Id.ContId)
                        agent.ipamMutex.Unlock()
                }
        }

        err := md.RecordMetadata(agent.config.CniMetadataDir,
                agent.config.CniNetwork, *metadata)
        if err != nil {
                logger.Debug("ERROR RecordMetadata")
                return nil, err
        }

        agent.indexMutex.Lock()
        if _, ok := agent.epMetadata[podid]; !ok {
                agent.epMetadata[podid] =
                        make(map[string]*md.ContainerMetadata)
        }
        agent.epMetadata[podid][metadata.Id.ContId] = metadata
        agent.indexMutex.Unlock()

        agent.env.CniDeviceChanged(&podid, &metadata.Id)

        logger.Info("Successfully configured container interface")
        return result, nil
}

func (agent *HostAgent) cleanStatleMetadata(id string) error {
        _, err := md.GetMetadata(agent.config.CniMetadataDir,
                agent.config.CniNetwork, id)
        if err == nil {
                err := md.ClearMetadata(agent.config.CniMetadataDir,
                        agent.config.CniNetwork, id)
                if err != nil {
                        return err
                }
        }
        return err
}

func (agent *HostAgent) unconfigureContainerIfaces(id *md.ContainerId) error {
        logger := agent.log.WithFields(logrus.Fields{
                "ContId":    id.ContId,
                "Pod":       id.Pod,
                "Namespace": id.Namespace,
        })

        podid := id.Namespace + "/" + id.Pod

        agent.indexMutex.Lock()
        mdmap, ok := agent.epMetadata[podid]
        if !ok {
                logger.Error("Unconfigure called for pod with no metadata")
                // Assume container is already unconfigured
                agent.indexMutex.Unlock()
                return nil
        }
        metadata, ok := mdmap[id.ContId]
        if !ok {
                logger.Error("Unconfigure called for container with no metadata")
                // Assume container is already unconfigured
                agent.indexMutex.Unlock()
                return nil
        }
        delete(mdmap, id.ContId)
        if len(mdmap) == 0 {
                delete(agent.epMetadata, podid)
        }
        agent.indexMutex.Unlock()

        err := md.ClearMetadata(agent.config.CniMetadataDir,
                agent.config.CniNetwork, id.ContId)
        if err != nil {
                return err
        }

        agent.cniEpDelete(podid)
        logger.Debug("Deallocating IP address(es)")
        agent.deallocateMdIps(metadata)

        logger.Debug("Clearing container interface")
        for _, iface := range metadata.Ifaces {
                err = runClearVeth(iface.Sandbox, iface.Name)
                if err != nil {
                        logger.Error("Could not clear Veth ports: ", err)
                }
        }

        agent.env.CniDeviceDeleted(&podid, id)

        logger.Info("Successfully unconfigured container interface")
        return nil
}

func (agent *HostAgent) cleanupSetup() {
        agent.log.Info("Checking for stale container setup")

        agent.indexMutex.Lock()
        if !agent.syncEnabled {
                agent.indexMutex.Unlock()
                agent.log.Info("Sync not enabled, skipping stale container setup")
                return
        }
        mdcopy := agent.epMetadata
        agent.indexMutex.Unlock()

        for podkey, mdmap := range mdcopy {
                logger := agent.log.WithFields(logrus.Fields{
                        "podkey": podkey,
                })

                logger.Debug("Checking")
                exists, err := agent.env.CheckPodExists(&podkey)
                if err != nil {
                        logger.Error("Could not lookup pod: ", err)
                        continue
                }

                if !exists {
                        for _, metadata := range mdmap {
                                logger := agent.log.WithFields(logrus.Fields{
                                        "namespace": metadata.Id.Namespace,
                                        "pod":       metadata.Id.Pod,
                                        "contid":    metadata.Id.ContId,
                                })
                                logger.Info("Unconfiguring stale container configuration")

                                err := agent.unconfigureContainerIfaces(&metadata.Id)
                                if err != nil {
                                        logger.Error("Could not unconfigure container: ", err)
                                }
                        }
                }
        }

        err := agent.syncPorts(agent.config.OvsDbSock)
        if err != nil {
                agent.log.Error("Could not sync OVS ports: ", err)
        }

        agent.log.Debug("Done stale check")
}

1	// Copyright 2016-2017 Cisco Systems, Inc.
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package hostagent
16
17	import (
18	"errors"
19	"fmt"
20	"net"
21	"os"
22
23	cnicur "github.com/containernetworking/cni/pkg/types/current"
24	"github.com/containernetworking/plugins/pkg/ip"
25	"github.com/containernetworking/plugins/pkg/ipam"
26	"github.com/containernetworking/plugins/pkg/ns"
27	"github.com/natefinch/pie"
28	"github.com/sirupsen/logrus"
29	"github.com/vishvananda/netlink"
30
31	md "github.com/noironetworks/aci-containers/pkg/metadata"
32	)
33
34	func StartPlugin(log *logrus.Logger) {	×
35	p := pie.NewProvider()	×
36	if err := p.Register(&ClientRPC{}); err != nil {	×
37	log.Fatalf("failed to register Plugin: %s", err)	×
38	return	×
39	}	×
40
41	log.Debug("Starting plugin provider")	×
42	p.Serve()	×
43	}
44
45	// Cloner encapsulate a binary cloner for executing in a different process
46	// context
47	type Cloner struct {
48	Stub bool
49	}
50
51	var PluginCloner Cloner
52
53	// runPluginCmd runs the command from a cloned instance of the
54	// executable in order to address name space binding needs
55	//func (c *Cloner) runPluginCmd(method, fsuid string, args interface{},
56	func (c *Cloner) runPluginCmd(method string, args interface{},
57	reply interface{}) error {	1✔
58		1✔
59	if c.Stub {	2✔
60	// if we are in stub mode, just return success	1✔
61	return nil	1✔
62	}	1✔
63
64	exe, err := os.Executable()	×
65	if err != nil {	×
66	return err	×
67	}	×
68
69	client, err := pie.StartProvider(os.Stderr, exe, "-child-mode")	×
70	if err != nil {	×
71	return err	×
72	}	×
73	defer client.Close()	×
74		×
75	return client.Call(method, args, reply)	×
76	}
77
78	type ClientRPC struct{}
79
80	type SetupVethArgs struct {
81	Sandbox string
82	IfName string
83	Mtu int
84	Ip net.IP
85	}
86
87	type SetupVethResult struct {
88	HostVethName string
89	Mac string
90	}
91
92	func runSetupVeth(sandbox string, ifName string,
93	mtu int, ip net.IP) (string, string, error) {	1✔
94	result := &SetupVethResult{}	1✔
95	err := PluginCloner.runPluginCmd("ClientRPC.SetupVeth",	1✔
96	&SetupVethArgs{sandbox, ifName, mtu, ip}, result)	1✔
97	return result.HostVethName, result.Mac, err	1✔
98	}	1✔
99
100	func (ClientRPC) SetupVeth(args SetupVethArgs, result *SetupVethResult) error {	×
101	netns, err := ns.GetNS(args.Sandbox)	×
102	if err != nil {	×
103	return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)	×
104	}	×
105	defer netns.Close()	×
106		×
107	return netns.Do(func(hostNS ns.NetNS) error {	×
108	// create the veth pair in the container and move host end	×
109	// into host netns	×
110	hostVeth, _, err := ip.SetupVeth(args.IfName, args.Mtu, hostNS)	×
111	if err != nil {	×
112	return err	×
113	}	×
114
115	result.HostVethName = hostVeth.Name	×
116		×
117	// Force a consistent MAC address based on the IPv4 address	×
118	// Currently we dont have a support for V6 based mac allocation. Upstream doesn't support yet :-(	×
119	// This code has to be revisted if upstream drops SetHWAddrByIP in future	×
120	// https://github.com/containernetworking/plugins/blob/e1517e2498fe4774435bc4be6bdd39fa735b469b/pkg/ip/link_linux.go#L228	×
121		×
122	if args.Ip.To4() != nil {	×
123	if err := ip.SetHWAddrByIP(args.IfName, args.Ip, nil); err != nil {	×
124	return fmt.Errorf("failed Ip based MAC address allocation for v4: %v", err)	×
125	}	×
126	}
127
128	contVeth, err := netlink.LinkByName(args.IfName)	×
129	if err != nil {	×
130	return err	×
131	}	×
132
133	result.Mac = contVeth.Attrs().HardwareAddr.String()	×
134	return nil	×
135	})
136	}
137
138	type ClearVethArgs struct {
139	Sandbox string
140	IfName string
141	}
142
143	func runClearVeth(sandbox string, ifName string) error {	1✔
144	ack := false	1✔
145	err := PluginCloner.runPluginCmd("ClientRPC.ClearVeth",	1✔
146	&ClearVethArgs{sandbox, ifName}, &ack)	1✔
147	return err	1✔
148	}	1✔
149
150	func (c ClientRPC) ClearVeth(args ClearVethArgs, ack *bool) error {	×
151	netns, err := ns.GetNS(args.Sandbox)	×
152	if err != nil {	×
153	return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)	×
154	}	×
155	defer netns.Close()	×
156		×
157	*ack = false	×
158	if err := netns.Do(func(_ ns.NetNS) error {	×
159	iface, err := netlink.LinkByName(args.IfName)	×
160	if err != nil {	×
161	return fmt.Errorf("failed to lookup %q: %v", args.IfName, err)	×
162	}	×
163
164	err = netlink.LinkDel(iface)	×
165	if err != nil {	×
166	return fmt.Errorf("failed to delete %q: %v", args.IfName, err)	×
167	}	×
168
169	return nil	×
170	}); err != nil {	×
171	return err	×
172	}	×
173
174	*ack = true	×
175	return nil	×
176	}
177
178	type SetupNetworkArgs struct {
179	Sandbox string
180	IfName string
181	Result *cnicur.Result
182	}
183
184	func runSetupNetwork(sandbox string, ifName string,
185	result *cnicur.Result) error {	1✔
186		1✔
187	ack := false	1✔
188	err := PluginCloner.runPluginCmd("ClientRPC.SetupNetwork",	1✔
189	&SetupNetworkArgs{sandbox, ifName, result}, &ack)	1✔
190	return err	1✔
191	}	1✔
192
193	func (ClientRPC) SetupNetwork(args SetupNetworkArgs, ack *bool) error {	×
194	netns, err := ns.GetNS(args.Sandbox)	×
195	if err != nil {	×
196	return fmt.Errorf("failed to open netns %q: %v", args.Sandbox, err)	×
197	}	×
198	defer netns.Close()	×
199		×
200	// in gob encoding, pointer to 0 gets turned into a nil pointer.	×
201	// This is a bug in the design of gob that will not be fixed:	×
202	// See https://github.com/golang/go/issues/4609	×
203	// Fix it to workaround I guess.	×
204	index := 0	×
205	for _, ip := range args.Result.IPs {	×
206	if ip.Interface == nil {	×
207	ip.Interface = &index	×
208	}	×
209	}
210
211	*ack = false	×
212	if err := netns.Do(func(_ ns.NetNS) error {	×
213	return ipam.ConfigureIface(args.IfName, args.Result)	×
214	}); err != nil {	×
215	return err	×
216	}	×
217
218	*ack = true	×
219	return nil	×
220	}
221
222	func (agent HostAgent) addToResult(iface md.ContainerIfaceMd,
223	index int, result *cnicur.Result) {	1✔
224		1✔
225	result.Interfaces = append(result.Interfaces,	1✔
226	&cnicur.Interface{	1✔
227	Name: iface.Name,	1✔
228	Sandbox: iface.Sandbox,	1✔
229	Mac: iface.Mac,	1✔
230	})	1✔
231	for _, ip := range iface.IPs {	2✔
232	var version string	1✔
233	if ip.Address.IP == nil {	1✔
234	continue	×
235	}
236	if ip.Address.IP.To4() != nil {	2✔
237	version = "4"	1✔
238	} else if ip.Address.IP.To16() != nil {	1✔
239	version = "6"	×
240	} else {	×
241	continue	×
242	}
243
244	ind := index	1✔
245	result.IPs = append(result.IPs,	1✔
246	&cnicur.IPConfig{	1✔
247	Interface: &ind,	1✔
248	Version: version,	1✔
249	Address: ip.Address,	1✔
250	Gateway: ip.Gateway,	1✔
251	})	1✔
252	}
253
254	}
255
256	func (agent HostAgent) configureContainerIfaces(metadata md.ContainerMetadata) (*cnicur.Result, error) {	1✔
257	logger := agent.log.WithFields(logrus.Fields{	1✔
258	"pod": metadata.Id.Pod,	1✔
259	"namespace": metadata.Id.Namespace,	1✔
260	"container": metadata.Id.ContId,	1✔
261	})	1✔
262		1✔
263	podKey := makePodKey(metadata.Id.Namespace, metadata.Id.Pod)	1✔
264	logger.Debug("Setting up veth")	1✔
265	if len(metadata.Ifaces) == 0 {	1✔
266	return nil, errors.New("No interfaces specified")	×
267	}	×
268	result := &cnicur.Result{}	1✔
269		1✔
270	for _, nc := range agent.config.NetConfig {	2✔
271	result.Routes =	1✔
272	append(result.Routes, convertRoutes(nc.Routes)...)	1✔
273	}	1✔
274
275	for ifaceind, iface := range metadata.Ifaces {	2✔
276	var err error	1✔
277	var mtu int	1✔
278	if agent.config.InterfaceMtu == 0 {	2✔
279	// MTU not explicitly set in config or discovered	1✔
280	mtu = 1500	1✔
281	} else {	1✔
282	mtu = agent.config.InterfaceMtu	×
283	}	×
284
285	if len(iface.IPs) == 0 {	2✔
286	// We're doing ip address management	1✔
287		1✔
288	logger.Debug("Allocating IP address(es) for ", iface.Name)	1✔
289	err = agent.allocateIps(iface, podKey)	1✔
290	if err != nil {	1✔
291	return nil, err	×
292	}	×
293	}
294	for _, ip := range iface.IPs {	2✔
295	//There are 4 cases: IPv4-only, IPv6-only, dual stack with either IPv4 or IPv6 as the first address.	1✔
296	//We are guaranteed to derive the MAC address from IPv4 if it is assigned	1✔
297	if ip.Address.IP != nil && ip.Address.IP.To4() != nil {	2✔
298	iface.HostVethName, iface.Mac, err =	1✔
299	runSetupVeth(iface.Sandbox, iface.Name, mtu, ip.Address.IP)	1✔
300	if err != nil {	1✔
301	return nil, err	×
302	} else {	1✔
303	break	1✔
304	}
305	}
306	}
307	// if no mac is assigned, set it to the default Mac.
308	if len(iface.Mac) == 0 {	2✔
309	iface.HostVethName, iface.Mac, err =	1✔
310	runSetupVeth(iface.Sandbox, iface.Name, agent.config.InterfaceMtu, nil)	1✔
311	if err != nil {	1✔
312	return nil, err	×
313	}	×
314	}
315
316	agent.addToResult(iface, ifaceind, result)	1✔
317		1✔
318	logger.Debug("Configuring network for ", iface.Name, ": ", *result)	1✔
319	err = runSetupNetwork(iface.Sandbox, iface.Name, result)	1✔
320	if err != nil {	1✔
321	agent.ipamMutex.Lock()	×
322	agent.deallocateIpsLocked(iface)	×
323	agent.ipamMutex.Unlock()	×
324	return nil, err	×
325	}	×
326	}
327	var StaleContMetadata []md.ContainerMetadata	1✔
328	podid := metadata.Id.Namespace + "/" + metadata.Id.Pod	1✔
329	agent.indexMutex.Lock()	1✔
330	if len(agent.epMetadata[podid]) > 1 {	1✔
331	logger.Warnf("There is a Stale metadata present for the pod")	×
332	}	×
333	if val, ok := agent.epMetadata[podid]; ok {	2✔
334	// check for any stale entry present.	1✔
335	// this is possible if we miss any register events for unconfiguring the POD	1✔
336	// ideally epMetadata[podid] Map should contain only one entry of containerID	1✔
337	// As every pod contains one network namespace for all the containers with in the pod	1✔
338	// (i.e pause container ==> metadata.Id.ContId)	1✔
339	// if there are any stale which doesn't match the ContainerID remove it	1✔
340	for key, v := range val {	2✔
341	if metadata.Id.ContId != key {	2✔
342	logger.Warnf("Stale metadata present clean the entry: %s", key)	1✔
343	StaleContMetadata = append(StaleContMetadata, *v)	1✔
344	}	1✔
345	}
346	}
347	agent.indexMutex.Unlock()	1✔
348		1✔
349	for _, v := range StaleContMetadata {	2✔
350	err := agent.cleanStatleMetadata(v.Id.ContId)	1✔
351	if err == nil {	2✔
352	agent.deallocateMdIps(&v)	1✔
353	agent.ipamMutex.Lock()	1✔
354	delete(agent.epMetadata[podid], v.Id.ContId)	1✔
355	agent.ipamMutex.Unlock()	1✔
356	}	1✔
357	}
358
359	err := md.RecordMetadata(agent.config.CniMetadataDir,	1✔
360	agent.config.CniNetwork, *metadata)	1✔
361	if err != nil {	1✔
362	logger.Debug("ERROR RecordMetadata")	×
363	return nil, err	×
364	}	×
365
366	agent.indexMutex.Lock()	1✔
367	if _, ok := agent.epMetadata[podid]; !ok {	2✔
368	agent.epMetadata[podid] =	1✔
369	make(map[string]*md.ContainerMetadata)	1✔
370	}	1✔
371	agent.epMetadata[podid][metadata.Id.ContId] = metadata	1✔
372	agent.indexMutex.Unlock()	1✔
373		1✔
374	agent.env.CniDeviceChanged(&podid, &metadata.Id)	1✔
375		1✔
376	logger.Info("Successfully configured container interface")	1✔
377	return result, nil	1✔
378	}
379
380	func (agent *HostAgent) cleanStatleMetadata(id string) error {	1✔
381	_, err := md.GetMetadata(agent.config.CniMetadataDir,	1✔
382	agent.config.CniNetwork, id)	1✔
383	if err == nil {	2✔
384	err := md.ClearMetadata(agent.config.CniMetadataDir,	1✔
385	agent.config.CniNetwork, id)	1✔
386	if err != nil {	1✔
387	return err	×
388	}	×
389	}
390	return err	1✔
391	}
392
393	func (agent HostAgent) unconfigureContainerIfaces(id md.ContainerId) error {	1✔
394	logger := agent.log.WithFields(logrus.Fields{	1✔
395	"ContId": id.ContId,	1✔
396	"Pod": id.Pod,	1✔
397	"Namespace": id.Namespace,	1✔
398	})	1✔
399		1✔
400	podid := id.Namespace + "/" + id.Pod	1✔
401		1✔
402	agent.indexMutex.Lock()	1✔
403	mdmap, ok := agent.epMetadata[podid]	1✔
404	if !ok {	2✔
405	logger.Error("Unconfigure called for pod with no metadata")	1✔
406	// Assume container is already unconfigured	1✔
407	agent.indexMutex.Unlock()	1✔
408	return nil	1✔
409	}	1✔
410	metadata, ok := mdmap[id.ContId]	1✔
411	if !ok {	2✔
412	logger.Error("Unconfigure called for container with no metadata")	1✔
413	// Assume container is already unconfigured	1✔
414	agent.indexMutex.Unlock()	1✔
415	return nil	1✔
416	}	1✔
417	delete(mdmap, id.ContId)	1✔
418	if len(mdmap) == 0 {	2✔
419	delete(agent.epMetadata, podid)	1✔
420	}	1✔
421	agent.indexMutex.Unlock()	1✔
422		1✔
423	err := md.ClearMetadata(agent.config.CniMetadataDir,	1✔
424	agent.config.CniNetwork, id.ContId)	1✔
425	if err != nil {	1✔
426	return err	×
427	}	×
428
429	agent.cniEpDelete(podid)	1✔
430	logger.Debug("Deallocating IP address(es)")	1✔
431	agent.deallocateMdIps(metadata)	1✔
432		1✔
433	logger.Debug("Clearing container interface")	1✔
434	for _, iface := range metadata.Ifaces {	2✔
435	err = runClearVeth(iface.Sandbox, iface.Name)	1✔
436	if err != nil {	1✔
437	logger.Error("Could not clear Veth ports: ", err)	×
438	}	×
439	}
440
441	agent.env.CniDeviceDeleted(&podid, id)	1✔
442		1✔
443	logger.Info("Successfully unconfigured container interface")	1✔
444	return nil	1✔
445	}
446
447	func (agent *HostAgent) cleanupSetup() {	1✔
448	agent.log.Info("Checking for stale container setup")	1✔
449		1✔
450	agent.indexMutex.Lock()	1✔
451	if !agent.syncEnabled {	2✔
452	agent.indexMutex.Unlock()	1✔
453	agent.log.Info("Sync not enabled, skipping stale container setup")	1✔
454	return	1✔
455	}	1✔
456	mdcopy := agent.epMetadata	1✔
457	agent.indexMutex.Unlock()	1✔
458		1✔
459	for podkey, mdmap := range mdcopy {	1✔
460	logger := agent.log.WithFields(logrus.Fields{	×
461	"podkey": podkey,	×
462	})	×
463		×
464	logger.Debug("Checking")	×
465	exists, err := agent.env.CheckPodExists(&podkey)	×
466	if err != nil {	×
467	logger.Error("Could not lookup pod: ", err)	×
468	continue	×
469	}
470
471	if !exists {	×
472	for _, metadata := range mdmap {	×
473	logger := agent.log.WithFields(logrus.Fields{	×
474	"namespace": metadata.Id.Namespace,	×
475	"pod": metadata.Id.Pod,	×
476	"contid": metadata.Id.ContId,	×
477	})	×
478	logger.Info("Unconfiguring stale container configuration")	×
479		×
480	err := agent.unconfigureContainerIfaces(&metadata.Id)	×
481	if err != nil {	×
482	logger.Error("Could not unconfigure container: ", err)	×
483	}	×
484	}
485	}
486	}
487
488	err := agent.syncPorts(agent.config.OvsDbSock)	1✔
489	if err != nil {	2✔
490	agent.log.Error("Could not sync OVS ports: ", err)	1✔
491	}	1✔
492
493	agent.log.Debug("Done stale check")	1✔
494	}

noironetworks / aci-containers / 4499

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous