public Runnable createAction(CommandLineParser parser, ParsedCommandLine commandLine) { Parameters parameters = parametersConverter.convert(commandLine, new Parameters()); parameters .getDaemonParameters() .applyDefaultsFor( new JvmVersionDetector(new DefaultExecActionFactory(new IdentityFileResolver())) .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( UUID.randomUUID().toString(), daemonParameters.getBaseDir(), daemonParameters.getIdleTimeout(), daemonParameters.getPeriodicCheckInterval()); 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 runBuildInSingleUseDaemon( StartParameter startParameter, DaemonParameters daemonParameters, ServiceRegistry loggingServices) { // (SF) this is a workaround until this story is completed. I'm hardcoding setting the idle // timeout to be max X mins. // this way we avoid potential runaway daemons that steal resources on linux and break builds on // windows. // We might leave that in if we decide it's a good idea for an extra safety net. int maxTimeout = 2 * 60 * 1000; if (daemonParameters.getIdleTimeout() > maxTimeout) { daemonParameters.setIdleTimeout(maxTimeout); } // end of workaround. // Create a client that will not match any existing daemons, so it will always startup a new one ServiceRegistry clientSharedServices = createGlobalClientServices(); ServiceRegistry clientServices = clientSharedServices .get(DaemonClientFactory.class) .createSingleUseDaemonClientServices( loggingServices.get(OutputEventListener.class), daemonParameters, System.in); DaemonClient client = clientServices.get(DaemonClient.class); return runBuild(startParameter, daemonParameters, client, clientSharedServices); }
private DaemonParameters constructDaemonParameters(StartParameter startParameter) { Map<String, String> mergedSystemProperties = startParameter.getMergedSystemProperties(); DaemonParameters daemonParameters = new DaemonParameters(); daemonParameters.configureFromBuildDir( startParameter.getCurrentDir(), startParameter.isSearchUpwards()); daemonParameters.configureFromGradleUserHome(startParameter.getGradleUserHomeDir()); daemonParameters.configureFromSystemProperties(mergedSystemProperties); return daemonParameters; }
public DaemonRegistry getDaemonRegistry() { DaemonParameters parameters = new DaemonParameters(new BuildLayoutParameters()); parameters.setBaseDir(getDaemonBaseDir()); return new DaemonClientServices( LoggingServiceRegistry.newEmbeddableLogging(), parameters, new ByteArrayInputStream(new byte[0])) .get(DaemonRegistry.class); }
private Action<ExecutionListener> daemonBuildAction( ParsedCommandLine commandLine, DaemonParameters daemonParameters, DaemonClient client) { return new ActionAdapter( new DaemonBuildAction( client, commandLine, getWorkingDir(), clientMetaData(), getBuildStartTime(), daemonParameters.getEffectiveSystemProperties(), System.getenv())); }
private Action<ExecutionListener> runBuildInSingleUseDaemon( ParsedCommandLine commandLine, DaemonParameters daemonParameters, ServiceRegistry loggingServices) { // (SF) this is a workaround until this story is completed. I'm hardcoding setting the idle // timeout to be max X mins. // this way we avoid potential runaway daemons that steal resources on linux and break builds on // windows. // We might leave that in if we decide it's a good idea for an extra safety net. int maxTimeout = 2 * 60 * 1000; if (daemonParameters.getIdleTimeout() > maxTimeout) { daemonParameters.setIdleTimeout(maxTimeout); } // end of workaround. // Create a client that will not match any existing daemons, so it will always startup a new one DaemonClientServices clientServices = new SingleUseDaemonClientServices(loggingServices, daemonParameters, System.in); DaemonClient client = clientServices.get(DaemonClient.class); return daemonBuildAction(commandLine, daemonParameters, client); }
private Action<ExecutionListener> createAction( CommandLineParser parser, final ParsedCommandLine commandLine, CommandLineConverter<StartParameter> startParameterConverter, final ServiceRegistry loggingServices) { if (commandLine.hasOption(HELP)) { return new ActionAdapter(new ShowUsageAction(parser)); } if (commandLine.hasOption(VERSION)) { return new ActionAdapter(new ShowVersionAction()); } if (commandLine.hasOption(GUI)) { return new ActionAdapter(new ShowGuiAction()); } final StartParameter startParameter = new StartParameter(); startParameterConverter.convert(commandLine, startParameter); DaemonParameters daemonParameters = constructDaemonParameters(startParameter); if (commandLine.hasOption(FOREGROUND)) { ForegroundDaemonConfiguration conf = new ForegroundDaemonConfiguration( daemonParameters.getUid(), daemonParameters.getBaseDir(), daemonParameters.getIdleTimeout()); return new ActionAdapter(new ForegroundDaemonMain(conf)); } if (commandLine.hasOption(STOP)) { return stopAllDaemons(daemonParameters, loggingServices); } if (useDaemon(commandLine, daemonParameters)) { return runBuildWithDaemon(commandLine, daemonParameters, loggingServices); } if (canUseCurrentProcess(daemonParameters)) { return runBuildInProcess(loggingServices, startParameter); } return runBuildInSingleUseDaemon(commandLine, daemonParameters, 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); }
private Parameters initParams(ProviderOperationParameters operationParameters) { BuildLayoutParameters layout = new BuildLayoutParameters(); if (operationParameters.getGradleUserHomeDir() != null) { layout.setGradleUserHomeDir(operationParameters.getGradleUserHomeDir()); } layout.setSearchUpwards( operationParameters.isSearchUpwards() != null ? operationParameters.isSearchUpwards() : true); layout.setProjectDir(operationParameters.getProjectDir()); Map<String, String> properties = new HashMap<String, String>(); new LayoutToPropertiesConverter().convert(layout, properties); DaemonParameters daemonParams = new DaemonParameters(layout); new PropertiesToDaemonParametersConverter().convert(properties, daemonParams); if (operationParameters.getDaemonBaseDir(null) != null) { daemonParams.setBaseDir(operationParameters.getDaemonBaseDir(null)); } // override the params with the explicit settings provided by the tooling api List<String> defaultJvmArgs = daemonParams.getAllJvmArgs(); daemonParams.setJvmArgs(operationParameters.getJvmArguments(defaultJvmArgs)); File defaultJavaHome = daemonParams.getEffectiveJavaHome(); daemonParams.setJavaHome(operationParameters.getJavaHome(defaultJavaHome)); if (operationParameters.getDaemonMaxIdleTimeValue() != null && operationParameters.getDaemonMaxIdleTimeUnits() != null) { int idleTimeout = (int) operationParameters .getDaemonMaxIdleTimeUnits() .toMillis(operationParameters.getDaemonMaxIdleTimeValue()); daemonParams.setIdleTimeout(idleTimeout); } return new Parameters(daemonParams, properties); }
private boolean useDaemon(ParsedCommandLine commandLine, DaemonParameters daemonParameters) { boolean useDaemon = daemonParameters.isEnabled(); useDaemon = useDaemon || commandLine.hasOption(DAEMON); useDaemon = useDaemon && !commandLine.hasOption(NO_DAEMON); return useDaemon; }
private boolean hasSystemProperties(DaemonParameters requiredBuildParameters) { return containsAll( getJvmOptions().getSystemProperties(), requiredBuildParameters.getSystemProperties()); }
private boolean hasJvmArgs(DaemonParameters requiredBuildParameters) { return requiredBuildParameters.isUsingDefaultJvmArgs() || (effectiveJvmOptions .getManagedJvmArgs() .equals(requiredBuildParameters.getEffectiveJvmArgs())); }
private boolean hasJavaHome(DaemonParameters requiredJavaHome) { return getJavaHome().equals(requiredJavaHome.getEffectiveJavaHome()); }
public DaemonStartupInfo startDaemon() { String daemonUid = UUID.randomUUID().toString(); GradleInstallation gradleInstallation = CurrentGradleInstallation.get(); ModuleRegistry registry = new DefaultModuleRegistry(gradleInstallation); ClassPath classpath; List<File> searchClassPath; if (gradleInstallation == null) { // When not running from a Gradle distro, need runtime impl for launcher plus the search path // to look for other modules classpath = new DefaultClassPath(); for (Module module : registry.getModule("gradle-launcher").getAllRequiredModules()) { classpath = classpath.plus(module.getClasspath()); } searchClassPath = registry.getAdditionalClassPath().getAsFiles(); } else { // When running from a Gradle distro, only need launcher jar. The daemon can find everything // from there. classpath = registry.getModule("gradle-launcher").getImplementationClasspath(); searchClassPath = Collections.emptyList(); } if (classpath.isEmpty()) { throw new IllegalStateException( "Unable to construct a bootstrap classpath when starting the daemon"); } versionValidator.validate(daemonParameters); List<String> daemonArgs = new ArrayList<String>(); daemonArgs.add(daemonParameters.getEffectiveJvm().getJavaExecutable().getAbsolutePath()); List<String> daemonOpts = daemonParameters.getEffectiveJvmArgs(); daemonArgs.addAll(daemonOpts); daemonArgs.add("-cp"); daemonArgs.add(CollectionUtils.join(File.pathSeparator, classpath.getAsFiles())); if (Boolean.getBoolean("org.gradle.daemon.debug")) { daemonArgs.add("-Xdebug"); daemonArgs.add("-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"); } LOGGER.debug("Using daemon args: {}", daemonArgs); daemonArgs.add(GradleDaemon.class.getName()); // Version isn't used, except by a human looking at the output of jps. daemonArgs.add(GradleVersion.current().getVersion()); // Serialize configuration to daemon via the process' stdin ByteArrayOutputStream serializedConfig = new ByteArrayOutputStream(); FlushableEncoder encoder = new KryoBackedEncoder(new EncodedStream.EncodedOutput(serializedConfig)); try { encoder.writeString(daemonParameters.getGradleUserHomeDir().getAbsolutePath()); encoder.writeString(daemonDir.getBaseDir().getAbsolutePath()); encoder.writeSmallInt(daemonParameters.getIdleTimeout()); encoder.writeString(daemonUid); encoder.writeSmallInt(daemonOpts.size()); for (String daemonOpt : daemonOpts) { encoder.writeString(daemonOpt); } encoder.writeSmallInt(searchClassPath.size()); for (File file : searchClassPath) { encoder.writeString(file.getAbsolutePath()); } encoder.flush(); } catch (IOException e) { throw new UncheckedIOException(e); } ByteArrayInputStream stdInput = new ByteArrayInputStream(serializedConfig.toByteArray()); DaemonStartupInfo daemonInfo = startProcess(daemonArgs, daemonDir.getVersionedDir(), stdInput); listener.daemonStarted(daemonInfo); return daemonInfo; }