Fix to advertise VRF routes from DC-GW
[netvirt.git] / vpnmanager / impl / src / main / java / org / opendaylight / netvirt / vpnmanager / VpnOpStatusListener.java
1 /*
2  * Copyright (c) 2015 - 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.netvirt.vpnmanager;
9
10 import com.google.common.base.Optional;
11 import com.google.common.util.concurrent.FutureCallback;
12 import com.google.common.util.concurrent.Futures;
13 import com.google.common.util.concurrent.ListenableFuture;
14 import com.google.common.util.concurrent.MoreExecutors;
15 import java.util.ArrayList;
16 import java.util.Collections;
17 import java.util.List;
18 import javax.annotation.PostConstruct;
19 import javax.inject.Inject;
20 import javax.inject.Singleton;
21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
23 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
24 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
25 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
26 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
27 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
28 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
29 import org.opendaylight.genius.utils.SystemPropertyReader;
30 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
31 import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
32 import org.opendaylight.netvirt.fibmanager.api.IFibManager;
33 import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
34 import org.opendaylight.yang.gen.v1.urn.ericsson.params.xml.ns.yang.ebgp.rev150901.AddressFamily;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
45 import org.slf4j.Logger;
46 import org.slf4j.LoggerFactory;
47
48 @Singleton
49 public class VpnOpStatusListener extends AsyncDataTreeChangeListenerBase<VpnInstanceOpDataEntry, VpnOpStatusListener> {
50     private static final Logger LOG = LoggerFactory.getLogger(VpnOpStatusListener.class);
51     private final DataBroker dataBroker;
52     private final ManagedNewTransactionRunner txRunner;
53     private final IBgpManager bgpManager;
54     private final IdManagerService idManager;
55     private final IFibManager fibManager;
56     private final IMdsalApiManager mdsalManager;
57     private final VpnFootprintService vpnFootprintService;
58     private final JobCoordinator jobCoordinator;
59
60     @Inject
61     public VpnOpStatusListener(final DataBroker dataBroker, final IBgpManager bgpManager,
62                                final IdManagerService idManager, final IFibManager fibManager,
63                                final IMdsalApiManager mdsalManager, final VpnFootprintService vpnFootprintService,
64                                final JobCoordinator jobCoordinator) {
65         super(VpnInstanceOpDataEntry.class, VpnOpStatusListener.class);
66         this.dataBroker = dataBroker;
67         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
68         this.bgpManager = bgpManager;
69         this.idManager = idManager;
70         this.fibManager = fibManager;
71         this.mdsalManager = mdsalManager;
72         this.vpnFootprintService = vpnFootprintService;
73         this.jobCoordinator = jobCoordinator;
74     }
75
76     @PostConstruct
77     public void start() {
78         LOG.info("{} start", getClass().getSimpleName());
79         registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
80     }
81
82     @Override
83     protected InstanceIdentifier<VpnInstanceOpDataEntry> getWildCardPath() {
84         return InstanceIdentifier.create(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class);
85     }
86
87     @Override
88     protected VpnOpStatusListener getDataTreeChangeListener() {
89         return VpnOpStatusListener.this;
90     }
91
92     @Override
93     protected void remove(InstanceIdentifier<VpnInstanceOpDataEntry> identifier, VpnInstanceOpDataEntry value) {
94         LOG.info("remove: Ignoring vpn Op {} with rd {}", value.getVpnInstanceName(), value.getVrfId());
95     }
96
97     @Override
98     @SuppressWarnings("checkstyle:IllegalCatch")
99     protected void update(InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
100                           VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
101         LOG.info("update: Processing update for vpn {} with rd {}", update.getVpnInstanceName(), update.getVrfId());
102         if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete
103                 && vpnFootprintService.isVpnFootPrintCleared(update)) {
104             //Cleanup VPN data
105             final String vpnName = update.getVpnInstanceName();
106             final List<String> rds = update.getRd();
107             String primaryRd = update.getVrfId();
108             final long vpnId = VpnUtil.getVpnId(dataBroker, vpnName);
109             jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
110                 // Two transactions are used, one for operational, one for config; we only submit the config
111                 // transaction if the operational transaction succeeds
112                 ListenableFuture<Void> operationalFuture = txRunner.callWithNewWriteOnlyTransactionAndSubmit(operTx -> {
113                     // Clean up VPNExtraRoutes Operational DS
114                     if (VpnUtil.isBgpVpn(vpnName, primaryRd)) {
115                         if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
116                             rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.L2VPN));
117                         }
118                         if (update.isIpv4Configured()) {
119                             rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV4));
120                         }
121                         if (update.isIpv6Configured()) {
122                             rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(rd, false, AddressFamily.IPV6));
123                         }
124                     }
125                     InstanceIdentifier<Vpn> vpnToExtraroute =
126                             VpnExtraRouteHelper.getVpnToExtrarouteVpnIdentifier(vpnName);
127                     Optional<Vpn> optVpnToExtraroute = Optional.absent();
128                     try {
129                         optVpnToExtraroute = SingleTransactionDataBroker.syncReadOptional(dataBroker,
130                                 LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
131                     } catch (ReadFailedException e) {
132                         LOG.error("update: Failed to read VpnToExtraRoute for vpn {}", vpnName);
133                     }
134                     if (optVpnToExtraroute.isPresent()) {
135                         VpnUtil.removeVpnExtraRouteForVpn(vpnName, operTx);
136                     }
137                     if (VpnUtil.isL3VpnOverVxLan(update.getL3vni())) {
138                         VpnUtil.removeExternalTunnelDemuxFlows(vpnName, dataBroker, mdsalManager);
139                     }
140                     // Clean up PrefixToInterface Operational DS
141                     Optional<VpnIds> optPrefixToIntf = Optional.absent();
142                     try {
143                         optPrefixToIntf = SingleTransactionDataBroker.syncReadOptional(dataBroker,
144                                 LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId));
145                     } catch (ReadFailedException e) {
146                         LOG.error("update: Failed to read PrefixToInterface for vpn {}", vpnName);
147                     }
148                     if (optPrefixToIntf.isPresent()) {
149                         VpnUtil.removePrefixToInterfaceForVpnId(vpnId, operTx);
150                     }
151                     // Clean up L3NextHop Operational DS
152                     InstanceIdentifier<VpnNexthops> vpnNextHops = InstanceIdentifier.builder(L3nexthop.class).child(
153                             VpnNexthops.class, new VpnNexthopsKey(vpnId)).build();
154                     Optional<VpnNexthops> optL3nexthopForVpnId = Optional.absent();
155                     try {
156                         optL3nexthopForVpnId = SingleTransactionDataBroker.syncReadOptional(dataBroker,
157                                 LogicalDatastoreType.OPERATIONAL, vpnNextHops);
158                     } catch (ReadFailedException e) {
159                         LOG.error("update: Failed to read VpnNextHops for vpn {}", vpnName);
160                     }
161                     if (optL3nexthopForVpnId.isPresent()) {
162                         VpnUtil.removeL3nexthopForVpnId(vpnId, operTx);
163                     }
164
165                     // Clean up VPNInstanceOpDataEntry
166                     VpnUtil.removeVpnOpInstance(primaryRd, operTx);
167                 });
168
169                 Futures.addCallback(operationalFuture, new FutureCallback<Void>() {
170                     @Override
171                     public void onSuccess(Void result) {
172                         Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(confTx -> {
173                             // Clean up VpnInstanceToVpnId from Config DS
174                             VpnUtil.removeVpnIdToVpnInstance(vpnId, confTx);
175                             VpnUtil.removeVpnInstanceToVpnId(vpnName, confTx);
176                             LOG.trace("Removed vpnIdentifier for  rd{} vpnname {}", primaryRd, vpnName);
177
178                             // Clean up FIB Entries Config DS
179                             synchronized (vpnName.intern()) {
180                                 fibManager.removeVrfTable(primaryRd, confTx);
181                             }
182                         }), new VpnOpStatusListener.PostDeleteVpnInstanceWorker(vpnName),
183                                 MoreExecutors.directExecutor());
184                         // Note: Release the of VpnId will happen in PostDeleteVpnInstancWorker only if
185                         // operationalTxn/Config succeeds.
186                     }
187
188                     @Override
189                     public void onFailure(Throwable throwable) {
190                         LOG.error("Error deleting VPN {}", vpnName, throwable);
191                     }
192                 }, MoreExecutors.directExecutor());
193
194                 LOG.info("Removed vpn data for vpnname {}", vpnName);
195                 return Collections.singletonList(operationalFuture);
196             }, SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
197         } else if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.Created) {
198             final String vpnName = update.getVpnInstanceName();
199             final List<String> rds = update.getRd();
200             String primaryRd = update.getVrfId();
201             if (!VpnUtil.isBgpVpn(vpnName, primaryRd)) {
202                 return;
203             }
204             if (original == null) {
205                 LOG.error("VpnOpStatusListener.update: vpn {} with RD {}. add() handler already called",
206                        vpnName, primaryRd);
207                 return;
208             }
209             if (update.getVpnTargets() == null) {
210                 LOG.error("VpnOpStatusListener.update: vpn {} with RD {} vpnTargets not ready",
211                        vpnName, primaryRd);
212                 return;
213             }
214             List<VpnTarget> vpnTargetList = update.getVpnTargets().getVpnTarget();
215             List<String> ertList = new ArrayList<>();
216             List<String> irtList = new ArrayList<>();
217             if (vpnTargetList != null) {
218                 for (VpnTarget vpnTarget : vpnTargetList) {
219                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
220                         ertList.add(vpnTarget.getVrfRTValue());
221                     }
222                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
223                         irtList.add(vpnTarget.getVrfRTValue());
224                     }
225                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
226                         ertList.add(vpnTarget.getVrfRTValue());
227                         irtList.add(vpnTarget.getVrfRTValue());
228                     }
229                 }
230             } else {
231                 LOG.error("VpnOpStatusListener.update: vpn target list is empty, cannot add BGP"
232                       + " VPN {} RD {}", vpnName, primaryRd);
233                 return;
234             }
235             jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
236                 rds.parallelStream().forEach(rd -> {
237                     try {
238                         LOG.info("VpnOpStatusListener.update: updating BGPVPN for vpn {} with RD {}"
239                                 + " Type is {}, IPv4 is {}, IPv6 is {}", vpnName, primaryRd, update.getType(),
240                                 update.isIpv4Configured(), update.isIpv6Configured());
241                         List<String> importRTList = rd.equals(primaryRd) ? irtList : Collections.emptyList();
242                         if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
243                             bgpManager.addVrf(rd, importRTList, ertList, AddressFamily.L2VPN);
244                         }
245                         if (!original.isIpv4Configured() && update.isIpv4Configured()) {
246                             bgpManager.addVrf(rd, importRTList, ertList, AddressFamily.IPV4);
247                         } else if (original.isIpv4Configured() && !update.isIpv4Configured()) {
248                             bgpManager.deleteVrf(rd, false, AddressFamily.IPV4);
249                         }
250                         if (!original.isIpv6Configured() && update.isIpv6Configured()) {
251                             bgpManager.addVrf(rd, importRTList, ertList, AddressFamily.IPV6);
252                         } else if (original.isIpv6Configured() && !update.isIpv6Configured()) {
253                             bgpManager.deleteVrf(rd, false, AddressFamily.IPV6);
254                         }
255                     } catch (Exception e) {
256                         LOG.error("VpnOpStatusListener.update: Exception when updating VRF to BGP"
257                                + " for vpn {} rd {}", vpnName, rd);
258                     }
259                 });
260                 return Collections.emptyList();
261             });
262         }
263     }
264
265     @Override
266     protected void add(final InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
267                        final VpnInstanceOpDataEntry value) {
268         LOG.debug("add: Ignoring vpn Op {} with rd {}", value.getVpnInstanceName(), value.getVrfId());
269     }
270
271     private class PostDeleteVpnInstanceWorker implements FutureCallback<Void> {
272         private final Logger log = LoggerFactory.getLogger(VpnOpStatusListener.PostDeleteVpnInstanceWorker.class);
273         String vpnName;
274
275         PostDeleteVpnInstanceWorker(String vpnName)  {
276             this.vpnName = vpnName;
277         }
278
279         /**
280          * This implies that all the future instances have returned success.
281          * Release the ID used for VPN back to IdManager
282          */
283         @Override
284         public void onSuccess(Void ignored) {
285             VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME, vpnName);
286             log.info("onSuccess: VpnId for VpnName {} is released to IdManager successfully.", vpnName);
287         }
288
289         /**
290          * This method is used to handle failure callbacks.
291          */
292         @Override
293         public void onFailure(Throwable throwable) {
294             log.error("onFailure: Job for vpnInstance: {} failed with exception:",
295                       vpnName , throwable);
296         }
297     }
298 }