git.opendaylight Code Review - netvirt.git/blob

   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 package org.opendaylight.netvirt.neutronvpn;
   9
  10 import java.util.Objects;
  11
  12 import com.google.common.base.Optional;
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  15 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  16 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  17 import org.opendaylight.netvirt.elanmanager.api.IElanService;
  18 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeBase;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.ext.rev160613.QosNetworkExtension;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 public class NeutronNetworkChangeListener extends AsyncDataTreeChangeListenerBase<Network, NeutronNetworkChangeListener>
  35         implements AutoCloseable {
  36     private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkChangeListener.class);
  37     private final DataBroker dataBroker;
  38     private final NeutronvpnManager nvpnManager;
  39     private final NeutronvpnNatManager nvpnNatManager;
  40     private final IElanService elanService;
  41     private OdlInterfaceRpcService odlInterfaceRpcService;
  42
  43     public NeutronNetworkChangeListener(final DataBroker dataBroker, final NeutronvpnManager nVpnMgr,
  44                                         final NeutronvpnNatManager nVpnNatMgr, final IElanService elanService,
  45                                         OdlInterfaceRpcService odlInterfaceRpcService) {
  46         super(Network.class, NeutronNetworkChangeListener.class);
  47         this.dataBroker = dataBroker;
  48         nvpnManager = nVpnMgr;
  49         nvpnNatManager = nVpnNatMgr;
  50         this.elanService = elanService;
  51         this.odlInterfaceRpcService = odlInterfaceRpcService;
  52     }
  53
  54     public void start() {
  55         LOG.info("{} start", getClass().getSimpleName());
  56         registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
  57     }
  58
  59     @Override
  60     protected InstanceIdentifier<Network> getWildCardPath() {
  61         return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
  62     }
  63
  64     @Override
  65     protected NeutronNetworkChangeListener getDataTreeChangeListener() {
  66         return NeutronNetworkChangeListener.this;
  67     }
  68
  69
  70     @Override
  71     protected void add(InstanceIdentifier<Network> identifier, Network input) {
  72         LOG.trace("Adding Network : key: {}, value={}", identifier, input);
  73         if (!NeutronvpnUtils.isNetworkTypeSupported(input)) {
  74             LOG.error("Neutronvpn doesn't support this network provider type for this network {} and uuid {}.", input.getName(), input.getUuid());
  75             return;
  76         }
  77
  78         NeutronvpnUtils.addToNetworkCache(input);
  79         // Create ELAN instance for this network
  80         ElanInstance elanInstance = createElanInstance(input);
  81         // Create ELAN interface and IETF interfaces for the physical network
  82         elanService.createExternalElanNetwork(elanInstance);
  83         if (NeutronvpnUtils.getIsExternal(input)) {
  84             ProviderTypes providerNwType = NeutronvpnUtils.getProviderNetworkType(input);
  85             if (providerNwType == null) {
  86                 LOG.error("Neutron Service : Unable to get Network Provider Type for network {}", input.getUuid());
  87                 return;
  88             }
  89             LOG.trace("Neutron Service : External Network Provider Type is {}", providerNwType.getName());
  90             nvpnNatManager.addExternalNetwork(input);
  91             if (NeutronvpnUtils.isFlatOrVlanNetwork(input)) {
  92                 nvpnManager.createL3InternalVpn(input.getUuid(), null, null, null, null, null, null, null);
  93                 nvpnManager.createExternalVpnInterfaces(input.getUuid());
  94             }
  95         }
  96     }
  97
  98     @Override
  99     protected void remove(InstanceIdentifier<Network> identifier, Network input) {
 100         LOG.trace("Removing Network : key: {}, value={}", identifier, input);
 101         if (!NeutronvpnUtils.isNetworkTypeSupported(input)) {
 102             //FIXME: This should be removed when support for GRE network types is added
 103             LOG.error("Neutronvpn doesn't support gre network provider type for this network {}.", input);
 104             return;
 105         }
 106         if (NeutronvpnUtils.getIsExternal(input)) {
 107             if (NeutronvpnUtils.isFlatOrVlanNetwork(input)) {
 108                 nvpnManager.removeExternalVpnInterfaces(input.getUuid());
 109                 nvpnManager.removeL3Vpn(input.getUuid());
 110             }
 111             nvpnNatManager.removeExternalNetwork(input);
 112         }
 113         //Delete ELAN instance for this network
 114         String elanInstanceName = input.getUuid().getValue();
 115         ElanInstance elanInstance = elanService.getElanInstance(elanInstanceName);
 116         if (elanInstance != null) {
 117             elanService.deleteExternalElanNetwork(elanInstance);
 118             deleteElanInstance(elanInstanceName);
 119         }
 120         NeutronvpnUtils.removeFromNetworkCache(input);
 121     }
 122
 123     @Override
 124     protected void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
 125         LOG.trace("Updating Network : key: {}, original value={}, update value={}", identifier, original, update);
 126         NeutronvpnUtils.addToNetworkCache(update);
 127         String elanInstanceName = original.getUuid().getValue();
 128         Class<? extends SegmentTypeBase> origSegmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(original);
 129         String origSegmentationId = NeutronUtils.getSegmentationIdFromNeutronNetwork(original);
 130         String origPhysicalNetwork = NeutronvpnUtils.getPhysicalNetworkName(original);
 131         Class<? extends SegmentTypeBase> updateSegmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(update);
 132         String updateSegmentationId = NeutronUtils.getSegmentationIdFromNeutronNetwork(update);
 133         String updatePhysicalNetwork = NeutronvpnUtils.getPhysicalNetworkName(update);
 134
 135         if (!Objects.equals(origSegmentType, updateSegmentType)
 136                 || !Objects.equals(origSegmentationId, updateSegmentationId)
 137                 || !Objects.equals(origPhysicalNetwork, updatePhysicalNetwork)) {
 138             if (NeutronvpnUtils.getIsExternal(original) && NeutronvpnUtils.isFlatOrVlanNetwork(original)) {
 139                 nvpnManager.removeExternalVpnInterfaces(original.getUuid());
 140             }
 141             ElanInstance elanInstance = elanService.getElanInstance(elanInstanceName);
 142             if (elanInstance != null) {
 143                 elanService.deleteExternalElanNetwork(elanInstance);
 144                 elanInstance = updateElanInstance(elanInstanceName, updateSegmentType, updateSegmentationId,
 145                         updatePhysicalNetwork);
 146                 elanService.createExternalElanNetwork(elanInstance);
 147             }
 148
 149             if (NeutronvpnUtils.getIsExternal(update) && NeutronvpnUtils.isFlatOrVlanNetwork(update)) {
 150                 nvpnManager.createExternalVpnInterfaces(update.getUuid());
 151             }
 152         }
 153
 154         QosNetworkExtension updateQos = update.getAugmentation(QosNetworkExtension.class);
 155         QosNetworkExtension originalQos = original.getAugmentation(QosNetworkExtension.class);
 156         if (originalQos == null && updateQos != null) {
 157             // qos policy add
 158             NeutronvpnUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
 159             NeutronQosUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
 160                     update, updateQos.getQosPolicyId());
 161         } else if (originalQos != null && updateQos != null
 162                 && !originalQos.getQosPolicyId().equals(updateQos.getQosPolicyId())) {
 163             // qos policy update
 164             NeutronvpnUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
 165             NeutronvpnUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
 166             NeutronQosUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
 167                     update, updateQos.getQosPolicyId());
 168         } else if (originalQos != null && updateQos == null) {
 169             // qos policy delete
 170             NeutronQosUtils.handleNeutronNetworkQosRemove(dataBroker, odlInterfaceRpcService,
 171                     original, originalQos.getQosPolicyId());
 172             NeutronvpnUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
 173         }
 174     }
 175
 176     private ElanInstance createElanInstance(Network input) {
 177         String elanInstanceName = input.getUuid().getValue();
 178         Class<? extends SegmentTypeBase> segmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(input);
 179         String segmentationId = NeutronUtils.getSegmentationIdFromNeutronNetwork(input);
 180         String physicalNetworkName = NeutronvpnUtils.getPhysicalNetworkName(input);
 181         ElanInstance elanInstance = createElanInstance(elanInstanceName, segmentType, segmentationId, physicalNetworkName);
 182         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 183         Optional<ElanInstance> existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 184         if (existingElanInstance.isPresent()) {
 185             return existingElanInstance.get();
 186         }
 187         MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, elanInstance);
 188         LOG.debug("ELANInstance {} created", elanInstanceName);
 189         return elanInstance;
 190     }
 191
 192     private void deleteElanInstance(String elanInstanceName) {
 193         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 194         MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 195         LOG.debug("ELANInstance {} deleted", elanInstanceName);
 196     }
 197
 198     private ElanInstance updateElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
 199             String segmentationId, String physicalNetworkName) {
 200         ElanInstance elanInstance = createElanInstance(elanInstanceName, segmentType, segmentationId, physicalNetworkName);
 201         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 202         MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, id, elanInstance);
 203         return elanInstance;
 204     }
 205
 206     private InstanceIdentifier<ElanInstance> createElanInstanceIdentifier(String elanInstanceName) {
 207         InstanceIdentifier<ElanInstance> id = InstanceIdentifier.builder(ElanInstances.class)
 208                 .child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
 209         return id;
 210     }
 211
 212     private ElanInstance createElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
 213             String segmentationId, String physicalNetworkName) {
 214         ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName);
 215         if (segmentType != null) {
 216             elanInstanceBuilder.setSegmentType(segmentType);
 217             if (segmentationId != null) {
 218                 elanInstanceBuilder.setSegmentationId(Long.valueOf(segmentationId));
 219             }
 220             if (physicalNetworkName != null) {
 221                 elanInstanceBuilder.setPhysicalNetworkName(physicalNetworkName);
 222             }
 223         }
 224         elanInstanceBuilder.setKey(new ElanInstanceKey(elanInstanceName));
 225         return elanInstanceBuilder.build();
 226     }
 227
 228 }