org/objectweb/proactive/core/process/prun/PrunSubProcess.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.core.process.prun;

import java.util.StringTokenizer;

import org.objectweb.proactive.core.config.ProActiveConfiguration;
import org.objectweb.proactive.core.process.AbstractExternalProcessDecorator;
import org.objectweb.proactive.core.process.ExternalProcess;
import org.objectweb.proactive.core.process.MessageSink;
import org.objectweb.proactive.core.process.SimpleExternalProcess;
import org.objectweb.proactive.core.process.UniversalProcess;


public class PrunSubProcess extends AbstractExternalProcessDecorator {
        
    //    private static final String DEFAULT_SCRIPT_LOCATION = System.getProperty(
    //            "user.home") + FILE_SEPARATOR + "ProActive" + FILE_SEPARATOR +
    //        "scripts" + FILE_SEPARATOR + "unix" + FILE_SEPARATOR + "cluster" +
    //        FILE_SEPARATOR + "startRuntime.sh ";
    //  public final static String DEFAULT_PBSPATH = FILE_SEPARATOR + "usr" +
    //      FILE_SEPARATOR + "local" + FILE_SEPARATOR + "pbs" + FILE_SEPARATOR +
    //      "bin";
    //    public final static String DEFAULT_QSUBPATH = DEFAULT_PBSPATH +
    //        FILE_SEPARATOR + "qsub";
    public final static String DEFAULT_PRUNPATH = "/usr/local/bin/prun";

    //  public final static String DEFAULT_QJOBPATH = DEFAULT_PBSPATH +
    //       FILE_SEPARATOR + "qjobs";
    // public static final String DEFAULT_QUEUE_NAME = "normal";
    protected static final String DEFAULT_HOSTS_NUMBER = "1";
    protected static final String DEFAULT_PROCESSOR_NUMBER = "1";
    protected static final String DEFAULT_BOOKING_DURATION = "00:01:00";
    private static final String FILE_TRANSFER_DEFAULT_PROTOCOL = null;
    protected int jobID;
    protected String queueName;
    protected String hostList;

    //  protected String scriptLocation = DEFAULT_SCRIPT_LOCATION;
    protected String hosts = DEFAULT_HOSTS_NUMBER;
    protected String processorPerNode = DEFAULT_PROCESSOR_NUMBER;
    protected String bookingDuration = DEFAULT_BOOKING_DURATION;
    protected String interactive = "false";
    protected String outputFile;

    //
    // -- CONSTRUCTORS -----------------------------------------------
    //

    public PrunSubProcess() {
        super();
        setCompositionType(GIVE_COMMAND_AS_PARAMETER);
        this.hostname = null;
        this.command_path = DEFAULT_PRUNPATH;
    }

    public PrunSubProcess(ExternalProcess targetProcess) {
        super(targetProcess);
        this.hostname = null;
        this.command_path = DEFAULT_PRUNPATH;
    }

    //
    // -- PUBLIC METHODS -----------------------------------------------
    //
    //    public void setInputMessageLogger(RemoteProcessMessageLogger inputMessageLogger) {
    //        super.setInputMessageLogger(new CompositeMessageLogger(
    //                new ParserMessageLogger(), inputMessageLogger));
    //    }
 
    public void setOutputMessageSink(MessageSink outputMessageSink) {
        if (outputMessageSink == null) {
            super.setOutputMessageSink(new SimpleMessageSink());
        } else {
            super.setOutputMessageSink(outputMessageSink);
        }
    }

    public static ExternalProcess buildBKillProcess(int jobID) {
        return new SimpleExternalProcess("qdel " + jobID);
    }

    public static void main(String[] args) {
        ProActiveConfiguration.load();
        try {
            PrunSubProcess p = new PrunSubProcess(new SimpleExternalProcess(
                        "/bin/ls "));
            p.setHostsNumber("2");
            p.setQueueName("plugtest");
            p.startProcess();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String getOutputFile() {
        return outputFile;
    }

    public void setOutputFile(String string) {
        outputFile = string;
    }

    public int getJobID() {
        return jobID;
    }

    public String getQueueName() {
        return queueName;
    }

    /* (non-Javadoc)
     * @see org.objectweb.proactive.core.process.UniversalProcess#stopProcess()
     */
    public void stopProcess() {
        //System.out.println("PrunSubProcess.stopProcess()");
        super.stopProcess();
    }

    public void setQueueName(String queueName) {
        checkStarted();
        if (queueName == null) {
            throw new NullPointerException();
        }
        this.queueName = queueName;
    }

    public void setHostList(String hostList) {
        checkStarted();
        this.hostList = hostList;
    }

    public String getHostList() {
        return hostList;
    }

    //    /**
    //     * Returns true if this BsubProcess is lauched with -I option false otherwise
    //     * @return boolean
    //     */
    //    public String isInteractive() {
    //        return interactive;
    //    }

    public void setBookingDuration(String d) {
        this.bookingDuration = d;
    }

    public String getBookingDuration() {
        return this.bookingDuration;
    }

    protected String parseHostname(String message) {
        String result = new String();
        if (logger.isDebugEnabled()) {
            logger.debug("parseHostname() analyzing " + message);
        }
        java.util.StringTokenizer st = new java.util.StringTokenizer(message);
        if (st.countTokens() < 2) {
            return null; //at least two tokens
        }
        if (!":".equals(st.nextToken())) {
            return null; //should start with :
        }

        while (st.hasMoreTokens()) {
            result += (st.nextToken());
            result += " ";
        }
        return result;
    }

    public void setInteractive(String interactive) {
        this.interactive = interactive;
    }

    public void setHostsNumber(String hosts) {
        checkStarted();
        if (hosts != null) {
            this.hosts = hosts;
        }

        // System.out.println("-------- setNodeNumber() " + nodes);
    }

    public void setProcessorPerNodeNumber(String processorPerNode) {
        checkStarted();
        if (processorPerNode != null) {
            this.processorPerNode = processorPerNode;
        }
    }

    public String getProcessId() {
        return "prun_" + targetProcess.getProcessId();
    }

    public int getNodeNumber() {
        return (new Integer(getProcessorPerNodeNumber()).intValue() * (new Integer(getHostsNumber()).intValue()));
    }

    public UniversalProcess getFinalProcess() {
        checkStarted();
        return targetProcess.getFinalProcess();
    }

    public String getHostsNumber() {
        return this.hosts;
    }

    public String getProcessorPerNodeNumber() {
        return this.processorPerNode;
    }

    //    public void setScriptLocation(String location) {
    //        checkStarted();
    //        if (location != null) {
    //            this.scriptLocation = location;
    //        }
    //    }
    //
    //    public String getScriptLocation() {
    //        return scriptLocation;
    //    }
    //
    // -- PROTECTED METHODS -----------------------------------------------
    //
    protected String internalBuildCommand() {
        return buildEnvironmentCommand(); // + buildPSubCommand();
    }

    protected void sendJobDetailsCommand() {
        //   outputMessageSink.setMessage(buildBJobsCommand());
    }

    protected void internalStartProcess(String command)
        throws java.io.IOException {
        //        System.out.println(
        //            "---------------Internal start process of PBSSubProcess " +
        //            command);
        if (logger.isDebugEnabled()) {
            logger.debug(command);
        }

        super.internalStartProcess(command);
    }

    protected String buildCommand() {
        StringBuilder prunCommand = new StringBuilder();
        prunCommand.append(command_path);
        if (interactive.equals("true")) {
            prunCommand.append(" -I");
        }

        String[] commandAndOptions = separateCommandFromOptions(targetProcess.getCommand());
        prunCommand.append(" -no-panda -v -" + processorPerNode + " -t " +
            bookingDuration + " ");

        if (queueName != null) {
            //prunCommand.append("-native '-q " + queueName + "' ");
            prunCommand.append("-q " + queueName + " ");
        }

        if (hostList != null) {
            prunCommand.append("-m " + hostList + " ");
        }

        if (outputFile != null) {
            prunCommand.append("-o " + outputFile + " ");
        }

        prunCommand.append(commandAndOptions[0] + " " + hosts + " " +
            commandAndOptions[1]); // " -q " + queueName + " ");

        if (logger.isDebugEnabled()) {
            logger.debug("prun command is " + prunCommand.toString());
        }
        return prunCommand.toString();
    }

    protected String[] separateCommandFromOptions(String s) {
        String[] result = { "", "" };

        //the problem is that the command we get should be splitted in command+option
        //since prun likes to have options for the command at the very end
        //of the line, after the requested number of nodes
        StringTokenizer st = new StringTokenizer(s);
        if (st.countTokens() > 1) {
            result[0] = st.nextToken();
            while (st.hasMoreTokens()) {
                result[1] += st.nextToken();
                result[1] += " ";
            }
        }
        return result;
    }

    public String getFileTransferDefaultCopyProtocol() {
        return FILE_TRANSFER_DEFAULT_PROTOCOL;
    }

    // end inner class CompositeMessageLogger
}

---