use of org.ow2.proactive.resourcemanager.rmnode.RMDeployingNode in project scheduling by ow2-proactive.
the class NodeSource method internalAddNode.
/**
* Updates internal node source structures.
*/
@VisibleForTesting
RMDeployingNode internalAddNode(Node node) throws RMException {
String nodeUrl = node.getNodeInformation().getURL();
if (this.nodes.containsKey(nodeUrl)) {
throw new RMException("The node " + nodeUrl + " already added to the node source " + name);
}
logger.info("[" + name + "] new node available : " + node.getNodeInformation().getURL());
RMDeployingNode rmDeployingNode = infrastructureManager.internalRegisterAcquiredNode(node);
nodes.put(nodeUrl, node);
if (removedNodes.containsKey(nodeUrl)) {
removedNodes.remove(nodeUrl);
}
return rmDeployingNode;
}
use of org.ow2.proactive.resourcemanager.rmnode.RMDeployingNode in project scheduling by ow2-proactive.
the class NodeSource method acquireNode.
/**
* Acquires the existing node with specific url. The node have to be up and running.
*
* @param nodeUrl the url of the node
* @param provider
*/
public BooleanWrapper acquireNode(String nodeUrl, Client provider) {
if (toShutdown) {
throw new AddingNodesException("[" + name + "] node " + nodeUrl + " adding request discarded because node source is shutting down");
}
// checking that client has a right to change this node source
// if the provider is the administrator of the node source it always has this permission
provider.checkPermission(providerPermission, provider + " is not authorized to add node " + nodeUrl + " to " + name, new RMCoreAllPermission(), new NSAdminPermission());
// lookup for a new Node
int lookUpTimeout = PAResourceManagerProperties.RM_NODELOOKUP_TIMEOUT.getValueAsInt();
Node nodeToAdd = null;
try {
logger.info("Looking up the node " + nodeUrl + " with " + lookUpTimeout + " ms timeout");
nodeToAdd = lookupNode(nodeUrl, lookUpTimeout);
logger.info("The node " + nodeUrl + " has been successfully looked up");
} catch (Exception e) {
logger.warn("Cannot look up the node " + nodeUrl + " within " + lookUpTimeout + " ms due to " + e.getMessage(), e);
throw new AddingNodesException(e);
}
// node should be not null at this point...
if (nodeToAdd == null) {
throw new AddingNodesException("Cannot lookup node for unknown reason : " + nodeUrl);
}
// now checking if this node has been registered before in the node source
if (downNodes.containsKey(nodeUrl)) {
// it was registered but detected as down node,
// so basically the node was restarted.
// adding a new node and removing old one from the down list
logger.debug("Removing existing node from down nodes list");
BooleanWrapper result = rmcore.removeNodeFromCore(nodeUrl);
if (result.getBooleanValue()) {
if (logger.isDebugEnabled())
logger.debug("[" + name + "] successfully removed node " + nodeUrl + " from the core");
// just removing it from down nodes list
removeNode(nodeUrl, provider);
}
} else if (nodes.containsKey(nodeUrl)) {
// adding a node which exists in node source
Node existingNode = nodes.get(nodeUrl);
if (nodeToAdd.equals(existingNode)) {
// don't do anything
if (logger.isDebugEnabled())
logger.debug("An attempt to add the same node twice " + nodeUrl + " - ignoring");
return new BooleanWrapper(false);
} else {
// adding another node with the same url
// replacing the old node by the new one
logger.debug("Removing existing node from the RM without request propagation to the infrastructure manager");
BooleanWrapper result = rmcore.removeNodeFromCore(nodeUrl);
if (result.getBooleanValue()) {
if (logger.isDebugEnabled())
logger.debug("[" + name + "] successfully removed node " + nodeUrl + " from the core");
// removing it from the nodes list but don't propagate
// the request the the infrastructure because the restarted node will be killed
nodes.remove(nodeUrl);
}
}
}
// if any exception occurs in internalAddNode(node) do not add the node to the core
RMDeployingNode deployingNode;
try {
deployingNode = internalAddNode(nodeToAdd);
} catch (RMException e) {
throw new AddingNodesException(e);
}
// we build the rmnode
RMNode rmNode = buildRMNode(nodeToAdd, provider);
if (deployingNode != null) {
// inherit locking status from associated deploying node created before
((AbstractRMNode) rmNode).copyLockStatusFrom(deployingNode);
}
BooleanWrapper nodeAdded = rmcore.registerAvailableNode(rmNode);
rmcore.internalRegisterConfiguringNode(rmNode);
return nodeAdded;
}
use of org.ow2.proactive.resourcemanager.rmnode.RMDeployingNode in project scheduling by ow2-proactive.
the class RMCore method getRMInitialState.
/**
* Builds and returns a snapshot of RMCore's current state. Initial state
* must be understood as a new Monitor point of view. A new monitor start to
* receive RMCore events, so must be informed of the current state of the
* Core at the beginning of monitoring. The monitor is built in three parts
* first with all the nodes knows by the RMCore, then with all deploying
* nodes known by the deployed node sources and then with all the defined
* node sources.
*
* @return RMInitialState containing nodes and nodeSources of the RMCore.
*/
public RMInitialState getRMInitialState() {
final Map<String, RMNodeEvent> nodeEvents = this.allNodes.values().stream().map(RMNode::createNodeEvent).collect(Collectors.toMap(RMNodeEvent::getNodeUrl, event -> event));
for (NodeSource source : this.deployedNodeSources.values()) {
for (RMDeployingNode node : source.getDeployingAndLostNodes()) {
final RMNodeEvent nodeEvent = node.createNodeEvent();
nodeEvents.put(nodeEvent.getNodeUrl(), nodeEvent);
}
}
final List<RMNodeSourceEvent> nodeSourceEvents = new ArrayList<>(this.definedNodeSources.values().stream().map(ns -> {
if (deployedNodeSources.containsKey(ns.getName())) {
return PAFuture.getFutureValue(deployedNodeSources.get(ns.getName()).createNodeSourceEvent());
} else {
return ns.createNodeSourceEvent();
}
}).collect(Collectors.toList()));
long eventCounter = 0;
for (RMNodeSourceEvent nodeSourceEvent : nodeSourceEvents) {
nodeSourceEvent.setCounter(eventCounter++);
}
for (RMNodeEvent nodeEvent : nodeEvents.values()) {
nodeEvent.setCounter(eventCounter++);
}
final RMInitialState rmInitialState = new RMInitialState();
rmInitialState.addAll(nodeEvents.values());
rmInitialState.addAll(nodeSourceEvents);
return rmInitialState;
}
use of org.ow2.proactive.resourcemanager.rmnode.RMDeployingNode in project scheduling by ow2-proactive.
the class InfrastructureManager method removeDeployingNodeWithLockAndPersist.
private RMDeployingNode removeDeployingNodeWithLockAndPersist(final String nodeUrl) {
return setPersistedInfraVariable(() -> {
RMDeployingNode removedDeployingNode = this.deployingNodesMap.remove(nodeUrl);
getPersistedDeployingNodesUrl().remove(nodeUrl);
return removedDeployingNode;
});
}
use of org.ow2.proactive.resourcemanager.rmnode.RMDeployingNode in project scheduling by ow2-proactive.
the class InfrastructureManager method addDeployingNodeWithLockAndPersist.
protected RMDeployingNode addDeployingNodeWithLockAndPersist(final String nodeUrl, final RMDeployingNode deployingNode) {
return setPersistedInfraVariable(() -> {
RMDeployingNode previousDeployingNode = this.deployingNodesMap.put(nodeUrl, deployingNode);
getPersistedDeployingNodesUrl().add(nodeUrl);
return previousDeployingNode;
});
}
Aggregations