tmf/org.eclipse.tracecompass.tmf.cli.core/src/org/eclipse/tracecompass/internal/provisional/tmf/cli/core/parser/CliParserManager.java - tracecompass/org.eclipse.tracecompass - Git at Google

 /*******************************************************************************
  * Copyright (c) 2019 Ericsson, École Polytechnique de Montréal
  *
  * All rights reserved. This program and the accompanying materials are
  * made available under the terms of the Eclipse Public License 2.0 which
  * accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/

 package org.eclipse.tracecompass.internal.provisional.tmf.cli.core.parser;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;

 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.CommandLineParser;
 import org.apache.commons.cli.HelpFormatter;
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.cli.PosixParser;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.tracecompass.internal.tmf.cli.core.Activator;
 import org.eclipse.tracecompass.internal.tmf.cli.core.parser.CliParserConfigElement;
 import org.eclipse.tracecompass.internal.tmf.cli.core.parser.Messages;

 /**
  * Utility class to manage cli actions
  *
  * @author Matthew Khouzam
  * @author Bernd Hufmann
  * @author Geneviève Bastien
  */
 public final class CliParserManager {

     private static final String CLI_ARGS_PREFIX = "--cli"; //$NON-NLS-1$

     /**
      * The CLI Parser instance
      */
     private static @Nullable CliParserManager INSTANCE = null;

     private final Options fOptions;

     /**
      * Constructor, not to be used
      */
     private CliParserManager() {
         Collection<@NonNull ICliParser> cliParsers = getCliParsers();
         Options options = new Options();
         for (ICliParser parser : cliParsers) {
             for (CliOption option : parser.getCmdLineOptions()) {
                 options.addOption(option.toCliOption());
             }
         }
         fOptions = options;
     }

     /**
      * Get the instance of this class
      *
      * @return The instance
      */
     public static synchronized CliParserManager getInstance() {
         CliParserManager instance = INSTANCE;
         if (instance == null) {
             instance = new CliParserManager();
             INSTANCE = instance;
         }
         return instance;
     }

     /**
      * Get the CLI actions available
      *
      * @return A collection of CLI actions
      */
     public static Collection<ICliParser> getCliParsers() {
         return CliParserConfigElement.getInstance().getParsers();
     }

     /**
      * Parse the command line arguments and return the result of the parsing
      *
      * @param args
      *            The arguments of the application
      * @return The parsed command line, or <code>null</code> if there were no
      *         options given
      * @throws CliParserException
      *             If there were exceptions parsing the arguments
      */
     public @Nullable CliCommandLine parse(String[] args) throws CliParserException {
         List<String> tcArgs = new ArrayList<>();
         boolean found = false;
         boolean addNext = false;
         for (String arg : args) {
             if (arg.equals(CLI_ARGS_PREFIX)) {
                 found = true;
                 continue;
             }
             if (found) {
                 tcArgs.add(arg);
             } else if (arg.equals("--open")) { //$NON-NLS-1$
                 // Legacy parsing of the --open option, without preceding --cli
                 System.out.println(Messages.CliParser_WarningCliPrefix);
                 tcArgs.add(arg);
                 addNext = true;
             } else if (addNext) {
                 tcArgs.add(arg);
                 addNext = false;
             }
         }
         if (tcArgs.isEmpty()) {
             return null;
         }
         CommandLineParser cmdLineParser = new PosixParser();
         try {
             // There may not be one and only one command line, do not keep the
             // command line as internal field of this class
             CommandLine cmdLine = cmdLineParser.parse(fOptions, tcArgs.toArray(new String[tcArgs.size()]), false);
             if (cmdLine != null) {
                 CliCommandLine cliCommandLine = new CliCommandLine(cmdLine);
                 return cliCommandLine;
             }
         } catch (ParseException e) {
             // Print to screen the error and help text and re-throw the
             // exception
             System.out.println(Messages.CliParser_ErrorParsingArguments);
             System.out.println(e);
             System.out.println();
             printHelpText();
             throw new CliParserException(String.valueOf(e.getMessage()));
         }
         return null;
     }

     /**
      * Print the help text for the command line
      */
     public void printHelpText() {
         HelpFormatter helpFormatter = new HelpFormatter();
         helpFormatter.printHelp(Messages.CliParser_HelpTextIntro, fOptions);
     }

     /**
      * Handle early command line option, at a stage where the application is not
      * fully loaded yet, but loading. This is the ideal place to handle help
      * options or other options that should give instant feedback to the user,
      * without having to fully open the interface.
      *
      * The return value of this method indicate whether to shutdown the
      * application after executing the option or continue loading.
      *
      * @param commandLine
      *            The command line that was previously parsed using the
      *            {@link #parse(String[])} method
      *
      * @return <code>true</code> if an option was handled, or <code>false</code>
      *         otherwise. At this stage, a return value of <code>true</code>
      *         will cause the application not to continue loading and do a quick
      *         return.
      */
     public static boolean applicationStartup(CliCommandLine commandLine) {
         boolean optionsHandled = false;
         for (ICliParser parser : getCliParsers()) {
             optionsHandled |= parser.preStartup(commandLine);
         }
         return optionsHandled;
     }

     private static class ExecuteCliParsersJob extends Job {

         private final CliCommandLine fCommandLine;

         /**
          * Constructor
          *
          * @param commandLine
          *            the trace element
          */
         public ExecuteCliParsersJob(CliCommandLine commandLine) {
             super("Executing CLI parser"); //$NON-NLS-1$
             fCommandLine = commandLine;
         }

         @Override
         protected IStatus run(@Nullable IProgressMonitor monitor) {
             SubMonitor subMonitor = SubMonitor.convert(monitor);
             Collection<ICliParser> cliParsers = getCliParsers();
             subMonitor.beginTask("Executing CLI Parsers", cliParsers.size()); //$NON-NLS-1$
             for (ICliParser parser : cliParsers) {
                 if (subMonitor.isCanceled()) {
                     return Status.CANCEL_STATUS;
                 }
                 subMonitor.subTask("Executing parser :" + parser.getCmdLineOptions().toString()); //$NON-NLS-1$
                 IStatus status = parser.workspaceLoading(fCommandLine, subMonitor);
                 if (!status.isOK()) {
                     Activator.getInstance().getLog().log(status);
                 }
             }
             return Status.OK_STATUS;
         }
     }

     /**
      * Get a job that will handle the command line options. It is the caller's
      * responsibility to schedule the job and do any appropriate actions for
      * proper termination and cancellation from the user.
      *
      * This method will create a Job in which each CLI parser, ordered by
      * priority, will execute its action sequentially. When the job is done, all
      * CLI parsers will have been executed
      *
      * @param commandLine
      *            The command line that was previously parsed using the
      *            {@link #parse(String[])} method
      * @return The workspace loading job, so it can be cancelled by caller
      */
     public static Job getWorkspaceLoadingJob(CliCommandLine commandLine) {
         return new ExecuteCliParsersJob(commandLine);
     }

 }
	/*******************************************************************************
	* Copyright (c) 2019 Ericsson, École Polytechnique de Montréal
	*
	* All rights reserved. This program and the accompanying materials are
	* made available under the terms of the Eclipse Public License 2.0 which
	* accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*******************************************************************************/

	package org.eclipse.tracecompass.internal.provisional.tmf.cli.core.parser;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;

	import org.apache.commons.cli.CommandLine;
	import org.apache.commons.cli.CommandLineParser;
	import org.apache.commons.cli.HelpFormatter;
	import org.apache.commons.cli.Options;
	import org.apache.commons.cli.ParseException;
	import org.apache.commons.cli.PosixParser;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.SubMonitor;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.tracecompass.internal.tmf.cli.core.Activator;
	import org.eclipse.tracecompass.internal.tmf.cli.core.parser.CliParserConfigElement;
	import org.eclipse.tracecompass.internal.tmf.cli.core.parser.Messages;

	/**
	* Utility class to manage cli actions
	*
	* @author Matthew Khouzam
	* @author Bernd Hufmann
	* @author Geneviève Bastien
	*/
	public final class CliParserManager {

	private static final String CLI_ARGS_PREFIX = "--cli"; //$NON-NLS-1$

	/**
	* The CLI Parser instance
	*/
	private static @Nullable CliParserManager INSTANCE = null;

	private final Options fOptions;

	/**
	* Constructor, not to be used
	*/
	private CliParserManager() {
	Collection<@NonNull ICliParser> cliParsers = getCliParsers();
	Options options = new Options();
	for (ICliParser parser : cliParsers) {
	for (CliOption option : parser.getCmdLineOptions()) {
	options.addOption(option.toCliOption());
	}
	}
	fOptions = options;
	}

	/**
	* Get the instance of this class
	*
	* @return The instance
	*/
	public static synchronized CliParserManager getInstance() {
	CliParserManager instance = INSTANCE;
	if (instance == null) {
	instance = new CliParserManager();
	INSTANCE = instance;
	}
	return instance;
	}

	/**
	* Get the CLI actions available
	*
	* @return A collection of CLI actions
	*/
	public static Collection<ICliParser> getCliParsers() {
	return CliParserConfigElement.getInstance().getParsers();
	}

	/**
	* Parse the command line arguments and return the result of the parsing
	*
	* @param args
	* The arguments of the application
	* @return The parsed command line, or <code>null</code> if there were no
	* options given
	* @throws CliParserException
	* If there were exceptions parsing the arguments
	*/
	public @Nullable CliCommandLine parse(String[] args) throws CliParserException {
	List<String> tcArgs = new ArrayList<>();
	boolean found = false;
	boolean addNext = false;
	for (String arg : args) {
	if (arg.equals(CLI_ARGS_PREFIX)) {
	found = true;
	continue;
	}
	if (found) {
	tcArgs.add(arg);
	} else if (arg.equals("--open")) { //$NON-NLS-1$
	// Legacy parsing of the --open option, without preceding --cli
	System.out.println(Messages.CliParser_WarningCliPrefix);
	tcArgs.add(arg);
	addNext = true;
	} else if (addNext) {
	tcArgs.add(arg);
	addNext = false;
	}
	}
	if (tcArgs.isEmpty()) {
	return null;
	}
	CommandLineParser cmdLineParser = new PosixParser();
	try {
	// There may not be one and only one command line, do not keep the
	// command line as internal field of this class
	CommandLine cmdLine = cmdLineParser.parse(fOptions, tcArgs.toArray(new String[tcArgs.size()]), false);
	if (cmdLine != null) {
	CliCommandLine cliCommandLine = new CliCommandLine(cmdLine);
	return cliCommandLine;
	}
	} catch (ParseException e) {
	// Print to screen the error and help text and re-throw the
	// exception
	System.out.println(Messages.CliParser_ErrorParsingArguments);
	System.out.println(e);
	System.out.println();
	printHelpText();
	throw new CliParserException(String.valueOf(e.getMessage()));
	}
	return null;
	}

	/**
	* Print the help text for the command line
	*/
	public void printHelpText() {
	HelpFormatter helpFormatter = new HelpFormatter();
	helpFormatter.printHelp(Messages.CliParser_HelpTextIntro, fOptions);
	}

	/**
	* Handle early command line option, at a stage where the application is not
	* fully loaded yet, but loading. This is the ideal place to handle help
	* options or other options that should give instant feedback to the user,
	* without having to fully open the interface.
	*
	* The return value of this method indicate whether to shutdown the
	* application after executing the option or continue loading.
	*
	* @param commandLine
	* The command line that was previously parsed using the
	* {@link #parse(String[])} method
	*
	* @return <code>true</code> if an option was handled, or <code>false</code>
	* otherwise. At this stage, a return value of <code>true</code>
	* will cause the application not to continue loading and do a quick
	* return.
	*/
	public static boolean applicationStartup(CliCommandLine commandLine) {
	boolean optionsHandled = false;
	for (ICliParser parser : getCliParsers()) {
	optionsHandled \|= parser.preStartup(commandLine);
	}
	return optionsHandled;
	}

	private static class ExecuteCliParsersJob extends Job {

	private final CliCommandLine fCommandLine;

	/**
	* Constructor
	*
	* @param commandLine
	* the trace element
	*/
	public ExecuteCliParsersJob(CliCommandLine commandLine) {
	super("Executing CLI parser"); //$NON-NLS-1$
	fCommandLine = commandLine;
	}

	@Override
	protected IStatus run(@Nullable IProgressMonitor monitor) {
	SubMonitor subMonitor = SubMonitor.convert(monitor);
	Collection<ICliParser> cliParsers = getCliParsers();
	subMonitor.beginTask("Executing CLI Parsers", cliParsers.size()); //$NON-NLS-1$
	for (ICliParser parser : cliParsers) {
	if (subMonitor.isCanceled()) {
	return Status.CANCEL_STATUS;
	}
	subMonitor.subTask("Executing parser :" + parser.getCmdLineOptions().toString()); //$NON-NLS-1$
	IStatus status = parser.workspaceLoading(fCommandLine, subMonitor);
	if (!status.isOK()) {
	Activator.getInstance().getLog().log(status);
	}
	}
	return Status.OK_STATUS;
	}
	}

	/**
	* Get a job that will handle the command line options. It is the caller's
	* responsibility to schedule the job and do any appropriate actions for
	* proper termination and cancellation from the user.
	*
	* This method will create a Job in which each CLI parser, ordered by
	* priority, will execute its action sequentially. When the job is done, all
	* CLI parsers will have been executed
	*
	* @param commandLine
	* The command line that was previously parsed using the
	* {@link #parse(String[])} method
	* @return The workspace loading job, so it can be cancelled by caller
	*/
	public static Job getWorkspaceLoadingJob(CliCommandLine commandLine) {
	return new ExecuteCliParsersJob(commandLine);
	}

	}