itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java

   1 /*
   2  * Copyright (c) 2016, 2018 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.genius.itm.listeners;
   9
  10 import java.util.Optional;
  11 import javax.inject.Inject;
  12 import javax.inject.Singleton;
  13 import org.eclipse.jdt.annotation.NonNull;
  14 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  15 import org.opendaylight.genius.itm.cache.DpnTepStateCache;
  16 import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
  17 import org.opendaylight.genius.itm.confighelpers.ItmMonitorIntervalWorker;
  18 import org.opendaylight.genius.itm.confighelpers.ItmMonitorWorker;
  19 import org.opendaylight.genius.itm.impl.ItmUtils;
  20 import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
  21 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  22 import org.opendaylight.mdsal.binding.api.DataBroker;
  23 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner;
  24 import org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunnerImpl;
  25 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  26 import org.opendaylight.serviceutils.tools.listener.AbstractSyncDataTreeChangeListener;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 @Singleton
  35 public class TunnelMonitorIntervalListener extends AbstractSyncDataTreeChangeListener<TunnelMonitorInterval> {
  36
  37     private static final Logger LOG = LoggerFactory.getLogger(TunnelMonitorIntervalListener.class);
  38
  39     private final DataBroker broker;
  40     private final JobCoordinator jobCoordinator;
  41     private final DirectTunnelUtils directTunnelUtils;
  42     private final IInterfaceManager interfaceManager;
  43     private final DpnTepStateCache dpnTepStateCache;
  44     private final OvsBridgeRefEntryCache ovsBridgeRefEntryCache;
  45     private final ManagedNewTransactionRunner txRunner;
  46
  47     @Inject
  48     public TunnelMonitorIntervalListener(DataBroker dataBroker, JobCoordinator jobCoordinator,
  49                                          final DirectTunnelUtils directTunnelUtils,
  50                                          final DpnTepStateCache dpnTepStateCache,
  51                                          final OvsBridgeRefEntryCache ovsBridgeRefEntryCache,
  52                                          final IInterfaceManager interfaceManager) {
  53         super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(TunnelMonitorInterval.class));
  54         this.broker = dataBroker;
  55         this.jobCoordinator = jobCoordinator;
  56         this.directTunnelUtils = directTunnelUtils;
  57         this.dpnTepStateCache = dpnTepStateCache;
  58         this.interfaceManager = interfaceManager;
  59         this.ovsBridgeRefEntryCache = ovsBridgeRefEntryCache;
  60         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
  61     }
  62
  63     @Override
  64     public void remove(@NonNull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
  65                        @NonNull TunnelMonitorInterval dataObjectModification) {
  66         LOG.debug("remove TunnelMonitorIntervalListener called with {}", dataObjectModification.getInterval());
  67         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
  68         Optional<TransportZones> transportZonesOptional = ItmUtils
  69                 .read(LogicalDatastoreType.CONFIGURATION, path, broker);
  70         if (transportZonesOptional.isPresent()) {
  71             for (TransportZone tzone : transportZonesOptional.get().nonnullTransportZone()) {
  72                 //if you remove configuration, the last configured interval is only set i.e no change
  73                 LOG.debug("Remove:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
  74                           dataObjectModification.getInterval());
  75                 if (interfaceManager.isItmDirectTunnelsEnabled()) {
  76                     jobCoordinator.enqueueJob(tzone.getZoneName(), new ItmMonitorWorker(tzone.getZoneName(),
  77                         dataObjectModification.getInterval(), null, broker, directTunnelUtils, dpnTepStateCache,
  78                         ovsBridgeRefEntryCache));
  79                 } else {
  80                     ItmMonitorIntervalWorker toggleWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
  81                         dataObjectModification.getInterval().toJava(), broker);
  82                     jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
  83                 }
  84             }
  85         }
  86     }
  87
  88     @Override
  89     public void update(@NonNull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
  90                        @NonNull TunnelMonitorInterval dataObjectModificationBefore,
  91                        @NonNull TunnelMonitorInterval dataObjectModificationAfter) {
  92         LOG.debug("update TunnelMonitorIntervalListener called with {}", dataObjectModificationAfter.getInterval());
  93         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
  94         Optional<TransportZones> transportZonesOptional = ItmUtils
  95                 .read(LogicalDatastoreType.CONFIGURATION, path, broker);
  96         if (transportZonesOptional.isPresent()) {
  97             for (TransportZone tzone : transportZonesOptional.get().nonnullTransportZone()) {
  98                 LOG.debug("Update:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
  99                           dataObjectModificationAfter.getInterval());
 100                 if (interfaceManager.isItmDirectTunnelsEnabled()) {
 101                     ItmMonitorWorker monitorWorker = new ItmMonitorWorker(tzone.getZoneName(),
 102                         dataObjectModificationAfter.getInterval(), null, broker, directTunnelUtils,
 103                         dpnTepStateCache, ovsBridgeRefEntryCache);
 104                     jobCoordinator.enqueueJob(tzone.getZoneName(), monitorWorker);
 105                 } else {
 106                     ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
 107                         dataObjectModificationAfter.getInterval().toJava(), broker);
 108                     jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
 109                 }
 110             }
 111         }
 112     }
 113
 114     @Override
 115     public void add(@NonNull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
 116                     @NonNull TunnelMonitorInterval dataObjectModification) {
 117         LOG.debug("Add TunnelMonitorIntervalListener called with {}", dataObjectModification.getInterval());
 118         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
 119         Optional<TransportZones> transportZonesOptional = ItmUtils
 120                 .read(LogicalDatastoreType.CONFIGURATION, path, broker);
 121         if (transportZonesOptional.isPresent()) {
 122             for (TransportZone tzone : transportZonesOptional.get().nonnullTransportZone()) {
 123                 LOG.debug("Add:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
 124                           dataObjectModification.getInterval());
 125                 if (interfaceManager.isItmDirectTunnelsEnabled()) {
 126                     ItmMonitorWorker toggleWorker = new ItmMonitorWorker(tzone.getZoneName(),
 127                         dataObjectModification.getInterval(), null, broker, directTunnelUtils,
 128                         dpnTepStateCache, ovsBridgeRefEntryCache);
 129                     jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
 130                 } else {
 131                     ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
 132                         dataObjectModification.getInterval().toJava(), broker);
 133                     //conversion to milliseconds done while writing to i/f-mgr config DS
 134                     jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
 135                 }
 136             }
 137         }
 138     }
 139 }