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

Example 11 with RMNode

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

the class RMCore method mapOnNodeUrlSet.

public BooleanWrapper mapOnNodeUrlSet(Set<String> nodeUrls, Predicate<RMNode> operation, String operationName) {
    boolean result = true;
    for (String url : nodeUrls) {
        RMNode rmnode = getNodeByUrlIncludingDeployingNodes(url);
        if (rmnode == null) {
            logger.warn("Cannot " + operationName + ", unknown node: " + url);
            result &= false;
            continue;
        }
        result &= operation.apply(rmnode);
    }
    return new BooleanWrapper(result);
}

Example 12 with RMNode

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

the class RMCore method findBusyNodesNotInSet.

private List<RMNode> findBusyNodesNotInSet(Set<String> nodesURL) {
    if (logger.isDebugEnabled()) {
        logger.debug("Given set of busy nodes URL: " + Arrays.toString(nodesURL.toArray()));
    }
    List<RMNode> busyNodesNotInGivenSet = new LinkedList<>();
    for (Entry<String, RMNode> nodeEntry : allNodes.entrySet()) {
        String nodeUrl = nodeEntry.getKey();
        RMNode node = nodeEntry.getValue();
        if (node.isBusy() && !nodesURL.contains(nodeUrl)) {
            logger.debug("Found busy node not in given set: " + node.getNodeName());
            busyNodesNotInGivenSet.add(node);
        }
    }
    return busyNodesNotInGivenSet;
}

Example 13 with RMNode

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

the class RMCore method setNodesAvailable.

/**
 * This method is called periodically by ProActive Nodes to inform the
 * Resource Manager of a possible reconnection. The method is also used by
 * ProActive Nodes to know if they are still known by the Resource Manager.
 * For instance a Node which has been removed by a user from the
 * Resource Manager is no longer known.
 * <p>
 * The method is defined as Immediate Service. This way it is executed in
 * a dedicated Thread. It is essential in order to allow other methods to
 * be executed immediately even if incoming connection to the Nodes is stopped
 * or filtered while a timeout occurs when this method tries to send back a reply.
 * <p>
 * The {@code allNodes} data-structure is written by a single Thread only
 * but read by multiple Threads.
 * <p>
 * Parallel executions of this method must involves different {@code nodeUrl}s.
 * <p>
 * The underlying calls to {@code setBusyNode} and {@code internalSetFree}
 * are writing to the {@code freeNodes} data-structure. It explains why this last
 * is synchronized (thread-safe).
 *
 * @param nodeUrls the URLs of the workers associated to the node that publishes the update.
 * @return The set of worker node URLs that are unknown to the Resource Manager
 * (i.e. have been removed by a user).
 */
@ImmediateService
@Override
public Set<String> setNodesAvailable(Set<String> nodeUrls) {
    waitForRMCoreToBeInitializedIfNeeded();
    if (logger.isTraceEnabled()) {
        logger.trace("Received availability for the following workers: " + nodeUrls);
    }
    ImmutableSet.Builder<String> nodeUrlsNotKnownByTheRM = new ImmutableSet.Builder<>();
    for (String nodeUrl : nodeUrls) {
        RMNode node = this.allNodes.get(nodeUrl);
        if (node == null) {
            logger.warn("Cannot set node as available, the node is unknown: " + nodeUrl);
            if (logger.isDebugEnabled()) {
                logger.debug("Known nodes are: " + Arrays.toString(allNodes.keySet().toArray()));
            }
            nodeUrlsNotKnownByTheRM.add(nodeUrl);
        } else if (node.isDown()) {
            restoreNodeState(nodeUrl, node);
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("The node identified by " + nodeUrl + " is known and not DOWN, no action performed");
            }
        }
    }
    return nodeUrlsNotKnownByTheRM.build();
}

Example 14 with RMNode

use of org.ow2.proactive.resourcemanager.rmnode.RMNode 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);
    // 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);
    }
    boolean isNodeAdded = rmcore.registerAvailableNode(rmNode).getBooleanValue();
    if (isNodeAdded) {
        // if the node is successfully added we can let it configure
        // asynchronously. It will then be seen as "configuring"
        rmcore.internalRegisterConfiguringNode(rmNode);
        return new BooleanWrapper(true);
    } else {
        return new BooleanWrapper(false);
    }
}

Example 15 with RMNode

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

the class NodeSource method buildRMNodeAfterRecovery.

/**
 * Rebuild a RMNode from a node that could be looked up again after a
 * recovery of the RM. This builder configures nothing for the node
 * because it is configured already as it suppoesed to be recovered from
 * the database.
 * @return the expected RMNode
 */
private RMNode buildRMNodeAfterRecovery(Node node, RMNodeData rmNodeData) {
    RMNodeImpl rmNode = new RMNodeImpl(node, stub, rmNodeData.getName(), rmNodeData.getNodeUrl(), rmNodeData.getProvider(), rmNodeData.getHostname(), rmNodeData.getJmxUrls(), rmNodeData.getJvmName(), rmNodeData.getUserPermission(), rmNodeData.getState());
    if (rmNodeData.getState().equals(NodeState.BUSY)) {
        logger.info("Node " + rmNodeData.getName() + " was found busy after scheduler recovery with owner " + rmNodeData.getOwner());
        rmNode.setBusy(rmNodeData.getOwner());
    }
    return rmNode;
}