Examples with RMNode org.ow2.proactive.resourcemanager.rmnode.RMNode used on opensource projects

Example 61 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode in project scheduling by ow2-proactive.

the class RMCore method releaseNodes.

/**
 * {@inheritDoc}
 */
public BooleanWrapper releaseNodes(NodeSet nodes) {
    if (nodes.getExtraNodes() != null) {
        // do not forget to release extra nodes
        nodes.addAll(nodes.getExtraNodes());
    }
    // exception to throw in case of problems
    RuntimeException exception = null;
    NodeSet nodesReleased = new NodeSet();
    NodeSet nodesFailedToRelease = new NodeSet();
    for (Node node : nodes) {
        String nodeURL = null;
        try {
            nodeURL = node.getNodeInformation().getURL();
            logger.debug("Releasing node " + nodeURL);
        } catch (RuntimeException e) {
            logger.debug("A Runtime exception occurred while obtaining information on the node," + "the node must be down (it will be detected later)", e);
            // node is down, will be detected by pinger
            exception = new IllegalStateException(e.getMessage(), e);
            nodesFailedToRelease.add(node);
        }
        // verify whether the node has not been removed from the RM
        if (this.allNodes.containsKey(nodeURL)) {
            RMNode rmnode = this.getNodebyUrl(nodeURL);
            // free
            if (rmnode.isFree()) {
                logger.warn("Client " + caller + " tries to release the already free node " + nodeURL);
                nodesFailedToRelease.add(node);
            } else if (rmnode.isDown()) {
                logger.warn("Node was down, it cannot be released");
                nodesFailedToRelease.add(node);
            } else {
                Set<? extends IdentityPrincipal> userPrincipal = rmnode.getOwner().getSubject().getPrincipals(UserNamePrincipal.class);
                Permission ownerPermission = new PrincipalPermission(rmnode.getOwner().getName(), userPrincipal);
                try {
                    caller.checkPermission(ownerPermission, caller + " is not authorized to free node " + node.getNodeInformation().getURL());
                    if (rmnode.isToRemove()) {
                        removeNodeFromCoreAndSource(rmnode, caller);
                        nodesReleased.add(node);
                    } else {
                        internalSetFree(rmnode);
                        nodesReleased.add(node);
                    }
                } catch (SecurityException ex) {
                    logger.error(ex.getMessage(), ex);
                    nodesFailedToRelease.add(node);
                    exception = ex;
                }
            }
        } else {
            logger.warn("Cannot release unknown node " + nodeURL);
            nodesFailedToRelease.add(node);
            exception = new IllegalArgumentException("Cannot release unknown node " + nodeURL);
        }
    }
    logger.info("Nodes released : " + nodesReleased);
    if (!nodesFailedToRelease.isEmpty()) {
        logger.warn("Nodes failed to release : " + nodesFailedToRelease);
    }
    if (exception != null) {
        // throwing the latest exception we had
        throw exception;
    }
    return new BooleanWrapper(true);
}

Example 62 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode 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(NodeSource::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;
}

Example 63 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode in project scheduling by ow2-proactive.

the class RMCore method setFreeNodes.

/**
 * Mark nodes as free after cleaning procedure.
 *
 * @param nodes to be free
 * @return true if all successful, false if there is a down node among nodes
 */
public BooleanWrapper setFreeNodes(List<RMNode> nodes) {
    boolean result = true;
    for (RMNode node : nodes) {
        // getting the correct instance
        RMNode rmnode = this.getNodebyUrl(node.getNodeURL());
        // freeing it
        result &= internalSetFree(rmnode).getBooleanValue();
    }
    return new BooleanWrapper(result);
}

Example 64 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode in project scheduling by ow2-proactive.

the class RMCore method persistUpdatedRMNodeIfRecoveryEnabled.

/**
 * Update the information of the given node in database.
 *
 * @param rmNode the node to update in database
 */
private void persistUpdatedRMNodeIfRecoveryEnabled(RMNode rmNode) {
    if (nodesRecoveryEnabledForNode(rmNode)) {
        RMNodeData rmNodeData = RMNodeData.createRMNodeData(rmNode);
        dbManager.updateNode(rmNodeData, rmNode.getNodeSourceName());
    }
}

Example 65 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode in project scheduling by ow2-proactive.

the class RMCore method setBusyNode.

/**
 * Set a node state to busy. Set the node to busy, and move the node to the
 * internal busy nodes list. An event informing the node state's change is
 * thrown to RMMonitoring.
 *
 * @param owner
 * @param nodeUrl node to set
 */
public void setBusyNode(final String nodeUrl, Client owner) throws NotConnectedException {
    final RMNode rmNode = this.allNodes.get(nodeUrl);
    if (rmNode == null) {
        logger.error("Unknown node " + nodeUrl);
        return;
    }
    if (!clients.containsKey(owner.getId())) {
        logger.warn(nodeUrl + " cannot set busy as the client disconnected " + owner);
        throw new NotConnectedException("Client " + owner + " is not connected to the resource manager");
    }
    // If the node is already busy no need to go further
    if (rmNode.isBusy()) {
        return;
    }
    // Get the previous state of the node needed for the event
    final NodeState previousNodeState = rmNode.getState();
    rmNode.setBusy(owner);
    this.eligibleNodes.remove(rmNode);
    persistUpdatedRMNodeIfRecoveryEnabled(rmNode);
    // create the event
    this.registerAndEmitNodeEvent(rmNode.createNodeEvent(RMEventType.NODE_STATE_CHANGED, previousNodeState, owner.getName()));
}