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.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.eid.container.Eid;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.AuthenticationKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 /**
  48  * The Mapping System coordinates caching of md-sal stored mappings and if so configured enables longest prefix match
  49  * mapping lookups.
  50  *
  51  * @author Florin Coras
  52  *
  53  */
  54 public class MappingSystem implements IMappingSystem {
  55     private static final Logger LOG = LoggerFactory.getLogger(MappingSystem.class);
  56     private boolean iterateMask;
  57     private boolean notificationService;
  58     private boolean overwrite;
  59     private ILispDAO dao;
  60     private IMapCache smc;
  61     private IMapCache pmc;
  62     private final EnumMap<MappingOrigin, IMapCache> tableMap = new EnumMap<>(MappingOrigin.class);
  63     private DataStoreBackEnd dsbe;
  64
  65     public MappingSystem(ILispDAO dao, boolean iterateMask, boolean notifications, boolean overwrite) {
  66         this.dao = dao;
  67         this.iterateMask = iterateMask;
  68         this.notificationService = notifications;
  69         this.overwrite = overwrite;
  70         buildMapCaches();
  71     }
  72
  73     public void setDataStoreBackEnd(DataStoreBackEnd dsbe) {
  74         this.dsbe = dsbe;
  75     }
  76
  77     @Override
  78     public void setOverwritePolicy(boolean overwrite) {
  79         this.overwrite = overwrite;
  80     }
  81
  82     @Override
  83     public void setIterateMask(boolean iterate) {
  84         this.iterateMask = iterate;
  85         if (smc != null || pmc != null) {
  86             buildMapCaches();
  87         }
  88     }
  89
  90     public void initialize() {
  91         restoreDaoFromDatastore();
  92     }
  93
  94     private void buildMapCaches() {
  95         /*
  96          * There exists a direct relationship between MappingOrigins and the tables that are part of the MappingSystem.
  97          * Therefore, if a new origin is added, probably a new table should be instantiate here as well.
  98          */
  99         if (iterateMask) {
 100             smc = new SimpleMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
 101             pmc = new MultiTableMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
 102         } else {
 103             smc = new FlatMapCache(dao.putTable(MappingOrigin.Southbound.toString()));
 104             pmc = new FlatMapCache(dao.putTable(MappingOrigin.Northbound.toString()));
 105         }
 106         tableMap.put(MappingOrigin.Northbound, pmc);
 107         tableMap.put(MappingOrigin.Southbound, smc);
 108     }
 109
 110     public void addMapping(MappingOrigin origin, Eid key, Object value, boolean merge) {
 111         tableMap.get(origin).addMapping(key, value, origin == MappingOrigin.Southbound ? overwrite : true, merge);
 112     }
 113
 114     public void updateMappingRegistration(MappingOrigin origin, Eid key, Long timestamp) {
 115         tableMap.get(origin).updateMappingRegistration(key, timestamp);
 116     }
 117
 118     private MappingRecord updateServicePathMappingRecord(MappingRecord mapping, Eid eid) {
 119         // keep properties of original record
 120         MappingRecordBuilder recordBuilder = new MappingRecordBuilder(mapping);
 121         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
 122
 123         // there should only be one locator record
 124         if (mapping.getLocatorRecord().size() != 1) {
 125             LOG.warn("MappingRecord associated to ServicePath EID has more than one locator!");
 126             return mapping;
 127         }
 128
 129         LocatorRecord locatorRecord = mapping.getLocatorRecord().get(0);
 130         long serviceIndex = ((ServicePath) eid.getAddress()).getServicePath().getServiceIndex();
 131         int index = LispAddressUtil.STARTING_SERVICE_INDEX - (int) serviceIndex;
 132         Rloc rloc = locatorRecord.getRloc();
 133         if (rloc.getAddress() instanceof Ipv4 || rloc.getAddress() instanceof Ipv6) {
 134             if (index != 0) {
 135                 LOG.warn("Service Index should be 255 for simple IP RLOCs!");
 136             }
 137             return mapping;
 138         } else if (rloc.getAddress() instanceof ExplicitLocatorPath) {
 139             ExplicitLocatorPath elp = (ExplicitLocatorPath) rloc.getAddress();
 140             List<Hop> hops = elp.getExplicitLocatorPath().getHop();
 141
 142             if (index < 0 || index > hops.size())  {
 143                 LOG.warn("Service Index out of bounds!");
 144                 return mapping;
 145             }
 146
 147             SimpleAddress nextHop = hops.get(index).getAddress();
 148             LocatorRecordBuilder lrb = new LocatorRecordBuilder(locatorRecord);
 149             lrb.setRloc(LispAddressUtil.toRloc(nextHop));
 150             recordBuilder.getLocatorRecord().add(lrb.build());
 151             return recordBuilder.build();
 152         } else {
 153             LOG.warn("Nothing to do with ServicePath mapping record");
 154             return mapping;
 155         }
 156     }
 157
 158     @Override
 159     public Object getMapping(Eid src, Eid dst) {
 160         // NOTE: Currently we have two lookup algorithms implemented, which are configurable
 161
 162         if (ConfigIni.getInstance().getLookupPolicy() == IMappingService.LookupPolicy.NB_AND_SB) {
 163             return getMappingNbSbIntersection(src, dst);
 164         } else {
 165             return getMappingNbFirst(src, dst);
 166         }
 167     }
 168
 169     @Override
 170     public Object getMapping(Eid dst) {
 171         return getMapping((Eid)null, dst);
 172     }
 173
 174     @Override
 175     public Object getMapping(MappingOrigin origin, Eid key) {
 176         if (origin.equals(MappingOrigin.Southbound)) {
 177             return getSbMappingWithExpiration(null, key);
 178         }
 179         return tableMap.get(origin).getMapping(null, key);
 180     }
 181
 182     private Object getMappingNbFirst(Eid src, Eid dst) {
 183
 184         // Default lookup policy is northboundFirst
 185         //lookupPolicy == NB_FIRST
 186
 187         Object nbMapping = pmc.getMapping(src, dst);
 188
 189         if (nbMapping == null) {
 190             return getSbMappingWithExpiration(src, dst);
 191         }
 192         if (dst.getAddress() instanceof ServicePath) {
 193             return updateServicePathMappingRecord((MappingRecord) nbMapping, dst);
 194         }
 195         return nbMapping;
 196     }
 197
 198     private Object getMappingNbSbIntersection(Eid src, Eid dst) {
 199         //lookupPolicy == NB_AND_SB, we return intersection
 200         //of NB and SB mappings, or NB mapping if intersection is empty.
 201
 202         Object nbMapping = pmc.getMapping(src, dst);
 203         if (nbMapping == null) {
 204             return nbMapping;
 205         }
 206         // no intersection for Service Path mappings
 207         if (dst.getAddress() instanceof ServicePath) {
 208             return updateServicePathMappingRecord((MappingRecord)nbMapping, dst);
 209         }
 210         Object sbMapping = getSbMappingWithExpiration(src, dst);
 211         if (sbMapping == null) {
 212             return nbMapping;
 213         }
 214         // both NB and SB mappings exist. Compute intersection of the mappings
 215         return MappingMergeUtil.computeNbSbIntersection((MappingRecord)nbMapping, (MappingRecord)sbMapping);
 216     }
 217
 218     private Object getSbMappingWithExpiration(Eid src, Eid dst) {
 219         Object mappingObject = smc.getMapping(src, dst);
 220         if (mappingObject instanceof MappingRecord) {
 221             MappingRecord mapping = (MappingRecord) mappingObject;
 222             if (MappingMergeUtil.mappingIsExpired(mapping)) {
 223                 dsbe.removeMapping(DSBEInputUtil.toMapping(MappingOrigin.Southbound, mapping.getEid(),
 224                         new SiteId(mapping.getSiteId()), mapping));
 225                 return null;
 226             }
 227         }
 228         return mappingObject;
 229     }
 230
 231     @Override
 232     public Eid getWidestNegativePrefix(Eid key) {
 233         Eid nbPrefix = pmc.getWidestNegativeMapping(key);
 234         if (nbPrefix == null) {
 235             return null;
 236         }
 237
 238         Eid sbPrefix = smc.getWidestNegativeMapping(key);
 239         if (sbPrefix == null) {
 240             return null;
 241         }
 242
 243         // since prefixes overlap, just return the more specific (larger mask)
 244         if (LispAddressUtil.getIpPrefixMask(nbPrefix) < LispAddressUtil.getIpPrefixMask(sbPrefix)) {
 245             return sbPrefix;
 246         } else {
 247             return nbPrefix;
 248         }
 249     }
 250
 251     @Override
 252     public void removeMapping(MappingOrigin origin, Eid key) {
 253         tableMap.get(origin).removeMapping(key, origin == MappingOrigin.Southbound ? overwrite : true);
 254         if (notificationService) {
 255             // TODO
 256         }
 257     }
 258
 259     @Override
 260     public void addAuthenticationKey(Eid key, MappingAuthkey authKey) {
 261         LOG.debug("Adding authentication key '{}' with key-ID {} for {}", authKey.getKeyString(), authKey.getKeyType(),
 262                 LispAddressStringifier.getString(key));
 263         smc.addAuthenticationKey(key, authKey);
 264     }
 265
 266     @Override
 267     public MappingAuthkey getAuthenticationKey(Eid key) {
 268         if (LOG.isDebugEnabled()) {
 269             LOG.debug("Retrieving authentication key for {}", LispAddressStringifier.getString(key));
 270         }
 271         return smc.getAuthenticationKey(key);
 272     }
 273
 274     @Override
 275     public void removeAuthenticationKey(Eid key) {
 276         if (LOG.isDebugEnabled()) {
 277             LOG.debug("Removing authentication key for {}", LispAddressStringifier.getString(key));
 278         }
 279         smc.removeAuthenticationKey(key);
 280     }
 281
 282     @Override
 283     public void addData(MappingOrigin origin, Eid key, String subKey, Object data) {
 284         if (LOG.isDebugEnabled()) {
 285             LOG.debug("Add data of class {} for key {} and subkey {}", data.getClass(),
 286                     LispAddressStringifier.getString(key), subKey);
 287         }
 288         tableMap.get(origin).addData(key, subKey, data);
 289     }
 290
 291     @Override
 292     public Object getData(MappingOrigin origin, Eid key, String subKey) {
 293         if (LOG.isDebugEnabled()) {
 294             LOG.debug("Retrieving data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
 295         }
 296         return tableMap.get(origin).getData(key, subKey);
 297     }
 298
 299     @Override
 300     public void removeData(MappingOrigin origin, Eid key, String subKey) {
 301         if (LOG.isDebugEnabled()) {
 302             LOG.debug("Removing data for key {} and subkey {}", LispAddressStringifier.getString(key), subKey);
 303         }
 304         tableMap.get(origin).removeData(key, subKey);
 305     }
 306
 307
 308     /**
 309      * Restore all mappings and keys from mdsal datastore.
 310      */
 311     private void restoreDaoFromDatastore() {
 312         List<Mapping> mappings = dsbe.getAllMappings();
 313         List<AuthenticationKey> authKeys = dsbe.getAllAuthenticationKeys();
 314
 315         LOG.info("Restoring {} mappings and {} keys from datastore into DAO", mappings.size(), authKeys.size());
 316
 317         int expiredMappings = 0;
 318         for (Mapping mapping : mappings) {
 319             if (MappingMergeUtil.mappingIsExpired(mapping.getMappingRecord())) {
 320                 dsbe.removeMapping(mapping);
 321                 expiredMappings++;
 322                 continue;
 323             }
 324             addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(), mapping.getMappingRecord(), false);
 325         }
 326         LOG.info("{} mappings were expired and were not restored", expiredMappings);
 327
 328         for (AuthenticationKey authKey : authKeys) {
 329             addAuthenticationKey(authKey.getEid(), authKey.getMappingAuthkey());
 330         }
 331     }
 332
 333     public void destroy() {
 334         LOG.info("Mapping System is being destroyed!");
 335     }
 336
 337     @Override
 338     public String printMappings() {
 339         final StringBuffer sb = new StringBuffer();
 340         sb.append("PolicyMapCache\n--------------\n");
 341         sb.append(pmc.printMappings());
 342         sb.append("SbMapCache\n----------\n");
 343         sb.append(smc.printMappings());
 344         return sb.toString();
 345     }
 346
 347     public void cleanCaches() {
 348         dao.removeAll();
 349         buildMapCaches();
 350     }
 351 }