mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/MappingSystem.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc.  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.lispflowmapping.implementation;
  10
  11 import java.util.ArrayList;
  12 import java.util.EnumMap;
  13 import java.util.List;
  14 import org.opendaylight.lispflowmapping.config.ConfigIni;
  15 import org.opendaylight.lispflowmapping.dsbackend.DataStoreBackEnd;
  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;
  47
  48 /**
  49  * The Mapping System coordinates caching of md-sal stored mappings and if so configured enables longest prefix match
  50  * mapping lookups.
  51  *
  52  * @author Florin Coras
  53  *
  54  */
  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;
  60     private ILispDAO dao;
  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;
  66
  67     public MappingSystem(ILispDAO dao, boolean iterateMask, boolean notifications, boolean overwrite) {
  68         this.dao = dao;
  69         this.iterateMask = iterateMask;
  70         this.notificationService = notifications;
  71         this.overwrite = overwrite;
  72         buildMapCaches();
  73     }
  74
  75     public void setDataStoreBackEnd(DataStoreBackEnd dsbe) {
  76         this.dsbe = dsbe;
  77     }
  78
  79     @Override
  80     public void setOverwritePolicy(boolean overwrite) {
  81         this.overwrite = overwrite;
  82     }
  83
  84     @Override
  85     public void setIterateMask(boolean iterate) {
  86         this.iterateMask = iterate;
  87         if (smc != null || pmc != null) {
  88             buildMapCaches();
  89         }
  90     }
  91
  92     public void initialize() {
  93         restoreDaoFromDatastore();
  94     }
  95
  96     private void buildMapCaches() {
  97         /*
  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.
 100          */
 101         if (iterateMask) {
 102             smc = new SimpleMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
 103             pmc = new MultiTableMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
 104         } else {
 105             smc = new FlatMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
 106             pmc = new FlatMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
 107         }
 108         tableMap.put(MappingOrigin.Northbound, pmc);
 109         tableMap.put(MappingOrigin.Southbound, smc);
 110     }
 111
 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);
 114     }
 115
 116     public void updateMappingRegistration(MappingOrigin origin, Eid key, Long timestamp) {
 117         tableMap.get(origin).updateMappingRegistration(key, timestamp);
 118     }
 119
 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>());
 124
 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!");
 128             return mapping;
 129         }
 130
 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) {
 136             if (index != 0) {
 137                 LOG.warn("Service Index should be 255 for simple IP RLOCs!");
 138             }
 139             return mapping;
 140         } else if (rloc.getAddress() instanceof ExplicitLocatorPath) {
 141             ExplicitLocatorPath elp = (ExplicitLocatorPath) rloc.getAddress();
 142             List<Hop> hops = elp.getExplicitLocatorPath().getHop();
 143
 144             if (index < 0 || index > hops.size())  {
 145                 LOG.warn("Service Index out of bounds!");
 146                 return mapping;
 147             }
 148
 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();
 154         } else {
 155             LOG.warn("Nothing to do with ServicePath mapping record");
 156             return mapping;
 157         }
 158     }
 159
 160     @Override
 161     public Object getMapping(Eid src, Eid dst) {
 162         // NOTE: Currently we have two lookup algorithms implemented, which are configurable
 163
 164         if (ConfigIni.getInstance().getLookupPolicy() == IMappingService.LookupPolicy.NB_AND_SB) {
 165             return getMappingNbSbIntersection(src, dst);
 166         } else {
 167             return getMappingNbFirst(src, dst);
 168         }
 169     }
 170
 171     @Override
 172     public Object getMapping(Eid dst) {
 173         return getMapping((Eid)null, dst);
 174     }
 175
 176     @Override
 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
 179
 180         if (xtrId == null) {
 181             return getMapping(src, dst);
 182         }
 183
 184         return smc.getMapping(src, dst, xtrId.getValue());
 185     }
 186
 187     @Override
 188     public Object getMapping(MappingOrigin origin, Eid key) {
 189         if (origin.equals(MappingOrigin.Southbound)) {
 190             return getSbMappingWithExpiration(null, key);
 191         }
 192         return tableMap.get(origin).getMapping(null, key);
 193     }
 194
 195     private Object getMappingNbFirst(Eid src, Eid dst) {
 196
 197         // Default lookup policy is northboundFirst
 198         //lookupPolicy == NB_FIRST
 199
 200         Object nbMapping = pmc.getMapping(src, dst);
 201
 202         if (nbMapping == null) {
 203             return getSbMappingWithExpiration(src, dst);
 204         }
 205         if (dst.getAddress() instanceof ServicePath) {
 206             return updateServicePathMappingRecord((MappingRecord) nbMapping, dst);
 207         }
 208         return nbMapping;
 209     }
 210
 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.
 214
 215         Object nbMapping = pmc.getMapping(src, dst);
 216         if (nbMapping == null) {
 217             return nbMapping;
 218         }
 219         // no intersection for Service Path mappings
 220         if (dst.getAddress() instanceof ServicePath) {
 221             return updateServicePathMappingRecord((MappingRecord)nbMapping, dst);
 222         }
 223         Object sbMapping = getSbMappingWithExpiration(src, dst);
 224         if (sbMapping == null) {
 225             return nbMapping;
 226         }
 227         // both NB and SB mappings exist. Compute intersection of the mappings
 228         return MappingMergeUtil.computeNbSbIntersection((MappingRecord)nbMapping, (MappingRecord)sbMapping);
 229     }
 230
 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));
 238                 return null;
 239             }
 240         }
 241         return mappingObject;
 242     }
 243
 244     @Override
 245     public Eid getWidestNegativePrefix(Eid key) {
 246         Eid nbPrefix = pmc.getWidestNegativeMapping(key);
 247         if (nbPrefix == null) {
 248             return null;
 249         }
 250
 251         Eid sbPrefix = smc.getWidestNegativeMapping(key);
 252         if (sbPrefix == null) {
 253             return null;
 254         }
 255
 256         // since prefixes overlap, just return the more specific (larger mask)
 257         if (LispAddressUtil.getIpPrefixMask(nbPrefix) < LispAddressUtil.getIpPrefixMask(sbPrefix)) {
 258             return sbPrefix;
 259         } else {
 260             return nbPrefix;
 261         }
 262     }
 263
 264     @Override
 265     public void removeMapping(MappingOrigin origin, Eid key) {
 266         tableMap.get(origin).removeMapping(key, origin == MappingOrigin.Southbound ? overwrite : true);
 267         if (notificationService) {
 268             // TODO
 269         }
 270     }
 271
 272     @Override
 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);
 277     }
 278
 279     @Override
 280     public MappingAuthkey getAuthenticationKey(Eid key) {
 281         if (LOG.isDebugEnabled()) {
 282             LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
 283         }
 284         return smc.getAuthenticationKey(key);
 285     }
 286
 287     @Override
 288     public void removeAuthenticationKey(Eid key) {
 289         if (LOG.isDebugEnabled()) {
 290             LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
 291         }
 292         smc.removeAuthenticationKey(key);
 293     }
 294
 295     @Override
 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);
 300         }
 301         tableMap.get(origin).addData(key, subKey, data);
 302     }
 303
 304     @Override
 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);
 308         }
 309         return tableMap.get(origin).getData(key, subKey);
 310     }
 311
 312     @Override
 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);
 316         }
 317         tableMap.get(origin).removeData(key, subKey);
 318     }
 319
 320
 321     /**
 322      * Restore all mappings and keys from mdsal datastore.
 323      */
 324     private void restoreDaoFromDatastore() {
 325         List<Mapping> mappings = dsbe.getAllMappings();
 326         List<AuthenticationKey> authKeys = dsbe.getAllAuthenticationKeys();
 327
 328         LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size());
 329
 330         int expiredMappings = 0;
 331         for (Mapping mapping : mappings) {
 332             if (MappingMergeUtil.mappingIsExpired(mapping.getMappingRecord())) {
 333                 dsbe.removeMapping(mapping);
 334                 expiredMappings++;
 335                 continue;
 336             }
 337             addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord(), false);
 338         }
 339         LOG.info("{} mappings were expired and were not restored", expiredMappings);
 340
 341         for (AuthenticationKey authKey : authKeys) {
 342             addAuthenticationKey(authKey.getEid(), authKey.getMappingAuthkey());
 343         }
 344     }
 345
 346     public void destroy() {
 347         LOG.info("Mapping System is being destroyed!");
 348     }
 349
 350     @Override
 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();
 358     }
 359
 360     public void cleanCaches() {
 361         dao.removeAll();
 362         buildMapCaches();
 363     }
 364
 365     @Override
 366     public void setIsMaster(boolean isMaster) {
 367         this.isMaster = isMaster;
 368     }
 369
 370     @Override
 371     public boolean isMaster() {
 372         return isMaster;
 373     }
 374 }