5682

Committed 08 Sep 2021 01:07AM UTC coverage: 57.546%. First build

Build # 5682

Build Type

Pull #879

travis-ci-com

Committed by

web-flow

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/8c895917a938053b2f8e4ba0b1495b8c60485436">8c895917a<a href="https://github.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c60485436">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/noironetworks/aci-containers/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c60485436&quot;&gt;8c895917a&lt;/a&gt;&lt;a href=&quot;https://github.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c60485436&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c&lt;/a&gt;60485436&quot;&gt;&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/03df8b3d8a0516ffb20e8e521489deedbb4eac09">03df8b3d8</a><a href="https://github.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c60485436">&amp;quot;&amp;gt;03df8b3d8&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;03df8b3d8&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/8c895917a938053b2f8e4ba0b1495b8c60485&lt;/a&gt;436&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/bbdc6cdff">bbdc6cdff">bbdc6cdff</a>

Pull Request Pull Request #879: Make mtu configurable

Run Details

3 of 3 new or added lines in 2 files covered. (100.0%)

11485 of 19958 relevant lines covered (57.55%)

0.64 hits per line

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

38.06

/pkg/hostagent/opflex.go

// Copyright 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 (
        "bytes"
        "errors"
        "io/ioutil"
        "net"
        "os"
        "path/filepath"
        "reflect"
        "strings"
        "text/template"

        "encoding/json"

        uuid "github.com/google/uuid"
        "github.com/sirupsen/logrus"
        "github.com/vishvananda/netlink"
)

type opflexFault struct {
        FaultUUID   string `json:"fault_uuid"`
        Severity    string `json:"severity"`
        Description string `json:"description"`
        FaultCode   int    `json:"faultCode"`
}

func writeFault(faultfile string, ep *opflexFault) (bool, error) {
        newdata, err := json.MarshalIndent(ep, "", "  ")
        if err != nil {
                return true, err
        }
        existingdata, err := ioutil.ReadFile(faultfile)
        if err == nil && reflect.DeepEqual(existingdata, newdata) {
                return false, nil
        }
        err = ioutil.WriteFile(faultfile, newdata, 0644)
        return true, err
}

func (agent *HostAgent) createFaultOnAgent(description string, faultCode int) {
        if agent.config.OpFlexFaultDir == "" {
                agent.log.Error("OpFlex Fault directory not set")
                return
        }
        Uuid := uuid.New().String()
        faultFilePath := filepath.Join(agent.config.OpFlexFaultDir, description+".fs")
        faultFileExists := fileExists(faultFilePath)
        if faultFileExists {
                agent.log.Debug("Fault file exist at: ", faultFilePath)
                return
        }
        desc := strings.Replace(description, "_", " ", -1)
        fault := &opflexFault{
                FaultUUID:   Uuid,
                Severity:    "critical",
                Description: desc,
                FaultCode:   faultCode,
        }
        wrote, err := writeFault(faultFilePath, fault)
        if err != nil {
                agent.log.Warn("Unable to write fault file: ", err.Error())
        } else if wrote {
                agent.log.Debug("Created fault files at the location: ", faultFilePath)
        }
        return
}

func (agent *HostAgent) discoverHostConfig() (conf *HostAgentNodeConfig) {
        if agent.config.OpflexMode == "overlay" {
                conf = &HostAgentNodeConfig{}
                conf.OpflexPeerIp = "127.0.0.1"
                agent.log.Debug("\n  == Opflex: Running in overlay mode ==\n")
                return
        }

        links, err := netlink.LinkList()
        if err != nil {
                agent.log.Error("Could not enumerate interfaces: ", err)
                description := "Could_not_enumerate_interfaces"
                agent.createFaultOnAgent(description, 3)
                return
        }

        for _, link := range links {
                switch link := link.(type) {
                case *netlink.Vlan:
                        // find link with matching vlan
                        if link.VlanId != int(agent.config.AciInfraVlan) {
                                continue
                        }
                        // if the interface MTU was not explicitly set by
                        // the user, use the link MTU
                        if agent.config.InterfaceMtu == 0 {
                                agent.config.InterfaceMtu = link.MTU - agent.config.InterfaceMtuHeadroom
                        }
                        // giving extra headroom of 100 bytes unless specified otherwise
                        configMtu := agent.config.InterfaceMtuHeadroom + agent.config.InterfaceMtu
                        if link.MTU < configMtu {
                                agent.log.WithFields(logrus.Fields{
                                        "name": link.Name,
                                        "vlan": agent.config.AciInfraVlan,
                                        "mtu":  link.MTU,
                                }).Error("OpFlex link MTU must be >= ", configMtu)
                                description := "User_configured_MTU_exceeds_opflex_MTU"
                                agent.createFaultOnAgent(description, 4)
                                return
                        }

                        // find parent link
                        var parent netlink.Link
                        for _, plink := range links {
                                if plink.Attrs().Index != link.ParentIndex {
                                        continue
                                }

                                parent = plink
                                if parent.Attrs().MTU < configMtu {
                                        agent.log.WithFields(logrus.Fields{
                                                "name": parent.Attrs().Name,
                                                "vlan": agent.config.AciInfraVlan,
                                                "mtu":  parent.Attrs().MTU,
                                        }).Error("Uplink MTU must be >= ", configMtu)
                                        description := "User_configured_MTU_exceed_uplink_MTU"
                                        agent.createFaultOnAgent(description, 5)
                                        return
                                }
                        }
                        if parent == nil {
                                agent.log.WithFields(logrus.Fields{
                                        "index": link.ParentIndex,
                                        "name":  link.Name,
                                }).Error("Could not find parent link for OpFlex interface")
                                description := "Could_not_find_parent_link_for_OpFlex_interface"
                                agent.createFaultOnAgent(description, 6)
                                return
                        }

                        // Find address of link to compute anycast and peer IPs
                        addrs, err := netlink.AddrList(link, 2)
                        if err != nil {
                                agent.log.WithFields(logrus.Fields{
                                        "name": link.Name,
                                }).Error("Could not enumerate link addresses: ", err)
                                description := "Could_not_enumerate_link_addresses"
                                agent.createFaultOnAgent(description, 7)
                                return
                        }
                        var anycast net.IP
                        var peerIp net.IP
                        for _, addr := range addrs {
                                if addr.IP.To4() == nil || addr.IP.IsLoopback() {
                                        continue
                                }
                                anycast = addr.IP.Mask(addr.Mask)
                                anycast[len(anycast)-1] = 32
                                peerIp = addr.IP.Mask(addr.Mask)
                                peerIp[len(peerIp)-1] = 30
                        }

                        if anycast == nil {
                                agent.log.WithFields(logrus.Fields{
                                        "name": link.Name,
                                        "vlan": agent.config.AciInfraVlan,
                                }).Error("IP address not set for OpFlex link")
                                description := "IP_address_not_set_for_OpFlex_link"
                                agent.createFaultOnAgent(description, 8)
                                return
                        }

                        conf = &HostAgentNodeConfig{}
                        conf.VxlanIface = link.Name
                        conf.UplinkIface = parent.Attrs().Name
                        conf.VxlanAnycastIp = anycast.String()
                        conf.OpflexPeerIp = peerIp.String()
                }
        }

        if conf != nil {
                intf, err := net.InterfaceByName(conf.UplinkIface)
                if err == nil {
                        conf.UplinkMacAdress = intf.HardwareAddr.String()
                        return
                }
        }

        agent.log.WithFields(logrus.Fields{"vlan": agent.config.AciInfraVlan}).
                Error("Could not find suitable host uplink interface for vlan")
        description := "Could_not_find_suitable_host_uplink_interface_for_vlan"
        agent.createFaultOnAgent(description, 9)
        return
}

var opflexConfigBase = initTempl("opflex-config-base", `{
    "opflex": {
        "name": "{{.NodeName | js}}",
        "domain": "{{print "comp/prov-" .AciVmmDomainType "/ctrlr-[" .AciVmmDomain "]-" .AciVmmController "/sw-InsiemeLSOid" | js}}",
        "peers": [
            {"hostname": "{{.OpflexPeerIp | js}}", "port": "8009"}
        ]
    } ,
    "endpoint-sources": {
        "filesystem": ["{{.OpFlexEndpointDir | js}}"]
    },
    "service-sources": {
        "filesystem": ["{{.OpFlexServiceDir | js}}"]
    },
    "snat-sources": {
        "filesystem": ["{{.OpFlexSnatDir | js}}"]
    },
    "drop-log-config-sources": {
        "filesystem": ["{{.OpFlexDropLogConfigDir | js}}"]
    },
    "packet-event-notif": {
        "socket-name": ["{{.PacketEventNotificationSock | js}}"]
    },
    "host-agent-fault-sources": {
        "filesystem": ["{{.OpFlexFaultDir | js}}"]
    }
}
`)

var opflexConfigVxlan = initTempl("opflex-config-vxlan", `{
    "renderers": {
        "stitched-mode": {
            "int-bridge-name": "{{.IntBridgeName | js}}",
            "access-bridge-name": "{{.AccessBridgeName | js}}",
            "encap": {
                "vxlan" : {
                    "encap-iface": "vxlan0",
                    "uplink-iface": "{{.VxlanIface | js}}",
                    "uplink-vlan": "{{.AciInfraVlan}}",
                    "remote-ip": "{{.VxlanAnycastIp | js}}",
                    "remote-port": 8472
                }
            },
            "flowid-cache-dir": "{{.OpFlexFlowIdCacheDir | js}}",
            "mcast-group-file": "{{.OpFlexMcastFile | js}}",
            "drop-log": {
                "geneve" : {
                    "int-br-iface": "{{.DropLogIntInterface | js}}",
                    "access-br-iface": "{{.DropLogAccessInterface | js}}",
                    "remote-ip": "{{.OpFlexDropLogRemoteIp | js}}"
                }
            }
        }
    }
}
`)

var opflexConfigVlan = initTempl("opflex-config-vlan", `{
    "renderers": {
        "stitched-mode": {
            "int-bridge-name": "{{.IntBridgeName | js}}",
            "access-bridge-name": "{{.AccessBridgeName | js}}",
            "encap": {
                "vlan" : {
                    "encap-iface": "{{.UplinkIface | js}}"
                }
            },
            "flowid-cache-dir": "{{.OpFlexFlowIdCacheDir | js}}",
            "mcast-group-file": "{{.OpFlexMcastFile | js}}",
            "drop-log": {
                "geneve" : {
                    "int-br-iface": "{{.DropLogIntInterface | js}}",
                    "access-br-iface": "{{.DropLogAccessInterface | js}}",
                    "remote-ip": "{{.OpFlexDropLogRemoteIp | js}}"
                }
            }
        }
    }
}
`)

func initTempl(name string, templ string) *template.Template {
        return template.Must(template.New(name).Parse(templ))
}

func (agent *HostAgent) writeConfigFile(name string,
        templ *template.Template) error {

        var buffer bytes.Buffer
        templ.Execute(&buffer, agent.config)

        path := filepath.Join(agent.config.OpFlexConfigPath, name)

        existing, err := ioutil.ReadFile(path)
        if err != nil {
                if bytes.Equal(existing, buffer.Bytes()) {
                        agent.log.Info("OpFlex agent configuration file ",
                                path, " unchanged")
                        return nil
                }
        }

        f, err := os.Create(path)
        if err != nil {
                return err
        }
        // in case there's an error in the write
        defer f.Close()
        _, err = f.Write(buffer.Bytes())
        if err != nil {
                return err
        }
        err = f.Close()
        if err != nil {
                return err
        }

        agent.log.Info("Wrote OpFlex agent configuration file ", path)

        return nil
}

func (agent *HostAgent) updateOpflexConfig() {
        if agent.config.OpFlexConfigPath == "" {
                agent.log.Debug("OpFlex agent configuration path not set")
                return
        }
        if agent.config.OpFlexFaultDir == "" {
                agent.log.Warn("OpFlex Fault directory not set")
        } else {
                err := agent.removeAllFiles(agent.config.OpFlexFaultDir)
                if err != nil {
                        agent.log.Error("Not able to clear Fault files on agent: ", err.Error())
                }
        }

        newNodeConfig := agent.discoverHostConfig()
        if newNodeConfig == nil {
                panic(errors.New("Node configuration autodiscovery failed"))
        }
        var update bool

        agent.indexMutex.Lock()
        if !reflect.DeepEqual(*newNodeConfig, agent.config.HostAgentNodeConfig) ||
                !agent.opflexConfigWritten {

                // reset opflexConfigWritten flag when node-config differs
                agent.opflexConfigWritten = false

                agent.config.HostAgentNodeConfig = *newNodeConfig
                agent.log.WithFields(logrus.Fields{
                        "uplink-iface":     newNodeConfig.UplinkIface,
                        "vxlan-iface":      newNodeConfig.VxlanIface,
                        "vxlan-anycast-ip": newNodeConfig.VxlanAnycastIp,
                        "opflex-peer-ip":   newNodeConfig.OpflexPeerIp,
                        "opflex-mode":      agent.config.OpflexMode,
                }).Info("Discovered node configuration")
                if err := agent.writeOpflexConfig(); err == nil {
                        agent.opflexConfigWritten = true
                } else {
                        agent.log.Error("Failed to write OpFlex agent config: ", err)
                }
        }
        agent.indexMutex.Unlock()

        if update {
                agent.updateAllServices()
        }
}

func (agent *HostAgent) writeOpflexConfig() error {
        err := agent.writeConfigFile("01-base.conf", opflexConfigBase)
        if err != nil {
                return err
        }

        var rtempl *template.Template
        if agent.config.EncapType == "vlan" {
                rtempl = opflexConfigVlan
        } else if agent.config.EncapType == "vxlan" {
                rtempl = opflexConfigVxlan
        } else {
                panic("Unsupported encap type: " + agent.config.EncapType)
        }

        err = agent.writeConfigFile("10-renderer.conf", rtempl)
        if err != nil {
                return err
        }
        return nil
}

func (agent *HostAgent) removeAllFiles(dir string) error {
        d, err := os.Open(dir)
        if err != nil {
                return err
        }
        defer d.Close()
        names, err := d.Readdirnames(-1)
        if err != nil {
                return err
        }
        for _, name := range names {
                err = os.RemoveAll(filepath.Join(dir, name))
                if err != nil {
                        agent.log.Error("Not able to clear the Fault Files  ", err)
                        return err
                }
        }
        return nil
}

1	// Copyright 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	"bytes"
19	"errors"
20	"io/ioutil"
21	"net"
22	"os"
23	"path/filepath"
24	"reflect"
25	"strings"
26	"text/template"
27
28	"encoding/json"
29
30	uuid "github.com/google/uuid"
31	"github.com/sirupsen/logrus"
32	"github.com/vishvananda/netlink"
33	)
34
35	type opflexFault struct {
36	FaultUUID string `json:"fault_uuid"`
37	Severity string `json:"severity"`
38	Description string `json:"description"`
39	FaultCode int `json:"faultCode"`
40	}
41
42	func writeFault(faultfile string, ep *opflexFault) (bool, error) {	1✔
43	newdata, err := json.MarshalIndent(ep, "", " ")	1✔
44	if err != nil {	1✔
45	return true, err	×
46	}	×
47	existingdata, err := ioutil.ReadFile(faultfile)	1✔
48	if err == nil && reflect.DeepEqual(existingdata, newdata) {	1✔
49	return false, nil	×
50	}	×
51	err = ioutil.WriteFile(faultfile, newdata, 0644)	1✔
52	return true, err	1✔
53	}
54
55	func (agent *HostAgent) createFaultOnAgent(description string, faultCode int) {	1✔
56	if agent.config.OpFlexFaultDir == "" {	2✔
57	agent.log.Error("OpFlex Fault directory not set")	1✔
58	return	1✔
59	}	1✔
60	Uuid := uuid.New().String()	1✔
61	faultFilePath := filepath.Join(agent.config.OpFlexFaultDir, description+".fs")	1✔
62	faultFileExists := fileExists(faultFilePath)	1✔
63	if faultFileExists {	1✔
64	agent.log.Debug("Fault file exist at: ", faultFilePath)	×
65	return	×
66	}	×
67	desc := strings.Replace(description, "_", " ", -1)	1✔
68	fault := &opflexFault{	1✔
69	FaultUUID: Uuid,	1✔
70	Severity: "critical",	1✔
71	Description: desc,	1✔
72	FaultCode: faultCode,	1✔
73	}	1✔
74	wrote, err := writeFault(faultFilePath, fault)	1✔
75	if err != nil {	1✔
76	agent.log.Warn("Unable to write fault file: ", err.Error())	×
77	} else if wrote {	2✔
78	agent.log.Debug("Created fault files at the location: ", faultFilePath)	1✔
79	}	1✔
80	return	1✔
81	}
82
83	func (agent HostAgent) discoverHostConfig() (conf HostAgentNodeConfig) {	1✔
84	if agent.config.OpflexMode == "overlay" {	2✔
85	conf = &HostAgentNodeConfig{}	1✔
86	conf.OpflexPeerIp = "127.0.0.1"	1✔
87	agent.log.Debug("\n == Opflex: Running in overlay mode ==\n")	1✔
88	return	1✔
89	}	1✔
90
91	links, err := netlink.LinkList()	1✔
92	if err != nil {	1✔
93	agent.log.Error("Could not enumerate interfaces: ", err)	×
94	description := "Could_not_enumerate_interfaces"	×
95	agent.createFaultOnAgent(description, 3)	×
96	return	×
97	}	×
98
99	for _, link := range links {	2✔
100	switch link := link.(type) {	1✔
101	case *netlink.Vlan:	×
102	// find link with matching vlan	×
103	if link.VlanId != int(agent.config.AciInfraVlan) {	×
104	continue	×
105	}
106	// if the interface MTU was not explicitly set by
107	// the user, use the link MTU
108	if agent.config.InterfaceMtu == 0 {	×
109	agent.config.InterfaceMtu = link.MTU - agent.config.InterfaceMtuHeadroom	×
110	}	×
111	// giving extra headroom of 100 bytes unless specified otherwise
112	configMtu := agent.config.InterfaceMtuHeadroom + agent.config.InterfaceMtu	×
113	if link.MTU < configMtu {	×
114	agent.log.WithFields(logrus.Fields{	×
115	"name": link.Name,	×
116	"vlan": agent.config.AciInfraVlan,	×
117	"mtu": link.MTU,	×
118	}).Error("OpFlex link MTU must be >= ", configMtu)	×
119	description := "User_configured_MTU_exceeds_opflex_MTU"	×
120	agent.createFaultOnAgent(description, 4)	×
121	return	×
122	}	×
123
124	// find parent link
125	var parent netlink.Link	×
126	for _, plink := range links {	×
127	if plink.Attrs().Index != link.ParentIndex {	×
128	continue	×
129	}
130
131	parent = plink	×
132	if parent.Attrs().MTU < configMtu {	×
133	agent.log.WithFields(logrus.Fields{	×
134	"name": parent.Attrs().Name,	×
135	"vlan": agent.config.AciInfraVlan,	×
136	"mtu": parent.Attrs().MTU,	×
137	}).Error("Uplink MTU must be >= ", configMtu)	×
138	description := "User_configured_MTU_exceed_uplink_MTU"	×
139	agent.createFaultOnAgent(description, 5)	×
140	return	×
141	}	×
142	}
143	if parent == nil {	×
144	agent.log.WithFields(logrus.Fields{	×
145	"index": link.ParentIndex,	×
146	"name": link.Name,	×
147	}).Error("Could not find parent link for OpFlex interface")	×
148	description := "Could_not_find_parent_link_for_OpFlex_interface"	×
149	agent.createFaultOnAgent(description, 6)	×
150	return	×
151	}	×
152
153	// Find address of link to compute anycast and peer IPs
154	addrs, err := netlink.AddrList(link, 2)	×
155	if err != nil {	×
156	agent.log.WithFields(logrus.Fields{	×
157	"name": link.Name,	×
158	}).Error("Could not enumerate link addresses: ", err)	×
159	description := "Could_not_enumerate_link_addresses"	×
160	agent.createFaultOnAgent(description, 7)	×
161	return	×
162	}	×
163	var anycast net.IP	×
164	var peerIp net.IP	×
165	for _, addr := range addrs {	×
166	if addr.IP.To4() == nil \|\| addr.IP.IsLoopback() {	×
167	continue	×
168	}
169	anycast = addr.IP.Mask(addr.Mask)	×
170	anycast[len(anycast)-1] = 32	×
171	peerIp = addr.IP.Mask(addr.Mask)	×
172	peerIp[len(peerIp)-1] = 30	×
173	}
174
175	if anycast == nil {	×
176	agent.log.WithFields(logrus.Fields{	×
177	"name": link.Name,	×
178	"vlan": agent.config.AciInfraVlan,	×
179	}).Error("IP address not set for OpFlex link")	×
180	description := "IP_address_not_set_for_OpFlex_link"	×
181	agent.createFaultOnAgent(description, 8)	×
182	return	×
183	}	×
184
185	conf = &HostAgentNodeConfig{}	×
186	conf.VxlanIface = link.Name	×
187	conf.UplinkIface = parent.Attrs().Name	×
188	conf.VxlanAnycastIp = anycast.String()	×
189	conf.OpflexPeerIp = peerIp.String()	×
190	}
191	}
192
193	if conf != nil {	1✔
194	intf, err := net.InterfaceByName(conf.UplinkIface)	×
195	if err == nil {	×
196	conf.UplinkMacAdress = intf.HardwareAddr.String()	×
197	return	×
198	}	×
199	}
200
201	agent.log.WithFields(logrus.Fields{"vlan": agent.config.AciInfraVlan}).	1✔
202	Error("Could not find suitable host uplink interface for vlan")	1✔
203	description := "Could_not_find_suitable_host_uplink_interface_for_vlan"	1✔
204	agent.createFaultOnAgent(description, 9)	1✔
205	return	1✔
206	}
207
208	var opflexConfigBase = initTempl("opflex-config-base", `{
209	"opflex": {
210	"name": "{{.NodeName \| js}}",
211	"domain": "{{print "comp/prov-" .AciVmmDomainType "/ctrlr-[" .AciVmmDomain "]-" .AciVmmController "/sw-InsiemeLSOid" \| js}}",
212	"peers": [
213	{"hostname": "{{.OpflexPeerIp \| js}}", "port": "8009"}
214	]
215	} ,
216	"endpoint-sources": {
217	"filesystem": ["{{.OpFlexEndpointDir \| js}}"]
218	},
219	"service-sources": {
220	"filesystem": ["{{.OpFlexServiceDir \| js}}"]
221	},
222	"snat-sources": {
223	"filesystem": ["{{.OpFlexSnatDir \| js}}"]
224	},
225	"drop-log-config-sources": {
226	"filesystem": ["{{.OpFlexDropLogConfigDir \| js}}"]
227	},
228	"packet-event-notif": {
229	"socket-name": ["{{.PacketEventNotificationSock \| js}}"]
230	},
231	"host-agent-fault-sources": {
232	"filesystem": ["{{.OpFlexFaultDir \| js}}"]
233	}
234	}
235	`)
236
237	var opflexConfigVxlan = initTempl("opflex-config-vxlan", `{
238	"renderers": {
239	"stitched-mode": {
240	"int-bridge-name": "{{.IntBridgeName \| js}}",
241	"access-bridge-name": "{{.AccessBridgeName \| js}}",
242	"encap": {
243	"vxlan" : {
244	"encap-iface": "vxlan0",
245	"uplink-iface": "{{.VxlanIface \| js}}",
246	"uplink-vlan": "{{.AciInfraVlan}}",
247	"remote-ip": "{{.VxlanAnycastIp \| js}}",
248	"remote-port": 8472
249	}
250	},
251	"flowid-cache-dir": "{{.OpFlexFlowIdCacheDir \| js}}",
252	"mcast-group-file": "{{.OpFlexMcastFile \| js}}",
253	"drop-log": {
254	"geneve" : {
255	"int-br-iface": "{{.DropLogIntInterface \| js}}",
256	"access-br-iface": "{{.DropLogAccessInterface \| js}}",
257	"remote-ip": "{{.OpFlexDropLogRemoteIp \| js}}"
258	}
259	}
260	}
261	}
262	}
263	`)
264
265	var opflexConfigVlan = initTempl("opflex-config-vlan", `{
266	"renderers": {
267	"stitched-mode": {
268	"int-bridge-name": "{{.IntBridgeName \| js}}",
269	"access-bridge-name": "{{.AccessBridgeName \| js}}",
270	"encap": {
271	"vlan" : {
272	"encap-iface": "{{.UplinkIface \| js}}"
273	}
274	},
275	"flowid-cache-dir": "{{.OpFlexFlowIdCacheDir \| js}}",
276	"mcast-group-file": "{{.OpFlexMcastFile \| js}}",
277	"drop-log": {
278	"geneve" : {
279	"int-br-iface": "{{.DropLogIntInterface \| js}}",
280	"access-br-iface": "{{.DropLogAccessInterface \| js}}",
281	"remote-ip": "{{.OpFlexDropLogRemoteIp \| js}}"
282	}
283	}
284	}
285	}
286	}
287	`)
288
289	func initTempl(name string, templ string) *template.Template {	1✔
290	return template.Must(template.New(name).Parse(templ))	1✔
291	}	1✔
292
293	func (agent *HostAgent) writeConfigFile(name string,
294	templ *template.Template) error {	1✔
295		1✔
296	var buffer bytes.Buffer	1✔
297	templ.Execute(&buffer, agent.config)	1✔
298		1✔
299	path := filepath.Join(agent.config.OpFlexConfigPath, name)	1✔
300		1✔
301	existing, err := ioutil.ReadFile(path)	1✔
302	if err != nil {	2✔
303	if bytes.Equal(existing, buffer.Bytes()) {	1✔
304	agent.log.Info("OpFlex agent configuration file ",	×
305	path, " unchanged")	×
306	return nil	×
307	}	×
308	}
309
310	f, err := os.Create(path)	1✔
311	if err != nil {	1✔
312	return err	×
313	}	×
314	// in case there's an error in the write
315	defer f.Close()	1✔
316	_, err = f.Write(buffer.Bytes())	1✔
317	if err != nil {	1✔
318	return err	×
319	}	×
320	err = f.Close()	1✔
321	if err != nil {	1✔
322	return err	×
323	}	×
324
325	agent.log.Info("Wrote OpFlex agent configuration file ", path)	1✔
326		1✔
327	return nil	1✔
328	}
329
330	func (agent *HostAgent) updateOpflexConfig() {	1✔
331	if agent.config.OpFlexConfigPath == "" {	2✔
332	agent.log.Debug("OpFlex agent configuration path not set")	1✔
333	return	1✔
334	}	1✔
335	if agent.config.OpFlexFaultDir == "" {	×
336	agent.log.Warn("OpFlex Fault directory not set")	×
337	} else {	×
338	err := agent.removeAllFiles(agent.config.OpFlexFaultDir)	×
339	if err != nil {	×
340	agent.log.Error("Not able to clear Fault files on agent: ", err.Error())	×
341	}	×
342	}
343
344	newNodeConfig := agent.discoverHostConfig()	×
345	if newNodeConfig == nil {	×
346	panic(errors.New("Node configuration autodiscovery failed"))	×
347	}
348	var update bool	×
349		×
350	agent.indexMutex.Lock()	×
351	if !reflect.DeepEqual(*newNodeConfig, agent.config.HostAgentNodeConfig) \|\|	×
352	!agent.opflexConfigWritten {	×
353		×
354	// reset opflexConfigWritten flag when node-config differs	×
355	agent.opflexConfigWritten = false	×
356		×
357	agent.config.HostAgentNodeConfig = *newNodeConfig	×
358	agent.log.WithFields(logrus.Fields{	×
359	"uplink-iface": newNodeConfig.UplinkIface,	×
360	"vxlan-iface": newNodeConfig.VxlanIface,	×
361	"vxlan-anycast-ip": newNodeConfig.VxlanAnycastIp,	×
362	"opflex-peer-ip": newNodeConfig.OpflexPeerIp,	×
363	"opflex-mode": agent.config.OpflexMode,	×
364	}).Info("Discovered node configuration")	×
365	if err := agent.writeOpflexConfig(); err == nil {	×
366	agent.opflexConfigWritten = true	×
367	} else {	×
368	agent.log.Error("Failed to write OpFlex agent config: ", err)	×
369	}	×
370	}
371	agent.indexMutex.Unlock()	×
372		×
373	if update {	×
374	agent.updateAllServices()	×
375	}	×
376	}
377
378	func (agent *HostAgent) writeOpflexConfig() error {	1✔
379	err := agent.writeConfigFile("01-base.conf", opflexConfigBase)	1✔
380	if err != nil {	1✔
381	return err	×
382	}	×
383
384	var rtempl *template.Template	1✔
385	if agent.config.EncapType == "vlan" {	2✔
386	rtempl = opflexConfigVlan	1✔
387	} else if agent.config.EncapType == "vxlan" {	3✔
388	rtempl = opflexConfigVxlan	1✔
389	} else {	1✔
390	panic("Unsupported encap type: " + agent.config.EncapType)	×
391	}
392
393	err = agent.writeConfigFile("10-renderer.conf", rtempl)	1✔
394	if err != nil {	1✔
395	return err	×
396	}	×
397	return nil	1✔
398	}
399
400	func (agent *HostAgent) removeAllFiles(dir string) error {	1✔
401	d, err := os.Open(dir)	1✔
402	if err != nil {	1✔
403	return err	×
404	}	×
405	defer d.Close()	1✔
406	names, err := d.Readdirnames(-1)	1✔
407	if err != nil {	1✔
408	return err	×
409	}	×
410	for _, name := range names {	1✔
411	err = os.RemoveAll(filepath.Join(dir, name))	×
412	if err != nil {	×
413	agent.log.Error("Not able to clear the Fault Files ", err)	×
414	return err	×
415	}	×
416	}
417	return nil	1✔
418	}

noironetworks / aci-containers / 5682

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