2 * Copyright (c) 2015 Cisco Systems, Inc. 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
9 package org.opendaylight.lispflowmapping.implementation;
11 import java.util.ArrayList;
12 import java.util.EnumMap;
13 import java.util.List;
14 import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
15 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
16 import org.opendaylight.lispflowmapping.implementation.util.DSBEInputUtil;
17 import org.opendaylight.lispflowmapping.implementation.util.MappingMergeUtil;
18 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
19 import org.opendaylight.lispflowmapping.interfaces.mapcache.IMapCache;
20 import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
21 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
22 import org.opendaylight.lispflowmapping.lisp.util.LispAddressStringifier;
23 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
24 import org.opendaylight.lispflowmapping.mapcache.FlatMapCache;
25 import org.opendaylight.lispflowmapping.mapcache.MultiTableMapCache;
26 import org.opendaylight.lispflowmapping.mapcache.SimpleMapCache;
27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ServicePath;
32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
45 import org.slf4j.Logger;
46 import org.slf4j.LoggerFactory;
49 * The Mapping System coordinates caching of md-sal stored mappings and if so configured enables longest prefix match
52 * @author Florin Coras
55 public class MappingSystem implements IMappingSystem {
56 private static final Logger LOG = LoggerFactory.getLogger(MappingSystem.class);
57 private boolean iterateMask;
58 private boolean notificationService;
59 private boolean overwrite;
61 private IMapCache smc;
62 private IMapCache pmc;
63 private final EnumMap<MappingOrigin, IMapCache> tableMap = new EnumMap<>(MappingOrigin.class);
64 private DataStoreBackEnd dsbe;
65 private boolean isMaster = false;
67 public MappingSystem(ILispDAO dao, boolean iterateMask, boolean notifications, boolean overwrite) {
69 this.iterateMask = iterateMask;
70 this.notificationService = notifications;
71 this.overwrite = overwrite;
75 public void setDataStoreBackEnd(DataStoreBackEnd dsbe) {
80 public void setOverwritePolicy(boolean overwrite) {
81 this.overwrite = overwrite;
85 public void setIterateMask(boolean iterate) {
86 this.iterateMask = iterate;
87 if (smc != null || pmc != null) {
92 public void initialize() {
93 restoreDaoFromDatastore();
96 private void buildMapCaches() {
98 * There exists a direct relationship between MappingOrigins and the tables that are part of the MappingSystem.
99 * Therefore, if a new origin is added, probably a new table should be instantiate here as well.
102 smc = new SimpleMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
103 pmc = new MultiTableMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
105 smc = new FlatMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
106 pmc = new FlatMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
108 tableMap.put(MappingOrigin.Northbound, pmc);
109 tableMap.put(MappingOrigin.Southbound, smc);
112 public void addMapping(MappingOrigin origin, Eid key, Object value, boolean merge) {
113 tableMap.get(origin).addMapping(key, value, origin == MappingOrigin.Southbound ? overwrite : true, merge);
116 public void updateMappingRegistration(MappingOrigin origin, Eid key, Long timestamp) {
117 tableMap.get(origin).updateMappingRegistration(key, timestamp);
120 private MappingRecord updateServicePathMappingRecord(MappingRecord mapping, Eid eid) {
121 // keep properties of original record
122 MappingRecordBuilder recordBuilder = new MappingRecordBuilder(mapping);
123 recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
125 // there should only be one locator record
126 if (mapping.getLocatorRecord().size() != 1) {
127 LOG.warn("MappingRecord associated to ServicePath EID has more than one locator!");
131 LocatorRecord locatorRecord = mapping.getLocatorRecord().get(0);
132 long serviceIndex = ((ServicePath) eid.getAddress()).getServicePath().getServiceIndex();
133 int index = LispAddressUtil.STARTING_SERVICE_INDEX - (int) serviceIndex;
134 Rloc rloc = locatorRecord.getRloc();
135 if (rloc.getAddress() instanceof Ipv4 || rloc.getAddress() instanceof Ipv6) {
137 LOG.warn("Service Index should be 255 for simple IP RLOCs!");
140 } else if (rloc.getAddress() instanceof ExplicitLocatorPath) {
141 ExplicitLocatorPath elp = (ExplicitLocatorPath) rloc.getAddress();
142 List<Hop> hops = elp.getExplicitLocatorPath().getHop();
144 if (index < 0 || index > hops.size()) {
145 LOG.warn("Service Index out of bounds!");
149 SimpleAddress nextHop = hops.get(index).getAddress();
150 LocatorRecordBuilder lrb = new LocatorRecordBuilder(locatorRecord);
151 lrb.setRloc(LispAddressUtil.toRloc(nextHop));
152 recordBuilder.getLocatorRecord().add(lrb.build());
153 return recordBuilder.build();
155 LOG.warn("Nothing to do with ServicePath mapping record");
161 public Object getMapping(Eid src, Eid dst) {
162 // NOTE: Currently we have two lookup algorithms implemented, which are configurable
164 if (ConfigIni.getInstance().getLookupPolicy() == IMappingService.LookupPolicy.NB_AND_SB) {
165 return getMappingNbSbIntersection(src, dst);
167 return getMappingNbFirst(src, dst);
172 public Object getMapping(Eid dst) {
173 return getMapping((Eid)null, dst);
177 public Object getMapping(Eid src, Eid dst, XtrId xtrId) {
178 // Note: If xtrId is null, we need to go through regular policy checking else Policy doesn't matter
181 return getMapping(src, dst);
184 return smc.getMapping(src, dst, xtrId.getValue());
188 public Object getMapping(MappingOrigin origin, Eid key) {
189 if (origin.equals(MappingOrigin.Southbound)) {
190 return getSbMappingWithExpiration(null, key);
192 return tableMap.get(origin).getMapping(null, key);
195 private Object getMappingNbFirst(Eid src, Eid dst) {
197 // Default lookup policy is northboundFirst
198 //lookupPolicy == NB_FIRST
200 Object nbMapping = pmc.getMapping(src, dst);
202 if (nbMapping == null) {
203 return getSbMappingWithExpiration(src, dst);
205 if (dst.getAddress() instanceof ServicePath) {
206 return updateServicePathMappingRecord((MappingRecord) nbMapping, dst);
211 private Object getMappingNbSbIntersection(Eid src, Eid dst) {
212 //lookupPolicy == NB_AND_SB, we return intersection
213 //of NB and SB mappings, or NB mapping if intersection is empty.
215 Object nbMapping = pmc.getMapping(src, dst);
216 if (nbMapping == null) {
219 // no intersection for Service Path mappings
220 if (dst.getAddress() instanceof ServicePath) {
221 return updateServicePathMappingRecord((MappingRecord)nbMapping, dst);
223 Object sbMapping = getSbMappingWithExpiration(src, dst);
224 if (sbMapping == null) {
227 // both NB and SB mappings exist. Compute intersection of the mappings
228 return MappingMergeUtil.computeNbSbIntersection((MappingRecord)nbMapping, (MappingRecord)sbMapping);
231 private Object getSbMappingWithExpiration(Eid src, Eid dst) {
232 Object mappingObject = smc.getMapping(src, dst);
233 if (mappingObject instanceof MappingRecord) {
234 MappingRecord mapping = (MappingRecord) mappingObject;
235 if (MappingMergeUtil.mappingIsExpired(mapping)) {
236 dsbe.removeMapping(DSBEInputUtil.toMapping(MappingOrigin.Southbound, mapping.getEid(),
237 new SiteId(mapping.getSiteId()), mapping));
241 return mappingObject;
245 public Eid getWidestNegativePrefix(Eid key) {
246 Eid nbPrefix = pmc.getWidestNegativeMapping(key);
247 if (nbPrefix == null) {
251 Eid sbPrefix = smc.getWidestNegativeMapping(key);
252 if (sbPrefix == null) {
256 // since prefixes overlap, just return the more specific (larger mask)
257 if (LispAddressUtil.getIpPrefixMask(nbPrefix) < LispAddressUtil.getIpPrefixMask(sbPrefix)) {
265 public void removeMapping(MappingOrigin origin, Eid key) {
266 tableMap.get(origin).removeMapping(key, origin == MappingOrigin.Southbound ? overwrite : true);
267 if (notificationService) {
273 public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
274 LOG.debug("Adding authentication key '{}' with key-ID {} for {}", authKey.getKeyString(), authKey.getKeyType(),
275 LispAddressStringifier.getString(key));
276 smc.addAuthenticationKey(key, authKey);
280 public MappingAuthkey getAuthenticationKey(Eid key) {
281 if (LOG.isDebugEnabled()) {
282 LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
284 return smc.getAuthenticationKey(key);
288 public void removeAuthenticationKey(Eid key) {
289 if (LOG.isDebugEnabled()) {
290 LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
292 smc.removeAuthenticationKey(key);
296 public void addData(MappingOrigin origin, Eid key, String subKey, Object data) {
297 if (LOG.isDebugEnabled()) {
298 LOG.debug("Add data of class {} for key {} and subkey {}", data.getClass(),
299 LispAddressStringifier.getString(key), subKey);
301 tableMap.get(origin).addData(key, subKey, data);
305 public Object getData(MappingOrigin origin, Eid key, String subKey) {
306 if (LOG.isDebugEnabled()) {
307 LOG.debug("Retrieving data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
309 return tableMap.get(origin).getData(key, subKey);
313 public void removeData(MappingOrigin origin, Eid key, String subKey) {
314 if (LOG.isDebugEnabled()) {
315 LOG.debug("Removing data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
317 tableMap.get(origin).removeData(key, subKey);
322 * Restore all mappings and keys from mdsal datastore.
324 private void restoreDaoFromDatastore() {
325 List<Mapping> mappings = dsbe.getAllMappings();
326 List<AuthenticationKey> authKeys = dsbe.getAllAuthenticationKeys();
328 LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size());
330 int expiredMappings = 0;
331 for (Mapping mapping : mappings) {
332 if (MappingMergeUtil.mappingIsExpired(mapping.getMappingRecord())) {
333 dsbe.removeMapping(mapping);
337 addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord(), false);
339 LOG.info("{} mappings were expired and were not restored", expiredMappings);
341 for (AuthenticationKey authKey : authKeys) {
342 addAuthenticationKey(authKey.getEid(), authKey.getMappingAuthkey());
346 public void destroy() {
347 LOG.info("Mapping System is being destroyed!");
351 public String printMappings() {
352 final StringBuffer sb = new StringBuffer();
353 sb.append("PolicyMapCache\n--------------\n");
354 sb.append(pmc.printMappings());
355 sb.append("SbMapCache\n----------\n");
356 sb.append(smc.printMappings());
357 return sb.toString();
360 public void cleanCaches() {
366 public void setIsMaster(boolean isMaster) {
367 this.isMaster = isMaster;
371 public boolean isMaster() {