2 * Copyright (c) 2015, 2017 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
8 package org.opendaylight.netvirt.neutronvpn;
10 import static org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils.buildfloatingIpIdToPortMappingIdentifier;
12 import com.google.common.base.Optional;
13 import com.google.common.util.concurrent.ListenableFuture;
15 import java.util.ArrayList;
16 import java.util.List;
18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
19 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
20 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
22 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
23 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
24 import org.opendaylight.genius.mdsalutil.MDSALUtil;
25 import org.opendaylight.genius.mdsalutil.NwConstants;
26 import org.opendaylight.netvirt.elanmanager.api.IElanService;
27 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
28 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronUtils;
29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlanBuilder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAcl;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.InterfaceAclBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.aclservice.rev160608.interfaces._interface.AllowedAddressPairs;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMappingBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.port.info.FloatingIpIdToPortMappingKey;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
52 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
53 import org.slf4j.Logger;
54 import org.slf4j.LoggerFactory;
56 public class NeutronPortChangeListener extends AsyncDataTreeChangeListenerBase<Port, NeutronPortChangeListener>
57 implements AutoCloseable {
58 private static final Logger LOG = LoggerFactory.getLogger(NeutronPortChangeListener.class);
59 private final DataBroker dataBroker;
60 private final NeutronvpnManager nvpnManager;
61 private final NeutronvpnNatManager nvpnNatManager;
62 private final NotificationPublishService notificationPublishService;
63 private final NeutronSubnetGwMacResolver gwMacResolver;
64 private final IElanService elanService;
66 public NeutronPortChangeListener(final DataBroker dataBroker,
67 final NeutronvpnManager neutronvpnManager,
68 final NeutronvpnNatManager neutronvpnNatManager,
69 final NotificationPublishService notiPublishService,
70 final NeutronSubnetGwMacResolver gwMacResolver,
71 final IElanService elanService) {
72 super(Port.class, NeutronPortChangeListener.class);
73 this.dataBroker = dataBroker;
74 nvpnManager = neutronvpnManager;
75 nvpnNatManager = neutronvpnNatManager;
76 notificationPublishService = notiPublishService;
77 this.gwMacResolver = gwMacResolver;
78 this.elanService = elanService;
83 LOG.info("{} start", getClass().getSimpleName());
84 registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
88 protected InstanceIdentifier<Port> getWildCardPath() {
89 return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
93 protected NeutronPortChangeListener getDataTreeChangeListener() {
94 return NeutronPortChangeListener.this;
99 protected void add(InstanceIdentifier<Port> identifier, Port input) {
100 String portName = input.getUuid().getValue();
101 LOG.trace("Adding Port : key: {}, value={}", identifier, input);
102 Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, input.getNetworkId());
103 if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
104 LOG.warn("neutron vpn received a port add() for a network without a provider extension augmentation "
105 + "or with an unsupported network type for the port {} which is part of network {}",
109 NeutronvpnUtils.addToPortCache(input);
111 /* check if router interface has been created */
112 if ((input.getDeviceOwner() != null) && (input.getDeviceId() != null)) {
113 if (input.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
114 handleRouterInterfaceAdded(input);
115 /* nothing else to do here */
118 if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(input.getDeviceOwner())) {
119 handleRouterGatewayUpdated(input);
120 } else if (NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(input.getDeviceOwner())) {
122 // populate floating-ip uuid and floating-ip port attributes (uuid, mac and subnet id for the ONLY
123 // fixed IP) to be used by NAT, depopulated in NATService once mac is retrieved in the removal path
124 addToFloatingIpPortInfo(new Uuid(input.getDeviceId()), input.getUuid(), input.getFixedIps().get(0)
125 .getSubnetId(), input.getMacAddress().getValue());
127 elanService.handleKnownL3DmacAddress(input.getMacAddress().getValue(), input.getNetworkId().getValue(),
128 NwConstants.ADD_FLOW);
131 if (input.getFixedIps() != null && !input.getFixedIps().isEmpty()) {
132 handleNeutronPortCreated(input);
137 protected void remove(InstanceIdentifier<Port> identifier, Port input) {
138 LOG.trace("Removing Port : key: {}, value={}", identifier, input);
139 Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, input.getNetworkId());
140 if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
141 String portName = input.getUuid().getValue();
142 LOG.warn("neutron vpn received a port remove() for a network without a provider extension augmentation "
143 + "or with an unsupported network type for the port {} which is part of network {}",
147 NeutronvpnUtils.removeFromPortCache(input);
149 if ((input.getDeviceOwner() != null) && (input.getDeviceId() != null)) {
150 if (input.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
151 handleRouterInterfaceRemoved(input);
152 /* nothing else to do here */
154 } else if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(input.getDeviceOwner())
155 || NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(input.getDeviceOwner())) {
156 elanService.handleKnownL3DmacAddress(input.getMacAddress().getValue(), input.getNetworkId().getValue(),
157 NwConstants.DEL_FLOW);
160 if (input.getFixedIps() != null && !input.getFixedIps().isEmpty()) {
161 handleNeutronPortDeleted(input);
166 // TODO Clean up the exception handling
167 @SuppressWarnings("checkstyle:IllegalCatch")
168 protected void update(InstanceIdentifier<Port> identifier, Port original, Port update) {
169 final String portName = update.getUuid().getValue();
170 LOG.trace("Updating Port : key: {}, original value={}, update value={}", identifier, original, update);
171 Network network = NeutronvpnUtils.getNeutronNetwork(dataBroker, update.getNetworkId());
172 if (network == null || !NeutronvpnUtils.isNetworkTypeSupported(network)) {
173 LOG.warn("neutron vpn received a port update() for a network without a provider extension augmentation "
174 + "or with an unsupported network type for the port {} which is part of network {}",
178 NeutronvpnUtils.addToPortCache(update);
180 /* check if router interface has been updated */
181 if ((update.getDeviceOwner() != null) && (update.getDeviceId() != null)) {
182 if (update.getDeviceOwner().equals(NeutronConstants.DEVICE_OWNER_ROUTER_INF)) {
183 handleRouterInterfaceAdded(update);
184 /* nothing else to do here */
189 // check if port security enabled/disabled as part of port update
190 boolean origSecurityEnabled = NeutronvpnUtils.getPortSecurityEnabled(original);
191 boolean updatedSecurityEnabled = NeutronvpnUtils.getPortSecurityEnabled(update);
193 if (origSecurityEnabled || updatedSecurityEnabled) {
194 InstanceIdentifier interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(portName);
195 final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
196 portDataStoreCoordinator.enqueueJob("PORT- " + portName, () -> {
197 WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
199 Optional<Interface> optionalInf = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType
200 .CONFIGURATION, interfaceIdentifier);
201 if (optionalInf.isPresent()) {
202 InterfaceBuilder interfaceBuilder = new InterfaceBuilder(optionalInf.get());
203 if (origSecurityEnabled || updatedSecurityEnabled) {
204 InterfaceAcl infAcl = handlePortSecurityUpdated(original, update,
205 origSecurityEnabled, updatedSecurityEnabled, interfaceBuilder).build();
206 interfaceBuilder.addAugmentation(InterfaceAcl.class, infAcl);
208 LOG.info("Of-port-interface updation for port {}", portName);
209 // Update OFPort interface for this neutron port
210 wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier,
211 interfaceBuilder.build());
213 LOG.error("Interface {} is not present", portName);
215 } catch (Exception e) {
216 LOG.error("Failed to update interface {} due to the exception {}", portName, e);
218 List<ListenableFuture<Void>> futures = new ArrayList<>();
219 futures.add(wrtConfigTxn.submit());
223 List<FixedIps> oldIPs = (original.getFixedIps() != null) ? original.getFixedIps() : new ArrayList<>();
224 List<FixedIps> newIPs = (update.getFixedIps() != null) ? update.getFixedIps() : new ArrayList<>();
225 if (!oldIPs.equals(newIPs)) {
226 newIPs.removeIf(oldIPs::remove);
227 handleNeutronPortUpdated(original, update);
229 if (NeutronConstants.DEVICE_OWNER_GATEWAY_INF.equals(update.getDeviceOwner())) {
230 handleRouterGatewayUpdated(update);
231 } else if (NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(update.getDeviceOwner())) {
232 elanService.handleKnownL3DmacAddress(update.getMacAddress().getValue(), update.getNetworkId().getValue(),
233 NwConstants.ADD_FLOW);
237 private void handleRouterInterfaceAdded(Port routerPort) {
238 if (routerPort.getDeviceId() != null) {
239 Uuid routerId = new Uuid(routerPort.getDeviceId());
240 Uuid infNetworkId = routerPort.getNetworkId();
241 Uuid existingVpnId = NeutronvpnUtils.getVpnForNetwork(dataBroker, infNetworkId);
243 elanService.handleKnownL3DmacAddress(routerPort.getMacAddress().getValue(), infNetworkId.getValue(),
244 NwConstants.ADD_FLOW);
245 if (existingVpnId == null) {
246 for (FixedIps portIP : routerPort.getFixedIps()) {
247 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(dataBroker, routerId, true);
251 // NOTE: Please donot change the order of calls to updateSubnetNodeWithFixedIP
252 // and addSubnetToVpn here
253 String ipValue = String.valueOf(portIP.getIpAddress().getValue());
254 nvpnManager.updateSubnetNodeWithFixedIp(portIP.getSubnetId(), routerId,
255 routerPort.getUuid(), ipValue, routerPort.getMacAddress().getValue());
256 nvpnManager.addSubnetToVpn(vpnId, portIP.getSubnetId());
257 nvpnNatManager.handleSubnetsForExternalRouter(routerId, dataBroker);
258 PhysAddress mac = new PhysAddress(routerPort.getMacAddress().getValue());
259 LOG.trace("NeutronPortChangeListener Add Subnet Gateway IP {} MAC {} Interface {} VPN {}",
260 ipValue, routerPort.getMacAddress(),
261 routerPort.getUuid().getValue(), vpnId.getValue());
262 // ping responder for router interfaces
263 nvpnManager.createVpnInterface(vpnId, routerId, routerPort, null);
266 LOG.error("Neutron network {} corresponding to router interface port {} for neutron router {} already"
267 + " associated to VPN {}", infNetworkId.getValue(), routerPort.getUuid().getValue(),
268 routerId.getValue(), existingVpnId.getValue());
273 private void handleRouterInterfaceRemoved(Port routerPort) {
274 if (routerPort.getDeviceId() != null) {
275 Uuid routerId = new Uuid(routerPort.getDeviceId());
276 Uuid infNetworkId = routerPort.getNetworkId();
278 elanService.handleKnownL3DmacAddress(routerPort.getMacAddress().getValue(), infNetworkId.getValue(),
279 NwConstants.DEL_FLOW);
280 for (FixedIps portIP : routerPort.getFixedIps()) {
281 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(dataBroker, routerId, true);
285 // NOTE: Please donot change the order of calls to removeSubnetFromVpn and
286 // and updateSubnetNodeWithFixedIP
287 nvpnManager.removeSubnetFromVpn(vpnId, portIP.getSubnetId());
288 nvpnManager.updateSubnetNodeWithFixedIp(portIP.getSubnetId(), null,
290 nvpnNatManager.handleSubnetsForExternalRouter(routerId, dataBroker);
291 String ipValue = String.valueOf(portIP.getIpAddress().getValue());
292 NeutronvpnUtils.removeVpnPortFixedIpToPort(dataBroker, vpnId.getValue(),
293 ipValue, null /*writeTransaction*/);
294 // ping responder for router interfaces
295 nvpnManager.deleteVpnInterface(vpnId, routerId, routerPort, null);
300 private void handleRouterGatewayUpdated(Port routerGwPort) {
301 Uuid routerId = new Uuid(routerGwPort.getDeviceId());
302 Uuid networkId = routerGwPort.getNetworkId();
303 elanService.handleKnownL3DmacAddress(routerGwPort.getMacAddress().getValue(), networkId.getValue(),
304 NwConstants.ADD_FLOW);
306 Router router = NeutronvpnUtils.getNeutronRouter(dataBroker, routerId);
307 if (router == null) {
308 LOG.warn("No router found for router GW port {} router id {}", routerGwPort.getUuid(), routerId.getValue());
311 gwMacResolver.sendArpRequestsToExtGateways(router);
314 private void handleNeutronPortCreated(final Port port) {
315 final String portName = port.getUuid().getValue();
316 final Uuid portId = port.getUuid();
317 final Uuid subnetId = port.getFixedIps().get(0).getSubnetId();
318 final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
319 portDataStoreCoordinator.enqueueJob("PORT- " + portName, () -> {
320 WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
321 List<ListenableFuture<Void>> futures = new ArrayList<>();
323 // add direct port to subnetMaps config DS
324 if (!NeutronUtils.isPortVnicTypeNormal(port)) {
325 nvpnManager.updateSubnetmapNodeWithPorts(subnetId, null, portId);
326 LOG.info("Port {} is not a NORMAL VNIC Type port; OF Port interfaces are not created", portName);
327 futures.add(wrtConfigTxn.submit());
330 LOG.info("Of-port-interface creation for port {}", portName);
331 // Create of-port interface for this neutron port
332 String portInterfaceName = createOfPortInterface(port, wrtConfigTxn);
333 LOG.debug("Creating ELAN Interface for port {}", portName);
334 createElanInterface(port, portInterfaceName, wrtConfigTxn);
336 Subnetmap subnetMap = nvpnManager.updateSubnetmapNodeWithPorts(subnetId, portId, null);
337 Uuid vpnId = (subnetMap != null) ? subnetMap.getVpnId() : null;
338 Uuid routerId = (subnetMap != null) ? subnetMap.getRouterId() : null;
340 // create vpn-interface on this neutron port
341 LOG.debug("Adding VPN Interface for port {}", portName);
342 nvpnManager.createVpnInterface(vpnId, routerId, port, wrtConfigTxn);
344 futures.add(wrtConfigTxn.submit());
349 private void handleNeutronPortDeleted(final Port port) {
350 final String portName = port.getUuid().getValue();
351 final Uuid portId = port.getUuid();
352 final Uuid subnetId = port.getFixedIps().get(0).getSubnetId();
353 final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
354 portDataStoreCoordinator.enqueueJob("PORT- " + portName, () -> {
355 WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
356 List<ListenableFuture<Void>> futures = new ArrayList<>();
358 // remove direct port from subnetMaps config DS
359 if (!NeutronUtils.isPortVnicTypeNormal(port)) {
360 nvpnManager.removePortsFromSubnetmapNode(subnetId, null, portId);
361 LOG.info("Port {} is not a NORMAL VNIC Type port; OF Port interfaces are not created", portName);
362 futures.add(wrtConfigTxn.submit());
365 Subnetmap subnetMap = nvpnManager.removePortsFromSubnetmapNode(subnetId, portId, null);
366 Uuid vpnId = (subnetMap != null) ? subnetMap.getVpnId() : null;
367 Uuid routerId = (subnetMap != null) ? subnetMap.getRouterId() : null;
369 // remove vpn-interface for this neutron port
370 LOG.debug("removing VPN Interface for port {}", portName);
371 nvpnManager.deleteVpnInterface(vpnId, routerId, port, wrtConfigTxn);
373 // Remove of-port interface for this neutron port
374 // ELAN interface is also implicitly deleted as part of this operation
375 LOG.debug("Of-port-interface removal for port {}", portName);
376 deleteOfPortInterface(port, wrtConfigTxn);
377 //dissociate fixedIP from floatingIP if associated
378 nvpnManager.dissociatefixedIPFromFloatingIP(port.getUuid().getValue());
379 futures.add(wrtConfigTxn.submit());
384 private void handleNeutronPortUpdated(final Port portoriginal, final Port portupdate) {
385 if (portoriginal.getFixedIps() == null || portoriginal.getFixedIps().isEmpty()) {
386 handleNeutronPortCreated(portupdate);
390 if (portupdate.getFixedIps() == null || portupdate.getFixedIps().isEmpty()) {
391 LOG.debug("Ignoring portUpdate (fixed_ip removal) for port {} as this case is handled "
392 + "during subnet deletion event.", portupdate.getUuid().getValue());
396 final DataStoreJobCoordinator portDataStoreCoordinator = DataStoreJobCoordinator.getInstance();
397 portDataStoreCoordinator.enqueueJob("PORT- " + portupdate.getUuid().getValue(), () -> {
398 WriteTransaction wrtConfigTxn = dataBroker.newWriteOnlyTransaction();
399 Uuid vpnIdNew = null;
400 final Uuid subnetIdOr = portupdate.getFixedIps().get(0).getSubnetId();
401 final Uuid subnetIdUp = portupdate.getFixedIps().get(0).getSubnetId();
402 // check if subnet UUID has changed upon change in fixedIP
403 final Boolean subnetUpdated = subnetIdUp.equals(subnetIdOr) ? false : true;
406 Subnetmap subnetMapOld = nvpnManager.removePortsFromSubnetmapNode(subnetIdOr, portoriginal
408 Uuid vpnIdOld = (subnetMapOld != null) ? subnetMapOld.getVpnId() : null;
409 Subnetmap subnetMapNew = nvpnManager.updateSubnetmapNodeWithPorts(subnetIdUp, portupdate
411 vpnIdNew = (subnetMapNew != null) ? subnetMapNew.getVpnId() : null;
413 if (!subnetUpdated) {
414 Subnetmap subnetmap = NeutronvpnUtils.getSubnetmap(dataBroker, subnetIdUp);
415 vpnIdNew = subnetmap != null ? subnetmap.getVpnId() : null;
417 if (vpnIdNew != null) {
418 // remove vpn-interface for this neutron port
419 LOG.debug("removing VPN Interface for port {}", portupdate.getUuid().getValue());
420 nvpnManager.deleteVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
421 // create vpn-interface on this neutron port
422 LOG.debug("Adding VPN Interface for port {}", portupdate.getUuid().getValue());
423 nvpnManager.createVpnInterface(vpnIdNew, null, portupdate, wrtConfigTxn);
425 List<ListenableFuture<Void>> futures = new ArrayList<>();
426 futures.add(wrtConfigTxn.submit());
431 private static InterfaceAclBuilder handlePortSecurityUpdated(Port portOriginal, Port portUpdated, boolean
432 origSecurityEnabled, boolean updatedSecurityEnabled, InterfaceBuilder interfaceBuilder) {
433 String interfaceName = portUpdated.getUuid().getValue();
434 InterfaceAclBuilder interfaceAclBuilder = null;
435 if (origSecurityEnabled != updatedSecurityEnabled) {
436 interfaceAclBuilder = new InterfaceAclBuilder();
437 interfaceAclBuilder.setPortSecurityEnabled(updatedSecurityEnabled);
438 if (updatedSecurityEnabled) {
439 // Handle security group enabled
440 NeutronvpnUtils.populateInterfaceAclBuilder(interfaceAclBuilder, portUpdated);
442 // Handle security group disabled
443 interfaceAclBuilder.setSecurityGroups(new ArrayList<>());
444 interfaceAclBuilder.setAllowedAddressPairs(new ArrayList<>());
447 if (updatedSecurityEnabled) {
448 // handle SG add/delete delta
449 InterfaceAcl interfaceAcl = interfaceBuilder.getAugmentation(InterfaceAcl.class);
450 interfaceAclBuilder = new InterfaceAclBuilder(interfaceAcl);
451 interfaceAclBuilder.setSecurityGroups(
452 NeutronvpnUtils.getUpdatedSecurityGroups(interfaceAcl.getSecurityGroups(),
453 portOriginal.getSecurityGroups(), portUpdated.getSecurityGroups()));
454 List<AllowedAddressPairs> updatedAddressPairs = NeutronvpnUtils.getUpdatedAllowedAddressPairs(
455 interfaceAcl.getAllowedAddressPairs(), portOriginal.getAllowedAddressPairs(),
456 portUpdated.getAllowedAddressPairs());
457 interfaceAclBuilder.setAllowedAddressPairs(NeutronvpnUtils.getAllowedAddressPairsForFixedIps(
458 updatedAddressPairs, portOriginal.getMacAddress(), portOriginal.getFixedIps(),
459 portUpdated.getFixedIps()));
462 return interfaceAclBuilder;
465 // TODO Clean up the exception handling
466 @SuppressWarnings("checkstyle:IllegalCatch")
467 private String createOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
468 Interface inf = createInterface(port);
469 String infName = inf.getName();
471 LOG.debug("Creating OFPort Interface {}", infName);
472 InstanceIdentifier interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(infName);
474 Optional<Interface> optionalInf = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
475 interfaceIdentifier);
476 if (!optionalInf.isPresent()) {
477 wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, inf);
479 LOG.warn("Interface {} is already present", infName);
481 } catch (Exception e) {
482 LOG.error("failed to create interface {} due to the exception {} ", infName, e.getMessage());
487 private Interface createInterface(Port port) {
488 String interfaceName = port.getUuid().getValue();
489 IfL2vlan.L2vlanMode l2VlanMode = IfL2vlan.L2vlanMode.Trunk;
490 InterfaceBuilder interfaceBuilder = new InterfaceBuilder();
491 IfL2vlanBuilder ifL2vlanBuilder = new IfL2vlanBuilder();
492 ifL2vlanBuilder.setL2vlanMode(l2VlanMode);
494 interfaceBuilder.setEnabled(true).setName(interfaceName).setType(L2vlan.class)
495 .addAugmentation(IfL2vlan.class, ifL2vlanBuilder.build());
497 if (NeutronvpnUtils.getPortSecurityEnabled(port)) {
498 InterfaceAclBuilder interfaceAclBuilder = new InterfaceAclBuilder();
499 interfaceAclBuilder.setPortSecurityEnabled(true);
500 NeutronvpnUtils.populateInterfaceAclBuilder(interfaceAclBuilder, port);
501 interfaceBuilder.addAugmentation(InterfaceAcl.class, interfaceAclBuilder.build());
503 return interfaceBuilder.build();
506 // TODO Clean up the exception handling
507 @SuppressWarnings("checkstyle:IllegalCatch")
508 private void deleteOfPortInterface(Port port, WriteTransaction wrtConfigTxn) {
509 String name = port.getUuid().getValue();
510 LOG.debug("Removing OFPort Interface {}", name);
511 InstanceIdentifier interfaceIdentifier = NeutronvpnUtils.buildVlanInterfaceIdentifier(name);
513 Optional<Interface> optionalInf = NeutronvpnUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
514 interfaceIdentifier);
515 if (optionalInf.isPresent()) {
516 wrtConfigTxn.delete(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier);
518 LOG.error("Interface {} is not present", name);
520 } catch (Exception e) {
521 LOG.error("Failed to delete interface {} due to the exception {}", name, e.getMessage());
525 private void createElanInterface(Port port, String name, WriteTransaction wrtConfigTxn) {
526 String elanInstanceName = port.getNetworkId().getValue();
527 List<PhysAddress> physAddresses = new ArrayList<>();
528 physAddresses.add(new PhysAddress(port.getMacAddress().getValue()));
530 InstanceIdentifier<ElanInterface> id = InstanceIdentifier.builder(ElanInterfaces.class).child(ElanInterface
531 .class, new ElanInterfaceKey(name)).build();
532 ElanInterface elanInterface = new ElanInterfaceBuilder().setElanInstanceName(elanInstanceName)
533 .setName(name).setStaticMacEntries(physAddresses).setKey(new ElanInterfaceKey(name)).build();
534 wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, elanInterface);
535 LOG.debug("Creating new ELan Interface {}", elanInterface);
538 // TODO Clean up the exception handling
539 @SuppressWarnings("checkstyle:IllegalCatch")
540 private void addToFloatingIpPortInfo(Uuid floatingIpId, Uuid floatingIpPortId, Uuid floatingIpPortSubnetId, String
541 floatingIpPortMacAddress) {
542 InstanceIdentifier id = buildfloatingIpIdToPortMappingIdentifier(floatingIpId);
544 FloatingIpIdToPortMappingBuilder floatingipIdToPortMacMappingBuilder = new
545 FloatingIpIdToPortMappingBuilder().setKey(new FloatingIpIdToPortMappingKey(floatingIpId))
546 .setFloatingIpId(floatingIpId).setFloatingIpPortId(floatingIpPortId)
547 .setFloatingIpPortSubnetId(floatingIpPortSubnetId)
548 .setFloatingIpPortMacAddress(floatingIpPortMacAddress);
549 LOG.debug("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
550 + " Port Info Config DS", floatingIpId.getValue(), floatingIpPortId.getValue());
551 MDSALUtil.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, id,
552 floatingipIdToPortMacMappingBuilder.build());
553 } catch (Exception e) {
554 LOG.error("Creating floating IP UUID {} to Floating IP neutron port {} mapping in Floating IP"
555 + " Port Info Config DS failed with exception {}",
556 floatingIpId.getValue(), floatingIpPortId.getValue(), e);