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

import javax.naming.directory.InvalidAttributeValueException;

import org.glite.wms.jdlj.*; // /lib/glite/glite-wms-jdlj.jar
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.ProActiveException;
import org.objectweb.proactive.core.descriptor.data.ProActiveDescriptor;
import org.objectweb.proactive.core.process.AbstractExternalProcessDecorator;
import org.objectweb.proactive.core.process.ExternalProcess;
import org.objectweb.proactive.core.process.JVMProcess;
import org.objectweb.proactive.core.process.UniversalProcess;
import org.objectweb.proactive.core.process.filetransfer.FileDependant;
import org.objectweb.proactive.core.process.filetransfer.FileTransferDefinition;

import java.util.LinkedList;


public class GLiteProcess extends AbstractExternalProcessDecorator
        implements FileDependant {

    private static final long serialVersionUID = 1L;
    private static final String FILE_SEPARATOR = System.getProperty(
            "file.separator");
    protected static final String DEFAULT_PROCESSOR_NUMBER = "1";
    protected static final String DEFAULT_COMMAND_PATH = "glite-job-submit";
    protected static final String DEFAULT_FILE_LOCATION = System.getProperty(
            "user.home") + FILE_SEPARATOR + "public" + FILE_SEPARATOR + "JDL";
    protected static final String DEFAULT_STDOUPUT = System.getProperty(
            "user.home") + FILE_SEPARATOR + "out.log";
    protected static final String DEFAULT_CONFIG_FILE = System.getProperty(
            "user.home") + FILE_SEPARATOR + "public" + FILE_SEPARATOR + "JDL" +
            FILE_SEPARATOR + "vo.conf";
    protected int jobID;
    protected String hostList;
    protected String processor = DEFAULT_PROCESSOR_NUMBER;
    protected String command_path = DEFAULT_COMMAND_PATH;
    protected String interactive = "false";
    protected String filePath = DEFAULT_FILE_LOCATION;
    protected String stdOutput = DEFAULT_STDOUPUT;
    protected String fileName = "job.jdl";
    protected String configFile = DEFAULT_CONFIG_FILE;
    protected String remoteFilePath = null;
    protected boolean confFileOption = false;
    protected boolean jdlRemote = false;
    protected String netServer;
    protected String logBook;
    /*jdl related fields*/
    protected GLiteJobAd jad;
    protected int jobNodeNumber = 2;
    protected String jobType;
    protected String jobJobType;
    protected String jobExecutable;
    protected String jobStdOutput;
    protected String jobStdInput;
    protected String jobStdError;
    protected String jobOutput_se;
    protected String jobVO;
    protected String jobRetryCount;
    protected String jobMyProxyServer;
    protected String jobDataAccessProtocol;
    protected String jobStorageIndex;
    protected String jobEnvironment;
    protected String jobRequirements;
    protected String jobRank;
    protected String jobFuzzyRank;
    protected String jobArgument;
    protected LinkedList jobInputSB;
    protected LinkedList jobOutputSB;

    public GLiteProcess() {
        super();
        setCompositionType(COPY_FILE_AND_APPEND_COMMAND);
        this.hostname = null;
        command_path = DEFAULT_COMMAND_PATH;
        jad = new GLiteJobAd();
    }

    public GLiteProcess(ExternalProcess targetProcess) {
        super(targetProcess);
        setCompositionType(COPY_FILE_AND_APPEND_COMMAND);
        this.hostname = null;
        jad = new GLiteJobAd();
    }


    public static void main(String[] args) {
        ProActiveDescriptor pad;
        try {
            pad = ProActive.getProactiveDescriptor(args[0]);
            pad.activateMappings();
        } catch (ProActiveException e) {
            e.printStackTrace();
        }
    }

    public void buildJdlFile() {
        StringBuffer gLiteCommand = new StringBuffer();
        String args;
        gLiteCommand.append(command_path);
        String initial_args = ((JVMProcess) getTargetProcess()).getCommand();

        if (this.getJobType().equals("MPICH")) {
            args = this.getJobExecutable() + initial_args.substring(initial_args.indexOf("/bin/java") + "/bin/java".length());
            /*arguments will be parsed again at script level within gLite environment*/
            this.setJobExecutable("gLiteStartRuntime.sh");
        } else {
            args = initial_args.substring(initial_args.indexOf("/bin/java") + "/bin/java".length());
        }
    
        args = checkSyntax(args);

        try {
            /*multiple job*/
            if (this.getJobType().equals("job") && this.getJobJobType().equals("mpich") ) {
                this.jad.addAttribute(Jdl.TYPE,  "job");
                this.jad.addAttribute(Jdl.JOBTYPE,  Jdl.JOBTYPE_MPICH);
                this.jad.addAttribute(Jdl.NODENUMB, this.getJobNodeNumber());

            /*single job, number of nodes doesn t matter (so far)*/
            } else if (this.getJobType() != null) {
                this.jad.addAttribute(Jdl.TYPE, "job");
            }

            if (this.getJobExecutable() != null)
                this.jad.addAttribute(Jdl.EXECUTABLE, this.getJobExecutable());

            if (this.getJobStdOutput() != null)
                this.jad.addAttribute(Jdl.STDOUTPUT, this.getJobStdOutput());

            if (this.getJobStdInput() != null)
                this.jad.addAttribute(Jdl.STDINPUT, this.getJobStdInput());

            if (this.getJobStdError() != null)
                this.jad.addAttribute(Jdl.STDERROR, this.getJobStdError());

            if (this.getJobOutput_se() != null)
                this.jad.addAttribute(Jdl.OUTPUT_SE, this.getJobOutput_se());

            if (this.getJobVO() != null)
                this.jad.addAttribute(Jdl.VIRTUAL_ORGANISATION, this.getJobVO());

            if (this.getJobRetryCount() != null)
                this.jad.addAttribute(Jdl.RETRYCOUNT, Integer.parseInt(getJobRetryCount()));

            if (this.getJobMyProxyServer() != null)
                this.jad.addAttribute(Jdl.MYPROXY, this.getJobMyProxyServer());

            if (this.getJobEnvironment() != null)
                this.jad.addAttribute(Jdl.ENVIRONMENT, this.getJobEnvironment());

            if (this.getJobRequirements() != null)
                this.jad.setAttributeExpr(Jdl.REQUIREMENTS, this.getJobRequirements());

            if (this.getJobRank() != null)
                this.jad.setAttributeExpr(Jdl.RANK, this.getJobRank());

            if (this.getJobDataAccessProtocol() != null)
                this.jad.addAttribute(Jdl.DATA_ACCESS, this.getJobDataAccessProtocol());

            if (this.getJobStorageIndex() != null)
                this.jad.addAttribute(Jdl.OD_STORAGE_ELEMENT, this.getJobStorageIndex());

            if (this.getJobFuzzyRank() != null)
                this.jad.addAttribute(Jdl.FUZZY_RANK, this.getJobFuzzyRank());

            if (this.jobInputSB != null && this.jobInputSB.size() > 0) {
                for (int i = 0; i < this.jobInputSB.size(); i++) {
                    String entry = (String) jobInputSB.get(i);
                    this.jad.addAttribute(Jdl.INPUTSB, entry);
                }
            }
            if (this.jobOutputSB != null && this.jobOutputSB.size() > 0) {
                for (int i = 0; i < this.jobOutputSB.size(); i++) {
                    String entry = (String) jobOutputSB.get(i);
                    this.jad.addAttribute(Jdl.OUTPUTSB, entry);
                }
            }
            
            if (jad.hasAttribute(Jdl.ARGUMENTS)) {
                jad.delAttribute(Jdl.ARGUMENTS);
            }
            jad.setAttribute(Jdl.ARGUMENTS, args);
            jad.toFile(filePath + "/" + fileName);

            //examples of requirements
            //jad.setAttributeExpr(Jdl.REQUIREMENTS,"other.GlueCEUniqueID ==\"pps-ce.egee.cesga.es:2119/blah-pbs-picard\"");
            //jad.setAttributeExpr(Jdl.REQUIREMENTS, "!(RegExp(\"*lxb2039*\",other.GlueCEUniqueID))");
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvalidAttributeValueException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected String internalBuildCommand() {
        return buildGLiteCommand();
    }

    protected String buildGLiteCommand() {
        String path = filePath;
        buildJdlFile();

        if (jdlRemote) {
            path = remoteFilePath;
        }

        if (!confFileOption) {
            return DEFAULT_COMMAND_PATH + " " + path + FILE_SEPARATOR +
                    fileName;
        }

        return DEFAULT_COMMAND_PATH + " --config-vo " + configFile + " " +
                path + FILE_SEPARATOR + fileName;
    }

    private String checkSyntax(String args) {
        String formatted_args = "";
        String[] splitted_args = args.split("\\s");
        for (int i = 0; i < splitted_args.length; i++) {
            if (!(splitted_args[i].indexOf("=") < 0)) {
                splitted_args[i] = "\"" + splitted_args[i] + "\"";
            }
            formatted_args = formatted_args + " " + splitted_args[i];
        }
        return formatted_args;
    }

    /* (non-Javadoc)
     * @see org.objectweb.proactive.core.process.UniversalProcess#getProcessId()
     */
    public String getProcessId() {
        return "glite_" + targetProcess.getProcessId();
    }

    public int getNodeNumber() {
        return this.getJobNodeNumber();
    }

    public String getProcessorNumber() {
        return processor;
    }

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

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public String getFilePath() {
        return filePath;
    }

    public void setFilePath(String filePath) {
        this.filePath = filePath;
    }

    public String getCommand_path() {
        return command_path;
    }

    public void setCommand_path(String command_path) {
        this.command_path = command_path;
    }

    public GLiteJobAd getJad() {
        return jad;
    }

    public void addAtt(String attrName, Ad attrValue) throws Exception {
        jad.addAttribute(attrName, attrValue);
    }

    public void addAtt(String attrName, int attrValue)
            throws Exception {
        jad.addAttribute(attrName, attrValue);
    }

    public void addAtt(String attrName, double attrValue)
            throws Exception {
        jad.addAttribute(attrName, attrValue);
    }

    public void addAtt(String attrName, String attrValue)
            throws Exception {
        jad.addAttribute(attrName, attrValue);
    }

    public void addAtt(String attrName, boolean attrValue)
            throws Exception {
        jad.addAttribute(attrName, attrValue);
    }

    public String getNetServer() {
        return netServer;
    }

    public void setNetServer(String netServer) {
        this.netServer = netServer;
    }

    public String getConfigFile() {
        return configFile;
    }

    public void setConfigFile(String configFile) {
        this.configFile = configFile;
    }

    public void setConfigFileOption(boolean b) {
        confFileOption = b;
    }

    public boolean isJdlRemote() {
        return jdlRemote;
    }

    public void setJdlRemote(boolean jdlRemote) {
        this.jdlRemote = jdlRemote;
    }

    public String getRemoteFilePath() {
        return remoteFilePath;
    }

    public void setRemoteFilePath(String remoteFilePath) {
        this.remoteFilePath = remoteFilePath;
    }

    public FileTransferDefinition getFileTransfertDefiniton() {
        FileTransferDefinition ft = new FileTransferDefinition("gliteProcess");
        ft.addFile(filePath + "/" + fileName, remoteFilePath + "/" + fileName);
        return ft;
    }

    public int getJobNodeNumber() {
        return jobNodeNumber;
    }

    public void setJobNodeNumber(int jobNodeNumber) {
        this.jobNodeNumber = jobNodeNumber;
    }

    public String getJobType() {
        return jobType;
    }

    public void setJobType(String jobType) {
        this.jobType = jobType;
    }

    public String getJobJobType() {
        return jobJobType;
    }

    public void setJobJobType(String jobJobType) {
        this.jobJobType = jobJobType;
    }

    public String getJobExecutable() {
        return jobExecutable;
    }

    public void setJobExecutable(String jobExecutable) {
        this.jobExecutable = jobExecutable;
    }

    public String getJobStdOutput() {
        return jobStdOutput;
    }

    public void setJobStdOutput(String jobStdOutput) {
        this.jobStdOutput = jobStdOutput;
    }

    public String getJobStdInput() {
        return jobStdInput;
    }

    public void setJobStdInput(String jobStdInput) {
        this.jobStdInput = jobStdInput;
    }

    public String getJobStdError() {
        return jobStdError;
    }

    public void setJobStdError(String jobStdError) {
        this.jobStdError = jobStdError;
    }

    public String getJobOutput_se() {
        return jobOutput_se;
    }

    public void setJobOutput_se(String jobOutput_se) {
        this.jobOutput_se = jobOutput_se;
    }

    public String getJobVO() {
        return jobVO;
    }

    public void setJobVO(String jobVO) {
        this.jobVO = jobVO;
    }

    public String getJobRetryCount() {
        return jobRetryCount;
    }

    public void setJobRetryCount(String jobRetryCount) {
        this.jobRetryCount = jobRetryCount;
    }

    public String getJobMyProxyServer() {
        return jobMyProxyServer;
    }

    public void setJobMyProxyServer(String jobMyProxyServer) {
        this.jobMyProxyServer = jobMyProxyServer;
    }

    public String getJobDataAccessProtocol() {
        return jobDataAccessProtocol;
    }

    public void setJobDataAccessProtocol(String jobDataAccessProtocol) {
        this.jobDataAccessProtocol = jobDataAccessProtocol;
    }


    public String getJobStorageIndex() {
        return jobStorageIndex;
    }

    public void setJobStorageIndex(String jobStorageIndex) {
        this.jobStorageIndex = jobStorageIndex;
    }

    public String getJobEnvironment() {
        return jobEnvironment;
    }

    public void setJobEnvironment(String jobEnvironment) {
        this.jobEnvironment = jobEnvironment;
    }


    public String getJobRequirements() {
        return jobRequirements;
    }

    public void setJobRequirements(String jobRequirements) {
        this.jobRequirements = jobRequirements;
    }

    public String getJobRank() {
        return jobRank;
    }

    public void setJobRank(String jobRank) {
        this.jobRank = jobRank;
    }

    public String getJobFuzzyRank() {
        return jobFuzzyRank;
    }

    public void setJobFuzzyRank(String jobFuzzyRank) {
        this.jobFuzzyRank = jobFuzzyRank;
    }

    public boolean addInputSBEntry(String entry) {
        if (jobInputSB == null) jobInputSB = new LinkedList();
        return jobInputSB.add(entry);
    }

    public boolean addOutputSBEntry(String entry) {
        if (jobOutputSB == null) jobOutputSB = new LinkedList();
        return jobOutputSB.add(entry);
    }


    public String getJobArgument() {
        return jobArgument;
    }

    public void setJobArgument(String jobArgument) {
        this.jobArgument = jobArgument;
    }

    /******************************************************************************************
     *                                END OF GETTERS AND SETTERS                              *
     ******************************************************************************************/
}

---