neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/vpnservice/neutronvpn/NeutronBgpvpnChangeListener.java

   1 /*
   2  * Copyright (c) 2016 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
   9 package org.opendaylight.vpnservice.neutronvpn;
  10
  11
  12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  13 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  14 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.vpnservice.mdsalutil.AbstractDataChangeListener;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.bgpvpns.rev150903.bgpvpns.attributes.Bgpvpns;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.bgpvpns.rev150903.bgpvpns.attributes.bgpvpns.Bgpvpn;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  21 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 import java.util.ArrayList;
  27 import java.util.Iterator;
  28 import java.util.List;
  29
  30
  31 public class NeutronBgpvpnChangeListener extends AbstractDataChangeListener<Bgpvpn> implements AutoCloseable {
  32     private static final Logger LOG = LoggerFactory.getLogger(NeutronBgpvpnChangeListener.class);
  33
  34     private ListenerRegistration<DataChangeListener> listenerRegistration;
  35     private NeutronvpnManager nvpnManager;
  36
  37
  38     public NeutronBgpvpnChangeListener(final DataBroker db, NeutronvpnManager nVpnMgr) {
  39         super(Bgpvpn.class);
  40         nvpnManager = nVpnMgr;
  41         registerListener(db);
  42     }
  43
  44     @Override
  45     public void close() throws Exception {
  46         if (listenerRegistration != null) {
  47             try {
  48                 listenerRegistration.close();
  49             } catch (final Exception e) {
  50                 LOG.error("Error when cleaning up DataChangeListener.", e);
  51             }
  52             listenerRegistration = null;
  53         }
  54         LOG.info("N_Bgpvpn listener Closed");
  55     }
  56
  57
  58     private void registerListener(final DataBroker db) {
  59         try {
  60             listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
  61                     InstanceIdentifier.create(Neutron.class).child(Bgpvpns.class).child(Bgpvpn.class),
  62                     NeutronBgpvpnChangeListener.this, DataChangeScope.SUBTREE);
  63         } catch (final Exception e) {
  64             LOG.error("Neutron Manager Bgpvpn DataChange listener registration fail!", e);
  65             throw new IllegalStateException("Neutron Manager Bgpvpn DataChange listener registration failed.", e);
  66         }
  67     }
  68
  69     @Override
  70     protected void add(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
  71         if (LOG.isTraceEnabled()) {
  72             LOG.trace("Adding Bgpvpn : key: " + identifier + ", value=" + input);
  73         }
  74         // Create internal VPN
  75         // handle route-target
  76         List<String> irt = new ArrayList<String>();
  77         List<String> ert = new ArrayList<String>();
  78         List<String> inrt = input.getRouteTargets();
  79         List<String> inirt = input.getImportTargets();
  80         List<String> inert = input.getExportTargets();
  81         if (inrt != null && !inrt.isEmpty()) {
  82             irt.addAll(inrt);
  83             ert.addAll(inrt);
  84         }
  85         if (inirt != null && !inirt.isEmpty()) {
  86             irt.addAll(inirt);
  87         }
  88         if (inert != null && !inert.isEmpty()) {
  89             ert.addAll(inert);
  90         }
  91         List<String> rd = input.getRouteDistinguishers();
  92
  93         if (rd == null || rd.isEmpty()) {
  94             // generate new RD
  95         }
  96         Uuid router = null;
  97         if (input.getRouters() != null && !input.getRouters().isEmpty()) {
  98             // currently only one router
  99             router = input.getRouters().get(0);
 100         }
 101         nvpnManager.createL3Vpn(input.getUuid(), input.getName(), input.getTenantId(),
 102                 rd, irt, ert, router, input.getNetworks());
 103     }
 104
 105     @Override
 106     protected void remove(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn input) {
 107         if (LOG.isTraceEnabled()) {
 108             LOG.trace("Removing Bgpvpn : key: " + identifier + ", value=" + input);
 109         }
 110         nvpnManager.removeL3Vpn(input.getUuid());
 111
 112     }
 113
 114     @Override
 115     protected void update(InstanceIdentifier<Bgpvpn> identifier, Bgpvpn original, Bgpvpn update) {
 116         List<Uuid> oldNetworks = original.getNetworks();
 117         List<Uuid> newNetworks = update.getNetworks();
 118         List<Uuid> oldRouters= original.getRouters();
 119         List<Uuid> newRouters = update.getRouters();
 120         Uuid vpnId = update.getUuid();
 121
 122         if (LOG.isTraceEnabled()) {
 123             LOG.trace("Update Bgpvpn : key: " + identifier + ", value=" + update);
 124         }
 125
 126         handleNetworksUpdate(vpnId, oldNetworks, newNetworks);
 127         handleRoutersUpdate(vpnId, oldRouters, newRouters);
 128     }
 129
 130     protected void handleNetworksUpdate(Uuid vpnId, List<Uuid> oldNetworks, List<Uuid> newNetworks) {
 131         if (newNetworks != null && !newNetworks.isEmpty()) {
 132             if (oldNetworks != null && !oldNetworks.isEmpty()) {
 133                 if (oldNetworks != newNetworks) {
 134                     Iterator<Uuid> iter = newNetworks.iterator();
 135                     while (iter.hasNext()) {
 136                         Object net = iter.next();
 137                         if (oldNetworks.contains(net)) {
 138                             oldNetworks.remove(net);
 139                             iter.remove();
 140                         }
 141                     }
 142                     //clear removed networks
 143                     if (!oldNetworks.isEmpty()) {
 144                         LOG.trace("Removing old networks {} ", oldNetworks);
 145                         nvpnManager.dissociateNetworksFromVpn(vpnId, oldNetworks);
 146                     }
 147                     //add new (Delta) Networks
 148                     if (!newNetworks.isEmpty()) {
 149                         LOG.trace("Adding delta New networks {} ", newNetworks);
 150                         nvpnManager.associateNetworksToVpn(vpnId, newNetworks);
 151                     }
 152                 }
 153             } else {
 154                 //add new Networks
 155                 LOG.trace("Adding New networks {} ", newNetworks);
 156                 nvpnManager.associateNetworksToVpn(vpnId, newNetworks);
 157             }
 158         }
 159     }
 160
 161     protected void handleRoutersUpdate(Uuid vpnId, List<Uuid> oldRouters, List<Uuid> newRouters) {
 162         if (newRouters != null && !newRouters.isEmpty()) {
 163             if (oldRouters != null && !oldRouters.isEmpty()) {
 164                 Uuid oldRouter = oldRouters.get(0);
 165                 Uuid newRouter = newRouters.get(0);
 166                 if (oldRouter != newRouter) {
 167                     nvpnManager.dissociateRouterFromVpn(vpnId, oldRouter);
 168                     nvpnManager.associateRouterToVpn(vpnId, newRouter);
 169                 }
 170             } else {
 171                 nvpnManager.associateRouterToVpn(vpnId, newRouters.get(0));
 172             }
 173         } else {
 174             /* dissociate old router */
 175             if (oldRouters != null && !oldRouters.isEmpty()) {
 176                 Uuid oldRouter = oldRouters.get(0);
 177                 nvpnManager.dissociateRouterFromVpn(vpnId, oldRouter);
 178             }
 179         }
 180
 181 /* TBD : multiple rotuer support
 182                 if (oldRouters != newRouters) {
 183                     Iterator<Uuid> iter = newRouters.iterator();
 184                     while (iter.hasNext()) {
 185                         Object net = iter.next();
 186                         if (oldRouters.contains(net)) {
 187                             oldRouters.remove(net);
 188                             iter.remove();
 189                         }
 190                     }
 191                     //clear removed routers
 192                     if (!oldRouters.isEmpty()) {
 193                         LOG.trace("Removing old routers {} ", oldRouters);
 194                         nvpnManager.dissociateRoutersFromVpn(vpnId, oldRouters);
 195                     }
 196                     //add new (Delta) routers
 197                     if (!newRouters.isEmpty()) {
 198                         LOG.trace("Adding delta New routers {} ", newRouters);
 199                         nvpnManager.associateRoutersToVpn(vpnId, newRouters);
 200                     }
 201                 }
 202             } else {
 203                 //add new routers
 204                 LOG.trace("Adding New routers {} ", newRouters);
 205                 nvpnManager.associateRoutersToVpn(vpnId, newRouters);
 206             }
 207
 208         }*/
 209     }
 210
 211 }