Feature/qos service api

atlasdb-api/build.gradle

@@ -6,13 +6,15 @@ apply from: "../gradle/shared.gradle"
 dependencies {
   compile project(":atlasdb-commons")
   compile project(":timestamp-api")
-  compile 'javax.ws.rs:javax.ws.rs-api:2.0.1'
+  compile project(":qos-service-api")
+  compile group: 'javax.ws.rs', name: 'javax.ws.rs-api'
   compile group: 'org.apache.commons', name: 'commons-lang3'
   compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations'
   compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind'
   compile group: 'javax.validation', name: 'validation-api'
 
   compile group: 'com.palantir.remoting-api', name: 'ssl-config'
+  compile group: 'com.palantir.remoting3', name: 'jaxrs-clients'
 
   processor group: 'org.immutables', name: 'value'
 

atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/ClusterAvailabilityStatus.java

@@ -16,8 +16,18 @@
 package com.palantir.atlasdb.keyvalue.api;
 
 public enum ClusterAvailabilityStatus {
-    TERMINAL,
-    NO_QUORUM_AVAILABLE,
-    QUORUM_AVAILABLE,
-    ALL_AVAILABLE
+    TERMINAL(false),
+    NO_QUORUM_AVAILABLE(false),
+    QUORUM_AVAILABLE(false),
+    ALL_AVAILABLE(true);
+
+    private final boolean isHealthy;
+
+    ClusterAvailabilityStatus(boolean isHealthy) {
+        this.isHealthy = isHealthy;
+    }
+
+    public boolean isHealthy() {
+        return isHealthy;
+    }
 }

atlasdb-api/src/main/java/com/palantir/atlasdb/keyvalue/api/KeyValueService.java

@@ -29,6 +29,7 @@
 import javax.ws.rs.core.MediaType;
 
 import com.google.common.collect.Multimap;
+import com.palantir.atlasdb.transaction.api.TransactionManager;
 import com.palantir.common.annotation.Idempotent;
 import com.palantir.common.annotation.NonIdempotent;
 import com.palantir.common.base.ClosableIterator;
@@ -655,8 +656,16 @@ Multimap<Cell, Long> getAllTimestamps(@QueryParam("tableName") TableReference ta
     void compactInternally(TableReference tableRef);
 
     /**
-     * Checks if the KVS has a quorum available to successfully perform reads/writes.
-     *
+     * Provides a {@link ClusterAvailabilityStatus}, indicating the current availability of the key value store.
+     * This can be used to infer product health - in the usual, conservative case, products can call
+     * {@link ClusterAvailabilityStatus#isHealthy()}, which returns true only if all KVS nodes are up.
+     * <p>
+     * Products that use AtlasDB only for reads and writes (no schema mutations or deletes, including having sweep and
+     * scrub disabled) can also treat {@link ClusterAvailabilityStatus#QUORUM_AVAILABLE} as healthy.
+     * <p>
+     * If you have access to a {@link com.palantir.atlasdb.transaction.api.TransactionManager}, then it is recommended
+     * to use its availability indicator, {@link TransactionManager#getKeyValueServiceStatus()}, instead of this one.
+     * <p>
      * This call must be implemented so that it completes synchronously.
      */
     @POST

atlasdb-api/src/main/java/com/palantir/atlasdb/spi/AtlasDbFactory.java

@@ -23,6 +23,8 @@
 import com.palantir.atlasdb.config.LeaderConfig;
 import com.palantir.atlasdb.keyvalue.api.KeyValueService;
 import com.palantir.atlasdb.keyvalue.api.TableReference;
+import com.palantir.atlasdb.qos.FakeQosClient;
+import com.palantir.atlasdb.qos.QosClient;
 import com.palantir.timestamp.TimestampService;
 import com.palantir.timestamp.TimestampStoreInvalidator;
 
@@ -34,7 +36,8 @@ public interface AtlasDbFactory {
 
     default KeyValueService createRawKeyValueService(
             KeyValueServiceConfig config, Optional<LeaderConfig> leaderConfig) {
-        return createRawKeyValueService(config, leaderConfig, Optional.empty(), DEFAULT_INITIALIZE_ASYNC);
+        return createRawKeyValueService(config, leaderConfig, Optional.empty(), DEFAULT_INITIALIZE_ASYNC,
+                FakeQosClient.INSTANCE);
     }
 
     /**
@@ -46,13 +49,15 @@ default KeyValueService createRawKeyValueService(
      * absent. If both are present, they must match.
      * @param initializeAsync If the implementations supports it, and initializeAsync is true, the KVS will initialize
      * asynchronously when synchronous initialization fails.
+     * @param qosClient the client for checking limits from the Quality-of-Service service.
      * @return The requested KeyValueService instance
      */
     KeyValueService createRawKeyValueService(
             KeyValueServiceConfig config,
             Optional<LeaderConfig> leaderConfig,
             Optional<String> namespace,
-            boolean initializeAsync);
+            boolean initializeAsync,
+            QosClient qosClient);
 
     default TimestampService createTimestampService(KeyValueService rawKvs) {
         return createTimestampService(rawKvs, Optional.empty(), DEFAULT_INITIALIZE_ASYNC);

atlasdb-api/src/main/java/com/palantir/atlasdb/transaction/api/KeyValueServiceStatus.java

@@ -16,8 +16,18 @@
 package com.palantir.atlasdb.transaction.api;
 
 public enum KeyValueServiceStatus {
-    TERMINAL,
-    UNHEALTHY,
-    HEALTHY_BUT_NO_SCHEMA_MUTATIONS_OR_DELETES,
-    HEALTHY_ALL_OPERATIONS
+    TERMINAL(false),
+    UNHEALTHY(false),
+    HEALTHY_BUT_NO_SCHEMA_MUTATIONS_OR_DELETES(false),
+    HEALTHY_ALL_OPERATIONS(true);
+
+    private final boolean isHealthy;
+
+    KeyValueServiceStatus(boolean isHealthy) {
+        this.isHealthy = isHealthy;
+    }
+
+    public boolean isHealthy() {
+        return isHealthy;
+    }
 }

atlasdb-api/src/main/java/com/palantir/atlasdb/transaction/api/TransactionManager.java

@@ -126,9 +126,15 @@ <T, E extends Exception> T runTaskThrowOnConflict(TransactionTask<T, E> task)
     long getImmutableTimestamp();
 
     /**
-     * Return the {@link KeyValueServiceStatus} depending on the availability of the underlying key-value store.
-     *
-     * @return status of the key value service, can be used by the application to decide its own health
+     * Provides a {@link KeyValueServiceStatus}, indicating the current availability of the key value store.
+     * This can be used to infer product health - in the usual, conservative case, products can call
+     * {@link KeyValueServiceStatus#isHealthy()}, which returns true only if all KVS nodes are up.
+     * <p>
+     * Products that use AtlasDB only for reads and writes (no schema mutations or deletes, including having sweep and
+     * scrub disabled) can also treat {@link KeyValueServiceStatus#HEALTHY_BUT_NO_SCHEMA_MUTATIONS_OR_DELETES} as
+     * healthy.
+     * <p>
+     * This call must be implemented so that it completes synchronously.
      */
     KeyValueServiceStatus getKeyValueServiceStatus();
 

atlasdb-api/src/test/java/com/palantir/atlasdb/keyvalue/api/ClusterAvailabilityStatusTest.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2017 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the BSD-3 License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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.keyvalue.api;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class ClusterAvailabilityStatusTest {
+    @Test
+    public void allAvailableMeansHealthy() {
+        assertTrue(ClusterAvailabilityStatus.ALL_AVAILABLE.isHealthy());
+    }
+
+    @Test
+    public void quorumAvailableMeansNotHealthy() {
+        assertFalse(ClusterAvailabilityStatus.QUORUM_AVAILABLE.isHealthy());
+    }
+
+    @Test
+    public void noQuorumMeansNotHealthy() {
+        assertFalse(ClusterAvailabilityStatus.NO_QUORUM_AVAILABLE.isHealthy());
+    }
+
+    @Test
+    public void terminalMeansNotHealthy() {
+        assertFalse(ClusterAvailabilityStatus.TERMINAL.isHealthy());
+    }
+}

atlasdb-api/src/test/java/com/palantir/atlasdb/transaction/api/KeyValueServiceStatusTest.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2017 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the BSD-3 License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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.transaction.api;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class KeyValueServiceStatusTest {
+    @Test
+    public void allOperationsMeansHealthy() {
+        assertTrue(KeyValueServiceStatus.HEALTHY_ALL_OPERATIONS.isHealthy());
+    }
+    @Test
+    public void mostOperationsMeansNotHealthy() {
+        assertFalse(KeyValueServiceStatus.HEALTHY_BUT_NO_SCHEMA_MUTATIONS_OR_DELETES.isHealthy());
+    }
+
+    @Test
+    public void unhealthyMeansNotHealthy() { // well, obviously
+        assertFalse(KeyValueServiceStatus.UNHEALTHY.isHealthy());
+    }
+
+    @Test
+    public void terminalMeansNotHealthy() {
+        assertFalse(KeyValueServiceStatus.TERMINAL.isHealthy());
+    }
+}