introduced Daos and Listeners

Change-Id: Idde19d276fa092d03c004d4c3c2aba75cb91a88d
Signed-off-by: Michal Rehak <mirehak@cisco.com>

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDao.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDao.java
new file mode 100644 (file)
index 0000000..9c6c3d5
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDao.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
+
+import com.google.common.base.Optional;
+import javax.annotation.Nonnull;
+
+/**
+ * Purpose: encapsulate access to DS by exposing
+ * <dl>
+ * <dt>read</dt>
+ * <dd>search through available values (e.g.: in  local cache)</dd>
+ * </dl>
+ *
+ * @param <K> data key type
+ * @param <V> data type
+ */
+public interface DSDao<K, V> {
+
+    /**
+     * @param key for search
+     * @return value found by key
+     */
+    Optional<V> read(@Nonnull K key);
+
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoAsync.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoAsync.java
new file mode 100644 (file)
index 0000000..75b5fde
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoAsync.java
@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Purpose: encapsulate access to DS by exposing
+ * <dl>
+ * <dt>read</dt>
+ * <dd>search through values (either in local cache or directly in DataStore)</dd>
+ * </dl>
+ *
+ * @param <K> data key type
+ * @param <V> data type
+ */
+public interface DSDaoAsync<K, V extends DataObject> {
+
+    /**
+     * @param key for search
+     * @return value found by key
+     */
+    ListenableFuture<Optional<V>> read(@Nonnull K key);
+
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoCached.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoCached.java
new file mode 100644 (file)
index 0000000..7779771
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/DSDaoCached.java
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
+
+import java.util.Map;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Purpose: encapsulate access to DS by exposing
+ * <dl>
+ * <dt>read</dt>
+ * <dd>search through cached values</dd>
+ * <dt>update</dt>
+ * <dd>stores given pair (key, value) to local cache</dd>
+ * </dl>
+ *
+ * @param <K> data key type
+ * @param <V> data type
+ */
+public interface DSDaoCached<K, V> extends DSDao<K, V> {
+
+    /**
+     * store given pair to local cache
+     *
+     * @param key   associated to value
+     * @param value associated to key
+     */
+    void update(@Nonnull K key, @Nullable V value);
+
+    /**
+     * @return unmodifiable view of cache backend map
+     */
+    Map<K, V> getBackendMapView();
+
+    /**
+     * invalidate all cache entries
+     */
+    void invalidateCache();
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/EPTemplateListener.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/EPTemplateListener.java
index f11007a8eccfd3fd7a712f1c2dd4336f770b5a90..1f9fe0cfa0c348f9e98352b799b5a5570fdd1e5f 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/EPTemplateListener.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/EPTemplateListener.java
@@ -8,11 +8,17 @@
 
 package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
 
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.SxpMapper;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 /**
  * Purpose: provide listener capability to EB templates
  */
-public interface EPTemplateListener extends DataChangeListener, AutoCloseable {
+public interface EPTemplateListener<T extends DataObject> extends DataTreeChangeListener<T>, AutoCloseable {
+
+    InstanceIdentifier<SxpMapper> SXP_MAPPER_TEMPLATE_PARENT_PATH = InstanceIdentifier.create(SxpMapper.class);
+
     //NOBODY
 }

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/L3EndpointDao.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/L3EndpointDao.java
deleted file mode 100644 (file)
index 1547589..0000000
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/L3EndpointDao.java
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
-
-/**
- * Purpose: provides storing of L3 endpoints
- */
-public interface L3EndpointDao {
-}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/MasterDatabaseBindingListener.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/MasterDatabaseBindingListener.java
new file mode 100644 (file)
index 0000000..dbfcfe2
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/MasterDatabaseBindingListener.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
+
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Purpose: provide listener capability to {@link MasterDatabaseBinding} (Sxp - MasterDB)
+ */
+public interface MasterDatabaseBindingListener extends DataTreeChangeListener<MasterDatabaseBinding>, AutoCloseable {
+    /** path to SXP topology */
+    InstanceIdentifier<Topology> SXP_TOPOLOGY_PATH = null;
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/SxpMapperReactor.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/SxpMapperReactor.java
index 3e9f865e37e1466e37475c039b5a853227abda49..1dbd69362163fdd946006988e21c29d87fde1450 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/SxpMapperReactor.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/api/SxpMapperReactor.java
@@ -9,7 +9,7 @@
 package org.opendaylight.groupbasedpolicy.sxp.mapper.api;
 
 /**
- * Purpose: TODO!
+ * Purpose: process given ip-sgt binding and EP-template in order to create L3-EP
  */
 public interface SxpMapperReactor {
 }

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPForwardingTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPForwardingTemplateListenerImpl.java
deleted file mode 100644 (file)
index abab5da..0000000
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPForwardingTemplateListenerImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Purpose: listens to EP forwarding template and propagates change events for further processing
- */
-public class EPForwardingTemplateListenerImpl implements EPTemplateListener {
-
-    private static final Logger LOG = LoggerFactory.getLogger(EPForwardingTemplateListenerImpl.class);
-    private final SxpMapperReactor sxpMapperReactor;
-    private final ListenerRegistration<DataChangeListener> listenerRegistration;
-    private final InstanceIdentifier<?> templatePath;
-
-    public EPForwardingTemplateListenerImpl(final DataBroker dataBroker, final SxpMapperReactor sxpMapperReactor) {
-        this.sxpMapperReactor = sxpMapperReactor;
-
-        // TODO: get template path
-        templatePath = null;
-        listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, templatePath,
-                this, AsyncDataBroker.DataChangeScope.BASE);
-        LOG.debug("started listening to {}", templatePath);
-    }
-
-    @Override
-    public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> asyncDataChangeEvent) {
-        // sxpMapperReactor.process(template)
-    }
-
-    @Override
-    public void close() throws Exception {
-        LOG.debug("closing listener registration to {}", templatePath);
-        listenerRegistration.close();
-    }
-}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPPolicyTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPPolicyTemplateListenerImpl.java
deleted file mode 100644 (file)
index 0b1c4e8..0000000
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/EPPolicyTemplateListenerImpl.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Purpose: listens to EP policy template and propagates change events for further processing
- */
-public class EPPolicyTemplateListenerImpl implements EPTemplateListener {
-
-    private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateListenerImpl.class);
-    private final ListenerRegistration<DataChangeListener> listenerRegistration;
-    private final InstanceIdentifier<?> templatePath;
-
-    public EPPolicyTemplateListenerImpl(final DataBroker dataBroker, final SxpMapperReactor sxpMapperReactor) {
-        // TODO: get template path
-        templatePath = null;
-        listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, templatePath,
-                this, AsyncDataBroker.DataChangeScope.BASE);
-        LOG.debug("started listening to {}", templatePath);
-    }
-
-    @Override
-    public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> asyncDataChangeEvent) {
-        // sxpMapperReactor.process(template)
-    }
-
-    @Override
-    public void close() throws Exception {
-        LOG.debug("closing listener registration to {}", templatePath);
-        listenerRegistration.close();
-    }
-}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/L3EndpointDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/L3EndpointDaoImpl.java
deleted file mode 100644 (file)
index e0bbc91..0000000
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/L3EndpointDaoImpl.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.L3EndpointDao;
-
-/**
- * Purpose: stores L3 endpoints to DS
- */
-public class L3EndpointDaoImpl implements L3EndpointDao {
-    private final DataBroker dataBroker;
-
-    public L3EndpointDaoImpl(final DataBroker dataBroker) {
-        this.dataBroker = dataBroker;
-    }
-}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpDatabaseListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpDatabaseListenerImpl.java
deleted file mode 100644 (file)
index c8d163d..0000000
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpDatabaseListenerImpl.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * listens to sxp master database and propagates change events for further processing
- */
-public class SxpDatabaseListenerImpl implements DataChangeListener, AutoCloseable {
-
-    private static final Logger LOG = LoggerFactory.getLogger(SxpDatabaseListenerImpl.class);
-    private final SxpMapperReactor sxpMapperReactor;
-
-    private final ListenerRegistration<DataChangeListener> listenerRegistration;
-    private final InstanceIdentifier<?> sxpDbPath;
-
-    public SxpDatabaseListenerImpl(final DataBroker dataBroker, final SxpMapperReactor sxpMapperReactor) {
-        this.sxpMapperReactor = sxpMapperReactor;
-
-        // TODO: get db path
-        sxpDbPath = null;
-        listenerRegistration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, sxpDbPath,
-                this, AsyncDataBroker.DataChangeScope.BASE);
-        LOG.debug("started listening to {}", sxpDbPath);
-    }
-
-    @Override
-    public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> asyncDataChangeEvent) {
-        // sxpMapperReactor.process(template)
-    }
-
-    @Override
-    public void close() throws Exception {
-        LOG.debug("closing listener registration to {}", sxpDbPath);
-        listenerRegistration.close();
-    }
-}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
index ff0844cd2316248763232f8579fc028ec2e947c1..89865e870f498efd7790b7021d2e2a7148276065 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperProviderImpl.java
@@ -10,9 +10,21 @@ package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
 
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoAsync;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.L3EndpointDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.DSDaoCachedImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao.EPPolicyTemplateDaoImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.EPForwardingTemplateListenerImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.EPPolicyTemplateListenerImpl;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen.MasterDatabaseBindingListenerImpl;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
 
 /**
  * SxpMapper provider implementation.
@@ -21,7 +33,7 @@ public class SxpMapperProviderImpl implements AutoCloseable {
 
     private final DataBroker dataBrokerDependency;
     private final RpcProviderRegistry rpcRegistryDependency;
-    private final SxpDatabaseListenerImpl sxpDatabaseListener;
+    private final MasterDatabaseBindingListenerImpl sxpDatabaseListener;
     private final SxpMapperReactor sxpMapperReactor;
     private final EPTemplateListener epPolicyTemplateListener;
     private final EPTemplateListener epForwardingTemplateListener;
@@ -30,12 +42,20 @@ public class SxpMapperProviderImpl implements AutoCloseable {
         this.dataBrokerDependency = dataBroker;
         this.rpcRegistryDependency = rpcRegistryDependency;
 
-        final L3EndpointDao l3EndpointDao = new L3EndpointDaoImpl(dataBroker);
-        sxpMapperReactor = new SxpMapperReactorImpl(l3EndpointDao);
-        sxpDatabaseListener = new SxpDatabaseListenerImpl(dataBroker, sxpMapperReactor);
-        epPolicyTemplateListener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapperReactor);
-        epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor);
+        final EndpointService endpointService = rpcRegistryDependency.getRpcService(EndpointService.class);
+        sxpMapperReactor = new SxpMapperReactorImpl(endpointService);
 
+        final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao = new DSDaoCachedImpl<>();
+        final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateCachedDao = new DSDaoCachedImpl<>();
+        final DSDaoCached<Sgt, MasterDatabaseBinding> masterDBBindingCachedDao = new DSDaoCachedImpl<>();
+
+        final DSDaoAsync<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao = new EPPolicyTemplateDaoImpl(dataBroker, epPolicyTemplateCachedDao);
+        //TODO: add full Daos for epForwardingTemplate and sxpMasterDB
+
+        sxpDatabaseListener = new MasterDatabaseBindingListenerImpl(dataBroker, sxpMapperReactor,
+                masterDBBindingCachedDao, epPolicyTemplateDao, null);
+        epPolicyTemplateListener = new EPPolicyTemplateListenerImpl(dataBroker, sxpMapperReactor, epPolicyTemplateCachedDao);
+        epForwardingTemplateListener = new EPForwardingTemplateListenerImpl(dataBroker, sxpMapperReactor, epForwardingTemplateCachedDao);
     }
 
     // register listeners to ip/sgt and EP-templates (by SGT, by subnet) -> 3x

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
index 8124bf5a9d1451b8226bfed8e8bdb5dbf39b2032..069dc0b75d3227ae0388079b12244e8264edf3ed 100644 (file)
--- a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/SxpMapperReactorImpl.java
@@ -8,16 +8,16 @@
 
 package org.opendaylight.groupbasedpolicy.sxp.mapper.impl;
 
-import org.opendaylight.groupbasedpolicy.sxp.mapper.api.L3EndpointDao;
 import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
 
 /**
  * Purpose: exclusively processes sxp master database changes and EGP templates changes
  */
 public class SxpMapperReactorImpl implements SxpMapperReactor {
-    private final L3EndpointDao l3EndpointDao;
+    private final EndpointService l3EndpointService;
 
-    public SxpMapperReactorImpl(final L3EndpointDao l3EndpointDao) {
-        this.l3EndpointDao = l3EndpointDao;
+    public SxpMapperReactorImpl(final EndpointService l3EndpointService) {
+        this.l3EndpointService = l3EndpointService;
     }
 }

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/DSDaoCachedImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/DSDaoCachedImpl.java
new file mode 100644 (file)
index 0000000..e4aedc8
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/DSDaoCachedImpl.java
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao;
+
+import com.google.common.base.Optional;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Purpose: generic implementation of {@link DSDaoCached}
+ */
+public class DSDaoCachedImpl<K, V extends DataObject> implements DSDaoCached<K, V> {
+
+    private final ConcurrentMap<K, V> cache;
+
+    public DSDaoCachedImpl() {
+        cache = new ConcurrentHashMap<>();
+    }
+
+    @Override
+    public void update(@Nonnull final K key, @Nullable final V value) {
+        if (value != null) {
+            cache.put(key, value);
+        } else {
+            cache.remove(key);
+        }
+    }
+
+    @Override
+    public Optional<V> read(@Nonnull final K key) {
+        return Optional.fromNullable(cache.get(key));
+    }
+
+    @Override
+    public Map<K, V> getBackendMapView() {
+        return Collections.unmodifiableMap(cache);
+    }
+
+    @Override
+    public void invalidateCache() {
+        cache.clear();
+    }
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java
new file mode 100644 (file)
index 0000000..d748d51
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPForwardingTemplateDaoImpl.java
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.List;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoAsync;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.SxpMapper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Purpose: general dao for EndPoint templates
+ */
+public class EPForwardingTemplateDaoImpl implements DSDaoAsync<IpPrefix, EndpointForwardingTemplateBySubnet> {
+
+    private final DataBroker dataBroker;
+    private final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> cachedDao;
+
+    public EPForwardingTemplateDaoImpl(final DataBroker dataBroker,
+                                       final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> cachedDao) {
+        this.dataBroker = dataBroker;
+        this.cachedDao = cachedDao;
+    }
+
+    @Override
+    public ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> read(@Nonnull final IpPrefix key) {
+        final Optional<EndpointForwardingTemplateBySubnet> value = lookup(cachedDao, key);
+        if (value.isPresent()) {
+            return Futures.immediateFuture(value);
+        } else {
+            final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+            final CheckedFuture<Optional<SxpMapper>, ReadFailedException> read =
+                    rTx.read(LogicalDatastoreType.CONFIGURATION, buildReadPath(key));
+
+            Futures.addCallback(read, SxpListenerUtil.createTxCloseCallback(rTx));
+
+            return Futures.transform(read, new Function<Optional<SxpMapper>, Optional<EndpointForwardingTemplateBySubnet>>() {
+                @Nullable
+                @Override
+                public Optional<EndpointForwardingTemplateBySubnet> apply(@Nullable final Optional<SxpMapper> input) {
+                    if (input.isPresent()) {
+                        // clean cache
+                        cachedDao.invalidateCache();
+                        // iterate through all template entries and update cachedDao at once
+                        final List<EndpointForwardingTemplateBySubnet> templateLot = input.get().getEndpointForwardingTemplateBySubnet();
+                        if (templateLot != null) {
+                            for (EndpointForwardingTemplateBySubnet template : templateLot) {
+                                cachedDao.update(template.getIpPrefix(), template);
+                            }
+                        }
+
+                        //TODO: do fastpath search (by key)
+                        //TODO: do slowpath fallback search (by ip-prefix and longest match)
+                        return null;
+                    } else {
+                        return Optional.absent();
+                    }
+                }
+            });
+        }
+    }
+
+    protected InstanceIdentifier<SxpMapper> buildReadPath(final IpPrefix key) {
+        return EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH;
+    }
+
+    private Optional<EndpointForwardingTemplateBySubnet> lookup(final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> cachedDao, final IpPrefix key) {
+        return cachedDao.read(key);
+    }
+
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java
new file mode 100644 (file)
index 0000000..aade564
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/dao/EPPolicyTemplateDaoImpl.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.dao;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoAsync;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgtKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Purpose: general dao for EndPoint templates
+ */
+public class EPPolicyTemplateDaoImpl implements DSDaoAsync<Sgt, EndpointPolicyTemplateBySgt> {
+
+    private final DataBroker dataBroker;
+    private final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> cachedDao;
+
+    public EPPolicyTemplateDaoImpl(final DataBroker dataBroker,
+                                   final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> cachedDao) {
+        this.dataBroker = dataBroker;
+        this.cachedDao = cachedDao;
+    }
+
+    @Override
+    public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> read(@Nonnull final Sgt key) {
+        final Optional<EndpointPolicyTemplateBySgt> cachedEndpointPolicyTemplateBySgtalue = lookup(cachedDao, key);
+        if (cachedEndpointPolicyTemplateBySgtalue.isPresent()) {
+            return Futures.immediateFuture(cachedEndpointPolicyTemplateBySgtalue);
+        } else {
+            final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+            final CheckedFuture<Optional<EndpointPolicyTemplateBySgt>, ReadFailedException> read =
+                    rTx.read(LogicalDatastoreType.CONFIGURATION, buildReadPath(key));
+
+            Futures.addCallback(read, SxpListenerUtil.createTxCloseCallback(rTx));
+
+            return Futures.transform(read, new Function<Optional<EndpointPolicyTemplateBySgt>, Optional<EndpointPolicyTemplateBySgt>>() {
+                @Nullable
+                @Override
+                public Optional<EndpointPolicyTemplateBySgt> apply(@Nullable final Optional<EndpointPolicyTemplateBySgt> input) {
+                    if (input.isPresent()) {
+                        cachedDao.update(key, input.get());
+                    }
+                    return input;
+                }
+            });
+        }
+    }
+
+    protected InstanceIdentifier<EndpointPolicyTemplateBySgt> buildReadPath(final Sgt key) {
+        return EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH
+                .child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(key));
+    }
+
+    private Optional<EndpointPolicyTemplateBySgt> lookup(final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> cachedDao, final Sgt key) {
+        return cachedDao.read(key);
+    }
+
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java
new file mode 100644 (file)
index 0000000..63f133d
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPForwardingTemplateListenerImpl.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Purpose: listens to EP forwarding template and propagates change events for further processing
+ */
+public class EPForwardingTemplateListenerImpl implements EPTemplateListener<EndpointForwardingTemplateBySubnet> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EPForwardingTemplateListenerImpl.class);
+    private final SxpMapperReactor sxpMapperReactor;
+    private final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> templateCachedDao;
+    private final ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
+    private final InstanceIdentifier<EndpointForwardingTemplateBySubnet> templatePath;
+
+    public EPForwardingTemplateListenerImpl(final DataBroker dataBroker,
+                                            final SxpMapperReactor sxpMapperReactor,
+                                            final DSDaoCached<IpPrefix, EndpointForwardingTemplateBySubnet> templateCachedDao) {
+        this.sxpMapperReactor = sxpMapperReactor;
+        this.templateCachedDao = templateCachedDao;
+        templatePath = EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH.child(EndpointForwardingTemplateBySubnet.class);
+
+        final DataTreeIdentifier<EndpointForwardingTemplateBySubnet> dataTreeIdentifier = new DataTreeIdentifier<>(
+                LogicalDatastoreType.CONFIGURATION, templatePath);
+        listenerRegistration = dataBroker.registerDataTreeChangeListener(dataTreeIdentifier, this);
+        LOG.debug("started listening to {}", templatePath);
+    }
+
+    @Override
+    public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<EndpointForwardingTemplateBySubnet>> collection) {
+        for (DataTreeModification<EndpointForwardingTemplateBySubnet> change : collection) {
+            LOG.trace("received modification: {} -> {}", change.getRootPath(), change.getRootNode().getModificationType());
+            // update cached dao
+            final InstanceIdentifier<EndpointForwardingTemplateBySubnet> changePath = change.getRootPath().getRootIdentifier();
+            final IpPrefix changeKey = changePath.firstKeyOf(EndpointForwardingTemplateBySubnet.class).getIpPrefix();
+            SxpListenerUtil.updateCachedDao(templateCachedDao, changeKey, change);
+
+            // TODO: sxpMapperReactor.process(template)
+        }
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.debug("closing listener registration to {}", templatePath);
+        listenerRegistration.close();
+    }
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java
new file mode 100644 (file)
index 0000000..e7e4141
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/EPPolicyTemplateListenerImpl.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen;
+
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.EPTemplateListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Purpose: listens to EP policy template and propagates change events for further processing
+ */
+public class EPPolicyTemplateListenerImpl implements EPTemplateListener<EndpointPolicyTemplateBySgt> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateListenerImpl.class);
+    private final ListenerRegistration<? extends EPTemplateListener> listenerRegistration;
+    private final InstanceIdentifier<EndpointPolicyTemplateBySgt> templatePath;
+    private final SxpMapperReactor sxpMapperReactor;
+    private final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> templateCachedDao;
+
+    public EPPolicyTemplateListenerImpl(final DataBroker dataBroker,
+                                        final SxpMapperReactor sxpMapperReactor,
+                                        final DSDaoCached<Sgt, EndpointPolicyTemplateBySgt> templateCachedDao) {
+        this.sxpMapperReactor = sxpMapperReactor;
+        this.templateCachedDao = templateCachedDao;
+        templatePath = EPTemplateListener.SXP_MAPPER_TEMPLATE_PARENT_PATH.child(EndpointPolicyTemplateBySgt.class);
+
+        final DataTreeIdentifier<EndpointPolicyTemplateBySgt> dataTreeIdentifier = new DataTreeIdentifier<>(
+                LogicalDatastoreType.CONFIGURATION, templatePath);
+        listenerRegistration = dataBroker.registerDataTreeChangeListener(dataTreeIdentifier, this);
+        LOG.debug("started listening to {}", templatePath);
+    }
+
+    @Override
+    public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<EndpointPolicyTemplateBySgt>> collection) {
+        for (DataTreeModification<EndpointPolicyTemplateBySgt> change : collection) {
+            LOG.trace("received modification: {} -> {}", change.getRootPath(), change.getRootNode().getModificationType());
+            // update cached dao
+            final InstanceIdentifier<EndpointPolicyTemplateBySgt> changePath = change.getRootPath().getRootIdentifier();
+            final Sgt changeKey = changePath.firstKeyOf(EndpointPolicyTemplateBySgt.class).getSgt();
+            SxpListenerUtil.updateCachedDao(templateCachedDao, changeKey, change);
+
+            // TODO: sxpMapperReactor.process(template)
+        }
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.debug("closing listener registration to {}", templatePath);
+        listenerRegistration.close();
+    }
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java
new file mode 100644 (file)
index 0000000..abb8cf9
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/listen/MasterDatabaseBindingListenerImpl.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.listen;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collection;
+import javax.annotation.Nonnull;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoAsync;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.MasterDatabaseBindingListener;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.SxpMapperReactor;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util.SxpListenerUtil;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointForwardingTemplateBySubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.mapper.model.rev160302.sxp.mapper.EndpointPolicyTemplateBySgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.master.database.fields.MasterDatabaseBinding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.SxpNodeIdentity;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.node.rev160308.sxp.databases.fields.MasterDatabase;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * listens to sxp master database and propagates change events for further processing
+ */
+public class MasterDatabaseBindingListenerImpl implements MasterDatabaseBindingListener {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MasterDatabaseBindingListenerImpl.class);
+
+    private final SxpMapperReactor sxpMapperReactor;
+    private final DSDaoCached<Sgt, MasterDatabaseBinding> masterDBBindingDaoCached;
+    private final DSDaoAsync<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao;
+    private final DSDaoAsync<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao;
+
+    private final ListenerRegistration<? extends DataTreeChangeListener> listenerRegistration;
+    private final InstanceIdentifier<MasterDatabaseBinding> sxpDbPath;
+
+    public MasterDatabaseBindingListenerImpl(final DataBroker dataBroker,
+                                             final SxpMapperReactor sxpMapperReactor,
+                                             final DSDaoCached<Sgt, MasterDatabaseBinding> masterDBBindingDaoCached,
+                                             final DSDaoAsync<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateDao,
+                                             final DSDaoAsync<IpPrefix, EndpointForwardingTemplateBySubnet> epForwardingTemplateDao) {
+        this.sxpMapperReactor = Preconditions.checkNotNull(sxpMapperReactor);
+        this.masterDBBindingDaoCached = Preconditions.checkNotNull(masterDBBindingDaoCached);
+        this.epPolicyTemplateDao = Preconditions.checkNotNull(epPolicyTemplateDao);
+        this.epForwardingTemplateDao = Preconditions.checkNotNull(epForwardingTemplateDao);
+        sxpDbPath = MasterDatabaseBindingListener.SXP_TOPOLOGY_PATH
+                .child(Node.class)
+                .augmentation(SxpNodeIdentity.class)
+                .child(MasterDatabase.class)
+                .child(MasterDatabaseBinding.class);
+
+        final DataTreeIdentifier<MasterDatabaseBinding> dataTreeIdentifier = new DataTreeIdentifier<>(
+                LogicalDatastoreType.OPERATIONAL, sxpDbPath);
+        listenerRegistration = dataBroker.registerDataTreeChangeListener(dataTreeIdentifier, this);
+        LOG.debug("started listening to {}", sxpDbPath);
+    }
+
+    @Override
+    public void onDataTreeChanged(@Nonnull final Collection<DataTreeModification<MasterDatabaseBinding>> collection) {
+        for (DataTreeModification<MasterDatabaseBinding> change : collection) {
+            LOG.trace("received modification: {} -> {}", change.getRootPath(), change.getRootNode().getModificationType());
+            // update cached dao
+            final MasterDatabaseBinding sxpMasterDBItem = change.getRootNode().getDataAfter();
+            if (sxpMasterDBItem == null) {
+                //TODO: cover sgt-ip mapping removal
+            } else {
+                final Sgt sgtKey = sxpMasterDBItem.getSecurityGroupTag();
+                final IpPrefix ipPrefixKey = sxpMasterDBItem.getIpPrefix();
+                SxpListenerUtil.updateCachedDao(masterDBBindingDaoCached, sgtKey, change);
+
+                processWithEPPolicyTemplate(sgtKey, sxpMasterDBItem);
+                processWithEPForwardingTemplate(ipPrefixKey, sxpMasterDBItem);
+            }
+        }
+    }
+
+    private void processWithEPForwardingTemplate(final IpPrefix changeKey, final MasterDatabaseBinding sxpMasterDBItem) {
+        final ListenableFuture<Optional<EndpointForwardingTemplateBySubnet>> epForwardingTemplateFuture =
+                epForwardingTemplateDao.read(changeKey);
+
+        final ListenableFuture<RpcResult<Void>> rpcResult = Futures.transform(epForwardingTemplateFuture, new AsyncFunction<Optional<EndpointForwardingTemplateBySubnet>, RpcResult<Void>>() {
+            @Override
+            public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointForwardingTemplateBySubnet> input) throws Exception {
+                if (input == null || !input.isPresent()) {
+                    LOG.debug("no epForwardingTemplate available for ipPrefix: {}", changeKey);
+                    throw new IllegalArgumentException("no epForwardingTemplate available");
+                } else {
+                    // TODO: invoke reactor
+                    return null;
+                }
+            }
+        });
+    }
+
+    private void processWithEPPolicyTemplate(final Sgt changeKey, final MasterDatabaseBinding sxpMasterDBItem) {
+        final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> epPolicyTemplateFuture =
+                epPolicyTemplateDao.read(changeKey);
+
+        final ListenableFuture<RpcResult<Void>> rpcResult = Futures.transform(epPolicyTemplateFuture, new AsyncFunction<Optional<EndpointPolicyTemplateBySgt>, RpcResult<Void>>() {
+            @Override
+            public ListenableFuture<RpcResult<Void>> apply(final Optional<EndpointPolicyTemplateBySgt> input) throws Exception {
+                if (input == null || !input.isPresent()) {
+                    LOG.debug("no epPolicyTemplate available for sgt: {}", changeKey);
+                    throw new IllegalArgumentException("no epPolicyTemplate available");
+                } else {
+                    LOG.trace("processing sxpMasterDB event and epPolicyTemplate for sgt: {}", changeKey);
+                    // TODO: invoke reactor
+                    return null;
+                }
+            }
+        });
+
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.debug("closing listener registration to {}", sxpDbPath);
+        listenerRegistration.close();
+    }
+}

diff --git a/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/util/SxpListenerUtil.java b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/util/SxpListenerUtil.java
new file mode 100644 (file)
index 0000000..83ca3ff
--- /dev/null
+++ b/sxp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/sxp/mapper/impl/util/SxpListenerUtil.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.sxp.mapper.impl.util;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.groupbasedpolicy.sxp.mapper.api.DSDaoCached;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+
+/**
+ * Purpose: provide general logic used by listeners
+ */
+public class SxpListenerUtil {
+    public static <K, V extends DataObject> void updateCachedDao(final DSDaoCached<K, V> valueCachedDao,
+                                                                 final K key,
+                                                                 final DataTreeModification<V> change) {
+        final V value = change.getRootNode().getDataAfter();
+        valueCachedDao.update(key, value);
+    }
+
+    public static FutureCallback<Optional<?>> createTxCloseCallback(final ReadOnlyTransaction rTx) {
+        return new FutureCallback<Optional<?>>() {
+            @Override
+            public void onSuccess(@Nullable final Optional<?> result) {
+                rTx.close();
+            }
+
+            @Override
+            public void onFailure(final Throwable t) {
+                rTx.close();
+            }
+        };
+    }
+}