5002

Committed 08 Jun 2021 01:57AM UTC coverage: 58.402%. First build

Build # 5002

Build Type

Pull #821

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/81769f6af5b56d0cf7738885634c051d852d3ea7">81769f6af<a href="https://github.com/noironetworks/aci-containers/commit/81769f6af5b56d0cf7738885634c051d852d3ea7">">Merge </a><a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/39e3aba1875892948dc45442bc3c9f8d3a76eef6">39e3aba18</a>">39e3aba18</a><a href="https://github.com/noironetworks/aci-containers/commit/81769f6af5b56d0cf7738885634c051d852d3ea7"> into 5aa76b6ce">5aa76b6ce</a>

Pull Request Pull Request #821: [kwai]Add multiple srcMembers to a single srcGrp

Run Details

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

11226 of 19222 relevant lines covered (58.4%)

0.65 hits per line

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

38.61

/pkg/controller/erspan.go

// Copyright 2021 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 controller

import (
        "fmt"
        "github.com/sirupsen/logrus"
        "regexp"
        "strconv"
        "strings"

        "github.com/noironetworks/aci-containers/pkg/apicapi"
        erspanpolicy "github.com/noironetworks/aci-containers/pkg/erspanpolicy/apis/aci.erspan/v1alpha"
        erspanclientset "github.com/noironetworks/aci-containers/pkg/erspanpolicy/clientset/versioned"
        podIfpolicy "github.com/noironetworks/aci-containers/pkg/gbpcrd/apis/acipolicy/v1"
        "github.com/noironetworks/aci-containers/pkg/index"
        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/client-go/tools/cache"
)

const (
        erspanCRDName = "erspanpolicies.aci.erspan"
)

func ErspanPolicyLogger(log *logrus.Logger, erspan *erspanpolicy.ErspanPolicy) *logrus.Entry {
        return log.WithFields(logrus.Fields{
                "namespace": erspan.ObjectMeta.Namespace,
                "name":      erspan.ObjectMeta.Name,
                "spec":      erspan.Spec,
        })
}

func erspanInit(cont *AciController, stopCh <-chan struct{}) {
        cont.log.Debug("Initializing erspan client")
        restconfig := cont.env.RESTConfig()
        erspanClient, err := erspanclientset.NewForConfig(restconfig)
        if err != nil {
                cont.log.Errorf("Failed to intialize erspan client")
                return
        }
        cont.initErspanInformerFromClient(erspanClient)
        go cont.erspanInformer.Run(stopCh)
        go cont.processQueue(cont.erspanQueue, cont.erspanIndexer,
                func(obj interface{}) bool {
                        return cont.handleErspanUpdate(obj.(*erspanpolicy.ErspanPolicy))
                }, stopCh)
        cache.WaitForCacheSync(stopCh, cont.erspanInformer.HasSynced)
        cont.erspanSyncOpflexDev()
}

func (cont *AciController) initErspanInformerFromClient(
        erspanClient *erspanclientset.Clientset) {
        cont.initErspanInformerBase(
                cache.NewListWatchFromClient(
                        erspanClient.AciV1alpha().RESTClient(), "erspanpolicies",
                        metav1.NamespaceAll, fields.Everything()))
}

func (cont *AciController) initErspanInformerBase(listWatch *cache.ListWatch) {
        cont.erspanIndexer, cont.erspanInformer = cache.NewIndexerInformer(
                listWatch, &erspanpolicy.ErspanPolicy{}, 0,
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                cont.erspanPolicyUpdated(obj)
                        },
                        UpdateFunc: func(_, obj interface{}) {
                                cont.erspanPolicyUpdated(obj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                cont.erspanPolicyDeleted(obj)
                        },
                },
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )
        cont.log.Debug("Initializing erspan Policy Informers")
}

func isValidEPG(podif *podIfpolicy.PodIF) bool {
        pattern := regexp.MustCompile("\\|")
        idx := pattern.FindAllStringIndex(podif.Status.EPG, -1)
        if len(idx) != 1 || idx[0][0] == 0 || idx[0][0] == len(podif.Status.EPG)-1 {
                return false
        }
        return true
}

func (cont *AciController) queueErspanUpdateByKey(key string) {
        cont.erspanQueue.Add(key)
}

func (cont *AciController) erspanPolicyUpdated(obj interface{}) {
        erspanPolicy, ok := obj.(*erspanpolicy.ErspanPolicy)
        if !ok {
                cont.log.Error("erspanPolicyUpdated: Bad object type")
                return
        }
        key, err := cache.MetaNamespaceKeyFunc(erspanPolicy)
        if err != nil {
                ErspanPolicyLogger(cont.log, erspanPolicy).
                        Error("Could not create key:" + err.Error())
                return
        }
        cont.queueErspanUpdateByKey(key)
        cont.erspanPolPods.UpdateSelectorObj(obj)
        cont.log.Infof("erspan policy updated: %s", erspanPolicy.ObjectMeta.Name)
}

func (cont *AciController) erspanPolicyDeleted(obj interface{}) {
        span, isSpan := obj.(*erspanpolicy.ErspanPolicy)
        if !isSpan {
                deletedState, ok := obj.(cache.DeletedFinalStateUnknown)
                if !ok {
                        ErspanPolicyLogger(cont.log, span).
                                Error("Received unexpected object: ", obj)
                        return
                }
                span, ok = deletedState.Obj.(*erspanpolicy.ErspanPolicy)
                if !ok {
                        ErspanPolicyLogger(cont.log, span).
                                Error("DeletedFinalStateUnknown contained non-erspan object: ", deletedState.Obj)
                        return
                }
        }
        spankey, err := cache.MetaNamespaceKeyFunc(span)
        if err != nil {
                ErspanPolicyLogger(cont.log, span).
                        Error("Could not create erspan key: ", err)
                return
        }
        cont.apicConn.ClearApicObjects(cont.aciNameForKey("span", spankey))
        cont.erspanPolPods.DeleteSelectorObj(obj)

}

func (cont *AciController) erspanSyncOpflexDev() {
        if cont.erspanIndexer == nil {
                return
        }
        cache.ListAll(cont.erspanIndexer, labels.Everything(),
                func(spanObj interface{}) {
                        cont.queueErspanUpdate(spanObj.(*erspanpolicy.ErspanPolicy))
                })
}

func (cont *AciController) queueErspanUpdate(span *erspanpolicy.ErspanPolicy) {
        key, err := cache.MetaNamespaceKeyFunc(span)
        if err != nil {
                ErspanPolicyLogger(cont.log, span).
                        Error("Could not create span key:" + err.Error())
                return
        }
        cont.erspanQueue.Add(key)
}

func (cont *AciController) initErspanPolPodIndex() {
        cont.erspanPolPods = index.NewPodSelectorIndex(cont.log,
                cont.podIndexer, cont.namespaceIndexer, cont.erspanIndexer,
                cache.MetaNamespaceKeyFunc,
                func(obj interface{}) []index.PodSelector {
                        span := obj.(*erspanpolicy.ErspanPolicy)
                        ls := &metav1.LabelSelector{MatchLabels: span.Spec.Selector.Labels}
                        return index.PodSelectorFromNsAndSelector(span.Spec.Selector.Namespace, ls)
                },
        )
        spanupdate := func(spankey string) {
                spanobj, exists, err := cont.erspanIndexer.GetByKey(spankey)
                if exists && err == nil {
                        cont.queueErspanUpdate(spanobj.(*erspanpolicy.ErspanPolicy))
                }
        }
        spanhash := func(pod *v1.Pod) string {
                return pod.Status.PodIP
        }

        // Callback when pods selected by erspan object change
        cont.erspanPolPods.SetObjUpdateCallback(spanupdate)
        cont.erspanPolPods.SetPodHashFunc(spanhash)
}

func (cont *AciController) getFabricPaths() []string {
        var paths []string
        cont.indexMutex.Lock()
        for node := range cont.nodeOpflexDevice {
                fabricPath, ok := cont.fabricPathForNode(node)
                if !ok {
                        continue
                }
                paths = append(paths, fabricPath)
        }
        cont.indexMutex.Unlock()
        return paths
}

func (cont *AciController) getVpcs() []string {
        var vpcs []string
        vpcPaths := cont.getFabricPaths()
        for _, path := range vpcPaths {
                // VPC identified
                if strings.Contains(path, "/protpaths-") {
                        vpc := strings.Split(path, "/pathep-[")
                        vpcUnTrimmed := vpc[len(vpc)-1]
                        vpcTrimmed := strings.TrimSuffix(vpcUnTrimmed, "]")
                        vpcs = append(vpcs, vpcTrimmed)
                }
        }
        return vpcs
}

func (cont *AciController) getAccLeafPorts() []string {
        var accPorts []string
        portPaths := cont.getFabricPaths()
        for _, path := range portPaths {
                // Leaf Access Port identified
                if strings.Contains(path, "/paths-") {
                        accPort := strings.Split(path, "/pathep-[")
                        accPortUnTrimmed := accPort[len(accPort)-1]
                        accPortTrimmed := strings.TrimSuffix(accPortUnTrimmed, "]")
                        accPorts = append(accPorts, accPortTrimmed)
                }
        }
        return accPorts
}

func transformMac(mac string) string {
        m := strings.ReplaceAll(mac, ":", "-")
        return m
}

func (cont *AciController) buildErspanObjs(span *erspanpolicy.ErspanPolicy) apicapi.ApicSlice {

        spankey, _ := cache.MetaNamespaceKeyFunc(span)
        labelKey := cont.aciNameForKey("span", spankey)
        cont.log.Infof("Creating erspan policy: %s", span.ObjectMeta.Name)

        // Source policies
        srcGrp := apicapi.NewSpanVSrcGrp(labelKey)
        apicSlice := apicapi.ApicSlice{srcGrp}
        srcGrp.SetAttr("adminSt", span.Spec.Source.AdminState)

        // Build fvCEp for matching pods
        cont.indexMutex.Lock()
        podKeys := cont.erspanPolPods.GetPodForObj(spankey)
        for _, podkey := range podKeys {
                if podkey, ok := cont.podIftoEp[podkey]; !ok {
                        cont.log.Warning("Could not find podif data for ", podkey)
                        continue
                }
                macRaw := cont.podIftoEp[podkey].MacAddr
                mac := strings.ToUpper(macRaw)
                epg := cont.podIftoEp[podkey].EPG
                appProfile := cont.podIftoEp[podkey].AppProfile
                srcName := labelKey + "_Src_" + transformMac(mac)
                fvCEpDn := fmt.Sprintf("uni/tn-%s/ap-%s/epg-%s/cep-%s",
                        cont.config.AciPolicyTenant, appProfile, epg, mac)
                src := apicapi.NewSpanVSrc(srcGrp.GetDn(), srcName)
                srcGrp.AddChild(src)
                src.SetAttr("dir", span.Spec.Source.Direction)
                srcCEp := apicapi.NewSpanRsSrcToVPort(src.GetDn(), fvCEpDn)
                src.AddChild(srcCEp)
        }
        cont.indexMutex.Unlock()

        // Destination policies
        destGrp := apicapi.NewSpanVDestGrp(labelKey)
        destName := labelKey + "_Dest"
        dest := apicapi.NewSpanVDest(destGrp.GetDn(), destName)
        destGrp.AddChild(dest)
        destSummary := apicapi.NewSpanVEpgSummary(dest.GetDn())
        dest.AddChild(destSummary)
        destSummary.SetAttr("dstIp", span.Spec.Dest.DestIP)
        destSummary.SetAttr("flowId", strconv.Itoa(span.Spec.Dest.FlowID))
        apicSlice = append(apicSlice, destGrp)

        // Erspan policy binding to Virtual Port Channels.
        vpcs := cont.getVpcs()
        if len(vpcs) == 0 {
                cont.log.Info("No Virtual Port Channels found for erspan binding.")
        }
        for _, bundleName := range vpcs {

                accBndlGrp := apicapi.NewInfraAccBndlGrp(bundleName)
                infraRsSpanVSrcGrp := apicapi.NewInfraRsSpanVSrcGrp(bundleName, labelKey)
                accBndlGrp.AddChild(infraRsSpanVSrcGrp)
                apicSlice = append(apicSlice, infraRsSpanVSrcGrp)
                infraRsSpanVDstGrp := apicapi.NewInfraRsSpanVDestGrp(bundleName, labelKey)
                accBndlGrp.AddChild(infraRsSpanVDstGrp)
                apicSlice = append(apicSlice, infraRsSpanVDstGrp)
        }

        // Erspan policy binding to Leaf Access Ports.
        accPorts := cont.getAccLeafPorts()
        if len(accPorts) == 0 {
                cont.log.Info("No Leaf Access Ports found for erspan binding.")
        }
        for _, portName := range accPorts {

                accPortGrp := apicapi.NewInfraAccPortGrp(portName)
                infraRsSpanVSrcGrpAP := apicapi.NewInfraRsSpanVSrcGrpAP(portName, labelKey)
                accPortGrp.AddChild(infraRsSpanVSrcGrpAP)
                apicSlice = append(apicSlice, infraRsSpanVSrcGrpAP)
                infraRsSpanVDstGrpAP := apicapi.NewInfraRsSpanVDestGrpAP(portName, labelKey)
                accPortGrp.AddChild(infraRsSpanVDstGrpAP)
                apicSlice = append(apicSlice, infraRsSpanVDstGrpAP)
        }

        lbl := apicapi.NewSpanSpanLbl(srcGrp.GetDn(), labelKey)
        srcGrp.AddChild(lbl)

        cont.log.Info("Erspan APIC slice: ", apicSlice)
        cont.log.Debug("erspan object: ", span)

        return apicSlice
}

func (cont *AciController) handleErspanUpdate(obj interface{}) bool {
        span, ok := obj.(*erspanpolicy.ErspanPolicy)
        if !ok {
                cont.log.Error("handleErspanUpdate: Bad object type")
                return false
        }
        erspanLogger := ErspanPolicyLogger(cont.log, span)
        spankey, err := cache.MetaNamespaceKeyFunc(span)
        if err != nil {
                erspanLogger.Error("Could not create erspan policy key: ", err)
                return false
        }
        labelKey := cont.aciNameForKey("span", spankey)
        cont.apicConn.WriteApicObjects(labelKey, cont.buildErspanObjs(span))

        return false
}

1	// Copyright 2021 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
12	// implied.
13	// See the License for the specific language governing permissions and
14	// limitations under the License.
15
16	package controller
17
18	import (
19	"fmt"
20	"github.com/sirupsen/logrus"
21	"regexp"
22	"strconv"
23	"strings"
24
25	"github.com/noironetworks/aci-containers/pkg/apicapi"
26	erspanpolicy "github.com/noironetworks/aci-containers/pkg/erspanpolicy/apis/aci.erspan/v1alpha"
27	erspanclientset "github.com/noironetworks/aci-containers/pkg/erspanpolicy/clientset/versioned"
28	podIfpolicy "github.com/noironetworks/aci-containers/pkg/gbpcrd/apis/acipolicy/v1"
29	"github.com/noironetworks/aci-containers/pkg/index"
30	v1 "k8s.io/api/core/v1"
31	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
32	"k8s.io/apimachinery/pkg/fields"
33	"k8s.io/apimachinery/pkg/labels"
34	"k8s.io/client-go/tools/cache"
35	)
36
37	const (
38	erspanCRDName = "erspanpolicies.aci.erspan"
39	)
40
41	func ErspanPolicyLogger(log logrus.Logger, erspan erspanpolicy.ErspanPolicy) *logrus.Entry {	1✔
42	return log.WithFields(logrus.Fields{	1✔
43	"namespace": erspan.ObjectMeta.Namespace,	1✔
44	"name": erspan.ObjectMeta.Name,	1✔
45	"spec": erspan.Spec,	1✔
46	})	1✔
47	}	1✔
48
49	func erspanInit(cont *AciController, stopCh <-chan struct{}) {	×
50	cont.log.Debug("Initializing erspan client")	×
51	restconfig := cont.env.RESTConfig()	×
52	erspanClient, err := erspanclientset.NewForConfig(restconfig)	×
53	if err != nil {	×
54	cont.log.Errorf("Failed to intialize erspan client")	×
55	return	×
56	}	×
57	cont.initErspanInformerFromClient(erspanClient)	×
58	go cont.erspanInformer.Run(stopCh)	×
59	go cont.processQueue(cont.erspanQueue, cont.erspanIndexer,	×
60	func(obj interface{}) bool {	×
61	return cont.handleErspanUpdate(obj.(*erspanpolicy.ErspanPolicy))	×
62	}, stopCh)	×
63	cache.WaitForCacheSync(stopCh, cont.erspanInformer.HasSynced)	×
64	cont.erspanSyncOpflexDev()	×
65	}
66
67	func (cont *AciController) initErspanInformerFromClient(
68	erspanClient *erspanclientset.Clientset) {	×
69	cont.initErspanInformerBase(	×
70	cache.NewListWatchFromClient(	×
71	erspanClient.AciV1alpha().RESTClient(), "erspanpolicies",	×
72	metav1.NamespaceAll, fields.Everything()))	×
73	}	×
74
75	func (cont AciController) initErspanInformerBase(listWatch cache.ListWatch) {	1✔
76	cont.erspanIndexer, cont.erspanInformer = cache.NewIndexerInformer(	1✔
77	listWatch, &erspanpolicy.ErspanPolicy{}, 0,	1✔
78	cache.ResourceEventHandlerFuncs{	1✔
79	AddFunc: func(obj interface{}) {	1✔
80	cont.erspanPolicyUpdated(obj)	×
81	},	×
82	UpdateFunc: func(_, obj interface{}) {	×
83	cont.erspanPolicyUpdated(obj)	×
84	},	×
85	DeleteFunc: func(obj interface{}) {	×
86	cont.erspanPolicyDeleted(obj)	×
87	},	×
88	},
89	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
90	)
91	cont.log.Debug("Initializing erspan Policy Informers")	1✔
92	}
93
94	func isValidEPG(podif *podIfpolicy.PodIF) bool {	×
95	pattern := regexp.MustCompile("\\\|")	×
96	idx := pattern.FindAllStringIndex(podif.Status.EPG, -1)	×
97	if len(idx) != 1 \|\| idx[0][0] == 0 \|\| idx[0][0] == len(podif.Status.EPG)-1 {	×
98	return false	×
99	}	×
100	return true	×
101	}
102
103	func (cont *AciController) queueErspanUpdateByKey(key string) {	×
104	cont.erspanQueue.Add(key)	×
105	}	×
106
107	func (cont *AciController) erspanPolicyUpdated(obj interface{}) {	×
108	erspanPolicy, ok := obj.(*erspanpolicy.ErspanPolicy)	×
109	if !ok {	×
110	cont.log.Error("erspanPolicyUpdated: Bad object type")	×
111	return	×
112	}	×
113	key, err := cache.MetaNamespaceKeyFunc(erspanPolicy)	×
114	if err != nil {	×
115	ErspanPolicyLogger(cont.log, erspanPolicy).	×
116	Error("Could not create key:" + err.Error())	×
117	return	×
118	}	×
119	cont.queueErspanUpdateByKey(key)	×
120	cont.erspanPolPods.UpdateSelectorObj(obj)	×
121	cont.log.Infof("erspan policy updated: %s", erspanPolicy.ObjectMeta.Name)	×
122	}
123
124	func (cont *AciController) erspanPolicyDeleted(obj interface{}) {	×
125	span, isSpan := obj.(*erspanpolicy.ErspanPolicy)	×
126	if !isSpan {	×
127	deletedState, ok := obj.(cache.DeletedFinalStateUnknown)	×
128	if !ok {	×
129	ErspanPolicyLogger(cont.log, span).	×
130	Error("Received unexpected object: ", obj)	×
131	return	×
132	}	×
133	span, ok = deletedState.Obj.(*erspanpolicy.ErspanPolicy)	×
134	if !ok {	×
135	ErspanPolicyLogger(cont.log, span).	×
136	Error("DeletedFinalStateUnknown contained non-erspan object: ", deletedState.Obj)	×
137	return	×
138	}	×
139	}
140	spankey, err := cache.MetaNamespaceKeyFunc(span)	×
141	if err != nil {	×
142	ErspanPolicyLogger(cont.log, span).	×
143	Error("Could not create erspan key: ", err)	×
144	return	×
145	}	×
146	cont.apicConn.ClearApicObjects(cont.aciNameForKey("span", spankey))	×
147	cont.erspanPolPods.DeleteSelectorObj(obj)	×
148
149	}
150
151	func (cont *AciController) erspanSyncOpflexDev() {	1✔
152	if cont.erspanIndexer == nil {	1✔
153	return	×
154	}	×
155	cache.ListAll(cont.erspanIndexer, labels.Everything(),	1✔
156	func(spanObj interface{}) {	1✔
157	cont.queueErspanUpdate(spanObj.(*erspanpolicy.ErspanPolicy))	×
158	})	×
159	}
160
161	func (cont AciController) queueErspanUpdate(span erspanpolicy.ErspanPolicy) {	×
162	key, err := cache.MetaNamespaceKeyFunc(span)	×
163	if err != nil {	×
164	ErspanPolicyLogger(cont.log, span).	×
165	Error("Could not create span key:" + err.Error())	×
166	return	×
167	}	×
168	cont.erspanQueue.Add(key)	×
169	}
170
171	func (cont *AciController) initErspanPolPodIndex() {	1✔
172	cont.erspanPolPods = index.NewPodSelectorIndex(cont.log,	1✔
173	cont.podIndexer, cont.namespaceIndexer, cont.erspanIndexer,	1✔
174	cache.MetaNamespaceKeyFunc,	1✔
175	func(obj interface{}) []index.PodSelector {	1✔
176	span := obj.(*erspanpolicy.ErspanPolicy)	×
177	ls := &metav1.LabelSelector{MatchLabels: span.Spec.Selector.Labels}	×
178	return index.PodSelectorFromNsAndSelector(span.Spec.Selector.Namespace, ls)	×
179	},	×
180	)
181	spanupdate := func(spankey string) {	1✔
182	spanobj, exists, err := cont.erspanIndexer.GetByKey(spankey)	×
183	if exists && err == nil {	×
184	cont.queueErspanUpdate(spanobj.(*erspanpolicy.ErspanPolicy))	×
185	}	×
186	}
187	spanhash := func(pod *v1.Pod) string {	2✔
188	return pod.Status.PodIP	1✔
189	}	1✔
190
191	// Callback when pods selected by erspan object change
192	cont.erspanPolPods.SetObjUpdateCallback(spanupdate)	1✔
193	cont.erspanPolPods.SetPodHashFunc(spanhash)	1✔
194	}
195
196	func (cont *AciController) getFabricPaths() []string {	1✔
197	var paths []string	1✔
198	cont.indexMutex.Lock()	1✔
199	for node := range cont.nodeOpflexDevice {	1✔
200	fabricPath, ok := cont.fabricPathForNode(node)	×
201	if !ok {	×
202	continue	×
203	}
204	paths = append(paths, fabricPath)	×
205	}
206	cont.indexMutex.Unlock()	1✔
207	return paths	1✔
208	}
209
210	func (cont *AciController) getVpcs() []string {	1✔
211	var vpcs []string	1✔
212	vpcPaths := cont.getFabricPaths()	1✔
213	for _, path := range vpcPaths {	1✔
214	// VPC identified	×
215	if strings.Contains(path, "/protpaths-") {	×
216	vpc := strings.Split(path, "/pathep-[")	×
217	vpcUnTrimmed := vpc[len(vpc)-1]	×
218	vpcTrimmed := strings.TrimSuffix(vpcUnTrimmed, "]")	×
219	vpcs = append(vpcs, vpcTrimmed)	×
220	}	×
221	}
222	return vpcs	1✔
223	}
224
225	func (cont *AciController) getAccLeafPorts() []string {	1✔
226	var accPorts []string	1✔
227	portPaths := cont.getFabricPaths()	1✔
228	for _, path := range portPaths {	1✔
229	// Leaf Access Port identified	×
230	if strings.Contains(path, "/paths-") {	×
231	accPort := strings.Split(path, "/pathep-[")	×
232	accPortUnTrimmed := accPort[len(accPort)-1]	×
233	accPortTrimmed := strings.TrimSuffix(accPortUnTrimmed, "]")	×
234	accPorts = append(accPorts, accPortTrimmed)	×
235	}	×
236	}
237	return accPorts	1✔
238	}
239
240	func transformMac(mac string) string {	×
241	m := strings.ReplaceAll(mac, ":", "-")	×
242	return m	×
243	}	×
244
245	func (cont AciController) buildErspanObjs(span erspanpolicy.ErspanPolicy) apicapi.ApicSlice {	1✔
246		1✔
247	spankey, _ := cache.MetaNamespaceKeyFunc(span)	1✔
248	labelKey := cont.aciNameForKey("span", spankey)	1✔
249	cont.log.Infof("Creating erspan policy: %s", span.ObjectMeta.Name)	1✔
250		1✔
251	// Source policies	1✔
252	srcGrp := apicapi.NewSpanVSrcGrp(labelKey)	1✔
253	apicSlice := apicapi.ApicSlice{srcGrp}	1✔
254	srcGrp.SetAttr("adminSt", span.Spec.Source.AdminState)	1✔
255		1✔
256	// Build fvCEp for matching pods	1✔
257	cont.indexMutex.Lock()	1✔
258	podKeys := cont.erspanPolPods.GetPodForObj(spankey)	1✔
259	for _, podkey := range podKeys {	1✔
260	if podkey, ok := cont.podIftoEp[podkey]; !ok {	×
261	cont.log.Warning("Could not find podif data for ", podkey)	×
262	continue	×
263	}
264	macRaw := cont.podIftoEp[podkey].MacAddr	×
265	mac := strings.ToUpper(macRaw)	×
266	epg := cont.podIftoEp[podkey].EPG	×
267	appProfile := cont.podIftoEp[podkey].AppProfile	×
268	srcName := labelKey + "_Src_" + transformMac(mac)	×
269	fvCEpDn := fmt.Sprintf("uni/tn-%s/ap-%s/epg-%s/cep-%s",	×
270	cont.config.AciPolicyTenant, appProfile, epg, mac)	×
271	src := apicapi.NewSpanVSrc(srcGrp.GetDn(), srcName)	×
272	srcGrp.AddChild(src)	×
273	src.SetAttr("dir", span.Spec.Source.Direction)	×
274	srcCEp := apicapi.NewSpanRsSrcToVPort(src.GetDn(), fvCEpDn)	×
275	src.AddChild(srcCEp)	×
276	}
277	cont.indexMutex.Unlock()	1✔
278		1✔
279	// Destination policies	1✔
280	destGrp := apicapi.NewSpanVDestGrp(labelKey)	1✔
281	destName := labelKey + "_Dest"	1✔
282	dest := apicapi.NewSpanVDest(destGrp.GetDn(), destName)	1✔
283	destGrp.AddChild(dest)	1✔
284	destSummary := apicapi.NewSpanVEpgSummary(dest.GetDn())	1✔
285	dest.AddChild(destSummary)	1✔
286	destSummary.SetAttr("dstIp", span.Spec.Dest.DestIP)	1✔
287	destSummary.SetAttr("flowId", strconv.Itoa(span.Spec.Dest.FlowID))	1✔
288	apicSlice = append(apicSlice, destGrp)	1✔
289		1✔
290	// Erspan policy binding to Virtual Port Channels.	1✔
291	vpcs := cont.getVpcs()	1✔
292	if len(vpcs) == 0 {	2✔
293	cont.log.Info("No Virtual Port Channels found for erspan binding.")	1✔
294	}	1✔
295	for _, bundleName := range vpcs {	1✔
296		×
297	accBndlGrp := apicapi.NewInfraAccBndlGrp(bundleName)	×
298	infraRsSpanVSrcGrp := apicapi.NewInfraRsSpanVSrcGrp(bundleName, labelKey)	×
299	accBndlGrp.AddChild(infraRsSpanVSrcGrp)	×
300	apicSlice = append(apicSlice, infraRsSpanVSrcGrp)	×
301	infraRsSpanVDstGrp := apicapi.NewInfraRsSpanVDestGrp(bundleName, labelKey)	×
302	accBndlGrp.AddChild(infraRsSpanVDstGrp)	×
303	apicSlice = append(apicSlice, infraRsSpanVDstGrp)	×
304	}	×
305
306	// Erspan policy binding to Leaf Access Ports.
307	accPorts := cont.getAccLeafPorts()	1✔
308	if len(accPorts) == 0 {	2✔
309	cont.log.Info("No Leaf Access Ports found for erspan binding.")	1✔
310	}	1✔
311	for _, portName := range accPorts {	1✔
312		×
313	accPortGrp := apicapi.NewInfraAccPortGrp(portName)	×
314	infraRsSpanVSrcGrpAP := apicapi.NewInfraRsSpanVSrcGrpAP(portName, labelKey)	×
315	accPortGrp.AddChild(infraRsSpanVSrcGrpAP)	×
316	apicSlice = append(apicSlice, infraRsSpanVSrcGrpAP)	×
317	infraRsSpanVDstGrpAP := apicapi.NewInfraRsSpanVDestGrpAP(portName, labelKey)	×
318	accPortGrp.AddChild(infraRsSpanVDstGrpAP)	×
319	apicSlice = append(apicSlice, infraRsSpanVDstGrpAP)	×
320	}	×
321
322	lbl := apicapi.NewSpanSpanLbl(srcGrp.GetDn(), labelKey)	1✔
323	srcGrp.AddChild(lbl)	1✔
324		1✔
325	cont.log.Info("Erspan APIC slice: ", apicSlice)	1✔
326	cont.log.Debug("erspan object: ", span)	1✔
327		1✔
328	return apicSlice	1✔
329	}
330
331	func (cont *AciController) handleErspanUpdate(obj interface{}) bool {	1✔
332	span, ok := obj.(*erspanpolicy.ErspanPolicy)	1✔
333	if !ok {	1✔
334	cont.log.Error("handleErspanUpdate: Bad object type")	×
335	return false	×
336	}	×
337	erspanLogger := ErspanPolicyLogger(cont.log, span)	1✔
338	spankey, err := cache.MetaNamespaceKeyFunc(span)	1✔
339	if err != nil {	1✔
340	erspanLogger.Error("Could not create erspan policy key: ", err)	×
341	return false	×
342	}	×
343	labelKey := cont.aciNameForKey("span", spankey)	1✔
344	cont.apicConn.WriteApicObjects(labelKey, cont.buildErspanObjs(span))	1✔
345		1✔
346	return false	1✔
347	}

noironetworks / aci-containers / 5002

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