Remove ILock, ICondition and their implementations

hazelcast-spring/src/main/java/com/hazelcast/spring/HazelcastConfigBeanDefinitionParser.java

@@ -47,7 +47,6 @@
 import com.hazelcast.config.JoinConfig;
 import com.hazelcast.config.ListConfig;
 import com.hazelcast.config.ListenerConfig;
-import com.hazelcast.config.LockConfig;
 import com.hazelcast.config.LoginModuleConfig;
 import com.hazelcast.config.MCMutualAuthConfig;
 import com.hazelcast.config.ManagementCenterConfig;
@@ -193,7 +192,6 @@ private class SpringXmlConfigBuilder extends SpringXmlBuilderHelper {
         private ManagedMap<String, AbstractBeanDefinition> mapConfigManagedMap;
         private ManagedMap<String, AbstractBeanDefinition> cacheConfigManagedMap;
         private ManagedMap<String, AbstractBeanDefinition> queueManagedMap;
-        private ManagedMap<String, AbstractBeanDefinition> lockManagedMap;
         private ManagedMap<String, AbstractBeanDefinition> ringbufferManagedMap;
         private ManagedMap<String, AbstractBeanDefinition> reliableTopicManagedMap;
         private ManagedMap<String, AbstractBeanDefinition> listManagedMap;
@@ -220,7 +218,6 @@ private class SpringXmlConfigBuilder extends SpringXmlBuilderHelper {
             this.mapConfigManagedMap = createManagedMap("mapConfigs");
             this.cacheConfigManagedMap = createManagedMap("cacheConfigs");
             this.queueManagedMap = createManagedMap("queueConfigs");
-            this.lockManagedMap = createManagedMap("lockConfigs");
             this.ringbufferManagedMap = createManagedMap("ringbufferConfigs");
             this.reliableTopicManagedMap = createManagedMap("reliableTopicConfigs");
             this.listManagedMap = createManagedMap("listConfigs");
@@ -273,8 +270,6 @@ public void handleConfig(Element element) {
                         handleCardinalityEstimator(node);
                     } else if ("queue".equals(nodeName)) {
                         handleQueue(node);
-                    } else if ("lock".equals(nodeName)) {
-                        handleLock(node);
                     } else if ("ringbuffer".equals(nodeName)) {
                         handleRingbuffer(node);
                     } else if ("reliable-topic".equals(nodeName)) {
@@ -1044,18 +1039,6 @@ public void handleReliableTopic(Node node) {
             reliableTopicManagedMap.put(getAttribute(node, "name"), builder.getBeanDefinition());
         }
 
-        public void handleLock(Node node) {
-            BeanDefinitionBuilder lockConfigBuilder = createBeanBuilder(LockConfig.class);
-            fillAttributeValues(node, lockConfigBuilder);
-            for (Node childNode : childElements(node)) {
-                String nodeName = cleanNodeName(childNode);
-                if ("split-brain-protection-ref".equals(nodeName)) {
-                    lockConfigBuilder.addPropertyValue("splitBrainProtectionName", getTextContent(childNode));
-                }
-            }
-            lockManagedMap.put(getAttribute(node, "name"), lockConfigBuilder.getBeanDefinition());
-        }
-
         public void handleRingbuffer(Node node) {
             BeanDefinitionBuilder ringbufferConfigBuilder = createBeanBuilder(RingbufferConfig.class);
             fillAttributeValues(node, ringbufferConfigBuilder);

hazelcast-spring/src/main/java/com/hazelcast/spring/HazelcastNamespaceHandler.java

@@ -50,6 +50,7 @@ public class HazelcastNamespaceHandler extends NamespaceHandlerSupport {
     private static final String PNCOUNTER = "PNCounter";
 
     static {
+        CP_TYPES.add(LOCK);
         CP_TYPES.add(SEMAPHORE);
         CP_TYPES.add(COUNT_DOWN_LATCH);
         CP_TYPES.add(ATOMIC_LONG);

hazelcast-spring/src/main/resources/hazelcast-spring-4.0.xsd

@@ -268,21 +268,6 @@
                                 </xs:attribute>
                             </xs:complexType>
                         </xs:element>
-                        <xs:element name="lock" minOccurs="0" maxOccurs="unbounded">
-                            <xs:complexType>
-                                <xs:sequence>
-                                    <xs:element name="split-brain-protection-ref" minOccurs="0" maxOccurs="1">
-                                        <xs:annotation>
-                                            <xs:documentation>
-                                                Adds the Split Brain Protection for this data-structure which you configure using the split-brain-protection element.
-                                                You should set the split-brain-protection-ref's value as the split brain protection's name.
-                                            </xs:documentation>
-                                        </xs:annotation>
-                                    </xs:element>
-                                </xs:sequence>
-                                <xs:attribute name="name" use="required" type="xs:string"/>
-                            </xs:complexType>
-                        </xs:element>
                         <xs:element name="ringbuffer" minOccurs="0" maxOccurs="unbounded">
                             <xs:complexType>
                                 <xs:sequence>

hazelcast-spring/src/test/java/com/hazelcast/spring/TestFullApplicationContext.java

@@ -54,7 +54,6 @@
 import com.hazelcast.config.KubernetesConfig;
 import com.hazelcast.config.ListConfig;
 import com.hazelcast.config.ListenerConfig;
-import com.hazelcast.config.LockConfig;
 import com.hazelcast.config.ManagementCenterConfig;
 import com.hazelcast.config.MapConfig;
 import com.hazelcast.config.MapIndexConfig;
@@ -115,7 +114,7 @@
 import com.hazelcast.cp.IAtomicReference;
 import com.hazelcast.cp.ICountDownLatch;
 import com.hazelcast.cp.ISemaphore;
-import com.hazelcast.cp.lock.ILock;
+import com.hazelcast.cp.lock.FencedLock;
 import com.hazelcast.crdt.pncounter.PNCounter;
 import com.hazelcast.flakeidgen.FlakeIdGenerator;
 import com.hazelcast.instance.impl.HazelcastInstanceFactory;
@@ -233,7 +232,7 @@ public class TestFullApplicationContext extends HazelcastTestSupport {
     private ISemaphore semaphore;
 
     @Resource(name = "lock")
-    private ILock lock;
+    private FencedLock lock;
 
     @Resource(name = "dummyMapStore")
     private MapStore dummyMapStore;
@@ -510,14 +509,6 @@ public void testQueueConfig() {
         assertEquals(dummyQueueStoreFactory, storeConfig4.getFactoryImplementation());
     }
 
-    @Test
-    public void testLockConfig() {
-        LockConfig lockConfig = config.getLockConfig("lock");
-        assertNotNull(lockConfig);
-        assertEquals("lock", lockConfig.getName());
-        assertEquals("my-split-brain-protection", lockConfig.getSplitBrainProtectionName());
-    }
-
     @Test
     public void testRingbufferConfig() {
         RingbufferConfig testRingbuffer = config.getRingbufferConfig("testRingbuffer");

hazelcast-spring/src/test/resources/com/hazelcast/spring/fullConfig-applicationContext-hazelcast.xml

@@ -318,10 +318,6 @@
                 <hz:queue-store enabled="true" factory-implementation="dummyQueueStoreFactory"/>
             </hz:queue>
 
-            <hz:lock name="lock">
-                <hz:split-brain-protection-ref>my-split-brain-protection</hz:split-brain-protection-ref>
-            </hz:lock>
-
             <hz:ringbuffer name="testRingbuffer"
                            in-memory-format="OBJECT"
                            capacity="100"

hazelcast/src/main/java/com/hazelcast/client/console/ClientConsoleApp.java

@@ -953,7 +953,7 @@ private void handStats(String[] args) {
     protected void handleLock(String[] args) {
         String lockStr = args[0];
         String key = args[1];
-        Lock lock = hazelcast.getLock(key);
+        Lock lock = hazelcast.getCPSubsystem().getLock(key);
         if (lockStr.equalsIgnoreCase("lock")) {
             lock.lock();
             println("true");

hazelcast/src/main/java/com/hazelcast/client/cp/internal/CPSubsystemImpl.java

@@ -29,7 +29,7 @@
 import com.hazelcast.cp.internal.datastructures.atomiclong.AtomicLongService;
 import com.hazelcast.cp.internal.datastructures.atomicref.AtomicRefService;
 import com.hazelcast.cp.internal.datastructures.countdownlatch.CountDownLatchService;
-import com.hazelcast.cp.internal.datastructures.lock.RaftLockService;
+import com.hazelcast.cp.internal.datastructures.lock.LockService;
 import com.hazelcast.cp.internal.datastructures.semaphore.SemaphoreService;
 import com.hazelcast.cp.lock.FencedLock;
 import com.hazelcast.cp.session.CPSessionManagementService;
@@ -66,7 +66,7 @@ public ICountDownLatch getCountDownLatch(String name) {
 
     @Override
     public FencedLock getLock(String name) {
-        return proxyFactory.createProxy(RaftLockService.SERVICE_NAME, name);
+        return proxyFactory.createProxy(LockService.SERVICE_NAME, name);
     }
 
     @Override

hazelcast/src/main/java/com/hazelcast/client/cp/internal/datastructures/lock/RaftFencedLockProxy.java → hazelcast/src/main/java/com/hazelcast/client/cp/internal/datastructures/lock/FencedLockProxy.java

@@ -18,10 +18,10 @@
 
 import com.hazelcast.client.impl.clientside.ClientMessageDecoder;
 import com.hazelcast.client.impl.protocol.ClientMessage;
-import com.hazelcast.client.impl.protocol.codec.CPFencedLockGetLockOwnershipCodec;
-import com.hazelcast.client.impl.protocol.codec.CPFencedLockLockCodec;
-import com.hazelcast.client.impl.protocol.codec.CPFencedLockTryLockCodec;
-import com.hazelcast.client.impl.protocol.codec.CPFencedLockUnlockCodec;
+import com.hazelcast.client.impl.protocol.codec.FencedLockGetLockOwnershipCodec;
+import com.hazelcast.client.impl.protocol.codec.FencedLockLockCodec;
+import com.hazelcast.client.impl.protocol.codec.FencedLockTryLockCodec;
+import com.hazelcast.client.impl.protocol.codec.FencedLockUnlockCodec;
 import com.hazelcast.client.impl.protocol.codec.CPGroupDestroyCPObjectCodec;
 import com.hazelcast.client.impl.spi.ClientContext;
 import com.hazelcast.client.impl.spi.ClientProxy;
@@ -30,9 +30,9 @@
 import com.hazelcast.client.impl.ClientDelegatingFuture;
 import com.hazelcast.cp.CPGroupId;
 import com.hazelcast.cp.internal.RaftGroupId;
-import com.hazelcast.cp.internal.datastructures.lock.RaftLockOwnershipState;
-import com.hazelcast.cp.internal.datastructures.lock.RaftLockService;
-import com.hazelcast.cp.internal.datastructures.lock.proxy.AbstractRaftFencedLockProxy;
+import com.hazelcast.cp.internal.datastructures.lock.LockOwnershipState;
+import com.hazelcast.cp.internal.datastructures.lock.LockService;
+import com.hazelcast.cp.internal.datastructures.lock.proxy.AbstractFencedLockProxy;
 import com.hazelcast.cp.internal.session.AbstractProxySessionManager;
 import com.hazelcast.cp.lock.FencedLock;
 import com.hazelcast.spi.impl.InternalCompletableFuture;
@@ -44,42 +44,42 @@
 /**
  * Client-side proxy of Raft-based {@link FencedLock} API
  */
-public class RaftFencedLockProxy extends ClientProxy implements FencedLock {
+public class FencedLockProxy extends ClientProxy implements FencedLock {
 
     private static final ClientMessageDecoder LOCK_RESPONSE_DECODER = new ClientMessageDecoder() {
         @Override
         public Long decodeClientMessage(ClientMessage clientMessage) {
-            return CPFencedLockLockCodec.decodeResponse(clientMessage).response;
+            return FencedLockLockCodec.decodeResponse(clientMessage).response;
         }
     };
 
     private static final ClientMessageDecoder TRY_RESPONSE_DECODER = new ClientMessageDecoder() {
         @Override
         public Long decodeClientMessage(ClientMessage clientMessage) {
-            return CPFencedLockTryLockCodec.decodeResponse(clientMessage).response;
+            return FencedLockTryLockCodec.decodeResponse(clientMessage).response;
         }
     };
 
     private static final ClientMessageDecoder UNLOCK_RESPONSE_DECODER = new ClientMessageDecoder() {
         @Override
         public Boolean decodeClientMessage(ClientMessage clientMessage) {
-            return CPFencedLockUnlockCodec.decodeResponse(clientMessage).response;
+            return FencedLockUnlockCodec.decodeResponse(clientMessage).response;
         }
     };
 
     private static final ClientMessageDecoder GET_LOCK_OWNERSHIP_STATE_RESPONSE_DECODER = new ClientMessageDecoder() {
         @Override
-        public RaftLockOwnershipState decodeClientMessage(ClientMessage clientMessage) {
-            CPFencedLockGetLockOwnershipCodec.ResponseParameters params = CPFencedLockGetLockOwnershipCodec
+        public LockOwnershipState decodeClientMessage(ClientMessage clientMessage) {
+            FencedLockGetLockOwnershipCodec.ResponseParameters params = FencedLockGetLockOwnershipCodec
                     .decodeResponse(clientMessage);
-            return new RaftLockOwnershipState(params.fence, params.lockCount, params.sessionId, params.threadId);
+            return new LockOwnershipState(params.fence, params.lockCount, params.sessionId, params.threadId);
         }
     };
 
     private final FencedLockImpl lock;
 
-    public RaftFencedLockProxy(ClientContext context, RaftGroupId groupId, String proxyName, String objectName) {
-        super(RaftLockService.SERVICE_NAME, proxyName, context);
+    public FencedLockProxy(ClientContext context, RaftGroupId groupId, String proxyName, String objectName) {
+        super(LockService.SERVICE_NAME, proxyName, context);
         this.lock = new FencedLockImpl(getClient().getProxySessionManager(), groupId, proxyName, objectName);
     }
 
@@ -166,38 +166,38 @@ protected void postDestroy() {
     }
 
 
-    private class FencedLockImpl extends AbstractRaftFencedLockProxy {
+    private class FencedLockImpl extends AbstractFencedLockProxy {
         FencedLockImpl(AbstractProxySessionManager sessionManager, RaftGroupId groupId, String proxyName, String objectName) {
             super(sessionManager, groupId, proxyName, objectName);
         }
 
         @Override
         protected InternalCompletableFuture<Long> doLock(long sessionId, long threadId, UUID invocationUid) {
-            ClientMessage request = CPFencedLockLockCodec.encodeRequest(groupId, objectName, sessionId, threadId, invocationUid);
+            ClientMessage request = FencedLockLockCodec.encodeRequest(groupId, objectName, sessionId, threadId, invocationUid);
             ClientInvocationFuture future = new ClientInvocation(getClient(), request, name).invoke();
             return new ClientDelegatingFuture<>(future, getSerializationService(), LOCK_RESPONSE_DECODER);
         }
 
         @Override
         protected InternalCompletableFuture<Long> doTryLock(long sessionId, long threadId, UUID invocationUid,
                                                             long timeoutMillis) {
-            ClientMessage request = CPFencedLockTryLockCodec.encodeRequest(groupId, objectName, sessionId, threadId,
+            ClientMessage request = FencedLockTryLockCodec.encodeRequest(groupId, objectName, sessionId, threadId,
                     invocationUid, timeoutMillis);
             ClientInvocationFuture future = new ClientInvocation(getClient(), request, name).invoke();
             return new ClientDelegatingFuture<>(future, getSerializationService(), TRY_RESPONSE_DECODER);
         }
 
         @Override
         protected InternalCompletableFuture<Boolean> doUnlock(long sessionId, long threadId, UUID invocationUid) {
-            ClientMessage request = CPFencedLockUnlockCodec.encodeRequest(groupId, objectName, sessionId, threadId,
+            ClientMessage request = FencedLockUnlockCodec.encodeRequest(groupId, objectName, sessionId, threadId,
                     invocationUid);
             ClientInvocationFuture future = new ClientInvocation(getClient(), request, name).invoke();
             return new ClientDelegatingFuture<>(future, getSerializationService(), UNLOCK_RESPONSE_DECODER);
         }
 
         @Override
-        protected InternalCompletableFuture<RaftLockOwnershipState> doGetLockOwnershipState() {
-            ClientMessage request = CPFencedLockGetLockOwnershipCodec.encodeRequest(groupId, objectName);
+        protected InternalCompletableFuture<LockOwnershipState> doGetLockOwnershipState() {
+            ClientMessage request = FencedLockGetLockOwnershipCodec.encodeRequest(groupId, objectName);
             ClientInvocationFuture future = new ClientInvocation(getClient(), request, name).invoke();
             return new ClientDelegatingFuture<>(future, getSerializationService(), GET_LOCK_OWNERSHIP_STATE_RESPONSE_DECODER);
         }

hazelcast/src/main/java/com/hazelcast/client/cp/internal/datastructures/proxy/ClientRaftProxyFactory.java

@@ -19,9 +19,9 @@
 import com.hazelcast.client.cp.internal.datastructures.atomiclong.AtomicLongProxy;
 import com.hazelcast.client.cp.internal.datastructures.atomicref.AtomicRefProxy;
 import com.hazelcast.client.cp.internal.datastructures.countdownlatch.CountDownLatchProxy;
-import com.hazelcast.client.cp.internal.datastructures.lock.RaftFencedLockProxy;
-import com.hazelcast.client.cp.internal.datastructures.semaphore.RaftSessionAwareSemaphoreProxy;
-import com.hazelcast.client.cp.internal.datastructures.semaphore.RaftSessionlessSemaphoreProxy;
+import com.hazelcast.client.cp.internal.datastructures.lock.FencedLockProxy;
+import com.hazelcast.client.cp.internal.datastructures.semaphore.SessionAwareSemaphoreProxy;
+import com.hazelcast.client.cp.internal.datastructures.semaphore.SessionlessSemaphoreProxy;
 import com.hazelcast.client.impl.clientside.HazelcastClientInstanceImpl;
 import com.hazelcast.client.impl.protocol.ClientMessage;
 import com.hazelcast.client.impl.protocol.codec.CPGroupCreateCPGroupCodec;
@@ -34,7 +34,7 @@
 import com.hazelcast.cp.internal.datastructures.atomiclong.AtomicLongService;
 import com.hazelcast.cp.internal.datastructures.atomicref.AtomicRefService;
 import com.hazelcast.cp.internal.datastructures.countdownlatch.CountDownLatchService;
-import com.hazelcast.cp.internal.datastructures.lock.RaftLockService;
+import com.hazelcast.cp.internal.datastructures.lock.LockService;
 import com.hazelcast.cp.internal.datastructures.semaphore.SemaphoreService;
 import com.hazelcast.cp.lock.FencedLock;
 
@@ -50,8 +50,8 @@
 public class ClientRaftProxyFactory {
 
     private final HazelcastClientInstanceImpl client;
-    private final ConcurrentMap<String, RaftFencedLockProxy> lockProxies
-            = new ConcurrentHashMap<String, RaftFencedLockProxy>();
+    private final ConcurrentMap<String, FencedLockProxy> lockProxies
+            = new ConcurrentHashMap<String, FencedLockProxy>();
     private ClientContext context;
 
     public ClientRaftProxyFactory(HazelcastClientInstanceImpl client) {
@@ -75,7 +75,7 @@ public <T extends DistributedObject> T createProxy(String serviceName, String pr
             return (T) new AtomicRefProxy(context, groupId, proxyName, objectName);
         } else if (serviceName.equals(CountDownLatchService.SERVICE_NAME)) {
             return (T) new CountDownLatchProxy(context, groupId, proxyName, objectName);
-        } else if (serviceName.equals(RaftLockService.SERVICE_NAME)) {
+        } else if (serviceName.equals(LockService.SERVICE_NAME)) {
             return (T) createFencedLock(groupId, proxyName, objectName);
         } else if (serviceName.equals(SemaphoreService.SERVICE_NAME)) {
             return (T) createSemaphore(groupId, proxyName, objectName);
@@ -86,7 +86,7 @@ public <T extends DistributedObject> T createProxy(String serviceName, String pr
 
     private FencedLock createFencedLock(RaftGroupId groupId, String proxyName, String objectName) {
         while (true) {
-            RaftFencedLockProxy proxy = lockProxies.get(proxyName);
+            FencedLockProxy proxy = lockProxies.get(proxyName);
             if (proxy != null) {
                 if (!proxy.getGroupId().equals(groupId)) {
                     lockProxies.remove(proxyName, proxy);
@@ -95,8 +95,8 @@ private FencedLock createFencedLock(RaftGroupId groupId, String proxyName, Strin
                 }
             }
 
-            proxy = new RaftFencedLockProxy(context, groupId, proxyName, objectName);
-            RaftFencedLockProxy existing = lockProxies.putIfAbsent(proxyName, proxy);
+            proxy = new FencedLockProxy(context, groupId, proxyName, objectName);
+            FencedLockProxy existing = lockProxies.putIfAbsent(proxyName, proxy);
             if (existing == null) {
                 return proxy;
             } else if (existing.getGroupId().equals(groupId)) {
@@ -113,8 +113,8 @@ private ISemaphore createSemaphore(RaftGroupId groupId, String proxyName, String
         boolean jdkCompatible = SemaphoreGetSemaphoreTypeCodec.decodeResponse(response).response;
 
         return jdkCompatible
-                ? new RaftSessionlessSemaphoreProxy(context, groupId, proxyName, objectName)
-                : new RaftSessionAwareSemaphoreProxy(context, groupId, proxyName, objectName);
+                ? new SessionlessSemaphoreProxy(context, groupId, proxyName, objectName)
+                : new SessionAwareSemaphoreProxy(context, groupId, proxyName, objectName);
     }
 
     private RaftGroupId getGroupId(String proxyName, String objectName) {