interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/listeners/InterfaceConfigListener.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.vpnservice.interfacemgr.listeners;
  10
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  13 import org.opendaylight.idmanager.IdManager;
  14 import org.opendaylight.vpnservice.datastoreutils.AsyncDataTreeChangeListenerBase;
  15 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  16 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.OvsInterfaceConfigAddHelper;
  17 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.OvsInterfaceConfigRemoveHelper;
  18 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.confighelpers.OvsInterfaceConfigUpdateHelper;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rev150331.ParentRefs;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 import java.util.List;
  27 import java.util.concurrent.Callable;
  28
  29 /**
  30  * This class listens for interface creation/removal/update in Configuration DS.
  31  * This is used to handle interfaces for base of-ports.
  32  */
  33 public class InterfaceConfigListener extends AsyncDataTreeChangeListenerBase<Interface, InterfaceConfigListener> {
  34     private static final Logger LOG = LoggerFactory.getLogger(InterfaceConfigListener.class);
  35     private DataBroker dataBroker;
  36     private IdManager idManager;
  37
  38     public InterfaceConfigListener(final DataBroker dataBroker, final IdManager idManager) {
  39         super(Interface.class, InterfaceConfigListener.class);
  40         this.dataBroker = dataBroker;
  41         this.idManager = idManager;
  42     }
  43
  44     @Override
  45     protected InstanceIdentifier<Interface> getWildCardPath() {
  46         return InstanceIdentifier.create(Interfaces.class).child(Interface.class);
  47     }
  48
  49     @Override
  50     protected InterfaceConfigListener getDataTreeChangeListener() {
  51         return InterfaceConfigListener.this;
  52     }
  53
  54     @Override
  55     protected void remove(InstanceIdentifier<Interface> key, Interface interfaceOld) {
  56         LOG.debug("Received Interface Remove Event: {}, {}", key, interfaceOld);
  57         String ifName = interfaceOld.getName();
  58         String parentInterface = null;
  59
  60         ParentRefs parentRefs = interfaceOld.getAugmentation(ParentRefs.class);
  61         if (parentRefs != null) {
  62             parentInterface = parentRefs.getParentInterface();
  63             if (parentInterface != null && !parentInterface.equals(ifName)) {
  64                 return;
  65             }
  66             if (parentRefs.getDatapathNodeIdentifier() == null) {
  67                 return;
  68             }
  69         }
  70
  71         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  72         RendererConfigRemoveWorker configWorker = new RendererConfigRemoveWorker(key, interfaceOld, ifName, parentRefs);
  73         coordinator.enqueueJob(ifName, configWorker);
  74     }
  75
  76     @Override
  77     protected void update(InstanceIdentifier<Interface> key, Interface interfaceOld, Interface interfaceNew) {
  78         LOG.debug("Received Interface Update Event: {}, {}, {}", key, interfaceOld, interfaceNew);
  79         String ifNameNew = interfaceNew.getName();
  80         String parentInterface = null;
  81
  82         ParentRefs parentRefs = interfaceNew.getAugmentation(ParentRefs.class);
  83         if (parentRefs != null) {
  84             parentInterface = parentRefs.getParentInterface();
  85         }
  86
  87         if (parentInterface != null && !parentInterface.equals(ifNameNew)) {
  88             return;
  89         }
  90
  91         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  92         RendererConfigUpdateWorker worker = new RendererConfigUpdateWorker(key, interfaceOld, interfaceNew, ifNameNew);
  93         coordinator.enqueueJob(ifNameNew, worker);
  94     }
  95
  96     @Override
  97     protected void add(InstanceIdentifier<Interface> key, Interface interfaceNew) {
  98         LOG.debug("Received Interface Add Event: {}, {}", key, interfaceNew);
  99         String ifName = interfaceNew.getName();
 100         String parentInterface = null;
 101
 102         ParentRefs parentRefs = interfaceNew.getAugmentation(ParentRefs.class);
 103         if (parentRefs != null) {
 104             parentInterface = parentRefs.getParentInterface();
 105         }
 106
 107         if (parentInterface != null && !parentInterface.equals(ifName)) {
 108             return;
 109         }
 110
 111         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 112         RendererConfigAddWorker configWorker = new RendererConfigAddWorker(key, interfaceNew, parentRefs, ifName);
 113         coordinator.enqueueJob(ifName, configWorker);
 114     }
 115
 116     private class RendererConfigAddWorker implements Callable<List<ListenableFuture<Void>>> {
 117         InstanceIdentifier<Interface> key;
 118         Interface interfaceNew;
 119         String portName;
 120         ParentRefs parentRefs;
 121
 122         public RendererConfigAddWorker(InstanceIdentifier<Interface> key, Interface interfaceNew,
 123                                        ParentRefs parentRefs, String portName) {
 124             this.key = key;
 125             this.interfaceNew = interfaceNew;
 126             this.portName = portName;
 127             this.parentRefs = parentRefs;
 128         }
 129
 130         @Override
 131         public List<ListenableFuture<Void>> call() throws Exception {
 132             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 133             // to call the respective helpers.
 134             return OvsInterfaceConfigAddHelper.addConfiguration(dataBroker, parentRefs, interfaceNew, idManager);
 135         }
 136
 137         @Override
 138         public String toString() {
 139             return "RendererConfigAddWorker{" +
 140                     "key=" + key +
 141                     ", interfaceNew=" + interfaceNew +
 142                     ", portName='" + portName + '\'' +
 143                     '}';
 144         }
 145     }
 146
 147     /**
 148      *
 149      */
 150     private class RendererConfigUpdateWorker implements Callable {
 151         InstanceIdentifier<Interface> key;
 152         Interface interfaceOld;
 153         Interface interfaceNew;
 154         String portNameNew;
 155
 156         public RendererConfigUpdateWorker(InstanceIdentifier<Interface> key, Interface interfaceOld,
 157                                           Interface interfaceNew, String portNameNew) {
 158             this.key = key;
 159             this.interfaceOld = interfaceOld;
 160             this.interfaceNew = interfaceNew;
 161             this.portNameNew = portNameNew;
 162         }
 163
 164         @Override
 165         public List<ListenableFuture<Void>> call() throws Exception {
 166             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 167             // to call the respective helpers.
 168             return OvsInterfaceConfigUpdateHelper.updateConfiguration(dataBroker, idManager, interfaceNew, interfaceOld);
 169         }
 170
 171         @Override
 172         public String toString() {
 173             return "RendererConfigUpdateWorker{" +
 174                     "key=" + key +
 175                     ", interfaceOld=" + interfaceOld +
 176                     ", interfaceNew=" + interfaceNew +
 177                     ", portNameNew='" + portNameNew + '\'' +
 178                     '}';
 179         }
 180     }
 181
 182     /**
 183      *
 184      */
 185     private class RendererConfigRemoveWorker implements Callable {
 186         InstanceIdentifier<Interface> key;
 187         Interface interfaceOld;
 188         String portName;
 189         ParentRefs parentRefs;
 190
 191         public RendererConfigRemoveWorker(InstanceIdentifier<Interface> key, Interface interfaceOld, String portName,
 192                                           ParentRefs parentRefs) {
 193             this.key = key;
 194             this.interfaceOld = interfaceOld;
 195             this.portName = portName;
 196             this.parentRefs = parentRefs;
 197         }
 198
 199         @Override
 200         public List<ListenableFuture<Void>> call() throws Exception {
 201             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 202             // to call the respective helpers.
 203             return OvsInterfaceConfigRemoveHelper.removeConfiguration(dataBroker, interfaceOld, idManager, parentRefs);
 204         }
 205
 206         @Override
 207         public String toString() {
 208             return "RendererConfigRemoveWorker{" +
 209                     "key=" + key +
 210                     ", interfaceOld=" + interfaceOld +
 211                     ", portName='" + portName + '\'' +
 212                     '}';
 213         }
 214     }
 215 }