Bug 6396: Integrate groupbasedpolicy-base with clustering singleton service

Change-Id: Iac131e3166fcf672d82e1a3e95201a2fc4fe23e5
Signed-off-by: Vladimir Lavor <vlavor@cisco.com>

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryInstance.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryInstance.java
index 272ce851adef64316efe377b257aa1942b745e00..6034b415687e376f50da1567e22f3198f10376ae 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryInstance.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryInstance.java
@@ -9,7 +9,9 @@
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 
 import java.util.concurrent.Future;
-
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
 import org.opendaylight.groupbasedpolicy.api.EndpointAugmentorRegistry;
@@ -18,29 +20,35 @@ import org.opendaylight.groupbasedpolicy.base_endpoint.BaseEndpointServiceImpl;
 import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl;
 import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl;
 import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class DomainSpecificRegistryInstance implements DomainSpecificRegistry, BaseEndpointService, AutoCloseable {
+public class DomainSpecificRegistryInstance implements ClusterSingletonService, DomainSpecificRegistry, BaseEndpointService, AutoCloseable {
 
-    private final EndpointAugmentorRegistryImpl endpointAugmentorRegistryImpl;
-    private final NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistryImpl;
-    private final BaseEndpointServiceImpl baseEndpointServiceImpl;
-    private final RendererManager rendererManager;
+    private static final Logger LOG = LoggerFactory.getLogger(DomainSpecificRegistryInstance.class);
 
-    public DomainSpecificRegistryInstance(DataBroker dataProvider) {
-        endpointAugmentorRegistryImpl = new EndpointAugmentorRegistryImpl();
-        netDomainAugmentorRegistryImpl = new NetworkDomainAugmentorRegistryImpl();
-        baseEndpointServiceImpl = new BaseEndpointServiceImpl(dataProvider, endpointAugmentorRegistryImpl);
-        rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistryImpl, endpointAugmentorRegistryImpl);
-    }
+    private static final ServiceGroupIdentifier IDENTIFIER =
+            ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
+    private final DataBroker dataBroker;
+    private ClusterSingletonServiceProvider clusterSingletonService;
+    private ClusterSingletonServiceRegistration singletonServiceRegistration;
+    private EndpointAugmentorRegistryImpl endpointAugmentorRegistryImpl;
+    private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistryImpl;
+    private BaseEndpointServiceImpl baseEndpointServiceImpl;
+    private RendererManager rendererManager;
 
-    @Override
-    public void close() throws Exception {
-        baseEndpointServiceImpl.close();
-        rendererManager.close();
+    public DomainSpecificRegistryInstance(final DataBroker dataBroker,
+                                          final ClusterSingletonServiceProvider clusterSingletonService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
     }
 
     @Override
@@ -63,4 +71,43 @@ public class DomainSpecificRegistryInstance implements DomainSpecificRegistry, B
         return baseEndpointServiceImpl.registerEndpoint(input);
     }
 
+    public void initialize() {
+        LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+        singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
+    }
+
+    @Override
+    public void instantiateServiceInstance() {
+        LOG.info("Instantiating {}", this.getClass().getSimpleName());
+        endpointAugmentorRegistryImpl = new EndpointAugmentorRegistryImpl();
+        netDomainAugmentorRegistryImpl = new NetworkDomainAugmentorRegistryImpl();
+        baseEndpointServiceImpl = new BaseEndpointServiceImpl(dataBroker, endpointAugmentorRegistryImpl);
+        rendererManager = new RendererManager(dataBroker, netDomainAugmentorRegistryImpl, endpointAugmentorRegistryImpl);
+    }
+
+    @Override
+    public ListenableFuture<Void> closeServiceInstance() {
+        LOG.info("Instance {} closed", this.getClass().getSimpleName());
+        baseEndpointServiceImpl.close();
+        rendererManager.close();
+        return Futures.immediateFuture(null);
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+        if (singletonServiceRegistration != null) {
+            try {
+                singletonServiceRegistration.close();
+            } catch (Exception e) {
+                LOG.warn("{} closed unexpectedly", this.getClass().getSimpleName(), e);
+            }
+            singletonServiceRegistration = null;
+        }
+    }
+
+    @Override
+    public ServiceGroupIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java
index e2aca3e64b58d6d4494a91757515945e7bf51d1e..0ebc418c5f18caf9a66d472ad7a705b65a2af52b 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java
@@ -16,6 +16,7 @@ import org.osgi.framework.BundleContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+@Deprecated
 public class DomainSpecificRegistryModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractDomainSpecificRegistryModule {
 
     private static final Logger LOG = LoggerFactory.getLogger(DomainSpecificRegistryModule.class);

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java
index c030d7d6600340e82e8eb1c706555bbcb025bb7b..b69dc308dbf3027e87c27676e659bd5b0a4eeaa8 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java
@@ -11,6 +11,7 @@ package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 import org.opendaylight.controller.config.api.DependencyResolver;
 import org.osgi.framework.BundleContext;
 
+@Deprecated
 public class DomainSpecificRegistryModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractDomainSpecificRegistryModuleFactory {
 
     @Override

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplInstance.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplInstance.java
index 8cda5897ca7cd7cc434e131170ee9f09e99889cb..3a5374c9fa52ebc9ccbd97f434d21c855bfadd58 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplInstance.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplInstance.java
@@ -9,11 +9,17 @@
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 
 import java.util.concurrent.Future;
-
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentation;
 import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
 import org.opendaylight.groupbasedpolicy.endpoint.EndpointRpcRegistry;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInput;
@@ -21,18 +27,24 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.UnregisterEndpointInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.UnsetEndpointGroupConditionsInput;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class EpRendererAugmentationRegistryImplInstance implements EpRendererAugmentationRegistry, EndpointService, AutoCloseable{
+public class EpRendererAugmentationRegistryImplInstance implements ClusterSingletonService, EpRendererAugmentationRegistry, EndpointService, AutoCloseable {
 
+    private static final Logger LOG = LoggerFactory.getLogger(EpRendererAugmentationRegistryImplInstance.class);
 
-    private final EndpointRpcRegistry endpointRpcRegistry;
+    private static final ServiceGroupIdentifier IDENTIFIER =
+            ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
+    private final DataBroker dataBroker;
+    private ClusterSingletonServiceProvider clusterSingletonService;
+    private ClusterSingletonServiceRegistration singletonServiceRegistration;
+    private EndpointRpcRegistry endpointRpcRegistry;
 
-    public EpRendererAugmentationRegistryImplInstance(DataBroker dataProvider) {
-        endpointRpcRegistry = new EndpointRpcRegistry(dataProvider);
-    }
-    @Override
-    public void close() throws Exception {
-        endpointRpcRegistry.close();
+    public EpRendererAugmentationRegistryImplInstance(final DataBroker dataBroker,
+                                                      final ClusterSingletonServiceProvider clusterSingletonService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
     }
 
     @Override
@@ -44,26 +56,65 @@ public class EpRendererAugmentationRegistryImplInstance implements EpRendererAug
     public void unregister(EpRendererAugmentation epRendererAugmentation) {
         endpointRpcRegistry.unregister(epRendererAugmentation);
     }
+
     @Override
     public Future<RpcResult<Void>> unsetEndpointGroupConditions(UnsetEndpointGroupConditionsInput input) {
         return endpointRpcRegistry.unsetEndpointGroupConditions(input);
     }
+
     @Override
     public Future<RpcResult<Void>> registerEndpoint(RegisterEndpointInput input) {
         return endpointRpcRegistry.registerEndpoint(input);
     }
+
     @Override
     public Future<RpcResult<Void>> setEndpointGroupConditions(SetEndpointGroupConditionsInput input) {
         return endpointRpcRegistry.setEndpointGroupConditions(input);
     }
+
     @Override
     public Future<RpcResult<Void>> registerL3PrefixEndpoint(RegisterL3PrefixEndpointInput input) {
         return endpointRpcRegistry.registerL3PrefixEndpoint(input);
     }
+
     @Override
     public Future<RpcResult<Void>> unregisterEndpoint(UnregisterEndpointInput input) {
         return endpointRpcRegistry.unregisterEndpoint(input);
     }
 
+    public void initialize() {
+        LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+        singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
+    }
+
+    @Override
+    public void instantiateServiceInstance() {
+        LOG.info("Instantiating {}", this.getClass().getSimpleName());
+        endpointRpcRegistry = new EndpointRpcRegistry(dataBroker);
+    }
+
+    @Override
+    public ListenableFuture<Void> closeServiceInstance() {
+        LOG.info("Instance {} closed", this.getClass().getSimpleName());
+        endpointRpcRegistry.close();
+        return Futures.immediateFuture(null);
+    }
 
+    @Override
+    public void close() {
+        LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+        if (singletonServiceRegistration != null) {
+            try {
+                singletonServiceRegistration.close();
+            } catch (Exception e) {
+                LOG.warn("{} closed unexpectedly", this.getClass().getSimpleName(), e);
+            }
+            singletonServiceRegistration = null;
+        }
+    }
+
+    @Override
+    public ServiceGroupIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModule.java
index 4aef5cea2184f3d121b8c86109472cd42bbaae0b..004537d352c9e4d82ed9869eb42bc8c319a6af88 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModule.java
@@ -15,6 +15,7 @@ import org.osgi.framework.BundleContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+@Deprecated
 public class EpRendererAugmentationRegistryImplModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractEpRendererAugmentationRegistryImplModule {
 
     private static final Logger LOG = LoggerFactory.getLogger(EpRendererAugmentationRegistryImplModule.class);

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModuleFactory.java
index f0efe0a007e6f54d06f76f4e4a9c3f29a9bb5436..3bad7f5586b5f86cd51d56f4fe0fc9f944caa98d 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModuleFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/EpRendererAugmentationRegistryImplModuleFactory.java
@@ -20,6 +20,7 @@ package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 import org.opendaylight.controller.config.api.DependencyResolver;
 import org.osgi.framework.BundleContext;
 
+@Deprecated
 public class EpRendererAugmentationRegistryImplModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractEpRendererAugmentationRegistryImplModuleFactory {
 
     @Override

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyInstance.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyInstance.java
index 1b2e1ef6a14f76ed0f626f064688dc69fd81f40a..c7270a7d1214b3bd0cc4a9581e291a2e00365d5b 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyInstance.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyInstance.java
@@ -8,39 +8,89 @@
 
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
 import org.opendaylight.groupbasedpolicy.location.resolver.LocationResolver;
 import org.opendaylight.groupbasedpolicy.resolver.ForwardingResolver;
 import org.opendaylight.groupbasedpolicy.sf.SubjectFeatureDefinitionProvider;
 import org.opendaylight.groupbasedpolicy.sf.SupportedActionDefinitionListener;
 import org.opendaylight.groupbasedpolicy.sf.SupportedClassifierDefinitionListener;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class GroupbasedpolicyInstance implements AutoCloseable {
-
-    private final SubjectFeatureDefinitionProvider sfdp;
-    private final SupportedClassifierDefinitionListener supportedClassifierDefinitionListener;
-    private final SupportedActionDefinitionListener supportedActionDefinitionListener;
-    private final LocationResolver locationResolver;
-    private final ForwardingResolver forwardingResolver;
-
-    public GroupbasedpolicyInstance(DataBroker dataProvider, PolicyValidatorRegistry validatorRegistry)
-            throws TransactionCommitFailedException {
-        sfdp = new SubjectFeatureDefinitionProvider(dataProvider);
-        supportedClassifierDefinitionListener =
-                new SupportedClassifierDefinitionListener(dataProvider, validatorRegistry);
-        supportedActionDefinitionListener = new SupportedActionDefinitionListener(dataProvider);
-        locationResolver = new LocationResolver(dataProvider);
-        forwardingResolver = new ForwardingResolver(dataProvider);
+public class GroupbasedpolicyInstance implements ClusterSingletonService, AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(GroupbasedpolicyInstance.class);
+
+    public static final String GBP_SERVICE_GROUP_IDENTIFIER = "gbp-service-group-identifier";
+    private static final ServiceGroupIdentifier IDENTIFIER = ServiceGroupIdentifier.create(GBP_SERVICE_GROUP_IDENTIFIER);
+    private final DataBroker dataBroker;
+    private final PolicyValidatorRegistry policyValidatorRegistry;
+    private ClusterSingletonServiceProvider clusterSingletonService;
+    private ClusterSingletonServiceRegistration singletonServiceRegistration;
+    private SubjectFeatureDefinitionProvider subjectFeatureDefinitionProvider;
+    private SupportedClassifierDefinitionListener supportedClassifierDefinitionListener;
+    private SupportedActionDefinitionListener supportedActionDefinitionListener;
+    private LocationResolver locationResolver;
+    private ForwardingResolver forwardingResolver;
+
+    public GroupbasedpolicyInstance(final DataBroker dataBroker,
+                                    final PolicyValidatorRegistry validatorRegistry,
+                                    final ClusterSingletonServiceProvider clusterSingletonService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.policyValidatorRegistry = Preconditions.checkNotNull(validatorRegistry);
+        this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
+    }
+
+    public void initialize() {
+        LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+        singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
     }
 
     @Override
-    public void close() throws Exception {
-        sfdp.close();
+    public void instantiateServiceInstance() {
+        LOG.info("Instantiating {}", this.getClass().getSimpleName());
+        subjectFeatureDefinitionProvider = new SubjectFeatureDefinitionProvider(dataBroker);
+        supportedClassifierDefinitionListener = new SupportedClassifierDefinitionListener(dataBroker,
+                policyValidatorRegistry);
+        supportedActionDefinitionListener = new SupportedActionDefinitionListener(dataBroker);
+        locationResolver = new LocationResolver(dataBroker);
+        forwardingResolver = new ForwardingResolver(dataBroker);
+    }
+
+    @Override
+    public ListenableFuture<Void> closeServiceInstance() {
+        LOG.info("Instance {} closed", this.getClass().getSimpleName());
+        subjectFeatureDefinitionProvider.close();
         supportedClassifierDefinitionListener.close();
         supportedActionDefinitionListener.close();
         locationResolver.close();
         forwardingResolver.close();
+        return Futures.immediateFuture(null);
+    }
+
+    @Override
+    public ServiceGroupIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+        if (singletonServiceRegistration != null) {
+            try {
+                singletonServiceRegistration.close();
+            } catch (Exception e) {
+                LOG.warn("{} closed unexpectedly", this.getClass().getSimpleName(), e);
+            }
+            singletonServiceRegistration = null;
+        }
     }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java
index 77e2522af82743a7b7a6e3b20c9a751d0decea16..6b5a2ece079c524af528ab410509ae0667bf3e40 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java
@@ -12,6 +12,7 @@ import org.opendaylight.controller.sal.common.util.NoopAutoCloseable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+@Deprecated
 public class GroupbasedpolicyModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractGroupbasedpolicyModule {
 
     private static final Logger LOG = LoggerFactory.getLogger(GroupbasedpolicyModule.class);

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModuleFactory.java
index bdb058d21afc74b554e5dbb380c49f53052a8a68..2e6fcd29a0bf6137b98bee4c059d9a52751148cf 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModuleFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModuleFactory.java
@@ -16,6 +16,7 @@
 * Do not modify this file unless it is present under src/main directory
 */
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
+@Deprecated
 public class GroupbasedpolicyModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractGroupbasedpolicyModuleFactory {
 
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryInstance.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryInstance.java
index 1a7bc1dc294b219c8d5f3fb4bd600e18ff9c7f3d..c0f3b8fab6f559db9d79a64b4d5c893b4469d08e 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryInstance.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryInstance.java
@@ -8,26 +8,39 @@
 
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
 import org.opendaylight.groupbasedpolicy.api.Validator;
 import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class PolicyValidatorRegistryInstance implements PolicyValidatorRegistry, AutoCloseable {
+public class PolicyValidatorRegistryInstance implements ClusterSingletonService, PolicyValidatorRegistry, AutoCloseable {
 
-    private final PolicyResolver policyResolver;
+    private static final Logger LOG = LoggerFactory.getLogger(PolicyValidatorRegistryInstance.class);
 
-    public PolicyValidatorRegistryInstance (DataBroker dataBroker) {
-        this.policyResolver = new PolicyResolver(dataBroker);
-    }
+    private static final ServiceGroupIdentifier IDENTIFIER =
+            ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
+    private final DataBroker dataBroker;
+    private ClusterSingletonServiceProvider clusterSingletonService;
+    private ClusterSingletonServiceRegistration singletonServiceRegistration;
+    private PolicyResolver policyResolver;
 
-    @Override
-    public void close() throws Exception {
-        policyResolver.close();
+    public PolicyValidatorRegistryInstance(final DataBroker dataBroker,
+                                           final ClusterSingletonServiceProvider clusterSingletonService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
     }
 
     @Override
@@ -49,4 +62,40 @@ public class PolicyValidatorRegistryInstance implements PolicyValidatorRegistry,
     public void unregister(ClassifierDefinitionId classifierDefinitionId, Validator<ClassifierInstance> validator) {
         policyResolver.unregister(classifierDefinitionId, validator);
     }
+
+    @Override
+    public void instantiateServiceInstance() {
+        LOG.info("Instantiating {}", this.getClass().getSimpleName());
+        this.policyResolver = new PolicyResolver(dataBroker);
+    }
+
+    public void initialize() {
+        LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+        singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
+    }
+
+    @Override
+    public ListenableFuture<Void> closeServiceInstance() {
+        LOG.info("Instance {} closed", this.getClass().getSimpleName());
+        policyResolver.close();
+        return Futures.immediateFuture(null);
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+        if (singletonServiceRegistration != null) {
+            try {
+                singletonServiceRegistration.close();
+            } catch (Exception e) {
+                LOG.warn("{} closed unexpectedly", this.getClass().getSimpleName(), e);
+            }
+            singletonServiceRegistration = null;
+        }
+    }
+
+    @Override
+    public ServiceGroupIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModule.java
index 8f72579280853c96d1f16c06317688366f23b74b..a0951f295aed5457cf1b041a2a369de1954c1063 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModule.java
@@ -19,6 +19,7 @@ import org.osgi.framework.BundleContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+@Deprecated
 public class PolicyValidatorRegistryModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractPolicyValidatorRegistryModule {
 
     private static final Logger LOG = LoggerFactory.getLogger(PolicyValidatorRegistryModule.class);

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModuleFactory.java
index 5a1e25ec2a3fb19144a2b96c57487703dc67504d..1a4dd488c400c44f302dee0d34a3c6be1703ebe4 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModuleFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/PolicyValidatorRegistryModuleFactory.java
@@ -20,6 +20,7 @@ package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 import org.opendaylight.controller.config.api.DependencyResolver;
 import org.osgi.framework.BundleContext;
 
+@Deprecated
 public class PolicyValidatorRegistryModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractPolicyValidatorRegistryModuleFactory {
 
     @Override

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplInstance.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplInstance.java
index bf9ec72b3edf2fce6d86c7e2c21fa8d00de6f67a..7142c3ead0c9191e6ce20d19832feb2e9367e566 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplInstance.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplInstance.java
@@ -8,22 +8,35 @@
 
 package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.groupbasedpolicy.api.StatisticsManager;
 import org.opendaylight.groupbasedpolicy.statistics.StatisticsManagerImpl;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.rev151215.statistic.records.StatRecords;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public class StatisticsManagerImplInstance implements StatisticsManager, AutoCloseable {
+public class StatisticsManagerImplInstance implements ClusterSingletonService, StatisticsManager, AutoCloseable {
 
-    private final StatisticsManagerImpl statsManager;
+    private static final Logger LOG = LoggerFactory.getLogger(StatisticsManagerImplInstance.class);
 
-    public StatisticsManagerImplInstance (DataBroker dataBroker) {
-        statsManager = new StatisticsManagerImpl(dataBroker);
-    }
+    private static final ServiceGroupIdentifier IDENTIFIER =
+            ServiceGroupIdentifier.create(GroupbasedpolicyInstance.GBP_SERVICE_GROUP_IDENTIFIER);
+    private final DataBroker dataBroker;
+    private ClusterSingletonServiceProvider clusterSingletonService;
+    private ClusterSingletonServiceRegistration singletonServiceRegistration;
+    private StatisticsManagerImpl statsManager;
 
-    @Override
-    public void close() throws Exception {
-        statsManager.close();
+    public StatisticsManagerImplInstance(final DataBroker dataBroker,
+                                         final ClusterSingletonServiceProvider clusterSingletonService) {
+        this.dataBroker = Preconditions.checkNotNull(dataBroker);
+        this.clusterSingletonService = Preconditions.checkNotNull(clusterSingletonService);
     }
 
     @Override
@@ -36,4 +49,39 @@ public class StatisticsManagerImplInstance implements StatisticsManager, AutoClo
         return statsManager.readStats();
     }
 
+    public void initialize() {
+        LOG.info("Clustering session initiated for {}", this.getClass().getSimpleName());
+        singletonServiceRegistration = clusterSingletonService.registerClusterSingletonService(this);
+    }
+
+    @Override
+    public void instantiateServiceInstance() {
+        LOG.info("Instantiating {}", this.getClass().getSimpleName());
+        statsManager = new StatisticsManagerImpl(dataBroker);
+    }
+
+    @Override
+    public ListenableFuture<Void> closeServiceInstance() {
+        LOG.info("Instance {} closed", this.getClass().getSimpleName());
+        statsManager.close();
+        return Futures.immediateFuture(null);
+    }
+
+    @Override
+    public void close() throws Exception {
+        LOG.info("Clustering provider closed for {}", this.getClass().getSimpleName());
+        if (singletonServiceRegistration != null) {
+            try {
+                singletonServiceRegistration.close();
+            } catch (Exception e) {
+                LOG.warn("{} closed unexpectedly", this.getClass().getSimpleName(), e);
+            }
+            singletonServiceRegistration = null;
+        }
+    }
+
+    @Override
+    public ServiceGroupIdentifier getIdentifier() {
+        return IDENTIFIER;
+    }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModule.java
index fb8bd263bf425f1184c0b82b25aed708f975c3df..90ede36bfd545ce5f9f8a9fc45170d2039ac7548 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModule.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModule.java
@@ -22,6 +22,7 @@ import org.opendaylight.groupbasedpolicy.api.StatisticsManager;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.rev151215.statistic.records.StatRecords;
 import org.osgi.framework.BundleContext;
 
+@Deprecated
 public class StatisticsManagerImplModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractStatisticsManagerImplModule {
 
     private BundleContext bundleContext;

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModuleFactory.java
index 585636f2d13a7ae0680243a9bf001c42c2647588..fa3a8f0eadebc8f06d3a2481f0fe97849f28d7f5 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModuleFactory.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/StatisticsManagerImplModuleFactory.java
@@ -20,6 +20,7 @@ package org.opendaylight.controller.config.yang.config.groupbasedpolicy;
 import org.opendaylight.controller.config.api.DependencyResolver;
 import org.osgi.framework.BundleContext;
 
+@Deprecated
 public class StatisticsManagerImplModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractStatisticsManagerImplModuleFactory {
 
     @Override

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/location/resolver/LocationResolver.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/location/resolver/LocationResolver.java
index 32addda168cc937f7be85c97956e07f453dfb007..ecb2656f0b5e5ba30990a52ecee51e725d3cefaa 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/location/resolver/LocationResolver.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/location/resolver/LocationResolver.java
@@ -219,7 +219,7 @@ public class LocationResolver implements DataTreeChangeListener<LocationProvider
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() {
         listenerRegistation.close();
     }
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java
index 0b278565ec342fefb73f81403095abc12647b9ed..c4590ee04d80f9330a8363d31411c1f6efb3efb5 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java
@@ -10,6 +10,14 @@ package org.opendaylight.groupbasedpolicy.renderer;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
 import com.google.common.base.Optional;
@@ -18,14 +26,6 @@ import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.ImmutableSet;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import javax.annotation.Nullable;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@@ -180,7 +180,7 @@ public class RendererManager implements AutoCloseable {
     }
 
     public RendererManager(DataBroker dataProvider, NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry,
-            EndpointAugmentorRegistryImpl epAugmentorRegistry) {
+                           EndpointAugmentorRegistryImpl epAugmentorRegistry) {
         this.dataProvider = checkNotNull(dataProvider);
         this.netDomainAugmentorRegistry = checkNotNull(netDomainAugmentorRegistry);
         this.epAugmentorRegistry = checkNotNull(epAugmentorRegistry);
@@ -293,8 +293,8 @@ public class RendererManager implements AutoCloseable {
             RendererPolicy rendererPolicy = null;
             if (configsByRendererName.get(rendererName).isPresent()) {
                 rendererPolicy = new RendererPolicyBuilder().setVersion(version)
-                    .setConfiguration(configsByRendererName.get(rendererName).get())
-                    .build();
+                        .setConfiguration(configsByRendererName.get(rendererName).get())
+                        .build();
 
             } else {
                 rendererPolicy = new RendererPolicyBuilder().setVersion(version).build();
@@ -333,7 +333,7 @@ public class RendererManager implements AutoCloseable {
                 rendererConfigBuilderByRendererName.put(rendererName, rendererConfigBuilder);
             }
             for (AddressEndpointKey rendererAdrEpKey : currentState.epLocInfo
-                .getAddressEpsWithAbsoluteNodeLocation(absEpLocation)) {
+                    .getAddressEpsWithAbsoluteNodeLocation(absEpLocation)) {
                 Optional<AddressEndpoint> potentialAddressEp = currentState.epInfo.getEndpoint(rendererAdrEpKey);
                 if (!potentialAddressEp.isPresent()) {
                     LOG.trace("Endpoint does not exist but has location: {}", rendererAdrEpKey);
@@ -382,7 +382,7 @@ public class RendererManager implements AutoCloseable {
 
     @VisibleForTesting
     void resolveRendererConfigForEndpoint(AddressEndpoint rendererAdrEp,
-            RendererConfigurationBuilder rendererPolicyBuilder) {
+                                          RendererConfigurationBuilder rendererPolicyBuilder) {
         Set<EpgKeyDto> rendererEpgs = toEpgKeys(rendererAdrEp.getEndpointGroup(), rendererAdrEp.getTenant());
         RendererEndpointKey rendererEpKey = AddressEndpointUtils.toRendererEpKey(rendererAdrEp.getKey());
         for (EpgKeyDto rendererEpg : rendererEpgs) {
@@ -416,8 +416,8 @@ public class RendererManager implements AutoCloseable {
     }
 
     private void resolveRendererPolicyBetweenEpAndContPeers(RendererEndpointKey rendererEpKey,
-            Set<ContainmentEndpointKey> peerContEps, ResolvedPolicy policy,
-            EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
+                                                            Set<ContainmentEndpointKey> peerContEps, ResolvedPolicy policy,
+                                                            EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
         if (isRendererEpInEig(policy, rendererEpParticipation)) {
             LOG.info("Renderer EP cannot be in EIG therefore it is ignored: {}. \nPolicy: {}", rendererEpKey);
             LOG.debug("Renderer EP participation: {}, Policy: {}", rendererEpParticipation, policy);
@@ -434,7 +434,7 @@ public class RendererManager implements AutoCloseable {
                 PeerExternalContainmentEndpointKey peerExtContEpKey =
                         ContainmentEndpointUtils.toPeerExtContEpKey(peerContEpKey);
                 for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
-                    .getPolicyRuleGroupWithEndpointConstraints()) {
+                        .getPolicyRuleGroupWithEndpointConstraints()) {
                     // TODO filter based on endpoint constraints
                     for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
                         rendererPolicyBuilder.add(rendererEpKey, peerExtContEpKey, ruleGrp.getKey(),
@@ -449,8 +449,8 @@ public class RendererManager implements AutoCloseable {
     }
 
     private void resolveRendererPolicyBetweenEpAndPeers(RendererEndpointKey rendererEpKey,
-            Set<AddressEndpointKey> peerAdrEps, ResolvedPolicy policy,
-            EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
+                                                        Set<AddressEndpointKey> peerAdrEps, ResolvedPolicy policy,
+                                                        EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
         if (isRendererEpInEig(policy, rendererEpParticipation)) {
             LOG.info("Renderer EP cannot be in EIG therefore it is ignored: {}. \nPolicy: {}", rendererEpKey);
             LOG.debug("Renderer EP participation: {}, Policy: {}", rendererEpParticipation, policy);
@@ -468,7 +468,7 @@ public class RendererManager implements AutoCloseable {
                 }
                 PeerExternalEndpointKey peerExtEpKey = AddressEndpointUtils.toPeerExtEpKey(peerAdrEpKey);
                 for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
-                    .getPolicyRuleGroupWithEndpointConstraints()) {
+                        .getPolicyRuleGroupWithEndpointConstraints()) {
                     // TODO filter based on endpoint constraints
                     for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
                         rendererPolicyBuilder.add(rendererEpKey, peerExtEpKey, ruleGrp.getKey(),
@@ -482,7 +482,7 @@ public class RendererManager implements AutoCloseable {
                 }
                 PeerEndpointKey peerEpKey = AddressEndpointUtils.toPeerEpKey(peerAdrEpKey);
                 for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
-                    .getPolicyRuleGroupWithEndpointConstraints()) {
+                        .getPolicyRuleGroupWithEndpointConstraints()) {
                     // TODO filter based on endpoint constraints
                     for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
                         rendererPolicyBuilder.add(rendererEpKey, peerEpKey, ruleGrp.getKey(), rendererEpParticipation);
@@ -535,12 +535,16 @@ public class RendererManager implements AutoCloseable {
     }
 
     @Override
-    public void close() throws Exception {
-        endpointsListener.close();
-        endpointLocationsListener.close();
-        resolvedPoliciesListener.close();
-        forwardingListener.close();
-        renderersListener.close();
+    public void close() {
+        try {
+            endpointsListener.close();
+            endpointLocationsListener.close();
+            resolvedPoliciesListener.close();
+            forwardingListener.close();
+            renderersListener.close();
+        } catch (Exception e) {
+            LOG.warn("Exception while closing", e);
+        }
     }
 
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/resolver/PolicyResolver.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/resolver/PolicyResolver.java
index b275bcd315653258123328490c24258d4c89198e..1d448962d6c8cbd9ee9b4992acd98f3b16befa41 100755 (executable)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/resolver/PolicyResolver.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/resolver/PolicyResolver.java
@@ -101,7 +101,7 @@ public class PolicyResolver implements PolicyValidatorRegistry, AutoCloseable {
     // AutoCloseable
     // *************
     @Override
-    public void close() throws Exception {
+    public void close() {
         if (tenantChangeListener != null) {
             tenantChangeListener.close();
         }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SubjectFeatureDefinitionProvider.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SubjectFeatureDefinitionProvider.java
index 10e480bf87c4cc198da3cf48f040bd347d496dd4..73ee66ee746f5db9b2413ecbcdb0f14cf24d7e26 100755 (executable)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SubjectFeatureDefinitionProvider.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SubjectFeatureDefinitionProvider.java
@@ -8,6 +8,8 @@
 
 package org.opendaylight.groupbasedpolicy.sf;
 
+import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@@ -17,50 +19,47 @@ import org.opendaylight.groupbasedpolicy.api.sf.ChainActionDefinition;
 import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
 import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
 import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * On creation, puts known Subject Feature Definitions to config datastore; deletes them on #close()
  */
 public class SubjectFeatureDefinitionProvider implements AutoCloseable {
 
+    private final static Logger LOG = LoggerFactory.getLogger(SubjectFeatureDefinitionProvider.class);
     private final DataBroker dataProvider;
 
     /**
      * Puts known Subject Feature Definitions to operational datastore
      *
      * @param dataProvider DataBroker
-     * @throws TransactionCommitFailedException
      */
-    public SubjectFeatureDefinitionProvider(DataBroker dataProvider)
-            throws TransactionCommitFailedException {
+    public SubjectFeatureDefinitionProvider(DataBroker dataProvider) {
         this.dataProvider = dataProvider;
         putSubjectFeatureDefinitions();
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() {
         deleteSubjectFeatureDefinitions();
     }
 
-    private void putSubjectFeatureDefinitions() throws TransactionCommitFailedException {
+    private void putSubjectFeatureDefinitions() {
         WriteTransaction wt = this.dataProvider.newWriteOnlyTransaction();
 
-        wt.put(LogicalDatastoreType.CONFIGURATION, EtherTypeClassifierDefinition.IID,
-                EtherTypeClassifierDefinition.DEFINITION);
-        wt.put(LogicalDatastoreType.CONFIGURATION, IpProtoClassifierDefinition.IID,
-                IpProtoClassifierDefinition.DEFINITION);
-        wt.put(LogicalDatastoreType.CONFIGURATION, L4ClassifierDefinition.IID,
-                L4ClassifierDefinition.DEFINITION);
+        wt.put(CONFIGURATION, EtherTypeClassifierDefinition.IID, EtherTypeClassifierDefinition.DEFINITION);
+        wt.put(CONFIGURATION, IpProtoClassifierDefinition.IID, IpProtoClassifierDefinition.DEFINITION);
+        wt.put(CONFIGURATION, L4ClassifierDefinition.IID, L4ClassifierDefinition.DEFINITION);
 
-        wt.put(LogicalDatastoreType.CONFIGURATION, AllowActionDefinition.IID,
-                AllowActionDefinition.DEFINITION);
-        wt.put(LogicalDatastoreType.CONFIGURATION, ChainActionDefinition.IID,
-                ChainActionDefinition.DEFINITION);
+        wt.put(CONFIGURATION, AllowActionDefinition.IID, AllowActionDefinition.DEFINITION);
+        wt.put(CONFIGURATION, ChainActionDefinition.IID, ChainActionDefinition.DEFINITION);
 
-        wt.submit().checkedGet();
+        DataStoreHelper.submitToDs(wt);
     }
 
-    private void deleteSubjectFeatureDefinitions() throws TransactionCommitFailedException {
+    private void deleteSubjectFeatureDefinitions() {
         WriteTransaction wt = this.dataProvider.newWriteOnlyTransaction();
 
         wt.delete(LogicalDatastoreType.CONFIGURATION, EtherTypeClassifierDefinition.IID);
@@ -70,7 +69,10 @@ public class SubjectFeatureDefinitionProvider implements AutoCloseable {
         wt.delete(LogicalDatastoreType.CONFIGURATION, AllowActionDefinition.IID);
         wt.delete(LogicalDatastoreType.CONFIGURATION, ChainActionDefinition.IID);
 
-        wt.submit().checkedGet();
+        try {
+            wt.submit().checkedGet();
+        } catch (TransactionCommitFailedException e) {
+            LOG.warn("Transaction failed", e);
+        }
     }
-
 }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java
index 01d98e6e59849d72ea7d975432164237176da7bc..f04be26dddb3bc8111f1f7da59fac52b0f527fcf 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/sf/SupportedActionDefinitionListener.java
@@ -87,7 +87,7 @@ public class SupportedActionDefinitionListener
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() {
         registration.close();
     }
 

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/statistics/StatisticsManagerImpl.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/statistics/StatisticsManagerImpl.java
index 190ea7ff48390ed60df25ed6f4676b799aa3db40..fd28cc13d5da76c55129c16f0b549a2ad423fba5 100755 (executable)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/statistics/StatisticsManagerImpl.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/statistics/StatisticsManagerImpl.java
@@ -248,7 +248,7 @@ public class StatisticsManagerImpl implements StatisticsManager, AutoCloseable {
     }
 
     @Override
-    public void close() throws Exception {
+    public void close() {
         // TODO Auto-generated method stub
 
     }

diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/DataTreeChangeHandler.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/DataTreeChangeHandler.java
index ae72a3a655bb1609b1e5064037120f27217262a8..d647d4790b0bc04d3b9643e844a49e2d96b4a4e8 100644 (file)
--- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/DataTreeChangeHandler.java
+++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/DataTreeChangeHandler.java
@@ -107,7 +107,7 @@ public abstract class DataTreeChangeHandler<T extends DataObject> implements Dat
     protected abstract void onSubtreeModified(DataObjectModification<T> rootNode, InstanceIdentifier<T> rootIdentifier);
 
     @Override
-    public void close() throws Exception {
+    public void close() {
         registeredListener.close();
     }
 

diff --git a/groupbasedpolicy/src/main/resources/org/opendaylight/blueprint/groupbasedpolicy.xml b/groupbasedpolicy/src/main/resources/org/opendaylight/blueprint/groupbasedpolicy.xml
index 72a3e526a410effa8800e9fe28848e65d9caea38..c18645872991e24e26d9c3374935e9a496ffd041 100644 (file)
--- a/groupbasedpolicy/src/main/resources/org/opendaylight/blueprint/groupbasedpolicy.xml
+++ b/groupbasedpolicy/src/main/resources/org/opendaylight/blueprint/groupbasedpolicy.xml
@@ -4,28 +4,34 @@
            odl:use-default-for-reference-types="true">
 
     <reference id="dataBroker" interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"/>
+    <reference id="clusterSingletonService" interface="org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider"/>
 
     <!-- Modules /-->
     <bean id="groupbasedpolicy" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.GroupbasedpolicyInstance"
-        destroy-method="close">
+        init-method="initialize" destroy-method="close">
         <argument ref="dataBroker"/>
         <argument ref="policyValidatorRegistry"/>
+        <argument ref="clusterSingletonService"/>
     </bean>
     <bean id="domainSpecificRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.DomainSpecificRegistryInstance"
-        destroy-method="close">
+        init-method="initialize" destroy-method="close">
         <argument ref="dataBroker"/>
+        <argument ref="clusterSingletonService"/>
     </bean>
     <bean id="epRendererAugmentationRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.EpRendererAugmentationRegistryImplInstance"
-        destroy-method="close">
+        init-method="initialize" destroy-method="close">
         <argument ref="dataBroker"/>
+        <argument ref="clusterSingletonService"/>
     </bean>
     <bean id="statisticsManagerImpl" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.StatisticsManagerImplInstance"
-        destroy-method="close">
+        init-method="initialize" destroy-method="close">
         <argument ref="dataBroker"/>
+        <argument ref="clusterSingletonService"/>
     </bean>
     <bean id="policyValidatorRegistry" class="org.opendaylight.controller.config.yang.config.groupbasedpolicy.PolicyValidatorRegistryInstance"
-        destroy-method="close">
+        init-method="initialize" destroy-method="close">
         <argument ref="dataBroker"/>
+        <argument ref="clusterSingletonService"/>
     </bean>
 
     <!-- Services -->