private void publishHeartbeats() {
try {
Map<MessageDestination, OutputQueue> neighbors =
m_BrokerCore.getOverlayManager().getORT().getBrokerQueues();
synchronized (neighbors) {
for (MessageDestination md : neighbors.keySet()) {
String brokerID = md.getDestinationID();
// create and set a timer event for the heartbeat request
TimerEvent event = new TimerEvent(this, m_HeartbeatTimeout, HEARTBEAT_TIMEOUT_TIMER);
event.setAttachment(brokerID);
int handle = m_TimerThread.setTimer(event);
// publish the heartbeat request
String pubStr =
"[class,"
+ HeartbeatSubscriber.MESSAGE_CLASS
+ "],"
+ "[brokerID,'"
+ brokerID
+ "'],"
+ "[fromID,'"
+ m_BrokerCore.getBrokerID()
+ "'],"
+ "[type,'HEARTBEAT_REQ'],"
+ "[handle,'"
+ handle
+ "']";
Publication pub = MessageFactory.createPublicationFromString(pubStr);
PublicationMessage pubMsg =
new PublicationMessage(
pub, m_BrokerCore.getNewMessageID(), MessageDestination.HEARTBEAT_MANAGER);
heartbeatLogger.info(
"Broker "
+ m_BrokerCore.getBrokerID()
+ " is sending heartbeat REQ to broker "
+ brokerID
+ " with handle "
+ handle);
m_BrokerCore.routeMessage(pubMsg, MessageDestination.INPUTQUEUE);
// add by shuang for testing
currentHandle = handle;
}
}
} catch (ParseException e) {
heartbeatLogger.error(e.getMessage());
exceptionLogger.error(e.getMessage());
}
}
/** called by the timer thread when one of the timer events we set has expired. */
public synchronized void returnToClientQ(TimerEvent event) {
if (m_ReturnedEventsQ == null) {
m_ReturnedEventsQ = event;
event.setNext(null);
} else {
TimerEvent current = m_ReturnedEventsQ;
while (current.getNext() != null) current = current.getNext();
current.setNext(event);
event.setNext(null);
}
interrupt();
}
public void run() {
synchronized (started_lock) {
m_TimerThread = m_BrokerCore.getTimerThread();
// advertise that we will be publishing heartbeat related messages
advertiseHeartbeat();
advertiseFailureDetected();
// set the initial heartbeat timer
m_TimerThread.setTimer(new TimerEvent(this, m_HeartbeatInterval, HEARTBEAT_INTERVAL_TIMER));
// wake up threads waiting for HeartbeatPublisher to start
started = true;
started_lock.notifyAll();
}
while (started) {
try {
sleep(DEFAULT_SLEEP_TIME);
} catch (InterruptedException ignored) {
}
if (!started) break;
synchronized (this) {
// check if neighbor list changed
if (m_NeighborListChanged) {
// TODO: process changed neighbor list
m_NeighborListChanged = false;
}
// check for expired events
while (m_ReturnedEventsQ != null) {
TimerEvent event = m_ReturnedEventsQ;
// process the event
if (event.getStatus() == TimerEvent.TIMER_STATUS_EXPIRED) {
if (event.getType() == HEARTBEAT_INTERVAL_TIMER) {
// send the next batch of heartbeats
if (m_PublishHeartbeats) publishHeartbeats();
// reset the interval timer
m_TimerThread.setTimer(
new TimerEvent(this, m_HeartbeatInterval, HEARTBEAT_INTERVAL_TIMER));
} else if (event.getType() == HEARTBEAT_TIMEOUT_TIMER) {
heartbeatLogger.info(
"Broker " + event.getAttachment() + " did not reply to a heartbeat");
// get the name of the offending broker
String broker = (String) event.getAttachment();
// a broker heartbeat timed out, increment the fail count
Map<MessageDestination, OutputQueue> neighbors1 =
m_BrokerCore.getOverlayManager().getORT().getBrokerQueues();
synchronized (neighbors1) {
for (MessageDestination md : neighbors1.keySet()) {
if (md.getDestinationID().equals(broker)) {
int failCount = md.incrementFailCount();
if (failCount >= m_FailureThreshold) {
publishFailureDetected(broker);
break;
}
}
}
}
}
}
m_ReturnedEventsQ = event.getNext();
}
}
}
}