6301

Committed 11 Feb 2022 04:21PM UTC coverage: 57.462%. First build

Build # 6301

Build Type

push

travis-ci-com

Committed by

akhilamohanan

Commit Message

<a href="https://github.com/noironetworks/aci-containers/commit/<a class=hub.com/noironetworks/aci-containers/commit/57b73d98606e7a1fc837a5bcbf0b4b6ed09a720c">57b73d986<a href="https://github.com/noironetworks/aci-containers/commit/57b73d98606e7a1fc837a5bcbf0b4b6ed09a720c">&quot;&gt;Introduce 100ms delay after each subscription query

The server side (nginx) is not able to handle when multiple requests are
sent in quick succession. Added a 100s delay between each subscription
query to fix the issue

Signed-off-by: Akhila &amp;lt;akhila.mohanan@oneconvergence.com&amp;gt;
(cherry picked from commit </a><a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/<a class="double-link" href="https://github.com/noironetworks/aci-containers/commit/49884835063e4ca45736c3fa94787c6ba694390e">498848350</a>">498848350</a><a href="https://github.com/noironetworks/aci-containers/commit/57b73d98606e7a1fc837a5bcbf0b4b6ed09a720c">)

Run Details

10 of 10 new or added lines in 3 files covered. (100.0%)

11717 of 20391 relevant lines covered (57.46%)

0.64 hits per line

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

47.49

/pkg/gbpserver/watchers/apic_watch.go

/***
Copyright 2019 Cisco Systems Inc. All rights reserved.

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.
*/

package watchers

import (
        "encoding/json"
        "fmt"
        "github.com/noironetworks/aci-containers/pkg/apicapi"
        "github.com/noironetworks/aci-containers/pkg/gbpcrd/apis/acipolicy/v1"
        "github.com/noironetworks/aci-containers/pkg/gbpserver"
        "github.com/sirupsen/logrus"
        "io/ioutil"
        "strconv"
        "strings"
        "sync"
)

const (
        refreshTime  = 0 // cAPIC folks recommend 0
        commonTenant = "common"
)

type ApicWatcher struct {
        sync.Mutex
        logger         *logrus.Logger
        log            *logrus.Entry
        apicConn       *apicapi.ApicConnection
        gs             *gbpserver.Server
        idb            *intentDB
        tenant         string
        apName         string
        hostProtPrefix string
        apicInfo       ApicInfo
        eps            *EPSyncer
}

type ApicInfo struct {
        user     string
        password string
        privKey  []byte
        cert     []byte
        prefix   string
}

func NewApicWatcher(gs *gbpserver.Server) *ApicWatcher {
        var privKey []byte
        var apicCert []byte
        var err error

        cfg := gs.Config()
        level, err := logrus.ParseLevel(cfg.WatchLogLevel)
        if err != nil {
                panic(err.Error())
        }
        logger := logrus.New()
        logger.Level = level
        log := logger.WithField("mod", "cAPIC-W")

        if cfg.Apic.PrivateKeyPath != "" {
                privKey, err = ioutil.ReadFile(cfg.Apic.PrivateKeyPath)
                if err != nil {
                        panic(err)
                }
        }
        if cfg.Apic.CertPath != "" {
                apicCert, err = ioutil.ReadFile(cfg.Apic.CertPath)
                if err != nil {
                        panic(err)
                }
        }

        vmmDomain := gs.Config().AciVmmDomain
        return &ApicWatcher{
                logger:         logger,
                log:            log,
                gs:             gs,
                idb:            newIntentDB(gs, log),
                tenant:         cfg.AciPolicyTenant,
                apName:         vmmDomain,
                hostProtPrefix: fmt.Sprintf("uni/tn-%s/pol-%s", cfg.AciPolicyTenant, vmmDomain),
                apicInfo: ApicInfo{
                        user:     cfg.Apic.Username,
                        password: cfg.Apic.Password,
                        prefix:   "k8s",
                        privKey:  privKey,
                        cert:     apicCert,
                },
        }
}

func (aw *ApicWatcher) Init(apicUrl []string, stopCh <-chan struct{}) error {
        // eventually, the url and credentials will come from the crd
        ai := aw.apicInfo
        conn, err := apicapi.New(aw.logger, apicUrl, ai.user, ai.password,
                ai.privKey, ai.cert, ai.prefix, refreshTime, 5, 5)

        if err != nil {
                return err
        }

        aw.apicConn = conn

        // add subscriptions
        aw.apicConn.AddSubscriptionTree("cloudEPg", []string{"cloudEPg", "fvRsCons", "fvRsProv"}, "")
        aw.apicConn.SetSubscriptionHooks("cloudEPg",
                func(obj apicapi.ApicObject) bool {
                        aw.EpgChanged(obj)
                        return true
                },
                func(dn string) {
                        aw.EpgDeleted(dn)
                })
        aw.apicConn.AddSubscriptionTree("vzBrCP", []string{"vzBrCP"}, "")
        aw.apicConn.SetSubscriptionHooks("vzBrCP",
                func(obj apicapi.ApicObject) bool {
                        aw.ContractChanged(obj)
                        return true
                },
                func(dn string) {
                        aw.ContractDeleted(dn)
                })

        aw.apicConn.AddSubscriptionTree("vzFilter", []string{"vzFilter"}, "")
        aw.apicConn.SetSubscriptionHooks("vzFilter",
                func(obj apicapi.ApicObject) bool {
                        aw.FilterChanged(obj)
                        return true
                },
                func(dn string) {
                        aw.FilterDeleted(dn)
                })

        aw.apicConn.AddSubscriptionTree("hostprotPol",
                []string{"hostprotPol", "hostprotSubj", "hostprotRule", "hostprotRemoteIp"}, "")
        aw.apicConn.SetSubscriptionHooks("hostprotPol",
                func(obj apicapi.ApicObject) bool {
                        aw.NetPolChanged(obj)
                        return true
                },
                func(dn string) {
                        if strings.Contains(dn, aw.hostProtPrefix) {
                                aw.log.Infof("Received delete hostprotPol: %s", dn)
                                aw.NetPolDeleted(dn)
                        }
                })

        eps := &EPSyncer{
                log:      aw.log,
                gs:       aw.gs,
                apicConn: aw.apicConn,
                aw:       aw,
        }
        err = eps.Init()
        if err != nil {
                return err
        }
        aw.eps = eps
        go aw.apicConn.Run(stopCh)
        if aw.gs.Config().SyncRemEps {
                go aw.eps.Run(stopCh)
        }
        return nil
}

func (aw *ApicWatcher) EpgChanged(obj apicapi.ApicObject) {
        epgDn := obj.GetAttrStr("dn")
        tenant := dnToTenant(epgDn)
        if tenant != aw.tenant && tenant != commonTenant {
                aw.log.Debugf("== epg: %s ignored tenant: %s", epgDn, tenant)
                return
        }

        aw.ProcessEpg(tenant, epgDn, obj)
}

func (aw *ApicWatcher) ProcessEpg(tenant, epgDn string, obj apicapi.ApicObject) {
        aw.Lock()
        defer aw.Unlock()
        aw.log.Infof("== epg: %s ==", epgDn)
        // construct the EPG
        epg := gbpserver.EPG{
                Tenant: tenant,
                Name:   aw.dnToEpgName(epgDn),
                ApicDN: epgDn,
        }

        for _, body := range obj {
                for _, cc := range body.Children {
                        for class := range cc {
                                switch class {
                                case "fvRsProv":
                                        if cname, err := xtractContract(cc); err == nil {
                                                epg.ProvContracts = append(epg.ProvContracts, cname)
                                        } else {
                                                aw.log.Errorf("epg: %s error: %v", epg.Name, err)
                                        }

                                case "fvRsCons":
                                        if cname, err := xtractContract(cc); err == nil {
                                                epg.ConsContracts = append(epg.ConsContracts, cname)
                                        } else {
                                                aw.log.Errorf("epg: %s error: %v", epg.Name, err)
                                        }
                                }
                        }
                }
        }

        aw.idb.saveEPG(&epg)
        aw.log.Debugf("epgAdded: %v", epg)
}

func xtractContract(c apicapi.ApicObject) (string, error) {
        Dn := c.GetAttrStr("tDn")
        if Dn == "" {
                return "", fmt.Errorf("Missing tDn")
        }
        cname := c.GetAttrStr("tnVzBrCPName")
        if cname == "" {
                return "", fmt.Errorf("contract: %s missing tnVzBrCPName", Dn)
        }

        // add tenant name for namespacing
        tenant := dnToTenant(Dn)
        return fmt.Sprintf("%s/%s", tenant, cname), nil
}

func (aw *ApicWatcher) EpgDeleted(dn string) {
        tenant := dnToTenant(dn)
        if tenant != aw.tenant && tenant != commonTenant {
                aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)
                return
        }
        epg := gbpserver.EPG{
                Tenant: tenant,
                Name:   aw.dnToEpgName(dn),
        }

        aw.idb.deleteEPG(&epg)
}

func dnToTenant(dn string) string {
        s := strings.TrimPrefix(dn, "uni/tn-")
        parts := strings.Split(s, "/")
        if len(parts) > 1 {
                return parts[0]
        }

        return ""
}

func (aw *ApicWatcher) dnToEpgName(dn string) string {
        parts := strings.Split(dn, "/")
        if len(parts) > 3 {
                apName := strings.TrimPrefix(parts[2], "cloudapp-")
                epgName := strings.TrimPrefix(parts[3], "cloudepg-")
                if apName == aw.apName {
                        return epgName
                }

                return fmt.Sprintf("%s|%s", apName, epgName)
        }

        return ""
}

func (aw *ApicWatcher) ContractChanged(obj apicapi.ApicObject) {
        dn := obj.GetAttrStr("dn")
        tenant := dnToTenant(dn)
        if tenant != aw.tenant && tenant != commonTenant {
                aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)
                return
        }

        name := obj.GetAttrStr("name")
        aw.log.Infof("== contract: %s", dn)
        contract := &apicContract{
                Tenant: tenant,
                Name:   name,
        }
        for _, body := range obj {
                for _, cc := range body.Children {
                        for class, o := range cc {
                                switch class {
                                case "vzSubj":
                                        fDn := getFilterDn(o)
                                        contract.Filters = append(contract.Filters, dnToCN(fDn))
                                }
                        }
                }
        }

        aw.log.Debugf("== apic-contract: %s", dn)
        aw.idb.saveApicContract(contract)
}

func getFilterDn(body *apicapi.ApicObjectBody) string {
        for _, cc := range body.Children {
                for class := range cc {
                        switch class {
                        case "vzRsSubjFiltAtt":
                                return cc.GetAttrStr("tDn")
                        }
                }
        }

        return "unknown"
}

func dnToCN(dn string) string {
        parts := strings.Split(dn, "/")
        if len(parts) != 3 {
                return "unknown"
        }

        return fmt.Sprintf("%s/%s", dnToTenant(dn), parts[2])
}

func (aw *ApicWatcher) ContractDeleted(dn string) {
        parts := strings.Split(dn, "/")
        if len(parts) != 3 {
                aw.log.Errorf("Bad contract dn: %s", dn)
                return
        }

        tenant := dnToTenant(dn)
        if tenant != aw.tenant && tenant != commonTenant {
                aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)
                return
        }
        contract := &apicContract{
                Tenant: tenant,
                Name:   parts[2],
        }
        aw.idb.deleteApicContract(contract)
}

func (aw *ApicWatcher) FilterChanged(obj apicapi.ApicObject) {
        var ruleset []v1.WLRule
        dn := obj.GetAttrStr("dn")
        tenant := dnToTenant(dn)
        if tenant != aw.tenant && tenant != commonTenant {
                aw.log.Debugf("== filter: %s ignored tenant: %s", dn, tenant)
                return
        }
        name := dnToCN(dn)
        aw.log.Infof("== filter: %s", dn)
        for _, body := range obj {
                for _, cc := range body.Children {
                        for class := range cc {
                                switch class {
                                case "vzEntry":
                                        r := new(v1.WLRule)
                                        prot := cc.GetAttrStr("prot")
                                        if prot != "unspecified" {
                                                r.Protocol = prot
                                        }
                                        start := cc.GetAttrStr("dFromPort")
                                        p, err := strconv.Atoi(start)
                                        if err == nil {
                                                r.Ports.Start = p
                                        }
                                        end := cc.GetAttrStr("dToPort")
                                        p, err = strconv.Atoi(end)
                                        if err == nil {
                                                r.Ports.End = p
                                        }
                                        ruleset = append(ruleset, *r)
                                }
                        }
                        aw.log.Debugf("Filter: %s, %+v", name, cc)
                }
        }

        aw.idb.saveFilter(name, ruleset)
}

func (aw *ApicWatcher) FilterDeleted(dn string) {
        name := dnToCN(dn)
        aw.idb.deleteFilter(name)
}

func (aw *ApicWatcher) NetPolChanged(obj apicapi.ApicObject) {

        aw.Lock()
        defer aw.Unlock()
        dn := obj.GetAttrStr("dn")
        if !strings.Contains(dn, aw.hostProtPrefix) {
                return
        }

        aw.log.Infof("Received hostprotPol")
        jsonStr, err := json.Marshal(obj)
        if err != nil {
                aw.log.Errorf("Error marshaling %v", err)
                return
        }

        np := gbpserver.NetworkPolicy{}
        err = json.Unmarshal(jsonStr, &np)
        if err != nil {
                aw.log.Errorf("Error unmarshaling %v", err)
                return
        }
        aw.gs.AddNetPol(np)
        aw.log.Infof("NetPol Added: %s", dn)
}

func (aw *ApicWatcher) NetPolDeleted(dn string) {

        aw.Lock()
        defer aw.Unlock()
        aw.gs.DelNetPol(dn)
        aw.log.Infof("NetPol Deleted: %s", dn)
}

1	/***
2	Copyright 2019 Cisco Systems Inc. All rights reserved.
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
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
16	package watchers
17
18	import (
19	"encoding/json"
20	"fmt"
21	"github.com/noironetworks/aci-containers/pkg/apicapi"
22	"github.com/noironetworks/aci-containers/pkg/gbpcrd/apis/acipolicy/v1"
23	"github.com/noironetworks/aci-containers/pkg/gbpserver"
24	"github.com/sirupsen/logrus"
25	"io/ioutil"
26	"strconv"
27	"strings"
28	"sync"
29	)
30
31	const (
32	refreshTime = 0 // cAPIC folks recommend 0
33	commonTenant = "common"
34	)
35
36	type ApicWatcher struct {
37	sync.Mutex
38	logger *logrus.Logger
39	log *logrus.Entry
40	apicConn *apicapi.ApicConnection
41	gs *gbpserver.Server
42	idb *intentDB
43	tenant string
44	apName string
45	hostProtPrefix string
46	apicInfo ApicInfo
47	eps *EPSyncer
48	}
49
50	type ApicInfo struct {
51	user string
52	password string
53	privKey []byte
54	cert []byte
55	prefix string
56	}
57
58	func NewApicWatcher(gs gbpserver.Server) ApicWatcher {	1✔
59	var privKey []byte	1✔
60	var apicCert []byte	1✔
61	var err error	1✔
62		1✔
63	cfg := gs.Config()	1✔
64	level, err := logrus.ParseLevel(cfg.WatchLogLevel)	1✔
65	if err != nil {	1✔
66	panic(err.Error())	×
67	}
68	logger := logrus.New()	1✔
69	logger.Level = level	1✔
70	log := logger.WithField("mod", "cAPIC-W")	1✔
71		1✔
72	if cfg.Apic.PrivateKeyPath != "" {	1✔
73	privKey, err = ioutil.ReadFile(cfg.Apic.PrivateKeyPath)	×
74	if err != nil {	×
75	panic(err)	×
76	}
77	}
78	if cfg.Apic.CertPath != "" {	1✔
79	apicCert, err = ioutil.ReadFile(cfg.Apic.CertPath)	×
80	if err != nil {	×
81	panic(err)	×
82	}
83	}
84
85	vmmDomain := gs.Config().AciVmmDomain	1✔
86	return &ApicWatcher{	1✔
87	logger: logger,	1✔
88	log: log,	1✔
89	gs: gs,	1✔
90	idb: newIntentDB(gs, log),	1✔
91	tenant: cfg.AciPolicyTenant,	1✔
92	apName: vmmDomain,	1✔
93	hostProtPrefix: fmt.Sprintf("uni/tn-%s/pol-%s", cfg.AciPolicyTenant, vmmDomain),	1✔
94	apicInfo: ApicInfo{	1✔
95	user: cfg.Apic.Username,	1✔
96	password: cfg.Apic.Password,	1✔
97	prefix: "k8s",	1✔
98	privKey: privKey,	1✔
99	cert: apicCert,	1✔
100	},	1✔
101	}	1✔
102	}
103
104	func (aw *ApicWatcher) Init(apicUrl []string, stopCh <-chan struct{}) error {	×
105	// eventually, the url and credentials will come from the crd	×
106	ai := aw.apicInfo	×
107	conn, err := apicapi.New(aw.logger, apicUrl, ai.user, ai.password,	×
108	ai.privKey, ai.cert, ai.prefix, refreshTime, 5, 5)	×
109		×
110	if err != nil {	×
111	return err	×
112	}	×
113
114	aw.apicConn = conn	×
115		×
116	// add subscriptions	×
117	aw.apicConn.AddSubscriptionTree("cloudEPg", []string{"cloudEPg", "fvRsCons", "fvRsProv"}, "")	×
118	aw.apicConn.SetSubscriptionHooks("cloudEPg",	×
119	func(obj apicapi.ApicObject) bool {	×
120	aw.EpgChanged(obj)	×
121	return true	×
122	},	×
123	func(dn string) {	×
124	aw.EpgDeleted(dn)	×
125	})	×
126	aw.apicConn.AddSubscriptionTree("vzBrCP", []string{"vzBrCP"}, "")	×
127	aw.apicConn.SetSubscriptionHooks("vzBrCP",	×
128	func(obj apicapi.ApicObject) bool {	×
129	aw.ContractChanged(obj)	×
130	return true	×
131	},	×
132	func(dn string) {	×
133	aw.ContractDeleted(dn)	×
134	})	×
135
136	aw.apicConn.AddSubscriptionTree("vzFilter", []string{"vzFilter"}, "")	×
137	aw.apicConn.SetSubscriptionHooks("vzFilter",	×
138	func(obj apicapi.ApicObject) bool {	×
139	aw.FilterChanged(obj)	×
140	return true	×
141	},	×
142	func(dn string) {	×
143	aw.FilterDeleted(dn)	×
144	})	×
145
146	aw.apicConn.AddSubscriptionTree("hostprotPol",	×
147	[]string{"hostprotPol", "hostprotSubj", "hostprotRule", "hostprotRemoteIp"}, "")	×
148	aw.apicConn.SetSubscriptionHooks("hostprotPol",	×
149	func(obj apicapi.ApicObject) bool {	×
150	aw.NetPolChanged(obj)	×
151	return true	×
152	},	×
153	func(dn string) {	×
154	if strings.Contains(dn, aw.hostProtPrefix) {	×
155	aw.log.Infof("Received delete hostprotPol: %s", dn)	×
156	aw.NetPolDeleted(dn)	×
157	}	×
158	})
159
160	eps := &EPSyncer{	×
161	log: aw.log,	×
162	gs: aw.gs,	×
163	apicConn: aw.apicConn,	×
164	aw: aw,	×
165	}	×
166	err = eps.Init()	×
167	if err != nil {	×
168	return err	×
169	}	×
170	aw.eps = eps	×
171	go aw.apicConn.Run(stopCh)	×
172	if aw.gs.Config().SyncRemEps {	×
173	go aw.eps.Run(stopCh)	×
174	}	×
175	return nil	×
176	}
177
178	func (aw *ApicWatcher) EpgChanged(obj apicapi.ApicObject) {	1✔
179	epgDn := obj.GetAttrStr("dn")	1✔
180	tenant := dnToTenant(epgDn)	1✔
181	if tenant != aw.tenant && tenant != commonTenant {	1✔
182	aw.log.Debugf("== epg: %s ignored tenant: %s", epgDn, tenant)	×
183	return	×
184	}	×
185
186	aw.ProcessEpg(tenant, epgDn, obj)	1✔
187	}
188
189	func (aw *ApicWatcher) ProcessEpg(tenant, epgDn string, obj apicapi.ApicObject) {	1✔
190	aw.Lock()	1✔
191	defer aw.Unlock()	1✔
192	aw.log.Infof("== epg: %s ==", epgDn)	1✔
193	// construct the EPG	1✔
194	epg := gbpserver.EPG{	1✔
195	Tenant: tenant,	1✔
196	Name: aw.dnToEpgName(epgDn),	1✔
197	ApicDN: epgDn,	1✔
198	}	1✔
199		1✔
200	for _, body := range obj {	2✔
201	for _, cc := range body.Children {	2✔
202	for class := range cc {	2✔
203	switch class {	1✔
204	case "fvRsProv":	1✔
205	if cname, err := xtractContract(cc); err == nil {	2✔
206	epg.ProvContracts = append(epg.ProvContracts, cname)	1✔
207	} else {	1✔
208	aw.log.Errorf("epg: %s error: %v", epg.Name, err)	×
209	}	×
210
211	case "fvRsCons":	1✔
212	if cname, err := xtractContract(cc); err == nil {	2✔
213	epg.ConsContracts = append(epg.ConsContracts, cname)	1✔
214	} else {	1✔
215	aw.log.Errorf("epg: %s error: %v", epg.Name, err)	×
216	}	×
217	}
218	}
219	}
220	}
221
222	aw.idb.saveEPG(&epg)	1✔
223	aw.log.Debugf("epgAdded: %v", epg)	1✔
224	}
225
226	func xtractContract(c apicapi.ApicObject) (string, error) {	1✔
227	Dn := c.GetAttrStr("tDn")	1✔
228	if Dn == "" {	1✔
229	return "", fmt.Errorf("Missing tDn")	×
230	}	×
231	cname := c.GetAttrStr("tnVzBrCPName")	1✔
232	if cname == "" {	1✔
233	return "", fmt.Errorf("contract: %s missing tnVzBrCPName", Dn)	×
234	}	×
235
236	// add tenant name for namespacing
237	tenant := dnToTenant(Dn)	1✔
238	return fmt.Sprintf("%s/%s", tenant, cname), nil	1✔
239	}
240
241	func (aw *ApicWatcher) EpgDeleted(dn string) {	×
242	tenant := dnToTenant(dn)	×
243	if tenant != aw.tenant && tenant != commonTenant {	×
244	aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)	×
245	return	×
246	}	×
247	epg := gbpserver.EPG{	×
248	Tenant: tenant,	×
249	Name: aw.dnToEpgName(dn),	×
250	}	×
251		×
252	aw.idb.deleteEPG(&epg)	×
253	}
254
255	func dnToTenant(dn string) string {	1✔
256	s := strings.TrimPrefix(dn, "uni/tn-")	1✔
257	parts := strings.Split(s, "/")	1✔
258	if len(parts) > 1 {	2✔
259	return parts[0]	1✔
260	}	1✔
261
262	return ""	×
263	}
264
265	func (aw *ApicWatcher) dnToEpgName(dn string) string {	1✔
266	parts := strings.Split(dn, "/")	1✔
267	if len(parts) > 3 {	2✔
268	apName := strings.TrimPrefix(parts[2], "cloudapp-")	1✔
269	epgName := strings.TrimPrefix(parts[3], "cloudepg-")	1✔
270	if apName == aw.apName {	2✔
271	return epgName	1✔
272	}	1✔
273
274	return fmt.Sprintf("%s\|%s", apName, epgName)	1✔
275	}
276
277	return ""	×
278	}
279
280	func (aw *ApicWatcher) ContractChanged(obj apicapi.ApicObject) {	1✔
281	dn := obj.GetAttrStr("dn")	1✔
282	tenant := dnToTenant(dn)	1✔
283	if tenant != aw.tenant && tenant != commonTenant {	1✔
284	aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)	×
285	return	×
286	}	×
287
288	name := obj.GetAttrStr("name")	1✔
289	aw.log.Infof("== contract: %s", dn)	1✔
290	contract := &apicContract{	1✔
291	Tenant: tenant,	1✔
292	Name: name,	1✔
293	}	1✔
294	for _, body := range obj {	2✔
295	for _, cc := range body.Children {	2✔
296	for class, o := range cc {	2✔
297	switch class {	1✔
298	case "vzSubj":	1✔
299	fDn := getFilterDn(o)	1✔
300	contract.Filters = append(contract.Filters, dnToCN(fDn))	1✔
301	}
302	}
303	}
304	}
305
306	aw.log.Debugf("== apic-contract: %s", dn)	1✔
307	aw.idb.saveApicContract(contract)	1✔
308	}
309
310	func getFilterDn(body *apicapi.ApicObjectBody) string {	1✔
311	for _, cc := range body.Children {	2✔
312	for class := range cc {	2✔
313	switch class {	1✔
314	case "vzRsSubjFiltAtt":	1✔
315	return cc.GetAttrStr("tDn")	1✔
316	}
317	}
318	}
319
320	return "unknown"	×
321	}
322
323	func dnToCN(dn string) string {	1✔
324	parts := strings.Split(dn, "/")	1✔
325	if len(parts) != 3 {	1✔
326	return "unknown"	×
327	}	×
328
329	return fmt.Sprintf("%s/%s", dnToTenant(dn), parts[2])	1✔
330	}
331
332	func (aw *ApicWatcher) ContractDeleted(dn string) {	×
333	parts := strings.Split(dn, "/")	×
334	if len(parts) != 3 {	×
335	aw.log.Errorf("Bad contract dn: %s", dn)	×
336	return	×
337	}	×
338
339	tenant := dnToTenant(dn)	×
340	if tenant != aw.tenant && tenant != commonTenant {	×
341	aw.log.Debugf("== contract: %s ignored tenant: %s", dn, tenant)	×
342	return	×
343	}	×
344	contract := &apicContract{	×
345	Tenant: tenant,	×
346	Name: parts[2],	×
347	}	×
348	aw.idb.deleteApicContract(contract)	×
349	}
350
351	func (aw *ApicWatcher) FilterChanged(obj apicapi.ApicObject) {	1✔
352	var ruleset []v1.WLRule	1✔
353	dn := obj.GetAttrStr("dn")	1✔
354	tenant := dnToTenant(dn)	1✔
355	if tenant != aw.tenant && tenant != commonTenant {	1✔
356	aw.log.Debugf("== filter: %s ignored tenant: %s", dn, tenant)	×
357	return	×
358	}	×
359	name := dnToCN(dn)	1✔
360	aw.log.Infof("== filter: %s", dn)	1✔
361	for _, body := range obj {	2✔
362	for _, cc := range body.Children {	2✔
363	for class := range cc {	2✔
364	switch class {	1✔
365	case "vzEntry":	1✔
366	r := new(v1.WLRule)	1✔
367	prot := cc.GetAttrStr("prot")	1✔
368	if prot != "unspecified" {	2✔
369	r.Protocol = prot	1✔
370	}	1✔
371	start := cc.GetAttrStr("dFromPort")	1✔
372	p, err := strconv.Atoi(start)	1✔
373	if err == nil {	1✔
374	r.Ports.Start = p	×
375	}	×
376	end := cc.GetAttrStr("dToPort")	1✔
377	p, err = strconv.Atoi(end)	1✔
378	if err == nil {	1✔
379	r.Ports.End = p	×
380	}	×
381	ruleset = append(ruleset, *r)	1✔
382	}
383	}
384	aw.log.Debugf("Filter: %s, %+v", name, cc)	1✔
385	}
386	}
387
388	aw.idb.saveFilter(name, ruleset)	1✔
389	}
390
391	func (aw *ApicWatcher) FilterDeleted(dn string) {	1✔
392	name := dnToCN(dn)	1✔
393	aw.idb.deleteFilter(name)	1✔
394	}	1✔
395
396	func (aw *ApicWatcher) NetPolChanged(obj apicapi.ApicObject) {	×
397		×
398	aw.Lock()	×
399	defer aw.Unlock()	×
400	dn := obj.GetAttrStr("dn")	×
401	if !strings.Contains(dn, aw.hostProtPrefix) {	×
402	return	×
403	}	×
404
405	aw.log.Infof("Received hostprotPol")	×
406	jsonStr, err := json.Marshal(obj)	×
407	if err != nil {	×
408	aw.log.Errorf("Error marshaling %v", err)	×
409	return	×
410	}	×
411
412	np := gbpserver.NetworkPolicy{}	×
413	err = json.Unmarshal(jsonStr, &np)	×
414	if err != nil {	×
415	aw.log.Errorf("Error unmarshaling %v", err)	×
416	return	×
417	}	×
418	aw.gs.AddNetPol(np)	×
419	aw.log.Infof("NetPol Added: %s", dn)	×
420	}
421
422	func (aw *ApicWatcher) NetPolDeleted(dn string) {	×
423		×
424	aw.Lock()	×
425	defer aw.Unlock()	×
426	aw.gs.DelNetPol(dn)	×
427	aw.log.Infof("NetPol Deleted: %s", dn)	×
428	}	×

noironetworks / aci-containers / 6301

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