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