vpnservice/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/netvirt/vpnmanager/SubnetOpDpnManager.java

   1 /*
   2  * Copyright (c) 2016 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.netvirt.vpnmanager;
   9
  10 import com.google.common.base.Optional;
  11 import java.math.BigInteger;
  12 import java.util.ArrayList;
  13 import java.util.List;
  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.controller.md.sal.common.api.data.TransactionCommitFailedException;
  17 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  18 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PortOpData;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.port.op.data.PortOpDataEntry;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.port.op.data.PortOpDataEntryBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.port.op.data.PortOpDataEntryKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpn;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpnBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.SubnetToDpnKey;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfaces;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfacesBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.subnet.op.data.entry.subnet.to.dpn.VpnInterfacesKey;
  33 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37
  38 public class SubnetOpDpnManager {
  39     private static final Logger LOG = LoggerFactory.getLogger(SubnetOpDpnManager.class);
  40
  41     private final DataBroker broker;
  42
  43     public SubnetOpDpnManager(final DataBroker db) {
  44         broker = db;
  45     }
  46
  47     private SubnetToDpn addDpnToSubnet(Uuid subnetId, BigInteger dpnId) {
  48         try {
  49             InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier =
  50                 InstanceIdentifier.builder(SubnetOpData.class).child(SubnetOpDataEntry.class,
  51                     new SubnetOpDataEntryKey(subnetId)).build();
  52             InstanceIdentifier<SubnetToDpn> dpnOpId =
  53                 subOpIdentifier.child(SubnetToDpn.class, new SubnetToDpnKey(dpnId));
  54             Optional<SubnetToDpn> optionalSubDpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
  55             if (optionalSubDpn.isPresent()) {
  56                 LOG.error("Cannot create, SubnetToDpn for subnet {} as DPN {} already seen in datastore",
  57                     subnetId.getValue(), dpnId);
  58                 return null;
  59             }
  60             SubnetToDpnBuilder subDpnBuilder = new SubnetToDpnBuilder().setKey(new SubnetToDpnKey(dpnId));
  61             List<VpnInterfaces> vpnIntfList = new ArrayList<>();
  62             subDpnBuilder.setVpnInterfaces(vpnIntfList);
  63             SubnetToDpn subDpn = subDpnBuilder.build();
  64             LOG.trace("Creating SubnetToDpn entry for subnet  " + subnetId.getValue() + " with DPNId " + dpnId);
  65             SingleTransactionDataBroker.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId, subDpn);
  66             return subDpn;
  67         } catch (TransactionCommitFailedException ex) {
  68             LOG.error("Creation of SubnetToDpn for subnet {} with DpnId {} failed", subnetId.getValue(), dpnId, ex);
  69             return null;
  70         }
  71     }
  72
  73     private void removeDpnFromSubnet(Uuid subnetId, BigInteger dpnId) {
  74         try {
  75             InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier =
  76                 InstanceIdentifier.builder(SubnetOpData.class).child(SubnetOpDataEntry.class,
  77                     new SubnetOpDataEntryKey(subnetId)).build();
  78             InstanceIdentifier<SubnetToDpn> dpnOpId =
  79                 subOpIdentifier.child(SubnetToDpn.class, new SubnetToDpnKey(dpnId));
  80             Optional<SubnetToDpn> optionalSubDpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
  81             if (!optionalSubDpn.isPresent()) {
  82                 LOG.warn("Cannot delete, SubnetToDpn for subnet {} DPN {} not available in datastore",
  83                     subnetId.getValue(), dpnId);
  84                 return;
  85             }
  86             LOG.trace("Deleting SubnetToDpn entry for subnet  " + subnetId.getValue() + " with DPNId " + dpnId);
  87             SingleTransactionDataBroker.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
  88         } catch (TransactionCommitFailedException ex) {
  89             LOG.error("Deletion of SubnetToDpn for subnet {} with DPN {} failed", subnetId.getValue(), dpnId, ex);
  90         }
  91     }
  92
  93     public SubnetToDpn addInterfaceToDpn(Uuid subnetId, BigInteger dpnId, String intfName) {
  94         SubnetToDpn subDpn = null;
  95         try {
  96             // Create and add SubnetOpDataEntry object for this subnet to the SubnetOpData container
  97             InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier =
  98                 InstanceIdentifier.builder(SubnetOpData.class).child(SubnetOpDataEntry.class,
  99                     new SubnetOpDataEntryKey(subnetId)).build();
 100             //Please use a synchronize block here as we donot need a cluster-wide lock
 101             InstanceIdentifier<SubnetToDpn> dpnOpId =
 102                 subOpIdentifier.child(SubnetToDpn.class, new SubnetToDpnKey(dpnId));
 103             Optional<SubnetToDpn> optionalSubDpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
 104             if (!optionalSubDpn.isPresent()) {
 105                 // Create a new DPN Entry
 106                 subDpn = addDpnToSubnet(subnetId, dpnId);
 107             } else {
 108                 subDpn = optionalSubDpn.get();
 109             }
 110             SubnetToDpnBuilder subDpnBuilder = new SubnetToDpnBuilder(subDpn);
 111             List<VpnInterfaces> vpnIntfList = subDpnBuilder.getVpnInterfaces();
 112             VpnInterfaces vpnIntfs =
 113                 new VpnInterfacesBuilder().setKey(new VpnInterfacesKey(intfName)).setInterfaceName(intfName).build();
 114             vpnIntfList.add(vpnIntfs);
 115             subDpnBuilder.setVpnInterfaces(vpnIntfList);
 116             subDpn = subDpnBuilder.build();
 117
 118             LOG.trace("Creating SubnetToDpn entry for subnet  " + subnetId.getValue() + " with DPNId " + dpnId);
 119             SingleTransactionDataBroker.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId, subDpn);
 120         } catch (TransactionCommitFailedException ex) {
 121             LOG.error("Addition of Interface {} for SubnetToDpn on subnet {} with DPN {} failed", intfName,
 122                 subnetId.getValue(), dpnId, ex);
 123             return null;
 124         }
 125         return subDpn;
 126     }
 127
 128     public void addPortOpDataEntry(String intfName, Uuid subnetId, BigInteger dpnId) {
 129         try {
 130             // Add to PortOpData as well.
 131             PortOpDataEntryBuilder portOpBuilder = null;
 132             PortOpDataEntry portOpEntry = null;
 133
 134             InstanceIdentifier<PortOpDataEntry> portOpIdentifier =
 135                 InstanceIdentifier.builder(PortOpData.class).child(PortOpDataEntry.class,
 136                     new PortOpDataEntryKey(intfName)).build();
 137             Optional<PortOpDataEntry> optionalPortOp =
 138                 VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
 139             if (!optionalPortOp.isPresent()) {
 140                 // Create PortOpDataEntry only if not present
 141                 portOpBuilder =
 142                     new PortOpDataEntryBuilder().setKey(new PortOpDataEntryKey(intfName)).setPortId(intfName);
 143                 portOpBuilder.setSubnetId(subnetId);
 144                 portOpBuilder.setDpnId(dpnId);
 145                 portOpEntry = portOpBuilder.build();
 146             } else {
 147                 portOpBuilder = new PortOpDataEntryBuilder(optionalPortOp.get());
 148                 portOpBuilder.setSubnetId(subnetId);
 149                 portOpBuilder.setDpnId(dpnId);
 150                 portOpEntry = portOpBuilder.build();
 151             }
 152             LOG.trace("Creating PortOpData entry for port " + intfName + " with DPNId " + dpnId);
 153             SingleTransactionDataBroker.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier,
 154                 portOpEntry);
 155         } catch (TransactionCommitFailedException ex) {
 156             LOG.error("Addition of Interface {} for SubnetToDpn on subnet {} with DPN {} failed", intfName,
 157                 subnetId.getValue(), dpnId, ex);
 158         }
 159     }
 160
 161     public boolean removeInterfaceFromDpn(Uuid subnetId, BigInteger dpnId, String intfName) {
 162         boolean dpnRemoved = false;
 163         try {
 164             InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier =
 165                 InstanceIdentifier.builder(SubnetOpData.class).child(SubnetOpDataEntry.class,
 166                     new SubnetOpDataEntryKey(subnetId)).build();
 167             InstanceIdentifier<SubnetToDpn> dpnOpId =
 168                 subOpIdentifier.child(SubnetToDpn.class, new SubnetToDpnKey(dpnId));
 169             Optional<SubnetToDpn> optionalSubDpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId);
 170             if (!optionalSubDpn.isPresent()) {
 171                 LOG.warn("Cannot delete, SubnetToDpn for subnet {} DPN {} not available in datastore",
 172                     subnetId.getValue(), dpnId);
 173                 return false;
 174             }
 175
 176             SubnetToDpnBuilder subDpnBuilder = new SubnetToDpnBuilder(optionalSubDpn.get());
 177             List<VpnInterfaces> vpnIntfList = subDpnBuilder.getVpnInterfaces();
 178             VpnInterfaces vpnIntfs =
 179                 new VpnInterfacesBuilder().setKey(new VpnInterfacesKey(intfName)).setInterfaceName(intfName).build();
 180             vpnIntfList.remove(vpnIntfs);
 181             if (vpnIntfList.isEmpty()) {
 182                 // Remove the DPN as well
 183                 removeDpnFromSubnet(subnetId, dpnId);
 184                 dpnRemoved = true;
 185             } else {
 186                 subDpnBuilder.setVpnInterfaces(vpnIntfList);
 187                 SingleTransactionDataBroker.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, dpnOpId,
 188                     subDpnBuilder.build());
 189             }
 190         } catch (TransactionCommitFailedException ex) {
 191             LOG.error("Deletion of Interface {} for SubnetToDpn on subnet {} with DPN {} failed", intfName,
 192                 subnetId.getValue(), dpnId, ex);
 193             return false;
 194         }
 195         return dpnRemoved;
 196     }
 197
 198     public PortOpDataEntry removePortOpDataEntry(String intfName) {
 199         // Remove PortOpData and return out
 200         InstanceIdentifier<PortOpDataEntry> portOpIdentifier =
 201             InstanceIdentifier.builder(PortOpData.class).child(PortOpDataEntry.class,
 202                 new PortOpDataEntryKey(intfName)).build();
 203         PortOpDataEntry portOpEntry = null;
 204         Optional<PortOpDataEntry> optionalPortOp =
 205             VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
 206         if (!optionalPortOp.isPresent()) {
 207             LOG.error("Cannot delete, portOp for port {} is not available in datastore", intfName);
 208             return null;
 209         } else {
 210             portOpEntry = optionalPortOp.get();
 211             LOG.trace("Deleting portOpData entry for port {}", intfName);
 212             MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
 213         }
 214         return portOpEntry;
 215     }
 216
 217     public PortOpDataEntry getPortOpDataEntry(String intfName) {
 218         // Remove PortOpData and return out
 219         InstanceIdentifier<PortOpDataEntry> portOpIdentifier =
 220             InstanceIdentifier.builder(PortOpData.class).child(PortOpDataEntry.class,
 221                 new PortOpDataEntryKey(intfName)).build();
 222         Optional<PortOpDataEntry> optionalPortOp =
 223             VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, portOpIdentifier);
 224         if (!optionalPortOp.isPresent()) {
 225             LOG.error("Cannot get, portOp for port {} is not available in datastore", intfName);
 226             return null;
 227         }
 228         return optionalPortOp.get();
 229     }
 230
 231 }