git.opendaylight Code Review - netvirt.git/blob

   1 /*
   2  * Copyright (c) 2017 Intel Corporation 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.netvirt.qosservice;
   9
  10
  11 import javax.annotation.PostConstruct;
  12 import javax.inject.Inject;
  13 import javax.inject.Singleton;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  16 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  17 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  18 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.ext.rev160613.QosPortExtension;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  24 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 @Singleton
  29 public class QosNeutronPortChangeListener extends AsyncDataTreeChangeListenerBase<Port, QosNeutronPortChangeListener>
  30     implements AutoCloseable {
  31     private static final Logger LOG = LoggerFactory.getLogger(QosNeutronPortChangeListener.class);
  32     private final DataBroker dataBroker;
  33     private final OdlInterfaceRpcService odlInterfaceRpcService;
  34     private final INeutronVpnManager neutronVpnManager;
  35     private  final IMdsalApiManager mdsalUtils;
  36
  37     @Inject
  38     public QosNeutronPortChangeListener(final DataBroker dataBroker,
  39                                         final INeutronVpnManager neutronVpnManager,
  40                                         final OdlInterfaceRpcService odlInterfaceRpcService,
  41                                         final IMdsalApiManager mdsalUtils) {
  42         super(Port.class, QosNeutronPortChangeListener.class);
  43         this.dataBroker = dataBroker;
  44         this.neutronVpnManager = neutronVpnManager;
  45         this.odlInterfaceRpcService = odlInterfaceRpcService;
  46         this.mdsalUtils = mdsalUtils;
  47         LOG.info("{} created",  getClass().getSimpleName());
  48     }
  49
  50     @Override
  51     @PostConstruct
  52     public void init() {
  53         registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
  54         LOG.info("{} init and registerListener done", getClass().getSimpleName());
  55     }
  56
  57     @Override
  58     protected InstanceIdentifier<Port> getWildCardPath() {
  59         return InstanceIdentifier.create(Neutron.class).child(Ports.class).child(Port.class);
  60     }
  61
  62     @Override
  63     protected QosNeutronPortChangeListener getDataTreeChangeListener() {
  64         return QosNeutronPortChangeListener.this;
  65     }
  66
  67     @Override
  68     protected void add(InstanceIdentifier<Port> instanceIdentifier, Port port) {
  69         if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, port)) {
  70             QosAlertManager.addToQosAlertCache(port);
  71         }
  72     }
  73
  74     @Override
  75     protected void remove(InstanceIdentifier<Port> instanceIdentifier, Port port) {
  76         if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, port)) {
  77             QosAlertManager.removeFromQosAlertCache(port);
  78         }
  79     }
  80
  81     @Override
  82     protected void update(InstanceIdentifier<Port> instanceIdentifier, Port original, Port update) {
  83         // check for QoS updates
  84         QosPortExtension updateQos = update.getAugmentation(QosPortExtension.class);
  85         QosPortExtension originalQos = original.getAugmentation(QosPortExtension.class);
  86
  87         if (originalQos == null && updateQos != null) {
  88             // qosservice policy add
  89             QosNeutronUtils.addToQosPortsCache(updateQos.getQosPolicyId(), update);
  90             QosNeutronUtils.handleNeutronPortQosAdd(dataBroker, odlInterfaceRpcService, mdsalUtils,
  91                     update, updateQos.getQosPolicyId());
  92         } else if (originalQos != null && updateQos != null
  93                 && !originalQos.getQosPolicyId().equals(updateQos.getQosPolicyId())) {
  94
  95             // qosservice policy update
  96             QosNeutronUtils.removeFromQosPortsCache(originalQos.getQosPolicyId(), original);
  97             QosNeutronUtils.addToQosPortsCache(updateQos.getQosPolicyId(), update);
  98             QosNeutronUtils.handleNeutronPortQosUpdate(dataBroker, odlInterfaceRpcService, mdsalUtils,
  99                     update, updateQos.getQosPolicyId(), originalQos.getQosPolicyId());
 100         } else if (originalQos != null && updateQos == null) {
 101             // qosservice policy delete
 102             QosNeutronUtils.handleNeutronPortQosRemove(dataBroker, odlInterfaceRpcService, neutronVpnManager,
 103                     mdsalUtils, original, originalQos.getQosPolicyId());
 104             QosNeutronUtils.removeFromQosPortsCache(originalQos.getQosPolicyId(), original);
 105         }
 106
 107         if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, original)
 108                                         && !QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, update)) {
 109             QosAlertManager.removeFromQosAlertCache(original);
 110         } else if (!QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, original)
 111                                           && QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager,update)) {
 112             QosAlertManager.addToQosAlertCache(update);
 113         }
 114     }
 115 }