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