public void markServerDown(String id) {
boolean triggered = false;
id = Server.normalizeId(id);
if (id == null) {
return;
}
Lock writeLock = upServerLock.writeLock();
try {
writeLock.lock();
final List<Server> changedServers = new ArrayList<Server>();
for (Server svr : upServerList) {
if (svr.isAlive() && (svr.getId().equals(id))) {
triggered = true;
svr.setAlive(false);
changedServers.add(svr);
}
}
if (triggered) {
logger.error("LoadBalancer: markServerDown called on [" + id + "]");
notifyServerStatusChangeListener(changedServers);
}
} finally {
try {
writeLock.unlock();
} catch (Exception e) { // NOPMD
}
}
}
@Override
public void markServerDown(Server server) {
if (server == null) {
return;
}
if (!server.isAlive()) {
return;
}
logger.error("LoadBalancer: markServerDown called on [" + server.getId() + "]");
server.setAlive(false);
// forceQuickPing();
notifyServerStatusChangeListener(singleton(server));
}
public void runPinger() {
if (pingInProgress.get()) {
return;
} else {
pingInProgress.set(true);
}
Object[] allServers = null;
boolean[] results = null;
Lock allLock = null;
Lock upLock = null;
try {
allLock = allServerLock.readLock();
allLock.lock();
allServers = allServerList.toArray();
allLock.unlock();
int numCandidates = allServers.length;
results = new boolean[numCandidates];
if (logger.isDebugEnabled()) {
logger.debug(
"LoadBalancer: PingTask executing [" + numCandidates + "] servers configured");
}
for (int i = 0; i < numCandidates; i++) {
results[i] = false;
try {
if (ping != null) {
results[i] = ping.isAlive((Server) allServers[i]);
}
} catch (Throwable t) {
logger.error("Exception while pinging Server:" + allServers[i], t);
}
}
final List<Server> newUpList = new ArrayList<Server>();
final List<Server> changedServers = new ArrayList<Server>();
for (int i = 0; i < numCandidates; i++) {
boolean isAlive = results[i];
Server svr = (Server) allServers[i];
boolean oldIsAlive = svr.isAlive();
svr.setAlive(isAlive);
if (oldIsAlive != isAlive) {
changedServers.add(svr);
if (logger.isDebugEnabled()) {
logger.debug(
"LoadBalancer: Server ["
+ svr.getId()
+ "] status changed to "
+ (isAlive ? "ALIVE" : "DEAD"));
}
}
if (isAlive) {
newUpList.add(svr);
}
}
upLock = upServerLock.writeLock();
upLock.lock();
upServerList = newUpList;
upLock.unlock();
notifyServerStatusChangeListener(changedServers);
} catch (Throwable t) {
logger.error("Throwable caught while running the Pinger-" + name, t);
} finally {
pingInProgress.set(false);
}
}
public void setServersList(List lsrv) {
Collections.shuffle(lsrv);
Lock writeLock = allServerLock.writeLock();
if (logger.isDebugEnabled()) {
logger.debug("LoadBalancer: clearing server list (SET op)");
}
List<Server> newUpServerList = null;
boolean listChanged = false;
writeLock.lock();
try {
List<Server> allServers = new ArrayList<Server>();
for (Object server : lsrv) {
if (server == null) {
continue;
}
if (server instanceof String) {
server = new Server((String) server);
}
if (server instanceof Server) {
if (logger.isDebugEnabled()) {
logger.debug("LoadBalancer: addServer [" + ((Server) server).getId() + "]");
}
allServers.add((Server) server);
} else {
throw new IllegalArgumentException(
"Type String or Server expected, instead found:" + server.getClass());
}
}
if (!allServerList.equals(allServers)) {
listChanged = true;
if (changeListeners != null && changeListeners.size() > 0) {
List<Server> oldList = new ArrayList<Server>(allServerList);
List<Server> newList = new ArrayList<Server>(allServers);
for (ServerListChangeListener l : changeListeners) {
try {
l.serverListChanged(oldList, newList);
} catch (Throwable e) {
logger.error("Error invoking server list change listener", e);
}
}
}
}
allServerList = allServers;
if (canSkipPing()) {
for (Server s : allServerList) {
s.setAlive(true);
}
newUpServerList = allServerList;
}
} finally {
writeLock.unlock();
}
if (newUpServerList != null) {
Lock unLock = upServerLock.writeLock();
try {
unLock.lock();
upServerList = newUpServerList;
} finally {
unLock.unlock();
}
} else if (listChanged) {
forceQuickPing();
}
}