/**
* Recomputes the monitor data for this replication server domain.
*
* @return The recomputed monitor data for this replication server domain.
* @throws InterruptedException If this thread is interrupted while waiting for a response.
*/
public ReplicationDomainMonitorData recomputeMonitorData() throws InterruptedException {
// Only allow monitor recalculation at a time.
synchronized (pendingMonitorLock) {
if (monitorDataLastBuildDate + monitorDataLifeTime < TimeThread.getTime()) {
try {
DN baseDN = domain.getBaseDN();
// Prevent out of band monitor responses from updating our pending
// table until we are ready.
synchronized (pendingMonitorDataLock) {
// Clear the pending monitor data.
pendingMonitorDataServerIDs.clear();
pendingMonitorData = new ReplicationDomainMonitorData();
initializePendingMonitorData();
// Send the monitor requests to the connected replication servers.
for (ServerHandler rs : domain.getConnectedRSs().values()) {
final int serverId = rs.getServerId();
MonitorRequestMsg msg = new MonitorRequestMsg(domain.getLocalRSServerId(), serverId);
try {
rs.send(msg);
// Only register this server ID to pending table if we were able
// to send the message.
pendingMonitorDataServerIDs.add(serverId);
} catch (IOException e) {
// Log a message and do a best effort from here.
logger.error(
ERR_SENDING_REMOTE_MONITOR_DATA_REQUEST, baseDN, serverId, e.getMessage());
}
}
// Create the pending response latch based on the number of expected
// monitor responses.
pendingMonitorDataLatch = new CountDownLatch(pendingMonitorDataServerIDs.size());
}
// Wait for the responses to come back.
pendingMonitorDataLatch.await(5, TimeUnit.SECONDS);
// Log messages for replication servers that have gone or come back.
synchronized (pendingMonitorDataLock) {
// Log servers that have come back.
for (int serverId : monitorDataLateServers) {
// Ensure that we only log once per server: don't fill the
// error log with repeated messages.
if (!pendingMonitorDataServerIDs.contains(serverId)) {
logger.info(NOTE_MONITOR_DATA_RECEIVED, baseDN, serverId);
}
}
// Log servers that have gone away.
for (int serverId : pendingMonitorDataServerIDs) {
// Ensure that we only log once per server: don't fill the
// error log with repeated messages.
if (!monitorDataLateServers.contains(serverId)) {
logger.warn(WARN_MISSING_REMOTE_MONITOR_DATA, baseDN, serverId);
}
}
// Remember which servers were late this time.
monitorDataLateServers.clear();
monitorDataLateServers.addAll(pendingMonitorDataServerIDs);
}
// Store the new computed data as the reference
synchronized (pendingMonitorDataLock) {
// Now we have the expected answers or an error occurred
pendingMonitorData.completeComputing();
monitorData = pendingMonitorData;
monitorDataLastBuildDate = TimeThread.getTime();
}
} finally {
synchronized (pendingMonitorDataLock) {
// Clear pending state.
pendingMonitorData = null;
pendingMonitorDataLatch = null;
pendingMonitorDataServerIDs.clear();
}
}
}
}
return monitorData;
}
