interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/listeners/HwVTEPConfigListener.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 package org.opendaylight.vpnservice.interfacemgr.listeners;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  12 import org.opendaylight.vpnservice.datastoreutils.AsyncDataTreeChangeListenerBase;
  13 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  14 import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.confighelpers.HwVTEPConfigRemoveHelper;
  15 import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.confighelpers.HwVTEPInterfaceConfigAddHelper;
  16 import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.confighelpers.HwVTEPInterfaceConfigUpdateHelper;
  17 import org.opendaylight.vpnservice.interfacemgr.renderer.hwvtep.utilities.SouthboundUtils;
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.AlivenessMonitorService;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.IfTunnel;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.ParentRefs;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.TunnelTypeVxlan;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.interfaces._interface.NodeIdentifier;
  25 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  26 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 import java.util.List;
  32 import java.util.concurrent.Callable;
  33
  34 public class HwVTEPConfigListener extends AsyncDataTreeChangeListenerBase<Interface, HwVTEPConfigListener> {
  35     private static final Logger LOG = LoggerFactory.getLogger(HwVTEPConfigListener.class);
  36     private DataBroker dataBroker;
  37
  38     public HwVTEPConfigListener(final DataBroker dataBroker) {
  39         super(Interface.class, HwVTEPConfigListener.class);
  40         this.dataBroker = dataBroker;
  41     }
  42
  43     @Override
  44     protected InstanceIdentifier<Interface> getWildCardPath() {
  45         return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
  46     }
  47
  48     @Override
  49     protected void remove(InstanceIdentifier<Interface> key, Interface interfaceOld) {
  50         // HwVTEPs support only vxlan
  51         IfTunnel ifTunnel = interfaceOld.getAugmentation(IfTunnel.class);
  52         if (ifTunnel != null && ifTunnel.getTunnelInterfaceType().isAssignableFrom(TunnelTypeVxlan.class)) {
  53             ParentRefs parentRefs = interfaceOld.getAugmentation(ParentRefs.class);
  54             if (parentRefs != null && parentRefs.getNodeIdentifier() != null) {
  55                 for(NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
  56                     if(SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
  57                         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  58                         RendererConfigRemoveWorker configWorker = new RendererConfigRemoveWorker(key, interfaceOld,
  59                                 SouthboundUtils.createPhysicalSwitchInstanceIdentifier(nodeIdentifier.getNodeId()),
  60                                 SouthboundUtils.createGlobalNodeInstanceIdentifier(dataBroker, nodeIdentifier.getNodeId()));
  61                         coordinator.enqueueJob(interfaceOld.getName(), configWorker);
  62                     }
  63                 }
  64             }
  65         }
  66     }
  67
  68     @Override
  69     protected void update(InstanceIdentifier<Interface> key, Interface interfaceOld, Interface interfaceNew) {
  70         // HwVTEPs support only vxlan
  71         IfTunnel ifTunnel = interfaceNew.getAugmentation(IfTunnel.class);
  72         if (ifTunnel != null && ifTunnel.getTunnelInterfaceType().isAssignableFrom(TunnelTypeVxlan.class)) {
  73             ParentRefs parentRefs = interfaceNew.getAugmentation(ParentRefs.class);
  74             if (parentRefs != null && parentRefs.getNodeIdentifier() != null) {
  75                 for(NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
  76                     if(SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
  77                         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  78                         RendererConfigUpdateWorker configWorker = new RendererConfigUpdateWorker(key, interfaceNew,
  79                                 SouthboundUtils.createPhysicalSwitchInstanceIdentifier(nodeIdentifier.getNodeId()),
  80                                 SouthboundUtils.createGlobalNodeInstanceIdentifier(dataBroker, nodeIdentifier.getNodeId()), ifTunnel);
  81                         coordinator.enqueueJob(interfaceNew.getName(), configWorker, 3);
  82                     }
  83                 }
  84             }
  85         }
  86     }
  87
  88     @Override
  89     protected void add(InstanceIdentifier<Interface> key, Interface interfaceNew) {
  90         // HwVTEPs support only vxlan
  91         IfTunnel ifTunnel = interfaceNew.getAugmentation(IfTunnel.class);
  92         if (ifTunnel != null && ifTunnel.getTunnelInterfaceType().isAssignableFrom(TunnelTypeVxlan.class)) {
  93             ParentRefs parentRefs = interfaceNew.getAugmentation(ParentRefs.class);
  94             if (parentRefs != null && parentRefs.getNodeIdentifier() != null) {
  95                 for(NodeIdentifier nodeIdentifier : parentRefs.getNodeIdentifier()) {
  96                     if(SouthboundUtils.HWVTEP_TOPOLOGY.equals(nodeIdentifier.getTopologyId())) {
  97                         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  98                         RendererConfigAddWorker configWorker = new RendererConfigAddWorker(key, interfaceNew,
  99                                 SouthboundUtils.createPhysicalSwitchInstanceIdentifier(nodeIdentifier.getNodeId()),
 100                                 SouthboundUtils.createGlobalNodeInstanceIdentifier(dataBroker, nodeIdentifier.getNodeId()), ifTunnel);
 101                         coordinator.enqueueJob(interfaceNew.getName(), configWorker, 3);
 102                     }
 103                 }
 104             }
 105         }
 106     }
 107
 108     @Override
 109     protected HwVTEPConfigListener getDataTreeChangeListener() {
 110         return HwVTEPConfigListener.this;
 111     }
 112
 113     private class RendererConfigAddWorker implements Callable<List<ListenableFuture<Void>>> {
 114         InstanceIdentifier<Interface> key;
 115         Interface interfaceNew;
 116         InstanceIdentifier<Node> physicalSwitchNodeId;
 117         InstanceIdentifier<Node> globalNodeId;
 118         IfTunnel ifTunnel;
 119
 120         public RendererConfigAddWorker(InstanceIdentifier<Interface> key, Interface interfaceNew,
 121                                        InstanceIdentifier<Node> physicalSwitchNodeId, InstanceIdentifier<Node> globalNodeId, IfTunnel ifTunnel) {
 122             this.key = key;
 123             this.interfaceNew = interfaceNew;
 124             this.physicalSwitchNodeId = physicalSwitchNodeId;
 125             this.globalNodeId = globalNodeId;
 126             this.ifTunnel = ifTunnel;
 127         }
 128
 129         @Override
 130         public List<ListenableFuture<Void>> call() throws Exception {
 131             return HwVTEPInterfaceConfigAddHelper.addConfiguration(dataBroker,
 132                     physicalSwitchNodeId, globalNodeId, interfaceNew, ifTunnel);
 133         }
 134     }
 135
 136     private class RendererConfigUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
 137         InstanceIdentifier<Interface> key;
 138         Interface interfaceNew;
 139         InstanceIdentifier<Node> globalNodeId;
 140         InstanceIdentifier<Node> physicalSwitchNodeId;
 141         IfTunnel ifTunnel;
 142
 143         public RendererConfigUpdateWorker(InstanceIdentifier<Interface> key, Interface interfaceNew,
 144                                        InstanceIdentifier<Node> physicalSwitchNodeId, InstanceIdentifier<Node> globalNodeId, IfTunnel ifTunnel) {
 145             this.key = key;
 146             this.interfaceNew = interfaceNew;
 147             this.physicalSwitchNodeId = physicalSwitchNodeId;
 148             this.ifTunnel = ifTunnel;
 149             this.globalNodeId = globalNodeId;
 150         }
 151
 152         @Override
 153         public List<ListenableFuture<Void>> call() throws Exception {
 154             return HwVTEPInterfaceConfigUpdateHelper.updateConfiguration(dataBroker,
 155                     physicalSwitchNodeId, globalNodeId, interfaceNew, ifTunnel);
 156         }
 157     }
 158
 159     private class RendererConfigRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
 160         InstanceIdentifier<Interface> key;
 161         Interface interfaceOld;
 162         InstanceIdentifier<Node> physicalSwitchNodeId;
 163         InstanceIdentifier<Node> globalNodeId;
 164
 165         public RendererConfigRemoveWorker(InstanceIdentifier<Interface> key, Interface interfaceOld,
 166                                           InstanceIdentifier<Node> physicalSwitchNodeId, InstanceIdentifier<Node> globalNodeId) {
 167             this.key = key;
 168             this.interfaceOld = interfaceOld;
 169             this.physicalSwitchNodeId = physicalSwitchNodeId;
 170             this.globalNodeId = globalNodeId;
 171         }
 172
 173         @Override
 174         public List<ListenableFuture<Void>> call() throws Exception {
 175             return HwVTEPConfigRemoveHelper.removeConfiguration(dataBroker,
 176                     interfaceOld, globalNodeId, physicalSwitchNodeId);
 177         }
 178     }
 179 }