Examples with BooleanWrapper org.objectweb.proactive.core.util.wrapper.BooleanWrapper used on opensource projects

Example 6 with BooleanWrapper

use of org.objectweb.proactive.core.util.wrapper.BooleanWrapper in project scheduling by ow2-proactive.

the class RMCore method configureDeployedNodeSource.

private void configureDeployedNodeSource(String nodeSourceName, NodeSourceDescriptor nodeSourceDescriptor, NodeSource nodeSourceStub, NodeSourcePolicy nodeSourcePolicyStub) {
    // Adding access to the core for node source and policy.
    // In order to do it node source and policy active objects are added to the clients list.
    // They will be removed from this list when node source is unregistered.
    UniqueID nsId = Client.getId(nodeSourceStub);
    UniqueID policyId = Client.getId(nodeSourcePolicyStub);
    if (nsId == null || policyId == null) {
        throw new IllegalStateException("Cannot register the node source");
    }
    BooleanWrapper result = nodeSourceStub.activate();
    if (!result.getBooleanValue()) {
        logger.error(NODE_SOURCE_STRING + nodeSourceName + " cannot be activated");
    }
    Client provider = nodeSourceDescriptor.getProvider();
    Client nsService = new Client(provider.getSubject(), false);
    Client policyService = new Client(provider.getSubject(), false);
    nsService.setId(nsId);
    policyService.setId(policyId);
    RMCore.clients.put(nsId, nsService);
    RMCore.clients.put(policyId, policyService);
}

Example 7 with BooleanWrapper

use of org.objectweb.proactive.core.util.wrapper.BooleanWrapper 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 8 with BooleanWrapper

use of org.objectweb.proactive.core.util.wrapper.BooleanWrapper in project scheduling by ow2-proactive.

the class RMCore method deployNodeSource.

/**
 * {@inheritDoc}
 */
@Override
public BooleanWrapper deployNodeSource(String nodeSourceName) {
    if (!this.deployedNodeSources.containsKey(nodeSourceName)) {
        NodeSourceDescriptor nodeSourceDescriptor = this.retrieveNodeSourceDescriptorOrFail(nodeSourceName);
        logger.info("Deploy node source " + nodeSourceName + REQUESTED_BY_STRING + this.caller.getName());
        this.updateNodeSourceDescriptorWithStatusAndPersist(nodeSourceDescriptor, NodeSourceStatus.NODES_DEPLOYED);
        NodeSource nodeSourceToDeploy = this.createNodeSourceInstance(nodeSourceDescriptor);
        NodeSourcePolicy nodeSourcePolicyStub = this.createNodeSourcePolicyActivity(nodeSourceDescriptor, nodeSourceToDeploy);
        NodeSource nodeSourceStub = this.createNodeSourceActivity(nodeSourceName, nodeSourceToDeploy);
        this.configureDeployedNodeSource(nodeSourceName, nodeSourceDescriptor, nodeSourceStub, nodeSourcePolicyStub);
        this.deployedNodeSources.put(nodeSourceName, nodeSourceStub);
        this.monitoring.nodeSourceEvent(new RMNodeSourceEvent(RMEventType.NODESOURCE_CREATED, this.caller.getName(), nodeSourceStub.getName(), nodeSourceStub.getDescription(), nodeSourceStub.getAdministrator().getName(), nodeSourceStub.getStatus().toString()));
        logger.info(NODE_SOURCE_STRING + nodeSourceName + " has been successfully deployed");
    }
    return new BooleanWrapper(true);
}

Example 9 with BooleanWrapper

use of org.objectweb.proactive.core.util.wrapper.BooleanWrapper 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 10 with BooleanWrapper

use of org.objectweb.proactive.core.util.wrapper.BooleanWrapper in project scheduling by ow2-proactive.

the class RestartDownNodesPolicy method activate.

/**
 * Activates static policy. Register a listener in RMMonitoring
 */
@Override
public BooleanWrapper activate() {
    acquireAllNodes();
    timer.schedule(new TimerTask() {

        @Override
        public void run() {
            int numberOfNodesToDeploy = 0;
            for (Node downNode : nodeSource.getDownNodes()) {
                String nodeUrl = downNode.getNodeInformation().getURL();
                logger.info("Removing down node " + nodeUrl);
                BooleanWrapper removed = nodeSource.getRMCore().removeNode(nodeUrl, true);
                if (removed.getBooleanValue()) {
                    logger.info("Down node removed " + nodeUrl);
                    numberOfNodesToDeploy++;
                }
            }
            for (RMDeployingNode lostNode : nodeSource.getDeployingAndLostNodes()) {
                if (!lostNode.isLost()) {
                    continue;
                }
                String nodeUrl = lostNode.getNodeURL();
                logger.info("Removing lost node " + nodeUrl);
                BooleanWrapper removed = nodeSource.getRMCore().removeNode(nodeUrl, true);
                if (removed.getBooleanValue()) {
                    logger.info("Lost node removed " + nodeUrl);
                    numberOfNodesToDeploy++;
                }
            }
            if (numberOfNodesToDeploy > 0) {
                logger.info("Acquiring " + numberOfNodesToDeploy + " nodes");
                acquireNodes(numberOfNodesToDeploy);
            }
        }
    }, checkNodeStateEach, checkNodeStateEach);
    return new BooleanWrapper(true);
}