Refactored AdvisoryLock to more extendable form

Author: Maciej Rosiek

README.md

@@ -17,7 +17,7 @@ To use SProcWrapper, add the following lines to your pom.xml:
 <dependency>
     <groupId>de.zalando</groupId>
     <artifactId>zalando-sprocwrapper</artifactId>
-    <version>1.2.4</version>
+    <version>1.3.0</version>
 </dependency>
 ```
 

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>de.zalando</groupId>
     <artifactId>zalando-sprocwrapper</artifactId>
-    <version>1.2.4</version>
+    <version>1.3.0</version>
     <packaging>jar</packaging>
     <name>Stored Procedure Wrapper</name>
     <description>Library to make PostgreSQL stored procedures available through simple Java "*SProcService" interfaces including automatic object serialization and deserialization (using typemapper and convention-over-configuration). Supports sharding, advisory locking, statement timeouts and PostgreSQL types such as enums and hstore.</description>

src/main/java/de/zalando/sprocwrapper/SProcCall.java

@@ -6,32 +6,87 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import java.util.Objects;
+
+import com.google.common.base.Preconditions;
+
 /**
  * @author  jmussler
  */
-@Retention(RetentionPolicy.RUNTIME)
+@Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.METHOD)
 @Inherited
 public @interface SProcCall {
 
-    public static enum AdvisoryLock {
-        NO_LOCK(0L),
-        LOCK_ONE(1L);
+    public static class AdvisoryLock {
 
-        /*
-         * Add more values to this enum if you need additional types of locks
-         */
+        public static class NoLock {
+            public static final String NAME = "NO_LOCK";
+            public static final long SPROC_ID = 0L;
+            public static final AdvisoryLock LOCK = new AdvisoryLock(NAME, SPROC_ID);
+        }
 
-        private AdvisoryLock(final long sprocId) {
-            this.sprocId = sprocId;
+        public static class LockOne {
+            public static final String NAME = "LOCK_ONE";
+            public static final long SPROC_ID = 1L;
+            public static final AdvisoryLock LOCK = new AdvisoryLock(NAME, SPROC_ID);
         }
 
+        private final String name;
         private final long sprocId;
 
+        public AdvisoryLock(final String name, final long sprocId) {
+            Preconditions.checkNotNull(name, "Name parameter cannot be null.");
+            Preconditions.checkArgument(sprocId == NoLock.SPROC_ID && Objects.equals(name, NoLock.NAME)
+                    || sprocId != NoLock.SPROC_ID && !Objects.equals(name, NoLock.NAME),
+                "SprocId parameter is different than %s (%s) but the name parameter was not changed: [name: %s, sprocId: %s]",
+                NoLock.SPROC_ID, NoLock.NAME, name, sprocId);
+            this.name = name;
+            this.sprocId = sprocId;
+        }
+
+        public String getName() {
+            return name;
+        }
+
         public long getSprocId() {
             return sprocId;
         }
 
+        @Override
+        public boolean equals(final Object o) {
+            if (this == o) {
+                return true;
+            }
+
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+
+            final AdvisoryLock that = (AdvisoryLock) o;
+
+            if (sprocId != that.sprocId) {
+                return false;
+            }
+
+            if (!name.equals(that.name)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        @Override
+        public int hashCode() {
+            int result = name.hashCode();
+            result = 31 * result + (int) (sprocId ^ (sprocId >>> 32));
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return "AdvisoryLock{" + "name='" + name + '\'' + ", sprocId=" + sprocId + '}';
+        }
     }
 
     public static enum Validate {
@@ -94,7 +149,10 @@ public static enum WriteTransaction {
 
     long timeoutInMilliSeconds() default 0;
 
-    AdvisoryLock adivsoryLockType() default AdvisoryLock.NO_LOCK;
+    long adivsoryLockSprocId() default AdvisoryLock.NoLock.SPROC_ID;
+
+    String adivsoryLockName() default AdvisoryLock.NoLock.NAME;
 
     Validate validate() default Validate.AS_DEFINED_IN_SERVICE;
+
 }

src/main/java/de/zalando/sprocwrapper/proxy/SProcProxyBuilder.java

@@ -136,8 +136,9 @@ public static <T> T build(final DataSourceProvider d, final Class<T> c) {
 
                 storedProcedure = new StoredProcedure(name, method.getGenericReturnType(), sprocStrategy,
                         scA.runOnAllShards(), scA.searchShards(), scA.parallel(), resultMapper,
-                        scA.timeoutInMilliSeconds(), scA.adivsoryLockType(), useValidation, scA.readOnly(),
-                        writeTransaction);
+                        scA.timeoutInMilliSeconds(),
+                        new SProcCall.AdvisoryLock(scA.adivsoryLockName(), scA.adivsoryLockSprocId()), useValidation,
+                        scA.readOnly(), writeTransaction);
                 if (!"".equals(scA.sql())) {
                     storedProcedure.setQuery(scA.sql());
                 }

src/main/java/de/zalando/sprocwrapper/proxy/StoredProcedure.java

@@ -152,7 +152,7 @@ public StoredProcedure(final String name, final java.lang.reflect.Type genericTy
             }
         }
 
-        if (this.timeout > 0 || this.adivsoryLock != AdvisoryLock.NO_LOCK) {
+        if (this.timeout > 0 || (this.adivsoryLock != null && !(this.adivsoryLock.equals(AdvisoryLock.NoLock.LOCK)))) {
 
             // Wrapper provides locking and changing of session settings functionality
             this.executor = new ExecutorWrapper(executor, this.timeout, this.adivsoryLock);

src/main/java/de/zalando/sprocwrapper/proxy/executors/ExecutorWrapper.java

@@ -60,13 +60,13 @@ private void resetTimeout(final Connection conn) throws SQLException {
     }
 
     private boolean lockAdvisoryLock(final Connection conn) throws SQLException {
-        if (lock == AdvisoryLock.NO_LOCK) {
+        if (lock == null || lock.equals(AdvisoryLock.NoLock.LOCK)) {
             return true;
         }
 
         final Statement st = conn.createStatement();
-        final ResultSet rs = st.executeQuery("SELECT pg_advisory_lock(" + lock.getSprocId() + ") AS \"" + lock.name()
-                    + "\";");
+        final ResultSet rs = st.executeQuery("SELECT pg_advisory_lock(" + lock.getSprocId() + ") AS \"" + lock
+                    .getName() + "\";");
 
         boolean b = false;
         if (rs.next()) {
@@ -79,7 +79,7 @@ private boolean lockAdvisoryLock(final Connection conn) throws SQLException {
     }
 
     private boolean unlockAdvisoryLock(final Connection conn) throws SQLException {
-        if (lock == AdvisoryLock.NO_LOCK) {
+        if (lock == null || lock.equals(AdvisoryLock.NoLock.LOCK)) {
             return true;
         }
 
@@ -108,7 +108,7 @@ public Object executeSProc(final DataSource ds, final String sql, final Object[]
             setTimeout(sameConnDs.getConnection());
 
             if (!lockAdvisoryLock(sameConnDs.getConnection())) {
-                throw new RuntimeException("Could not acquire AdvisoryLock " + lock.name());
+                throw new RuntimeException("Could not acquire AdvisoryLock " + lock.getName());
             }
 
             return executor.executeSProc(sameConnDs, sql, args, types, invocationContext, returnType);
@@ -130,7 +130,7 @@ public Object executeSProc(final DataSource ds, final String sql, final Object[]
                     }
 
                     // unlock in all cases, locks not owned by this session cannot be unlocked
-                    if (lock != AdvisoryLock.NO_LOCK) {
+                    if (lock != null && !lock.equals(AdvisoryLock.NoLock.LOCK)) {
                         try {
                             unlockAdvisoryLock(sameConnDs.getConnection());
                         } catch (final SQLException ex) {

src/test/java/de/zalando/sprocwrapper/AdvisoryLockTest.java

@@ -0,0 +1,26 @@
+package de.zalando.sprocwrapper;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AdvisoryLockTest {
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldNotCreateAdvisoryLockWithWrongName() {
+        new SProcCall.AdvisoryLock(SProcCall.AdvisoryLock.NoLock.NAME, SProcCall.AdvisoryLock.NoLock.SPROC_ID + 1);
+    }
+
+    @Test
+    public void shouldCreateAdvisoryLockWithCorrectName() {
+        new SProcCall.AdvisoryLock("TEST_LOCK", 100L);
+    }
+
+    @Test
+    public void shouldCompareLocksCorrectly() {
+        Assert.assertEquals(SProcCall.AdvisoryLock.NoLock.LOCK,
+            new SProcCall.AdvisoryLock(SProcCall.AdvisoryLock.NoLock.NAME, SProcCall.AdvisoryLock.NoLock.SPROC_ID));
+        Assert.assertNotEquals(SProcCall.AdvisoryLock.LockOne.LOCK,
+            new SProcCall.AdvisoryLock(SProcCall.AdvisoryLock.NoLock.NAME, SProcCall.AdvisoryLock.NoLock.SPROC_ID));
+    }
+
+}