Main
/**
* The main command-line entry-point for Gradle.
*/
public class Main extends EntryPoint {
public static void main(String[] args) {
new Main().run(args);
}
protected void doAction(String[] args, ExecutionListener listener) { createActionFactory().convert(Arrays.asList(args)).execute(listener);
}
CommandLineActionFactory createActionFactory() {
return new CommandLineActionFactory();
}
}
CommendLineActionFactory
public class CommandLineActionFactory {
private static final String HELP = "h";
private static final String VERSION = "v";
/**
* <p>Converts the given command-line arguments to an {@link Action} which performs the action requested by the
* command-line args.
*
* @param args The command-line arguments.
* @return The action to execute.
*/
public Action<ExecutionListener> convert(List<String> args) {
ServiceRegistry loggingServices = createLoggingServices();
LoggingConfiguration loggingConfiguration = new LoggingConfiguration();
return new ExceptionReportingAction(
new WithLogging(loggingServices, args, loggingConfiguration,
new JavaRuntimeValidationAction(
new ParseAndBuildAction(loggingServices, args))),
new BuildExceptionReporter(loggingServices.get(StyledTextOutputFactory.class), loggingConfiguration, clientMetaData()));
}
ParseAndBuildAction
private class ParseAndBuildAction implements Action<ExecutionListener> {
private final ServiceRegistry loggingServices;
private final List<String> args;
private ParseAndBuildAction(ServiceRegistry loggingServices, List<String> args) {
this.loggingServices = loggingServices;
this.args = args;
}
public void execute(ExecutionListener executionListener) {
List<CommandLineAction> actions = new ArrayList<CommandLineAction>();
actions.add(new BuiltInActions());
createActionFactories(loggingServices, actions);
CommandLineParser parser = new CommandLineParser();
for (CommandLineAction action : actions) {
action.configureCommandLineParser(parser);
}
Action<? super ExecutionListener> action;
try {
ParsedCommandLine commandLine = parser.parse(args);
action = createAction(actions, parser, commandLine);
} catch (CommandLineArgumentException e) {
action = new CommandLineParseFailureAction(parser, e);
}
action.execute(executionListener);
}
private Action<? super ExecutionListener> createAction(Iterable<CommandLineAction> factories, CommandLineParser parser, ParsedCommandLine commandLine) {
for (CommandLineAction factory : factories) {
Runnable action = factory.createAction(parser, commandLine);
if (action != null) {
return Actions.toAction(action);
}
}
throw new UnsupportedOperationException("No action factory for specified command-line arguments.");
}
}
}
CommandLineAction/BuildActionsFactory Runnable createAction()
class BuildActionsFactory implements CommandLineAction {
public Runnable createAction(CommandLineParser parser, ParsedCommandLine commandLine) {
Parameters parameters = parametersConverter.convert(commandLine, new Parameters());
parameters.getDaemonParameters().applyDefaultsFor(new JvmVersionDetector().getJavaVersion(parameters.getDaemonParameters().getEffectiveJvm()));
if (parameters.getDaemonParameters().isStop()) {
return stopAllDaemons(parameters.getDaemonParameters(), loggingServices);
}
if (parameters.getDaemonParameters().isForeground()) {
DaemonParameters daemonParameters = parameters.getDaemonParameters();
ForegroundDaemonConfiguration conf = new ForegroundDaemonConfiguration(
daemonParameters.getUid(), daemonParameters.getBaseDir(), daemonParameters.getIdleTimeout());
return new ForegroundDaemonAction(loggingServices, conf);
}
if (parameters.getDaemonParameters().getDaemonUsage().isEnabled()) {
return runBuildWithDaemon(parameters.getStartParameter(), parameters.getDaemonParameters(), loggingServices);
}
if (canUseCurrentProcess(parameters.getDaemonParameters())) {
return runBuildInProcess(parameters.getStartParameter(), parameters.getDaemonParameters(), loggingServices);
}
return runBuildInSingleUseDaemon(parameters.getStartParameter(), parameters.getDaemonParameters(), loggingServices);
}
private Runnable runBuild(StartParameter startParameter, DaemonParameters daemonParameters, BuildActionExecuter<BuildActionParameters> executer, ServiceRegistry sharedServices) {
BuildActionParameters parameters = new DefaultBuildActionParameters(
daemonParameters.getEffectiveSystemProperties(),
System.getenv(),
SystemProperties.getInstance().getCurrentDir(),
startParameter.getLogLevel(),
daemonParameters.getDaemonUsage(), startParameter.isContinuous(), daemonParameters.isInteractive(), ClassPath.EMPTY);
return new RunBuildAction(executer, startParameter, clientMetaData(), getBuildStartTime(), parameters, sharedServices);
}
Runnable/RunBuildAction
public class RunBuildAction implements Runnable {
private final BuildActionExecuter<BuildActionParameters> executer;
public void run() {
executer.execute(
new ExecuteBuildAction(startParameter),
new DefaultBuildRequestContext(new DefaultBuildRequestMetaData(clientMetaData, startTime), new DefaultBuildCancellationToken(), new NoOpBuildEventConsumer()),
buildActionParameters,
sharedServices);
}
BuildActionExecuter/InProcessBuildActionExecuter
public class InProcessBuildActionExecuter implements BuildActionExecuter<BuildActionParameters> {
private final GradleLauncherFactory gradleLauncherFactory;
private final BuildActionRunner buildActionRunner;
public Object execute(BuildAction action, BuildRequestContext buildRequestContext, BuildActionParameters actionParameters, ServiceRegistry contextServices) {
DefaultGradleLauncher gradleLauncher = (DefaultGradleLauncher) gradleLauncherFactory.newInstance(action.getStartParameter(), buildRequestContext, contextServices);
try { gradleLauncher.addStandardOutputListener(buildRequestContext.getOutputListener()); gradleLauncher.addStandardErrorListener(buildRequestContext.getErrorListener());
DefaultBuildController buildController = new DefaultBuildController(gradleLauncher);
buildActionRunner.run(action, buildController);
return buildController.result;
} finally {
gradleLauncher.stop();
}
BuildActionRunner/ExecuteBuildActionRunner
public class ExecuteBuildActionRunner implements BuildActionRunner {
@Override
public void run(BuildAction action, BuildController buildController) {
if (action instanceof ExecuteBuildAction) {
buildController.run();
buildController.setResult(null);
}
}
}
BuildController.run()
private static class DefaultBuildController implements BuildController {
public GradleInternal run() {
try {
return (GradleInternal) getLauncher().run().getGradle();
} finally {
state = State.Completed;
}
}
DefaultGradleLauncher.run()