public ClassPathSnapshot snapshot(ClassPath classPath) {
List<String> visitedFilePaths = new LinkedList<String>();
Set<File> visitedDirs = new LinkedHashSet<File>();
byte[] combinedHash = new byte[0];
List<File> cpFiles = classPath.getAsFiles();
combinedHash =
hash(
visitedFilePaths, visitedDirs, combinedHash, cpFiles.toArray(new File[cpFiles.size()]));
return new ClassPathSnapshotImpl(visitedFilePaths, combinedHash);
}
public DefaultIsolatedAntBuilder(
ClassPathRegistry classPathRegistry, ClassLoaderFactory classLoaderFactory) {
this.classPathRegistry = classPathRegistry;
this.classLoaderFactory = classLoaderFactory;
this.libClasspath = new DefaultClassPath();
GroovySystemLoaderFactory groovySystemLoaderFactory = new GroovySystemLoaderFactory();
this.classLoaderCache = new ClassPathToClassLoaderCache(groovySystemLoaderFactory);
List<File> antClasspath =
Lists.newArrayList(classPathRegistry.getClassPath("ANT").getAsFiles());
// Need tools.jar for compile tasks
File toolsJar = Jvm.current().getToolsJar();
if (toolsJar != null) {
antClasspath.add(toolsJar);
}
antLoader = classLoaderFactory.createIsolatedClassLoader(new DefaultClassPath(antClasspath));
FilteringClassLoader loggingLoader = new FilteringClassLoader(getClass().getClassLoader());
loggingLoader.allowPackage("org.slf4j");
loggingLoader.allowPackage("org.apache.commons.logging");
loggingLoader.allowPackage("org.apache.log4j");
loggingLoader.allowClass(Logger.class);
loggingLoader.allowClass(LogLevel.class);
this.baseAntLoader =
new CachingClassLoader(new MultiParentClassLoader(antLoader, loggingLoader));
// Need gradle core to pick up ant logging adapter, AntBuilder and such
ClassPath gradleCoreUrls = classPathRegistry.getClassPath("GRADLE_CORE");
gradleCoreUrls = gradleCoreUrls.plus(classPathRegistry.getClassPath("GROOVY"));
// Need Transformer (part of AntBuilder API) from base services
gradleCoreUrls = gradleCoreUrls.plus(classPathRegistry.getClassPath("GRADLE_BASE_SERVICES"));
this.antAdapterLoader = new URLClassLoader(gradleCoreUrls.getAsURLArray(), baseAntLoader);
gradleApiGroovyLoader =
groovySystemLoaderFactory.forClassLoader(this.getClass().getClassLoader());
antAdapterGroovyLoader = groovySystemLoaderFactory.forClassLoader(antAdapterLoader);
// register finalizer for the root builder only!
FINALIZERS.add(new Finalizer(this, FINALIZER_REFQUEUE));
}
public ClassPath findClassPath(String name) {
if (name.equals("WORKER_PROCESS")) {
// TODO - split out a logging project and use its classpath, instead of hardcoding logging
// dependencies here
ClassPath classpath = new DefaultClassPath();
classpath =
classpath.plus(
moduleRegistry.getModule("gradle-base-services").getImplementationClasspath());
classpath =
classpath.plus(moduleRegistry.getModule("gradle-core").getImplementationClasspath());
classpath =
classpath.plus(moduleRegistry.getModule("gradle-cli").getImplementationClasspath());
classpath =
classpath.plus(moduleRegistry.getModule("gradle-native").getImplementationClasspath());
classpath =
classpath.plus(moduleRegistry.getModule("gradle-messaging").getImplementationClasspath());
classpath = classpath.plus(moduleRegistry.getExternalModule("slf4j-api").getClasspath());
classpath =
classpath.plus(moduleRegistry.getExternalModule("logback-classic").getClasspath());
classpath = classpath.plus(moduleRegistry.getExternalModule("logback-core").getClasspath());
classpath = classpath.plus(moduleRegistry.getExternalModule("jul-to-slf4j").getClasspath());
classpath = classpath.plus(moduleRegistry.getExternalModule("guava-jdk5").getClasspath());
return classpath;
}
if (name.equals("WORKER_MAIN")) {
synchronized (lock) {
if (workerClassPath == null) {
workerClassPathCache =
cacheRepository.cache("workerMain").withInitializer(new CacheInitializer()).open();
workerClassPath = new DefaultClassPath(jarFile(workerClassPathCache));
}
LOGGER.debug("Using worker process classpath: {}", workerClassPath);
return workerClassPath;
}
}
return null;
}
public ClassLoader createIsolatedClassLoader(ClassPath classPath) {
return doCreateIsolatedClassLoader(classPath.getAsURLs());
}
@Override
public List<? extends File> getPluginClasspath() {
return classpath.getAsFiles();
}
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;
}