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

import org.objectweb.proactive.core.process.filetransfer.FileTransferWorkShop;
import org.objectweb.proactive.core.util.RemoteProcessMessageLogger;

import java.io.IOException;

import java.util.ArrayList;


public abstract class AbstractListProcessDecorator
    implements ExternalProcessDecorator {
    //Array of processes
    protected ArrayList<ExternalProcessDecorator> processes;

    //baseProcess is used to get the common configuration
    protected ExternalProcessDecorator baseProcess;

    //represent the fixed part of the hostName
    protected String fixedName;
    protected String domain;
    protected String list;
    private String tmp;
    protected String beginIndex;
    protected String endIndex;
    protected int padding = 1;
    protected int repeat = 1;
    protected int step = 1;
    protected ArrayList<String> excludeArray = new ArrayList<String>();
    protected int nodeNumber = 0;

    public AbstractListProcessDecorator() {
        processes = new ArrayList<ExternalProcessDecorator>();
    }

    public void setHostConfig(String fixedName, String list, String domain,
        int padding, int repeat) {
        this.fixedName = fixedName;
        this.domain = domain;
        this.padding = padding;
        this.repeat = repeat;
        this.list = list.replaceAll("\\s", "");
        setAllIndex(this.list);
        for (int i = Integer.parseInt(beginIndex);
                i <= Integer.parseInt(endIndex); i = i + step) {
            tmp = "" + i; //we change as String to check the array
            if (!excludeArray.contains(tmp)) {
                for (int count=0; count<repeat; count++) {
                        setHostname(handlePadding(tmp));
                }
            }
        }
        baseProcess = processes.get(0);
    }

    public void setHostList(String hostlistattr, String domain) {
        String[] hostlist = hostlistattr.split("\\s");
        if (checkNonEmpty(domain)) {
            if (!domain.startsWith(".")) {
                domain = "." + domain;
            }
            for (int i = 0; i < hostlist.length; i++) {
                String hostname = hostlist[i] + domain;
                setHostname(hostname);
            }
        } else {
            for (int i = 0; i < hostlist.length; i++) {
                setHostname(hostlist[i]);
            }
        }
        baseProcess =  processes.get(0);
    }

    //
    //--------------------------Implements ExternalProcessDecorator----------------------

    public ExternalProcess getTargetProcess() {
        return baseProcess.getTargetProcess();
    }

    public void setTargetProcess(ExternalProcess targetProcess) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setTargetProcess(targetProcess);
        }
    }

    public int getCompositionType() {
        return baseProcess.getCompositionType();
    }

    public void setCompositionType(int compositionType) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setCompositionType(compositionType);
        }
    }

    public FileTransferWorkShop getFileTransferWorkShopRetrieve() {

        /* TODO Check if this is the correct place
         * implement this. Then implement it
         */
        return null;
    }

    public FileTransferWorkShop getFileTransferWorkShopDeploy() {

        /* TODO Check if this is the correct place
         * implement this. Then implement it
         */
        return null;
    }

    public void startFileTransfer() {

        /* TODO Check if this is the correct place
         * implement this. Then implement it
         */
    }

    public boolean isRequiredFileTransferDeployOnNodeCreation() {

        /* TODO Check if this is the correct place
         * implement this. Then implement it
         */
        return false;
    }

    public void closeStream() {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).closeStream();
        }
    }

    public RemoteProcessMessageLogger getInputMessageLogger() {
        return baseProcess.getInputMessageLogger();
    }

    public RemoteProcessMessageLogger getErrorMessageLogger() {
        return baseProcess.getErrorMessageLogger();
    }

    public MessageSink getOutputMessageSink() {
        return baseProcess.getOutputMessageSink();
    }

    public void setInputMessageLogger(
        RemoteProcessMessageLogger inputMessageLogger) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setInputMessageLogger(inputMessageLogger);
        }
    }

    public void setErrorMessageLogger(
        RemoteProcessMessageLogger errorMessageLogger) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setErrorMessageLogger(errorMessageLogger);
        }
    }

    public void setOutputMessageSink(MessageSink outputMessageSink) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setOutputMessageSink(outputMessageSink);
        }
    }

    public String[] getEnvironment() {
        return baseProcess.getEnvironment();
    }

    public void setEnvironment(String[] environment) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setEnvironment(environment);
        }
    }

    public String getHostname() {
        return fixedName;
    }

    public void setHostname(String hostname) {
        ExternalProcessDecorator process = createProcess();
        process.setHostname(hostname);
        processes.add(process);
    }

    public String getUsername() {
        return baseProcess.getUsername();
    }

    public void setUsername(String username) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setUsername(username);
        }
    }

    public String getCommand() {
        return baseProcess.getCommandPath() + " " + fixedName + " " + list +
        " " + domain;
    }

    public String getProcessId() {
        return baseProcess.getProcessId();
    }

    public int getNodeNumber() {
        if (nodeNumber == 0) {
            for (int i = 0; i < processes.size(); i++) {
                nodeNumber = nodeNumber +
                    ( processes.get(i)).getNodeNumber();
            }
        }
        return nodeNumber;
    }

    public UniversalProcess getFinalProcess() {
        return baseProcess.getFinalProcess();
    }

    public void startProcess() throws IOException {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).startProcess();
        }
    }

    public void stopProcess() {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).stopProcess();
        }
    }

    public int waitFor() throws InterruptedException {
        int status = 0;
        for (int i = 0; i < processes.size(); i++) {
            status = ( processes.get(i)).waitFor();
            if (status != 0) {
                return status;
            }
        }
        return status;
    }

    public boolean isStarted() {
        boolean started = true;
        for (int i = 0; i < processes.size(); i++) {
            started = ( processes.get(i)).isStarted();
            if (!started) {
                return started;
            }
        }
        return started;
    }

    public boolean isFinished() {
        boolean finished = true;
        for (int i = 0; i < processes.size(); i++) {
            finished = ( processes.get(i)).isFinished();
            if (!finished) {
                return finished;
            }
        }
        return finished;
    }

    /* Return true if this process is hierarchical, false otherwise  */
    public boolean isHierarchical() {
        return false;
    }

    /* Return true if this process is dependent, false otherwise */
    public boolean isDependent() {
        return false;
    }

    /* Return true if this process is sequential, false otherwise */
    public boolean isSequential() {
        return false;
    }

    public void setCommandPath(String path) {
        for (int i = 0; i < processes.size(); i++) {
            ( processes.get(i)).setCommandPath(path);
        }
    }

    public String getCommandPath() {
        return baseProcess.getCommandPath();
    }

    //
    //-----------------protected methods----------------------------------------
    //
    protected abstract ExternalProcessDecorator createProcess();

    protected void setAllIndex(String list) {
        int index1 = list.indexOf(';');
        int index2 = list.indexOf(']');
        int index3 = list.indexOf('^');
        beginIndex = list.substring(1, list.indexOf('-'));
        if (index1 == -1) {
            endIndex = list.substring(list.indexOf('-') + 1, index2);
        } else {
            endIndex = list.substring(list.indexOf('-') + 1, index1);
            String scount = list.substring(index1 + 1, index2);
            step = new Integer(scount).intValue();
        }
        if (index3 != -1) {
            String[] listexclude = list.substring(list.lastIndexOf('[') + 1,
                    list.lastIndexOf(']')).split(",");
            for (int i = 0; i < listexclude.length; i++) {
                if (listexclude[i].indexOf("-") < 0) {
                    excludeArray.add(listexclude[i]);
                } else {
                    String init = listexclude[i].substring(0,
                            listexclude[i].indexOf("-"));
                    String end = listexclude[i].substring(listexclude[i].indexOf(
                                "-") + 1, listexclude[i].length());
                    for (int j = Integer.parseInt(init);
                            j <= Integer.parseInt(end); j++) {
                        excludeArray.add(new Integer(j).toString());
                    }
                }
            }
        }
    }

    protected String handlePadding(String word) {
        int wlength = word.length();
        if (wlength < padding) {
            for (int i = 0; i < (padding - wlength); i++) {
                word = "0" + word;
            }
        }
        if (domain.length() > 0) {
            if (!domain.startsWith(".")) {
                domain = "." + domain;
            }
        }
        return fixedName + word + domain;
    }

    protected boolean checkNonEmpty(String s) {
        return (s != null) && (s.length() > 0);
    }

    public int exitValue() throws IllegalThreadStateException {
        // TODO Auto-generated method stub
        return 0;
    }

    public void setStarted(boolean isStarted) {
        // TODO Auto-generated method stub
    }

    public void setFinished(boolean isFinished) {
        // TODO Auto-generated method stub
    }
}

---