Main.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2022 Marco Foscato <marco.foscato@uib.no>
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.main;
 
import java.awt.EventQueue;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.util.List;
import java.util.concurrent.ExecutionException;
 
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.ParseException;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.ExceptionUtils;
import denoptim.files.FileFormat;
import denoptim.files.FileUtils;
import denoptim.gui.GUI;
import denoptim.integration.python.Py4JGetawayServer;
import denoptim.logging.Version;
import denoptim.programs.combinatorial.FragSpaceExplorer;
import denoptim.programs.denovo.GARunner;
import denoptim.programs.fitnessevaluator.FitnessRunner;
import denoptim.programs.fragmenter.Fragmenter;
import denoptim.programs.genetweeker.GeneOpsRunner;
import denoptim.programs.grapheditor.GraphEditor;
import denoptim.programs.graphlisthandler.GraphListsHandler;
import denoptim.programs.isomorphism.Isomorphism;
import denoptim.programs.moldecularmodelbuilder.MolecularModelBuilder;
import denoptim.task.ProgramTask;
import denoptim.task.StaticTaskManager;
 
public class Main
{
    public static enum RunType {
        GUI, 
        
        GA, 
        
        FSE, 
        
        FIT,
        
        B3D,
        
        DRY,
        
        GO,
        
        GE,
        
        GI,
        
        CLG,
        
        FRG,
        
        PY4J;
        
        // NB: to define a new run type: 
        //  1) add the enum alternative. The order is somewhat related to the
        //     importance (i.e., common use) of a run type.
        //  2) set the value of "description" in the static block below
        //  3) set the value of "isCLIEnabled" in the static block below
        //  4) set the value of "programTaskImpl" in the static block below
        //  5) consider whether a new parameter file format should be added
        //     in FileFormats.
        
        private Class<?> programTaskImpl;
        
        private String description = "";
        
        private boolean isCLIEnabled = true;
        
        private boolean needsInputFile = false;
        
        static {
            DRY.description = "Dry run";
            FSE.description = "Combinatorial Fragment Space Exploration";
            FIT.description = "Stand-alone FITness evaluation";
            GA.description = "Genetic Algorithm";
            GE.description = "Stand-alone Graph Editing task";
            GI.description = "Stand-alone Graph Isomorphism analysis";
            GO.description = "Stand-alone Genetic Operation";
            GUI.description = "Graphycal User Interface";
            CLG.description = "Comparison of Lists of Graphs";
            B3D.description = "Stand-alone build a 3D molecular model from a "
                    + "graph";
            FRG.description = "Fragmentation and managment of fragments";
            PY4J.description = "Starts a server listening to Python";
            
            DRY.isCLIEnabled = false;
            FSE.isCLIEnabled = true;
            FIT.isCLIEnabled = true;
            GA.isCLIEnabled = true;
            GE.isCLIEnabled = true;
            GI.isCLIEnabled = true;
            GO.isCLIEnabled = true;
            GUI.isCLIEnabled = false;
            CLG.isCLIEnabled = true;
            B3D.isCLIEnabled = true;
            FRG.isCLIEnabled = true;
            PY4J.isCLIEnabled = true;
            
            DRY.needsInputFile = false;
            FSE.needsInputFile = true;
            FIT.needsInputFile = true;
            GA.needsInputFile = true;
            GE.needsInputFile = true;
            GI.needsInputFile = true;
            GO.needsInputFile = true;
            GUI.needsInputFile = false;
            CLG.needsInputFile = true;
            B3D.needsInputFile = true;
            FRG.needsInputFile = true;
            PY4J.needsInputFile = false;
            
            DRY.programTaskImpl = null;
            FSE.programTaskImpl = FragSpaceExplorer.class;
            FIT.programTaskImpl = FitnessRunner.class;
            GA.programTaskImpl = GARunner.class;
            GE.programTaskImpl = GraphEditor.class;
            GI.programTaskImpl = Isomorphism.class;
            GO.programTaskImpl = GeneOpsRunner.class;
            GUI.programTaskImpl = GUI.class;
            CLG.programTaskImpl = GraphListsHandler.class;
            B3D.programTaskImpl = MolecularModelBuilder.class;
            FRG.programTaskImpl = Fragmenter.class;
            PY4J.programTaskImpl = null;
        }
 
        public Class<?> getProgramTaskImpl()
        {
            return programTaskImpl;
        }
        
        public static String getRunTypesForUser()
        {
            String s = "";
            String separator = DENOPTIMConstants.EOL;
            String last = ""; //in case the last entry should use " and "
            for (int i=0; i<RunType.values().length; i++)
            {
                RunType rt = RunType.values()[i];
                if (!rt.isCLIEnabled)
                    continue; //This run type should not be visible by the user
                if (i>0 && i < RunType.values().length-2)
                    s = s + " '" + rt.toString() + "' for "+rt.description+ ",";
                else if (i==0)
                    s = "'" + rt.toString() + "' for "+rt.description+",";
                else
                    s = s + last+"'"+rt.toString()+"' for "+rt.description+".";
                s = s + separator;
            }
            return s;
        }
 
        boolean isCLIEnabled()
        {
            return isCLIEnabled;
        }
        
        boolean needsInputFile()
        {
            return needsInputFile;
        }
    };
    
//------------------------------------------------------------------------------
    
    public static void main(String[] args)
    {
        // First, we try to understand what the user wants to do.
        Behavior behavior = defineProgramBehavior(args);
        
        // In case of inconsistent requests, we report the error and stop
        if (behavior.exitStatus!=0)
            reportError(behavior);
        
        // Deal with simple requests for information
        if (RunType.DRY.equals(behavior.runType))
        {
            System.out.println(behavior.helpMsg);
            System.exit(0);
        }
        
        // Deal with deamon/server launches
        if (RunType.PY4J.equals(behavior.runType))
        {
            try
            {
                Py4JGetawayServer.launch();
            } catch (Throwable e)
            {
                e.printStackTrace();
                reportError("Could not start J2PyServer. Hint on problem: " 
                        + e.getMessage(), 1);
            }
            return;
        }
        
        List<String> inputFiles = behavior.cmd.getArgList();
        
        // We instantiate also the task manager, even if it might not be used.
        // This is to pre-start the tasks and get a more reliable queue status
        // at any given time after this point.
        StaticTaskManager.getInstance();
        
        // Now, we deal with proper program runs
        if (ProgramTask.class.isAssignableFrom(
                behavior.runType.getProgramTaskImpl()))
        {
            File inpFile = null;
            File wDir = null;
            if (inputFiles.size()>1)
            {    
                reportError("Only one input file allowed when requesting run "
                        + behavior.runType + ". Found " + inputFiles.size()
                        + " files: " + inputFiles, 1);
            }
            if (behavior.runType.needsInputFile())
            {
                if (inputFiles.size()<1)
                {   
                    reportError("Need an input file when requesting run "
                        + behavior.runType + ". Found " + inputFiles.size(), 1);
                } else if (inputFiles.size()==1) {
                    inpFile = new File(inputFiles.get(0));
                    wDir = inpFile.getParentFile();
                    if (wDir==null)
                    {
                        wDir = new File(System.getProperty("user.dir"));
                    }
                }
            }
            runProgramTask(behavior.runType.getProgramTaskImpl(), inpFile, wDir);
            terminate();
        } else if (RunType.GUI.equals(behavior.runType)) {
            EventQueue.invokeLater(new GUI(behavior.cmd));
        } else {
            reportError("You requested a run of type '" + behavior.runType 
                    + "', but I found no such implementation. "
                    + "Please, report this to the authors.", 1);
        }
    }
 
//------------------------------------------------------------------------------
    
    private static void runProgramTask(Class<?> taskClass, File inputFile,
            File workDir)
    {
        if (!ProgramTask.class.isAssignableFrom(taskClass))
        {
            reportError("Attempt to create a program task for class '" 
                    + taskClass.getSimpleName() + "', but such class is not a "
                    + "extension of '" + ProgramTask.class.getSimpleName() 
                    + "'.", 1);
        }
 
        ProgramTask task = null;
        try
        {
            Constructor<?> taskBuilder = taskClass.getConstructor(File.class,
                    File.class);
            task = (ProgramTask) taskBuilder.newInstance(inputFile,workDir);
        } catch (Exception e)
        {
            reportError("Could not create a program task for " 
                    + taskClass.getSimpleName() + DENOPTIMConstants.EOL
                    + ". Details: " + DENOPTIMConstants.EOL
                    + ExceptionUtils.getStackTraceAsString(e), 1);
        }
        
        try
        {
            StaticTaskManager.submitAndWait(task);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
 
//------------------------------------------------------------------------------
    
    private static Behavior ensureFileExistsAndIsReadable(File file, 
            Behavior behavior)
    {
        if (!file.exists())
        {
            return new Behavior(behavior.runType, behavior.cmd, 1, null,
                    "File '"+ file.getAbsolutePath() +"' not found.");
        }
        FileFormat format = FileFormat.UNRECOGNIZED;
        try {
            format = FileUtils.detectFileFormat(file);
        } catch (Throwable t) {
            // Ignore: if anything goes wrong, will still get UNRECOGNIZED which
            // triggers the error.
        }
        if (FileFormat.UNRECOGNIZED.equals(format))
        {
            return new Behavior(behavior.runType, behavior.cmd, 1, null,
                    "Could not open file '" + file.getAbsolutePath() 
                    + "' because its format is not recognized.");
        }
        return behavior;
    }
 
//------------------------------------------------------------------------------
    
    protected static Behavior defineProgramBehavior(String[] args)
    {   
        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = null;
        
        try {
            cmd = parser.parse(CLIOptions.getInstance(), args);
        } catch (ParseException e) {
            String helpMsg = getHelpString();
            String errMsg = "Unable to parse command-line arguments. "
                    + "Please, check your input! " + DENOPTIMConstants.EOL
                    + "Details: " + e.getMessage();
            return new Behavior(null, null, 1, helpMsg, errMsg);
        }
        
        if (cmd.hasOption(CLIOptions.help))
        {
            String helpMsg = getHelpString();
            return new Behavior(RunType.DRY, null, 0, helpMsg, null);
        }
        
        if (cmd.hasOption(CLIOptions.version))
        {
            return new Behavior(RunType.DRY, null, 0, Version.VERSION, null);
        } 
        
        Behavior result = null;
        if (cmd.getOptions().length==0)
            result = new Behavior(RunType.GUI, cmd, 0, null, null);
        else {
            if (cmd.hasOption(CLIOptions.run))
            {
                String rts = cmd.getOptionValue(CLIOptions.run).toString();
                RunType rt = null;
                try
                {
                    rt = RunType.valueOf(rts.toUpperCase());
                } catch (Exception e)
                {
                    String errMsg = "Unacceptable value for "
                            + CLIOptions.run.getLongOpt() + " option: "
                            + "'" + rts + "'. Please, modify "
                            + "your command. ";
                    return new Behavior(null, null, 1, null, errMsg);
                }
            
                if (rt.isCLIEnabled())
                {
                    result = new Behavior(rt, cmd);
                } else {
                    result = new Behavior(null, null, 1, null, 
                            "RunType '"+rt+"' is not enabled from CLI. "
                            + "Please, contacts the developers.");
                }
            } else {
                reportError("Command line has no " + CLIOptions.run + " option, "
                        + "but more than zero options. Please, contact the "
                        + "developers.", 1);
            }
        }
 
        List<String> inputFiles = cmd.getArgList();
        for (String pathname : inputFiles)
            result = ensureFileExistsAndIsReadable(new File(pathname), result);
        
        return result;
    }
    
//------------------------------------------------------------------------------
    
    private static String getHelpString()
    {   
        HelpFormatter formatter = new HelpFormatter();
        StringWriter out = new StringWriter();
        PrintWriter pw = new PrintWriter(out);
        
        formatter.printHelp(pw, 80, "denoptim", DENOPTIMConstants.EOL, 
                CLIOptions.getInstance(), 
                formatter.getLeftPadding(), formatter.getDescPadding(), 
                DENOPTIMConstants.EOL +
                "Run without arguments to launch the graphical user "
                + "interface (GUI) without opening any file. ", true);
        pw.flush();
        return out.toString();
    }
    
//------------------------------------------------------------------------------
 
    private static void reportError(String msg, int exitCode)
    {
        System.out.println(DENOPTIMConstants.EOL
                + "ERROR! " + msg 
                + DENOPTIMConstants.EOL);
        System.exit(exitCode);
    }
    
//------------------------------------------------------------------------------
    
    private static void reportError(Behavior behavior)
    {
        if (behavior.helpMsg!=null)
            System.out.println(behavior.helpMsg);
        reportError(behavior.errorMsg, behavior.exitStatus);
    }
    
//------------------------------------------------------------------------------
    
    private static void terminate()
    {
        try {
            StaticTaskManager.stopAll();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("StaticTaskManager had problems stopping. "
                    + "Forcing termination.");
        }
        Runtime.getRuntime().halt(0);
    }
    
//------------------------------------------------------------------------------
 
}