AutRunApplication.java

/*******************************************************************************
 * Copyright (c) 2004, 2011 BREDEX GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     BREDEX GmbH - initial API and implementation and/or initial documentation
 *******************************************************************************/
package org.eclipse.jubula.app.autrun;

import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

import org.apache.commons.cli.BasicParser;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.OptionGroup;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.Parser;
import org.apache.commons.lang.StringUtils;
import org.eclipse.core.runtime.adaptor.EclipseStarter;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.jubula.app.autrun.i18n.Messages;
import org.eclipse.jubula.tools.internal.constants.AutConfigConstants;
import org.eclipse.jubula.tools.internal.constants.EnvConstants;
import org.eclipse.jubula.tools.internal.constants.StringConstants;
import org.eclipse.jubula.tools.internal.registration.AutIdentifier;
import org.eclipse.jubula.tools.internal.utils.IsAliveThread;
import org.eclipse.jubula.tools.internal.utils.TimeUtil;
import org.eclipse.jubula.version.Vn;
import org.eclipse.osgi.util.NLS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Starts an AUT and registers the AUT with an AUT Agent. In order to terminate 
 * at the right time (not too early, not too late) this application assumes 
 * that the following JVM parameters (or equivalent) are used:<ul>
 * <li>osgi.noShutdown=true</li> 
 * <li>eclipse.jobs.daemon=true</li> 
 * </ul>
 * These parameters are required because the original application was designed 
 * to run outside of an OSGi context, i.e. the application should end only 
 * when no non-daemon threads are active.
 * 
 * @author BREDEX GmbH
 * @created Dec 9, 2009
 */
public class AutRunApplication implements IApplication {
    
    /** the logger */
    private static final Logger LOG = 
        LoggerFactory.getLogger(AutRunApplication.class);
    
    /**
     * <code>LAUNCHER_NAME</code>
     */
    private static final String LAUNCHER_NAME = "autrun"; //$NON-NLS-1$

    /** <code>TOOLKIT_RCP</code> */
    private static final String TK_RCP = "rcp"; //$NON-NLS-1$

    /** <code>TK_SWT</code> */
    private static final String TK_SWT = "swt"; //$NON-NLS-1$

    /** <code>TK_SWING</code> */
    private static final String TK_SWING = "swing"; //$NON-NLS-1$

    /** <code>TK_JAVAFX</code> */
    private static final String TK_JAVAFX = "javafx"; //$NON-NLS-1$

    /** <code>DEFAULT_NAME_TECHNICAL_COMPONENTS</code> */
    private static final boolean DEFAULT_NAME_TECHNICAL_COMPONENTS = true;

    // - Command line options - Start //
    /** port number for the Aut Agent with which to register */
    private static final String OPT_AUT_AGENT_PORT = "p"; //$NON-NLS-1$

    /** port number for the Aut Agent with which to register */
    private static final String OPT_AUT_AGENT_PORT_LONG = "autagentport"; //$NON-NLS-1$
    
    /** hostname for the Aut Agent with which to register */
    private static final String OPT_AUT_AGENT_HOST = "a"; //$NON-NLS-1$
    
    /** hostname for the Aut Agent with which to register */
    private static final String OPT_AUT_AGENT_HOST_LONG = "autagenthost"; //$NON-NLS-1$
    
    /** help option */
    private static final String OPT_HELP = "h"; //$NON-NLS-1$
    
    /** hostname for the Aut Agent with which to register */
    private static final String OPT_HELP_LONG = "help"; //$NON-NLS-1$
    
    /** name of the AUT to register */
    private static final String OPT_AUT_ID = "i"; //$NON-NLS-1$
    
    /** name of the AUT to register */
    private static final String OPT_AUT_ID_LONG = "autid"; //$NON-NLS-1$
    
    /** flag for name generation for certain technical components */
    private static final String OPT_NAME_TECHNICAL_COMPONENTS = "g"; //$NON-NLS-1$

    /** flag for name generation for certain technical components */
    private static final String OPT_NAME_TECHNICAL_COMPONENTS_LONG = "generatenames"; //$NON-NLS-1$
    
    /** keyboard layout */
    private static final String OPT_KEYBOARD_LAYOUT = "k"; //$NON-NLS-1$

    /** keyboard layout */
    private static final String OPT_KEYBOARD_LAYOUT_LONG = "kblayout"; //$NON-NLS-1$

    /** AUT working directory */
    private static final String OPT_WORKING_DIR = "w"; //$NON-NLS-1$

    /** AUT working directory */
    private static final String OPT_WORKING_DIR_LONG = "workingdir"; //$NON-NLS-1$
    
    /** executable file used to start the AUT */
    private static final String OPT_EXECUTABLE = "e"; //$NON-NLS-1$
    
    /** executable file used to start the AUT */
    private static final String OPT_EXECUTABLE_LONG = "exec"; //$NON-NLS-1$
    
    /** AUT agent host name */
    private static final String HOSTNAME = "hostname"; //$NON-NLS-1$
    
    /** AUT agent port */
    private static final String PORT = "port"; //$NON-NLS-1$
    
    /** AUT id */
    private static final String ID = "id"; //$NON-NLS-1$
    
    /** technical components */
    private static final String TRUE_FALSE = "true / false"; //$NON-NLS-1$
    
    /** AUT keyboard layout */
    private static final String LOCALE = "locale"; //$NON-NLS-1$
    
    /** AUT working directory */
    private static final String DIRECTORY = "directory"; //$NON-NLS-1$
    
    /** AUT options */
    private static final String COMMAND = "command"; //$NON-NLS-1$
    
    /** swing class prefix */
    private static final String SWING_AUT_TOOLKIT_CLASS_PREFIX = "Swing"; //$NON-NLS-1$
    
    /** SWT class prefix */
    private static final String SWT_AUT_TOOLKIT_CLASS_PREFIX = "Swt"; //$NON-NLS-1$
    
    /** RCP class prefix */
    private static final String RCP_AUT_TOOLKIT_CLASS_PREFIX = "Rcp"; //$NON-NLS-1$
    
    /** JavaFX class prefix */
    private static final String JAVAFX_AUT_TOOLKIT_CLASS_PREFIX = "JavaFX"; //$NON-NLS-1$
    // - Command line options - End //

    /**
     * prints help options
     * @param pe a parse Exception - may also be null
     */
    private static void printHelp(ParseException pe) {
        System.out.println(Vn.getDefault().getVersion());
        HelpFormatter formatter = new HelpFormatter();
        formatter.setOptionComparator(new OptionComparator());
        if (pe != null) {
            formatter.printHelp(
                    LAUNCHER_NAME,
                    StringConstants.EMPTY,
                    createCmdLineOptions(), 
                    "\n" + pe.getLocalizedMessage(),  //$NON-NLS-1$
                    true);
        } else {
            formatter.printHelp(LAUNCHER_NAME,
                    createCmdLineOptions(), true);
        }
    }

    /**
     * Creates and returns settings for starting an AUT based on the given
     * command line.
     *  
     * @param cmdLine Provides the settings for the AUT configuration.
     * @return new settings for starting an AUT.
     */
    private static Map<String, String> createAutConfig(CommandLine cmdLine) {
        Map<String, String> autConfig = new HashMap<String, String>();
        if (cmdLine.hasOption(OPT_WORKING_DIR)) {
            autConfig.put(AutConfigConstants.WORKING_DIR, cmdLine
                    .getOptionValue(OPT_WORKING_DIR));
        } else {
            autConfig.put(AutConfigConstants.WORKING_DIR, System
                    .getProperty("user.dir")); //$NON-NLS-1$
        }
        
        if (cmdLine.hasOption(OPT_NAME_TECHNICAL_COMPONENTS)) {
            autConfig.put(AutConfigConstants.NAME_TECHNICAL_COMPONENTS, String
                    .valueOf(cmdLine.getOptionValue(
                        OPT_NAME_TECHNICAL_COMPONENTS)));
        } else {
            autConfig.put(AutConfigConstants.NAME_TECHNICAL_COMPONENTS,
                String.valueOf(DEFAULT_NAME_TECHNICAL_COMPONENTS));
        }
        autConfig.put(AutConfigConstants.EXECUTABLE, cmdLine
                .getOptionValue(OPT_EXECUTABLE));
        
        if (cmdLine.hasOption(OPT_KEYBOARD_LAYOUT)) {
            autConfig.put(AutConfigConstants.KEYBOARD_LAYOUT, 
                    cmdLine.getOptionValue(OPT_KEYBOARD_LAYOUT));
        }
        
        String[] autArguments = cmdLine.getOptionValues(OPT_EXECUTABLE);
        if (autArguments.length > 1) {
            autConfig.put(AutConfigConstants.AUT_RUN_AUT_ARGUMENTS, StringUtils
                .join(autArguments,
                    AutConfigConstants.AUT_RUN_AUT_ARGUMENTS_SEPARATOR_CHAR, 1,
                    autArguments.length));
        }
        
        return autConfig;
    }

    /**
     * @return the command line options available when invoking the main method. 
     */
    private static Options createCmdLineOptions() {
        Options options = new Options();
        Option autAgentHostOption = new Option(OPT_AUT_AGENT_HOST, true,
            NLS.bind(Messages.infoAutAgentHost, EnvConstants.LOCALHOST_ALIAS));
        autAgentHostOption.setLongOpt(OPT_AUT_AGENT_HOST_LONG);
        autAgentHostOption.setArgName(HOSTNAME);
        options.addOption(autAgentHostOption);

        Option autAgentPortOption = new Option(OPT_AUT_AGENT_PORT, true,
            NLS.bind(Messages.infoAutAgentPort,
                EnvConstants.AUT_AGENT_DEFAULT_PORT));
        autAgentPortOption.setLongOpt(OPT_AUT_AGENT_PORT_LONG);
        autAgentPortOption.setArgName(PORT);
        options.addOption(autAgentPortOption);

        OptionGroup autToolkitOptionGroup = new OptionGroup();
        autToolkitOptionGroup.addOption(new Option(TK_SWING,
                Messages.infoSwingToolkit));
        autToolkitOptionGroup.addOption(new Option(TK_SWT,
                Messages.infoSwtToolkit));
        autToolkitOptionGroup.addOption(new Option(TK_RCP,
                Messages.infoRcpToolkit));
        autToolkitOptionGroup.addOption(new Option(TK_JAVAFX,
                Messages.infoJavaFXToolkit));
        autToolkitOptionGroup.setRequired(true);
        options.addOptionGroup(autToolkitOptionGroup);

        Option autIdOption = new Option(OPT_AUT_ID, true, Messages.infoAutId);
        autIdOption.setLongOpt(OPT_AUT_ID_LONG);
        autIdOption.setArgName(ID);
        autIdOption.setRequired(true);
        options.addOption(autIdOption);

        Option nameTechnicalComponentsOption = new Option(
                OPT_NAME_TECHNICAL_COMPONENTS, true,
                Messages.infoGenerateTechnicalComponentNames);
        nameTechnicalComponentsOption
                .setLongOpt(OPT_NAME_TECHNICAL_COMPONENTS_LONG);
        nameTechnicalComponentsOption.setArgName(TRUE_FALSE);
        options.addOption(nameTechnicalComponentsOption);

        Option keyboardLayoutOption = new Option(OPT_KEYBOARD_LAYOUT, true,
                Messages.infoKbLayout);
        keyboardLayoutOption.setLongOpt(OPT_KEYBOARD_LAYOUT_LONG);
        keyboardLayoutOption.setArgName(LOCALE);
        options.addOption(keyboardLayoutOption);

        Option workingDirOption = new Option(OPT_WORKING_DIR, true,
                Messages.infoAutWorkingDirectory);
        workingDirOption.setLongOpt(OPT_WORKING_DIR_LONG);
        workingDirOption.setArgName(DIRECTORY);
        options.addOption(workingDirOption);

        Option helpOption = new Option(OPT_HELP, false, Messages.infoHelp);
        helpOption.setLongOpt(OPT_HELP_LONG);
        options.addOption(helpOption);
        
        OptionBuilder.hasArgs();
        Option autExecutableFileOption = OptionBuilder.create(OPT_EXECUTABLE);
        autExecutableFileOption.setDescription(Messages.infoExecutableFile);
        autExecutableFileOption.setLongOpt(OPT_EXECUTABLE_LONG);
        autExecutableFileOption.setRequired(true);
        autExecutableFileOption.setArgName(COMMAND);
        options.addOption(autExecutableFileOption);
        
        return options;
    }
    
    /**
     * @author BREDEX GmbH
     */
    private static final class WatchDog extends Thread {
        /**
         * the barrier to await
         */
        private CyclicBarrier m_b;

        /**
         * Constructor
         * 
         * @param name
         *            the name
         * @param b the barrier to use
         */
        private WatchDog(String name, CyclicBarrier b) {
            super(name);
            m_b = b;
        }
        
        /** {@inheritDoc} */
        public void run() {
            try {
                boolean shouldShutdown;
                do {
                    TimeUtil.delay(2500);
                    shouldShutdown = true;
                    Set<Thread> allThreads = Thread.getAllStackTraces()
                            .keySet();
                    for (Thread t : allThreads) {
                        if (t instanceof IsAliveThread) {
                            shouldShutdown = false;
                            break;
                        }
                    }
                } while (!shouldShutdown);
            } finally {
                try {
                    m_b.await();
                } catch (InterruptedException e) {
                    LOG.error(e.getLocalizedMessage(), e);
                } catch (BrokenBarrierException e) {
                    LOG.error(e.getLocalizedMessage(), e);
                }
            }

            try {
                EclipseStarter.shutdown();
            } catch (Exception e) {
                LOG.error(e.getLocalizedMessage(), e);
            }
        }
    }

    /**
     * This class implements the <code>Comparator</code> interface for comparing
     * Options.
     */
    private static class OptionComparator implements Comparator {
        /** {@inheritDoc} */
        public int compare(Object o1, Object o2) {
            Option opt1 = (Option)o1;
            Option opt2 = (Option)o2;
            // always list -exec as last option
            if (opt1.getOpt().equals(OPT_EXECUTABLE)) {
                return 1;
            }
            if (opt2.getOpt().equals(OPT_EXECUTABLE)) {
                return -1;
            }
            return 0;
        }
    }

    /**
     * {@inheritDoc}
     */
    public Object start(final IApplicationContext context) throws Exception {
        String[] args = (String[])context.getArguments().get(
                IApplicationContext.APPLICATION_ARGS);
        if (args == null) {
            args = new String[0];
        }
        Options options = createCmdLineOptions();
        Parser parser = new BasicParser();
        CommandLine cmdLine = null;
        try {
            cmdLine = parser.parse(options, args, false);
            if (!cmdLine.hasOption(OPT_HELP)) {
                
                String toolkit = StringConstants.EMPTY;
                if (cmdLine.hasOption(TK_SWING)) {
                    toolkit = SWING_AUT_TOOLKIT_CLASS_PREFIX;
                } else if (cmdLine.hasOption(TK_SWT)) {
                    toolkit = SWT_AUT_TOOLKIT_CLASS_PREFIX;
                } else if (cmdLine.hasOption(TK_RCP)) {
                    toolkit = RCP_AUT_TOOLKIT_CLASS_PREFIX;
                } else if (cmdLine.hasOption(TK_JAVAFX)) {
                    toolkit = JAVAFX_AUT_TOOLKIT_CLASS_PREFIX;
                }
                
                int autAgentPort = EnvConstants.AUT_AGENT_DEFAULT_PORT;
                if (cmdLine.hasOption(OPT_AUT_AGENT_PORT)) {
                    try {
                        autAgentPort = Integer.parseInt(cmdLine
                                .getOptionValue(OPT_AUT_AGENT_PORT));
                    } catch (NumberFormatException nfe) {
                        // use default
                    }
                }
                String autAgentHost = EnvConstants.LOCALHOST_ALIAS;
                if (cmdLine.hasOption(OPT_AUT_AGENT_HOST)) {
                    autAgentHost = cmdLine.getOptionValue(OPT_AUT_AGENT_HOST);
                }
                
                InetSocketAddress agentAddr = 
                        new InetSocketAddress(autAgentHost, autAgentPort);
                AutIdentifier autId = new AutIdentifier(cmdLine
                        .getOptionValue(OPT_AUT_ID));
                
                Map<String, String> autConfiguration = createAutConfig(cmdLine);
                
                AutRunner runner = new AutRunner(
                        toolkit, autId, agentAddr, autConfiguration);
                try {
                    runner.run();
                } catch (ConnectException ce) {
                    LOG.info(Messages.infoConnectionToAutAgentFailed, ce);
                    System.err.println(Messages.infoNonAutAgentConnectionInfo);
                }
            } else {
                printHelp(null);
            }
        } catch (ParseException pe) {
            printHelp(pe);
        } finally {
            CyclicBarrier b = new CyclicBarrier(2);
            Thread watchDog = new WatchDog("http://eclip.se/457600#c8", b); //$NON-NLS-1$
            watchDog.setDaemon(true);
            watchDog.start();
            // http://eclip.se/461810: prevent application to quit too early, otherwise framework bundle lookups do not work
            b.await();
        }
        
        return IApplication.EXIT_OK;
    }

    /**
     * 
     * {@inheritDoc}
     */
    public void stop() {
        // no-op
    }
}