6813

Committed 16 Aug 2022 05:50PM UTC coverage: 57.184%. First build

Build # 6813

Build Type

Pull #1037

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/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://git"><a class=hub.com/noironetworks/aci-containers/commit/f3fdd0917d815760e99295f377f87cb5374b6eaf">f3fdd0917">&lt;a href=&quot;https://github.com/noironetworks/aci-containers/commit/</a><a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/noironetworks/aci-containers/commit/f3fdd0917d815760e99295f377f87cb5374b6eaf">f3fdd0917</a><a href="https://github.com/noironetworks/aci-containers/commit/f3fdd0917d815760e99295f377f87cb5374b6eaf">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/noironetworks/aci-containers/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/noironetworks/aci-containers/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/noironetworks/aci-containers/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/noironetworks/aci-containers/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/noironetworks/aci-containers/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/noironetworks/aci-containers/commit/f3fdd0917d815760e99295f377f87cb5374b6eaf&quot;&gt;f3fdd0917&lt;/a&gt;&lt;a href=&quot;https://github.com/noironetworks/aci-containers/commit/f3fdd0917d815760e99295f377f87cb5374b6eaf&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/noironetworks/aci-containers/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;ht... (continued)

Pull Request Pull Request #1037: Add extern from pod arg kmr2

Run Details

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

12091 of 21144 relevant lines covered (57.18%)

0.64 hits per line

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

25.25

/pkg/controller/rdconfig.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 controller

import (
        "context"
        rdConfigv1 "github.com/noironetworks/aci-containers/pkg/rdconfig/apis/aci.snat/v1"
        rdconfigclset "github.com/noironetworks/aci-containers/pkg/rdconfig/clientset/versioned"
        "github.com/noironetworks/aci-containers/pkg/util"
        "github.com/sirupsen/logrus"
        apierrors "k8s.io/apimachinery/pkg/api/errors"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/watch"
        "k8s.io/client-go/tools/cache"
        "os"
        "reflect"
)

func (cont *AciController) initRdConfigInformerFromClient(
        rdConfigClient *rdconfigclset.Clientset) {
        ns := os.Getenv("ACI_SNAT_NAMESPACE")
        name := os.Getenv("ACI_RDCONFIG_NAME")
        cont.initRdConfigInformerBase(
                &cache.ListWatch{
                        ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
                                options.FieldSelector = fields.Set{"metadata.name": name}.String()
                                obj, err := rdConfigClient.AciV1().RdConfigs(ns).List(context.TODO(), options)
                                if err != nil {
                                        cont.log.Fatalf("Failed to list RdConfigs during initialization of RdConfigInformer with err: %v", err)
                                }
                                return obj, err
                        },
                        WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
                                options.FieldSelector = fields.Set{"metadata.name": name}.String()
                                obj, err := rdConfigClient.AciV1().RdConfigs(ns).Watch(context.TODO(), options)
                                if err != nil {
                                        cont.log.Fatalf("Failed to watch RdConfigs during initialization RdConfigsInformer with err: %v", err)
                                }
                                return obj, err
                        },
                })
}

func (cont *AciController) initRdConfigInformerBase(listWatch *cache.ListWatch) {
        cont.rdConfigIndexer, cont.rdConfigInformer = cache.NewIndexerInformer(
                listWatch,
                &rdConfigv1.RdConfig{}, 0,
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                cont.RdConfigAdded(obj)
                        },
                        UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                                cont.RdConfigUpdated(oldobj, newobj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                cont.RdConfigDeleted(obj)
                        },
                },
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )
        cont.log.Debug("Initializing RdConfig Informers")
}

func (cont *AciController) RdConfigAdded(obj interface{}) {
        rdcon := obj.(*rdConfigv1.RdConfig)
        rdconkey, err := cache.MetaNamespaceKeyFunc(rdcon)
        if err != nil {
                RdConfigLogger(cont.log, rdcon).Error("Could not create key:" + err.Error())
                return
        }
        cont.log.Infof("RdConfig: %s added", rdconkey)
        cont.indexMutex.Lock()
        cont.rdConfigCache[rdcon.ObjectMeta.Name] = rdcon
        cont.indexMutex.Unlock()
        cont.queueRdConfigUpdateByKey(rdconkey)
}

func (cont *AciController) RdConfigUpdated(oldobj interface{}, newobj interface{}) {
        oldrdcon := oldobj.(*rdConfigv1.RdConfig)
        newrdcon := newobj.(*rdConfigv1.RdConfig)
        rdconkey, err := cache.MetaNamespaceKeyFunc(newrdcon)
        if err != nil {
                RdConfigLogger(cont.log, newrdcon).Error("Could not create key:" + err.Error())
                return
        }
        if reflect.DeepEqual(oldrdcon.Spec, newrdcon.Spec) {
                return
        }
        cont.log.Infof("Updating RdConfig:%s, from: %v, to: %v", rdconkey, oldrdcon, newrdcon)
        cont.indexMutex.Lock()
        cont.rdConfigCache[newrdcon.ObjectMeta.Name] = newrdcon
        cont.indexMutex.Unlock()
        cont.queueRdConfigUpdateByKey(rdconkey)

}

func (cont *AciController) RdConfigDeleted(obj interface{}) {
        rdcon := obj.(*rdConfigv1.RdConfig)
        rdconkey, err := cache.MetaNamespaceKeyFunc(rdcon)
        if err != nil {
                RdConfigLogger(cont.log, rdcon).Error("Could not create key:" + err.Error())
                return
        }
        cont.indexMutex.Lock()
        cont.log.Info("Deleting RdConfig object with name: ", rdcon.ObjectMeta.Name)
        delete(cont.rdConfigCache, rdcon.ObjectMeta.Name)
        cont.indexMutex.Unlock()
        cont.queueRdConfigUpdateByKey(rdconkey)
}

func (cont *AciController) queueRdConfigUpdateByKey(key string) {
        cont.log.Debug("RdConfig key Queued: ", key)
        cont.rdConfigQueue.Add(key)
}

func (cont *AciController) postDelHandleRdConfig() bool {
        name := os.Getenv("ACI_RDCONFIG_NAME")
        cont.log.Debugf("RdConfig %s should not be deleted Re-Creating...", name)
        //gatekeeping against before init RdConfig Sync
        if spec, ok := cont.rdConfigSubnetCache[name]; ok {
                err := util.CreateRdConfigCR(*cont.env.(*K8sEnvironment).rdConfigClient, *spec)
                if err != nil {
                        cont.log.Debugf("Unable to RE-Create RDConfig: %s, err: %v, spec: %+v", name, err, spec)
                        return true
                }
                cont.log.Debugf("RdConfig: %s RE-Created with spec: %v, Please update this resource and refrain from deleting it.", name, spec)
        }
        cont.scheduleRdConfig()
        return false
}

func (cont *AciController) handleRdConfig(rdconfig *rdConfigv1.RdConfig) bool {
        //store discovered subnets and user subnets in a cache to recreate on delete
        cont.log.Debug("handle RdConfig: ", rdconfig)
        _, err := cache.MetaNamespaceIndexFunc(rdconfig)
        if err != nil {
                cont.log.Debugf("Could not create key: %s", err)
                return false
        }
        if spec, ok := cont.rdConfigSubnetCache[rdconfig.ObjectMeta.Name]; ok && reflect.DeepEqual(rdconfig.Spec.UserSubnets, spec.UserSubnets) {
                //no update necessary
                return false
        } else {
                cont.indexMutex.Lock()
                cont.rdConfigSubnetCache[rdconfig.ObjectMeta.Name] = &rdconfig.Spec
                cont.indexMutex.Unlock()
        }
        return true
}

func (cont *AciController) syncRdConfig() bool {
        cont.log.Debug("Syncing RdConfig")
        var options metav1.GetOptions
        var discoveredSubnets []string
        cont.indexMutex.Lock()
        for _, v := range cont.apicConn.CachedSubnetDns {
                discoveredSubnets = append(discoveredSubnets, v)
        }
        cont.indexMutex.Unlock()
        env := cont.env.(*K8sEnvironment)
        rdConfigClient := env.rdConfigClient
        if rdConfigClient == nil {
                return false
        }
        ns := os.Getenv("ACI_SNAT_NAMESPACE")
        name := os.Getenv("ACI_RDCONFIG_NAME")
        rdCon, err := rdConfigClient.AciV1().RdConfigs(ns).Get(context.TODO(), name, options)
        if err != nil {
                if apierrors.IsNotFound(err) {
                        cont.log.Debugf("RDConfig {name: %s, namespace: %s} not found. Creating...", name, ns)
                        /*        spec := rdConfigv1.RdConfigSpec{
                                        DiscoveredSubnets: discoveredSubnets,
                                }
                                err := util.CreateRdConfigCR(*rdConfigClient, spec)
                                if err != nil {
                                        cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)
                                        return true
                                }
                                cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)
                        */
                        if cont.config.ExternFromPod == false {
                                spec := rdConfigv1.RdConfigSpec{
                                        DiscoveredSubnets: discoveredSubnets,
                                }
                                err := util.CreateRdConfigCR(*rdConfigClient, spec)
                                if err != nil {
                                        cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)
                                        return true
                                }
                                cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)
                        } else {

                                prev_usersubnet := rdCon.Spec.UserSubnets

                                var isExternStaticPresent bool = false
                                var isExternDynamicPresent bool = false
                                for _, v := range prev_usersubnet {
                                        if cont.config.ExternStatic == v {
                                                isExternStaticPresent = true
                                        }
                                        if cont.config.ExternDynamic == v {
                                                isExternDynamicPresent = true
                                        }

                                }
                                if isExternStaticPresent == false {
                                        prev_usersubnet = append(prev_usersubnet, cont.config.ExternStatic)
                                }
                                if isExternDynamicPresent == false {
                                        prev_usersubnet = append(prev_usersubnet, cont.config.ExternDynamic)
                                }
                                spec := rdConfigv1.RdConfigSpec{
                                        DiscoveredSubnets: discoveredSubnets,
                                        UserSubnets:       prev_usersubnet,
                                }
                                err := util.CreateRdConfigCR(*rdConfigClient, spec)
                                if err != nil {
                                        cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)
                                        return true
                                }
                                cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)
                        }

                } else {
                        cont.log.Debugf("Unable to get RDConfig: %s, err: %v", name, err)
                }
        } else {
                cont.log.Debugf("Comparing existing rdconfig DiscoveredSubnets with cached values")
                if !reflect.DeepEqual(rdCon.Spec.DiscoveredSubnets, discoveredSubnets) {
                        rdCon.Spec.DiscoveredSubnets = discoveredSubnets
                        _, err = rdConfigClient.AciV1().RdConfigs(ns).Update(context.TODO(), rdCon, metav1.UpdateOptions{})
                        if err != nil {
                                cont.log.Debugf("Unable to Update RDConfig: %s, err: %v", name, err)
                                return true
                        }
                        cont.log.Debug("RdConfig Updated: ", discoveredSubnets)
                }
        }
        return false
}

func RdConfigLogger(log *logrus.Logger, r *rdConfigv1.RdConfig) *logrus.Entry {
        return log.WithFields((logrus.Fields{
                "name":      r.ObjectMeta.Name,
                "namespace": r.ObjectMeta.Namespace,
                "spec":      r.Spec,
        }))
}

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 controller
18
19	import (
20	"context"
21	rdConfigv1 "github.com/noironetworks/aci-containers/pkg/rdconfig/apis/aci.snat/v1"
22	rdconfigclset "github.com/noironetworks/aci-containers/pkg/rdconfig/clientset/versioned"
23	"github.com/noironetworks/aci-containers/pkg/util"
24	"github.com/sirupsen/logrus"
25	apierrors "k8s.io/apimachinery/pkg/api/errors"
26	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
27	"k8s.io/apimachinery/pkg/fields"
28	"k8s.io/apimachinery/pkg/runtime"
29	"k8s.io/apimachinery/pkg/watch"
30	"k8s.io/client-go/tools/cache"
31	"os"
32	"reflect"
33	)
34
35	func (cont *AciController) initRdConfigInformerFromClient(
36	rdConfigClient *rdconfigclset.Clientset) {	×
37	ns := os.Getenv("ACI_SNAT_NAMESPACE")	×
38	name := os.Getenv("ACI_RDCONFIG_NAME")	×
39	cont.initRdConfigInformerBase(	×
40	&cache.ListWatch{	×
41	ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {	×
42	options.FieldSelector = fields.Set{"metadata.name": name}.String()	×
43	obj, err := rdConfigClient.AciV1().RdConfigs(ns).List(context.TODO(), options)	×
44	if err != nil {	×
45	cont.log.Fatalf("Failed to list RdConfigs during initialization of RdConfigInformer with err: %v", err)	×
46	}	×
47	return obj, err	×
48	},
49	WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {	×
50	options.FieldSelector = fields.Set{"metadata.name": name}.String()	×
51	obj, err := rdConfigClient.AciV1().RdConfigs(ns).Watch(context.TODO(), options)	×
52	if err != nil {	×
53	cont.log.Fatalf("Failed to watch RdConfigs during initialization RdConfigsInformer with err: %v", err)	×
54	}	×
55	return obj, err	×
56	},
57	})
58	}
59
60	func (cont AciController) initRdConfigInformerBase(listWatch cache.ListWatch) {	1✔
61	cont.rdConfigIndexer, cont.rdConfigInformer = cache.NewIndexerInformer(	1✔
62	listWatch,	1✔
63	&rdConfigv1.RdConfig{}, 0,	1✔
64	cache.ResourceEventHandlerFuncs{	1✔
65	AddFunc: func(obj interface{}) {	2✔
66	cont.RdConfigAdded(obj)	1✔
67	},	1✔
68	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	1✔
69	cont.RdConfigUpdated(oldobj, newobj)	1✔
70	},	1✔
71	DeleteFunc: func(obj interface{}) {	×
72	cont.RdConfigDeleted(obj)	×
73	},	×
74	},
75	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
76	)
77	cont.log.Debug("Initializing RdConfig Informers")	1✔
78	}
79
80	func (cont *AciController) RdConfigAdded(obj interface{}) {	1✔
81	rdcon := obj.(*rdConfigv1.RdConfig)	1✔
82	rdconkey, err := cache.MetaNamespaceKeyFunc(rdcon)	1✔
83	if err != nil {	1✔
84	RdConfigLogger(cont.log, rdcon).Error("Could not create key:" + err.Error())	×
85	return	×
86	}	×
87	cont.log.Infof("RdConfig: %s added", rdconkey)	1✔
88	cont.indexMutex.Lock()	1✔
89	cont.rdConfigCache[rdcon.ObjectMeta.Name] = rdcon	1✔
90	cont.indexMutex.Unlock()	1✔
91	cont.queueRdConfigUpdateByKey(rdconkey)	1✔
92	}
93
94	func (cont *AciController) RdConfigUpdated(oldobj interface{}, newobj interface{}) {	1✔
95	oldrdcon := oldobj.(*rdConfigv1.RdConfig)	1✔
96	newrdcon := newobj.(*rdConfigv1.RdConfig)	1✔
97	rdconkey, err := cache.MetaNamespaceKeyFunc(newrdcon)	1✔
98	if err != nil {	1✔
99	RdConfigLogger(cont.log, newrdcon).Error("Could not create key:" + err.Error())	×
100	return	×
101	}	×
102	if reflect.DeepEqual(oldrdcon.Spec, newrdcon.Spec) {	1✔
103	return	×
104	}	×
105	cont.log.Infof("Updating RdConfig:%s, from: %v, to: %v", rdconkey, oldrdcon, newrdcon)	1✔
106	cont.indexMutex.Lock()	1✔
107	cont.rdConfigCache[newrdcon.ObjectMeta.Name] = newrdcon	1✔
108	cont.indexMutex.Unlock()	1✔
109	cont.queueRdConfigUpdateByKey(rdconkey)	1✔
110
111	}
112
113	func (cont *AciController) RdConfigDeleted(obj interface{}) {	×
114	rdcon := obj.(*rdConfigv1.RdConfig)	×
115	rdconkey, err := cache.MetaNamespaceKeyFunc(rdcon)	×
116	if err != nil {	×
117	RdConfigLogger(cont.log, rdcon).Error("Could not create key:" + err.Error())	×
118	return	×
119	}	×
120	cont.indexMutex.Lock()	×
121	cont.log.Info("Deleting RdConfig object with name: ", rdcon.ObjectMeta.Name)	×
122	delete(cont.rdConfigCache, rdcon.ObjectMeta.Name)	×
123	cont.indexMutex.Unlock()	×
124	cont.queueRdConfigUpdateByKey(rdconkey)	×
125	}
126
127	func (cont *AciController) queueRdConfigUpdateByKey(key string) {	1✔
128	cont.log.Debug("RdConfig key Queued: ", key)	1✔
129	cont.rdConfigQueue.Add(key)	1✔
130	}	1✔
131
132	func (cont *AciController) postDelHandleRdConfig() bool {	×
133	name := os.Getenv("ACI_RDCONFIG_NAME")	×
134	cont.log.Debugf("RdConfig %s should not be deleted Re-Creating...", name)	×
135	//gatekeeping against before init RdConfig Sync	×
136	if spec, ok := cont.rdConfigSubnetCache[name]; ok {	×
137	err := util.CreateRdConfigCR(cont.env.(K8sEnvironment).rdConfigClient, *spec)	×
138	if err != nil {	×
139	cont.log.Debugf("Unable to RE-Create RDConfig: %s, err: %v, spec: %+v", name, err, spec)	×
140	return true	×
141	}	×
142	cont.log.Debugf("RdConfig: %s RE-Created with spec: %v, Please update this resource and refrain from deleting it.", name, spec)	×
143	}
144	cont.scheduleRdConfig()	×
145	return false	×
146	}
147
148	func (cont AciController) handleRdConfig(rdconfig rdConfigv1.RdConfig) bool {	1✔
149	//store discovered subnets and user subnets in a cache to recreate on delete	1✔
150	cont.log.Debug("handle RdConfig: ", rdconfig)	1✔
151	_, err := cache.MetaNamespaceIndexFunc(rdconfig)	1✔
152	if err != nil {	1✔
153	cont.log.Debugf("Could not create key: %s", err)	×
154	return false	×
155	}	×
156	if spec, ok := cont.rdConfigSubnetCache[rdconfig.ObjectMeta.Name]; ok && reflect.DeepEqual(rdconfig.Spec.UserSubnets, spec.UserSubnets) {	2✔
157	//no update necessary	1✔
158	return false	1✔
159	} else {	2✔
160	cont.indexMutex.Lock()	1✔
161	cont.rdConfigSubnetCache[rdconfig.ObjectMeta.Name] = &rdconfig.Spec	1✔
162	cont.indexMutex.Unlock()	1✔
163	}	1✔
164	return true	1✔
165	}
166
167	func (cont *AciController) syncRdConfig() bool {	×
168	cont.log.Debug("Syncing RdConfig")	×
169	var options metav1.GetOptions	×
170	var discoveredSubnets []string	×
171	cont.indexMutex.Lock()	×
172	for _, v := range cont.apicConn.CachedSubnetDns {	×
173	discoveredSubnets = append(discoveredSubnets, v)	×
174	}	×
175	cont.indexMutex.Unlock()	×
176	env := cont.env.(*K8sEnvironment)	×
177	rdConfigClient := env.rdConfigClient	×
178	if rdConfigClient == nil {	×
179	return false	×
180	}	×
181	ns := os.Getenv("ACI_SNAT_NAMESPACE")	×
182	name := os.Getenv("ACI_RDCONFIG_NAME")	×
183	rdCon, err := rdConfigClient.AciV1().RdConfigs(ns).Get(context.TODO(), name, options)	×
184	if err != nil {	×
185	if apierrors.IsNotFound(err) {	×
186	cont.log.Debugf("RDConfig {name: %s, namespace: %s} not found. Creating...", name, ns)	×
187	/* spec := rdConfigv1.RdConfigSpec{	×
188	DiscoveredSubnets: discoveredSubnets,	×
189	}	×
190	err := util.CreateRdConfigCR(*rdConfigClient, spec)	×
191	if err != nil {	×
192	cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)	×
193	return true	×
194	}	×
195	cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)	×
196	*/	×
197	if cont.config.ExternFromPod == false {	×
198	spec := rdConfigv1.RdConfigSpec{	×
199	DiscoveredSubnets: discoveredSubnets,	×
200	}	×
201	err := util.CreateRdConfigCR(*rdConfigClient, spec)	×
202	if err != nil {	×
203	cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)	×
204	return true	×
205	}	×
206	cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)	×
207	} else {	×
208		×
209	prev_usersubnet := rdCon.Spec.UserSubnets	×
210		×
211	var isExternStaticPresent bool = false	×
212	var isExternDynamicPresent bool = false	×
213	for _, v := range prev_usersubnet {	×
214	if cont.config.ExternStatic == v {	×
215	isExternStaticPresent = true	×
216	}	×
217	if cont.config.ExternDynamic == v {	×
218	isExternDynamicPresent = true	×
219	}	×
220
221	}
222	if isExternStaticPresent == false {	×
223	prev_usersubnet = append(prev_usersubnet, cont.config.ExternStatic)	×
224	}	×
225	if isExternDynamicPresent == false {	×
226	prev_usersubnet = append(prev_usersubnet, cont.config.ExternDynamic)	×
227	}	×
228	spec := rdConfigv1.RdConfigSpec{	×
229	DiscoveredSubnets: discoveredSubnets,	×
230	UserSubnets: prev_usersubnet,	×
231	}	×
232	err := util.CreateRdConfigCR(*rdConfigClient, spec)	×
233	if err != nil {	×
234	cont.log.Debugf("Unable to create RDConfig: %s, err: %v, spec: %+v", name, err, spec)	×
235	return true	×
236	}	×
237	cont.log.Debugf("RdConfig: %s Created with spec: %v", name, spec)	×
238	}
239
240	} else {	×
241	cont.log.Debugf("Unable to get RDConfig: %s, err: %v", name, err)	×
242	}	×
243	} else {	×
244	cont.log.Debugf("Comparing existing rdconfig DiscoveredSubnets with cached values")	×
245	if !reflect.DeepEqual(rdCon.Spec.DiscoveredSubnets, discoveredSubnets) {	×
246	rdCon.Spec.DiscoveredSubnets = discoveredSubnets	×
247	_, err = rdConfigClient.AciV1().RdConfigs(ns).Update(context.TODO(), rdCon, metav1.UpdateOptions{})	×
248	if err != nil {	×
249	cont.log.Debugf("Unable to Update RDConfig: %s, err: %v", name, err)	×
250	return true	×
251	}	×
252	cont.log.Debug("RdConfig Updated: ", discoveredSubnets)	×
253	}
254	}
255	return false	×
256	}
257
258	func RdConfigLogger(log logrus.Logger, r rdConfigv1.RdConfig) *logrus.Entry {	×
259	return log.WithFields((logrus.Fields{	×
260	"name": r.ObjectMeta.Name,	×
261	"namespace": r.ObjectMeta.Namespace,	×
262	"spec": r.Spec,	×
263	}))	×
264	}	×

noironetworks / aci-containers / 6813

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