Update internal structure to pass registrations

Within lusterSingletonServiceGroupImpl we need identity-based
lookup, which ObjectRegistration provides.

This is useful for keeping additional per-service state without
relying on user's equals() method.

JIRA: MDSAL-362
Change-Id: I01fd1f34a689a2c8f50ff7efc590f713a0212354
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
index 0f1d583cbe91f1343656fe5a4e8d2fcbc40735c8..c65fb7e45b27819a473db7c3f69c48f4f015c8a6 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/AbstractClusterSingletonServiceProviderImpl.java
@@ -114,19 +114,21 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Path
             serviceGroup = existing;
         }
 
-        serviceGroup.registerService(service);
-        return new AbstractClusterSingletonServiceRegistration(service) {
+        final ClusterSingletonServiceRegistration reg =  new AbstractClusterSingletonServiceRegistration(service) {
             @Override
             protected void removeRegistration() {
                 // We need to bounce the unregistration through a ordered lock in order not to deal with asynchronous
                 // shutdown of the group and user registering it again.
-                AbstractClusterSingletonServiceProviderImpl.this.removeRegistration(serviceIdentifier, service);
+                AbstractClusterSingletonServiceProviderImpl.this.removeRegistration(serviceIdentifier, this);
             }
         };
+
+        serviceGroup.registerService(reg);
+        return reg;
     }
 
     private ClusterSingletonServiceGroup<P, E, C> createGroup(final String serviceIdentifier,
-            final List<ClusterSingletonService> services) {
+            final List<ClusterSingletonServiceRegistration> services) {
         return new ClusterSingletonServiceGroupImpl<>(serviceIdentifier, entityOwnershipService,
                 createEntity(SERVICE_ENTITY_TYPE, serviceIdentifier),
                 createEntity(CLOSE_SERVICE_ENTITY_TYPE, serviceIdentifier), services);
@@ -142,13 +144,13 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Path
         }
     }
 
-    void removeRegistration(final String serviceIdentifier, final ClusterSingletonService service) {
+    void removeRegistration(final String serviceIdentifier, final ClusterSingletonServiceRegistration reg) {
 
         final PlaceholderGroup<P, E, C> placeHolder;
         final ListenableFuture<?> future;
         synchronized (this) {
             final ClusterSingletonServiceGroup<P, E, C> lookup = verifyNotNull(serviceGroupMap.get(serviceIdentifier));
-            if (!lookup.unregisterService(service)) {
+            if (!lookup.unregisterService(reg)) {
                 return;
             }
 
@@ -157,7 +159,7 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Path
             future = lookup.closeClusterSingletonGroup();
             placeHolder = new PlaceholderGroup<>(lookup, future);
 
-            final String identifier = service.getIdentifier().getValue();
+            final String identifier = reg.getInstance().getIdentifier().getValue();
             verify(serviceGroupMap.replace(identifier, lookup, placeHolder));
             LOG.debug("Replaced group {} with {}", serviceIdentifier, placeHolder);
         }
@@ -169,7 +171,7 @@ public abstract class AbstractClusterSingletonServiceProviderImpl<P extends Path
         final String identifier = placeHolder.getIdentifier();
         LOG.debug("Service group {} closed", identifier);
 
-        final List<ClusterSingletonService> services = placeHolder.getServices();
+        final List<ClusterSingletonServiceRegistration> services = placeHolder.getServices();
         if (services.isEmpty()) {
             // No services, we are all done
             if (serviceGroupMap.remove(identifier, placeHolder)) {

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
index 8682ef08f318b5b7639a9a2a42db38ac227e5a25..40d8332edeb39c9ad99eda1f01a4a92a587d8cf8 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroup.java
@@ -47,7 +47,7 @@ abstract class ClusterSingletonServiceGroup<P extends Path<P>, E extends Generic
      *
      * @param service instance
      */
-    abstract void registerService(ClusterSingletonService service);
+    abstract void registerService(ClusterSingletonServiceRegistration reg);
 
     /**
      * Method provides possibility to restart some service from group without change
@@ -60,7 +60,7 @@ abstract class ClusterSingletonServiceGroup<P extends Path<P>, E extends Generic
      * @param service instance
      * @return True if this was the last service registered
      */
-    abstract boolean unregisterService(ClusterSingletonService service);
+    abstract boolean unregisterService(ClusterSingletonServiceRegistration reg);
 
     /**
      * Method implementation has to apply ownershipChange for all registered services.

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
index 5fc180208c2bed4222937a5bbb9afae36ef3d012..3594d64f2248d7f633e9b0846054cb4253691e39 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImpl.java
@@ -32,6 +32,7 @@ import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipChange;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipListener;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipService;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
 import org.opendaylight.yangtools.concepts.Path;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -116,7 +117,7 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
     private final ReentrantLock lock = new ReentrantLock(true);
 
     @GuardedBy("lock")
-    private final List<ClusterSingletonService> serviceGroup;
+    private final List<ClusterSingletonServiceRegistration> serviceGroup;
 
     /*
      * State tracking is quite involved, as we are tracking up to four asynchronous sources of events:
@@ -190,7 +191,7 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
      * @param services Services list
      */
     ClusterSingletonServiceGroupImpl(final String identifier, final S entityOwnershipService, final E mainEntity,
-            final E closeEntity, final List<ClusterSingletonService> services) {
+            final E closeEntity, final List<ClusterSingletonServiceRegistration> services) {
         Preconditions.checkArgument(!identifier.isEmpty(), "Identifier may not be empty");
         this.identifier = identifier;
         this.entityOwnershipService = Preconditions.checkNotNull(entityOwnershipService);
@@ -355,7 +356,8 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
     }
 
     @Override
-    void registerService(final ClusterSingletonService service) {
+    void registerService(final ClusterSingletonServiceRegistration reg) {
+        final ClusterSingletonService service = reg.getInstance();
         Verify.verify(identifier.equals(service.getIdentifier().getValue()));
         checkNotClosed();
 
@@ -365,7 +367,7 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
                     "Service group %s is not initialized yet", identifier);
 
             LOG.debug("Adding service {} to service group {}", service, identifier);
-            serviceGroup.add(service);
+            serviceGroup.add(reg);
 
             switch (localServicesState) {
                 case STARTED:
@@ -386,7 +388,8 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
 
     @CheckReturnValue
     @Override
-    boolean unregisterService(final ClusterSingletonService service) {
+    boolean unregisterService(final ClusterSingletonServiceRegistration reg) {
+        final ClusterSingletonService service = reg.getInstance();
         Verify.verify(identifier.equals(service.getIdentifier().getValue()));
         checkNotClosed();
 
@@ -395,11 +398,11 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
             // There is a slight problem here, as the type does not match the list type, hence we need to tread
             // carefully.
             if (serviceGroup.size() == 1) {
-                Verify.verify(serviceGroup.contains(service));
+                Verify.verify(serviceGroup.contains(reg));
                 return true;
             }
 
-            Verify.verify(serviceGroup.remove(service));
+            Verify.verify(serviceGroup.remove(reg));
             LOG.debug("Service {} was removed from group.", service.getIdentifier().getValue());
 
             switch (localServicesState) {
@@ -642,7 +645,8 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
         }
 
         LOG.debug("Service group {} starting services", identifier);
-        serviceGroup.forEach(service -> {
+        serviceGroup.forEach(reg -> {
+            final ClusterSingletonService service = reg.getInstance();
             LOG.debug("Starting service {}", service);
             try {
                 service.instantiateServiceInstance();
@@ -662,9 +666,9 @@ final class ClusterSingletonServiceGroupImpl<P extends Path<P>, E extends Generi
                 localServicesState = ServiceState.STOPPING;
 
                 final List<ListenableFuture<?>> serviceCloseFutureList = new ArrayList<>(serviceGroup.size());
-                for (final ClusterSingletonService service : serviceGroup) {
+                for (final ClusterSingletonServiceRegistration reg : serviceGroup) {
+                    final ClusterSingletonService service = reg.getInstance();
                     final ListenableFuture<?> future;
-
                     try {
                         future = service.closeServiceInstance();
                     } catch (Exception e) {

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
index ea50afe01be4fea7b7eaa5afc8a671fca55a5022..a94b51b8169f59c08fd6b396948cd3009eb0990e 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/main/java/org/opendaylight/mdsal/singleton/dom/impl/PlaceholderGroup.java
@@ -18,7 +18,7 @@ import java.util.List;
 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
 import org.opendaylight.mdsal.eos.common.api.GenericEntity;
 import org.opendaylight.mdsal.eos.common.api.GenericEntityOwnershipChange;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
 import org.opendaylight.yangtools.concepts.Path;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -31,7 +31,7 @@ final class PlaceholderGroup<P extends Path<P>, E extends GenericEntity<P>,
         C extends GenericEntityOwnershipChange<P, E>> extends ClusterSingletonServiceGroup<P, E, C> {
     private static final Logger LOG = LoggerFactory.getLogger(PlaceholderGroup.class);
 
-    private final List<ClusterSingletonService> services = new ArrayList<>(0);
+    private final List<ClusterSingletonServiceRegistration> services = new ArrayList<>(0);
     private final ClusterSingletonServiceGroup<P, E, C> previous;
     private final ListenableFuture<?> closeFuture;
 
@@ -53,17 +53,17 @@ final class PlaceholderGroup<P extends Path<P>, E extends GenericEntity<P>,
     }
 
     @Override
-    void registerService(final ClusterSingletonService service) {
+    void registerService(final ClusterSingletonServiceRegistration reg) {
         verifyNoSuccessor();
-        services.add(service);
-        LOG.debug("{}: added service {}", this, service);
+        services.add(reg);
+        LOG.debug("{}: added service {}", this, reg.getInstance());
     }
 
     @Override
-    boolean unregisterService(final ClusterSingletonService service) {
+    boolean unregisterService(final ClusterSingletonServiceRegistration reg) {
         verifyNoSuccessor();
-        services.remove(service);
-        LOG.debug("{}: removed service {}", this, service);
+        services.remove(reg);
+        LOG.debug("{}: removed service {}", this, reg.getInstance());
         return false;
     }
 
@@ -81,7 +81,7 @@ final class PlaceholderGroup<P extends Path<P>, E extends GenericEntity<P>,
     }
 
     // Note: this is a leaked structure, the caller can reuse it at will, but has to regard
-    List<ClusterSingletonService> getServices() {
+    List<ClusterSingletonServiceRegistration> getServices() {
         verifyNoSuccessor();
         LOG.trace("{}: returning services {}", this, services);
         return services;

diff --git a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
index 83ed842d504ebe388338ae3bf5860c863010d72d..5d681b00f1da1b6c1151c1c293d2f79a4d626f7f 100644 (file)
--- a/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
+++ b/singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/ClusterSingletonServiceGroupImplTest.java
@@ -73,6 +73,9 @@ public class ClusterSingletonServiceGroupImplTest {
                         GenericEntityOwnershipListener<TestInstanceIdentifier,
                             GenericEntityOwnershipChange<TestInstanceIdentifier, TestEntity>>>> singletonServiceGroup;
 
+    private ClusterSingletonServiceRegistration firstReg;
+    private ClusterSingletonServiceRegistration secondReg;
+
     /**
      * Initialization functionality for every Tests in this suite.
      *
@@ -92,6 +95,19 @@ public class ClusterSingletonServiceGroupImplTest {
         doReturn(SERVICE_GROUP_IDENT).when(mockClusterSingletonService).getIdentifier();
         doReturn(SERVICE_GROUP_IDENT).when(mockClusterSingletonServiceSecond).getIdentifier();
 
+        firstReg = new AbstractClusterSingletonServiceRegistration(mockClusterSingletonService) {
+            @Override
+            protected void removeRegistration() {
+                // No-op
+            }
+        };
+        secondReg = new AbstractClusterSingletonServiceRegistration(mockClusterSingletonServiceSecond) {
+            @Override
+            protected void removeRegistration() {
+                // No-op
+            }
+        };
+
         singletonServiceGroup = new ClusterSingletonServiceGroupImpl<>(SERVICE_IDENTIFIER, MAIN_ENTITY, CLOSE_ENTITY,
             mockEosService);
     }
@@ -154,7 +170,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void initializationSlaveTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToSlave());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
@@ -169,7 +185,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void initializationNoMasterTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToSlaveNoMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
@@ -184,7 +200,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void initializationInJeopardyTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToJeopardy());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
@@ -199,7 +215,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void serviceRegistrationClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
     }
 
     /**
@@ -212,8 +228,8 @@ public class ClusterSingletonServiceGroupImplTest {
             throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
-        singletonServiceGroup.registerService(mockClusterSingletonServiceSecond);
+        singletonServiceGroup.registerService(firstReg);
+        singletonServiceGroup.registerService(secondReg);
     }
 
     /**
@@ -226,8 +242,8 @@ public class ClusterSingletonServiceGroupImplTest {
     public void serviceUnregistrationClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
-        assertTrue(singletonServiceGroup.unregisterService(mockClusterSingletonService));
+        singletonServiceGroup.registerService(firstReg);
+        assertTrue(singletonServiceGroup.unregisterService(firstReg));
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
 
@@ -242,9 +258,9 @@ public class ClusterSingletonServiceGroupImplTest {
             throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
-        singletonServiceGroup.registerService(mockClusterSingletonServiceSecond);
-        assertFalse(singletonServiceGroup.unregisterService(mockClusterSingletonService));
+        singletonServiceGroup.registerService(firstReg);
+        singletonServiceGroup.registerService(secondReg);
+        assertFalse(singletonServiceGroup.unregisterService(firstReg));
         verify(mockClusterSingletonService, never()).closeServiceInstance();
     }
 
@@ -257,7 +273,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void getSlaveClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToSlave());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
     }
@@ -271,7 +287,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void tryToTakeLeaderClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -286,7 +302,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void takeMasterClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -304,7 +320,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void waitToTakeMasterClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -322,7 +338,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void inJeopardyInWaitPhaseClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -341,8 +357,8 @@ public class ClusterSingletonServiceGroupImplTest {
             throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
-        singletonServiceGroup.registerService(mockClusterSingletonServiceSecond);
+        singletonServiceGroup.registerService(firstReg);
+        singletonServiceGroup.registerService(secondReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -360,7 +376,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void inJeopardyLeaderClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -385,7 +401,7 @@ public class ClusterSingletonServiceGroupImplTest {
     public void lostLeaderClusterSingletonServiceGroupTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -402,7 +418,7 @@ public class ClusterSingletonServiceGroupImplTest {
      */
     @Test(expected = RuntimeException.class)
     public void tryToTakeLeaderForNotInitializedGroupTest() {
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
     }
 
     /**
@@ -414,13 +430,13 @@ public class ClusterSingletonServiceGroupImplTest {
     public void checkClosingRegistrationTest() throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
         singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());
         verify(mockClusterSingletonService).instantiateServiceInstance();
-        assertTrue(singletonServiceGroup.unregisterService(mockClusterSingletonService));
+        assertTrue(singletonServiceGroup.unregisterService(firstReg));
         verify(mockClusterSingletonService, never()).closeServiceInstance();
         singletonServiceGroup.ownershipChanged(getEntityToSlaveNoMaster());
         verify(mockClusterSingletonService).closeServiceInstance();
@@ -436,7 +452,7 @@ public class ClusterSingletonServiceGroupImplTest {
             throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
@@ -457,7 +473,7 @@ public class ClusterSingletonServiceGroupImplTest {
             throws CandidateAlreadyRegisteredException {
         singletonServiceGroup.initialize();
         verify(mockEosService).registerCandidate(MAIN_ENTITY);
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToSlave());
         verify(mockClusterSingletonService, never()).instantiateServiceInstance();
         verify(mockEosService, never()).registerCandidate(CLOSE_ENTITY);
@@ -470,7 +486,7 @@ public class ClusterSingletonServiceGroupImplTest {
             ExecutionException {
         initializeGroupAndStartService();
 
-        assertTrue(singletonServiceGroup.unregisterService(mockClusterSingletonService));
+        assertTrue(singletonServiceGroup.unregisterService(firstReg));
         verify(mockClusterSingletonService, never()).closeServiceInstance();
         verify(mockEntityCandReg, never()).close();
 
@@ -496,7 +512,7 @@ public class ClusterSingletonServiceGroupImplTest {
 
     private void initializeGroupAndStartService() throws CandidateAlreadyRegisteredException {
         initialize();
-        singletonServiceGroup.registerService(mockClusterSingletonService);
+        singletonServiceGroup.registerService(firstReg);
         singletonServiceGroup.ownershipChanged(getEntityToMaster());
         verify(mockEosService).registerCandidate(CLOSE_ENTITY);
         singletonServiceGroup.ownershipChanged(getDoubleEntityToMaster());