9881

Committed 13 Sep 2024 07:22AM UTC coverage: 69.939% (+0.02%) from 69.917%

Build # 9881

Build Type

Pull #1397

travis-pro

Committed by

smshareef

Commit Message

Do not use cachedEpgDns to filter out fvRsDomAtt

As cachedEpgDns are updated only for APIC version >=5.2, to allow
for compatiability with previous versions removed the logic to use
cachedEpgDns to filter out the EPGs for which the fvRsDomAtt needs
to be updated on ProactiveConf update. As the vmmDomPDn is used to
filter checking for Dns in cachedEpgDns was redundant.

(cherry picked from commit c8926ac9f)

Pull Request Pull Request #1397: Backport ProactiveConf changes to mmr-6.1.1

Run Details

0 of 20 new or added lines in 3 files covered. (0.0%)

1 existing line in 1 file now uncovered.

13103 of 18735 relevant lines covered (69.94%)

0.8 hits per line

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

9.28

/pkg/hostagent/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 hostagent

import (
        "context"
        "encoding/json"
        "os"
        "path/filepath"

        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"
)

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

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

type oobData struct {
        TunnelEpAdvertisementInterval uint64 `json:"tunnel-ep-advertisement-interval"`
}

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

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

func (agent *HostAgent) proactiveConfDelete(obj interface{}) {
        agent.proactiveConfMutex.Lock()
        defer agent.proactiveConfMutex.Unlock()
        policy := obj.(*pcv1.ProactiveConf)
        agent.log.Infof("ProactiveConf deleted: %s", policy.Name)
        agent.deleteProactiveConf()
}

func (agent *HostAgent) updateProactiveConf(policy *pcv1.ProactiveConf) {
        agent.proactiveConfMutex.Lock()
        defer agent.proactiveConfMutex.Unlock()

        tunnelEpAdvertisementInterval := policy.Spec.TunnelEpAdvertisementInterval
        vmmEpgDeploymentImmediacy := policy.Spec.VmmEpgDeploymentImmediacy

        if vmmEpgDeploymentImmediacy == pcv1.VmmEpgDeploymentImmediacyTypeImmediate {
                oobData := oobData{
                        TunnelEpAdvertisementInterval: tunnelEpAdvertisementInterval,
                }
                filePath := filepath.Join(agent.config.OOBPolicyDir, "aci-containers-system.oob")
                agent.log.Infof("Updating ProactiveConf file %s", filePath)
                err := agent.writeOOBPolicyFile(filePath, oobData)
                if err != nil {
                        agent.log.Errorf("Failed to update ProactiveConf file %s: %v", filePath, err)
                }
        } else {
                agent.deleteProactiveConf()
        }
}

func (agent *HostAgent) deleteProactiveConf() {
        filePath := filepath.Join(agent.config.OOBPolicyDir, "aci-containers-system.oob")
        agent.log.Infof("Deleting oob policy data file %s", filePath)
        err := agent.deleteOOBPolicyFile(filePath)
        if err != nil {
                agent.log.Errorf("Failed to delete oob policy data %s: %v", filePath, err)
        }
}

func (agent *HostAgent) writeOOBPolicyFile(filePath string, oobData oobData) error {
        oobJson, err := json.MarshalIndent(oobData, "", "  ")
        if err != nil {
                return err
        }
        err = os.WriteFile(filePath, oobJson, 0644)
        if err != nil {
                agent.log.Fatalf("Failed to write oob policy data to file: %v", err)
                return err
        } else {
                agent.log.Infof("File %s updated", filePath)
        }

        return nil

}

func (agent *HostAgent) deleteOOBPolicyFile(filePath string) error {
        err := os.Remove(filePath)
        if err != nil {
                agent.log.Fatalf("Failed to delete oob policy data file: %v", err)
                return err
        } else {
                agent.log.Infof("File %s deleted", filePath)
        }
        return nil
}

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 hostagent
18
19	import (
20	"context"
21	"encoding/json"
22	"os"
23	"path/filepath"
24
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	func (agent *HostAgent) initProactiveConfInformerFromClient(
36	proactiveConfClient *proactiveconfclientset.Clientset) {	×
37	agent.initProactiveConfInformerBase(	×
38	&cache.ListWatch{	×
39	ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {	×
NEW 40	return proactiveConfClient.AciV1().ProactiveConfs().List(context.TODO(), options)	×
41	},	×
42	WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {	×
NEW 43	return proactiveConfClient.AciV1().ProactiveConfs().Watch(context.TODO(), options)	×
44	},	×
45	})
46	}
47
48	func (agent HostAgent) initProactiveConfInformerBase(listWatch cache.ListWatch) {	1✔
49	agent.proactiveConfInformer = cache.NewSharedIndexInformer(	1✔
50	listWatch,	1✔
51	&pcv1.ProactiveConf{},	1✔
52	controller.NoResyncPeriodFunc(),	1✔
53	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
54	)	1✔
55	agent.proactiveConfInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{	1✔
56	AddFunc: func(obj interface{}) {	1✔
57	agent.proactiveConfAdded(obj)	×
58	},	×
59	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
60	agent.proactiveConfUpdate(oldobj, newobj)	×
61	},	×
62	DeleteFunc: func(obj interface{}) {	×
63	agent.proactiveConfDelete(obj)	×
64	},	×
65	})
66	}
67
68	type oobData struct {
69	TunnelEpAdvertisementInterval uint64 `json:"tunnel-ep-advertisement-interval"`
70	}
71
72	func (agent *HostAgent) proactiveConfAdded(obj interface{}) {	×
73	policy := obj.(*pcv1.ProactiveConf)	×
74	agent.log.Infof("ProactiveConf added: %s", policy.Name)	×
75	agent.updateProactiveConf(policy)	×
76	}	×
77
78	func (agent *HostAgent) proactiveConfUpdate(oldobj interface{}, newobj interface{}) {	×
79	oldpolicy := oldobj.(*pcv1.ProactiveConf)	×
80	newpolicy := newobj.(*pcv1.ProactiveConf)	×
81	agent.log.Infof("ProactiveConf updated: %s", newpolicy.Name)	×
82	if oldpolicy.Spec.TunnelEpAdvertisementInterval == newpolicy.Spec.TunnelEpAdvertisementInterval &&	×
83	oldpolicy.Spec.VmmEpgDeploymentImmediacy == newpolicy.Spec.VmmEpgDeploymentImmediacy {	×
84	agent.log.Infof("ProactiveConf update: No change in policy")	×
85	return	×
86	}	×
87	agent.updateProactiveConf(newpolicy)	×
88	}
89
90	func (agent *HostAgent) proactiveConfDelete(obj interface{}) {	×
91	agent.proactiveConfMutex.Lock()	×
92	defer agent.proactiveConfMutex.Unlock()	×
93	policy := obj.(*pcv1.ProactiveConf)	×
94	agent.log.Infof("ProactiveConf deleted: %s", policy.Name)	×
95	agent.deleteProactiveConf()	×
96	}	×
97
98	func (agent HostAgent) updateProactiveConf(policy pcv1.ProactiveConf) {	×
99	agent.proactiveConfMutex.Lock()	×
100	defer agent.proactiveConfMutex.Unlock()	×
101		×
102	tunnelEpAdvertisementInterval := policy.Spec.TunnelEpAdvertisementInterval	×
103	vmmEpgDeploymentImmediacy := policy.Spec.VmmEpgDeploymentImmediacy	×
104		×
105	if vmmEpgDeploymentImmediacy == pcv1.VmmEpgDeploymentImmediacyTypeImmediate {	×
106	oobData := oobData{	×
107	TunnelEpAdvertisementInterval: tunnelEpAdvertisementInterval,	×
108	}	×
109	filePath := filepath.Join(agent.config.OOBPolicyDir, "aci-containers-system.oob")	×
110	agent.log.Infof("Updating ProactiveConf file %s", filePath)	×
111	err := agent.writeOOBPolicyFile(filePath, oobData)	×
112	if err != nil {	×
113	agent.log.Errorf("Failed to update ProactiveConf file %s: %v", filePath, err)	×
114	}	×
115	} else {	×
116	agent.deleteProactiveConf()	×
117	}	×
118	}
119
120	func (agent *HostAgent) deleteProactiveConf() {	×
121	filePath := filepath.Join(agent.config.OOBPolicyDir, "aci-containers-system.oob")	×
122	agent.log.Infof("Deleting oob policy data file %s", filePath)	×
123	err := agent.deleteOOBPolicyFile(filePath)	×
124	if err != nil {	×
125	agent.log.Errorf("Failed to delete oob policy data %s: %v", filePath, err)	×
126	}	×
127	}
128
129	func (agent *HostAgent) writeOOBPolicyFile(filePath string, oobData oobData) error {	×
130	oobJson, err := json.MarshalIndent(oobData, "", " ")	×
131	if err != nil {	×
132	return err	×
133	}	×
134	err = os.WriteFile(filePath, oobJson, 0644)	×
135	if err != nil {	×
136	agent.log.Fatalf("Failed to write oob policy data to file: %v", err)	×
137	return err	×
138	} else {	×
139	agent.log.Infof("File %s updated", filePath)	×
140	}	×
141
142	return nil	×
143
144	}
145
146	func (agent *HostAgent) deleteOOBPolicyFile(filePath string) error {	×
147	err := os.Remove(filePath)	×
148	if err != nil {	×
149	agent.log.Fatalf("Failed to delete oob policy data file: %v", err)	×
150	return err	×
151	} else {	×
152	agent.log.Infof("File %s deleted", filePath)	×
153	}	×
154	return nil	×
155	}

noironetworks / aci-containers / 9881

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