neutronvpn/impl/src/main/java/org/opendaylight/netvirt/neutronvpn/evpn/manager/NeutronEvpnManager.java

   1 /*
   2  * Copyright © 2017 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.neutronvpn.evpn.manager;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import com.google.common.util.concurrent.SettableFuture;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.Optional;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.function.Consumer;
  17 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  18 import org.opendaylight.mdsal.binding.api.DataBroker;
  19 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  20 import org.opendaylight.netvirt.neutronvpn.NeutronvpnManager;
  21 import org.opendaylight.netvirt.neutronvpn.NeutronvpnUtils;
  22 import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.vpn.instance.vpntargets.VpnTarget;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateEVPNInput;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateEVPNOutput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateEVPNOutputBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteEVPNInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteEVPNOutput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteEVPNOutputBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetEVPNInput;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetEVPNOutput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetEVPNOutputBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createevpn.input.Evpn;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getevpn.output.EvpnInstances;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getevpn.output.EvpnInstancesBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.common.RpcError;
  43 import org.opendaylight.yangtools.yang.common.RpcResult;
  44 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47 import org.slf4j.helpers.FormattingTuple;
  48 import org.slf4j.helpers.MessageFormatter;
  49
  50
  51 public class NeutronEvpnManager {
  52     private static final Logger LOG = LoggerFactory.getLogger(NeutronEvpnManager.class);
  53     private final DataBroker dataBroker;
  54     private final NeutronvpnManager neutronvpnManager;
  55     private final NeutronvpnUtils neutronvpnUtils;
  56
  57     public NeutronEvpnManager(DataBroker dataBroker, NeutronvpnManager neutronvpnManager,
  58             NeutronvpnUtils neutronvpnUtils) {
  59         this.dataBroker = dataBroker;
  60         this.neutronvpnManager = neutronvpnManager;
  61         this.neutronvpnUtils = neutronvpnUtils;
  62     }
  63
  64     @SuppressWarnings("checkstyle:IllegalCatch")
  65     public ListenableFuture<RpcResult<CreateEVPNOutput>> createEVPN(CreateEVPNInput input) {
  66         CreateEVPNOutputBuilder opBuilder = new CreateEVPNOutputBuilder();
  67         SettableFuture<RpcResult<CreateEVPNOutput>> result = SettableFuture.create();
  68         List<RpcError> errorList = new ArrayList<>();
  69         int failurecount = 0;
  70         List<String> existingRDs = neutronvpnUtils.getExistingRDs();
  71
  72         for (Evpn vpn : input.nonnullEvpn()) {
  73             if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
  74                 errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-input",
  75                         formatAndLog(LOG::warn, "Creation of EVPN failed for VPN {} due to absence of RD/iRT/eRT input",
  76                                 vpn.getId().getValue())));
  77                 continue;
  78             }
  79             if (vpn.getRouteDistinguisher().size() > 1) {
  80                 errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-input",
  81                         formatAndLog(LOG::warn, "Creation of EVPN failed for VPN {} due to multiple RD input {}",
  82                                 vpn.getId().getValue(), vpn.getRouteDistinguisher())));
  83                 continue;
  84             }
  85             if (existingRDs.contains(vpn.getRouteDistinguisher().get(0))) {
  86                 errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-input",
  87                         formatAndLog(LOG::warn,
  88                                 "Creation of EVPN failed for VPN {} as another VPN with the same RD {} is already "
  89                                         + "configured",
  90                                 vpn.getId().getValue(), vpn.getRouteDistinguisher().get(0))));
  91                 continue;
  92             }
  93             try {
  94                 List<String> rdList = vpn.getRouteDistinguisher() != null
  95                         ? new ArrayList<>(vpn.getRouteDistinguisher()) : new ArrayList<>();
  96                 List<String> importRdList = vpn.getImportRT() != null
  97                         ? new ArrayList<>(vpn.getImportRT()) : new ArrayList<>();
  98                 List<String> exportRdList = vpn.getExportRT() != null
  99                         ? new ArrayList<>(vpn.getExportRT()) : new ArrayList<>();
 100                 neutronvpnManager.createVpn(vpn.getId(), vpn.getName(), vpn.getTenantId(), rdList,
 101                         importRdList, exportRdList, null /*router-id*/, null /*network-id*/,
 102                         true /*isL2Vpn*/, 0 /*l2vni*/);
 103             } catch (Exception ex) {
 104                 errorList.add(RpcResultBuilder.newError(RpcError.ErrorType.APPLICATION,
 105                         formatAndLog(LOG::error, "Creation of EVPN failed for VPN {}", vpn.getId().getValue(), ex),
 106                         ex.getMessage()));
 107                 failurecount++;
 108             }
 109         }
 110         if (failurecount != 0) {
 111             result.set(RpcResultBuilder.<CreateEVPNOutput>failed().withRpcErrors(errorList).build());
 112         } else {
 113             List<String> errorResponseList = new ArrayList<>();
 114             if (!errorList.isEmpty()) {
 115                 for (RpcError rpcError : errorList) {
 116                     errorResponseList.add("ErrorType: " + rpcError.getErrorType() + ", ErrorTag: " + rpcError.getTag()
 117                             + ", ErrorMessage: " + rpcError.getMessage());
 118                 }
 119             } else {
 120                 errorResponseList.add("EVPN creation successful with no errors");
 121             }
 122             opBuilder.setResponse(errorResponseList);
 123             result.set(RpcResultBuilder.success(opBuilder.build()).build());
 124         }
 125         return result;
 126     }
 127
 128     public ListenableFuture<RpcResult<GetEVPNOutput>> getEVPN(GetEVPNInput input) {
 129         GetEVPNOutputBuilder opBuilder = new GetEVPNOutputBuilder();
 130         SettableFuture<RpcResult<GetEVPNOutput>> result = SettableFuture.create();
 131         Uuid inputVpnId = input.getId();
 132         List<VpnInstance> vpns = new ArrayList<>();
 133         if (inputVpnId == null) {
 134             vpns = VpnHelper.getAllVpnInstances(dataBroker);
 135             if (!vpns.isEmpty()) {
 136                 for (VpnInstance vpn : vpns) {
 137                     if (vpn.getRouteDistinguisher() != null
 138                             && vpn.isL2vpn()) {
 139                         vpns.add(vpn);
 140                     }
 141                 }
 142             } else {
 143                 // No VPN present
 144                 result.set(RpcResultBuilder.success(opBuilder.build()).build());
 145                 return result;
 146             }
 147         } else {
 148             String name = inputVpnId.getValue();
 149             VpnInstance vpnInstance = VpnHelper.getVpnInstance(dataBroker, name);
 150             if (vpnInstance != null && vpnInstance.getRouteDistinguisher() != null
 151                     && vpnInstance.isL2vpn()) {
 152                 vpns.add(vpnInstance);
 153             } else {
 154                 result.set(RpcResultBuilder.<GetEVPNOutput>failed().withWarning(RpcError.ErrorType.PROTOCOL,
 155                         "invalid-value",
 156                         formatAndLog(LOG::error, "GetEVPN failed because VPN {} is not present", name)).build());
 157             }
 158         }
 159         List<EvpnInstances> evpnList = new ArrayList<>();
 160         for (VpnInstance vpnInstance : vpns) {
 161             Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
 162             InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
 163                     .class, new VpnMapKey(vpnId)).build();
 164             EvpnInstancesBuilder evpn = new EvpnInstancesBuilder();
 165             List<String> rd = vpnInstance.getRouteDistinguisher();
 166             List<String> ertList = new ArrayList<>();
 167             List<String> irtList = new ArrayList<>();
 168             for (VpnTarget vpnTarget : vpnInstance.getVpnTargets().nonnullVpnTarget()) {
 169                 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
 170                     ertList.add(vpnTarget.getVrfRTValue());
 171                 }
 172                 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
 173                     irtList.add(vpnTarget.getVrfRTValue());
 174                 }
 175                 if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
 176                     ertList.add(vpnTarget.getVrfRTValue());
 177                     irtList.add(vpnTarget.getVrfRTValue());
 178                 }
 179             }
 180             evpn.setId(vpnId).setRouteDistinguisher(rd).setImportRT(irtList).setExportRT(ertList);
 181             try {
 182                 Optional<VpnMap> optionalVpnMap =
 183                         SingleTransactionDataBroker.syncReadOptional(dataBroker, LogicalDatastoreType.CONFIGURATION,
 184                                 vpnMapIdentifier);
 185                 if (optionalVpnMap.isPresent()) {
 186                     VpnMap vpnMap = optionalVpnMap.get();
 187                     evpn.setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
 188                 }
 189             } catch (ExecutionException | InterruptedException e) {
 190                 LOG.error("Error reading the VPN map for {}", vpnMapIdentifier, e);
 191                 result.set(RpcResultBuilder.<GetEVPNOutput>failed().withError(RpcError.ErrorType.APPLICATION,
 192                         "Error reading the VPN map for " + vpnMapIdentifier, e).build());
 193                 return result;
 194             }
 195             evpnList.add(evpn.build());
 196         }
 197
 198         opBuilder.setEvpnInstances(evpnList);
 199         result.set(RpcResultBuilder.success(opBuilder.build()).build());
 200         return result;
 201     }
 202
 203     public ListenableFuture<RpcResult<DeleteEVPNOutput>> deleteEVPN(DeleteEVPNInput input) {
 204         List<RpcError> errorList = new ArrayList<>();
 205
 206         if (input.getId() != null) {
 207             for (Uuid vpn : input.getId()) {
 208                 VpnInstance vpnInstance = VpnHelper.getVpnInstance(dataBroker, vpn.getValue());
 209                 if (vpnInstance != null) {
 210                     neutronvpnManager.removeVpn(vpn);
 211                 } else {
 212                     errorList.add(RpcResultBuilder.newWarning(RpcError.ErrorType.PROTOCOL, "invalid-value",
 213                         formatAndLog(LOG::warn, "EVPN with vpnid: {} does not exist", vpn.getValue())));
 214                 }
 215             }
 216         }
 217         List<String> errorResponseList = new ArrayList<>();
 218         if (!errorList.isEmpty()) {
 219             for (RpcError rpcError : errorList) {
 220                 errorResponseList.add("ErrorType: " + rpcError.getErrorType() + ", ErrorTag: " + rpcError.getTag()
 221                         + ", ErrorMessage: " + rpcError.getMessage());
 222             }
 223         } else {
 224             errorResponseList.add("Deletion of EVPN operation successful");
 225         }
 226         DeleteEVPNOutputBuilder opBuilder = new DeleteEVPNOutputBuilder();
 227         opBuilder.setResponse(errorResponseList);
 228         SettableFuture<RpcResult<DeleteEVPNOutput>> result = SettableFuture.create();
 229         result.set(RpcResultBuilder.success(opBuilder.build()).build());
 230         return result;
 231     }
 232
 233     private String formatAndLog(Consumer<String> logger, String template, Object arg) {
 234         return logAndReturnMessage(logger, MessageFormatter.format(template, arg));
 235     }
 236
 237     private String formatAndLog(Consumer<String> logger, String template, Object arg1, Object arg2) {
 238         return logAndReturnMessage(logger, MessageFormatter.format(template, arg1, arg2));
 239     }
 240
 241     private String logAndReturnMessage(Consumer<String> logger, FormattingTuple tuple) {
 242         String message = tuple.getMessage();
 243         logger.accept(message);
 244         return message;
 245     }
 246 }