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