Fix gradle-baseline excavator

atlasdb-commons/src/main/java/com/palantir/common/concurrent/InterruptibleFuture.java

@@ -53,16 +53,16 @@ private enum State {
     private final Lock lock = new ReentrantLock(false);
     private final Condition condition = lock.newCondition();
 
-    @GuardedBy(value = "lock")
+    @GuardedBy("lock")
     private V returnValue;
 
-    @GuardedBy(value = "lock")
+    @GuardedBy("lock")
     private Throwable executionException;
 
-    @GuardedBy(value = "lock")
+    @GuardedBy("lock")
     private volatile CancellationException cancellationException;
 
-    @GuardedBy(value = "lock")
+    @GuardedBy("lock")
     private volatile State state = State.WAITING_TO_RUN;
 
     private final FutureTask<?> futureTask = new FutureTask<Void>(
@@ -113,10 +113,14 @@ public final boolean cancel(boolean mayInterruptIfRunning) {
         return futureTask.cancel(mayInterruptIfRunning);
     }
 
-    @SuppressWarnings("GuardedByChecker")
     protected void noteFinished() {
-        state = State.COMPLETED;
-        condition.signalAll();
+        lock.lock();
+        try {
+            state = State.COMPLETED;
+            condition.signalAll();
+        } finally {
+            lock.unlock();
+        }
     }
 
     /**
@@ -157,31 +161,43 @@ public final V get(long timeout, TimeUnit unit)
         }
     }
 
-    @SuppressWarnings("GuardedByChecker")
     private V getReturnValue() throws ExecutionException, CancellationException {
-        if (cancellationException != null) {
-            throw Throwables.chain(
-                    new CancellationException("This task was canceled before it ever ran."), cancellationException);
-        }
-        if (executionException != null) {
-            throw new ExecutionException(executionException);
+        lock.lock();
+        try {
+            if (cancellationException != null) {
+                throw Throwables.chain(
+                        new CancellationException("This task was canceled before it ever ran."), cancellationException);
+            }
+            if (executionException != null) {
+                throw new ExecutionException(executionException);
+            }
+            return returnValue;
+        } finally {
+            lock.unlock();
         }
-        return returnValue;
     }
 
     /**
      * @return true if and only if the task was canceled before it ever executed
      */
     @Override
-    @SuppressWarnings("GuardedByChecker")
     public final boolean isCancelled() {
-        return cancellationException != null;
+        lock.lock();
+        try {
+            return cancellationException != null;
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override
-    @SuppressWarnings("GuardedByChecker")
     public final boolean isDone() {
-        return state == State.COMPLETED;
+        lock.lock();
+        try {
+            return state == State.COMPLETED;
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override

atlasdb-dbkvs/src/main/java/com/palantir/atlasdb/keyvalue/dbkvs/timestamp/InDbTimestampBoundStore.java

@@ -62,8 +62,7 @@ protected String getInitializingClassName() {
     private final PhysicalBoundStoreStrategy physicalBoundStoreStrategy;
     private final InitializingWrapper wrapper = new InitializingWrapper();
 
-    @GuardedBy("this") // lazy init to avoid db connections in constructors
-    private DBType dbType;
+    private volatile DBType dbType;
 
     @GuardedBy("this")
     private Long currentLimit = null;
@@ -131,7 +130,6 @@ private InDbTimestampBoundStore(
         this.physicalBoundStoreStrategy = physicalBoundStoreStrategy;
     }
 
-    @SuppressWarnings("GuardedBy") // TODO (jkong): synchronize?
     private void init() {
         try (Connection conn = connManager.getConnection()) {
             physicalBoundStoreStrategy.createTimestampTable(conn, this::getDbType);
@@ -222,11 +220,17 @@ public synchronized void storeUpperLimit(final long limit) {
         });
     }
 
-    @GuardedBy("this")
     private DBType getDbType(Connection connection) {
-        if (dbType == null) {
-            dbType = ConnectionDbTypes.getDbType(connection);
+        DBType type = this.dbType; // volatile read
+        if (type == null) {
+            synchronized (this) {
+                type = this.dbType;
+                if (type == null) {
+                    type = ConnectionDbTypes.getDbType(connection);
+                    this.dbType = type;
+                }
+            }
         }
-        return dbType;
+        return type;
     }
 }

atlasdb-impl-shared/src/main/java/com/palantir/atlasdb/keyvalue/api/cache/LockWatchValueScopingCacheImpl.java

@@ -244,10 +244,9 @@ private synchronized boolean isNewEvent(LockWatchEvent event) {
                 .orElse(true);
     }
 
-    @SuppressWarnings("GuardedBy") // The stream operation is terminal within this synchronized method.
     private synchronized void assertNoSnapshotsMissing(Multimap<Sequence, StartTimestamp> reversedMap) {
         Set<Sequence> sequences = reversedMap.keySet();
-        if (sequences.stream().map(snapshotStore::getSnapshotForSequence).anyMatch(Optional::isEmpty)) {
+        if (sequences.stream().map(this::getSnapshotForSequence).anyMatch(Optional::isEmpty)) {
             log.warn(
                     "snapshots were not taken for all sequences; logging additional information",
                     SafeArg.of("numSequences", sequences),
@@ -261,6 +260,12 @@ private synchronized void assertNoSnapshotsMissing(Multimap<Sequence, StartTimes
         }
     }
 
+    private Optional<ValueCacheSnapshot> getSnapshotForSequence(Sequence sequence) {
+        synchronized (this) {
+            return snapshotStore.getSnapshotForSequence(sequence);
+        }
+    }
+
     private synchronized void updateCurrentVersion(Optional<LockWatchVersion> maybeUpdateVersion) {
         maybeUpdateVersion
                 .filter(this::shouldUpdateVersion)

atlasdb-service/src/main/java/com/palantir/atlasdb/proto/fork/ForkedJsonFormat.java

@@ -1240,7 +1240,7 @@ private static String escapeText(String input) {
                     break;
                 default:
                     // Check for other control characters
-                    if (c >= 0x0000 && c <= 0x001F) {
+                    if (c <= 0x001F) {
                         appendEscapedUnicode(builder, c);
                     } else if (Character.isHighSurrogate(c)) {
                         // Encode the surrogate pair using 2 six-character sequence (\\uXXXX\\uXXXX)

atlasdb-tests-shared/src/test/java/com/palantir/atlasdb/schema/stream/StreamTest.java

@@ -657,13 +657,15 @@ public void startFirstAndFail(Transaction tx, long streamId) {
             @Override
             public void startSecondAndFinish(Transaction tx, long streamId) {
                 StreamTestStreamStore ss = StreamTestStreamStore.of(txManager, StreamTestTableFactory.of());
-                ss.storeStreams(tx, ImmutableMap.of(streamId, new ByteArrayInputStream(new byte[1])));
+                ss.storeStreams(tx, ImmutableMap.of(streamId, new ByteArrayInputStream(new byte[] {0x42})));
             }
         });
 
         Optional<InputStream> stream = getStream(streamId);
         assertThat(stream).isPresent();
-        assertThat(stream.get()).isNotNull();
+        try (InputStream inputStream = stream.get()) {
+            assertThat(inputStream).isNotNull().hasBinaryContent(new byte[] {0x42});
+        }
     }
 
     @Test

build.gradle

@@ -9,7 +9,7 @@ buildscript {
     dependencies {
         classpath 'com.netflix.nebula:gradle-info-plugin:12.1.6'
         classpath 'com.netflix.nebula:nebula-publishing-plugin:20.3.0'
-        classpath 'com.palantir.baseline:gradle-baseline-java:5.0.0'
+        classpath 'com.palantir.baseline:gradle-baseline-java:5.18.0'
         classpath 'com.palantir.gradle.conjure:gradle-conjure:5.41.0'
         classpath 'com.palantir.gradle.consistentversions:gradle-consistent-versions:2.13.0'
         classpath 'com.palantir.gradle.docker:gradle-docker:0.32.0'

commons-db/src/main/java/com/palantir/nexus/db/sql/SQLString.java

@@ -165,13 +165,15 @@ public static boolean isQueryRegistered(String key) {
      * @param dbType Look for queries registered with this override first
      * @return a SQLString object representing the stored query
      */
-    @SuppressWarnings("GuardedByChecker")
     static FinalSQLString getByKey(final String key, DBType dbType) {
         assert isValidKey(key) : "Keys only consist of word characters"; // $NON-NLS-1$
         assert registeredValues.containsKey(key) || registeredValuesOverride.containsKey(key)
                 : "Couldn't find SQLString key: " + key + ", dbtype " + dbType; // $NON-NLS-1$ //$NON-NLS-2$
 
-        FinalSQLString cached = cachedKeyed.get(key);
+        FinalSQLString cached;
+        synchronized (cacheLock) {
+            cached = cachedKeyed.get(key);
+        }
         if (null != cached) {
             callbackOnUse.noteUse((SQLString) cached.delegate);
             return cached;
@@ -209,7 +211,6 @@ public static boolean isValidKey(final String key) {
      * @param sql The string to be used in a query
      * @return a SQLString object representing the given SQL
      */
-    @SuppressWarnings("GuardedByChecker")
     static FinalSQLString getUnregisteredQuery(String sql) {
         assert !isValidKey(sql) : "Unregistered Queries should not look like keys"; // $NON-NLS-1$
         return new FinalSQLString(new SQLString(sql));
@@ -423,9 +424,10 @@ protected static ImmutableMap<String, FinalSQLString> getCachedUnregistered() {
     @Deprecated
     protected static void setCachedUnregistered(ImmutableMap<String, FinalSQLString> _cachedUnregistered) {}
 
-    @SuppressWarnings("GuardedByChecker")
     protected static ImmutableMap<String, FinalSQLString> getCachedKeyed() {
-        return cachedKeyed;
+        synchronized (cacheLock) {
+            return cachedKeyed;
+        }
     }
 
     protected static void setCachedKeyed(ImmutableMap<String, FinalSQLString> cachedKeyed) {