fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java

   1 /*
   2  * Copyright (c) 2015 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.vpnservice.fibmanager;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.util.concurrent.Futures;
  12 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  13 import com.google.common.util.concurrent.FutureCallback;
  14 import org.opendaylight.vpnservice.AbstractDataChangeListener;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  17 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  18 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  19 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  20 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
  21 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
  22 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  23 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
  24 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
  25 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
  26 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
  27 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  28 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerInputBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerOutput;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
  37 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  38 import org.opendaylight.yangtools.yang.binding.DataObject;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  41 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  42 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  43 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
  45 import org.opendaylight.yangtools.yang.binding.RpcService;
  46 import org.opendaylight.yangtools.yang.common.RpcResult;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49 import com.google.common.base.Optional;
  50
  51 import java.math.BigInteger;
  52 import java.net.InetAddress;
  53 import java.net.UnknownHostException;
  54 import java.util.ArrayList;
  55 import java.util.List;
  56 import java.util.Set;
  57 import java.util.concurrent.ExecutionException;
  58 import java.util.concurrent.Future;
  59
  60 public class FibManager extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable{
  61   private static final Logger LOG = LoggerFactory.getLogger(FibManager.class);
  62   private static final String FLOWID_PREFIX = "L3.";
  63   private ListenerRegistration<DataChangeListener> listenerRegistration;
  64   private final DataBroker broker;
  65   private final L3nexthopService l3nexthopService;
  66   private IMdsalApiManager mdsalManager;
  67
  68   private static final short L3_FIB_TABLE = 20;
  69   private static final short L3_LFIB_TABLE = 21;
  70   private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
  71   private static final BigInteger COOKIE_VM_FIB_TABLE =  new BigInteger("8000003", 16);
  72   private static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
  73
  74
  75   private static final FutureCallback<Void> DEFAULT_CALLBACK =
  76       new FutureCallback<Void>() {
  77         public void onSuccess(Void result) {
  78           LOG.debug("Success in Datastore write operation");
  79         }
  80
  81         public void onFailure(Throwable error) {
  82           LOG.error("Error in Datastore write operation", error);
  83         };
  84       };
  85
  86   public FibManager(final DataBroker db, final RpcService nextHopService) {
  87     super(VrfEntry.class);
  88     broker = db;
  89     l3nexthopService = (L3nexthopService)nextHopService;
  90     registerListener(db);
  91   }
  92
  93   @Override
  94   public void close() throws Exception {
  95     if (listenerRegistration != null) {
  96       try {
  97         listenerRegistration.close();
  98       } catch (final Exception e) {
  99         LOG.error("Error when cleaning up DataChangeListener.", e);
 100       }
 101       listenerRegistration = null;
 102     }
 103     LOG.info("Fib Manager Closed");
 104   }
 105
 106
 107   public void setMdsalManager(IMdsalApiManager mdsalManager) {
 108     this.mdsalManager = mdsalManager;
 109   }
 110
 111   private void registerListener(final DataBroker db) {
 112     try {
 113       listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
 114                                                            getWildCardPath(), FibManager.this, DataChangeScope.SUBTREE);
 115     } catch (final Exception e) {
 116       LOG.error("FibManager DataChange listener registration fail!", e);
 117       throw new IllegalStateException("FibManager registration Listener failed.", e);
 118     }
 119   }
 120
 121   @Override
 122   protected void add(final InstanceIdentifier<VrfEntry> identifier,
 123                      final VrfEntry vrfEntry) {
 124     LOG.trace("key: " + identifier + ", value=" + vrfEntry );
 125     createFibEntries(identifier, vrfEntry);
 126   }
 127
 128   private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
 129                                                   InstanceIdentifier<T> path) {
 130
 131     ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 132
 133     Optional<T> result = Optional.absent();
 134     try {
 135       result = tx.read(datastoreType, path).get();
 136     } catch (Exception e) {
 137       throw new RuntimeException(e);
 138     }
 139
 140     return result;
 141   }
 142
 143   private InstanceIdentifier<VrfEntry> getWildCardPath() {
 144     return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
 145   }
 146
 147   @Override
 148   protected void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry del) {
 149     LOG.trace("key: " + identifier + ", value=" + del );
 150   }
 151
 152   @Override
 153   protected void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
 154     LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update );
 155   }
 156
 157   private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
 158                                                  InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 159     WriteTransaction tx = broker.newWriteOnlyTransaction();
 160     tx.put(datastoreType, path, data, true);
 161     Futures.addCallback(tx.submit(), callback);
 162   }
 163
 164   private void createFibEntries(final InstanceIdentifier<VrfEntry> identifier,
 165                                 final VrfEntry vrfEntry) {
 166     final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
 167     Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
 168     Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
 169
 170     Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
 171     Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
 172     List<Long> dpns = getDpnsByVpn(vpnId);
 173     for (Long dpId : dpns) {
 174       addRouteInternal(dpId, vpnId, vrfTableKey, vrfEntry);
 175     }
 176   }
 177
 178   /*
 179    *
 180    */
 181   private void addRouteInternal(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
 182                         final VrfEntry vrfEntry) {
 183     String rd = vrfTableKey.getRouteDistinguisher();
 184     LOG.info("adding route " + vrfEntry.getDestPrefix() + " " + rd);
 185
 186     String values[] = vrfEntry.getDestPrefix().split("/");
 187     LOG.info(String.format("Adding route to DPN. ip %s masklen %s", values[0], values[1]));
 188     String ipAddress = values[0];
 189     int prefix = Integer.parseInt(values[1]);
 190     InetAddress destAddress = null;
 191     try {
 192       destAddress = InetAddress.getByName(ipAddress);
 193     } catch (UnknownHostException e) {
 194       LOG.error(String.format("UnknowHostException in addRoute."
 195                                  + "Failed to add Route for ipPrefix %s", vrfEntry.getDestPrefix()));
 196       return;
 197     }
 198
 199     GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfTableKey, vrfEntry);
 200     long groupId = -1;
 201     boolean isLocalRoute = false;
 202     if(adjacency != null) {
 203       groupId = adjacency.getEgressPointer();
 204       isLocalRoute = adjacency.isLocalDestination();
 205     }
 206     if(groupId == -1) {
 207       LOG.error(String.format("Could not get nexthop group id for nexthop: %s in vpn %s",
 208                                    vrfEntry.getNextHopAddress(), rd));
 209       LOG.warn(String.format("Failed to add Route: %s in vpn: %s",
 210                              vrfEntry.getDestPrefix(), rd));
 211       return;
 212     }
 213
 214     makeConnectedRoute(dpId, destAddress, prefix, vpnId, rd, groupId, NwConstants.ADD_FLOW);
 215
 216     if (isLocalRoute) {
 217       makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.ADD_FLOW);
 218     }
 219
 220     LOG.info(
 221         "Successfully added fib entry for " + destAddress.getHostAddress() + " vpnId " + vpnId);
 222   }
 223
 224   public void deleteRoute(InetAddress destPrefix, int prefixLength, int vpnId, String rd) {
 225     LOG.info("deleting route "+destPrefix.getHostAddress()+ " "+vpnId);
 226
 227     List<Long> dpnIds = getDpnsByVpn(vpnId);
 228
 229     for (long dpnId : dpnIds) {
 230       makeConnectedRoute(dpnId, destPrefix, prefixLength, vpnId, rd, 0/*groupId*/, NwConstants.DEL_FLOW);
 231     }
 232     LOG.info("Successfully delete fib entry for "+destPrefix.getHostAddress()+ " vpnId "+vpnId);
 233   }
 234
 235   public void deleteRoute(InetAddress destPrefix, int prefixLength, int vpnId, String rd, long dpId) {
 236     LOG.info("deleting route "+destPrefix.getHostAddress()+ " "+vpnId);
 237
 238     makeConnectedRoute(dpId, destPrefix, prefixLength, vpnId, rd, 0/*groupId*/, NwConstants.DEL_FLOW);
 239
 240     LOG.info("Successfully delete fib entry for "+destPrefix.getHostAddress()+ " vpnId "+vpnId);
 241   }
 242
 243   private long getIpAddress(byte[] rawIpAddress) {
 244     return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
 245             + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
 246   }
 247
 248   private void makeConnectedRoute(long dpId, InetAddress destPrefix, int prefixLength, long vpnId,
 249                           String rd, long groupId, int addOrRemove) {
 250
 251     List<MatchInfo> matches = new ArrayList<MatchInfo>();
 252
 253     matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
 254         BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
 255
 256     matches.add(new MatchInfo(MatchFieldType.eth_type,
 257                               new long[] { 0x0800L }));
 258
 259     if(prefixLength != 0) {
 260       matches.add(new MatchInfo(MatchFieldType.ipv4_dst, new long[] {
 261           getIpAddress(destPrefix.getAddress()), prefixLength }));
 262     }
 263
 264     List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
 265     List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 266
 267     if(addOrRemove == NwConstants.ADD_FLOW) {
 268       actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId)}));
 269       instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
 270     }
 271
 272     String flowRef = getFlowRef(dpId, L3_FIB_TABLE, rd, destPrefix);
 273
 274     FlowEntity flowEntity;
 275
 276     int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
 277     flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_FIB_TABLE, flowRef,
 278                                            priority, flowRef, 0, 0,
 279                                            COOKIE_VM_FIB_TABLE, matches, instructions);
 280
 281     if (addOrRemove == NwConstants.ADD_FLOW) {
 282       mdsalManager.installFlow(flowEntity);
 283     } else {
 284       mdsalManager.removeFlow(flowEntity);
 285     }
 286   }
 287
 288   private void makeLFibTableEntry(long dpId, long label, long groupId,
 289                                   String nextHop, int addOrRemove) {
 290     List<MatchInfo> matches = new ArrayList<MatchInfo>();
 291     matches.add(new MatchInfo(MatchFieldType.eth_type,
 292                               new long[] { 0x8847L }));
 293     matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(label)}));
 294
 295     List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
 296     List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
 297     actionsInfos.add(new ActionInfo(ActionType.pop_mpls, new String[]{Long.toString(label)}));
 298     actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
 299     instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
 300
 301     // Install the flow entry in L3_LFIB_TABLE
 302     String flowRef = getFlowRef(dpId, L3_LFIB_TABLE, label, nextHop);
 303
 304     FlowEntity flowEntity;
 305     flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_LFIB_TABLE, flowRef,
 306                                            DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
 307                                            COOKIE_VM_LFIB_TABLE, matches, instructions);
 308
 309     if (addOrRemove == NwConstants.ADD_FLOW) {
 310       mdsalManager.installFlow(flowEntity);
 311     } else {
 312       mdsalManager.removeFlow(flowEntity);
 313     }
 314     LOG.info("LFIB Entry for dpID {} : label : {} grpup {} modified successfully {}",dpId, label, groupId );
 315   }
 316
 317   private String getFlowRef(long dpnId, short tableId, long label, String nextHop) {
 318     return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 319         .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 320         .append(label).append(NwConstants.FLOWID_SEPARATOR)
 321         .append(nextHop).toString();
 322   }
 323
 324   private String getFlowRef(long dpnId, short tableId, String rd, InetAddress destPrefix) {
 325     return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 326         .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
 327         .append(rd).append(NwConstants.FLOWID_SEPARATOR)
 328         .append(destPrefix.getHostAddress()).toString();
 329   }
 330
 331   private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
 332                         final VrfEntry vrfEntry) {
 333     GetEgressPointerOutput adjacency = null;
 334     try {
 335       Future<RpcResult<GetEgressPointerOutput>> result =
 336           l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId)
 337                                                 .setIpPrefix(vrfEntry.getDestPrefix())
 338                                                 .setNexthopIp(vrfEntry.getNextHopAddress())
 339                                                 .setVpnId(vpnId)
 340                                                 .build());
 341       RpcResult<GetEgressPointerOutput> rpcResult = result.get();
 342       if (rpcResult.isSuccessful()) {
 343         adjacency = rpcResult.getResult();
 344       } else {
 345         LOG.error("Next hop information not available");
 346       }
 347     } catch (NullPointerException | InterruptedException | ExecutionException e) {
 348       LOG.trace("", e);
 349     }
 350     return adjacency;
 351   }
 352
 353   private List<Long> getDpnsByVpn(long vpnId) {
 354     // TODO: get list of dpns from vpnmanager, for all dpns List<Long>
 355     return new ArrayList<>();
 356   }
 357
 358   private Long getVpnId(String rd) {
 359     Long vpnId = null;
 360     InstanceIdentifier<VpnInstances> id = InstanceIdentifier.create(VpnInstances.class);
 361     Optional<VpnInstances> vpnInstances = read(LogicalDatastoreType.OPERATIONAL, id);
 362     if(vpnInstances.isPresent()) {
 363       List<VpnInstance> vpns = vpnInstances.get().getVpnInstance();
 364       for(VpnInstance vpn : vpns) {
 365         if(vpn.getIpv4Family().getRouteDistinguisher().equals(rd)) {
 366           VpnInstance1 vpnInstanceId = vpn.getAugmentation(VpnInstance1.class);
 367           if (vpnInstanceId != null) {
 368             vpnId = vpnInstanceId.getVpnId();
 369             break;
 370           }
 371         }
 372       }
 373     }
 374     return vpnId;
 375   }
 376 }