/**
* method called when a new Master connection is found after a fallback.
*
* @param protocol the new active connection
*/
@Override
public void foundActiveMaster(Protocol protocol) throws QueryException {
if (isExplicitClosed()) {
proxy.lock.lock();
try {
protocol.close();
} finally {
proxy.lock.unlock();
}
return;
}
syncConnection(this.currentProtocol, protocol);
proxy.lock.lock();
try {
if (currentProtocol != null && !currentProtocol.isClosed()) {
currentProtocol.close();
}
currentProtocol = protocol;
} finally {
proxy.lock.unlock();
}
resetMasterFailoverData();
FailoverLoop.removeListener(this);
}
/**
* Add listener to FailoverLoop if master connection is not active, so a reconnection will be
* done. (the reconnection will be done by failover or if append before by the next query/method
* that will use the failed connection) Remove listener from FailoverLoop is master connection is
* active.
*/
public void handleFailLoop() {
if (isMasterHostFail()) {
if (!isExplicitClosed()) {
FailoverLoop.addListener(this);
}
} else {
FailoverLoop.removeListener(this);
}
}
/**
* Loop to connect failed hosts.
*
* @param searchFilter search parameters.
* @throws QueryException if there is any error during reconnection
*/
@Override
public void reconnectFailedConnection(SearchFilter searchFilter) throws QueryException {
proxy.lock.lock();
try {
if (!searchFilter.isInitialConnection() && (isExplicitClosed() || !isMasterHostFail())) {
return;
}
currentConnectionAttempts.incrementAndGet();
resetOldsBlackListHosts();
List<HostAddress> loopAddress = new LinkedList<>(urlParser.getHostAddresses());
if (HaMode.FAILOVER.equals(mode)) {
// put the list in the following order
// - random order not connected host
// - random order blacklist host
// - random order connected host
loopAddress.removeAll(getBlacklistKeys());
Collections.shuffle(loopAddress);
List<HostAddress> blacklistShuffle = new LinkedList<>(getBlacklistKeys());
Collections.shuffle(blacklistShuffle);
loopAddress.addAll(blacklistShuffle);
} else {
// order in sequence
loopAddress.removeAll(getBlacklistKeys());
loopAddress.addAll(getBlacklistKeys());
}
// put connected at end
if (currentProtocol != null && !isMasterHostFail()) {
loopAddress.remove(currentProtocol.getHostAddress());
// loopAddress.add(currentProtocol.getHostAddress());
}
MasterProtocol.loop(this, loopAddress, searchFilter);
// close loop if all connection are retrieved
if (!isMasterHostFail()) {
FailoverLoop.removeListener(this);
}
// if no error, reset failover variables
resetMasterFailoverData();
} finally {
proxy.lock.unlock();
}
}
@Override
public HandleErrorResult primaryFail(Method method, Object[] args) throws Throwable {
boolean alreadyClosed = !currentProtocol.isConnected();
boolean inTransaction = currentProtocol != null && currentProtocol.inTransaction();
try {
if (currentProtocol != null && currentProtocol.isConnected() && currentProtocol.ping()) {
// connection re-established
// if in transaction cannot be sure that the last query has been received by server of not,
// so rollback.and throw exception
if (currentProtocol.inTransaction()) {
currentProtocol.rollback();
}
return new HandleErrorResult(true);
}
} catch (QueryException e) {
proxy.lock.lock();
try {
currentProtocol.close();
} finally {
proxy.lock.unlock();
}
if (setMasterHostFail()) {
addToBlacklist(currentProtocol.getHostAddress());
}
}
try {
reconnectFailedConnection(new SearchFilter(true, false));
handleFailLoop();
if (alreadyClosed
|| (!alreadyClosed && !inTransaction && isQueryRelaunchable(method, args))) {
return relaunchOperation(method, args);
}
return new HandleErrorResult(true);
} catch (Exception e) {
// we will throw a Connection exception that will close connection
FailoverLoop.removeListener(this);
return new HandleErrorResult();
}
}