ABR12: AllNodesDisabledNamespacesUpdater

leader-election-api/build.gradle

@@ -17,7 +17,6 @@ dependencies {
   implementation 'com.palantir.safe-logging:safe-logging'
   implementation project(':commons-annotations')
 
-
   annotationProcessor group: 'org.immutables', name: 'value'
   compileOnly 'org.immutables:value::annotations'
 }

leader-election-impl/src/main/java/com/palantir/paxos/PaxosQuorumChecker.java

@@ -65,6 +65,25 @@ private PaxosQuorumChecker() {
         // Private constructor. Disallow instantiation.
     }
 
+    public static <SERVICE, RESPONSE extends PaxosResponse>
+            PaxosResponsesWithRemote<SERVICE, RESPONSE> collectAllResponses(
+                    ImmutableList<SERVICE> remotes,
+                    Function<SERVICE, RESPONSE> request,
+                    Map<? extends SERVICE, CheckedRejectionExecutorService> executors,
+                    Duration remoteRequestTimeout,
+                    boolean cancelRemainingCalls) {
+        Preconditions.checkState(
+                executors.keySet().equals(new HashSet<>(remotes)), "Each remote should have an executor.");
+        return collectResponses(
+                remotes,
+                request,
+                remotes.size(), // wait until all responses have been received
+                remoteRequestTimeout,
+                _unused -> false, // never abort early
+                cancelRemainingCalls,
+                MultiplexingCompletionService.createFromCheckedExecutors(executors));
+    }
+
     /**
      * Collects a list of responses from a quorum of remote services.
      * This method short-circuits if a quorum can no longer be obtained (if too many servers have sent nacks), and

timelock-api/build.gradle

@@ -9,10 +9,21 @@ conjure {
     }
 }
 
+dependencies {
+    implementation project(':leader-election-api')
+
+    compileOnly 'com.fasterxml.jackson.core:jackson-databind'
+    compileOnly 'org.immutables:value::annotations'
+    annotationProcessor group: 'org.immutables', name: 'value'
+}
+
 subprojects {
     apply from: "../../gradle/shared.gradle"
     dependencies {
         compile project(':lock-api-objects')
+        compile project(':timelock-api')
+        implementation project(':leader-election-api')
+
         compile 'com.palantir.conjure.java:conjure-lib'
 
         implementation 'com.fasterxml.jackson.core:jackson-annotations'

timelock-api/src/main/conjure/timelock-api.yml

@@ -4,6 +4,10 @@ types:
       base-type: any
       external:
         java: com.palantir.lock.v2.LeaderTime
+    Namespace:
+      base-type: string
+      external:
+        java: com.palantir.atlasdb.timelock.api.Namespace
     NanoTime:
       base-type: safelong
       external:
@@ -114,8 +118,6 @@ types:
       LockWatchRequest:
         fields:
           references: set<LockWatchReference>
-      Namespace:
-        alias: string
       LeaderTimes:
         fields:
           leaderTimes: map<Namespace, LeaderTime>

timelock-api/src/main/conjure/timelock-management-api.yml

@@ -1,28 +1,30 @@
 types:
   conjure-imports:
     api: timelock-api.yml
+  imports:
+    SingleNodeUpdateResponse:
+      external:
+        java: com.palantir.atlasdb.timelock.api.SingleNodeUpdateResponse
   definitions:
     default-package: com.palantir.atlasdb.timelock.api
     objects:
       DisableNamespacesRequest:
         fields:
           namespaces: set<api.Namespace>
           lockId: uuid
-      SingleNodeUpdateResponse:
-        fields:
-          wasSuccessful: boolean
-          # other namespaces will not have been disabled/re-enabled (the transaction will not complete)
-          lockedNamespaces: map<api.Namespace, uuid>
       SuccessfulDisableNamespacesResponse:
         fields:
           lockId: uuid
       UnsuccessfulDisableNamespacesResponse:
         fields:
-          # we can assume another restore is in progress for this namespace
-          consistentlyDisabledNamespaces: set<api.Namespace>
-          # either another restore is in progress for this namespace (and we've hit a race condition), or
-          # the namespace is stuck and needs to be manually fixed.
-          partiallyDisabledNamespaces: set<api.Namespace>
+          consistentlyDisabledNamespaces:
+            type: set<api.Namespace>
+            docs: Namespaces where we can assume another restore is in progress
+          partiallyDisabledNamespaces:
+            type: set<api.Namespace>
+            docs: |
+              Either another restore is in progress for this namespace (and we've hit a race condition), or
+              the namespace is stuck and needs to be manually fixed.
       DisableNamespacesResponse:
         union:
           successful: SuccessfulDisableNamespacesResponse
@@ -35,11 +37,14 @@ types:
         alias: boolean
       UnsuccessfulReenableNamespacesResponse:
         fields:
-          # we can assume another restore is in progress for this namespace (we lost our lock)
-          consistentlyLockedNamespaces: set<api.Namespace>
-          # either another restore is in progress for this namespace (and we lost our lock), or
-          # the namespace is stuck and needs to be manually fixed.
-          partiallyLockedNamespaces: set<api.Namespace>
+          consistentlyLockedNamespaces:
+            type: set<api.Namespace>
+            docs: We can assume another restore is in progress for this namespace (we lost our lock)
+          partiallyLockedNamespaces:
+            type: set<api.Namespace>
+            docs: |
+              Either another restore is in progress for this namespace (and we lost our lock), or
+              the namespace is stuck and needs to be manually fixed.
       ReenableNamespacesResponse:
         union:
           successful: SuccessfulReenableNamespacesResponse

timelock-api/src/main/java/com/palantir/atlasdb/timelock/api/Namespace.java

@@ -0,0 +1,43 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.atlasdb.timelock.api;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.immutables.value.Value;
+
+@JsonDeserialize(as = ImmutableNamespace.class)
+@JsonSerialize(as = ImmutableNamespace.class)
+@Value.Immutable
+public interface Namespace {
+    @JsonValue
+    String value();
+
+    // For back-compatibility with conjure-generated Namespace
+    default String get() {
+        return value();
+    }
+
+    static Namespace valueOf(String value) {
+        return of(value);
+    }
+
+    static Namespace of(String value) {
+        return ImmutableNamespace.builder().value(value).build();
+    }
+}

timelock-api/src/main/java/com/palantir/atlasdb/timelock/api/SingleNodeUpdateResponse.java

@@ -0,0 +1,45 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.atlasdb.timelock.api;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.palantir.paxos.PaxosResponse;
+import java.util.Map;
+import java.util.UUID;
+import org.immutables.value.Value;
+
+@JsonDeserialize(as = ImmutableSingleNodeUpdateResponse.class)
+@JsonSerialize(as = ImmutableSingleNodeUpdateResponse.class)
+@Value.Immutable
+public interface SingleNodeUpdateResponse extends PaxosResponse {
+    /**
+     * other namespaces will not have been disabled/re-enabled (the transaction will not complete).
+     */
+    Map<Namespace, UUID> lockedNamespaces();
+
+    static SingleNodeUpdateResponse successful() {
+        return ImmutableSingleNodeUpdateResponse.builder().isSuccessful(true).build();
+    }
+
+    static SingleNodeUpdateResponse failed(Map<Namespace, UUID> lockedNamespaces) {
+        return ImmutableSingleNodeUpdateResponse.builder()
+                .isSuccessful(false)
+                .lockedNamespaces(lockedNamespaces)
+                .build();
+    }
+}

timelock-impl/build.gradle

@@ -8,6 +8,7 @@ dependencies {
     compile project(":lock-conjure-api:lock-conjure-api-undertow")
     compile project(":lock-conjure-api:lock-conjure-api-jersey")
     compile project(":lock-impl")
+    compile project(':timelock-api')
     compile project(':timelock-api:timelock-api-undertow')
     compile project(':timelock-api:timelock-api-jersey')
     compile project(":leader-election-impl")

timelock-impl/src/main/java/com/palantir/atlasdb/timelock/TimelockNamespaces.java

@@ -129,17 +129,13 @@ public void invalidateResourcesForClient(String namespace) {
         }
     }
 
-    public Map<Namespace, UUID> getIncorrectlyLockedNamespaces(Set<Namespace> namespaces, UUID expectedLockId) {
-        log.info(
-                "Reading namespace state locally",
-                SafeArg.of("namespaces", namespaces),
-                SafeArg.of("expectedLockId", expectedLockId));
-        return disabledNamespaces.getIncorrectlyLockedNamespaces(namespaces, expectedLockId);
+    public Map<Namespace, UUID> getNamespacesLockedWithDifferentLockId(Set<Namespace> namespaces, UUID expectedLockId) {
+        return disabledNamespaces.getNamespacesLockedWithDifferentLockId(namespaces, expectedLockId);
     }
 
     public SingleNodeUpdateResponse disable(DisableNamespacesRequest request) {
         SingleNodeUpdateResponse response = disabledNamespaces.disable(request);
-        if (response.getWasSuccessful()) {
+        if (response.isSuccessful()) {
             request.getNamespaces().stream().map(Namespace::get).forEach(this::invalidateResourcesForClient);
         } else {
             log.info(