interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/listeners/InterfaceInventoryStateListener.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 package org.opendaylight.vpnservice.interfacemgr.listeners;
   9
  10 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  11 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  12 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  13 import org.opendaylight.idmanager.IdManager;
  14 import org.opendaylight.vpnservice.datastoreutils.AsyncDataChangeListenerBase;
  15 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  16 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceStateAddHelper;
  17 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceStateRemoveHelper;
  18 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceStateRemoveHelper;
  19 import org.opendaylight.vpnservice.interfacemgr.renderer.ovs.statehelpers.OvsInterfaceStateUpdateHelper;
  20 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 import java.util.concurrent.Callable;
  32
  33 /**
  34  *
  35  * This Class is a Data Change Listener for FlowCapableNodeConnector updates.
  36  * This creates an entry in the interface-state OperDS for every node-connector used.
  37  *
  38  * NOTE: This class just creates an ifstate entry whose interface-name will be the same as the node-connector portname.
  39  * If PortName is not unique across DPNs, this implementation can have problems.
  40  */
  41
  42 public class InterfaceInventoryStateListener extends AsyncDataChangeListenerBase<FlowCapableNodeConnector, InterfaceInventoryStateListener> implements AutoCloseable{
  43     private static final Logger LOG = LoggerFactory.getLogger(InterfaceInventoryStateListener.class);
  44     private DataBroker dataBroker;
  45     private IdManagerService idManager;
  46     private IMdsalApiManager mdsalApiManager;
  47
  48     public InterfaceInventoryStateListener(final DataBroker dataBroker, final IdManagerService idManager, final IMdsalApiManager mdsalApiManager) {
  49         super(FlowCapableNodeConnector.class, InterfaceInventoryStateListener.class);
  50         this.dataBroker = dataBroker;
  51         this.idManager = idManager;
  52         this.mdsalApiManager = mdsalApiManager;
  53     }
  54
  55     @Override
  56     protected InstanceIdentifier<FlowCapableNodeConnector> getWildCardPath() {
  57         return InstanceIdentifier.create(Nodes.class).child(Node.class).child(NodeConnector.class)
  58                 .augmentation(FlowCapableNodeConnector.class);
  59     }
  60
  61     @Override
  62     protected DataChangeListener getDataChangeListener() {
  63         return InterfaceInventoryStateListener.this;
  64     }
  65
  66     @Override
  67     protected AsyncDataBroker.DataChangeScope getDataChangeScope() {
  68         return AsyncDataBroker.DataChangeScope.BASE;
  69     }
  70
  71     @Override
  72     protected void remove(InstanceIdentifier<FlowCapableNodeConnector> key,
  73                           FlowCapableNodeConnector flowCapableNodeConnectorOld) {
  74         LOG.debug("Received NodeConnector Remove Event: {}, {}", key, flowCapableNodeConnectorOld);
  75         String portName = flowCapableNodeConnectorOld.getName();
  76         NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
  77         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  78
  79         InterfaceStateRemoveWorker interfaceStateRemoveWorker = new InterfaceStateRemoveWorker(idManager, key,
  80                 flowCapableNodeConnectorOld, portName);
  81         coordinator.enqueueJob(portName, interfaceStateRemoveWorker);
  82     }
  83
  84     @Override
  85     protected void update(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorOld,
  86                           FlowCapableNodeConnector fcNodeConnectorNew) {
  87         LOG.debug("Received NodeConnector Update Event: {}, {}, {}", key, fcNodeConnectorOld, fcNodeConnectorNew);
  88         String portName = fcNodeConnectorNew.getName();
  89         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
  90
  91         InterfaceStateUpdateWorker interfaceStateUpdateWorker = new InterfaceStateUpdateWorker(key, fcNodeConnectorOld,
  92                 fcNodeConnectorNew, portName);
  93         coordinator.enqueueJob(portName, interfaceStateUpdateWorker);
  94     }
  95
  96     @Override
  97     protected void add(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorNew) {
  98         LOG.debug("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
  99         String portName = fcNodeConnectorNew.getName();
 100         NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
 101
 102         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
 103         InterfaceStateAddWorker ifStateAddWorker = new InterfaceStateAddWorker(idManager, nodeConnectorId,
 104                 fcNodeConnectorNew, portName);
 105         coordinator.enqueueJob(portName, ifStateAddWorker);
 106     }
 107
 108     private class InterfaceStateAddWorker implements Callable {
 109         private final NodeConnectorId nodeConnectorId;
 110         private final FlowCapableNodeConnector fcNodeConnectorNew;
 111         private final String portName;
 112         private final IdManagerService idManager;
 113
 114         public InterfaceStateAddWorker(IdManagerService idManager, NodeConnectorId nodeConnectorId,
 115                                        FlowCapableNodeConnector fcNodeConnectorNew,
 116                                        String portName) {
 117             this.nodeConnectorId = nodeConnectorId;
 118             this.fcNodeConnectorNew = fcNodeConnectorNew;
 119             this.portName = portName;
 120             this.idManager = idManager;
 121         }
 122
 123         @Override
 124         public Object call() throws Exception {
 125             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 126             // to call the respective helpers.
 127              return OvsInterfaceStateAddHelper.addState(dataBroker, idManager, mdsalApiManager, nodeConnectorId,
 128                      portName, fcNodeConnectorNew);
 129         }
 130
 131         @Override
 132         public String toString() {
 133             return "InterfaceStateAddWorker{" +
 134                     "nodeConnectorId=" + nodeConnectorId +
 135                     ", fcNodeConnectorNew=" + fcNodeConnectorNew +
 136                     ", portName='" + portName + '\'' +
 137                     '}';
 138         }
 139     }
 140
 141     private class InterfaceStateUpdateWorker implements Callable {
 142         private InstanceIdentifier<FlowCapableNodeConnector> key;
 143         private final FlowCapableNodeConnector fcNodeConnectorOld;
 144         private final FlowCapableNodeConnector fcNodeConnectorNew;
 145         private String portName;
 146
 147
 148         public InterfaceStateUpdateWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
 149                                           FlowCapableNodeConnector fcNodeConnectorOld,
 150                                           FlowCapableNodeConnector fcNodeConnectorNew,
 151                                           String portName) {
 152             this.key = key;
 153             this.fcNodeConnectorOld = fcNodeConnectorOld;
 154             this.fcNodeConnectorNew = fcNodeConnectorNew;
 155             this.portName = portName;
 156         }
 157
 158         @Override
 159         public Object call() throws Exception {
 160             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 161             // to call the respective helpers.
 162             return OvsInterfaceStateUpdateHelper.updateState(key, dataBroker, portName,
 163                     fcNodeConnectorNew, fcNodeConnectorOld);
 164         }
 165
 166         @Override
 167         public String toString() {
 168             return "InterfaceStateUpdateWorker{" +
 169                     "key=" + key +
 170                     ", fcNodeConnectorOld=" + fcNodeConnectorOld +
 171                     ", fcNodeConnectorNew=" + fcNodeConnectorNew +
 172                     ", portName='" + portName + '\'' +
 173                     '}';
 174         }
 175     }
 176
 177     private class InterfaceStateRemoveWorker implements Callable {
 178         InstanceIdentifier<FlowCapableNodeConnector> key;
 179         FlowCapableNodeConnector fcNodeConnectorOld;
 180         private final String portName;
 181         private final IdManagerService idManager;
 182
 183         public InterfaceStateRemoveWorker(IdManagerService idManager,
 184                                           InstanceIdentifier<FlowCapableNodeConnector> key,
 185                                           FlowCapableNodeConnector fcNodeConnectorOld,
 186                                           String portName) {
 187             this.key = key;
 188             this.fcNodeConnectorOld = fcNodeConnectorOld;
 189             this.portName = portName;
 190             this.idManager = idManager;
 191         }
 192
 193         @Override
 194         public Object call() throws Exception {
 195             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
 196             // to call the respective helpers.
 197             return OvsInterfaceStateRemoveHelper.removeState(idManager, mdsalApiManager, key, dataBroker, portName, fcNodeConnectorOld);
 198         }
 199
 200         @Override
 201         public String toString() {
 202             return "InterfaceStateRemoveWorker{" +
 203                     "key=" + key +
 204                     ", fcNodeConnectorOld=" + fcNodeConnectorOld +
 205                     ", portName='" + portName + '\'' +
 206                     '}';
 207         }
 208     }
 209 }