5213

Committed 23 Jul 2021 04:35AM UTC coverage: 58.467% (-0.009%) from 58.476%

Build # 5213

Build Type

push

travis-ci-com

Committed by Apoorva

Commit Message

<a href="https://github.com/noironetworks/aci-containers/commit/<a class=hub.com/noironetworks/aci-containers/commit/08e0031a13c1ed3bffd88221c8541fad8f299d57">08e0031a1<a href="https://github.com/noironetworks/aci-containers/commit/08e0031a13c1ed3bffd88221c8541fad8f299d57">&quot;&gt;Check opflex device state to compute fabric path Dn

If theres no device with connected state, then we reutn the first item in the device list

(cherry picked from commit </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/05c5471fb2ddf09242562be30681d9a1261093c5">05c5471fb</a>">05c5471fb</a><a href="https://github.com/noironetworks/aci-containers/commit/08e0031a13c1ed3bffd88221c8541fad8f299d57">)

Run Details

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

11256 of 19252 relevant lines covered (58.47%)

0.65 hits per line

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

10.22

/pkg/controller/qos.go

// Copyright 2020 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 (
        "github.com/sirupsen/logrus"
        "strconv"

        qospolicy "github.com/noironetworks/aci-containers/pkg/qospolicy/apis/aci.qos/v1"
        qosclientset "github.com/noironetworks/aci-containers/pkg/qospolicy/clientset/versioned"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/client-go/tools/cache"

        "github.com/noironetworks/aci-containers/pkg/apicapi"
)

func QosPolicyLogger(log *logrus.Logger, qos *qospolicy.QosPolicy) *logrus.Entry {
        return log.WithFields(logrus.Fields{
                "namespace": qos.ObjectMeta.Namespace,
                "name":      qos.ObjectMeta.Name,
                "spec":      qos.Spec,
        })
}

func qosInit(cont *AciController, stopCh <-chan struct{}) {
        cont.log.Debug("Initializing qos client")
        restconfig := cont.env.RESTConfig()
        qosClient, err := qosclientset.NewForConfig(restconfig)
        if err != nil {
                cont.log.Errorf("Failed to intialize qos client")
                return
        }
        cont.initQosInformerFromClient(qosClient)
        go cont.qosInformer.Run(stopCh)
        go cont.processQueue(cont.qosQueue, cont.qosIndexer,
                func(obj interface{}) bool {
                        return cont.handleQosPolUpdate(obj)
                }, stopCh)
        cache.WaitForCacheSync(stopCh, cont.qosInformer.HasSynced)
}

func (cont *AciController) initQosInformerFromClient(
        qosClient *qosclientset.Clientset) {
        cont.initQosInformerBase(
                cache.NewListWatchFromClient(
                        qosClient.AciV1().RESTClient(), "qospolicies",
                        metav1.NamespaceAll, fields.Everything()))
}

func (cont *AciController) initQosInformerBase(listWatch *cache.ListWatch) {
        cont.qosIndexer, cont.qosInformer = cache.NewIndexerInformer(
                listWatch,
                &qospolicy.QosPolicy{}, 0,
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                cont.qosPolicyUpdated(obj)
                        },
                        UpdateFunc: func(_, obj interface{}) {
                                cont.qosPolicyUpdated(obj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                cont.qosPolicyDeleted(obj)
                        },
                },
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )
        cont.log.Debug("Initializing Qos Policy Informers")

}

func (cont *AciController) qosPolicyUpdated(obj interface{}) {
        qosPolicy := obj.(*qospolicy.QosPolicy)
        key, err := cache.MetaNamespaceKeyFunc(qosPolicy)
        if err != nil {
                QosPolicyLogger(cont.log, qosPolicy).
                        Error("Could not create key:" + err.Error())
                return
        }
        cont.queueQosUpdateByKey(key)

}

func (cont *AciController) queueQosUpdateByKey(key string) {
        cont.qosQueue.Add(key)
}

func (cont *AciController) qosPolicyDeleted(qosobj interface{}) {
        qr, isQr := qosobj.(*qospolicy.QosPolicy)
        if !isQr {
                deletedState, ok := qosobj.(cache.DeletedFinalStateUnknown)
                if !ok {
                        QosPolicyLogger(cont.log, qr).
                                Error("Received unexpected object: ", qosobj)
                        return
                }
                qr, ok = deletedState.Obj.(*qospolicy.QosPolicy)
                if !ok {
                        QosPolicyLogger(cont.log, qr).
                                Error("DeletedFinalStateUnknown contained non-qos object: ", deletedState.Obj)
                        return
                }
        }
        qrkey, err := cache.MetaNamespaceKeyFunc(qr)
        if err != nil {
                QosPolicyLogger(cont.log, qr).
                        Error("Could not create qos policy key: ", err)
                return
        }

        cont.apicConn.ClearApicObjects(cont.aciNameForKey("qp", qrkey))

}

func (cont *AciController) handleQosPolUpdate(obj interface{}) bool {

        // Ability to configure Qos Policy is available only in APIC versions >= 5.1(x).
        if apicapi.ApicVersion < "5.1" {
                cont.log.Error("Cannot create Qos Policy in APIC versions < 5.1(x). Actual APIC version: ",
                        apicapi.ApicVersion)
                return false
        }

        qp, ok := obj.(*qospolicy.QosPolicy)
        if !ok {
                cont.log.Error("handleQosPolUpdate: Bad object type")
                return false
        }
        logger := QosPolicyLogger(cont.log, qp)
        key, err := cache.MetaNamespaceKeyFunc(qp)
        if err != nil {
                logger.Error("Could not create qos policy key: ", err)
                return false
        }
        labelKey := cont.aciNameForKey("qp", key)
        cont.log.Debug("create qospolicy")
        qr := apicapi.NewQosRequirement(cont.config.AciPolicyTenant, labelKey)
        qrDn := qr.GetDn()
        apicSlice := apicapi.ApicSlice{qr}

        // Pushing EpDscpMarking Mo if dscp_mark not equal to 0
        if qp.Spec.Mark != 0 {
                DscpMarking := apicapi.NewQosEpDscpMarking(qrDn, "EpDscpMarking")
                DscpMarking.SetAttr("mark", strconv.Itoa(qp.Spec.Mark))
                qr.AddChild(DscpMarking)
        }

        // Generate ingress policies
        if qp.Spec.Ingress.PolicingRate != 0 && qp.Spec.Ingress.PolicingBurst != 0 {

                DppPolIngressName := labelKey + "_ingress"
                DppPolIngress := apicapi.NewQosDppPol(cont.config.AciPolicyTenant, DppPolIngressName)
                DppPolIngress.SetAttr("rate", strconv.Itoa(qp.Spec.Ingress.PolicingRate))
                DppPolIngress.SetAttr("rateUnit", "kilo")
                DppPolIngress.SetAttr("burst", strconv.Itoa(qp.Spec.Ingress.PolicingBurst))
                DppPolIngress.SetAttr("burstUnit", "kilo")

                RsIngressDppPol := apicapi.NewRsIngressDppPol(qrDn, DppPolIngressName)
                qr.AddChild(RsIngressDppPol)
                apicSlice = append(apicSlice, DppPolIngress)
        }

        // Generate egress policies
        if qp.Spec.Egress.PolicingRate != 0 && qp.Spec.Egress.PolicingBurst != 0 {

                DppPolEgressName := labelKey + "_egress"
                DppPolEgress := apicapi.NewQosDppPol(cont.config.AciPolicyTenant, DppPolEgressName)
                DppPolEgress.SetAttr("rate", strconv.Itoa(qp.Spec.Egress.PolicingRate))
                DppPolEgress.SetAttr("rateUnit", "kilo")
                DppPolEgress.SetAttr("burst", strconv.Itoa(qp.Spec.Egress.PolicingBurst))
                DppPolEgress.SetAttr("burstUnit", "kilo")

                RsEgressDppPol := apicapi.NewRsEgressDppPol(qrDn, DppPolEgressName)
                qr.AddChild(RsEgressDppPol)
                apicSlice = append(apicSlice, DppPolEgress)
        }

        cont.apicConn.WriteApicObjects(labelKey, apicSlice)

        return false

}

1	// Copyright 2020 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	"github.com/sirupsen/logrus"
20	"strconv"
21
22	qospolicy "github.com/noironetworks/aci-containers/pkg/qospolicy/apis/aci.qos/v1"
23	qosclientset "github.com/noironetworks/aci-containers/pkg/qospolicy/clientset/versioned"
24	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
25	"k8s.io/apimachinery/pkg/fields"
26	"k8s.io/client-go/tools/cache"
27
28	"github.com/noironetworks/aci-containers/pkg/apicapi"
29	)
30
31	func QosPolicyLogger(log logrus.Logger, qos qospolicy.QosPolicy) *logrus.Entry {	1✔
32	return log.WithFields(logrus.Fields{	1✔
33	"namespace": qos.ObjectMeta.Namespace,	1✔
34	"name": qos.ObjectMeta.Name,	1✔
35	"spec": qos.Spec,	1✔
36	})	1✔
37	}	1✔
38
39	func qosInit(cont *AciController, stopCh <-chan struct{}) {	×
40	cont.log.Debug("Initializing qos client")	×
41	restconfig := cont.env.RESTConfig()	×
42	qosClient, err := qosclientset.NewForConfig(restconfig)	×
43	if err != nil {	×
44	cont.log.Errorf("Failed to intialize qos client")	×
45	return	×
46	}	×
47	cont.initQosInformerFromClient(qosClient)	×
48	go cont.qosInformer.Run(stopCh)	×
49	go cont.processQueue(cont.qosQueue, cont.qosIndexer,	×
50	func(obj interface{}) bool {	×
51	return cont.handleQosPolUpdate(obj)	×
52	}, stopCh)	×
53	cache.WaitForCacheSync(stopCh, cont.qosInformer.HasSynced)	×
54	}
55
56	func (cont *AciController) initQosInformerFromClient(
57	qosClient *qosclientset.Clientset) {	×
58	cont.initQosInformerBase(	×
59	cache.NewListWatchFromClient(	×
60	qosClient.AciV1().RESTClient(), "qospolicies",	×
61	metav1.NamespaceAll, fields.Everything()))	×
62	}	×
63
64	func (cont AciController) initQosInformerBase(listWatch cache.ListWatch) {	1✔
65	cont.qosIndexer, cont.qosInformer = cache.NewIndexerInformer(	1✔
66	listWatch,	1✔
67	&qospolicy.QosPolicy{}, 0,	1✔
68	cache.ResourceEventHandlerFuncs{	1✔
69	AddFunc: func(obj interface{}) {	1✔
70	cont.qosPolicyUpdated(obj)	×
71	},	×
72	UpdateFunc: func(_, obj interface{}) {	×
73	cont.qosPolicyUpdated(obj)	×
74	},	×
75	DeleteFunc: func(obj interface{}) {	×
76	cont.qosPolicyDeleted(obj)	×
77	},	×
78	},
79	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
80	)
81	cont.log.Debug("Initializing Qos Policy Informers")	1✔
82
83	}
84
85	func (cont *AciController) qosPolicyUpdated(obj interface{}) {	×
86	qosPolicy := obj.(*qospolicy.QosPolicy)	×
87	key, err := cache.MetaNamespaceKeyFunc(qosPolicy)	×
88	if err != nil {	×
89	QosPolicyLogger(cont.log, qosPolicy).	×
90	Error("Could not create key:" + err.Error())	×
91	return	×
92	}	×
93	cont.queueQosUpdateByKey(key)	×
94
95	}
96
97	func (cont *AciController) queueQosUpdateByKey(key string) {	×
98	cont.qosQueue.Add(key)	×
99	}	×
100
101	func (cont *AciController) qosPolicyDeleted(qosobj interface{}) {	×
102	qr, isQr := qosobj.(*qospolicy.QosPolicy)	×
103	if !isQr {	×
104	deletedState, ok := qosobj.(cache.DeletedFinalStateUnknown)	×
105	if !ok {	×
106	QosPolicyLogger(cont.log, qr).	×
107	Error("Received unexpected object: ", qosobj)	×
108	return	×
109	}	×
110	qr, ok = deletedState.Obj.(*qospolicy.QosPolicy)	×
111	if !ok {	×
112	QosPolicyLogger(cont.log, qr).	×
113	Error("DeletedFinalStateUnknown contained non-qos object: ", deletedState.Obj)	×
114	return	×
115	}	×
116	}
117	qrkey, err := cache.MetaNamespaceKeyFunc(qr)	×
118	if err != nil {	×
119	QosPolicyLogger(cont.log, qr).	×
120	Error("Could not create qos policy key: ", err)	×
121	return	×
122	}	×
123
124	cont.apicConn.ClearApicObjects(cont.aciNameForKey("qp", qrkey))	×
125
126	}
127
128	func (cont *AciController) handleQosPolUpdate(obj interface{}) bool {	×
129		×
130	// Ability to configure Qos Policy is available only in APIC versions >= 5.1(x).	×
131	if apicapi.ApicVersion < "5.1" {	×
132	cont.log.Error("Cannot create Qos Policy in APIC versions < 5.1(x). Actual APIC version: ",	×
133	apicapi.ApicVersion)	×
134	return false	×
135	}	×
136
137	qp, ok := obj.(*qospolicy.QosPolicy)	×
138	if !ok {	×
139	cont.log.Error("handleQosPolUpdate: Bad object type")	×
140	return false	×
141	}	×
142	logger := QosPolicyLogger(cont.log, qp)	×
143	key, err := cache.MetaNamespaceKeyFunc(qp)	×
144	if err != nil {	×
145	logger.Error("Could not create qos policy key: ", err)	×
146	return false	×
147	}	×
148	labelKey := cont.aciNameForKey("qp", key)	×
149	cont.log.Debug("create qospolicy")	×
150	qr := apicapi.NewQosRequirement(cont.config.AciPolicyTenant, labelKey)	×
151	qrDn := qr.GetDn()	×
152	apicSlice := apicapi.ApicSlice{qr}	×
153		×
154	// Pushing EpDscpMarking Mo if dscp_mark not equal to 0	×
155	if qp.Spec.Mark != 0 {	×
156	DscpMarking := apicapi.NewQosEpDscpMarking(qrDn, "EpDscpMarking")	×
157	DscpMarking.SetAttr("mark", strconv.Itoa(qp.Spec.Mark))	×
158	qr.AddChild(DscpMarking)	×
159	}	×
160
161	// Generate ingress policies
162	if qp.Spec.Ingress.PolicingRate != 0 && qp.Spec.Ingress.PolicingBurst != 0 {	×
163		×
164	DppPolIngressName := labelKey + "_ingress"	×
165	DppPolIngress := apicapi.NewQosDppPol(cont.config.AciPolicyTenant, DppPolIngressName)	×
166	DppPolIngress.SetAttr("rate", strconv.Itoa(qp.Spec.Ingress.PolicingRate))	×
167	DppPolIngress.SetAttr("rateUnit", "kilo")	×
168	DppPolIngress.SetAttr("burst", strconv.Itoa(qp.Spec.Ingress.PolicingBurst))	×
169	DppPolIngress.SetAttr("burstUnit", "kilo")	×
170		×
171	RsIngressDppPol := apicapi.NewRsIngressDppPol(qrDn, DppPolIngressName)	×
172	qr.AddChild(RsIngressDppPol)	×
173	apicSlice = append(apicSlice, DppPolIngress)	×
174	}	×
175
176	// Generate egress policies
177	if qp.Spec.Egress.PolicingRate != 0 && qp.Spec.Egress.PolicingBurst != 0 {	×
178		×
179	DppPolEgressName := labelKey + "_egress"	×
180	DppPolEgress := apicapi.NewQosDppPol(cont.config.AciPolicyTenant, DppPolEgressName)	×
181	DppPolEgress.SetAttr("rate", strconv.Itoa(qp.Spec.Egress.PolicingRate))	×
182	DppPolEgress.SetAttr("rateUnit", "kilo")	×
183	DppPolEgress.SetAttr("burst", strconv.Itoa(qp.Spec.Egress.PolicingBurst))	×
184	DppPolEgress.SetAttr("burstUnit", "kilo")	×
185		×
186	RsEgressDppPol := apicapi.NewRsEgressDppPol(qrDn, DppPolEgressName)	×
187	qr.AddChild(RsEgressDppPol)	×
188	apicSlice = append(apicSlice, DppPolEgress)	×
189	}	×
190
191	cont.apicConn.WriteApicObjects(labelKey, apicSlice)	×
192		×
193	return false	×
194
195	}

noironetworks / aci-containers / 5213

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