MLE-21476 Deprecates MarkLogicCloudAuthContext

Deprecates the MarkLogicCloudAuthContext class in favor of ProgressDataCloudAuthContext.

This change reflects the rebranding of MarkLogic Cloud to Progress Data Cloud and ensures that the client API aligns with the updated naming convention.
The deprecated class will be removed in a future release.

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));