9721

Committed 04 Sep 2024 05:15PM UTC coverage: 70.447% (-1.2%) from 71.633%

Build # 9721

Build Type

Pull #1385

travis-pro

Committed by

smshareef

Commit Message

Handle ProactiveConf CR objects updates

When a ProactiveConf is created, the host agent notifies the
OpFlex agent, which then adjusts the frequency of the tunnel
endpoint advertisement timer accordingly.

Example CR:
apiVersion: aci.pc/v1
kind: ProactiveConf
metadata:
  name: proactiveconf
  namespace: aci-containers-system
spec:
  TunnelEpAdvertisementInterval: <seconds>
  VmmEpgDeploymentImmediacy: Immediate/OnDemand

VmmEpgDeploymentImmediacy is to specify the Deploy and Resolution
Immediacy. Immediate/Ondemand correspond to immediate/lazy.

(cherry picked from commit de2ac15ec)
(cherry picked from commit 513c5dc35)

Pull Request Pull Request #1385: Handle ProactiveConf CR objects updates

Run Details

62 of 340 new or added lines in 7 files covered. (18.24%)

10 existing lines in 3 files now uncovered.

11268 of 15995 relevant lines covered (70.45%)

0.8 hits per line

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

7.09

/pkg/controller/proactiveconf.go

// Copyright 2019 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 WARRATIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Handlers for ProactiveConf CR updates.

package controller

import (
        "context"
        "fmt"
        "strings"

        "github.com/noironetworks/aci-containers/pkg/apicapi"
        pcv1 "github.com/noironetworks/aci-containers/pkg/proactiveconf/apis/aci.pc/v1"
        proactiveconfclientset "github.com/noironetworks/aci-containers/pkg/proactiveconf/clientset/versioned"

        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/watch"
        "k8s.io/client-go/tools/cache"
        "k8s.io/kubernetes/pkg/controller"
)

const (
        proactiveConfCRDName = "proactiveconfs.aci.pc"
)

func proactiveConfInit(cont *AciController, stopCh <-chan struct{}) {
        cont.log.Debug("Initializing proactiveConfClient")
        restconfig := cont.env.RESTConfig()
        proactiveConfClient, err := proactiveconfclientset.NewForConfig(restconfig)
        if err != nil {
                cont.log.Errorf("Failed to intialize proactiveConfClient")
                return
        }

        cont.initProactiveConfInformerFromClient(proactiveConfClient)
        go cont.proactiveConfInformer.Run(stopCh)
        cache.WaitForCacheSync(stopCh, cont.proactiveConfInformer.HasSynced)
}

func (cont *AciController) initProactiveConfInformerFromClient(
        proactiveConfClient *proactiveconfclientset.Clientset) {
        cont.initProactiveConfInformerBase(
                &cache.ListWatch{
                        ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
                                return proactiveConfClient.AciV1().ProactiveConfs(metav1.NamespaceAll).List(context.TODO(), options)
                        },
                        WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
                                return proactiveConfClient.AciV1().ProactiveConfs(metav1.NamespaceAll).Watch(context.TODO(), options)
                        },
                })
}

func (cont *AciController) initProactiveConfInformerBase(listWatch *cache.ListWatch) {
        cont.proactiveConfInformer = cache.NewSharedIndexInformer(
                listWatch,
                &pcv1.ProactiveConf{},
                controller.NoResyncPeriodFunc(),
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )
        cont.proactiveConfInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
                AddFunc: func(obj interface{}) {
                        cont.proactiveConfAdded(obj)
                },
                UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                        cont.proactiveConfUpdate(oldobj, newobj)
                },
                DeleteFunc: func(obj interface{}) {
                        cont.proactiveConfDelete(obj)
                },
        })
}

func (cont *AciController) proactiveConfAdded(obj interface{}) {
        policy := obj.(*pcv1.ProactiveConf)
        cont.log.Infof("ProactiveConf added: %s", policy.Name)
        cont.updateProactiveConf(policy)
}

func (cont *AciController) proactiveConfUpdate(oldobj interface{}, newobj interface{}) {
        oldpolicy := oldobj.(*pcv1.ProactiveConf)
        newpolicy := newobj.(*pcv1.ProactiveConf)
        cont.log.Infof("ProactiveConf updated: %s", newpolicy.Name)
        if oldpolicy.Spec.VmmEpgDeploymentImmediacy == newpolicy.Spec.VmmEpgDeploymentImmediacy {
                cont.log.Infof("ProactiveConf update: No change in VmmEpgDeploymentImmediacy")
                return
        }
        cont.updateProactiveConf(newpolicy)
}

func (cont *AciController) proactiveConfDelete(obj interface{}) {
        cont.indexMutex.Lock()
        defer cont.indexMutex.Unlock()
        policy := obj.(*pcv1.ProactiveConf)
        cont.log.Infof("ProactiveConf deleted: %s", policy.Name)
        fvRsDomAttSlice := cont.getfvRsDomAtt()
        cont.deleteProactiveConf(fvRsDomAttSlice)
}

func (cont *AciController) filterfvRsDomAtt(imdata []apicapi.ApicObject) []apicapi.ApicObject {
        epgDnsSet := make(map[string]struct{}, len(cont.cachedEpgDns)+1)
        for _, epgDn := range cont.cachedEpgDns {
                epgDnsSet[epgDn] = struct{}{}
        }

        systemDnsToFilter := []string{
                fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-system", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),
                fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-istio", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),
                fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-nodes", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),
        }

        for _, dn := range systemDnsToFilter {
                delete(epgDnsSet, dn)
        }

        vmmDomPDn := fmt.Sprintf("uni/vmmp-%s/dom-%s", cont.vmmDomainProvider(), cont.config.AciVmmDomain)

        var fvRsDomAttSlice []apicapi.ApicObject
        for _, fvRsDomAtt := range imdata {
                dn := fvRsDomAtt.GetAttr("dn").(string)

                rsdomAttIndex := strings.LastIndex(dn, "/rsdomAtt-")
                if rsdomAttIndex == -1 {
                        continue
                }

                parentDn := dn[:rsdomAttIndex]
                if _, found := epgDnsSet[parentDn]; !found {
                        continue
                }

                rsdomAttDn := dn[rsdomAttIndex+len("/rsdomAtt-"):]
                rsdomAttDn = strings.Trim(rsdomAttDn, "[]")
                if rsdomAttDn == vmmDomPDn {
                        fvRsDomAttSlice = append(fvRsDomAttSlice, fvRsDomAtt)
                }
        }

        return fvRsDomAttSlice
}

func (cont *AciController) getfvRsDomAtt() []apicapi.ApicObject {
        uri := fmt.Sprintf("/api/node/class/fvRsDomAtt.json?query-target-filter=and(wcard(fvRsDomAtt.dn,\"%s\"))", cont.config.AciPolicyTenant)
        resp, err := cont.apicConn.GetApicResponse(uri)
        if err != nil {
                cont.log.Errorf("Failed to get response from APIC: %v", err)
                return nil
        }
        return cont.filterfvRsDomAtt(resp.Imdata)
}

func (cont *AciController) postfvRsDomAtt(fvRsDomAttSlice []apicapi.ApicObject) {
        uri := fmt.Sprintf("/api/node/mo/uni/tn-%s.json", cont.config.AciPolicyTenant)
        err := cont.apicConn.PostApicObjects(uri, fvRsDomAttSlice)
        if err != nil {
                cont.log.Errorf("Failed to update the fvRsDomAtt: %v", err)
        }
}

func (cont *AciController) updateFvRsDomAttInstrImedcy(fvRsDomAttSlice []apicapi.ApicObject, immediacy string) {
        for _, fvRsDomAtt := range fvRsDomAttSlice {
                dn := fvRsDomAtt.GetAttr("dn").(string)
                fvRsDomAttNew := apicapi.EmptyApicObject("fvRsDomAtt", dn)
                fvRsDomAttNew.SetAttr("instrImedcy", immediacy)
                fvRsDomAttNew.SetAttr("resImedcy", immediacy)
                cont.postfvRsDomAtt([]apicapi.ApicObject{fvRsDomAttNew})
        }
}

func (cont *AciController) updateProactiveConf(policy *pcv1.ProactiveConf) {
        cont.indexMutex.Lock()
        defer cont.indexMutex.Unlock()
        vmmEpgDeploymentImmediacy := policy.Spec.VmmEpgDeploymentImmediacy
        fvRsDomAttSlice := cont.getfvRsDomAtt()

        if vmmEpgDeploymentImmediacy == pcv1.VmmEpgDeploymentImmediacyTypeImmediate {
                cont.updateFvRsDomAttInstrImedcy(fvRsDomAttSlice, "immediate")
        } else {
                cont.deleteProactiveConf(fvRsDomAttSlice)
        }
}

func (cont *AciController) deleteProactiveConf(fvRsDomAttSlice []apicapi.ApicObject) {
        cont.updateFvRsDomAttInstrImedcy(fvRsDomAttSlice, "lazy")
}

1	// Copyright 2019 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 WARRATIES 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	// Handlers for ProactiveConf CR updates.
16
17	package controller
18
19	import (
20	"context"
21	"fmt"
22	"strings"
23
24	"github.com/noironetworks/aci-containers/pkg/apicapi"
25	pcv1 "github.com/noironetworks/aci-containers/pkg/proactiveconf/apis/aci.pc/v1"
26	proactiveconfclientset "github.com/noironetworks/aci-containers/pkg/proactiveconf/clientset/versioned"
27
28	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
29	"k8s.io/apimachinery/pkg/runtime"
30	"k8s.io/apimachinery/pkg/watch"
31	"k8s.io/client-go/tools/cache"
32	"k8s.io/kubernetes/pkg/controller"
33	)
34
35	const (
36	proactiveConfCRDName = "proactiveconfs.aci.pc"
37	)
38
NEW 39	func proactiveConfInit(cont *AciController, stopCh <-chan struct{}) {	×
NEW 40	cont.log.Debug("Initializing proactiveConfClient")	×
NEW 41	restconfig := cont.env.RESTConfig()	×
NEW 42	proactiveConfClient, err := proactiveconfclientset.NewForConfig(restconfig)	×
NEW 43	if err != nil {	×
NEW 44	cont.log.Errorf("Failed to intialize proactiveConfClient")	×
NEW 45	return	×
NEW 46	}	×
47
NEW 48	cont.initProactiveConfInformerFromClient(proactiveConfClient)	×
NEW 49	go cont.proactiveConfInformer.Run(stopCh)	×
NEW 50	cache.WaitForCacheSync(stopCh, cont.proactiveConfInformer.HasSynced)	×
51	}
52
53	func (cont *AciController) initProactiveConfInformerFromClient(
NEW 54	proactiveConfClient *proactiveconfclientset.Clientset) {	×
NEW 55	cont.initProactiveConfInformerBase(	×
NEW 56	&cache.ListWatch{	×
NEW 57	ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {	×
NEW 58	return proactiveConfClient.AciV1().ProactiveConfs(metav1.NamespaceAll).List(context.TODO(), options)	×
NEW 59	},	×
NEW 60	WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {	×
NEW 61	return proactiveConfClient.AciV1().ProactiveConfs(metav1.NamespaceAll).Watch(context.TODO(), options)	×
NEW 62	},	×
63	})
64	}
65
66	func (cont AciController) initProactiveConfInformerBase(listWatch cache.ListWatch) {	1✔
67	cont.proactiveConfInformer = cache.NewSharedIndexInformer(	1✔
68	listWatch,	1✔
69	&pcv1.ProactiveConf{},	1✔
70	controller.NoResyncPeriodFunc(),	1✔
71	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
72	)	1✔
73	cont.proactiveConfInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{	1✔
74	AddFunc: func(obj interface{}) {	1✔
NEW 75	cont.proactiveConfAdded(obj)	×
NEW 76	},	×
NEW 77	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
NEW 78	cont.proactiveConfUpdate(oldobj, newobj)	×
NEW 79	},	×
NEW 80	DeleteFunc: func(obj interface{}) {	×
NEW 81	cont.proactiveConfDelete(obj)	×
NEW 82	},	×
83	})
84	}
85
NEW 86	func (cont *AciController) proactiveConfAdded(obj interface{}) {	×
NEW 87	policy := obj.(*pcv1.ProactiveConf)	×
NEW 88	cont.log.Infof("ProactiveConf added: %s", policy.Name)	×
NEW 89	cont.updateProactiveConf(policy)	×
NEW 90	}	×
91
NEW 92	func (cont *AciController) proactiveConfUpdate(oldobj interface{}, newobj interface{}) {	×
NEW 93	oldpolicy := oldobj.(*pcv1.ProactiveConf)	×
NEW 94	newpolicy := newobj.(*pcv1.ProactiveConf)	×
NEW 95	cont.log.Infof("ProactiveConf updated: %s", newpolicy.Name)	×
NEW 96	if oldpolicy.Spec.VmmEpgDeploymentImmediacy == newpolicy.Spec.VmmEpgDeploymentImmediacy {	×
NEW 97	cont.log.Infof("ProactiveConf update: No change in VmmEpgDeploymentImmediacy")	×
NEW 98	return	×
NEW 99	}	×
NEW 100	cont.updateProactiveConf(newpolicy)	×
101	}
102
NEW 103	func (cont *AciController) proactiveConfDelete(obj interface{}) {	×
NEW 104	cont.indexMutex.Lock()	×
NEW 105	defer cont.indexMutex.Unlock()	×
NEW 106	policy := obj.(*pcv1.ProactiveConf)	×
NEW 107	cont.log.Infof("ProactiveConf deleted: %s", policy.Name)	×
NEW 108	fvRsDomAttSlice := cont.getfvRsDomAtt()	×
NEW 109	cont.deleteProactiveConf(fvRsDomAttSlice)	×
NEW 110	}	×
111
NEW 112	func (cont *AciController) filterfvRsDomAtt(imdata []apicapi.ApicObject) []apicapi.ApicObject {	×
NEW 113	epgDnsSet := make(map[string]struct{}, len(cont.cachedEpgDns)+1)	×
NEW 114	for _, epgDn := range cont.cachedEpgDns {	×
NEW 115	epgDnsSet[epgDn] = struct{}{}	×
NEW 116	}	×
117
NEW 118	systemDnsToFilter := []string{	×
NEW 119	fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-system", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),	×
NEW 120	fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-istio", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),	×
NEW 121	fmt.Sprintf("uni/tn-%s/ap-aci-containers-%s/epg-aci-containers-nodes", cont.config.AciPolicyTenant, cont.config.AciVmmDomain),	×
NEW 122	}	×
NEW 123		×
NEW 124	for _, dn := range systemDnsToFilter {	×
NEW 125	delete(epgDnsSet, dn)	×
NEW 126	}	×
127
NEW 128	vmmDomPDn := fmt.Sprintf("uni/vmmp-%s/dom-%s", cont.vmmDomainProvider(), cont.config.AciVmmDomain)	×
NEW 129		×
NEW 130	var fvRsDomAttSlice []apicapi.ApicObject	×
NEW 131	for _, fvRsDomAtt := range imdata {	×
NEW 132	dn := fvRsDomAtt.GetAttr("dn").(string)	×
NEW 133		×
NEW 134	rsdomAttIndex := strings.LastIndex(dn, "/rsdomAtt-")	×
NEW 135	if rsdomAttIndex == -1 {	×
NEW 136	continue	×
137	}
138
NEW 139	parentDn := dn[:rsdomAttIndex]	×
NEW 140	if _, found := epgDnsSet[parentDn]; !found {	×
NEW 141	continue	×
142	}
143
NEW 144	rsdomAttDn := dn[rsdomAttIndex+len("/rsdomAtt-"):]	×
NEW 145	rsdomAttDn = strings.Trim(rsdomAttDn, "[]")	×
NEW 146	if rsdomAttDn == vmmDomPDn {	×
NEW 147	fvRsDomAttSlice = append(fvRsDomAttSlice, fvRsDomAtt)	×
NEW 148	}	×
149	}
150
NEW 151	return fvRsDomAttSlice	×
152	}
153
NEW 154	func (cont *AciController) getfvRsDomAtt() []apicapi.ApicObject {	×
NEW 155	uri := fmt.Sprintf("/api/node/class/fvRsDomAtt.json?query-target-filter=and(wcard(fvRsDomAtt.dn,\"%s\"))", cont.config.AciPolicyTenant)	×
NEW 156	resp, err := cont.apicConn.GetApicResponse(uri)	×
NEW 157	if err != nil {	×
NEW 158	cont.log.Errorf("Failed to get response from APIC: %v", err)	×
NEW 159	return nil	×
NEW 160	}	×
NEW 161	return cont.filterfvRsDomAtt(resp.Imdata)	×
162	}
163
NEW 164	func (cont *AciController) postfvRsDomAtt(fvRsDomAttSlice []apicapi.ApicObject) {	×
NEW 165	uri := fmt.Sprintf("/api/node/mo/uni/tn-%s.json", cont.config.AciPolicyTenant)	×
NEW 166	err := cont.apicConn.PostApicObjects(uri, fvRsDomAttSlice)	×
NEW 167	if err != nil {	×
NEW 168	cont.log.Errorf("Failed to update the fvRsDomAtt: %v", err)	×
NEW 169	}	×
170	}
171
NEW 172	func (cont *AciController) updateFvRsDomAttInstrImedcy(fvRsDomAttSlice []apicapi.ApicObject, immediacy string) {	×
NEW 173	for _, fvRsDomAtt := range fvRsDomAttSlice {	×
NEW 174	dn := fvRsDomAtt.GetAttr("dn").(string)	×
NEW 175	fvRsDomAttNew := apicapi.EmptyApicObject("fvRsDomAtt", dn)	×
NEW 176	fvRsDomAttNew.SetAttr("instrImedcy", immediacy)	×
NEW 177	fvRsDomAttNew.SetAttr("resImedcy", immediacy)	×
NEW 178	cont.postfvRsDomAtt([]apicapi.ApicObject{fvRsDomAttNew})	×
NEW 179	}	×
180	}
181
NEW 182	func (cont AciController) updateProactiveConf(policy pcv1.ProactiveConf) {	×
NEW 183	cont.indexMutex.Lock()	×
NEW 184	defer cont.indexMutex.Unlock()	×
NEW 185	vmmEpgDeploymentImmediacy := policy.Spec.VmmEpgDeploymentImmediacy	×
NEW 186	fvRsDomAttSlice := cont.getfvRsDomAtt()	×
NEW 187		×
NEW 188	if vmmEpgDeploymentImmediacy == pcv1.VmmEpgDeploymentImmediacyTypeImmediate {	×
NEW 189	cont.updateFvRsDomAttInstrImedcy(fvRsDomAttSlice, "immediate")	×
NEW 190	} else {	×
NEW 191	cont.deleteProactiveConf(fvRsDomAttSlice)	×
NEW 192	}	×
193	}
194
NEW 195	func (cont *AciController) deleteProactiveConf(fvRsDomAttSlice []apicapi.ApicObject) {	×
NEW 196	cont.updateFvRsDomAttInstrImedcy(fvRsDomAttSlice, "lazy")	×
NEW 197	}	×

noironetworks / aci-containers / 9721

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