mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/mdsal/MappingDataListener.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 package org.opendaylight.lispflowmapping.implementation.mdsal;
   9
  10 import java.util.Collection;
  11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  12 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
  13 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
  14 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  15 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  16 import org.opendaylight.lispflowmapping.implementation.util.MSNotificationInputUtil;
  17 import org.opendaylight.lispflowmapping.interfaces.mapcache.IMappingSystem;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingChange;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingDatabase;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.database.VirtualNetworkIdentifier;
  23 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 /**
  28  * DataListener for all Mapping modification events.
  29  *
  30  * @author Lorand Jakab
  31  * @author Florin Coras
  32  *
  33  */
  34 public class MappingDataListener extends NewAbstractDataListener<Mapping> {
  35     private static final Logger LOG = LoggerFactory.getLogger(MappingDataListener.class);
  36     private IMappingSystem mapSystem;
  37     private NotificationPublishService notificationPublishService;
  38
  39     public MappingDataListener(DataBroker broker, IMappingSystem msmr, NotificationPublishService nps) {
  40         setBroker(broker);
  41         setMappingSystem(msmr);
  42         setNotificationProviderService(nps);
  43         setPath(InstanceIdentifier.create(MappingDatabase.class).child(VirtualNetworkIdentifier.class)
  44                 .child(Mapping.class));
  45         LOG.trace("Registering Mapping listener.");
  46         registerDataChangeListener();
  47     }
  48
  49     public void setNotificationProviderService(NotificationPublishService nps) {
  50         this.notificationPublishService = nps;
  51     }
  52
  53     void setMappingSystem(IMappingSystem msmr) {
  54         this.mapSystem = msmr;
  55     }
  56
  57     @Override
  58     public void onDataTreeChanged(Collection<DataTreeModification<Mapping>> changes) {
  59         for (DataTreeModification<Mapping> change : changes) {
  60             final DataObjectModification<Mapping> mod = change.getRootNode();
  61
  62             if (ModificationType.DELETE == mod.getModificationType()) {
  63                 // Process deleted mappings
  64
  65                 final Mapping mapping = mod.getDataBefore();
  66
  67                 // Only treat mapping changes caused by Northbound, since Southbound changes are already handled
  68                 // before being persisted.
  69                 if (mapping.getOrigin() == MappingOrigin.Southbound) {
  70                     continue;
  71                 }
  72
  73                 LOG.trace("Received deleted data");
  74                 LOG.trace("Key: {}", change.getRootPath().getRootIdentifier());
  75                 LOG.trace("Value: {}", mapping);
  76
  77                 mapSystem.removeMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid());
  78                 try {
  79                     notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(
  80                             mapping, MappingChange.Removed));
  81                 } catch (InterruptedException e) {
  82                     LOG.warn("Notification publication interrupted!");
  83                 }
  84
  85             } else if (ModificationType.SUBTREE_MODIFIED == mod.getModificationType() || ModificationType.WRITE == mod
  86                     .getModificationType()) {
  87                 final Mapping mapping = mod.getDataAfter();
  88
  89                 // Only treat mapping changes caused by Northbound, since Southbound changes are already handled
  90                 // before being persisted. XXX separate NB and SB to avoid ignoring SB notifications
  91                 if (mapping.getOrigin() == MappingOrigin.Southbound) {
  92                     continue;
  93                 }
  94
  95                 MappingChange mappingChange;
  96
  97                 if (ModificationType.SUBTREE_MODIFIED == mod.getModificationType()) {
  98                     LOG.trace("Received update data");
  99                     mappingChange = MappingChange.Updated;
 100                 } else {
 101                     LOG.trace("Received write data");
 102                     mappingChange = MappingChange.Created;
 103                 }
 104                 LOG.trace("Key: {}", change.getRootPath().getRootIdentifier());
 105                 LOG.trace("Value: {}", mapping);
 106
 107                 mapSystem.addMapping(mapping.getOrigin(), mapping.getMappingRecord().getEid(),
 108                         mapping.getMappingRecord(), false);
 109
 110                 try {
 111                     // The notifications are used for sending SMR.
 112                     notificationPublishService.putNotification(MSNotificationInputUtil.toMappingChanged(mapping,
 113                             mappingChange));
 114                 } catch (InterruptedException e) {
 115                     LOG.warn("Notification publication interrupted!");
 116                 }
 117
 118             } else {
 119                 LOG.warn("Ignoring unhandled modification type {}", mod.getModificationType());
 120             }
 121         }
 122     }
 123 }