netvirt/src/main/java/org/opendaylight/unimgr/mef/netvirt/EvcUniUtils.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.unimgr.mef.netvirt;
  10
  11 import java.util.List;
  12
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  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.interfacemanager.globals.IfmConstants;
  18 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.uni.PhysicalLayers;
  19 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.uni.physical.layers.Links;
  20 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.uni.physical.layers.links.Link;
  21 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.evc.unis.Uni;
  22 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.evc.unis.uni.EvcUniCeVlans;
  23 import org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.services.rev150526.mef.services.mef.service.evc.unis.uni.evc.uni.ce.vlans.EvcUniCeVlan;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  27 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 import com.google.common.base.Optional;
  32 import com.google.common.util.concurrent.CheckedFuture;
  33
  34 public class EvcUniUtils {
  35
  36     private static final Logger logger = LoggerFactory.getLogger(EvcUniUtils.class);
  37
  38     public static Link getLink(DataBroker dataBroker, Uni evcUni) {
  39         Optional<org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.Uni> optional = MdsalUtils
  40                 .read(dataBroker, LogicalDatastoreType.CONFIGURATION,
  41                         MefUtils.getUniInstanceIdentifier(evcUni.getUniId().getValue()));
  42
  43         if (!optional.isPresent()) {
  44             logger.error("A matching Uni doesn't exist for EvcUni {}", evcUni.getUniId());
  45             return null;
  46         }
  47
  48         org.opendaylight.yang.gen.v1.http.metroethernetforum.org.ns.yang.mef.interfaces.rev150526.mef.interfaces.unis.Uni uni = optional
  49                 .get();
  50
  51         PhysicalLayers physicalLayers = uni.getPhysicalLayers();
  52         if (physicalLayers == null) {
  53             logger.warn("Uni {} is missing PhysicalLayers", evcUni.getUniId());
  54             return null;
  55         }
  56
  57         Links links = physicalLayers.getLinks();
  58         if (links == null || links.getLink() == null) {
  59             logger.warn("Uni {} is has no links", evcUni.getUniId());
  60             return null;
  61         }
  62
  63         Link link = links.getLink().get(0);
  64         return link;
  65     }
  66
  67     public static void removeUni(DataBroker dataBroker, Uni data) {
  68         try {
  69             String uniId = data.getUniId().getValue();
  70             WriteTransaction tx = createTransaction(dataBroker);
  71
  72             Link link = EvcUniUtils.getLink(dataBroker, data);
  73
  74             logger.info("Removing trunk {}", uniId);
  75
  76             delete(uniId, tx);
  77
  78             Optional<List<EvcUniCeVlan>> ceVlansOptional = getCeVlans(data);
  79             if (!ceVlansOptional.isPresent()) {
  80                 return;
  81             }
  82
  83             removeTrunkMemberInterfaces(uniId, ceVlansOptional.get(), tx);
  84             commitTransaction(tx);
  85         } catch (final Exception e) {
  86             logger.error("Remove uni failed !", e);
  87         }
  88     }
  89
  90     public static void addUni(DataBroker dataBroker, Uni data) {
  91         try {
  92             String uniId = data.getUniId().getValue();
  93             WriteTransaction tx = createTransaction(dataBroker);
  94             Link link = EvcUniUtils.getLink(dataBroker, data);
  95             String interfaceName = uniId;
  96             addTrunkInterface(interfaceName, getTrunkParentName(link), tx);
  97
  98             Optional<List<EvcUniCeVlan>> ceVlansOptional = getCeVlans(data);
  99             if (ceVlansOptional.isPresent()) {
 100                 addTrunkMemberInterfaces(interfaceName, ceVlansOptional.get(), tx);
 101             }
 102
 103             commitTransaction(tx);
 104         } catch (final Exception e) {
 105             logger.error("Add uni failed !", e);
 106         }
 107     }
 108
 109     private static void addTrunkInterface(String interfaceName, String parentInterfaceName, WriteTransaction tx) {
 110         logger.info("Adding VLAN trunk {} ParentRef {}", interfaceName, parentInterfaceName);
 111         Interface trunkInterface = NetvirtUtils.createTrunkInterface(interfaceName, parentInterfaceName);
 112         write(trunkInterface, tx);
 113     }
 114
 115     private static void addTrunkMemberInterfaces(String parentInterfaceName, Iterable<EvcUniCeVlan> ceVlans,
 116             WriteTransaction tx) {
 117         for (EvcUniCeVlan ceVlan : ceVlans) {
 118             Object vid = ceVlan.getVid();
 119             if (!(vid instanceof Long)) {
 120                 String errorMessage = String.format("vlan id {} cannot be cast to Long", vid);
 121                 logger.error(errorMessage);
 122                 throw new UnsupportedOperationException(errorMessage);
 123             }
 124
 125             Long vlanId = (Long) vid;
 126             String interfaceName = NetvirtUtils.getInterfaceNameForVlan(parentInterfaceName, vlanId.toString());
 127             logger.info("Adding VLAN trunk-member {} ParentRef {}", interfaceName, parentInterfaceName);
 128             Interface trunkMemberInterface = NetvirtUtils.createTrunkMemberInterface(interfaceName, parentInterfaceName,
 129                     vlanId.intValue());
 130             write(trunkMemberInterface, tx);
 131         }
 132     }
 133
 134     private static void removeTrunkMemberInterfaces(String parentInterfaceName, Iterable<EvcUniCeVlan> ceVlans,
 135             WriteTransaction tx) {
 136         for (EvcUniCeVlan ceVlan : ceVlans) {
 137             Object vid = ceVlan.getVid();
 138             if (!(vid instanceof Long)) {
 139                 String errorMessage = String.format("vlan id {} cannot be cast to Long", vid);
 140                 logger.error(errorMessage);
 141                 throw new UnsupportedOperationException(errorMessage);
 142             }
 143
 144             Long vlanId = (Long) vid;
 145             String interfaceName = NetvirtUtils.getInterfaceNameForVlan(parentInterfaceName, vlanId.toString());
 146             logger.info("Removing VLAN trunk-member {}", interfaceName);
 147             delete(interfaceName, tx);
 148         }
 149     }
 150
 151     private static InstanceIdentifier<Interface> createInterfaceIdentifier(String interfaceName) {
 152         return InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName))
 153                 .build();
 154     }
 155
 156     private static WriteTransaction createTransaction(DataBroker dataBroker) {
 157         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 158         return tx;
 159     }
 160
 161     private static void commitTransaction(WriteTransaction tx) {
 162         try {
 163             CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 164             futures.get();
 165         } catch (Exception e) {
 166             logger.error("failed to commit transaction due to exception ", e);
 167         }
 168     }
 169
 170     private static void write(Interface iface, WriteTransaction tx) {
 171         String interfaceName = iface.getName();
 172         InstanceIdentifier<Interface> interfaceIdentifier = createInterfaceIdentifier(interfaceName);
 173         tx.put(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface, true);
 174     }
 175
 176     private static void delete(String interfaceName, WriteTransaction tx) {
 177         InstanceIdentifier<Interface> interfaceIdentifier = createInterfaceIdentifier(interfaceName);
 178         tx.delete(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier);
 179     }
 180
 181     private static String getTrunkParentName(Link link) {
 182         String deviceName = link.getDevice().getValue();
 183         String interfaceName = link.getInterface().toString();
 184         return interfaceName;
 185     }
 186
 187     private static Optional<List<EvcUniCeVlan>> getCeVlans(Uni uni) {
 188         EvcUniCeVlans ceVlans = uni.getEvcUniCeVlans();
 189         if (ceVlans == null) {
 190             return Optional.absent();
 191         }
 192
 193         return Optional.fromNullable(ceVlans.getEvcUniCeVlan());
 194     }
 195
 196     public static String getDeviceInterfaceName(String deviceName, String interfaceName) {
 197         return deviceName + IfmConstants.OF_URI_SEPARATOR + interfaceName;
 198     }
 199 }