public ProgramCommandLine makeProgramCommandLine()

in gradle-runner-agent/src/main/java/jetbrains/buildServer/gradle/agent/GradleRunnerService.java [77:160]
72 lines of code
10 McCabe index (conditional complexity)

  public ProgramCommandLine makeProgramCommandLine() throws RunBuildException {
    boolean useWrapper = ConfigurationParamsUtil.isParameterEnabled(getRunnerParameters(),
                                                                    GradleRunnerConstants.GRADLE_WRAPPER_FLAG);

    List<String> params = new ArrayList<>();
    File gradleExe;
    File gradleHome = null;
    File gradleWrapperProperties = null;
    String exePath = "gradle";
    File workingDirectory = getWorkingDirectory();

    if (!useWrapper) {
      if (getRunnerContext().isVirtualContext()) {
        getLogger().message("Step is running in a virtual context, skip detecting GRADLE_HOME");
      } else {
        gradleHome = getGradleHome();
        gradleExe = new File(gradleHome, this.exePath);
        exePath = gradleExe.getAbsolutePath();

        if (!gradleHome.exists()) {
          throw new RunBuildException("Gradle home path (" + gradleHome + ") is invalid.");
        }
        if (!gradleExe.exists()) {
          throw new RunBuildException("Gradle home path (" + gradleHome + ") does not contain a Gradle installation.  Cannot find " + this.exePath + ".");
        }
      }
    } else {
      String relativeGradleWPath = ConfigurationParamsUtil.getGradleWPath(getRunnerParameters());

      gradleExe = new File(workingDirectory, relativeGradleWPath + File.separator + wrapperName);
      exePath = gradleExe.getAbsolutePath();
      if (!gradleExe.exists()) {
        throw new RunBuildException("Gradle wrapper script " + wrapperName + " can not be found at " + gradleExe.getAbsolutePath() + "\n" +
                                    "Please, provide path to wrapper script in build configuration settings.");
      }

      gradleWrapperProperties = getGradleWrapperProperties(workingDirectory, relativeGradleWPath);
      if (!gradleWrapperProperties.exists()) {
        getLogger().warning("gradle-wrapper.properties couldn't be found at " + gradleWrapperProperties.getAbsolutePath());
      }
    }

    if (SystemInfo.isUnix) {
      params.add(exePath);
      exePath = "bash";
    }

    List<String> gradleTasks = tasksComposer.getGradleTasks(getRunnerParameters());
    List<String> userDefinedParams = ConfigurationParamsUtil.getGradleParams(getRunnerParameters());
    Map<String, String> env = getEnvironments(workingDirectory, useWrapper, gradleHome, gradleWrapperProperties);

    if (useWrapper && !gradleWrapperProperties.exists()) {
      return composerHolder.getCommandLineComposer(GradleLaunchMode.COMMAND_LINE).compose(
        getComposerParameters(env, gradleTasks, userDefinedParams, null, params, exePath, null));
    }

    GradleConnector projectConnector = getGradleConnector(workingDirectory, useWrapper, gradleHome, gradleWrapperProperties);
    File gradleUserHome = gradleUserHomeManager.detectGradleUserHome(gradleTasks, userDefinedParams, env, projectConnector).orElse(null);
    DefaultGradleVersion gradleVersion = gradleVersionDetector.detect(projectConnector, getLogger()).orElse(null);
    boolean configurationCacheEnabled =
      gradleConfigurationCacheDetector.isConfigurationCacheEnabled(getLogger(), gradleTasks, userDefinedParams, gradleUserHome, workingDirectory, gradleVersion);
    boolean configurationCacheProblemsIgnored =
      gradleConfigurationCacheDetector.areConfigurationCacheProblemsIgnored(getLogger(), gradleTasks, userDefinedParams, gradleUserHome, workingDirectory, gradleVersion);
    Set<String> unsupportedByToolingArgs =
      commandLineParametersProcessor.obtainUnsupportedArguments(Stream.concat(gradleTasks.stream(), userDefinedParams.stream()).collect(Collectors.toList()));

    GradleLaunchModeSelectionResult selectionResult = gradleLaunchModeSelector.selectMode(
      GradleLaunchModeSelector
        .Parameters
        .builder()
        .withLogger(getLogger())
        .withConfigurationParameters(getConfigParameters())
        .withGradleVersion(gradleVersion)
        .withConfigurationCacheEnabled(configurationCacheEnabled)
        .withConfigurationCacheProblemsIgnored(configurationCacheProblemsIgnored)
        .withUnsupportedByToolingArgs(unsupportedByToolingArgs)
        .build()
    );

    GradleCommandLineComposerParameters composerParameters =
      getComposerParameters(env, gradleTasks, userDefinedParams, configurationCacheEnabled, params, exePath, selectionResult);

    return composerHolder.getCommandLineComposer(selectionResult.getLaunchMode()).compose(composerParameters);
  }