Example #1
0
  public String resolveAsRelativePath(Object path) {
    List<String> basePath =
        Arrays.asList(StringUtils.split(baseDir.getAbsolutePath(), "/" + File.separator));
    File targetFile = resolve(path);
    List<String> targetPath =
        new ArrayList<String>(
            Arrays.asList(StringUtils.split(targetFile.getAbsolutePath(), "/" + File.separator)));

    // Find and remove common prefix
    int maxDepth = Math.min(basePath.size(), targetPath.size());
    int prefixLen = 0;
    while (prefixLen < maxDepth && basePath.get(prefixLen).equals(targetPath.get(prefixLen))) {
      prefixLen++;
    }
    basePath = basePath.subList(prefixLen, basePath.size());
    targetPath = targetPath.subList(prefixLen, targetPath.size());

    for (int i = 0; i < basePath.size(); i++) {
      targetPath.add(0, "..");
    }
    if (targetPath.isEmpty()) {
      return ".";
    }
    return CollectionUtils.join(File.separator, targetPath);
  }
Example #2
0
  private String compilerConfig(String action, String... args) {
    String quotedArgs =
        CollectionUtils.join(",", CollectionUtils.collect(args, new SingleQuotingTransformer()));
    StringBuilder builder = new StringBuilder();
    for (String plugin : getPluginList()) {
      String compilerPrefix = getCompilerPrefix(plugin);
      if (compilerPrefix == null) {
        continue;
      }
      builder
          .append(compilerPrefix)
          .append("Compiler.")
          .append(action)
          .append(" ")
          .append(quotedArgs)
          .append("\n");
    }

    return builder.toString();
  }
  protected List<String> getCompleteArgs() {
    List<String> args = new ArrayList<>(getArgs());

    List<String> dirNames = getDirNames();

    if (dirNames.size() == 1) {
      args.add("sass.dir=/" + _removeLeadingSlash(dirNames.get(0)));
    } else {
      for (int i = 0; i < dirNames.size(); i++) {
        String dirName = dirNames.get(i);

        args.add("sass.dir." + i + "=/" + _removeLeadingSlash(dirName));
      }
    }

    String docrootDirName = FileUtil.getAbsolutePath(getDocrootDir());

    args.add("sass.docroot.dir=" + _removeTrailingSlash(docrootDirName));

    args.add("sass.generate.source.map=" + isGenerateSourceMap());

    args.add("sass.output.dir=" + _addTrailingSlash(getOutputDirName()));

    String portalCommonPath = FileUtil.getAbsolutePath(getPortalCommonPath());

    args.add("sass.portal.common.path=" + portalCommonPath);

    args.add("sass.precision=" + getPrecision());

    String rtlExcludedPathRegexps = CollectionUtils.join(",", getRtlExcludedPathRegexps());

    args.add("sass.rtl.excluded.path.regexps=" + rtlExcludedPathRegexps);

    String sassCompilerClassName = getSassCompilerClassName();

    if (Validator.isNotNull(sassCompilerClassName)) {
      args.add("sass.compiler.class.name=" + sassCompilerClassName);
    }

    return args;
  }
  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;
  }