7001

Committed 04 Jan 2023 04:53AM UTC coverage: 56.607%. First build

Build # 7001

Build Type

push

travis-ci-com

Committed by

akhilamohanan

Commit Message

hpp optimization

* networkpolicy with same spec points to same hpp Mo
* name of hpp is hash of spec of networkpolicy

(cherry picked from commit 25a9627fa)

Run Details

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

11866 of 20962 relevant lines covered (56.61%)

0.63 hits per line

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

38.5

/pkg/hostagent/pod_relatives.go

// Copyright 2018 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.

// Handlers for namespace updates.  Keeps an index of namespace
// annotations

package hostagent

import (
        "reflect"

        "github.com/noironetworks/aci-containers/pkg/index"
        qospolicy "github.com/noironetworks/aci-containers/pkg/qospolicy/apis/aci.qos/v1"
        qospolicyclset "github.com/noironetworks/aci-containers/pkg/qospolicy/clientset/versioned"
        "github.com/sirupsen/logrus"
        appsv1 "k8s.io/api/apps/v1"
        v1 "k8s.io/api/core/v1"
        v1net "k8s.io/api/networking/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/tools/cache"
        "k8s.io/kubernetes/pkg/controller"
)

func (agent *HostAgent) initNamespaceInformerFromClient(
        kubeClient kubernetes.Interface) {

        agent.initNamespaceInformerBase(
                cache.NewListWatchFromClient(
                        kubeClient.CoreV1().RESTClient(), "namespaces",
                        metav1.NamespaceAll, fields.Everything()))
}

func (agent *HostAgent) initNamespaceInformerBase(listWatch *cache.ListWatch) {
        agent.nsInformer = cache.NewSharedIndexInformer(
                listWatch, &v1.Namespace{}, controller.NoResyncPeriodFunc(),
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )

        agent.nsInformer.AddEventHandler(
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                agent.namespaceAdded(obj)
                        },
                        UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                                agent.namespaceChanged(oldobj, newobj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                agent.namespaceDeleted(obj)
                        },
                })
}

func (agent *HostAgent) updatePodsForNamespace(ns string) {
        cache.ListAllByNamespace(agent.podInformer.GetIndexer(), ns, labels.Everything(),
                func(podobj interface{}) {
                        pod := podobj.(*v1.Pod)
                        if pod.Spec.NodeName == agent.config.NodeName {
                                agent.podUpdated(pod)
                        }
                })
}

func (agent *HostAgent) namespaceAdded(obj interface{}) {
        ns := obj.(*v1.Namespace)
        agent.log.Infof("Namespace %+v added", ns)
        agent.netPolPods.UpdateNamespace(ns)
        agent.updatePodsForNamespace(ns.ObjectMeta.Name)
        agent.handleObjectUpdateForSnat(obj)
}

func (agent *HostAgent) namespaceChanged(oldobj interface{},
        newobj interface{}) {

        oldns := oldobj.(*v1.Namespace)
        newns := newobj.(*v1.Namespace)
        agent.log.Infof("Namespace %+v changed", oldns)

        if !reflect.DeepEqual(oldns.ObjectMeta.Labels, newns.ObjectMeta.Labels) {
                agent.netPolPods.UpdateNamespace(newns)
                agent.handleObjectUpdateForSnat(newobj)
        }
        if !reflect.DeepEqual(oldns.ObjectMeta.Annotations,
                newns.ObjectMeta.Annotations) {
                agent.updatePodsForNamespace(newns.ObjectMeta.Name)
        }
}

func (agent *HostAgent) namespaceDeleted(obj interface{}) {
        ns := obj.(*v1.Namespace)
        agent.handleObjectDeleteForSnat(obj)
        agent.netPolPods.DeleteNamespace(ns)
        agent.log.Infof("Namespace %+v deleted", ns)
}

func (agent *HostAgent) initNetworkPolicyInformerFromClient(
        kubeClient kubernetes.Interface) {

        agent.initNetworkPolicyInformerBase(
                cache.NewListWatchFromClient(
                        kubeClient.NetworkingV1().RESTClient(), "networkpolicies",
                        metav1.NamespaceAll, fields.Everything()))
}

func (agent *HostAgent) initNetworkPolicyInformerBase(listWatch *cache.ListWatch) {
        agent.netPolInformer =
                cache.NewSharedIndexInformer(
                        listWatch, &v1net.NetworkPolicy{}, 0,
                        cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
                )

        agent.netPolInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
                AddFunc: func(obj interface{}) {
                        agent.networkPolicyAdded(obj)
                },
                UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                        agent.networkPolicyChanged(oldobj, newobj)
                },
                DeleteFunc: func(obj interface{}) {
                        agent.networkPolicyDeleted(obj)
                },
        },
        )
}

func (agent *HostAgent) networkPolicyAdded(obj interface{}) {
        np := obj.(*v1net.NetworkPolicy)
        agent.netPolPods.UpdateSelectorObj(obj)
        agent.log.Infof("Network policy added: %s", np.ObjectMeta.Name)
}

func (agent *HostAgent) networkPolicyChanged(oldobj, newobj interface{}) {
        oldnp := oldobj.(*v1net.NetworkPolicy)
        newnp := newobj.(*v1net.NetworkPolicy)
        agent.log.Infof("Network policy changed: %s", oldnp.ObjectMeta.Name)
        if !reflect.DeepEqual(oldnp.Spec.PodSelector, newnp.Spec.PodSelector) {
                agent.netPolPods.UpdateSelectorObjNoCallback(newobj)
        }

        npkey, err := cache.MetaNamespaceKeyFunc(newnp)
        if err != nil {
                logrus.Error("Could not create network policy key: ", err)
                return
        }

        if !reflect.DeepEqual(oldnp.Spec, newnp.Spec) {
                peerPodKeys := agent.netPolPods.GetPodForObj(npkey)
                for _, podkey := range peerPodKeys {
                        agent.podChanged(&podkey)
                }
        }
}

func (agent *HostAgent) networkPolicyDeleted(obj interface{}) {
        np := obj.(*v1net.NetworkPolicy)
        agent.netPolPods.DeleteSelectorObj(obj)
        agent.log.Infof("Network policy deleted: %s", np.ObjectMeta.Name)
}

func (agent *HostAgent) initNetPolPodIndex() {
        agent.netPolPods = index.NewPodSelectorIndex(
                agent.log,
                agent.podInformer.GetIndexer(), agent.nsInformer.GetIndexer(), agent.netPolInformer.GetIndexer(),
                cache.MetaNamespaceKeyFunc,
                func(obj interface{}) []index.PodSelector {
                        np := obj.(*v1net.NetworkPolicy)
                        return index.PodSelectorFromNsAndSelector(np.ObjectMeta.Namespace,
                                &np.Spec.PodSelector)
                },
        )
        agent.netPolPods.SetPodUpdateCallback(func(podkey string) {
                podobj, exists, err := agent.podInformer.GetIndexer().GetByKey(podkey)
                if exists && err == nil {
                        agent.podUpdated(podobj.(*v1.Pod))
                }
        })
}

func (agent *HostAgent) initQoSPolicyInformerFromClient(
        qosClient *qospolicyclset.Clientset) {
        agent.initQoSPolicyInformerBase(
                cache.NewListWatchFromClient(
                        qosClient.AciV1().RESTClient(), "qospolicies",
                        metav1.NamespaceAll, fields.Everything()))
}

func (agent *HostAgent) initQoSPolicyInformerBase(listWatch *cache.ListWatch) {
        agent.qosPolicyInformer =
                cache.NewSharedIndexInformer(
                        listWatch, &qospolicy.QosPolicy{}, 0,
                        cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
                )

        agent.qosPolicyInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
                AddFunc: func(obj interface{}) {
                        agent.qosPolicyAdded(obj)
                },
                UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                        agent.qosPolicyChanged(oldobj, newobj)
                },
                DeleteFunc: func(obj interface{}) {
                        agent.qosPolicyDeleted(obj)
                },
        },
        )
}

func (agent *HostAgent) qosPolicyAdded(obj interface{}) {
        qp := obj.(*qospolicy.QosPolicy)
        agent.qosPolPods.UpdateSelectorObj(obj)
        agent.log.Infof("qos policy added: %s", qp.ObjectMeta.Name)

}

func (agent *HostAgent) qosPolicyChanged(oldobj, newobj interface{}) {
        oldqp := oldobj.(*qospolicy.QosPolicy)
        newqp := newobj.(*qospolicy.QosPolicy)
        agent.log.Infof("qos policy changed: %s", oldqp.ObjectMeta.Name)
        if !reflect.DeepEqual(oldqp.Spec.Selector, newqp.Spec.Selector) {
                agent.qosPolPods.UpdateSelectorObjNoCallback(newobj)
        }

        qpkey, err := cache.MetaNamespaceKeyFunc(newqp)
        if err != nil {
                logrus.Error("Could not create qos policy key: ", err)
                return
        }

        if !reflect.DeepEqual(oldqp.Spec.Ingress, newqp.Spec.Ingress) {
                peerPodKeys := agent.qosPolPods.GetPodForObj(qpkey)
                for _, podkey := range peerPodKeys {
                        agent.podChanged(&podkey)
                }
        }
        if !reflect.DeepEqual(oldqp.Spec.Egress, newqp.Spec.Egress) {
                peerPodKeys := agent.qosPolPods.GetPodForObj(qpkey)
                for _, podkey := range peerPodKeys {
                        agent.podChanged(&podkey)
                }
        }
}

func (agent *HostAgent) qosPolicyDeleted(obj interface{}) {
        qp := obj.(*qospolicy.QosPolicy)
        agent.qosPolPods.DeleteSelectorObj(obj)
        agent.log.Infof("qos policy deleted: %s", qp.ObjectMeta.Name)
}

func (agent *HostAgent) initQoSPolPodIndex() {
        agent.qosPolPods = index.NewPodSelectorIndex(
                agent.log,
                agent.podInformer.GetIndexer(), agent.nsInformer.GetIndexer(), agent.qosPolicyInformer.GetIndexer(),
                cache.MetaNamespaceKeyFunc,
                func(obj interface{}) []index.PodSelector {
                        qp := obj.(*qospolicy.QosPolicy)
                        ls := &metav1.LabelSelector{MatchLabels: qp.Spec.Selector.Labels}
                        return index.PodSelectorFromNsAndSelector(qp.ObjectMeta.Namespace,
                                ls)
                },
        )
        agent.qosPolPods.SetPodUpdateCallback(func(podkey string) {
                podobj, exists, err := agent.podInformer.GetIndexer().GetByKey(podkey)
                if exists && err == nil {
                        agent.podUpdated(podobj.(*v1.Pod))
                }
        })
}

func (agent *HostAgent) initDeploymentInformerFromClient(
        kubeClient kubernetes.Interface) {

        agent.initDeploymentInformerBase(
                cache.NewListWatchFromClient(
                        kubeClient.AppsV1().RESTClient(), "deployments",
                        metav1.NamespaceAll, fields.Everything()))
}

func (agent *HostAgent) initDeploymentInformerBase(listWatch *cache.ListWatch) {
        agent.depInformer = cache.NewSharedIndexInformer(
                listWatch, &appsv1.Deployment{}, controller.NoResyncPeriodFunc(),
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )

        agent.depInformer.AddEventHandler(
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                agent.deploymentAdded(obj)
                        },
                        UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                                agent.deploymentChanged(oldobj, newobj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                agent.deploymentDeleted(obj)
                        },
                })
}

func (agent *HostAgent) initDepPodIndex() {
        agent.depPods = index.NewPodSelectorIndex(agent.log,
                agent.podInformer.GetIndexer(),
                agent.nsInformer.GetIndexer(),
                agent.depInformer.GetIndexer(),
                cache.MetaNamespaceKeyFunc,
                func(obj interface{}) []index.PodSelector {
                        dep := obj.(*appsv1.Deployment)
                        return index.PodSelectorFromNsAndSelector(dep.ObjectMeta.Namespace,
                                dep.Spec.Selector)
                },
        )
        agent.depPods.SetPodUpdateCallback(func(podkey string) {
                agent.podChangedPostLock(&podkey)
        })
}

func deploymentLogger(log *logrus.Logger, dep *appsv1.Deployment) *logrus.Entry {
        return log.WithFields(logrus.Fields{
                "namespace": dep.ObjectMeta.Namespace,
                "name":      dep.ObjectMeta.Name,
        })
}

func (agent *HostAgent) deploymentAdded(obj interface{}) {
        depObj := obj.(*appsv1.Deployment)
        deploymentLogger(agent.log, depObj).Info("Deployment added:")
        agent.indexMutex.Lock()
        defer agent.indexMutex.Unlock()
        agent.depPods.UpdateSelectorObj(obj)
        agent.handleObjectUpdateForSnat(obj)
}

// deploymentChanged - callback for deployment change. Trigger pod update
// in order to handle any changes to annotations, also keep the indexer
// in sync
func (agent *HostAgent) deploymentChanged(oldobj interface{},
        newobj interface{}) {

        olddep := oldobj.(*appsv1.Deployment)
        newdep := newobj.(*appsv1.Deployment)
        deploymentLogger(agent.log, olddep).Info("Deployment changed:")
        if !reflect.DeepEqual(olddep.Spec.Selector, newdep.Spec.Selector) {
                agent.indexMutex.Lock()
                agent.depPods.UpdateSelectorObj(newobj)
                agent.indexMutex.Unlock()
        }
        if !reflect.DeepEqual(olddep.ObjectMeta.Annotations,
                newdep.ObjectMeta.Annotations) {
                depkey, err :=
                        cache.MetaNamespaceKeyFunc(newdep)
                if err != nil {
                        deploymentLogger(agent.log, newdep).
                                Error("Could not create key: ", err)
                        return
                }
                for _, podkey := range agent.depPods.GetPodForObj(depkey) {
                        agent.podChanged(&podkey)
                }
        }
        if !reflect.DeepEqual(olddep.ObjectMeta.Labels,
                newdep.ObjectMeta.Labels) {
                agent.handleObjectUpdateForSnat(newdep)
        }
}

func (agent *HostAgent) deploymentDeleted(obj interface{}) {
        depObj := obj.(*appsv1.Deployment)
        agent.handleObjectDeleteForSnat(obj)
        agent.indexMutex.Lock()
        agent.depPods.DeleteSelectorObj(obj)
        agent.indexMutex.Unlock()
        deploymentLogger(agent.log, depObj).Info("Deployment deleted:")
}

func (agent *HostAgent) initRCInformerFromClient(
        kubeClient kubernetes.Interface) {

        agent.initRCInformerBase(
                cache.NewListWatchFromClient(
                        kubeClient.CoreV1().RESTClient(), "replicationcontrollers",
                        metav1.NamespaceAll, fields.Everything()))
}

func (agent *HostAgent) initRCInformerBase(listWatch *cache.ListWatch) {
        agent.rcInformer = cache.NewSharedIndexInformer(
                listWatch, &v1.ReplicationController{}, controller.NoResyncPeriodFunc(),
                cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
        )

        agent.rcInformer.AddEventHandler(
                cache.ResourceEventHandlerFuncs{
                        AddFunc: func(obj interface{}) {
                                agent.rcAdded(obj)
                        },
                        UpdateFunc: func(oldobj interface{}, newobj interface{}) {
                                agent.rcChanged(oldobj, newobj)
                        },
                        DeleteFunc: func(obj interface{}) {
                                agent.rcDeleted(obj)
                        },
                })
}

func (agent *HostAgent) initRCPodIndex() {
        agent.rcPods = index.NewPodSelectorIndex(agent.log,
                agent.podInformer.GetIndexer(),
                agent.nsInformer.GetIndexer(),
                agent.rcInformer.GetIndexer(),
                cache.MetaNamespaceKeyFunc,
                func(obj interface{}) []index.PodSelector {
                        rc := obj.(*v1.ReplicationController)
                        labels := rc.Spec.Selector
                        if len(labels) == 0 {
                                agent.log.Infof("RC %s/%s has no selector. Using template", rc.ObjectMeta.Namespace, rc.ObjectMeta.Name)
                                labels = rc.Spec.Template.Labels
                        }
                        ls := &metav1.LabelSelector{MatchLabels: labels}
                        return index.PodSelectorFromNsAndSelector(rc.ObjectMeta.Namespace, ls)
                },
        )
        agent.rcPods.SetPodUpdateCallback(func(podkey string) {
                agent.podChanged(&podkey)
        })
}

func rcLogger(log *logrus.Logger, rc *v1.ReplicationController) *logrus.Entry {
        return log.WithFields(logrus.Fields{
                "namespace": rc.ObjectMeta.Namespace,
                "name":      rc.ObjectMeta.Name,
        })
}

func (agent *HostAgent) rcAdded(obj interface{}) {
        rc := obj.(*v1.ReplicationController)
        rcLogger(agent.log, rc).Info("rcAdded:")
        agent.rcPods.UpdateSelectorObj(obj)
}

// rcChanged - callback for replicationController change. Trigger pod update
// in order to handle any changes to annotations, also keep the indexer
// in sync
func (agent *HostAgent) rcChanged(oldobj interface{},
        newobj interface{}) {

        oldrc := oldobj.(*v1.ReplicationController)
        newrc := newobj.(*v1.ReplicationController)
        rcLogger(agent.log, oldrc).Info("rcChanged:")

        if !reflect.DeepEqual(oldrc.Spec.Selector, newrc.Spec.Selector) {
                agent.rcPods.UpdateSelectorObj(newobj)
        }
        if !reflect.DeepEqual(oldrc.ObjectMeta.Annotations,
                newrc.ObjectMeta.Annotations) {
                rckey, err :=
                        cache.MetaNamespaceKeyFunc(newrc)
                if err != nil {
                        rcLogger(agent.log, newrc).
                                Error("Could not create key: ", err)
                        return
                }
                for _, podkey := range agent.rcPods.GetPodForObj(rckey) {
                        agent.podChanged(&podkey)
                }
        }
}

func (agent *HostAgent) rcDeleted(obj interface{}) {
        rc := obj.(*v1.ReplicationController)
        agent.rcPods.DeleteSelectorObj(obj)
        rcLogger(agent.log, rc).Info("rcDeleted:")
}

1	// Copyright 2018 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 implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	// Handlers for namespace updates. Keeps an index of namespace
16	// annotations
17
18	package hostagent
19
20	import (
21	"reflect"
22
23	"github.com/noironetworks/aci-containers/pkg/index"
24	qospolicy "github.com/noironetworks/aci-containers/pkg/qospolicy/apis/aci.qos/v1"
25	qospolicyclset "github.com/noironetworks/aci-containers/pkg/qospolicy/clientset/versioned"
26	"github.com/sirupsen/logrus"
27	appsv1 "k8s.io/api/apps/v1"
28	v1 "k8s.io/api/core/v1"
29	v1net "k8s.io/api/networking/v1"
30	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
31	"k8s.io/apimachinery/pkg/fields"
32	"k8s.io/apimachinery/pkg/labels"
33	"k8s.io/client-go/kubernetes"
34	"k8s.io/client-go/tools/cache"
35	"k8s.io/kubernetes/pkg/controller"
36	)
37
38	func (agent *HostAgent) initNamespaceInformerFromClient(
39	kubeClient kubernetes.Interface) {	×
40		×
41	agent.initNamespaceInformerBase(	×
42	cache.NewListWatchFromClient(	×
43	kubeClient.CoreV1().RESTClient(), "namespaces",	×
44	metav1.NamespaceAll, fields.Everything()))	×
45	}	×
46
47	func (agent HostAgent) initNamespaceInformerBase(listWatch cache.ListWatch) {	1✔
48	agent.nsInformer = cache.NewSharedIndexInformer(	1✔
49	listWatch, &v1.Namespace{}, controller.NoResyncPeriodFunc(),	1✔
50	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
51	)	1✔
52		1✔
53	agent.nsInformer.AddEventHandler(	1✔
54	cache.ResourceEventHandlerFuncs{	1✔
55	AddFunc: func(obj interface{}) {	2✔
56	agent.namespaceAdded(obj)	1✔
57	},	1✔
58	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
59	agent.namespaceChanged(oldobj, newobj)	×
60	},	×
61	DeleteFunc: func(obj interface{}) {	×
62	agent.namespaceDeleted(obj)	×
63	},	×
64	})
65	}
66
67	func (agent *HostAgent) updatePodsForNamespace(ns string) {	1✔
68	cache.ListAllByNamespace(agent.podInformer.GetIndexer(), ns, labels.Everything(),	1✔
69	func(podobj interface{}) {	1✔
70	pod := podobj.(*v1.Pod)	×
71	if pod.Spec.NodeName == agent.config.NodeName {	×
72	agent.podUpdated(pod)	×
73	}	×
74	})
75	}
76
77	func (agent *HostAgent) namespaceAdded(obj interface{}) {	1✔
78	ns := obj.(*v1.Namespace)	1✔
79	agent.log.Infof("Namespace %+v added", ns)	1✔
80	agent.netPolPods.UpdateNamespace(ns)	1✔
81	agent.updatePodsForNamespace(ns.ObjectMeta.Name)	1✔
82	agent.handleObjectUpdateForSnat(obj)	1✔
83	}	1✔
84
85	func (agent *HostAgent) namespaceChanged(oldobj interface{},
86	newobj interface{}) {	×
87		×
88	oldns := oldobj.(*v1.Namespace)	×
89	newns := newobj.(*v1.Namespace)	×
90	agent.log.Infof("Namespace %+v changed", oldns)	×
91		×
92	if !reflect.DeepEqual(oldns.ObjectMeta.Labels, newns.ObjectMeta.Labels) {	×
93	agent.netPolPods.UpdateNamespace(newns)	×
94	agent.handleObjectUpdateForSnat(newobj)	×
95	}	×
96	if !reflect.DeepEqual(oldns.ObjectMeta.Annotations,	×
97	newns.ObjectMeta.Annotations) {	×
98	agent.updatePodsForNamespace(newns.ObjectMeta.Name)	×
99	}	×
100	}
101
102	func (agent *HostAgent) namespaceDeleted(obj interface{}) {	×
103	ns := obj.(*v1.Namespace)	×
104	agent.handleObjectDeleteForSnat(obj)	×
105	agent.netPolPods.DeleteNamespace(ns)	×
106	agent.log.Infof("Namespace %+v deleted", ns)	×
107	}	×
108
109	func (agent *HostAgent) initNetworkPolicyInformerFromClient(
110	kubeClient kubernetes.Interface) {	×
111		×
112	agent.initNetworkPolicyInformerBase(	×
113	cache.NewListWatchFromClient(	×
114	kubeClient.NetworkingV1().RESTClient(), "networkpolicies",	×
115	metav1.NamespaceAll, fields.Everything()))	×
116	}	×
117
118	func (agent HostAgent) initNetworkPolicyInformerBase(listWatch cache.ListWatch) {	1✔
119	agent.netPolInformer =	1✔
120	cache.NewSharedIndexInformer(	1✔
121	listWatch, &v1net.NetworkPolicy{}, 0,	1✔
122	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
123	)	1✔
124		1✔
125	agent.netPolInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{	1✔
126	AddFunc: func(obj interface{}) {	2✔
127	agent.networkPolicyAdded(obj)	1✔
128	},	1✔
129	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
130	agent.networkPolicyChanged(oldobj, newobj)	×
131	},	×
132	DeleteFunc: func(obj interface{}) {	×
133	agent.networkPolicyDeleted(obj)	×
134	},	×
135	},
136	)
137	}
138
139	func (agent *HostAgent) networkPolicyAdded(obj interface{}) {	1✔
140	np := obj.(*v1net.NetworkPolicy)	1✔
141	agent.netPolPods.UpdateSelectorObj(obj)	1✔
142	agent.log.Infof("Network policy added: %s", np.ObjectMeta.Name)	1✔
143	}	1✔
144
145	func (agent *HostAgent) networkPolicyChanged(oldobj, newobj interface{}) {	×
146	oldnp := oldobj.(*v1net.NetworkPolicy)	×
147	newnp := newobj.(*v1net.NetworkPolicy)	×
148	agent.log.Infof("Network policy changed: %s", oldnp.ObjectMeta.Name)	×
149	if !reflect.DeepEqual(oldnp.Spec.PodSelector, newnp.Spec.PodSelector) {	×
150	agent.netPolPods.UpdateSelectorObjNoCallback(newobj)	×
151	}	×
152
153	npkey, err := cache.MetaNamespaceKeyFunc(newnp)	×
154	if err != nil {	×
155	logrus.Error("Could not create network policy key: ", err)	×
156	return	×
157	}	×
158
159	if !reflect.DeepEqual(oldnp.Spec, newnp.Spec) {	×
160	peerPodKeys := agent.netPolPods.GetPodForObj(npkey)	×
161	for _, podkey := range peerPodKeys {	×
162	agent.podChanged(&podkey)	×
163	}	×
164	}
165	}
166
167	func (agent *HostAgent) networkPolicyDeleted(obj interface{}) {	×
168	np := obj.(*v1net.NetworkPolicy)	×
169	agent.netPolPods.DeleteSelectorObj(obj)	×
170	agent.log.Infof("Network policy deleted: %s", np.ObjectMeta.Name)	×
171	}	×
172
173	func (agent *HostAgent) initNetPolPodIndex() {	1✔
174	agent.netPolPods = index.NewPodSelectorIndex(	1✔
175	agent.log,	1✔
176	agent.podInformer.GetIndexer(), agent.nsInformer.GetIndexer(), agent.netPolInformer.GetIndexer(),	1✔
177	cache.MetaNamespaceKeyFunc,	1✔
178	func(obj interface{}) []index.PodSelector {	2✔
179	np := obj.(*v1net.NetworkPolicy)	1✔
180	return index.PodSelectorFromNsAndSelector(np.ObjectMeta.Namespace,	1✔
181	&np.Spec.PodSelector)	1✔
182	},	1✔
183	)
184	agent.netPolPods.SetPodUpdateCallback(func(podkey string) {	1✔
185	podobj, exists, err := agent.podInformer.GetIndexer().GetByKey(podkey)	×
186	if exists && err == nil {	×
187	agent.podUpdated(podobj.(*v1.Pod))	×
188	}	×
189	})
190	}
191
192	func (agent *HostAgent) initQoSPolicyInformerFromClient(
193	qosClient *qospolicyclset.Clientset) {	×
194	agent.initQoSPolicyInformerBase(	×
195	cache.NewListWatchFromClient(	×
196	qosClient.AciV1().RESTClient(), "qospolicies",	×
197	metav1.NamespaceAll, fields.Everything()))	×
198	}	×
199
200	func (agent HostAgent) initQoSPolicyInformerBase(listWatch cache.ListWatch) {	1✔
201	agent.qosPolicyInformer =	1✔
202	cache.NewSharedIndexInformer(	1✔
203	listWatch, &qospolicy.QosPolicy{}, 0,	1✔
204	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
205	)	1✔
206		1✔
207	agent.qosPolicyInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{	1✔
208	AddFunc: func(obj interface{}) {	1✔
209	agent.qosPolicyAdded(obj)	×
210	},	×
211	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
212	agent.qosPolicyChanged(oldobj, newobj)	×
213	},	×
214	DeleteFunc: func(obj interface{}) {	×
215	agent.qosPolicyDeleted(obj)	×
216	},	×
217	},
218	)
219	}
220
221	func (agent *HostAgent) qosPolicyAdded(obj interface{}) {	×
222	qp := obj.(*qospolicy.QosPolicy)	×
223	agent.qosPolPods.UpdateSelectorObj(obj)	×
224	agent.log.Infof("qos policy added: %s", qp.ObjectMeta.Name)	×
225		×
226	}	×
227
228	func (agent *HostAgent) qosPolicyChanged(oldobj, newobj interface{}) {	×
229	oldqp := oldobj.(*qospolicy.QosPolicy)	×
230	newqp := newobj.(*qospolicy.QosPolicy)	×
231	agent.log.Infof("qos policy changed: %s", oldqp.ObjectMeta.Name)	×
232	if !reflect.DeepEqual(oldqp.Spec.Selector, newqp.Spec.Selector) {	×
233	agent.qosPolPods.UpdateSelectorObjNoCallback(newobj)	×
234	}	×
235
236	qpkey, err := cache.MetaNamespaceKeyFunc(newqp)	×
237	if err != nil {	×
238	logrus.Error("Could not create qos policy key: ", err)	×
239	return	×
240	}	×
241
242	if !reflect.DeepEqual(oldqp.Spec.Ingress, newqp.Spec.Ingress) {	×
243	peerPodKeys := agent.qosPolPods.GetPodForObj(qpkey)	×
244	for _, podkey := range peerPodKeys {	×
245	agent.podChanged(&podkey)	×
246	}	×
247	}
248	if !reflect.DeepEqual(oldqp.Spec.Egress, newqp.Spec.Egress) {	×
249	peerPodKeys := agent.qosPolPods.GetPodForObj(qpkey)	×
250	for _, podkey := range peerPodKeys {	×
251	agent.podChanged(&podkey)	×
252	}	×
253	}
254	}
255
256	func (agent *HostAgent) qosPolicyDeleted(obj interface{}) {	×
257	qp := obj.(*qospolicy.QosPolicy)	×
258	agent.qosPolPods.DeleteSelectorObj(obj)	×
259	agent.log.Infof("qos policy deleted: %s", qp.ObjectMeta.Name)	×
260	}	×
261
262	func (agent *HostAgent) initQoSPolPodIndex() {	1✔
263	agent.qosPolPods = index.NewPodSelectorIndex(	1✔
264	agent.log,	1✔
265	agent.podInformer.GetIndexer(), agent.nsInformer.GetIndexer(), agent.qosPolicyInformer.GetIndexer(),	1✔
266	cache.MetaNamespaceKeyFunc,	1✔
267	func(obj interface{}) []index.PodSelector {	1✔
268	qp := obj.(*qospolicy.QosPolicy)	×
269	ls := &metav1.LabelSelector{MatchLabels: qp.Spec.Selector.Labels}	×
270	return index.PodSelectorFromNsAndSelector(qp.ObjectMeta.Namespace,	×
271	ls)	×
272	},	×
273	)
274	agent.qosPolPods.SetPodUpdateCallback(func(podkey string) {	1✔
275	podobj, exists, err := agent.podInformer.GetIndexer().GetByKey(podkey)	×
276	if exists && err == nil {	×
277	agent.podUpdated(podobj.(*v1.Pod))	×
278	}	×
279	})
280	}
281
282	func (agent *HostAgent) initDeploymentInformerFromClient(
283	kubeClient kubernetes.Interface) {	×
284		×
285	agent.initDeploymentInformerBase(	×
286	cache.NewListWatchFromClient(	×
287	kubeClient.AppsV1().RESTClient(), "deployments",	×
288	metav1.NamespaceAll, fields.Everything()))	×
289	}	×
290
291	func (agent HostAgent) initDeploymentInformerBase(listWatch cache.ListWatch) {	1✔
292	agent.depInformer = cache.NewSharedIndexInformer(	1✔
293	listWatch, &appsv1.Deployment{}, controller.NoResyncPeriodFunc(),	1✔
294	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
295	)	1✔
296		1✔
297	agent.depInformer.AddEventHandler(	1✔
298	cache.ResourceEventHandlerFuncs{	1✔
299	AddFunc: func(obj interface{}) {	2✔
300	agent.deploymentAdded(obj)	1✔
301	},	1✔
302	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
303	agent.deploymentChanged(oldobj, newobj)	×
304	},	×
305	DeleteFunc: func(obj interface{}) {	×
306	agent.deploymentDeleted(obj)	×
307	},	×
308	})
309	}
310
311	func (agent *HostAgent) initDepPodIndex() {	1✔
312	agent.depPods = index.NewPodSelectorIndex(agent.log,	1✔
313	agent.podInformer.GetIndexer(),	1✔
314	agent.nsInformer.GetIndexer(),	1✔
315	agent.depInformer.GetIndexer(),	1✔
316	cache.MetaNamespaceKeyFunc,	1✔
317	func(obj interface{}) []index.PodSelector {	2✔
318	dep := obj.(*appsv1.Deployment)	1✔
319	return index.PodSelectorFromNsAndSelector(dep.ObjectMeta.Namespace,	1✔
320	dep.Spec.Selector)	1✔
321	},	1✔
322	)
323	agent.depPods.SetPodUpdateCallback(func(podkey string) {	1✔
324	agent.podChangedPostLock(&podkey)	×
325	})	×
326	}
327
328	func deploymentLogger(log logrus.Logger, dep appsv1.Deployment) *logrus.Entry {	1✔
329	return log.WithFields(logrus.Fields{	1✔
330	"namespace": dep.ObjectMeta.Namespace,	1✔
331	"name": dep.ObjectMeta.Name,	1✔
332	})	1✔
333	}	1✔
334
335	func (agent *HostAgent) deploymentAdded(obj interface{}) {	1✔
336	depObj := obj.(*appsv1.Deployment)	1✔
337	deploymentLogger(agent.log, depObj).Info("Deployment added:")	1✔
338	agent.indexMutex.Lock()	1✔
339	defer agent.indexMutex.Unlock()	1✔
340	agent.depPods.UpdateSelectorObj(obj)	1✔
341	agent.handleObjectUpdateForSnat(obj)	1✔
342	}	1✔
343
344	// deploymentChanged - callback for deployment change. Trigger pod update
345	// in order to handle any changes to annotations, also keep the indexer
346	// in sync
347	func (agent *HostAgent) deploymentChanged(oldobj interface{},
348	newobj interface{}) {	×
349		×
350	olddep := oldobj.(*appsv1.Deployment)	×
351	newdep := newobj.(*appsv1.Deployment)	×
352	deploymentLogger(agent.log, olddep).Info("Deployment changed:")	×
353	if !reflect.DeepEqual(olddep.Spec.Selector, newdep.Spec.Selector) {	×
354	agent.indexMutex.Lock()	×
355	agent.depPods.UpdateSelectorObj(newobj)	×
356	agent.indexMutex.Unlock()	×
357	}	×
358	if !reflect.DeepEqual(olddep.ObjectMeta.Annotations,	×
359	newdep.ObjectMeta.Annotations) {	×
360	depkey, err :=	×
361	cache.MetaNamespaceKeyFunc(newdep)	×
362	if err != nil {	×
363	deploymentLogger(agent.log, newdep).	×
364	Error("Could not create key: ", err)	×
365	return	×
366	}	×
367	for _, podkey := range agent.depPods.GetPodForObj(depkey) {	×
368	agent.podChanged(&podkey)	×
369	}	×
370	}
371	if !reflect.DeepEqual(olddep.ObjectMeta.Labels,	×
372	newdep.ObjectMeta.Labels) {	×
373	agent.handleObjectUpdateForSnat(newdep)	×
374	}	×
375	}
376
377	func (agent *HostAgent) deploymentDeleted(obj interface{}) {	×
378	depObj := obj.(*appsv1.Deployment)	×
379	agent.handleObjectDeleteForSnat(obj)	×
380	agent.indexMutex.Lock()	×
381	agent.depPods.DeleteSelectorObj(obj)	×
382	agent.indexMutex.Unlock()	×
383	deploymentLogger(agent.log, depObj).Info("Deployment deleted:")	×
384	}	×
385
386	func (agent *HostAgent) initRCInformerFromClient(
387	kubeClient kubernetes.Interface) {	×
388		×
389	agent.initRCInformerBase(	×
390	cache.NewListWatchFromClient(	×
391	kubeClient.CoreV1().RESTClient(), "replicationcontrollers",	×
392	metav1.NamespaceAll, fields.Everything()))	×
393	}	×
394
395	func (agent HostAgent) initRCInformerBase(listWatch cache.ListWatch) {	1✔
396	agent.rcInformer = cache.NewSharedIndexInformer(	1✔
397	listWatch, &v1.ReplicationController{}, controller.NoResyncPeriodFunc(),	1✔
398	cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},	1✔
399	)	1✔
400		1✔
401	agent.rcInformer.AddEventHandler(	1✔
402	cache.ResourceEventHandlerFuncs{	1✔
403	AddFunc: func(obj interface{}) {	2✔
404	agent.rcAdded(obj)	1✔
405	},	1✔
406	UpdateFunc: func(oldobj interface{}, newobj interface{}) {	×
407	agent.rcChanged(oldobj, newobj)	×
408	},	×
409	DeleteFunc: func(obj interface{}) {	×
410	agent.rcDeleted(obj)	×
411	},	×
412	})
413	}
414
415	func (agent *HostAgent) initRCPodIndex() {	1✔
416	agent.rcPods = index.NewPodSelectorIndex(agent.log,	1✔
417	agent.podInformer.GetIndexer(),	1✔
418	agent.nsInformer.GetIndexer(),	1✔
419	agent.rcInformer.GetIndexer(),	1✔
420	cache.MetaNamespaceKeyFunc,	1✔
421	func(obj interface{}) []index.PodSelector {	2✔
422	rc := obj.(*v1.ReplicationController)	1✔
423	labels := rc.Spec.Selector	1✔
424	if len(labels) == 0 {	2✔
425	agent.log.Infof("RC %s/%s has no selector. Using template", rc.ObjectMeta.Namespace, rc.ObjectMeta.Name)	1✔
426	labels = rc.Spec.Template.Labels	1✔
427	}	1✔
428	ls := &metav1.LabelSelector{MatchLabels: labels}	1✔
429	return index.PodSelectorFromNsAndSelector(rc.ObjectMeta.Namespace, ls)	1✔
430	},
431	)
432	agent.rcPods.SetPodUpdateCallback(func(podkey string) {	1✔
433	agent.podChanged(&podkey)	×
434	})	×
435	}
436
437	func rcLogger(log logrus.Logger, rc v1.ReplicationController) *logrus.Entry {	1✔
438	return log.WithFields(logrus.Fields{	1✔
439	"namespace": rc.ObjectMeta.Namespace,	1✔
440	"name": rc.ObjectMeta.Name,	1✔
441	})	1✔
442	}	1✔
443
444	func (agent *HostAgent) rcAdded(obj interface{}) {	1✔
445	rc := obj.(*v1.ReplicationController)	1✔
446	rcLogger(agent.log, rc).Info("rcAdded:")	1✔
447	agent.rcPods.UpdateSelectorObj(obj)	1✔
448	}	1✔
449
450	// rcChanged - callback for replicationController change. Trigger pod update
451	// in order to handle any changes to annotations, also keep the indexer
452	// in sync
453	func (agent *HostAgent) rcChanged(oldobj interface{},
454	newobj interface{}) {	×
455		×
456	oldrc := oldobj.(*v1.ReplicationController)	×
457	newrc := newobj.(*v1.ReplicationController)	×
458	rcLogger(agent.log, oldrc).Info("rcChanged:")	×
459		×
460	if !reflect.DeepEqual(oldrc.Spec.Selector, newrc.Spec.Selector) {	×
461	agent.rcPods.UpdateSelectorObj(newobj)	×
462	}	×
463	if !reflect.DeepEqual(oldrc.ObjectMeta.Annotations,	×
464	newrc.ObjectMeta.Annotations) {	×
465	rckey, err :=	×
466	cache.MetaNamespaceKeyFunc(newrc)	×
467	if err != nil {	×
468	rcLogger(agent.log, newrc).	×
469	Error("Could not create key: ", err)	×
470	return	×
471	}	×
472	for _, podkey := range agent.rcPods.GetPodForObj(rckey) {	×
473	agent.podChanged(&podkey)	×
474	}	×
475	}
476	}
477
478	func (agent *HostAgent) rcDeleted(obj interface{}) {	×
479	rc := obj.(*v1.ReplicationController)	×
480	agent.rcPods.DeleteSelectorObj(obj)	×
481	rcLogger(agent.log, rc).Info("rcDeleted:")	×
482	}	×

noironetworks / aci-containers / 7001

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