org/objectweb/proactive/scheduler/RessourceManager.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.scheduler;

import java.util.Iterator;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.objectweb.proactive.core.node.Node;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.core.util.wrapper.BooleanWrapper;


public class RessourceManager {
    private static Logger logger = ProActiveLogger.getLogger(Loggers.RESSOURCE_MANAGER);

    // There are 3 HashMaps one for the idle nodes another for the nodes that 
    // are busy and one for the reservedNodes that haven't been activated yet. 
    // We can check the size of the HashMap unusedNodes to find out the number 
    // of nodes available ...
    private Vector unusedNodes;
    private Vector reservedNodes;
    private Vector usedNodes;

    public RessourceManager() {
    }

    public RessourceManager(BooleanWrapper b) {
        unusedNodes = new Vector();
        reservedNodes = new Vector();
        usedNodes = new Vector();

        // launches the specific ressourceListener that shall listen for the nodes
        // created and add the newly created node to the queue.
        String xmlURL = RessourceManager.class.getResource(
                "/org/objectweb/proactive/scheduler/test.xml").getPath();

        Vector vnNames = new Vector();
        vnNames.add("SchedulerVN");
        new RessourceListener(this.unusedNodes, xmlURL, vnNames);
        logger.debug("ressource manager created");
    }

    public int getAvailableNodesNb() {
        return this.unusedNodes.size();
    }

    public void freeNodes(String jobId, boolean mainIsDead) {
        int index = 0;
        Vector nodes;

        while ((index != this.usedNodes.size()) &&
                (!((Node) this.usedNodes.get(index)).getNodeInformation()
                       .getJobID().equals(jobId))) {
            index++;
        }
        if (index == this.usedNodes.size()) {
            nodes = this.reservedNodes;
        } else {
            nodes = this.usedNodes;
        }

        this.nodeFreer(nodes, jobId, mainIsDead);
    }

    private void nodeFreer(Vector nodes, String jobId, boolean mainIsDead) {
        int ressourceNumber = 0;
        int indexOfFirstNode = 0;
        int i;

        while (!(((Node) nodes.get(indexOfFirstNode)).getNodeInformation()
                      .getJobID().equals(jobId)))
            indexOfFirstNode++;

        int index = indexOfFirstNode;

        while ((index != nodes.size()) &&
                (((Node) nodes.get(index)).getNodeInformation().getJobID()
                      .equals(jobId))) {
            ressourceNumber++;
            index++;
        }

        if (mainIsDead) {
            nodes.remove(indexOfFirstNode);
            logger.debug("removing dead node");
            i = 1;
        } else {
            i = 0;
        }

        for (; i < ressourceNumber; ++i) {
            Node node = (Node) nodes.get(indexOfFirstNode);
            try {
                if (node.getNumberOfActiveObjects() != 0) {
                    node.killAllActiveObjects();
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            node.getNodeInformation().setJobID("-");
            nodes.remove(indexOfFirstNode);
            this.unusedNodes.add(node);
            logger.debug("node freed " + node.getNodeInformation().getURL());
        }
    }

    public Node reserveNodes(String jobId, int ressourceNumber) {
        if (ressourceNumber == 0) {
            return null;
        }
        Node node = (Node) this.unusedNodes.remove(0);
        node.getNodeInformation().setJobID(jobId);
        this.reservedNodes.add(node);
        logger.debug("node reserved " + node.getNodeInformation().getURL());

        for (int i = 1; i < ressourceNumber; ++i) {
            Node tmpNode = (Node) this.unusedNodes.remove(0);
            tmpNode.getNodeInformation().setJobID(jobId);
            this.reservedNodes.add(tmpNode);
        }

        return node;
    }

    public Node[] getNodes(String jobId, int askedNodes) {
        int indexOfFirstNode = 0;
        while (!(((Node) this.reservedNodes.get(indexOfFirstNode)).getNodeInformation()
                      .getJobID().equals(jobId)))
            indexOfFirstNode++;

        Node[] nodes = new Node[askedNodes];

        for (int i = 0; i < askedNodes; ++i) {
            Node node = (Node) this.reservedNodes.remove(indexOfFirstNode);
            this.usedNodes.add(node);
            nodes[i] = node;
            logger.debug("acquiring reserved node " +
                node.getNodeInformation().getURL());
        }

        return nodes;
    }

    public BooleanWrapper isAvailable(int ressourceNumber) {
        return new BooleanWrapper(ressourceNumber <= this.getAvailableNodesNb());
    }

    public Vector nodes(String nodeURL) {
        Vector nodes = new Vector();

        nodes.addAll(this.unusedNodes);
        nodes.addAll(this.reservedNodes);
        nodes.addAll(this.usedNodes);

        if (nodeURL != null) {
            Iterator iterator = nodes.iterator();
            Node node = null;

            while (iterator.hasNext()) {
                Node tmpNode = (Node) iterator.next();
                if (tmpNode.getNodeInformation().getURL().equals(nodeURL)) {
                    node = tmpNode;
                    break;
                }
            }

            nodes.clear();
            if (node != null) {
                nodes.add(node);
            }
        }

        logger.debug("fetching node(s) description");

        return nodes;
    }

    public BooleanWrapper checkReservation(String jobId) {
        logger.debug("checking for node reservation");
        for (int i = 0; i < this.reservedNodes.size(); ++i) {
            Node node = (Node) this.reservedNodes.get(i);
            if (node.getNodeInformation().getJobID().equals(jobId)) {
                return new BooleanWrapper(true);
            }
        }

        return new BooleanWrapper(false);
    }
}

---