public void assertCanExecute() {
   assertNull(getExecutable());
   assertEquals(getJavaHome(), Jvm.current().getJavaHome());
   String defaultEncoding = getImplicitJvmSystemProperties().get("file.encoding");
   if (defaultEncoding != null) {
     assertEquals(Charset.forName(defaultEncoding), Charset.defaultCharset());
   }
   assertFalse(isRequireGradleHome());
 }
예제 #2
0
 protected boolean supportsWhiteSpaceInEnvVars() {
   final Jvm current = Jvm.current();
   if (getJavaHome().equals(current.getJavaHome())) {
     // we can tell for sure
     return current.getJavaVersion().isJava7Compatible();
   } else {
     // TODO improve lookup by reusing AvailableJavaHomes testfixture
     // for now we play it safe and just return false;
     return false;
   }
 }
예제 #3
0
  /**
   * Locates a JVM installation that has a different version to the current JVM, ie for which
   * java.version is different.
   *
   * @return null if not found.
   */
  @Nullable
  public static JavaInfo getDifferentVersion() {
    Jvm jvm = Jvm.current();
    for (JvmInstallation candidate : getJvms()) {
      if (candidate.getJavaVersion().equals(jvm.getJavaVersion())) {
        continue;
      }
      return Jvm.forHome(candidate.getJavaHome());
    }

    return null;
  }
예제 #4
0
 /**
  * Locates a JRE installation for the current JVM. Prefers a stand-alone JRE installation over one
  * that is part of a JDK install.
  *
  * @return The JRE home directory, or null if not found
  */
 public static File getBestJre() {
   Jvm jvm = Jvm.current();
   Jre jre = jvm.getStandaloneJre();
   if (jre != null) {
     return jre.getHomeDir();
   }
   jre = jvm.getJre();
   if (jre != null) {
     return jre.getHomeDir();
   }
   return null;
 }
예제 #5
0
  /**
   * Locates a JDK installation that is different to the current JVM, ie for which java.home is
   * different.
   *
   * @return null if not found.
   */
  @Nullable
  public static JavaInfo getDifferentJdk() {
    Jvm jvm = Jvm.current();
    for (JvmInstallation candidate : getJvms()) {
      if (candidate.getJavaHome().equals(jvm.getJavaHome())) {
        continue;
      }
      // Currently tests implicitly assume a JDK
      if (!candidate.isJdk()) {
        continue;
      }
      return Jvm.forHome(candidate.getJavaHome());
    }

    return null;
  }
예제 #6
0
  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));
  }
예제 #7
0
 public File getEffectiveJavaHome() {
   if (javaHome == null) {
     return canonicalise(Jvm.current().getJavaHome());
   }
   return javaHome;
 }
예제 #8
0
 public File getEffectiveJavaExecutable() {
   if (javaHome == null) {
     return Jvm.current().getJavaExecutable();
   }
   return Jvm.forHome(javaHome).getJavaExecutable();
 }
예제 #9
0
public class DaemonParameters {
  static final int DEFAULT_IDLE_TIMEOUT = 3 * 60 * 60 * 1000;
  static final int DEFAULT_PERIODIC_CHECK_INTERVAL_MILLIS = 10 * 1000;

  public static final List<String> DEFAULT_JVM_ARGS =
      ImmutableList.of("-Xmx1024m", "-XX:MaxPermSize=256m", "-XX:+HeapDumpOnOutOfMemoryError");
  public static final List<String> DEFAULT_JVM_9_ARGS =
      ImmutableList.of("-Xmx1024m", "-XX:+HeapDumpOnOutOfMemoryError");
  public static final String INTERACTIVE_TOGGLE = "org.gradle.interactive";

  private final File gradleUserHomeDir;

  private File baseDir;
  private int idleTimeout = DEFAULT_IDLE_TIMEOUT;

  private int periodicCheckInterval = DEFAULT_PERIODIC_CHECK_INTERVAL_MILLIS;
  private final DaemonJvmOptions jvmOptions = new DaemonJvmOptions(new IdentityFileResolver());
  private boolean enabled = true;
  private boolean hasJvmArgs;
  private boolean foreground;
  private boolean stop;
  private boolean status;
  private boolean interactive = System.console() != null || Boolean.getBoolean(INTERACTIVE_TOGGLE);
  private JavaInfo jvm = Jvm.current();

  public DaemonParameters(BuildLayoutParameters layout) {
    this(layout, Collections.<String, String>emptyMap());
  }

  public DaemonParameters(BuildLayoutParameters layout, Map<String, String> extraSystemProperties) {
    jvmOptions.systemProperties(extraSystemProperties);
    baseDir = new File(layout.getGradleUserHomeDir(), "daemon");
    gradleUserHomeDir = layout.getGradleUserHomeDir();
  }

  public boolean isInteractive() {
    return interactive;
  }

  public boolean isEnabled() {
    return enabled;
  }

  public void setEnabled(boolean enabled) {
    this.enabled = enabled;
  }

  public File getBaseDir() {
    return baseDir;
  }

  public File getGradleUserHomeDir() {
    return gradleUserHomeDir;
  }

  public int getIdleTimeout() {
    return idleTimeout;
  }

  public void setIdleTimeout(int idleTimeout) {
    this.idleTimeout = idleTimeout;
  }

  public int getPeriodicCheckInterval() {
    return periodicCheckInterval;
  }

  public void setPeriodicCheckInterval(int periodicCheckInterval) {
    this.periodicCheckInterval = periodicCheckInterval;
  }

  public List<String> getEffectiveJvmArgs() {
    return jvmOptions.getAllImmutableJvmArgs();
  }

  public List<String> getEffectiveSingleUseJvmArgs() {
    return jvmOptions.getAllSingleUseImmutableJvmArgs();
  }

  public JavaInfo getEffectiveJvm() {
    return jvm;
  }

  @Nullable
  public DaemonParameters setJvm(JavaInfo jvm) {
    this.jvm = jvm == null ? Jvm.current() : jvm;
    return this;
  }

  public void applyDefaultsFor(JavaVersion javaVersion) {
    if (hasJvmArgs) {
      return;
    }
    if (javaVersion.compareTo(JavaVersion.VERSION_1_9) >= 0) {
      jvmOptions.jvmArgs(DEFAULT_JVM_9_ARGS);
    } else {
      jvmOptions.jvmArgs(DEFAULT_JVM_ARGS);
    }
  }

  public Map<String, String> getSystemProperties() {
    Map<String, String> systemProperties = new HashMap<String, String>();
    GUtil.addToMap(systemProperties, jvmOptions.getMutableSystemProperties());
    return systemProperties;
  }

  public Map<String, String> getEffectiveSystemProperties() {
    Map<String, String> systemProperties = new HashMap<String, String>();
    GUtil.addToMap(systemProperties, jvmOptions.getMutableSystemProperties());
    GUtil.addToMap(systemProperties, jvmOptions.getImmutableDaemonProperties());
    GUtil.addToMap(systemProperties, System.getProperties());
    return systemProperties;
  }

  public void setJvmArgs(Iterable<String> jvmArgs) {
    hasJvmArgs = true;
    jvmOptions.setAllJvmArgs(jvmArgs);
  }

  public void setDebug(boolean debug) {
    jvmOptions.setDebug(debug);
  }

  public DaemonParameters setBaseDir(File baseDir) {
    this.baseDir = baseDir;
    return this;
  }

  public boolean getDebug() {
    return jvmOptions.getDebug();
  }

  public boolean isForeground() {
    return foreground;
  }

  public void setForeground(boolean foreground) {
    this.foreground = foreground;
  }

  public boolean isStop() {
    return stop;
  }

  public void setStop(boolean stop) {
    this.stop = stop;
  }

  public boolean isStatus() {
    return status;
  }

  public void setStatus(boolean status) {
    this.status = status;
  }
}
예제 #10
0
 @Nullable
 public DaemonParameters setJvm(JavaInfo jvm) {
   this.jvm = jvm == null ? Jvm.current() : jvm;
   return this;
 }
 public File getJavaHome() {
   return javaHome == null ? Jvm.current().getJavaHome() : javaHome;
 }