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