Add health codes

README.md

@@ -31,7 +31,7 @@ The driver is available from Maven Central, for all modern Java build systems.
 Gradle:
 ```
 dependencies {
-    compile('com.bettercloud:vault-java-driver:4.0.0')
+    compile('com.bettercloud:vault-java-driver:4.1.0')
 }
 ```
 
@@ -249,11 +249,15 @@ Note that changes to the major version (i.e. the first number) represent possibl
 may require modifications in your code to migrate.  Changes to the minor version (i.e. the second number)
 should represent non-breaking changes.  The third number represents any very minor bugfix patches.
 
+* **4.1.0**:  New health code support:
+  * Adds support for the new [Vault health codes](https://www.vaultproject.io/api/system/health.html#parameters)
+
 * **4.0.0**:  This is a breaking-change release, with two primary updates:
   * Adds support for Version 2 of the Key/Value Secrets Engine.  The driver now assumes that your Vault instance uses Version 2 of the 
     Key/Value Secrets Engine across the board.  To configure this, see the [Key/Value Secret Engine Config](#key-value-secret-engine-config) 
     section above.
   * Adds support for the namespaces feature of Vault Enterprise.
+
 * **3.1.0**:  Several updates.
   * Adds support for seal-related operations (i.e. `/sys/seal`, `/sys/unseal`, `/sys/seal-status`).
   * Adds support for the AWS auth backend.

build.gradle

@@ -4,7 +4,7 @@ apply plugin: 'signing'
 
 group 'com.bettercloud'
 archivesBaseName = 'vault-java-driver'
-version '4.0.0'
+version '4.1.0'
 ext.isReleaseVersion = !version.endsWith('SNAPSHOT')
 
 compileJava {

src/main/java/com/bettercloud/vault/SslConfig.java

@@ -452,7 +452,7 @@ public SslConfig build() throws VaultException {
         } else {
             this.verify = true;
         }
-        if (this.verify == true && this.pemUTF8 == null && environmentLoader.loadVariable(VAULT_SSL_CERT) != null) {
+        if (this.verify && this.pemUTF8 == null && environmentLoader.loadVariable(VAULT_SSL_CERT) != null) {
             final File pemFile = new File(environmentLoader.loadVariable(VAULT_SSL_CERT));
             try (final InputStream input = new FileInputStream(pemFile)) {
                 this.pemUTF8 = inputStreamToUTF8(input);
@@ -477,7 +477,7 @@ public SslConfig build() throws VaultException {
      * @throws VaultException
      */
     private void buildSsl() throws VaultException {
-        if (verify == true) {
+        if (verify) {
             if (keyStore != null || trustStore != null) {
                 this.sslContext = buildSslContextFromJks();
             } else if (pemUTF8 != null || clientPemUTF8 != null || clientKeyPemUTF8 != null) {

src/main/java/com/bettercloud/vault/api/Debug.java

@@ -43,7 +43,8 @@ public Debug withNameSpace(final String nameSpace) {
      * health check and provides a simple way to monitor the health of a Vault instance.</p>
      *
      * @return The response information returned from Vault
-     * @throws VaultException If any errors occurs with the REST request (e.g. non-200 status code, invalid JSON payload, etc), and the maximum number of retries is exceeded.
+     * @throws VaultException If any errors occurs with the REST request (e.g. non-200 status code, invalid JSON payload, etc),
+     *                        and the maximum number of retries is exceeded.
      * @see <a href="https://www.vaultproject.io/docs/http/sys-health.html">https://www.vaultproject.io/docs/http/sys-health.html</a>
      *
      * <blockquote>
@@ -58,7 +59,21 @@ public Debug withNameSpace(final String nameSpace) {
      * </blockquote>
      */
     public HealthResponse health() throws VaultException {
-        return health(null, null, null, null);
+        return health(null, null, null, null, null,
+                null, null, null);
+    }
+
+    /**
+     * <p>A deprecated, overloaded version of {@link Debug#health()} that allows for passing one or more of the previous four optional parameters.</p>
+     * Please consider using the new constructor that adds support for perfStandbyOk, drSecondaryCode, etc/
+     */
+    @Deprecated
+    public HealthResponse health(
+            final Boolean standbyOk,
+            final Integer activeCode,
+            final Integer standbyCode,
+            final Integer sealedCode) throws VaultException {
+        return health(standbyOk, activeCode, standbyCode, sealedCode, null, null, null, null);
     }
 
     /**
@@ -71,18 +86,26 @@ public HealthResponse health() throws VaultException {
      * will need to check <code>HealthReponse.getRestResponse().getStatus()</code> to determine the result of
      * the operation.</p>
      *
-     * @param standbyOk   (optional) Indicates that being a standby should still return the active status code instead of the standby code
-     * @param activeCode  (optional) Indicates the status code that should be returned for an active node instead of the default of 200
-     * @param standbyCode (optional) Indicates the status code that should be returned for a standby node instead of the default of 429
-     * @param sealedCode  (optional) Indicates the status code that should be returned for a sealed node instead of the default of 500
+     * @param standbyOk              (optional) Indicates that being a standby should still return the active status code instead of the standby code
+     * @param activeCode             (optional) Indicates the status code that should be returned for an active node instead of the default of 200
+     * @param standbyCode            (optional) Indicates the status code that should be returned for a standby node instead of the default of 429
+     * @param sealedCode             (optional) Indicates the status code that should be returned for a sealed node instead of the default of 500
+     * @param perfStandbyOk          (optional)  Specifies if being a performance standby should still return the active status code instead of the performance standby status code
+     * @param drSecondaryCode        (optional)  Indicates the status code that should be returned for a DR secondary node instead of the default of 472
+     * @param performanceStandbyCode (optional)  Indicates the status code that should be returned for a performance standby node instead of the default of 473
+     * @param unInitCode             (optional)  Indicates the status code that should be returned for an uninitialized node instead of the default of 501
      * @return The response information returned from Vault
      * @throws VaultException If an error occurs or unexpected response received from Vault
      */
     public HealthResponse health(
             final Boolean standbyOk,
             final Integer activeCode,
             final Integer standbyCode,
-            final Integer sealedCode
+            final Integer sealedCode,
+            final Boolean perfStandbyOk,
+            final Integer drSecondaryCode,
+            final Integer performanceStandbyCode,
+            final Integer unInitCode
     ) throws VaultException {
         final String path = "sys/health";
         int retryCount = 0;
@@ -105,19 +128,32 @@ public HealthResponse health(
                 if (activeCode != null) rest.parameter("activecode", activeCode.toString());
                 if (standbyCode != null) rest.parameter("standbycode", standbyCode.toString());
                 if (sealedCode != null) rest.parameter("sealedcode", sealedCode.toString());
+                if (perfStandbyOk != null) rest.parameter("perfstandbyok", perfStandbyOk.toString());
+                if (drSecondaryCode != null) rest.parameter("drsecondarycode", drSecondaryCode.toString());
+                if (performanceStandbyCode != null)
+                    rest.parameter("performancestandbycode", performanceStandbyCode.toString());
+                if (unInitCode != null) rest.parameter("uninitcode", unInitCode.toString());
                 // Execute request
                 final RestResponse restResponse = rest.get();
 
                 // Validate response
                 final Set<Integer> validCodes = new HashSet<>();//NOPMD
                 validCodes.add(200);
                 validCodes.add(429);
+                validCodes.add(472);
+                validCodes.add(473);
                 validCodes.add(500);
+                validCodes.add(501);
+                validCodes.add(503);
                 if (activeCode != null) validCodes.add(activeCode);
                 if (standbyCode != null) validCodes.add(standbyCode);
                 if (sealedCode != null) validCodes.add(sealedCode);
+                if (drSecondaryCode != null) validCodes.add(drSecondaryCode);
+                if (performanceStandbyCode != null) validCodes.add(performanceStandbyCode);
+                if (unInitCode != null) validCodes.add(unInitCode);
                 if (!validCodes.contains(restResponse.getStatus())) {
-                    throw new VaultException("Vault responded with HTTP status code: " + restResponse.getStatus(), restResponse.getStatus());
+                    throw new VaultException("Vault responded with HTTP status code: " + restResponse.getStatus(),
+                            restResponse.getStatus());
                 }
                 return new HealthResponse(restResponse, retryCount);
             } catch (RuntimeException | VaultException | RestException e) {

src/main/java/com/bettercloud/vault/api/Leases.java

@@ -239,7 +239,7 @@ public VaultResponse renew(final String leaseId, final long increment) throws Va
                         .readTimeoutSeconds(config.getReadTimeout())
                         .sslVerification(config.getSslConfig().isVerify())
                         .sslContext(config.getSslConfig().getSslContext())
-                        .post();
+                        .put();
 
                 // Validate response
                 if (restResponse.getStatus() != 200) {

src/main/java/com/bettercloud/vault/json/JsonObject.java

@@ -23,7 +23,6 @@
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
-import java.io.Reader;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;

src/main/java/com/bettercloud/vault/response/AuthResponse.java

@@ -54,7 +54,7 @@ public AuthResponse(final RestResponse restResponse, final int retries) {
             for (final JsonValue authPolicy : authPoliciesJsonArray) {
                 authPolicies.add(authPolicy.asString());
             }
-        } catch (ParseException e) {
+        } catch (ParseException ignored) {
         }
     }
 

src/main/java/com/bettercloud/vault/response/HealthResponse.java

@@ -3,6 +3,7 @@
 import com.bettercloud.vault.VaultException;
 import com.bettercloud.vault.json.Json;
 import com.bettercloud.vault.json.JsonObject;
+import com.bettercloud.vault.json.JsonValue;
 import com.bettercloud.vault.rest.RestResponse;
 
 import java.io.Serializable;
@@ -21,6 +22,9 @@ public class HealthResponse implements Serializable {
     private Boolean sealed;
     private Boolean standby;
     private Long serverTimeUTC;
+    private Boolean performanceStandby;
+    private String replicationPerformanceMode;
+    private String replicationDrMode;
 
     /**
      * <p>Constructs a <code>HealthResponse</code> object from the data received in a health
@@ -34,7 +38,7 @@ public class HealthResponse implements Serializable {
      * {@link com.bettercloud.vault.api.Debug#health(Boolean, Integer, Integer, Integer)}.</p>
      *
      * @param restResponse The raw HTTP response from Vault
-     * @param retries The number of retry attempts that occurred during the API call (can be zero)
+     * @param retries      The number of retry attempts that occurred during the API call (can be zero)
      * @throws VaultException If any error occurs or unexpected response is received from Vault
      */
     public HealthResponse(final RestResponse restResponse, final int retries) throws VaultException {
@@ -59,7 +63,14 @@ public HealthResponse(final RestResponse restResponse, final int retries) throws
                 this.sealed = jsonObject.get("sealed") == null ? null : jsonObject.get("sealed").asBoolean();
                 this.standby = jsonObject.get("standby") == null ? null : jsonObject.get("standby").asBoolean();
                 this.serverTimeUTC = jsonObject.get("server_time_utc") == null ? null : jsonObject.get("server_time_utc").asLong();
-            } catch(final Exception e) {
+                this.performanceStandby = jsonObject.get("performance_standby") == null ? null :
+                        jsonObject.get("performance_standby").asBoolean();
+                this.replicationPerformanceMode = jsonObject.get("replication_performance_mode") == null ? null :
+                        jsonObject.get("replication_performance_mode").asString();
+                this.replicationDrMode = jsonObject.get("replication_dr_mode") == null ? null :
+                        jsonObject.get("replication_dr_mode").asString();
+
+            } catch (final Exception e) {
                 throw new VaultException("Unable to parse JSON payload: " + e, restResponse.getStatus());
             }
         }
@@ -93,4 +104,15 @@ public Long getServerTimeUTC() {
         return serverTimeUTC;
     }
 
+    public Boolean getPerformanceStandby() {
+        return performanceStandby;
+    }
+
+    public String getReplicationPerformanceMode() {
+        return replicationPerformanceMode;
+    }
+
+    public String getReplicationDrMode() {
+        return replicationDrMode;
+    }
 }

src/test-integration/java/com/bettercloud/vault/api/DebugTests.java

@@ -4,6 +4,7 @@
 import com.bettercloud.vault.VaultException;
 import com.bettercloud.vault.response.HealthResponse;
 import com.bettercloud.vault.util.VaultContainer;
+import junit.framework.TestCase;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
@@ -12,6 +13,7 @@
 import java.io.IOException;
 
 import static junit.framework.TestCase.*;
+import static org.junit.Assert.assertNotEquals;
 
 /**
  * <p>Integration tests for the debug-related operations on the Vault HTTP API's.</p>
@@ -44,12 +46,29 @@ public void testHealth_Plain() throws VaultException {
         assertEquals(200, response.getRestResponse().getStatus());
     }
 
+    @Test
+    public void testHealth_Sealed() throws VaultException {
+        vault.seal().seal();
+        final HealthResponse response = vault.debug().health();
+
+        assertTrue(response.getInitialized());
+        assertTrue(response.getSealed());
+        assertTrue(response.getStandby());
+        assertNotNull(response.getServerTimeUTC());
+        assertEquals(503, response.getRestResponse().getStatus());
+        assertFalse(response.getPerformanceStandby());
+        assertNotEquals("disabled", response.getReplicationPerformanceMode());
+        assertNotEquals("disabled", response.getReplicationDrMode());
+        container.getRootVault().seal().unseal(container.getUnsealKey());
+    }
+
     @Test
     public void testHealth_WithParams() throws VaultException {
-        final HealthResponse response = vault.debug().health(null, 212, null, null);
+        final HealthResponse response = vault.debug().health(null, 212, null, null, null, null, null, null);
         assertTrue(response.getInitialized());
         assertFalse(response.getSealed());
         assertFalse(response.getStandby());
+        assertFalse(response.getPerformanceStandby());
         assertNotNull(response.getServerTimeUTC());
         assertEquals(212, response.getRestResponse().getStatus());
     }
@@ -66,11 +85,30 @@ public void testHealth_WithParams() throws VaultException {
     @Test
     public void testHealth_WonkyActiveCode() throws VaultException {
         final HealthResponse response = vault.debug().health(null, 204, null,
-                null);
+                null, null, null, null, null);
         assertNull(response.getInitialized());
         assertNull(response.getSealed());
         assertNull(response.getStandby());
         assertNull(response.getServerTimeUTC());
+        assertNull(response.getPerformanceStandby());
+        assertNull(response.getReplicationDrMode());
+        assertNull(response.getReplicationPerformanceMode());
         assertEquals(204, response.getRestResponse().getStatus());
     }
+
+    @Test
+    public void testHealth_WonkySealedCode() throws VaultException {
+        vault.seal().seal();
+        final HealthResponse response = vault.debug().health(null, null, null,
+                900, null, null, null, null);
+        assertTrue(response.getInitialized());
+        assertTrue(response.getSealed());
+        assertTrue(response.getStandby());
+        assertNotNull(response.getServerTimeUTC());
+        assertFalse(response.getPerformanceStandby());
+        assertNotNull(response.getReplicationDrMode());
+        assertNotNull(response.getReplicationPerformanceMode());
+        assertEquals(900, response.getRestResponse().getStatus());
+        container.getRootVault().seal().unseal(container.getUnsealKey());
+    }
 }

src/test/java/com/bettercloud/vault/RetryTests.java

@@ -9,7 +9,6 @@
 import java.util.HashMap;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 /**
  * <p>Unit tests for the Vault driver, having no dependency on an actual Vault server instance being available.  The

src/test/java/com/bettercloud/vault/VaultConfigTests.java

@@ -72,7 +72,7 @@ public String loadVariable(final String name) {
                     try {
                         final byte[] bytes = Files.readAllBytes(Paths.get(mockHomeDirectory).resolve(".vault-token"));
                         value = new String(bytes, StandardCharsets.UTF_8).trim();
-                    } catch (IOException e) {
+                    } catch (IOException ignored) {
                     }
                 }
             } else {
@@ -154,8 +154,8 @@ public void testConfigBuilder_LoadFromEnv() throws VaultException {
         assertEquals("http://127.0.0.1:8200", config.getAddress());
         assertEquals("c24e2469-298a-6c64-6a71-5b47c9ba459a", config.getToken());
         assertTrue(config.getSslConfig().isVerify());
-        assertTrue(30 == config.getOpenTimeout());
-        assertTrue(30 == config.getReadTimeout());
+        assertEquals(30, (int) config.getOpenTimeout());
+        assertEquals(30, (int) config.getReadTimeout());
     }
 
     @Test

src/test/java/com/bettercloud/vault/api/pki/CredentialTests.java

@@ -1,6 +1,5 @@
 package com.bettercloud.vault.api.pki;
 
-import com.bettercloud.vault.api.pki.Credential;
 import org.junit.Assert;
 import org.junit.Test;
 

src/test/java/com/bettercloud/vault/api/pki/RoleOptionsTests.java

@@ -12,7 +12,7 @@ public void RoleOptionsTests() {
         RoleOptions roleOptions = new RoleOptions();
         Assert.assertNotNull(roleOptions);
 
-        Assert.assertEquals(roleOptions.getAllowedDomains(), null);
+        Assert.assertNull(roleOptions.getAllowedDomains());
 
         roleOptions.allowAnyName(true);
         roleOptions.allowBareDomains(true);

src/test/java/com/bettercloud/vault/json/JsonArray_Test.java

@@ -21,13 +21,11 @@
  ******************************************************************************/
 package com.bettercloud.vault.json;
 
-import static com.bettercloud.vault.json.TestUtil.assertException;
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 
 import java.io.IOException;
-import java.io.StringReader;
 import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.List;

src/test/java/com/bettercloud/vault/json/JsonNumber_Test.java

@@ -45,11 +45,7 @@ public void setUp() {
 
     @Test
     public void constructor_failsWithNull() {
-        TestUtil.assertException(NullPointerException.class, "string is null", new Runnable() {
-            public void run() {
-                new JsonNumber(null);
-            }
-        });
+        TestUtil.assertException(NullPointerException.class, "string is null", (Runnable) () -> new JsonNumber(null));
     }
 
     @Test