vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnElanInterfaceChangeListener.java

   1 /*
   2  * Copyright (c) 2016 Hewlett Packard Enterprise, Co. 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
   9 package org.opendaylight.netvirt.vpnmanager;
  10
  11 import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
  12
  13 import java.util.ArrayList;
  14 import java.util.List;
  15
  16 import javax.annotation.PostConstruct;
  17 import javax.inject.Inject;
  18 import javax.inject.Singleton;
  19
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  23 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  24 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  25 import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
  26 import org.opendaylight.netvirt.elanmanager.api.IElanService;
  27 import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
  28 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames;
  32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames.AssociatedSubnetType;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
  36 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 @Singleton
  41 public class VpnElanInterfaceChangeListener
  42     extends AsyncDataTreeChangeListenerBase<ElanInterface, VpnElanInterfaceChangeListener> {
  43     private static final Logger LOG = LoggerFactory.getLogger(VpnElanInterfaceChangeListener.class);
  44
  45     private final DataBroker broker;
  46     private final ManagedNewTransactionRunner txRunner;
  47     private final IElanService elanService;
  48     private final VpnUtil vpnUtil;
  49
  50     @Inject
  51     public VpnElanInterfaceChangeListener(final DataBroker broker, final IElanService elanService,
  52                                           final VpnUtil vpnUtil) {
  53         super(ElanInterface.class, VpnElanInterfaceChangeListener.class);
  54         this.broker = broker;
  55         this.txRunner = new ManagedNewTransactionRunnerImpl(broker);
  56         this.elanService = elanService;
  57         this.vpnUtil = vpnUtil;
  58     }
  59
  60     @PostConstruct
  61     public void start() {
  62         LOG.info("{} start", getClass().getSimpleName());
  63         registerListener(LogicalDatastoreType.CONFIGURATION, broker);
  64     }
  65
  66     @Override
  67     protected InstanceIdentifier<ElanInterface> getWildCardPath() {
  68         return InstanceIdentifier.create(ElanInterfaces.class).child(ElanInterface.class);
  69     }
  70
  71     @Override
  72     protected void remove(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
  73         String interfaceName = elanInterface.getName();
  74         if (!elanService.isExternalInterface(interfaceName)) {
  75             LOG.debug("remove: Interface {} is not external. Ignoring interface removal", interfaceName);
  76             return;
  77         }
  78
  79         if (!vpnUtil.isVpnInterfaceConfigured(interfaceName)) {
  80             LOG.debug("remove: VpnInterface was never configured for {}. Ignoring interface removal", interfaceName);
  81             return;
  82         }
  83
  84         InstanceIdentifier<VpnInterface> vpnInterfaceIdentifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
  85         ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx ->
  86             tx.delete(vpnInterfaceIdentifier)), LOG, "Error removing VPN interface {}", vpnInterfaceIdentifier);
  87         LOG.info("remove: Removed VPN interface {}", interfaceName);
  88     }
  89
  90     @Override
  91     protected void update(InstanceIdentifier<ElanInterface> key, ElanInterface origElanInterface,
  92         ElanInterface updatedElanInterface) {
  93
  94     }
  95
  96     @Override
  97     protected void add(InstanceIdentifier<ElanInterface> key, ElanInterface elanInterface) {
  98         String interfaceName = elanInterface.getName();
  99         if (!elanService.isExternalInterface(interfaceName)) {
 100             LOG.debug("add: Interface {} is not external. Ignoring", interfaceName);
 101             return;
 102         }
 103
 104         Uuid networkId;
 105         try {
 106             networkId = new Uuid(elanInterface.getElanInstanceName());
 107         } catch (IllegalArgumentException e) {
 108             LOG.debug("add: ELAN instance {} for interface {} is not Uuid", elanInterface.getElanInstanceName(),
 109                     elanInterface.getName());
 110             return;
 111         }
 112
 113         Uuid vpnId = vpnUtil.getExternalNetworkVpnId(networkId);
 114         if (vpnId == null) {
 115             LOG.debug("add: Network {} is not external or vpn-id missing. Ignoring interface {} on elan {}",
 116                     networkId.getValue(), elanInterface.getName(), elanInterface.getElanInstanceName());
 117             return;
 118         }
 119         VpnInstanceNames vpnInstance = VpnHelper
 120             .getVpnInterfaceVpnInstanceNames(vpnId.getValue(), AssociatedSubnetType.V4AndV6Subnets);
 121         List<VpnInstanceNames> listVpn = new ArrayList<>();
 122         listVpn.add(vpnInstance);
 123         VpnInterface vpnInterface = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName))
 124             .setVpnInstanceNames(listVpn)
 125             .build();
 126         InstanceIdentifier<VpnInterface> vpnInterfaceIdentifier = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
 127         vpnUtil.syncWrite(LogicalDatastoreType.CONFIGURATION, vpnInterfaceIdentifier, vpnInterface);
 128         LOG.info("add: Added VPN interface {} with VPN-id {} elanInstance {}", interfaceName, vpnId.getValue(),
 129                 elanInterface.getElanInstanceName());
 130     }
 131
 132     @Override
 133     protected VpnElanInterfaceChangeListener getDataTreeChangeListener() {
 134         return this;
 135     }
 136 }