2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
8 package org.opendaylight.vpnservice.fibmanager;
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;
15 import org.opendaylight.vpnmanager.api.IVpnManager;
16 import org.opendaylight.vpnservice.AbstractDataChangeListener;
17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
18 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
19 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
20 import org.opendaylight.vpnservice.mdsalutil.ActionType;
21 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
22 import org.opendaylight.vpnservice.mdsalutil.InstructionInfo;
23 import org.opendaylight.vpnservice.mdsalutil.InstructionType;
24 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
25 import org.opendaylight.vpnservice.mdsalutil.MatchFieldType;
26 import org.opendaylight.vpnservice.mdsalutil.MatchInfo;
27 import org.opendaylight.vpnservice.mdsalutil.MetaDataUtil;
28 import org.opendaylight.vpnservice.mdsalutil.NwConstants;
29 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerInputBuilder;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.GetEgressPointerOutput;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthopService;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.RemoveLocalNextHopInputBuilder;
40 import org.opendaylight.yangtools.concepts.ListenerRegistration;
41 import org.opendaylight.yangtools.yang.binding.DataObject;
42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
44 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
45 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
46 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
48 import org.opendaylight.yangtools.yang.binding.RpcService;
49 import org.opendaylight.yangtools.yang.common.RpcResult;
50 import org.slf4j.Logger;
51 import org.slf4j.LoggerFactory;
52 import com.google.common.base.Optional;
54 import java.math.BigInteger;
55 import java.net.InetAddress;
56 import java.net.UnknownHostException;
57 import java.util.ArrayList;
58 import java.util.Collection;
59 import java.util.List;
61 import java.util.concurrent.ExecutionException;
62 import java.util.concurrent.Future;
64 public class FibManager extends AbstractDataChangeListener<VrfEntry> implements AutoCloseable{
65 private static final Logger LOG = LoggerFactory.getLogger(FibManager.class);
66 private static final String FLOWID_PREFIX = "L3.";
67 private ListenerRegistration<DataChangeListener> listenerRegistration;
68 private final DataBroker broker;
69 private final L3nexthopService l3nexthopService;
70 private IMdsalApiManager mdsalManager;
71 private IVpnManager vpnmanager;
73 private static final short L3_FIB_TABLE = 21;
74 private static final short L3_LFIB_TABLE = 20;
75 private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
76 private static final BigInteger COOKIE_VM_FIB_TABLE = new BigInteger("8000003", 16);
77 private static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
80 private static final FutureCallback<Void> DEFAULT_CALLBACK =
81 new FutureCallback<Void>() {
82 public void onSuccess(Void result) {
83 LOG.debug("Success in Datastore write operation");
86 public void onFailure(Throwable error) {
87 LOG.error("Error in Datastore write operation", error);
91 public FibManager(final DataBroker db, final RpcService nextHopService) {
92 super(VrfEntry.class);
94 l3nexthopService = (L3nexthopService)nextHopService;
99 public void close() throws Exception {
100 if (listenerRegistration != null) {
102 listenerRegistration.close();
103 } catch (final Exception e) {
104 LOG.error("Error when cleaning up DataChangeListener.", e);
106 listenerRegistration = null;
108 LOG.info("Fib Manager Closed");
112 public void setMdsalManager(IMdsalApiManager mdsalManager) {
113 this.mdsalManager = mdsalManager;
116 public void setVpnmanager(IVpnManager vpnmanager) {
117 this.vpnmanager = vpnmanager;
120 private void registerListener(final DataBroker db) {
122 listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
123 getWildCardPath(), FibManager.this, DataChangeScope.SUBTREE);
124 } catch (final Exception e) {
125 LOG.error("FibManager DataChange listener registration fail!", e);
126 throw new IllegalStateException("FibManager registration Listener failed.", e);
130 private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
131 InstanceIdentifier<T> path) {
133 ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
135 Optional<T> result = Optional.absent();
137 result = tx.read(datastoreType, path).get();
138 } catch (Exception e) {
139 throw new RuntimeException(e);
145 private InstanceIdentifier<VrfEntry> getWildCardPath() {
146 return InstanceIdentifier.create(FibEntries.class).child(VrfTables.class).child(VrfEntry.class);
149 private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
150 InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
151 WriteTransaction tx = broker.newWriteOnlyTransaction();
152 tx.put(datastoreType, path, data, true);
153 Futures.addCallback(tx.submit(), callback);
157 protected void add(final InstanceIdentifier<VrfEntry> identifier,
158 final VrfEntry vrfEntry) {
159 LOG.trace("key: " + identifier + ", value=" + vrfEntry );
160 createFibEntries(identifier, vrfEntry);
164 protected void remove(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry) {
165 LOG.trace("key: " + identifier + ", value=" + vrfEntry);
166 deleteFibEntries(identifier, vrfEntry);
170 protected void update(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update) {
171 LOG.trace("key: " + identifier + ", original=" + original + ", update=" + update );
174 private void createFibEntries(final InstanceIdentifier<VrfEntry> identifier,
175 final VrfEntry vrfEntry) {
176 final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
177 Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
178 Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
180 Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
181 Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
182 Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
183 for (Long dpId : dpns) {
184 addRouteInternal(dpId, vpnId, vrfTableKey, vrfEntry);
188 private void addRouteInternal(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
189 final VrfEntry vrfEntry) {
190 String rd = vrfTableKey.getRouteDistinguisher();
191 LOG.debug("adding route " + vrfEntry.getDestPrefix() + " " + rd);
193 GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
195 boolean isLocalRoute = false;
196 if(adjacency != null) {
197 groupId = adjacency.getEgressPointer();
198 isLocalRoute = adjacency.isLocalDestination();
201 LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
202 vrfEntry.getNextHopAddress(), rd);
203 LOG.warn("Failed to add Route: {} in vpn: {}",
204 vrfEntry.getDestPrefix(), rd);
208 makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.ADD_FLOW);
211 makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.ADD_FLOW);
215 "Successfully added fib entry for " + vrfEntry.getDestPrefix() + " vpnId " + vpnId);
218 private void deleteFibEntries(final InstanceIdentifier<VrfEntry> identifier,
219 final VrfEntry vrfEntry) {
220 final VrfTablesKey vrfTableKey = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
221 Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
222 Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
224 Long vpnId = getVpnId(vrfTableKey.getRouteDistinguisher());
225 Preconditions.checkNotNull(vpnId, "Vpn Instance not available!");
226 Collection<Long> dpns = vpnmanager.getDpnsForVpn(vpnId);
227 for (Long dpId : dpns) {
228 deleteRoute(dpId, vpnId, vrfTableKey, vrfEntry);
232 public void deleteRoute(final long dpId, final long vpnId, final VrfTablesKey vrfTableKey,
233 final VrfEntry vrfEntry) {
234 LOG.debug("deleting route "+ vrfEntry.getDestPrefix() + " "+vpnId);
235 String rd = vrfTableKey.getRouteDistinguisher();
236 GetEgressPointerOutput adjacency = resolveAdjacency(dpId, vpnId, vrfEntry);
238 boolean isLocalRoute = false;
239 if(adjacency != null) {
240 groupId = adjacency.getEgressPointer();
241 isLocalRoute = adjacency.isLocalDestination();
244 LOG.error("Could not get nexthop group id for nexthop: {} in vpn {}",
245 vrfEntry.getNextHopAddress(), rd);
246 LOG.warn("Failed to add Route: {} in vpn: {}",
247 vrfEntry.getDestPrefix(), rd);
251 makeConnectedRoute(dpId, vpnId, vrfEntry, rd, groupId, NwConstants.DEL_FLOW);
254 makeLFibTableEntry(dpId, vrfEntry.getLabel(), groupId, vrfEntry.getNextHopAddress(), NwConstants.DEL_FLOW);
255 deleteLocalAdjacency(dpId, vpnId, vrfEntry);
258 LOG.debug("Successfully delete fib entry for "+ vrfEntry.getDestPrefix() + " vpnId "+vpnId);
261 private long getIpAddress(byte[] rawIpAddress) {
262 return (((rawIpAddress[0] & 0xFF) << (3 * 8)) + ((rawIpAddress[1] & 0xFF) << (2 * 8))
263 + ((rawIpAddress[2] & 0xFF) << (1 * 8)) + (rawIpAddress[3] & 0xFF)) & 0xffffffffL;
266 private void makeConnectedRoute(long dpId, long vpnId, VrfEntry vrfEntry, String rd,
267 long groupId, int addOrRemove) {
268 LOG.trace("makeConnectedRoute: vrfEntry {}",vrfEntry);
269 String values[] = vrfEntry.getDestPrefix().split("/");
270 String ipAddress = values[0];
271 int prefixLength = (values.length == 1) ? 32 : Integer.parseInt(values[1]);
272 LOG.debug("Adding route to DPN. ip {} masklen {}", ipAddress, prefixLength);
273 InetAddress destPrefix = null;
275 destPrefix = InetAddress.getByName(ipAddress);
276 } catch (UnknownHostException e) {
277 LOG.error("UnknowHostException in addRoute. Failed to add Route for ipPrefix {}", vrfEntry.getDestPrefix());
281 List<MatchInfo> matches = new ArrayList<MatchInfo>();
283 matches.add(new MatchInfo(MatchFieldType.metadata, new BigInteger[] {
284 BigInteger.valueOf(vpnId), MetaDataUtil.METADATA_MASK_VRFID }));
286 matches.add(new MatchInfo(MatchFieldType.eth_type,
287 new long[] { 0x0800L }));
289 if(prefixLength != 0) {
290 matches.add(new MatchInfo(MatchFieldType.ipv4_dst, new long[] {
291 getIpAddress(destPrefix.getAddress()), prefixLength }));
294 List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
295 List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
297 if(addOrRemove == NwConstants.ADD_FLOW) {
298 actionsInfos.add(new ActionInfo(ActionType.push_mpls, new String[] { null }));
299 actionsInfos.add(new ActionInfo(ActionType.set_field_mpls_label, new String[] { Long.toString(vrfEntry.getLabel())}));
300 actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId)}));
301 instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
304 String flowRef = getFlowRef(dpId, L3_FIB_TABLE, rd, destPrefix);
306 FlowEntity flowEntity;
308 int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
309 flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_FIB_TABLE, flowRef,
310 priority, flowRef, 0, 0,
311 COOKIE_VM_FIB_TABLE, matches, instructions);
313 if (addOrRemove == NwConstants.ADD_FLOW) {
314 mdsalManager.installFlow(flowEntity);
316 mdsalManager.removeFlow(flowEntity);
320 private void makeLFibTableEntry(long dpId, long label, long groupId,
321 String nextHop, int addOrRemove) {
322 List<MatchInfo> matches = new ArrayList<MatchInfo>();
323 matches.add(new MatchInfo(MatchFieldType.eth_type,
324 new long[] { 0x8847L }));
325 matches.add(new MatchInfo(MatchFieldType.mpls_label, new String[]{Long.toString(label)}));
327 List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
328 List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
329 actionsInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
330 instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
332 // Install the flow entry in L3_LFIB_TABLE
333 String flowRef = getFlowRef(dpId, L3_LFIB_TABLE, label, nextHop);
335 FlowEntity flowEntity;
336 flowEntity = MDSALUtil.buildFlowEntity(dpId, L3_LFIB_TABLE, flowRef,
337 DEFAULT_FIB_FLOW_PRIORITY, flowRef, 0, 0,
338 COOKIE_VM_LFIB_TABLE, matches, instructions);
340 if (addOrRemove == NwConstants.ADD_FLOW) {
341 mdsalManager.installFlow(flowEntity);
343 mdsalManager.removeFlow(flowEntity);
345 LOG.debug("LFIB Entry for dpID {} : label : {} group {} modified successfully {}",dpId, label, groupId );
348 private void deleteLocalAdjacency(final long dpId, final long vpnId, final VrfEntry vrfEntry) {
349 LOG.trace("deleteLocalAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
351 Future<RpcResult<Void>> result =
352 l3nexthopService.removeLocalNextHop(new RemoveLocalNextHopInputBuilder().setDpnId(dpId)
353 .setIpPrefix(vrfEntry.getDestPrefix())
354 .setNexthopIp(vrfEntry.getNextHopAddress())
357 RpcResult<Void> rpcResult = result.get();
358 if (rpcResult.isSuccessful()) {
359 LOG.debug("Local Next hop for {} on dpn {} successfully deleted", vrfEntry.getDestPrefix(), dpId);
361 LOG.error("Local Next hop for {} on dpn {} not deleted", vrfEntry.getDestPrefix(), dpId);
363 } catch (NullPointerException | InterruptedException | ExecutionException e) {
368 public void populateFibOnNewDpn(long dpnId, long vpnId, String rd) {
369 LOG.trace("New dpn {} for vpn {} : populateFibOnNewDpn", dpnId, rd);
370 InstanceIdentifier<VrfTables> id = buildVrfId(rd);
371 Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
372 if(vrfTable.isPresent()) {
373 for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
374 addRouteInternal(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry);
379 public void cleanUpDpnForVpn(long dpnId, long vpnId, String rd) {
380 LOG.trace("Remove dpn {} for vpn {} : cleanUpDpnForVpn", dpnId, rd);
381 InstanceIdentifier<VrfTables> id = buildVrfId(rd);
382 Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
383 if(vrfTable.isPresent()) {
384 for(VrfEntry vrfEntry : vrfTable.get().getVrfEntry()) {
385 deleteRoute(dpnId, vpnId, vrfTable.get().getKey(), vrfEntry);
390 public static InstanceIdentifier<VrfTables> buildVrfId(String rd) {
391 InstanceIdentifierBuilder<VrfTables> idBuilder =
392 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd));
393 InstanceIdentifier<VrfTables> id = idBuilder.build();
397 private String getFlowRef(long dpnId, short tableId, long label, String nextHop) {
398 return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
399 .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
400 .append(label).append(NwConstants.FLOWID_SEPARATOR)
401 .append(nextHop).toString();
404 private String getFlowRef(long dpnId, short tableId, String rd, InetAddress destPrefix) {
405 return new StringBuilder(64).append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
406 .append(tableId).append(NwConstants.FLOWID_SEPARATOR)
407 .append(rd).append(NwConstants.FLOWID_SEPARATOR)
408 .append(destPrefix.getHostAddress()).toString();
411 private GetEgressPointerOutput resolveAdjacency(final long dpId, final long vpnId,
412 final VrfEntry vrfEntry) {
413 GetEgressPointerOutput adjacency = null;
414 LOG.trace("resolveAdjacency called with dpid {}, vpnId{}, VrfEntry {}",dpId, vpnId, vrfEntry);;
416 Future<RpcResult<GetEgressPointerOutput>> result =
417 l3nexthopService.getEgressPointer(new GetEgressPointerInputBuilder().setDpnId(dpId)
418 .setIpPrefix(vrfEntry.getDestPrefix())
419 .setNexthopIp(vrfEntry.getNextHopAddress())
422 RpcResult<GetEgressPointerOutput> rpcResult = result.get();
423 if (rpcResult.isSuccessful()) {
424 adjacency = rpcResult.getResult();
426 LOG.error("Next hop information not available");
428 } catch (NullPointerException | InterruptedException | ExecutionException e) {
434 private Long getVpnId(String rd) {
436 InstanceIdentifier<VpnInstances> id = InstanceIdentifier.create(VpnInstances.class);
437 Optional<VpnInstances> vpnInstances = read(LogicalDatastoreType.OPERATIONAL, id);
438 if(vpnInstances.isPresent()) {
439 List<VpnInstance> vpns = vpnInstances.get().getVpnInstance();
440 for(VpnInstance vpn : vpns) {
441 if(vpn.getIpv4Family().getRouteDistinguisher().equals(rd)) {
442 VpnInstance1 vpnInstanceId = vpn.getAugmentation(VpnInstance1.class);
443 if (vpnInstanceId != null) {
444 vpnId = vpnInstanceId.getVpnId();
453 public void processNodeAdd(long dpnId) {
454 LOG.debug("Received notification to install TableMiss entries for dpn {} ", dpnId);
455 makeTableMissFlow(dpnId, NwConstants.ADD_FLOW);
458 private void makeTableMissFlow(long dpnId, int addOrRemove) {
459 final BigInteger COOKIE_TABLE_MISS = new BigInteger("1030000", 16);
460 // Instruction to punt to controller
461 List<InstructionInfo> instructions = new ArrayList<InstructionInfo>();
462 List<ActionInfo> actionsInfos = new ArrayList<ActionInfo>();
463 actionsInfos.add(new ActionInfo(ActionType.punt_to_controller, new String[] {}));
464 instructions.add(new InstructionInfo(InstructionType.write_actions, actionsInfos));
465 List<MatchInfo> matches = new ArrayList<MatchInfo>();
466 FlowEntity flowEntityLfib = MDSALUtil.buildFlowEntity(dpnId, L3_LFIB_TABLE,
467 getFlowRef(dpnId, L3_LFIB_TABLE, NwConstants.TABLE_MISS_FLOW),
468 NwConstants.TABLE_MISS_PRIORITY, "Table Miss", 0, 0, COOKIE_TABLE_MISS, matches, instructions);
470 FlowEntity flowEntityFib = MDSALUtil.buildFlowEntity(dpnId,L3_FIB_TABLE, getFlowRef(dpnId, L3_FIB_TABLE, NwConstants.TABLE_MISS_FLOW),
471 NwConstants.TABLE_MISS_PRIORITY, "FIB Table Miss Flow", 0, 0, COOKIE_VM_FIB_TABLE,
472 matches, instructions);
474 if (addOrRemove == NwConstants.ADD_FLOW) {
475 LOG.debug("Invoking MDSAL to install Table Miss Entries");
476 mdsalManager.installFlow(flowEntityLfib);
477 mdsalManager.installFlow(flowEntityFib);
479 mdsalManager.removeFlow(flowEntityLfib);
480 mdsalManager.removeFlow(flowEntityFib);
485 private String getFlowRef(long dpnId, short tableId, int tableMiss) {
486 return new StringBuffer().append(FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
487 .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(tableMiss)
488 .append(FLOWID_PREFIX).toString();