neutronvpn/impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronNetworkChangeListener.java

   1 /*
   2  * Copyright (c) 2016, 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.neutronvpn;
   9
  10 import com.google.common.base.Optional;
  11 import java.util.Collections;
  12 import java.util.List;
  13 import java.util.Objects;
  14 import java.util.stream.Collectors;
  15 import javax.annotation.Nonnull;
  16 import javax.annotation.Nullable;
  17 import javax.annotation.PostConstruct;
  18 import javax.inject.Inject;
  19 import javax.inject.Singleton;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  23 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  24 import org.opendaylight.netvirt.elanmanager.api.IElanService;
  25 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeBase;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeFlat;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVlan;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVxlan;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ElanSegments;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.elan.instance.ElanSegmentsBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ProviderTypes;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeBase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVxlan;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.neutron.networks.network.Segments;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 @Singleton
  51 public class NeutronNetworkChangeListener
  52         extends AsyncDataTreeChangeListenerBase<Network, NeutronNetworkChangeListener> {
  53     private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkChangeListener.class);
  54     private final DataBroker dataBroker;
  55     private final NeutronvpnManager nvpnManager;
  56     private final NeutronvpnNatManager nvpnNatManager;
  57     private final IElanService elanService;
  58     private final NeutronvpnUtils neutronvpnUtils;
  59
  60     @Inject
  61     public NeutronNetworkChangeListener(final DataBroker dataBroker, final NeutronvpnManager neutronvpnManager,
  62                                         final NeutronvpnNatManager neutronvpnNatManager,
  63                                         final IElanService elanService, final NeutronvpnUtils neutronvpnUtils) {
  64         super(Network.class, NeutronNetworkChangeListener.class);
  65         this.dataBroker = dataBroker;
  66         nvpnManager = neutronvpnManager;
  67         nvpnNatManager = neutronvpnNatManager;
  68         this.elanService = elanService;
  69         this.neutronvpnUtils = neutronvpnUtils;
  70     }
  71
  72     @Override
  73     @PostConstruct
  74     public void init() {
  75         LOG.info("{} init", getClass().getSimpleName());
  76         registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
  77     }
  78
  79     @Override
  80     protected InstanceIdentifier<Network> getWildCardPath() {
  81         return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
  82     }
  83
  84     @Override
  85     protected NeutronNetworkChangeListener getDataTreeChangeListener() {
  86         return NeutronNetworkChangeListener.this;
  87     }
  88
  89
  90     @Override
  91     protected void add(InstanceIdentifier<Network> identifier, Network input) {
  92         LOG.trace("Adding Network : key: {}, value={}", identifier, input);
  93         String networkId = input.getUuid().getValue();
  94         if (!NeutronvpnUtils.isNetworkTypeSupported(input)) {
  95             LOG.error("Neutronvpn doesn't support the provider type for given network {}", networkId);
  96             return;
  97         }
  98         Class<? extends NetworkTypeBase> networkType = input.augmentation(NetworkProviderExtension.class)
  99                 .getNetworkType();
 100         if (NeutronvpnUtils.isVlanOrVxlanNetwork(networkType)
 101                 && NeutronUtils.getSegmentationIdFromNeutronNetwork(input, networkType) == null) {
 102             LOG.error("Segmentation ID is null for configured provider network {} of type {}. Abandoning any further "
 103                     + "processing for the network", input.getUuid().getValue(), networkType);
 104             return;
 105         }
 106
 107         neutronvpnUtils.addToNetworkCache(input);
 108         // Create ELAN instance for this network
 109         ElanInstance elanInstance = createElanInstance(input);
 110
 111         if (NeutronvpnUtils.getIsExternal(input)) {
 112             // Create ELAN interface and IETF interfaces for the physical network
 113             elanService.createExternalElanNetwork(elanInstance);
 114             ProviderTypes providerNwType = NeutronvpnUtils.getProviderNetworkType(input);
 115             if (providerNwType == null) {
 116                 LOG.error("Unable to get Network Provider Type for network {}", networkId);
 117                 return;
 118             }
 119             LOG.trace("External Network Provider Type for network {} is {}", networkId, providerNwType.getName());
 120             nvpnNatManager.addExternalNetwork(input);
 121             if (NeutronvpnUtils.isFlatOrVlanNetwork(input)) {
 122                 nvpnManager.createL3InternalVpn(input.getUuid(), null, null, null, null, null, null, null);
 123                 nvpnManager.createExternalVpnInterfaces(input.getUuid());
 124             }
 125         }
 126     }
 127
 128     @Override
 129     protected void remove(InstanceIdentifier<Network> identifier, Network input) {
 130         LOG.trace("Removing Network : key: {}, value={}", identifier, input);
 131         if (NeutronvpnUtils.getIsExternal(input)) {
 132             if (NeutronvpnUtils.isFlatOrVlanNetwork(input)) {
 133                 nvpnManager.removeExternalVpnInterfaces(input.getUuid());
 134                 nvpnManager.removeVpn(input.getUuid());
 135             }
 136             nvpnNatManager.removeExternalNetwork(input);
 137         }
 138         //Delete ELAN instance for this network
 139         String elanInstanceName = input.getUuid().getValue();
 140         ElanInstance elanInstance = elanService.getElanInstance(elanInstanceName);
 141         if (elanInstance != null) {
 142             elanService.deleteExternalElanNetwork(elanInstance);
 143             deleteElanInstance(elanInstanceName);
 144         }
 145         neutronvpnUtils.removeFromNetworkCache(input);
 146     }
 147
 148     @Override
 149     protected void update(InstanceIdentifier<Network> identifier, Network original, Network update) {
 150         LOG.trace("Updating Network : key: {}, original value={}, update value={}", identifier, original, update);
 151         neutronvpnUtils.addToNetworkCache(update);
 152         String elanInstanceName = original.getUuid().getValue();
 153         Class<? extends SegmentTypeBase> origSegmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(original);
 154         String origSegmentationId = NeutronvpnUtils.getSegmentationIdFromNeutronNetwork(original);
 155         String origPhysicalNetwork = NeutronvpnUtils.getPhysicalNetworkName(original);
 156         Class<? extends SegmentTypeBase> updateSegmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(update);
 157         String updateSegmentationId = NeutronvpnUtils.getSegmentationIdFromNeutronNetwork(update);
 158         String updatePhysicalNetwork = NeutronvpnUtils.getPhysicalNetworkName(update);
 159         Boolean origExternal = NeutronvpnUtils.getIsExternal(original);
 160         Boolean updateExternal = NeutronvpnUtils.getIsExternal(update);
 161         Boolean origIsFlatOrVlanNetwork = NeutronvpnUtils.isFlatOrVlanNetwork(original);
 162         Boolean updateIsFlatOrVlanNetwork = NeutronvpnUtils.isFlatOrVlanNetwork(update);
 163
 164         if (!Objects.equals(origSegmentType, updateSegmentType)
 165                 || !Objects.equals(origSegmentationId, updateSegmentationId)
 166                 || !Objects.equals(origPhysicalNetwork, updatePhysicalNetwork)
 167                 || !Objects.equals(origExternal, updateExternal)) {
 168             if (origExternal && origIsFlatOrVlanNetwork && (!updateExternal || !updateIsFlatOrVlanNetwork)) {
 169                 nvpnManager.removeExternalVpnInterfaces(original.getUuid());
 170                 nvpnManager.removeVpn(original.getUuid());
 171                 nvpnNatManager.removeExternalNetwork(original);
 172             }
 173
 174             ElanInstance elanInstance = elanService.getElanInstance(elanInstanceName);
 175             if (elanInstance != null) {
 176                 elanService.deleteExternalElanNetwork(elanInstance);
 177                 elanInstance = updateElanInstance(elanInstanceName, updateSegmentType, updateSegmentationId,
 178                         updatePhysicalNetwork, update);
 179                 if (updateExternal) {
 180                     elanService.updateExternalElanNetwork(elanInstance);
 181                 }
 182             }
 183
 184             if (updateExternal && updateIsFlatOrVlanNetwork && !origExternal) {
 185                 nvpnNatManager.addExternalNetwork(update);
 186                 nvpnManager.createL3InternalVpn(update.getUuid(), null, null, null, null, null, null, null);
 187                 nvpnManager.createExternalVpnInterfaces(update.getUuid());
 188             }
 189         }
 190     }
 191
 192     @Nonnull
 193     private List<ElanSegments> buildSegments(Network input) {
 194         NetworkProviderExtension providerExtension = input.augmentation(NetworkProviderExtension.class);
 195         if (providerExtension == null || providerExtension.getSegments() == null) {
 196             return Collections.emptyList();
 197         }
 198         return providerExtension.getSegments().stream()
 199                 .map(segment -> new ElanSegmentsBuilder()
 200                         .setSegmentationIndex(segment.getSegmentationIndex())
 201                         .setSegmentationId(getSegmentationId(input, segment))
 202                         .setSegmentType(elanSegmentTypeFromNetworkType(segment.getNetworkType()))
 203                         .build())
 204                 .collect(Collectors.toList());
 205     }
 206
 207     private Long getSegmentationId(Network network, Segments segment) {
 208         try {
 209             if (segment.getSegmentationId() != null) {
 210                 return Long.valueOf(segment.getSegmentationId());
 211             }
 212         } catch (NumberFormatException error) {
 213             LOG.error("Failed to get the segment id for network {}", network);
 214         }
 215         return 0L;
 216     }
 217
 218     @Nullable
 219     private Class<? extends SegmentTypeBase> elanSegmentTypeFromNetworkType(
 220             @Nullable Class<? extends NetworkTypeBase> networkType) {
 221         if (networkType == null) {
 222             return null;
 223         }
 224         if (networkType.isAssignableFrom(NetworkTypeVxlan.class)) {
 225             return SegmentTypeVxlan.class;
 226         } else if (networkType.isAssignableFrom(NetworkTypeVlan.class)) {
 227             return SegmentTypeVlan.class;
 228         } else if (networkType.isAssignableFrom(NetworkTypeFlat.class)) {
 229             return SegmentTypeFlat.class;
 230         }
 231         return null;
 232     }
 233
 234     private ElanInstance createElanInstance(Network input) {
 235         String elanInstanceName = input.getUuid().getValue();
 236         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 237         Optional<ElanInstance> existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
 238                 id);
 239         if (existingElanInstance.isPresent()) {
 240             return existingElanInstance.get();
 241         }
 242         Class<? extends SegmentTypeBase> segmentType = NeutronvpnUtils.getSegmentTypeFromNeutronNetwork(input);
 243         String segmentationId = NeutronvpnUtils.getSegmentationIdFromNeutronNetwork(input);
 244         String physicalNetworkName = NeutronvpnUtils.getPhysicalNetworkName(input);
 245         long elanTag = elanService.retrieveNewElanTag(elanInstanceName);
 246         ElanInstance elanInstance = createElanInstanceBuilder(elanInstanceName, segmentType, segmentationId,
 247                 physicalNetworkName, input).setElanTag(elanTag).build();
 248         MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id, elanInstance);
 249         LOG.debug("ELANInstance {} created with elan tag {} and segmentation ID {}", elanInstanceName, elanTag,
 250                 segmentationId);
 251         return elanInstance;
 252     }
 253
 254     private ElanInstanceBuilder createElanInstanceBuilder(String elanInstanceName, Class<? extends SegmentTypeBase>
 255             segmentType, String segmentationId, String physicalNetworkName, Network network) {
 256         Boolean isExternal = NeutronvpnUtils.getIsExternal(network);
 257         List<ElanSegments> segments = buildSegments(network);
 258         ElanInstanceBuilder elanInstanceBuilder = new ElanInstanceBuilder().setElanInstanceName(elanInstanceName);
 259         if (segmentType != null) {
 260             elanInstanceBuilder.setSegmentType(segmentType);
 261             if (segmentationId != null) {
 262                 elanInstanceBuilder.setSegmentationId(Long.valueOf(segmentationId));
 263             }
 264             if (physicalNetworkName != null) {
 265                 elanInstanceBuilder.setPhysicalNetworkName(physicalNetworkName);
 266             }
 267         }
 268
 269         elanInstanceBuilder.setElanSegments(segments);
 270         elanInstanceBuilder.setExternal(isExternal);
 271         elanInstanceBuilder.withKey(new ElanInstanceKey(elanInstanceName));
 272         return elanInstanceBuilder;
 273     }
 274
 275     private void deleteElanInstance(String elanInstanceName) {
 276         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 277         MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
 278         LOG.debug("ELANInstance {} deleted", elanInstanceName);
 279     }
 280
 281     private ElanInstance updateElanInstance(String elanInstanceName, Class<? extends SegmentTypeBase> segmentType,
 282                                             String segmentationId, String physicalNetworkName, Network network) {
 283
 284         ElanInstance elanInstance = createElanInstanceBuilder(elanInstanceName, segmentType, segmentationId,
 285                 physicalNetworkName, network).build();
 286         InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
 287         MDSALUtil.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, id, elanInstance);
 288         return elanInstance;
 289     }
 290
 291     private InstanceIdentifier<ElanInstance> createElanInstanceIdentifier(String elanInstanceName) {
 292         InstanceIdentifier<ElanInstance> id = InstanceIdentifier.builder(ElanInstances.class)
 293                 .child(ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
 294         return id;
 295     }
 296 }