6391

Committed 04 Mar 2022 05:08AM UTC coverage: 57.427%. First build

Build # 6391

Build Type

push

travis-ci-com

Committed by

akhilamohanan

Commit Message

Fix for snat-uuid missing in ep file

* RCA: Sometimes syncEps() was called at the time of initialization even before
opflexSnatLocalinfo was not updated with snat-uuids and empty snat-uuid list was written to ep file.

* Fix: If opflexSnatLocalinfo update is not happened before syncEps() at the
time of initialization, snat-uuids in the ep file will be maintained

(cherry picked from commit cb2cffa5a)

Run Details

67 of 67 new or added lines in 5 files covered. (100.0%)

11753 of 20466 relevant lines covered (57.43%)

0.64 hits per line

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

12.93

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

// creates snat crs.

package hostagent

import (
        "context"
        "errors"
        "reflect"

        snatLocalInfov1 "github.com/noironetworks/aci-containers/pkg/snatlocalinfo/apis/aci.snat/v1"
        v1 "k8s.io/api/core/v1"
        apierrors "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type SnatLocalInfo struct {
        snatIp         string
        destIps        []string
        snatpolicyName string
}

func (agent *HostAgent) populateSnatLocalInfos() error {
        env := agent.env.(*K8sEnvironment)
        agent.log.Debug("Populating opflexSnatLocalInfos from SnatLocalInfo CR")
        snatLocalInfoClient := env.snatLocalInfoClient
        if snatLocalInfoClient == nil {
                agent.log.Error("snatLocalInfo or Kube clients are not intialized")
                return errors.New("snatLocalInfo or Kube clients are not intialized")
        }
        snatLocalInfoCr, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})
        if err != nil {
                agent.log.Error("Failed to get snatlocalinfo ", err.Error())
                return err
        }
        agent.indexMutex.Lock()
        for _, localInfo := range snatLocalInfoCr.Spec.LocalInfos {
                if localInfo.PodUid != "" {
                        var snatLocalInfo opflexSnatLocalInfo
                        snatLocalInfo.Snatpolicies = make(map[ResourceType][]string)
                        snatLocalInfo.Existing = true
                        agent.opflexSnatLocalInfos[localInfo.PodUid] = &snatLocalInfo
                        agent.log.Debug("Populated opflexSnatLocalInfos for poduid :", localInfo.PodUid)
                }
        }
        agent.indexMutex.Unlock()
        return nil
}

func (agent *HostAgent) UpdateLocalInfoCr() bool {
        env := agent.env.(*K8sEnvironment)
        snatLocalInfoClient := env.snatLocalInfoClient
        if snatLocalInfoClient == nil {
                agent.log.Debug("snatLocalInfo or Kube clients are not intialized")
                return false
        }
        agent.indexMutex.Lock()
        ginfos, ok := agent.opflexSnatGlobalInfos[agent.config.NodeName]
        if !ok {
                agent.indexMutex.Unlock()
                return agent.deleteLocalInfoCr()
        }

        snatLocalInfo := make(map[string]SnatLocalInfo)
        for _, ginfo := range ginfos {
                var localInfo SnatLocalInfo
                localInfo.snatIp = ginfo.SnatIp
                agent.snatPolicyCacheMutex.RLock()
                if _, ok := agent.snatPolicyCache[ginfo.SnatPolicyName]; ok {
                        if len(agent.snatPolicyCache[ginfo.SnatPolicyName].Spec.DestIp) == 0 {
                                localInfo.destIps = []string{"0.0.0.0/0"}
                        } else {
                                localInfo.destIps =
                                        agent.snatPolicyCache[ginfo.SnatPolicyName].Spec.DestIp
                        }
                }
                agent.snatPolicyCacheMutex.RUnlock()
                localInfo.snatpolicyName = ginfo.SnatPolicyName
                snatLocalInfo[ginfo.SnatIpUid] = localInfo
        }
        var localInfos []snatLocalInfov1.LocalInfo
        for uid, v := range agent.opflexSnatLocalInfos {
                var localinfo snatLocalInfov1.LocalInfo
                var policies []snatLocalInfov1.SnatPolicy
                for _, plcyUid := range v.PlcyUuids {
                        if linfo, ok := snatLocalInfo[plcyUid]; ok {
                                var policy snatLocalInfov1.SnatPolicy
                                policy.SnatIp = linfo.snatIp
                                policy.DestIp = linfo.destIps
                                policy.Name = linfo.snatpolicyName
                                policies = append(policies, policy)
                        }
                }
                epkey := agent.podUidToName[uid]
                podobj, exists, err := agent.podInformer.GetStore().GetByKey(epkey)
                if exists && err == nil {
                        pod := podobj.(*v1.Pod)
                        localinfo.PodName = pod.ObjectMeta.Name
                        localinfo.PodNamespace = pod.ObjectMeta.Namespace
                        agent.log.Debugf("Adding pod %s to snatLocalInfo:", localinfo.PodName)
                }
                localinfo.PodUid = uid
                localinfo.SnatPolicies = policies
                if len(policies) > 0 {
                        localInfos = append(localInfos, localinfo)
                }
        }
        agent.indexMutex.Unlock()
        snatLocalInfoCr, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})
        if err != nil {
                if apierrors.IsNotFound(err) {
                        snatLocalInfoInstance := &snatLocalInfov1.SnatLocalInfo{
                                ObjectMeta: metav1.ObjectMeta{
                                        Name:      agent.config.NodeName,
                                        Namespace: agent.config.AciSnatNamespace,
                                },
                                Spec: snatLocalInfov1.SnatLocalInfoSpec{
                                        LocalInfos: localInfos,
                                },
                        }
                        _, err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Create(context.TODO(), snatLocalInfoInstance, metav1.CreateOptions{})
                }
        } else {
                Spec := snatLocalInfov1.SnatLocalInfoSpec{
                        LocalInfos: localInfos,
                }
                if !reflect.DeepEqual(snatLocalInfoCr.Spec, Spec) {
                        snatLocalInfoCr.Spec = Spec
                        _, err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Update(context.TODO(), snatLocalInfoCr, metav1.UpdateOptions{})
                }
        }
        if err == nil {
                agent.log.Debug("SnatLocalInfo  Update Successful..")
                return false
        }
        return true
}

func (agent *HostAgent) deleteLocalInfoCr() bool {
        env := agent.env.(*K8sEnvironment)
        snatLocalInfoClient := env.snatLocalInfoClient
        _, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})
        if err == nil {
                err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Delete(context.TODO(), agent.config.NodeName, metav1.DeleteOptions{})
                if err != nil {
                        agent.log.Debug("SnatLocalInfo failed to delete: ", err)
                        return true
                }
        }
        return false
}

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	// creates snat crs.
16
17	package hostagent
18
19	import (
20	"context"
21	"errors"
22	"reflect"
23
24	snatLocalInfov1 "github.com/noironetworks/aci-containers/pkg/snatlocalinfo/apis/aci.snat/v1"
25	v1 "k8s.io/api/core/v1"
26	apierrors "k8s.io/apimachinery/pkg/api/errors"
27	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
28	)
29
30	type SnatLocalInfo struct {
31	snatIp string
32	destIps []string
33	snatpolicyName string
34	}
35
36	func (agent *HostAgent) populateSnatLocalInfos() error {	1✔
37	env := agent.env.(*K8sEnvironment)	1✔
38	agent.log.Debug("Populating opflexSnatLocalInfos from SnatLocalInfo CR")	1✔
39	snatLocalInfoClient := env.snatLocalInfoClient	1✔
40	if snatLocalInfoClient == nil {	2✔
41	agent.log.Error("snatLocalInfo or Kube clients are not intialized")	1✔
42	return errors.New("snatLocalInfo or Kube clients are not intialized")	1✔
43	}	1✔
44	snatLocalInfoCr, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})	×
45	if err != nil {	×
46	agent.log.Error("Failed to get snatlocalinfo ", err.Error())	×
47	return err	×
48	}	×
49	agent.indexMutex.Lock()	×
50	for _, localInfo := range snatLocalInfoCr.Spec.LocalInfos {	×
51	if localInfo.PodUid != "" {	×
52	var snatLocalInfo opflexSnatLocalInfo	×
53	snatLocalInfo.Snatpolicies = make(map[ResourceType][]string)	×
54	snatLocalInfo.Existing = true	×
55	agent.opflexSnatLocalInfos[localInfo.PodUid] = &snatLocalInfo	×
56	agent.log.Debug("Populated opflexSnatLocalInfos for poduid :", localInfo.PodUid)	×
57	}	×
58	}
59	agent.indexMutex.Unlock()	×
60	return nil	×
61	}
62
63	func (agent *HostAgent) UpdateLocalInfoCr() bool {	1✔
64	env := agent.env.(*K8sEnvironment)	1✔
65	snatLocalInfoClient := env.snatLocalInfoClient	1✔
66	if snatLocalInfoClient == nil {	2✔
67	agent.log.Debug("snatLocalInfo or Kube clients are not intialized")	1✔
68	return false	1✔
69	}	1✔
70	agent.indexMutex.Lock()	×
71	ginfos, ok := agent.opflexSnatGlobalInfos[agent.config.NodeName]	×
72	if !ok {	×
73	agent.indexMutex.Unlock()	×
74	return agent.deleteLocalInfoCr()	×
75	}	×
76
77	snatLocalInfo := make(map[string]SnatLocalInfo)	×
78	for _, ginfo := range ginfos {	×
79	var localInfo SnatLocalInfo	×
80	localInfo.snatIp = ginfo.SnatIp	×
81	agent.snatPolicyCacheMutex.RLock()	×
82	if _, ok := agent.snatPolicyCache[ginfo.SnatPolicyName]; ok {	×
83	if len(agent.snatPolicyCache[ginfo.SnatPolicyName].Spec.DestIp) == 0 {	×
84	localInfo.destIps = []string{"0.0.0.0/0"}	×
85	} else {	×
86	localInfo.destIps =	×
87	agent.snatPolicyCache[ginfo.SnatPolicyName].Spec.DestIp	×
88	}	×
89	}
90	agent.snatPolicyCacheMutex.RUnlock()	×
91	localInfo.snatpolicyName = ginfo.SnatPolicyName	×
92	snatLocalInfo[ginfo.SnatIpUid] = localInfo	×
93	}
94	var localInfos []snatLocalInfov1.LocalInfo	×
95	for uid, v := range agent.opflexSnatLocalInfos {	×
96	var localinfo snatLocalInfov1.LocalInfo	×
97	var policies []snatLocalInfov1.SnatPolicy	×
98	for _, plcyUid := range v.PlcyUuids {	×
99	if linfo, ok := snatLocalInfo[plcyUid]; ok {	×
100	var policy snatLocalInfov1.SnatPolicy	×
101	policy.SnatIp = linfo.snatIp	×
102	policy.DestIp = linfo.destIps	×
103	policy.Name = linfo.snatpolicyName	×
104	policies = append(policies, policy)	×
105	}	×
106	}
107	epkey := agent.podUidToName[uid]	×
108	podobj, exists, err := agent.podInformer.GetStore().GetByKey(epkey)	×
109	if exists && err == nil {	×
110	pod := podobj.(*v1.Pod)	×
111	localinfo.PodName = pod.ObjectMeta.Name	×
112	localinfo.PodNamespace = pod.ObjectMeta.Namespace	×
113	agent.log.Debugf("Adding pod %s to snatLocalInfo:", localinfo.PodName)	×
114	}	×
115	localinfo.PodUid = uid	×
116	localinfo.SnatPolicies = policies	×
117	if len(policies) > 0 {	×
118	localInfos = append(localInfos, localinfo)	×
119	}	×
120	}
121	agent.indexMutex.Unlock()	×
122	snatLocalInfoCr, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})	×
123	if err != nil {	×
124	if apierrors.IsNotFound(err) {	×
125	snatLocalInfoInstance := &snatLocalInfov1.SnatLocalInfo{	×
126	ObjectMeta: metav1.ObjectMeta{	×
127	Name: agent.config.NodeName,	×
128	Namespace: agent.config.AciSnatNamespace,	×
129	},	×
130	Spec: snatLocalInfov1.SnatLocalInfoSpec{	×
131	LocalInfos: localInfos,	×
132	},	×
133	}	×
134	_, err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Create(context.TODO(), snatLocalInfoInstance, metav1.CreateOptions{})	×
135	}	×
136	} else {	×
137	Spec := snatLocalInfov1.SnatLocalInfoSpec{	×
138	LocalInfos: localInfos,	×
139	}	×
140	if !reflect.DeepEqual(snatLocalInfoCr.Spec, Spec) {	×
141	snatLocalInfoCr.Spec = Spec	×
142	_, err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Update(context.TODO(), snatLocalInfoCr, metav1.UpdateOptions{})	×
143	}	×
144	}
145	if err == nil {	×
146	agent.log.Debug("SnatLocalInfo Update Successful..")	×
147	return false	×
148	}	×
149	return true	×
150	}
151
152	func (agent *HostAgent) deleteLocalInfoCr() bool {	×
153	env := agent.env.(*K8sEnvironment)	×
154	snatLocalInfoClient := env.snatLocalInfoClient	×
155	_, err := snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Get(context.TODO(), agent.config.NodeName, metav1.GetOptions{})	×
156	if err == nil {	×
157	err = snatLocalInfoClient.AciV1().SnatLocalInfos(agent.config.AciSnatNamespace).Delete(context.TODO(), agent.config.NodeName, metav1.DeleteOptions{})	×
158	if err != nil {	×
159	agent.log.Debug("SnatLocalInfo failed to delete: ", err)	×
160	return true	×
161	}	×
162	}
163	return false	×
164	}

noironetworks / aci-containers / 6391

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