/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
* or http://forgerock.org/license/CDDLv1.0.html.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at legal-notices/CDDLv1_0.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2008-2010 Sun Microsystems, Inc.
* Portions Copyright 2011-2015 ForgeRock AS
*/
package org.opends.server.replication.service;
import static org.opends.messages.ReplicationMessages.*;
import static org.opends.server.util.CollectionUtils.*;
import static org.testng.Assert.*;
import java.util.Map;
import java.util.SortedSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.opends.server.TestCaseUtils;
import org.opends.server.backends.task.Task;
import org.opends.server.replication.ReplicationTestCase;
import org.opends.server.replication.common.DSInfo;
import org.opends.server.replication.common.RSInfo;
import org.opends.server.replication.common.ServerState;
import org.opends.server.replication.common.ServerStatus;
import org.opends.server.replication.protocol.UpdateMsg;
import org.opends.server.replication.server.ReplServerFakeConfiguration;
import org.opends.server.replication.server.ReplicationServer;
import org.opends.server.replication.service.ReplicationDomain.ImportExportContext;
import org.opends.server.types.DN;
import org.opends.server.types.DirectoryException;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/**
* Test the Generic Replication Service.
*/
@SuppressWarnings("javadoc")
public class ReplicationDomainTest extends ReplicationTestCase
{
private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();
private static final Task NO_INIT_TASK = null;
@DataProvider(name = "publishAndReceiveData")
public Object[][] createpublishAndReceiveData()
{
return new Object[][] {
{1, 2, 3, 4},
{1, 2, 1, 2},
{1, 2, 45891, 45672},
{45610, 45720, 1, 2},
{45610, 45720, 45891, 45672}
};
}
/**
* Test that a ReplicationDomain is able to publish and receive UpdateMsg.
* Also test the ReplicationDomain.resetReplicationLog() method.
*/
@Test(dataProvider = "publishAndReceiveData", enabled=true)
public void publishAndReceive(
int replServerID1, int replServerID2,
int domain1ServerId, int domain2ServerId)
throws Exception
{
DN testService = DN.valueOf("o=test");
ReplicationServer replServer1 = null;
ReplicationServer replServer2 = null;
FakeReplicationDomain domain1 = null;
FakeReplicationDomain domain2 = null;
try
{
int[] ports = TestCaseUtils.findFreePorts(2);
int replServerPort1 = ports[0];
int replServerPort2 = ports[1];
replServer1 = createReplicationServer(replServerID1, replServerPort1,
"ReplicationDomainTestDb1", 100, "localhost:" + replServerPort2);
replServer2 = createReplicationServer(replServerID2, replServerPort2,
"ReplicationDomainTestDb2", 100, "localhost:" + replServerPort1);
SortedSet<String> servers = newTreeSet("localhost:" + replServerPort1);
BlockingQueue<UpdateMsg> rcvQueue1 = new LinkedBlockingQueue<>();
domain1 = new FakeReplicationDomain(
testService, domain1ServerId, servers, 100, 1000, rcvQueue1);
SortedSet<String> servers2 = newTreeSet("localhost:" + replServerPort2);
BlockingQueue<UpdateMsg> rcvQueue2 = new LinkedBlockingQueue<>();
domain2 = new FakeReplicationDomain(
testService, domain2ServerId, servers2, 100, 1000, rcvQueue2);
Thread.sleep(500);
/*
* Publish a message from domain1,
* Check that domain2 receives it shortly after.
*/
byte[] test = {1, 2, 3 ,4, 0, 1, 2, 3, 4, 5};
publish(domain1, test);
UpdateMsg rcvdMsg = rcvQueue2.poll(20, TimeUnit.SECONDS);
assertNotNull(rcvdMsg);
assertEquals(test, rcvdMsg.getPayload());
for (RSInfo replServerInfo : domain1.getRsInfos())
{
// The generation Id of the remote should be 1
assertEquals(replServerInfo.getGenerationId(), 1,
"Unexpected value of generationId in RSInfo for RS=" + replServerInfo);
}
for (DSInfo serverInfo : domain1.getReplicaInfos().values())
{
assertEquals(serverInfo.getStatus(), ServerStatus.NORMAL_STATUS);
}
domain1.setGenerationID(2);
domain1.resetReplicationLog();
Thread.sleep(500);
for (RSInfo replServerInfo : domain1.getRsInfos())
{
// The generation Id of the remote should now be 2
assertEquals(replServerInfo.getGenerationId(), 2,
"Unexpected value of generationId in RSInfo for RS=" + replServerInfo);
}
int sleepTime = 50;
while (true)
{
try
{
assertExpectedServerStatuses(domain1.getReplicaInfos(),
domain1ServerId, domain2ServerId);
assertExpectedServerStatuses(domain2.getReplicaInfos(),
domain1ServerId, domain2ServerId);
Map<Integer, ServerState> states1 = domain1.getReplicaStates();
ServerState state2 = states1.get(domain2ServerId);
assertNotNull(state2, "getReplicaStates is not showing DS2");
Map<Integer, ServerState> states2 = domain2.getReplicaStates();
ServerState state1 = states2.get(domain1ServerId);
assertNotNull(state1, "getReplicaStates is not showing DS1");
// if we reach this point all tests are OK
break;
}
catch (AssertionError e)
{
if (sleepTime >= 30000)
{
throw e;
}
Thread.sleep(sleepTime);
sleepTime *= 2;
}
}
}
finally
{
disable(domain1, domain2);
remove(replServer1, replServer2);
}
}
/**
* Publish information to the Replication Service (not assured mode).
*
* @param msg The byte array containing the information that should
* be sent to the remote entities.
*/
void publish(FakeReplicationDomain domain, byte[] msg)
{
UpdateMsg updateMsg;
synchronized (this)
{
updateMsg = new UpdateMsg(domain.getGenerator().newCSN(), msg);
// If assured replication is configured,
// this will prepare blocking mechanism.
// If assured replication is disabled, this returns immediately
domain.prepareWaitForAckIfAssuredEnabled(updateMsg);
domain.publish(updateMsg);
}
try
{
// If assured replication is enabled,
// this will wait for the matching ack or time out.
// If assured replication is disabled, this returns immediately
domain.waitForAckIfAssuredEnabled(updateMsg);
}
catch (TimeoutException ex)
{
// This exception may only be raised if assured replication is enabled
logger.info(NOTE_DS_ACK_TIMEOUT, domain.getBaseDN(), domain.getAssuredTimeout(), updateMsg);
}
}
private void assertExpectedServerStatuses(Map<Integer, DSInfo> dsInfos,
int domain1ServerId, int domain2ServerId)
{
for (DSInfo serverInfo : dsInfos.values())
{
if (serverInfo.getDsId() == domain2ServerId)
{
assertEquals(serverInfo.getStatus(), ServerStatus.BAD_GEN_ID_STATUS);
}
else
{
assertEquals(serverInfo.getDsId(), domain1ServerId);
assertEquals(serverInfo.getStatus(), ServerStatus.NORMAL_STATUS);
}
}
}
/**
* Publish performance test.
* The test loops calling the publish methods of the ReplicationDomain.
* It should not be enabled by default as it will use a lot of time.
* Its call is only to investigate performance issues with the replication.
*/
@Test(enabled=false)
public void publishPerf() throws Exception
{
DN testService = DN.valueOf("o=test");
ReplicationServer replServer1 = null;
int replServerID1 = 10;
FakeReplicationDomain domain1 = null;
int domain1ServerId = 1;
try
{
int replServerPort = TestCaseUtils.findFreePort();
replServer1 = createReplicationServer(replServerID1, replServerPort,
"ReplicationDomainTestDb", 100000, "localhost:" + replServerPort);
SortedSet<String> servers = newTreeSet("localhost:" + replServerPort);
BlockingQueue<UpdateMsg> rcvQueue1 = new LinkedBlockingQueue<>();
domain1 = new FakeReplicationDomain(
testService, domain1ServerId, servers, 1000, 100000, rcvQueue1);
/*
* Publish a message from domain1,
* Check that domain2 receives it shortly after.
*/
byte[] test = {1, 2, 3 ,4, 0, 1, 2, 3, 4, 5};
long timeNow = System.nanoTime();
timeNow = publishRepeatedly(domain1, test, timeNow);
timeNow = publishRepeatedly(domain1, test, timeNow);
timeNow = publishRepeatedly(domain1, test, timeNow);
timeNow = publishRepeatedly(domain1, test, timeNow);
}
finally
{
disable(domain1);
remove(replServer1);
}
}
private long publishRepeatedly(FakeReplicationDomain domain1, byte[] test, long timeNow)
{
long timeStart = timeNow;
for (int i = 0; i < 100000; i++)
{
publish(domain1, test);
}
timeNow = System.nanoTime();
System.out.println(timeNow - timeStart);
return timeNow;
}
private ReplicationServer createReplicationServer(int serverId,
int replicationPort, String dirName, int windowSize,
String... replServers) throws Exception
{
return createReplicationServer(serverId, replicationPort, dirName, windowSize, newTreeSet(replServers));
}
private ReplicationServer createReplicationServer(int serverId,
int replicationPort, String dirName, int windowSize,
SortedSet<String> replServers) throws Exception
{
return new ReplicationServer(
new ReplServerFakeConfiguration(replicationPort, dirName, 0, serverId, 0, windowSize, replServers));
}
private void disable(ReplicationDomain... domains)
{
for (ReplicationDomain domain : domains)
{
if (domain != null)
{
domain.disableService();
}
}
}
@DataProvider(name = "exportAndImportData")
public Object[][] createExportAndimportData()
{
return new Object[][] {
{1, 2},
{45610, 45720}
};
}
/**
* Test that a ReplicationDomain is able to export and import its database
* When there is only one replication server.
*/
@Test(dataProvider = "exportAndImportData", enabled=true)
public void exportAndImport(int serverId1, int serverId2) throws Exception
{
final int ENTRYCOUNT=5000;
DN testService = DN.valueOf("o=test");
ReplicationServer replServer = null;
int replServerID = 11;
FakeReplicationDomain domain1 = null;
FakeReplicationDomain domain2 = null;
try
{
int replServerPort = TestCaseUtils.findFreePort();
replServer = createReplicationServer(replServerID, replServerPort,
"exportAndImportData", 100);
SortedSet<String> servers = newTreeSet("localhost:" + replServerPort);
String exportedData = buildExportedData(ENTRYCOUNT);
domain1 = new FakeReplicationDomain(
testService, serverId1, servers, 0, exportedData, null, ENTRYCOUNT);
StringBuilder importedData = new StringBuilder();
domain2 = new FakeReplicationDomain(
testService, serverId2, servers, 0, null, importedData, 0);
/*
* Trigger a total update from domain1 to domain2.
* Check that the exported data is correctly received on domain2.
*/
assertTrue(initializeFromRemote(domain2));
waitEndExport(exportedData, importedData);
assertExportSucessful(domain1, domain2, exportedData, importedData);
}
finally
{
disable(domain1, domain2);
remove(replServer);
}
}
private boolean initializeFromRemote(ReplicationDomain domain) throws DirectoryException
{
for (DSInfo remoteDS : domain.getReplicaInfos().values())
{
if (remoteDS.getDsId() != domain.getServerId())
{
domain.initializeFromRemote(remoteDS.getDsId(), NO_INIT_TASK);
return true;
}
}
return false;
}
/**
* Test that a ReplicationDomain is able to export and import its database
* across 2 replication servers.
*/
@Test(enabled=true)
public void exportAndImportAcross2ReplServers() throws Exception
{
final int ENTRYCOUNT=5000;
DN testService = DN.valueOf("o=test");
ReplicationServer replServer2 = null;
ReplicationServer replServer1 = null;
int replServerID = 11;
int replServerID2 = 12;
FakeReplicationDomain domain1 = null;
FakeReplicationDomain domain2 = null;
try
{
int[] ports = TestCaseUtils.findFreePorts(2);
int replServerPort1 = ports[0];
int replServerPort2 = ports[1];
replServer1 = createReplicationServer(replServerID, replServerPort1,
"exportAndImportservice1", 100);
replServer2 = createReplicationServer(replServerID2, replServerPort2,
"exportAndImportservice2", 100, "localhost:" + replServerPort1);
SortedSet<String> servers1 = newTreeSet("localhost:" + replServerPort1);
SortedSet<String> servers2 = newTreeSet("localhost:" + replServerPort2);
String exportedData = buildExportedData(ENTRYCOUNT);
domain1 = new FakeReplicationDomain(
testService, 1, servers1, 0, exportedData, null, ENTRYCOUNT);
StringBuilder importedData = new StringBuilder();
domain2 = new FakeReplicationDomain(
testService, 2, servers2, 0, null, importedData, 0);
domain2.initializeFromRemote(1, NO_INIT_TASK);
waitEndExport(exportedData, importedData);
assertExportSucessful(domain1, domain2, exportedData, importedData);
}
finally
{
disable(domain1, domain2);
remove(replServer1, replServer2);
}
}
private String buildExportedData(final int ENTRYCOUNT)
{
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < ENTRYCOUNT; i++)
{
sb.append("key : value").append(i).append("\n\n");
}
return sb.toString();
}
private void waitEndExport(String exportedData, StringBuilder importedData) throws Exception
{
int count = 0;
while (importedData.length() < exportedData.length() && count < 500)
{
count ++;
Thread.sleep(100);
}
}
private void assertExportSucessful(ReplicationDomain domain1,
ReplicationDomain domain2, String exportedData, StringBuilder importedData)
{
assertEquals(getLeftEntryCount(domain2), 0, "Wrong LeftEntryCount for export");
assertEquals(getLeftEntryCount(domain1), 0, "Wrong LeftEntryCount for import");
assertEquals(importedData.length(), exportedData.length());
assertEquals(importedData.toString(), exportedData);
}
private long getLeftEntryCount(ReplicationDomain domain)
{
final ImportExportContext ieContext = domain.getImportExportContext();
if (ieContext != null)
{
return ieContext.getLeftEntryCount();
}
return 0; // import/export is finished
}
/**
* Sender side of the Total Update Perf test.
* The goal of this test is to measure the performance
* of the total update code.
* It is not intended to be run as part of the daily unit test but
* should only be used manually by developer in need of testing the
* performance improvement or non-regression of the total update code.
* Use this test in combination with the receiverInitialize() :
* - enable the test
* - start the senderInitialize first using
* ./build.sh \
* -Dorg.opends.test.suppressOutput=false \
* -Dtest.methods=org.opends.server.replication.service.ReplicationDomainTest.senderInitialize test
* - start the receiverInitialize second.
* - you may want to change HOST1 and HOST2 to use 2 different hosts
* if you don't want to do a loopback test.
* - don't forget to disable again the tests after running them
*/
final String HOST1 = "localhost:";
final String HOST2 = "localhost:";
final int SENDERPORT = 10102;
final int RECEIVERPORT = 10101;
@Test(enabled=false)
public void senderInitialize() throws Exception
{
DN testService = DN.valueOf("o=test");
ReplicationServer replServer = null;
int replServerID = 12;
FakeStressReplicationDomain domain1 = null;
try
{
SortedSet<String> servers =
newTreeSet(HOST1 + SENDERPORT, HOST2 + RECEIVERPORT);
replServer = createReplicationServer(replServerID, SENDERPORT,
"ReplicationDomainTestDb", 100, servers);
BlockingQueue<UpdateMsg> rcvQueue1 = new LinkedBlockingQueue<>();
domain1 = new FakeStressReplicationDomain(
testService, 2, servers, 1000, rcvQueue1);
System.out.println("waiting");
Thread.sleep(1000000000);
}
finally
{
disable(domain1);
remove(replServer);
}
}
/**
* See comments in senderInitialize() above.
*/
@Test(enabled=false)
public void receiverInitialize() throws Exception
{
DN testService = DN.valueOf("o=test");
ReplicationServer replServer = null;
int replServerID = 11;
FakeStressReplicationDomain domain1 = null;
try
{
SortedSet<String> servers =
newTreeSet(HOST1 + SENDERPORT, HOST2 + RECEIVERPORT);
replServer = createReplicationServer(replServerID, RECEIVERPORT,
"ReplicationDomainTestDb", 100, servers);
BlockingQueue<UpdateMsg> rcvQueue1 = new LinkedBlockingQueue<>();
domain1 = new FakeStressReplicationDomain(
testService, 1, servers, 100000, rcvQueue1);
/*
* Trigger a total update from domain1 to domain2.
* Check that the exported data is correctly received on domain2.
*/
while (!initializeFromRemote(domain1))
{
System.out.println("trying...");
Thread.sleep(1000);
}
System.out.println("waiting");
Thread.sleep(10000000);
}
finally
{
disable(domain1);
remove(replServer);
}
}
}