feat: fix issues

Author: KirillKurdyukov

shaded-lock-ydb/pom.xml

@@ -60,6 +60,13 @@
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-dependencies</artifactId>
+                <version>${spring.boot.version}</version>
+                <scope>import</scope>
+                <type>pom</type>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
@@ -83,14 +90,12 @@
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-autoconfigure</artifactId>
-            <version>${spring.boot.version}</version>
             <scope>provided</scope>
         </dependency>
 
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
-            <version>${spring.boot.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -99,9 +104,8 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit5.version}</version>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>

shaded-lock-ydb/src/main/java/tech/ydb/lock/provider/YdbLockProvider.java renamed to shaded-lock-ydb/src/main/java/tech/ydb/lock/provider/YdbCoordinationServiceLockProvider.java

@@ -1,28 +1,31 @@
 package tech.ydb.lock.provider;
 
+import java.sql.SQLException;
 import java.util.Optional;
+import javax.annotation.PreDestroy;
 import net.javacrumbs.shedlock.core.LockConfiguration;
 import net.javacrumbs.shedlock.core.LockProvider;
 import net.javacrumbs.shedlock.core.SimpleLock;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import tech.ydb.coordination.CoordinationClient;
 import tech.ydb.coordination.SemaphoreLease;
+import tech.ydb.jdbc.YdbConnection;
 
 /**
  * @author Kirill Kurdyukov
  */
-public class YdbLockProvider implements LockProvider {
-    private static final Logger logger = LoggerFactory.getLogger(YdbLockProvider.class);
+public class YdbCoordinationServiceLockProvider implements LockProvider {
+    private static final Logger logger = LoggerFactory.getLogger(YdbCoordinationServiceLockProvider.class);
     private static final String YDB_LOCK_NODE_NAME = "shared-lock-ydb";
     private static final int ATTEMPT_CREATE_NODE = 10;
 
+    private final YdbConnection ydbConnection;
     private final CoordinationClient coordinationClient;
-    private final YdbLockProperties ydbLockProperties;
 
-    public YdbLockProvider(CoordinationClient coordinationClient, YdbLockProperties ydbLockProperties) {
-        this.coordinationClient = coordinationClient;
-        this.ydbLockProperties = ydbLockProperties;
+    public YdbCoordinationServiceLockProvider(YdbConnection ydbConnection) {
+        this.ydbConnection = ydbConnection;
+        this.coordinationClient = CoordinationClient.newClient(ydbConnection.getCtx().getGrpcTransport());
     }
 
     public void init() {
@@ -48,24 +51,27 @@ public Optional<SimpleLock> lock(LockConfiguration lockConfiguration) {
 
         logger.debug("Created coordination node session");
 
-        coordinationSession.createSemaphore(lockConfiguration.getName(), 1).join()
-                .expectSuccess("Failed creating semaphore[" + lockConfiguration.getName() +
-                        "], coordination node[" + YDB_LOCK_NODE_NAME + "]");
+        var semaphoreLease = coordinationSession.acquireEphemeralSemaphore(lockConfiguration.getName(), true,
+                lockConfiguration.getLockAtMostFor()).join();
 
-        logger.debug("Created semaphore[" + lockConfiguration.getName() + "]");
+        if (semaphoreLease.isSuccess()) {
+            logger.debug("Semaphore acquired");
 
-        var semaphoreLease = coordinationSession.acquireSemaphore(lockConfiguration.getName(), 1,
-                ydbLockProperties.acquireSemaphoreTimeout).join().getValue();
-
-        logger.debug("Semaphore acquired");
-
-        return Optional.of(new YdbSimpleLock(semaphoreLease));
+            return Optional.of(new YdbSimpleLock(semaphoreLease.getValue()));
+        } else {
+            return Optional.empty();
+        }
     }
 
     private record YdbSimpleLock(SemaphoreLease semaphoreLease) implements SimpleLock {
         @Override
-            public void unlock() {
-                semaphoreLease.release().join();
-            }
+        public void unlock() {
+            semaphoreLease.release().join();
         }
+    }
+
+    @PreDestroy
+    private void close() throws SQLException {
+        ydbConnection.close();
+    }
 }

shaded-lock-ydb/src/main/java/tech/ydb/lock/provider/YdbLockProperties.java

@@ -2,44 +2,18 @@
 
 import java.sql.SQLException;
 import javax.sql.DataSource;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import tech.ydb.coordination.CoordinationClient;
 import tech.ydb.jdbc.YdbConnection;
-import tech.ydb.jdbc.YdbDriver;
 
 /**
  * @author Kirill Kurdyukov
  */
 
 @Configuration
-@EnableConfigurationProperties(YdbLockProperties.class)
 public class YdbLockProviderConfiguration {
-
-    @Configuration
-    @ConditionalOnClass(YdbDriver.class)
-    public static class YdbLockProviderDataSourceConfiguration {
-
-        @Bean
-        @ConditionalOnBean(DataSource.class)
-        public CoordinationClient coordinationClient(DataSource dataSource) throws SQLException {
-            try (var ydbConnection = dataSource.getConnection().unwrap(YdbConnection.class)) {
-
-                return CoordinationClient.newClient(ydbConnection.getCtx().getGrpcTransport());
-            }
-        }
-    }
-
     @Bean
-    public YdbLockProvider ydbLockProvider(CoordinationClient coordinationClient,
-                                           YdbLockProperties ydbLockProperties) {
-        var ydbLockProvider = new YdbLockProvider(coordinationClient, ydbLockProperties);
-
-        ydbLockProvider.init();
-
-        return ydbLockProvider;
+    public YdbCoordinationServiceLockProvider ydbLockProvider(DataSource dataSource) throws SQLException {
+        return new YdbCoordinationServiceLockProvider(dataSource.getConnection().unwrap(YdbConnection.class));
     }
 }

shaded-lock-ydb/src/main/java/tech/ydb/lock/provider/YdbLockProviderConfiguration.java

@@ -1,10 +1,10 @@
 package tech.ydb.lock.provider;
 
-import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 /**
  * @author Kirill Kurdyukov
  */
-@SpringBootTest
+@SpringBootApplication
 public class TestApp {
 }

shaded-lock-ydb/src/test/java/tech/ydb/lock/provider/TestApp.java

@@ -1,5 +1,16 @@
 package tech.ydb.lock.provider;
 
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+import net.javacrumbs.shedlock.core.LockConfiguration;
+import net.javacrumbs.shedlock.core.SimpleLock;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -36,10 +47,43 @@ private static String jdbcUrl() {
     }
 
     @Autowired
-    private YdbLockProvider ydbLockProvider;
+    private YdbCoordinationServiceLockProvider lockProvider;
 
     @Test
-    public void integrationTest() {
+    public void integrationTest() throws ExecutionException, InterruptedException {
+        var executorServer = Executors.newFixedThreadPool(10);
+        var atomicInt = new AtomicInteger();
+        var futures = new ArrayList<Future<?>>();
 
+        for (int i = 0; i < 100; i++) {
+            final var ii = i;
+            futures.add(executorServer.submit(() -> {
+                lockProvider.init();
+
+                Optional<SimpleLock> optinal = Optional.empty();
+
+                while (optinal.isEmpty()) {
+                    optinal = lockProvider.lock(
+                            new LockConfiguration(Instant.now(), "semaphore", Duration.ZERO, Duration.ZERO));
+
+                    optinal.ifPresent(simpleLock -> {
+                        try {
+                            Thread.sleep(100);
+                        } catch (InterruptedException e) {
+                            throw new RuntimeException(e);
+                        }
+
+                        atomicInt.addAndGet(ii);
+                        simpleLock.unlock();
+                    });
+                }
+            }));
+        }
+
+        for (Future<?> future : futures) {
+            future.get();
+        }
+
+        Assertions.assertEquals(4950, atomicInt.get());
     }
 }

shaded-lock-ydb/src/test/java/tech/ydb/lock/provider/YdbLockProviderTest.java

@@ -0,0 +1 @@
+spring.datasource.driver-class-name=tech.ydb.jdbc.YdbDriver