void lookupOperationSucceeded(Operation<OverlayContact<OverlayID<?>>> op) {
LookupResult result = treeHandlerDelegator.lookupOperationSucceeded(op);
parentCoordinator =
new SkyNetNodeInfoImpl(
result.getSkyNetID(),
coordinatorKey,
DefaultTransInfo.getTransInfo(
result.getContact().getTransInfo().getNetId(), skyNetNode.getPort()),
level);
log.info(
parentCoordinator.toString()
+ " is parentCoordinator of "
+ skyNetNode.getSkyNetNodeInfo().toString());
skyNetNode.getMetricUpdateStrategy().sendNextDataUpdate();
}
private void lookupParentCoordinator() {
if (((AbstractOverlayNode<?, ?>) skyNetNode.getOverlayNode())
.getPeerStatus()
.equals(PeerStatus.PRESENT)) {
log.debug(
SkyNetUtilities.getTimeAndNetID(skyNetNode)
+ "starts a lookup for the key "
+ coordinatorKey.getPlainSkyNetID());
treeHandlerDelegator.lookupParentCoordinator(
coordinatorKey,
new OperationCallback<OverlayContact<OverlayID<?>>>() {
@Override
public void calledOperationFailed(Operation<OverlayContact<OverlayID<?>>> op) {
lookupOperationFailed(op);
}
@Override
public void calledOperationSucceeded(Operation<OverlayContact<OverlayID<?>>> op) {
lookupOperationSucceeded(op);
}
});
} else {
log.warn("SkyNetNode cannot lookup ParentCoordinator" + ", because he is not PRESENT");
}
}
private void calculateNextLevel(
SkyNetID ownID, SkyNetID skyNetCoKey, BigDecimal left, BigDecimal right, int iter) {
if (iter == 0) {
coordinatorKey = skyNetCoKey;
level = iter;
} else {
coordinatorKey = skyNetCoKey;
level = iter;
}
if (iter < 100) {
// call processNextLevel(...), but before split the interval
// defined by left and right in k subintervals as defined by
// branchingFactor.
BigDecimal interval = right.subtract(left);
BigDecimal intervalStep = interval.divide(new BigDecimal(String.valueOf(branchingFactor)));
BigDecimal tempLeft = left;
BigDecimal tempRight = left.add(new BigDecimal(String.valueOf(intervalStep)));
log.info(
SkyNetUtilities.getTimeAndNetID(skyNetNode)
+ "is actually in the interval between "
+ left.toPlainString()
+ " and "
+ right.toPlainString()
+ ". The size of the interval is"
+ interval);
int correctnessCounter = 0;
while (ownID.getID().compareTo(tempRight) > -1) {
tempLeft = tempRight;
tempRight = tempRight.add(new BigDecimal(String.valueOf(intervalStep)));
if (correctnessCounter < branchingFactor) {
correctnessCounter++;
} else {
log.fatal(
"There are actually "
+ (correctnessCounter + 1)
+ " intervals instead of "
+ branchingFactor);
}
}
processNextLevel(ownID, tempLeft, tempRight, iter + 1);
} else {
skyNetNode.getMetricUpdateStrategy().scheduleNextUpdateEvent();
parentCoordinator = null;
if (isRoot) {
log.warn(SkyNetUtilities.getTimeAndNetID(skyNetNode) + "lost the root-position");
}
isRoot = false;
log.error(
SkyNetUtilities.getTimeAndNetID(skyNetNode)
+ "is to deep in the tree."
+ "Probably no predecessor in the overlay can be found"
+ " to calculate the 'isRootOf'-method");
}
}
private void checkResponsibility(
SkyNetID ownID, SkyNetID skyNetCoKey, BigDecimal left, BigDecimal right, int iter) {
skyNetNode.getSkyNetNodeInfo().setCoordinatorKey(skyNetCoKey);
log.info(
" The client "
+ skyNetNode.getSkyNetNodeInfo().toString()
+ " is responsible for the CoordinatorKey "
+ skyNetCoKey.getPlainSkyNetID()
+ " in the interval["
+ left.toPlainString()
+ ";"
+ right.toPlainString()
+ "] @ level "
+ iter);
ISkyNetMonitor monitor = (ISkyNetMonitor) Simulator.getMonitor();
ChurnStatisticsAnalyzer csAnalyzer =
(ChurnStatisticsAnalyzer) monitor.getConnectivityAnalyzer(ChurnStatisticsAnalyzer.class);
if (iter > 0) {
// complete the parentSkyNetNode Info
if (isRoot) {
log.warn(SkyNetUtilities.getTimeAndNetID(skyNetNode) + "lost the root-position");
csAnalyzer.lostRootPosition(skyNetNode);
skyNetNode.getMetricUpdateStrategy().setLastMetricSync(0);
}
skyNetNode.getSkyNetNodeInfo().setLevel(iter);
isRoot = false;
lookupParentCoordinator();
} else {
if (!isRoot) {
log.warn(SkyNetUtilities.getTimeAndNetID(skyNetNode) + "got the root-position");
csAnalyzer.gotRootPosition(skyNetNode);
skyNetNode.getMetricUpdateStrategy().setLastMetricSync(0);
}
skyNetNode.getSkyNetNodeInfo().setLevel(iter);
// Also set the observed level at this point
skyNetNode.getSkyNetNodeInfo().setObservedLevelFromRoot(0);
isRoot = true;
skyNetNode.getAttributeUpdateStrategy().resetOnlyAttributeUpdateStrategy();
skyNetNode.getMetricUpdateStrategy().sendNextDataUpdate();
}
}
public TreeHandler(SkyNetNodeInterface node, TreeHandlerDelegator treeHandlerDelegator) {
branchingFactor =
SkyNetPropertiesReader.getInstance().getIntProperty("SkyNetTreeBranchingFactor");
this.skyNetNode = node;
this.treeHandlerDelegator = treeHandlerDelegator;
this.treeHandlerDelegator.setSkyNetNode(skyNetNode);
this.treeHandlerDelegator.setOwnOverlayNode(skyNetNode.getOverlayNode());
isRoot = false;
parentCoordinator = new SkyNetNodeInfoImpl(null, null, null, -1);
coordinatorKey = null;
level = 0;
}
/**
* If it is possible to calculate the responsibility interval of a peer on the current overlay,
* this method calculates the corresponding responsibility interval of the node in the ID-space of
* SkyNet. In this context, the responsibility interval is used to test, if a SkyNet-node is
* responsible for a Coordinator.
*
* @param id contains the ID of this SkyNet-node
*/
public void calculateResponsibilityInterval(SkyNetID id) {
if (((AbstractOverlayNode<?, ?>) skyNetNode.getOverlayNode())
.getPeerStatus()
.equals(PeerStatus.PRESENT)) {
// execute getPredecessor-method
final SkyNetID ownID = id;
treeHandlerDelegator.calculateResponsibilityInterval(
ownID,
new OperationCallback<OverlayContact<OverlayID<?>>>() {
@Override
public void calledOperationFailed(Operation<OverlayContact<OverlayID<?>>> op) {
calculateResponsibilityIntervalOperationFailed(op);
}
@Override
public void calledOperationSucceeded(Operation<OverlayContact<OverlayID<?>>> op) {
calculateResponsibilityIntervalOperationSucceeded(op, ownID);
}
});
} else {
log.warn("SkyNetNode cannot get Predecessor" + ", because he is not PRESENT");
}
}
void lookupOperationFailed(Operation<OverlayContact<OverlayID<?>>> op) {
treeHandlerDelegator.lookupOperationFailed(op);
skyNetNode.getMetricUpdateStrategy().scheduleNextUpdateEvent();
}
void processNextLevelOperationFailed(Operation<?> op) {
treeHandlerDelegator.processNextLevelOperationFailed(op);
skyNetNode.getMetricUpdateStrategy().scheduleNextUpdateEvent();
}
void calculateResponsibilityIntervalOperationFailed(Operation<OverlayContact<OverlayID<?>>> op) {
treeHandlerDelegator.calculateResponsibilityIntervalOperationFailed(op);
skyNetNode.getMetricUpdateStrategy().scheduleNextUpdateEvent();
}