Merge pull request #1773 from marklogic/feature/21476-rename-auth-cloud

MLE-21476 Deprecates MarkLogicCloudAuthContext

Author: rjrudin

gradle.properties

@@ -11,7 +11,7 @@ mlPassword=admin
 # Whether tests should run with the expectation that they'll use a basePath and talk to a reverse proxy server
 testUseReverseProxyServer=false
 
-# For testing cloud-based authentication; define in gradle-local.properties with valid values for a MarkLogic Cloud instance
+# For testing cloud-based authentication; define in gradle-local.properties with valid values for a Progress Data Cloud instance
 cloudHost=
 cloudKey=
 cloudBasePath=

marklogic-client-api/build.gradle

@@ -202,7 +202,7 @@ task testRows(type: Test) {
 }
 
 task debugCloudAuth(type: JavaExec) {
-	description = "Test program for manual testing of cloud-based authentication against a MarkLogic Cloud instance"
+	description = "Test program for manual testing of cloud-based authentication against a Progress Data Cloud instance"
 	main = 'com.marklogic.client.test.MarkLogicCloudAuthenticationDebugger'
 	classpath = sourceSets.test.runtimeClasspath
 	args = [cloudHost, cloudKey, cloudBasePath]

marklogic-client-api/src/main/java/com/marklogic/client/DatabaseClientFactory.java

@@ -350,52 +350,113 @@ public SecurityContext withSSLContext(SSLContext context, X509TrustManager trust
 
 	/**
 	 * @since 6.1.0
+	 * @deprecated as of 7.2.0; use {@code ProgressDataCloudAuthContext} instead. Will be removed in 8.0.0.
 	 */
-	public static class MarkLogicCloudAuthContext extends AuthContext {
+	@Deprecated
+	public static class MarkLogicCloudAuthContext extends ProgressDataCloudAuthContext {
+
+		/**
+		 * @param apiKey user's API key for accessing Progress Data Cloud
+		 */
+		public MarkLogicCloudAuthContext(String apiKey) {
+			super(apiKey);
+		}
+
+		/**
+		 * @param apiKey user's API key for accessing Progress Data Cloud
+		 * @param tokenDuration length in minutes until the generated access token expires
+		 * @since 6.3.0
+		 */
+		public MarkLogicCloudAuthContext(String apiKey, Integer tokenDuration) {
+			super(apiKey, tokenDuration);
+		}
+
+		/**
+		 * Only intended to be used in the scenario that the token endpoint of "/token" and the grant type of "apikey"
+		 * are not the intended values.
+		 *
+		 * @param apiKey user's API key for accessing Progress Data Cloud
+		 * @param tokenEndpoint for overriding the default token endpoint if necessary
+		 * @param grantType for overriding the default grant type if necessary
+		 */
+		public MarkLogicCloudAuthContext(String apiKey, String tokenEndpoint, String grantType) {
+			super(apiKey, tokenEndpoint, grantType);
+		}
+
+		/**
+		 * Only intended to be used in the scenario that the token endpoint of "/token" and the grant type of "apikey"
+		 * are not the intended values.
+		 *
+		 * @param apiKey user's API key for accessing Progress Data Cloud
+		 * @param tokenEndpoint for overriding the default token endpoint if necessary
+		 * @param grantType for overriding the default grant type if necessary
+		 * @param tokenDuration length in minutes until the generated access token expires
+		 * @since 6.3.0
+		 */
+		public MarkLogicCloudAuthContext(String apiKey, String tokenEndpoint, String grantType, Integer tokenDuration) {
+			super(apiKey, tokenEndpoint, grantType, tokenDuration);
+		}
+
+		@Override
+		public MarkLogicCloudAuthContext withSSLContext(SSLContext context, X509TrustManager trustManager) {
+			this.sslContext = context;
+			this.trustManager = trustManager;
+			return this;
+		}
+
+		@Override
+		public MarkLogicCloudAuthContext withSSLHostnameVerifier(SSLHostnameVerifier verifier) {
+			this.sslVerifier = verifier;
+			return this;
+		}
+	}
+
+	/**
+	 * @since 7.2.0 Use this instead of the now-deprecated {@code MarkLogicCloudAuthContext}
+	 */
+	public static class ProgressDataCloudAuthContext extends AuthContext {
 		private String tokenEndpoint;
 		private String grantType;
 		private String apiKey;
 		private Integer tokenDuration;
 
 		/**
-		 * @param apiKey user's API key for accessing MarkLogic Cloud
+		 * @param apiKey user's API key for accessing Progress Data Cloud
 		 */
-		public MarkLogicCloudAuthContext(String apiKey) {
+		public ProgressDataCloudAuthContext(String apiKey) {
 			this(apiKey, null);
 		}
 
 		/**
-		 * @param apiKey user's API key for accessing MarkLogic Cloud
+		 * @param apiKey user's API key for accessing Progress Data Cloud
 		 * @param tokenDuration length in minutes until the generated access token expires
-		 * @since 6.3.0
 		 */
-		public MarkLogicCloudAuthContext(String apiKey, Integer tokenDuration) {
+		public ProgressDataCloudAuthContext(String apiKey, Integer tokenDuration) {
 			this(apiKey, "/token", "apikey", tokenDuration);
 		}
 
 		/**
 		 * Only intended to be used in the scenario that the token endpoint of "/token" and the grant type of "apikey"
 		 * are not the intended values.
 		 *
-		 * @param apiKey user's API key for accessing MarkLogic Cloud
+		 * @param apiKey user's API key for accessing Progress Data Cloud
 		 * @param tokenEndpoint for overriding the default token endpoint if necessary
 		 * @param grantType for overriding the default grant type if necessary
 		 */
-		public MarkLogicCloudAuthContext(String apiKey, String tokenEndpoint, String grantType) {
+		public ProgressDataCloudAuthContext(String apiKey, String tokenEndpoint, String grantType) {
 			this(apiKey, tokenEndpoint, grantType, null);
 		}
 
 		/**
 		 * Only intended to be used in the scenario that the token endpoint of "/token" and the grant type of "apikey"
 		 * are not the intended values.
 		 *
-		 * @param apiKey user's API key for accessing MarkLogic Cloud
+		 * @param apiKey user's API key for accessing Progress Data Cloud
 		 * @param tokenEndpoint for overriding the default token endpoint if necessary
 		 * @param grantType for overriding the default grant type if necessary
 		 * @param tokenDuration length in minutes until the generated access token expires
-		 * @since 6.3.0
 		 */
-		public MarkLogicCloudAuthContext(String apiKey, String tokenEndpoint, String grantType, Integer tokenDuration) {
+		public ProgressDataCloudAuthContext(String apiKey, String tokenEndpoint, String grantType, Integer tokenDuration) {
 			this.apiKey = apiKey;
 			this.tokenEndpoint = tokenEndpoint;
 			this.grantType = grantType;
@@ -414,23 +475,19 @@ public String getApiKey() {
 			return apiKey;
 		}
 
-		/**
-		 * @return
-		 * @since 6.3.0
-		 */
 		public Integer getTokenDuration() {
 			return tokenDuration;
 		}
 
 		@Override
-		public MarkLogicCloudAuthContext withSSLContext(SSLContext context, X509TrustManager trustManager) {
+		public ProgressDataCloudAuthContext withSSLContext(SSLContext context, X509TrustManager trustManager) {
 			this.sslContext = context;
 			this.trustManager = trustManager;
 			return this;
 		}
 
 		@Override
-		public MarkLogicCloudAuthContext withSSLHostnameVerifier(SSLHostnameVerifier verifier) {
+		public ProgressDataCloudAuthContext withSSLHostnameVerifier(SSLHostnameVerifier verifier) {
 			this.sslVerifier = verifier;
 			return this;
 		}
@@ -1277,10 +1334,10 @@ static public DatabaseClient newClient(String host, int port, String basePath, S
                                          DatabaseClient.ConnectionType connectionType) {
       RESTServices services = new OkHttpServices();
 	  // As of 6.1.0, the following optimization is made as it's guaranteed that if the user is connecting to a
-	  // MarkLogic Cloud instance, then port 443 will be used. Every path for constructing a DatabaseClient goes through
+	  // Progress Data Cloud instance, then port 443 will be used. Every path for constructing a DatabaseClient goes through
 	  // this method, ensuring that this optimization will always be applied, and thus freeing the user from having to
-	  // worry about what port to configure when using MarkLogic Cloud.
-	  if (securityContext instanceof MarkLogicCloudAuthContext) {
+	  // worry about what port to configure when using Progress Data Cloud.
+	  if (securityContext instanceof MarkLogicCloudAuthContext || securityContext instanceof ProgressDataCloudAuthContext) {
 		  port = 443;
 	  }
       services.connect(host, port, basePath, database, securityContext);

marklogic-client-api/src/main/java/com/marklogic/client/impl/DatabaseClientPropertySource.java

@@ -259,7 +259,7 @@ private DatabaseClientFactory.SecurityContext newCloudAuthContext() {
 				throw new IllegalArgumentException("Cloud token duration must be numeric");
 			}
 		}
-		return new DatabaseClientFactory.MarkLogicCloudAuthContext(apiKey, duration);
+		return new DatabaseClientFactory.ProgressDataCloudAuthContext(apiKey, duration);
 	}
 
 	private DatabaseClientFactory.SecurityContext newCertificateAuthContext(SSLUtil.SSLInputs sslInputs, String sslProtocol) {
@@ -315,7 +315,7 @@ private DatabaseClientFactory.SSLHostnameVerifier determineHostnameVerifier() {
 	 * Uses the given propertySource to construct the inputs pertaining to constructing an SSLContext and an
 	 * X509TrustManager.
 	 *
-	 * @param authType used for applying "default" as the SSL protocol for MarkLogic cloud authentication in
+	 * @param authType used for applying "default" as the SSL protocol for Progress Data Cloud authentication in
 	 *                 case the user does not define their own SSLContext or SSL protocol
 	 * @return
 	 */
@@ -398,8 +398,8 @@ private String getSSLProtocol(String authType) {
 		if (sslProtocol != null) {
 			sslProtocol = sslProtocol.trim();
 		}
-		// For convenience for MarkLogic Cloud users, assume the JVM's default SSLContext should trust the certificate
-		// used by MarkLogic Cloud. A user can always override this default behavior by providing their own SSLContext.
+		// For convenience for Progress Data Cloud users, assume the JVM's default SSLContext should trust the certificate
+		// used by Progress Data Cloud. A user can always override this default behavior by providing their own SSLContext.
 		if ((sslProtocol == null || sslProtocol.length() == 0) && DatabaseClientBuilder.AUTH_TYPE_MARKLOGIC_CLOUD.equalsIgnoreCase(authType)) {
 			sslProtocol = "default";
 		}

marklogic-client-api/src/main/java/com/marklogic/client/impl/okhttp/OkHttpUtil.java

@@ -54,8 +54,9 @@ public static OkHttpClient.Builder newOkHttpClientBuilder(String host, DatabaseC
 		} else if (securityContext instanceof DatabaseClientFactory.CertificateAuthContext) {
 		} else if (securityContext instanceof DatabaseClientFactory.SAMLAuthContext) {
 			configureSAMLAuth((DatabaseClientFactory.SAMLAuthContext) securityContext, clientBuilder);
-		} else if (securityContext instanceof DatabaseClientFactory.MarkLogicCloudAuthContext) {
-			authenticationConfigurer = new MarkLogicCloudAuthenticationConfigurer(host);
+		} else if (securityContext instanceof DatabaseClientFactory.ProgressDataCloudAuthContext ||
+			securityContext instanceof DatabaseClientFactory.MarkLogicCloudAuthContext) {
+			authenticationConfigurer = new ProgressDataCloudAuthenticationConfigurer(host);
 		} else if (securityContext instanceof DatabaseClientFactory.OAuthContext) {
 			authenticationConfigurer = new OAuthAuthenticationConfigurer();
 		} else {

marklogic-client-api/src/main/java/com/marklogic/client/impl/okhttp/MarkLogicCloudAuthenticationConfigurer.java renamed to marklogic-client-api/src/main/java/com/marklogic/client/impl/okhttp/ProgressDataCloudAuthenticationConfigurer.java

@@ -5,23 +5,23 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.marklogic.client.DatabaseClientFactory.MarkLogicCloudAuthContext;
+import com.marklogic.client.DatabaseClientFactory;
 import okhttp3.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 
-class MarkLogicCloudAuthenticationConfigurer implements AuthenticationConfigurer<MarkLogicCloudAuthContext> {
+class ProgressDataCloudAuthenticationConfigurer implements AuthenticationConfigurer<DatabaseClientFactory.ProgressDataCloudAuthContext> {
 
-	private String host;
+	private final String host;
 
-	MarkLogicCloudAuthenticationConfigurer(String host) {
+	ProgressDataCloudAuthenticationConfigurer(String host) {
 		this.host = host;
 	}
 
 	@Override
-	public void configureAuthentication(OkHttpClient.Builder clientBuilder, MarkLogicCloudAuthContext securityContext) {
+	public void configureAuthentication(OkHttpClient.Builder clientBuilder, DatabaseClientFactory.ProgressDataCloudAuthContext securityContext) {
 		final String apiKey = securityContext.getApiKey();
 		if (apiKey == null || apiKey.trim().length() < 1) {
 			throw new IllegalArgumentException("No API key provided");
@@ -38,16 +38,16 @@ public interface TokenGenerator {
 	}
 
 	/**
-	 * Knows how to call the "/token" endpoint in MarkLogic Cloud to generate a new token based on the
+	 * Knows how to call the "/token" endpoint in Progress Data Cloud to generate a new token based on the
 	 * user-provided API key.
 	 */
 	static class DefaultTokenGenerator implements TokenGenerator {
 
 		private final static Logger logger = LoggerFactory.getLogger(DefaultTokenGenerator.class);
-		private String host;
-		private MarkLogicCloudAuthContext securityContext;
+		private final String host;
+		private final DatabaseClientFactory.ProgressDataCloudAuthContext securityContext;
 
-		public DefaultTokenGenerator(String host, MarkLogicCloudAuthContext securityContext) {
+		public DefaultTokenGenerator(String host, DatabaseClientFactory.ProgressDataCloudAuthContext securityContext) {
 			this.host = host;
 			this.securityContext = securityContext;
 		}
@@ -65,7 +65,7 @@ private Response callTokenEndpoint() {
 			final HttpUrl tokenUrl = buildTokenUrl();
 			OkHttpClient.Builder clientBuilder = OkHttpUtil.newClientBuilder();
 			// Current assumption is that the SSL config provided for connecting to MarkLogic should also be applicable
-			// for connecting to MarkLogic Cloud's "/token" endpoint.
+			// for connecting to Progress Data Cloud's "/token" endpoint.
 			OkHttpUtil.configureSocketFactory(clientBuilder, securityContext.getSSLContext(), securityContext.getTrustManager());
 			OkHttpUtil.configureHostnameVerifier(clientBuilder, securityContext.getSSLHostnameVerifier());
 
@@ -89,7 +89,7 @@ private Response callTokenEndpoint() {
 		}
 
 		protected HttpUrl buildTokenUrl() {
-			// For the near future, it's guaranteed that https and 443 will be required for connecting to MarkLogic Cloud,
+			// For the near future, it's guaranteed that https and 443 will be required for connecting to Progress Data Cloud,
 			// so providing the ability to customize this would be misleading.
 			HttpUrl.Builder builder = new HttpUrl.Builder()
 				.scheme("https")
@@ -134,7 +134,7 @@ static class TokenAuthenticationInterceptor implements Interceptor {
 
 		private final static Logger logger = LoggerFactory.getLogger(TokenAuthenticationInterceptor.class);
 
-		private TokenGenerator tokenGenerator;
+		private final TokenGenerator tokenGenerator;
 		private String token;
 
 		public TokenAuthenticationInterceptor(TokenGenerator tokenGenerator) {

marklogic-client-api/src/test/java/com/marklogic/client/impl/DatabaseClientPropertySourceTest.java

@@ -81,9 +81,9 @@ void cloudAuthWithNoSslInputs() {
 		bean = buildBean();
 
 		assertEquals("/my/path", bean.getBasePath());
-		assertTrue(bean.getSecurityContext() instanceof DatabaseClientFactory.MarkLogicCloudAuthContext);
+		assertTrue(bean.getSecurityContext() instanceof DatabaseClientFactory.ProgressDataCloudAuthContext);
 
-		DatabaseClientFactory.MarkLogicCloudAuthContext context = (DatabaseClientFactory.MarkLogicCloudAuthContext) bean.getSecurityContext();
+		DatabaseClientFactory.ProgressDataCloudAuthContext context = (DatabaseClientFactory.ProgressDataCloudAuthContext) bean.getSecurityContext();
 		assertEquals("abc123", context.getApiKey());
 
 		assertNotNull(context.getSSLContext(), "If cloud is chosen with no SSL protocol or context, the default JVM " +

marklogic-client-api/src/test/java/com/marklogic/client/impl/okhttp/MarkLogicCloudAuthenticationConfigurerTest.java renamed to marklogic-client-api/src/test/java/com/marklogic/client/impl/okhttp/ProgressDataCloudAuthenticationConfigurerTest.java

@@ -10,15 +10,15 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
- * Since we don't yet have a reliable way to test against a MarkLogic cloud instance, including some small unit tests
+ * Since we don't yet have a reliable way to test against a Progress Data Cloud instance, including some small unit tests
  * to ensure that certain things are built as expected.
  */
-public class MarkLogicCloudAuthenticationConfigurerTest {
+public class ProgressDataCloudAuthenticationConfigurerTest {
 
 	@Test
 	void buildTokenUrl() throws Exception {
-		MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator client = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("doesnt-matter")
+		ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator client = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("doesnt-matter")
 				.withSSLContext(SSLContext.getDefault(), null)
 		);
 
@@ -32,8 +32,8 @@ void buildTokenUrl() throws Exception {
 	 */
 	@Test
 	void buildTokenUrlWithCustomTokenPath() throws Exception {
-		MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator client = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("otherhost",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("doesnt-matter", "/customToken", "doesnt-matter")
+		ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator client = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("otherhost",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("doesnt-matter", "/customToken", "doesnt-matter")
 				.withSSLContext(SSLContext.getDefault(), null)
 		);
 
@@ -44,8 +44,8 @@ void buildTokenUrlWithCustomTokenPath() throws Exception {
 	@Test
 	void buildTokenUrlWithDuration() throws Exception {
 		Integer duration = 10;
-		MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator client = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("doesnt-matter", duration)
+		ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator client = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("doesnt-matter", duration)
 				.withSSLContext(SSLContext.getDefault(), null)
 		);
 
@@ -56,8 +56,8 @@ void buildTokenUrlWithDuration() throws Exception {
 	@Test
 	void buildTokenUrlWithDurationAndCustomPath() throws Exception {
 		Integer duration = 10;
-		MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator client = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("doesnt-matter", "/customToken", "doesnt-matter", duration)
+		ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator client = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("somehost",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("doesnt-matter", "/customToken", "doesnt-matter", duration)
 				.withSSLContext(SSLContext.getDefault(), null)
 		);
 
@@ -67,8 +67,8 @@ void buildTokenUrlWithDurationAndCustomPath() throws Exception {
 
 	@Test
 	void newFormBody() {
-		FormBody body = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("host-doesnt-matter",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("myKey"))
+		FormBody body = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("host-doesnt-matter",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("myKey"))
 							.newFormBody();
 		assertEquals("grant_type", body.name(0));
 		assertEquals("apikey", body.value(0));
@@ -82,8 +82,8 @@ void newFormBody() {
 	 */
 	@Test
 	void newFormBodyWithOverrides() {
-		FormBody body = new MarkLogicCloudAuthenticationConfigurer.DefaultTokenGenerator("host-doesnt-matter",
-			new DatabaseClientFactory.MarkLogicCloudAuthContext("myKey", "doesnt-matter", "custom-grant-type"))
+		FormBody body = new ProgressDataCloudAuthenticationConfigurer.DefaultTokenGenerator("host-doesnt-matter",
+			new DatabaseClientFactory.ProgressDataCloudAuthContext("myKey", "doesnt-matter", "custom-grant-type"))
 							.newFormBody();
 		assertEquals("grant_type", body.name(0));
 		assertEquals("custom-grant-type", body.value(0));