#425: Can now create replicas for a database with primaries on one host

Also deprecated "setCreateForestsOnOneHost"

Author: rjrudin

src/main/java/com/marklogic/appdeployer/command/databases/DeployDatabaseCommand.java

@@ -67,6 +67,7 @@ public class DeployDatabaseCommand extends AbstractCommand implements UndoableCo
      * Passed on to DeployForestsCommand. If forests are to be created, controls whether forests on created on every
      * host or only one one host.
      */
+    @Deprecated
     private boolean createForestsOnEachHost = true;
 
     private int undoSortOrder;
@@ -399,10 +400,16 @@ public void setDatabaseName(String databaseName) {
         this.databaseName = databaseName;
     }
 
+    @Deprecated
     public boolean isCreateForestsOnEachHost() {
         return createForestsOnEachHost;
     }
 
+	/**
+	 * Use appConfig.setDatabasesWithForestsOnOneHost
+	 * @param createForestsOnEachHost
+	 */
+	@Deprecated
     public void setCreateForestsOnEachHost(boolean createForestsOnEachHost) {
         this.createForestsOnEachHost = createForestsOnEachHost;
     }

src/main/java/com/marklogic/appdeployer/command/forests/DeployForestsCommand.java

@@ -44,7 +44,10 @@ public class DeployForestsCommand extends AbstractCommand {
 	private String databaseName;
 	private String forestFilename;
 	private String forestPayload;
+
+	@Deprecated
 	private boolean createForestsOnEachHost = true;
+
 	private HostCalculator hostCalculator;
 
 	private ForestBuilder forestBuilder = new ForestBuilder();
@@ -101,7 +104,7 @@ protected void createForestsViaForestEndpoint(CommandContext context, List<Fores
 
 	/**
 	 * Public so that it can be reused without actually saving any of the forests.
-	 *
+	 * <p>
 	 * This also facilitates the creation of forests for many databases at one time. A client can call this on a set of
 	 * these commands to construct a list of many forests that can be created via CMA in one request.
 	 *
@@ -113,19 +116,20 @@ protected void createForestsViaForestEndpoint(CommandContext context, List<Fores
 	public List<Forest> buildForests(CommandContext context, boolean includeReplicas) {
 		String template = buildForestTemplate(context, new ForestManager(context.getManageClient()));
 
-		List<String> hostNames = new HostManager(context.getManageClient()).getHostNames();
-		hostNames = determineHostNamesForForest(context, hostNames);
+		final List<String> allHostNames = new HostManager(context.getManageClient()).getHostNames();
+		ForestHostNames forestHostNames = determineHostNamesForForest(context, allHostNames);
 
 		// Need to know what primary forests exist already in case more need to be added, or a new host has been added
 		List<Forest> forests = getExistingPrimaryForests(context, this.databaseName);
-		ForestPlan forestPlan = new ForestPlan(this.databaseName, hostNames)
+		ForestPlan forestPlan = new ForestPlan(this.databaseName, forestHostNames.getPrimaryForestHostNames())
+			.withReplicaHostNames(forestHostNames.getReplicaForestHostNames())
 			.withTemplate(template)
 			.withForestsPerDataDirectory(this.forestsPerHost)
 			.withExistingForests(forests);
 
 		if (includeReplicas) {
 			Map<String, Integer> map = context.getAppConfig().getDatabaseNamesAndReplicaCounts();
-			if (map != null) {
+			if (map != null && map.containsKey(this.databaseName)) {
 				int count = map.get(this.databaseName);
 				if (count > 0) {
 					forestPlan.withReplicaCount(count);
@@ -178,26 +182,32 @@ protected String buildForestTemplate(CommandContext context, ForestManager fores
 
 	/**
 	 * @param context
-	 * @param hostNames
-	 * @return
+	 * @param allHostNames
+	 * @return a ForestHostNames instance that defines the list of host names that can be used for primary forests and
+	 * that can be used for replica forests. As of 4.1.0, the only reason these will differ is when a database is
+	 * configured to only have forests on one host, or when the deprecated setCreateForestsOnOneHost method is used.
 	 */
-	protected List<String> determineHostNamesForForest(CommandContext context, List<String> hostNames) {
+	protected ForestHostNames determineHostNamesForForest(CommandContext context, final List<String> allHostNames) {
 		Set<String> databaseNames = context.getAppConfig().getDatabasesWithForestsOnOneHost();
 		boolean onlyOnOneHost = databaseNames != null && databaseNames.contains(this.databaseName);
 
-		if (!createForestsOnEachHost || onlyOnOneHost) {
-			String first = hostNames.get(0);
-			logger.info(format("Only creating forests on the first host: " + first));
-			hostNames = new ArrayList<>();
-			hostNames.add(first);
-			return hostNames;
+		if (hostCalculator == null) {
+			hostCalculator = new DefaultHostCalculator(new DefaultHostNameProvider(context.getManageClient()));
 		}
 
-		if (hostCalculator == null) {
-			return new DefaultHostCalculator(new DefaultHostNameProvider(context.getManageClient())).calculateHostNames(this.databaseName, context);
+		// "candidate" = hosts that can be used for primary and replica forests
+		List<String> candidateHostNames = hostCalculator.calculateHostNames(this.databaseName, context);
+		List<String> primaryForestHostNames = new ArrayList<>();
+
+		if (!createForestsOnEachHost || onlyOnOneHost) {
+			String first = allHostNames.get(0);
+			logger.info(format("Only creating forests on the first host: " + first));
+			primaryForestHostNames.add(first);
+		} else {
+			primaryForestHostNames.addAll(candidateHostNames);
 		}
 
-		return hostCalculator.calculateHostNames(this.databaseName, context);
+		return new ForestHostNames(primaryForestHostNames, candidateHostNames);
 	}
 
 	public int getForestsPerHost() {
@@ -228,10 +238,16 @@ public void setForestPayload(String forestPayload) {
 		this.forestPayload = forestPayload;
 	}
 
+	@Deprecated
 	public boolean isCreateForestsOnEachHost() {
 		return createForestsOnEachHost;
 	}
 
+	/**
+	 * Use appConfig.setDatabasesWithForestsOnOneHost
+	 * @param createForestsOnEachHost
+	 */
+	@Deprecated
 	public void setCreateForestsOnEachHost(boolean createForestsOnEachHost) {
 		this.createForestsOnEachHost = createForestsOnEachHost;
 	}
@@ -253,3 +269,21 @@ public void setForestBuilder(ForestBuilder forestBuilder) {
 		this.forestBuilder = forestBuilder;
 	}
 }
+
+class ForestHostNames {
+	private List<String> primaryForestHostNames;
+	private List<String> replicaForestHostNames;
+
+	public ForestHostNames(List<String> primaryForestHostNames, List<String> replicaForestHostNames) {
+		this.primaryForestHostNames = primaryForestHostNames;
+		this.replicaForestHostNames = replicaForestHostNames;
+	}
+
+	public List<String> getPrimaryForestHostNames() {
+		return primaryForestHostNames;
+	}
+
+	public List<String> getReplicaForestHostNames() {
+		return replicaForestHostNames;
+	}
+}

src/main/java/com/marklogic/appdeployer/command/forests/DistributedReplicaBuilderStrategy.java

@@ -17,7 +17,7 @@ public void buildReplicas(List<Forest> forests, ForestPlan forestPlan, AppConfig
 		List<String> replicaDataDirectories, ForestNamingStrategy fns)
 	{
 		final String databaseName = forestPlan.getDatabaseName();
-		final List<String> hostNames = forestPlan.getHostNames();
+		final List<String> hostNames = forestPlan.getReplicaHostNames();
 		final int replicaCount = forestPlan.getReplicaCount();
 
 		HashMap<String, List<Forest>> hostToForests = new HashMap<String, List<Forest>>();

src/main/java/com/marklogic/appdeployer/command/forests/ForestBuilder.java

@@ -151,7 +151,7 @@ protected Map<String, Map<String, List<Forest>>> existingForestsMap(ForestPlan f
 	 */
 	public void addReplicasToForests(List<Forest> forests, ForestPlan forestPlan, AppConfig appConfig, List<String> dataDirectories) {
 		final String databaseName = forestPlan.getDatabaseName();
-		final List<String> hostNames = forestPlan.getHostNames();
+		final List<String> hostNames = forestPlan.getReplicaHostNames();
 		final int replicaCount = forestPlan.getReplicaCount();
 
 		if (replicaCount >= hostNames.size()) {

src/main/java/com/marklogic/appdeployer/command/forests/ForestPlan.java

@@ -10,6 +10,7 @@ public class ForestPlan {
 
 	private String databaseName;
 	private List<String> hostNames;
+	private List<String> replicaHostNames;
 	private String template;
 	private int forestsPerDataDirectory = 1;
 	private List<Forest> existingForests = new ArrayList<>();
@@ -19,9 +20,15 @@ public ForestPlan(String databaseName, String... hostNames) {
 		this(databaseName, Arrays.asList(hostNames));
 	}
 
+	/**
+	 * @param databaseName
+	 * @param hostNames    the list of hosts that primary and replica forests can be created on. If the list of replica
+	 *                     forest host names differs, use withReplicaHostNames
+	 */
 	public ForestPlan(String databaseName, List<String> hostNames) {
 		this.databaseName = databaseName;
 		this.hostNames = hostNames;
+		this.replicaHostNames = hostNames;
 	}
 
 	public ForestPlan withTemplate(String template) {
@@ -44,6 +51,11 @@ public ForestPlan withReplicaCount(int count) {
 		return this;
 	}
 
+	public ForestPlan withReplicaHostNames(List<String> replicaHostNames) {
+		this.replicaHostNames = replicaHostNames;
+		return this;
+	}
+
 	public String getDatabaseName() {
 		return databaseName;
 	}
@@ -67,4 +79,8 @@ public String getTemplate() {
 	public List<Forest> getExistingForests() {
 		return existingForests;
 	}
+
+	public List<String> getReplicaHostNames() {
+		return replicaHostNames;
+	}
 }

src/test/java/com/marklogic/appdeployer/command/forests/BuildForestReplicaTest.java

@@ -8,6 +8,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -61,7 +62,7 @@ public void sameNumberOfForestsAsHosts() {
 	}
 
 	/**
-	 * Similar to the above test, just even more forests. 
+	 * Similar to the above test, just even more forests.
 	 */
 	@Test
 	public void numberOfForestsPerHostIsMoreThanDoubleTheNumberOfHosts() {
@@ -91,6 +92,34 @@ public void numberOfForestsPerHostIsMoreThanDoubleTheNumberOfHosts() {
 		});
 	}
 
+	/**
+	 * Verifies that replicaHostNames is used for generating the replicas. This is for databases that are configured
+	 * to have their primary forests on a single host, which is often the case for modules, schemas, and triggers.
+	 */
+	@Test
+	public void primaryForestsOnOneHost() {
+		AppConfig appConfig = newAppConfig("mlForestsPerHost", "db,2");
+
+		ForestPlan plan = new ForestPlan("db", "host1").withReplicaCount(2);
+		assertEquals(1, plan.getHostNames().size());
+		assertEquals(1, plan.getReplicaHostNames().size());
+		plan.withReplicaHostNames(Arrays.asList("host1", "host2", "host3"));
+		assertEquals(1, plan.getHostNames().size());
+		assertEquals(3, plan.getReplicaHostNames().size());
+
+		List<Forest> forests = builder.buildForests(plan, appConfig);
+
+		assertEquals(2, forests.size());
+		forests.forEach(forest -> {
+			assertEquals("host1", forest.getHost());
+			assertEquals(2, forest.getForestReplica().size());
+			for (ForestReplica replica : forest.getForestReplica()) {
+				String host = replica.getHost();
+				assertTrue(host.equals("host2") || host.equals("host3"));
+			}
+		});
+	}
+
 	@Test
 	public void customNamingStrategyWithDistributedStrategy() {
 		AppConfig appConfig = newAppConfig("mlForestsPerHost", "my-database,2");

src/test/java/com/marklogic/appdeployer/command/forests/CreateForestsOnOneHostTest.java

@@ -27,22 +27,27 @@ public void test() {
 		HostCalculator hostCalculator = new DefaultHostCalculator(new TestHostNameProvider("host1", "host2", "host3"));
 		command.setHostCalculator(hostCalculator);
 
-		List<String> hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(3, hostNames.size());
+		ForestHostNames hostNames = command.determineHostNamesForForest(context, fakeHostNames);
+		assertEquals(3, hostNames.getPrimaryForestHostNames().size());
 
 		command.setCreateForestsOnEachHost(false);
 		hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(1, hostNames.size());
-		assertEquals("host1", hostNames.get(0));
+		assertEquals(1, hostNames.getPrimaryForestHostNames().size());
+		assertEquals("host1", hostNames.getPrimaryForestHostNames().get(0));
+		assertEquals(
+			"When forests aren't created on each host, all hosts should still be available for replica forests, " +
+				"with the expectation that the primary forest host will still not be used",
+			3, hostNames.getReplicaForestHostNames().size());
 
 		command.setCreateForestsOnEachHost(true);
 		hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(3, hostNames.size());
+		assertEquals(3, hostNames.getPrimaryForestHostNames().size());
 
 		Set<String> names = new HashSet<>();
 		names.add("test-db");
 		appConfig.setDatabasesWithForestsOnOneHost(names);
 		hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(1, hostNames.size());
+		assertEquals(1, hostNames.getPrimaryForestHostNames().size());
+		assertEquals(3, hostNames.getReplicaForestHostNames().size());
 	}
 }

src/test/java/com/marklogic/appdeployer/command/forests/CreateForestsOnSpecificHostsTest.java

@@ -26,8 +26,9 @@ public void test() {
 
 		command.setHostCalculator(new DefaultHostCalculator(new TestHostNameProvider(fakeHostNames.toArray(new String[]{}))));
 		// Verify we get all 3 hosts back when nothing special is configured
-		List<String> hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(3, hostNames.size());
+		ForestHostNames hostNames = command.determineHostNamesForForest(context, fakeHostNames);
+		assertEquals(3, hostNames.getPrimaryForestHostNames().size());
+		assertEquals(3, hostNames.getReplicaForestHostNames().size());
 
 		// Select 2 of the 3 hosts for test-db
 		Properties props = new Properties();
@@ -37,16 +38,18 @@ public void test() {
 		context = new CommandContext(appConfig, null, null);
 
 		hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(2, hostNames.size());
-		assertTrue(hostNames.contains("host1"));
-		assertTrue(hostNames.contains("host2"));
+		assertEquals(2, hostNames.getPrimaryForestHostNames().size());
+		assertEquals(2, hostNames.getReplicaForestHostNames().size());
+		assertTrue(hostNames.getPrimaryForestHostNames().contains("host1"));
+		assertTrue(hostNames.getPrimaryForestHostNames().contains("host2"));
 
 		// Select 1 of the 3 hosts, and include a bad host; the bad one should be ignored
 		props.setProperty("mlDatabaseHosts", "some-other-db,host2,test-db,bad-host|host2");
 		appConfig = factory.newAppConfig();
 		context = new CommandContext(appConfig, null, null);
 		hostNames = command.determineHostNamesForForest(context, fakeHostNames);
-		assertEquals(1, hostNames.size());
-		assertTrue(hostNames.contains("host2"));
+		assertEquals(1, hostNames.getPrimaryForestHostNames().size());
+		assertEquals(1, hostNames.getReplicaForestHostNames().size());
+		assertTrue(hostNames.getPrimaryForestHostNames().contains("host2"));
 	}
 }