Configuration

//******************************************************************************
//
// File:    Configuration.java
// Package: edu.rit.pj.cluster
// Unit:    Class edu.rit.pj.cluster.Configuration
//
// This Java source file is copyright (C) 2012 by Alan Kaminsky. All rights
// reserved. For further information, contact the author, Alan Kaminsky, at
// ark@cs.rit.edu.
//
// This Java source file is part of the Parallel Java Library ("PJ"). PJ is free
// software; you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// PJ 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 General Public License for more details.
//
// Linking this library statically or dynamically with other modules is making a
// combined work based on this library. Thus, the terms and conditions of the GNU
// General Public License cover the whole combination.
//
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent modules, and
// to copy and distribute the resulting executable under terms of your choice,
// provided that you also meet, for each linked independent module, the terms
// and conditions of the license of that module. An independent module is a module
// which is not derived from or based on this library. If you modify this library,
// you may extend this exception to your version of the library, but you are not
// obligated to do so. If you do not wish to do so, delete this exception
// statement from your version.
//
// A copy of the GNU General Public License is provided in the file gpl.txt. You
// may also obtain a copy of the GNU General Public License on the World Wide
// Web at http://www.gnu.org/licenses/gpl.html.
//
//******************************************************************************
package edu.rit.pj.cluster;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Scanner;

/**
 * Class Configuration provides configuration information about a parallel
 * computer running Parallel Java. The configuration information is read from a
 * plain text file. Each configuration file entry is on a single line. Lines
 * beginning with <code>#</code> and blank lines are ignored. The order of the
 * entries in the file does not matter (unless stated otherwise below). The
 * items in each entry are separated by whitespace; there cannot be any
 * whitespace within an item (unless stated otherwise below). The configuration
 * file entries are:
 * <UL>
 *
 * <LI>
 * <code>cluster &lt;name&gt;</code>
 * <BR>The name of the cluster is <code>&lt;name&gt;</code>. The name may contain
 * whitespace. This entry must be specified; there is no default.
 *
 * <LI>
 * <code>logfile &lt;file&gt;</code>
 * <BR>The Job Scheduler will append log entries to the log file named
 * <code>&lt;file&gt;</code>. This entry must be specified; there is no default.
 *
 * <LI>
 * <code>webhost &lt;host&gt;</code>
 * <BR>The host name for the Job Scheduler's web interface is
 * <code>&lt;host&gt;</code>. This entry must be specified; there is no default.
 *
 * <LI>
 * <code>webport &lt;port&gt;</code>
 * <BR>The port number for the Job Scheduler's web interface is
 * <code>&lt;port&gt;</code>. If not specified, the default port number is 8080.
 *
 * <LI>
 * <code>schedulerhost &lt;host&gt;</code>
 * <BR>The host name to which the Job Scheduler listens for connections from job
 * frontend processes is <code>&lt;host&gt;</code>. If not specified, the default is
 * <code>"localhost"</code>.
 *
 * <LI>
 * <code>schedulerport &lt;port&gt;</code>
 * <BR>The port number to which the Job Scheduler listens for connections from
 * job frontend processes is <code>&lt;port&gt;</code>. If not specified, the
 * default port number is 20617.
 *
 * <LI>
 * <code>frontendhost &lt;host&gt;</code>
 * <BR>The host name to which job frontend processes listen for connections from
 * job backend processes is <code>&lt;host&gt;</code>. This entry must be specified;
 * there is no default.
 *
 * <LI>
 * <code>backend &lt;name&gt; &lt;cpus&gt; &lt;host&gt; &lt;jvm&gt;
 * &lt;classpath&gt; [&lt;jvmflag&gt; ...]</code>
 * <BR>The parallel computer includes a backend node named
 * <code>&lt;name&gt;</code> with <code>&lt;cpus&gt;</code> CPUs. The host name for SSH
 * remote logins to the backend node is <code>&lt;host&gt;</code>. The full pathname
 * for executing the Java Virtual Machine (JVM) on the backend node is
 * <code>&lt;jvm&gt;</code>. The Java class path for the Parallel Java Library on
 * the backend node is <code>&lt;classpath&gt;</code>. Each
 * <code>&lt;jvmflag&gt;</code> (zero or more) gives a flag passed to the JVM on the
 * command line. At least one of this entry must be specified.
 *
 * <LI>
 * <code>backendshell &lt;name&gt; &lt;shell command&gt;</code>
 * <BR>On the backend node named <code>&lt;name&gt;</code>, use the given shell
 * command string when starting a job backend process. This entry, if present,
 * must appear after the corresponding <code>backend &lt;name&gt;</code> entry. If
 * this entry is omitted, the default shell command string is
 * <code>"bash&nbsp;-l&nbsp;-c"</code>.
 *
 * <LI>
 * <code>jobtime &lt;time&gt;</code>
 * <BR>The maximum time in seconds any Parallel Java job is allowed to run. The
 * Job Scheduler will abort a job if it runs for this many seconds. If not
 * specified, the default is not to impose a maximum time on jobs. <I>Note:</I>
 * If the Job Scheduler is configured with a maximum job time and a particular
 * job is given a maximum time with the <code>-Dpj.jobtime</code> property, the
 * smaller of the Job Scheduler's maximum job time and the job's maximum time
 * will be used for that job.
 * </UL>
 * <P>
 * Here is an example of a configuration file:
 *
 * <TABLE BORDER=1>
 * <CAPTION>Parallel Java Job Scheduler configuration file</CAPTION>
 * <TR>
 * <TD style="vertical-align:top;">
 * <PRE> # Parallel Java Job Scheduler configuration file
 * # Frontend node: tardis.cs.rit.edu
 * # Backend nodes: dr00-dr09
 *
 * cluster RIT CS Tardis Hybrid SMP Cluster
 * logfile /var/tmp/parajava/scheduler.log
 * webhost tardis.cs.rit.edu
 * webport 8080
 * schedulerhost localhost
 * schedulerport 20617
 * frontendhost 10.10.221.1
 * backend dr00 4 10.10.221.10 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr01 4 10.10.221.11 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr02 4 10.10.221.12 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr03 4 10.10.221.13 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr04 4 10.10.221.14 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr05 4 10.10.221.15 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr06 4 10.10.221.16 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr07 4 10.10.221.17 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr08 4 10.10.221.18 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar
 * backend dr09 4 10.10.221.19 /usr/local/versions/jdk-1.5.0_15/bin/java /var/tmp/parajava/pj.jar</PRE>
 * </TD>
 * </TR>
 * </TABLE>
 *
 * @author Alan Kaminsky
 * @version 20-Jun-2012
 */
public class Configuration {

// Hidden data members.
    // Cluster name.
    private String myClusterName;

    // Log file.
    private String myLogFile;

    // Web interface host and port.
    private String myWebHost = Constants.ALL_NETWORK_INTERFACES;
    private int myWebPort = Constants.WEB_PORT;

    // Job Scheduler host and port.
    private String mySchedulerHost = "localhost";
    private int mySchedulerPort = Constants.PJ_PORT;

    // Frontend host.
    private String myFrontendHost;

    // List of backend information objects.
    private ArrayList<BackendInfo> myBackendInfo
            = new ArrayList<BackendInfo>();

    // Default shell comand string.
    private static final String DEFAULT_SHELL_COMMAND = "bash -l -c";

    // Maximum job time. 0 means no maximum.
    private int myJobTime;

// Exported constructors.
    /**
     * Construct a new configuration. The configuration information is read from
     * the given file.
     *
     * @param configfile Configuration file name.
     * @exception IOException Thrown if an I/O error occurred while reading the
     * configuration file. Thrown if there was an error in the configuration
     * file.
     * @throws java.io.IOException if any.
     */
    public Configuration(String configfile)
            throws IOException {
        parseConfigFile(configfile);
    }

// Exported operations.
    /**
     * Returns the cluster name.
     *
     * @return Cluster name.
     */
    public String getClusterName() {
        return myClusterName;
    }

    /**
     * Returns the Job Scheduler's log file name.
     *
     * @return Log file name.
     */
    public String getLogFile() {
        return myLogFile;
    }

    /**
     * Returns the Job Scheduler's web interface host name.
     *
     * @return Host name.
     */
    public String getWebHost() {
        return myWebHost;
    }

    /**
     * Returns the Job Scheduler's web interface port number.
     *
     * @return Port number.
     */
    public int getWebPort() {
        return myWebPort;
    }

    /**
     * Returns the Job Scheduler's channel group host name. To send messages to
     * the Job Scheduler, a job frontend connects a channel to this host.
     *
     * @return Host name.
     */
    public String getSchedulerHost() {
        return mySchedulerHost;
    }

    /**
     * Returns the Job Scheduler's channel group port number. To send messages
     * to the Job Scheduler, a job frontend connects a channel to this port.
     *
     * @return Port number.
     */
    public int getSchedulerPort() {
        return mySchedulerPort;
    }

    /**
     * Returns the host name of the cluster's frontend processor.
     *
     * @return Host name.
     */
    public String getFrontendHost() {
        return myFrontendHost;
    }

    /**
     * Returns the number of backend processors.
     *
     * @return Count.
     */
    public int getBackendCount() {
        return myBackendInfo.size();
    }

    /**
     * Returns information about the given backend processor.
     *
     * @param i Index in the range 0 .. <code>getBackendCount()-1</code>.
     * @return Backend information object.
     */
    public BackendInfo getBackendInfo(int i) {
        return myBackendInfo.get(i);
    }

    /**
     * Returns information about all backend processors.
     *
     * @return List of backend information objects.
     */
    public List<BackendInfo> getBackendInfoList() {
        return myBackendInfo;
    }

    /**
     * Returns the maximum job time.
     *
     * @return Maximum job time (seconds), or 0 if no maximum.
     */
    public int getJobTime() {
        return myJobTime;
    }

// Hidden operations.
    /**
     * Parse the configuration file.
     *
     * @param configfile Configuration file name.
     *
     * @exception IOException Thrown if an I/O error occurred.
     */
    private void parseConfigFile(String configfile)
            throws IOException {
        Scanner scanner = null;
        String line = null;
        long now = System.currentTimeMillis();
        try {
            scanner = new Scanner(new File(configfile));
            lineloop:
            while (scanner.hasNextLine()) {
                line = scanner.nextLine();
                Scanner linescanner = new Scanner(line);
                if (!linescanner.hasNext()) {
                    continue lineloop;
                }
                String command = linescanner.next();
                if (command.charAt(0) == '#') {
                } else if (command.equals("cluster")) {
                    myClusterName = linescanner.nextLine().trim();
                } else if (command.equals("logfile")) {
                    myLogFile = linescanner.next();
                } else if (command.equals("webhost")) {
                    myWebHost = linescanner.next();
                } else if (command.equals("webport")) {
                    myWebPort = Integer.parseInt(linescanner.next());
                } else if (command.equals("schedulerhost")) {
                    mySchedulerHost = linescanner.next();
                } else if (command.equals("schedulerport")) {
                    mySchedulerPort = Integer.parseInt(linescanner.next());
                } else if (command.equals("frontendhost")) {
                    myFrontendHost = linescanner.next();
                } else if (command.equals("backend")) {
                    String name = linescanner.next();
                    int cpus = linescanner.nextInt();
                    if (cpus < 1) {
                        throw new IOException("Invalid backend command, <cpus> must be >= 1: "
                                + line);
                    }
                    String host = linescanner.next();
                    String jvm = linescanner.next();
                    String classpath = linescanner.next();
                    ArrayList<String> jvmflags = new ArrayList<String>();
                    while (linescanner.hasNext()) {
                        jvmflags.add(linescanner.next());
                    }
                    BackendInfo backendinfo = new BackendInfo(name, cpus, BackendInfo.State.IDLE,
                                    now, host, jvm, classpath, jvmflags.toArray(new String[0]), DEFAULT_SHELL_COMMAND);
                    myBackendInfo.add(backendinfo);
                } else if (command.equals("backendshell")) {
                    String name = linescanner.next();
                    String shellCommand = linescanner.nextLine().trim();
                    BackendInfo backendinfo = backendInfoForName(name);
                    if (backendinfo == null) {
                        throw new IOException("Invalid backendshell command, no backend named \""
                                + name + "\"");
                    }
                    backendinfo.shellCommand = shellCommand;
                } else if (command.equals("jobtime")) {
                    int time = linescanner.nextInt();
                    if (time < 1) {
                        throw new IOException("Invalid configuration command: " + line);
                    }
                    myJobTime = time;
                } else {
                    throw new IOException("Invalid configuration command: " + line);
                }
            }
            if (myClusterName == null) {
                throw new IOException("Missing configuration command: cluster <name>");
            }
            if (myLogFile == null) {
                throw new IOException("Missing configuration command: logfile <file>");
            }
            if (myWebHost == null) {
                throw new IOException("Missing configuration command: webhost <host>");
            }
            if (myFrontendHost == null) {
                throw new IOException("Missing configuration command: frontendhost <host>");
            }
            if (myBackendInfo.isEmpty()) {
                throw new IOException("Missing configuration command: backend <name> <host> <port>");
            }
        } catch (NoSuchElementException exc) {
            throw new IOException("Invalid configuration command: " + line);
        } catch (NumberFormatException exc) {
            throw new IOException("Invalid configuration command: " + line);
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
    }

// Hidden operations.
    /**
     * Returns the backend info object for the given backend name.
     *
     * @param name Backend name.
     *
     * @return Backend info, or null if <code>name</code> does not exist.
     */
    private BackendInfo backendInfoForName(String name) {
        for (BackendInfo backendinfo : myBackendInfo) {
            if (backendinfo.name.equals(name)) {
                return backendinfo;
            }
        }
        return null;
    }

}