private void configureJoobyRun(final Project project) { project.getTasks() .withType(JoobyTask.class, joobyRun -> { ConventionMapping mapping = joobyRun.getConventionMapping(); mapping.map("classpath", () -> new JoobyProject(project).classpath()); mapping.map("src", () -> new JoobyProject(project).sources()); mapping.map("mainClassName", () -> project.getProperties().get("mainClassName")); mapping.map("srcExtensions", () -> Arrays.asList(".java", ".conf", ".properties", ".kt")); mapping.map("compiler", () -> { File eclipseClasspath = new File(project.getProjectDir(), ".classpath"); return eclipseClasspath.exists() ? "off" : "on"; }); Gradle gradle = project.getGradle(); mapping.map("block", () -> !gradle.getStartParameter().isContinuous()); mapping.map("logLevel", () -> gradle.getStartParameter().getLogLevel().name()); }); Map<String, Object> options = new HashMap<>(); options.put(Task.TASK_TYPE, JoobyTask.class); options.put(Task.TASK_DEPENDS_ON, "classes"); options.put(Task.TASK_NAME, "joobyRun"); options.put(Task.TASK_DESCRIPTION, "Run, debug and hot reload applications"); options.put(Task.TASK_GROUP, "jooby"); project.getTasks().create(options); }
String[] args = project.getGradle().getStartParameter().getProjectProperties() .entrySet().stream().map(Object::toString).collect(Collectors.toList()) .toArray(new String[0]);
public StartParameter convert(final ParsedCommandLine options, final StartParameter startParameter) throws CommandLineArgumentException { loggingConfigurationCommandLineConverter.convert(options, startParameter); parallelConfigurationCommandLineConverter.convert(options, startParameter); Transformer<File, String> resolver = new BasicFileResolver(startParameter.getCurrentDir()); startParameter.getProjectProperties().putAll(projectProperties); .setGradleUserHomeDir(startParameter.getGradleUserHomeDir()) .setProjectDir(startParameter.getProjectDir()) .setCurrentDir(startParameter.getCurrentDir()); layoutCommandLineConverter.convert(options, layout); startParameter.setGradleUserHomeDir(layout.getGradleUserHomeDir()); if (layout.getProjectDir() != null) { startParameter.setProjectDir(layout.getProjectDir()); startParameter.setSearchUpwards(layout.getSearchUpwards()); startParameter.setBuildFile(resolver.transform(options.option(BUILD_FILE).getValue())); startParameter.setSettingsFile(resolver.transform(options.option(SETTINGS_FILE).getValue())); startParameter.addInitScript(resolver.transform(script)); startParameter.setProjectCacheDir(resolver.transform(options.option(PROJECT_CACHE_DIR).getValue())); startParameter.setBuildProjectDependencies(false); startParameter.setTaskNames(options.getExtraArguments()); startParameter.setDryRun(true);
/** * Returns the tasks that should be executed for this build. * * @return The sequence. May be empty. Never returns null. */ @Input public List<String> getTasks() { return getStartParameter().getTaskNames(); }
public List<Output> getStackOutputs(String stackName) { if (getProject().getGradle().getStartParameter().isOffline() == false) { Optional<Stack> stack = getStack(stackName); return stack.map(Stack::getOutputs).orElse(Collections.emptyList()); } logger.info("offline mode: return empty outputs"); return Collections.emptyList(); }
public BuildLayoutConfiguration(StartParameter startParameter) { currentDir = startParameter.getCurrentDir(); searchUpwards = startParameter.isSearchUpwards(); settingsFile = startParameter.getSettingsFile(); useEmptySettings = startParameter.isUseEmptySettings(); }
private GradleLauncher buildGradleLauncher(StartParameter startParameter) { StartParameter startParameterArg = startParameter.newInstance(); startParameterArg.setProjectProperties(startParameter.getProjectProperties()); startParameterArg.setSearchUpwards(false); startParameterArg.setProfile(startParameter.isProfile()); GradleLauncher gradleLauncher = nestedBuildFactory.nestedInstance(startParameterArg); GradleInternal build = gradleLauncher.getGradle(); if (build.getParent().findIdentityPath() == null) { // When nested inside a nested build, we need to synthesize a path for this build, as the root project is not yet known for the parent build // Use the directory structure to do this. This means that the buildSrc build and its containing build may end up with different paths Path path = build.getParent().getParent().getIdentityPath().child(startParameter.getCurrentDir().getParentFile().getName()).child(startParameter.getCurrentDir().getName()); build.setIdentityPath(path); } return gradleLauncher; } }
@Override public void scheduleTasks(final Iterable<String> taskPaths) { GradleInternal gradle = getConfiguredBuild(); Set<String> allTasks = Sets.newLinkedHashSet(gradle.getStartParameter().getTaskNames()); boolean added = allTasks.addAll(Lists.newArrayList(taskPaths)); if (!added) { return; } gradle.getStartParameter().setTaskNames(allTasks); // Force back to configure so that task graph will get reevaluated stage = Stage.Configure; doBuildStages(Stage.TaskGraph); }
/** * Get a description of this profiled build. It contains info about tasks passed to gradle as targets from the command line. */ public String getBuildDescription() { StringBuilder sb = new StringBuilder(); for (String name : startParameter.getExcludedTaskNames()) { sb.append("-x "); sb.append(name); sb.append(" "); } for (String name : startParameter.getTaskNames()) { sb.append(name); sb.append(" "); } String tasks = sb.toString(); if (tasks.length() == 0) { tasks = "(no tasks specified)"; } return "Profiled build: " + tasks; }
Path buildIdentityPath = gradle.getIdentityPath(); File gradleUserHomeDir = gradle.getGradleUserHomeDir(); BuildCacheMode buildCacheMode = startParameter.isBuildCacheEnabled() ? ENABLED : DISABLED; RemoteAccessMode remoteAccessMode = startParameter.isOffline() ? OFFLINE : ONLINE; boolean logStackTraces = startParameter.getShowStacktrace() != ShowStacktrace.INTERNAL_EXCEPTIONS;
public void buildStarted(Gradle gradle) { StartParameter startParameter = gradle.getStartParameter(); logger.info("Starting Build"); if (logger.isDebugEnabled()) { logger.debug("Gradle user home: {}", startParameter.getGradleUserHomeDir()); logger.debug("Current dir: {}", startParameter.getCurrentDir()); logger.debug("Settings file: {}", startParameter.getSettingsFile()); logger.debug("Build file: {}", startParameter.getBuildFile()); } }
if (project.getGradle().getStartParameter().getLogLevel().compareTo(LogLevel.QUIET) < 0) { project.getLogger().warn("WARNING: You are running a REPL task without '-q'. You are missing out on a better REPL experience."); if (!project.getGradle().getStartParameter().getConsoleOutput().equals(ConsoleOutput.Plain)) { project.getLogger().warn("WARNING: You are running a REPL task without '--console plain'. You are missing out on a better REPL experience.");
public void execute(BuildExecutionContext context) { GradleInternal gradle = context.getGradle(); TaskGraphExecuter taskGraph = gradle.getTaskGraph(); if (gradle.getStartParameter().isContinueOnFailure()) { taskGraph.useFailureHandler(new ContinueOnFailureHandler()); } taskGraph.addTaskExecutionGraphListener(new BindAllReferencesOfProjectsToExecuteListener()); taskGraph.execute(); }
private static void checkIfNotRunningFromRootOfPride(final Project project) throws IOException { // Don't check for a pride when not searching upward if (!project.getGradle().getStartParameter().isSearchUpwards()) { return; } if (!alreadyCheckedIfRunningFromRootOfPride) { if (!Pride.containsPride(project.getRootDir())) { logger.debug("No pride found in " + String.valueOf(project.getRootDir())); for (File dir = project.getRootDir().getParentFile(); dir != null && dir.canRead(); dir = dir.getParentFile()) { logger.debug("Checking pride in " + dir); if (Pride.containsPride(dir)) { logger.warn("WARNING: Found a pride in parent directory " + dir + ". " + "This means that you are running Gradle from a subproject of the pride. " + "Dynamic dependencies cannot be resolved to local projects this way. " + "To avoid this warning run Gradle from the root of the pride."); break; } } } alreadyCheckedIfRunningFromRootOfPride = true; } }
public static AntBuilder setupAnt(Task task) { AntBuilder ant = task.getAnt(); LogLevel startLevel = task.getProject().getGradle().getStartParameter().getLogLevel(); if (startLevel.compareTo(LogLevel.LIFECYCLE) >= 0) { GradleVersion v2_14 = GradleVersion.version("2.14"); if (GradleVersion.current().compareTo(v2_14) >= 0) { ant.setLifecycleLogLevel(AntMessagePriority.ERROR); } else { try { LoggingManager.class.getMethod("setLevel", LogLevel.class).invoke(task.getLogging(), LogLevel.ERROR); } catch (Exception e) { //Couldn't find it? We are on some weird version oh well. task.getLogger().info("Could not set log level:", e); } } } return ant; }
private static boolean isProgressFooterEnabled(Project project) { // TODO: Consolidate with MavenProjectProperties? if ("plain".equals(System.getProperty(PropertyNames.CONSOLE))) { return false; } switch (project.getGradle().getStartParameter().getConsoleOutput()) { case Plain: return false; case Auto: // Enables progress footer when ANSI is supported (Windows or TERM not 'dumb'). return Os.isFamily(Os.FAMILY_WINDOWS) || !"dumb".equals(System.getenv("TERM")); default: return true; } }
void loadProperties(File settingsDir, StartParameter startParameter, Map<String, String> systemProperties, Map<String, String> envProperties) { defaultProperties.clear(); overrideProperties.clear(); addGradleProperties(defaultProperties, new File(settingsDir, Project.GRADLE_PROPERTIES)); addGradleProperties(overrideProperties, new File(startParameter.getGradleUserHomeDir(), Project.GRADLE_PROPERTIES)); setSystemProperties(startParameter.getSystemPropertiesArgs()); overrideProperties.putAll(getEnvProjectProperties(envProperties)); overrideProperties.putAll(getSystemProjectProperties(systemProperties)); overrideProperties.putAll(startParameter.getProjectProperties()); }
/** * Prints the locations of a project's build.gradle, settings.gradle, and gradle.properties. * * @param project the project */ private static void printGradleFiles(Project project) { Path projectPath = project.getProjectDir().toPath(); // Print build.gradle System.out.println(project.getBuildFile()); // Print settings.gradle if (project.getGradle().getStartParameter().getSettingsFile() != null) { System.out.println(project.getGradle().getStartParameter().getSettingsFile()); } else if (Files.exists(projectPath.resolve(Settings.DEFAULT_SETTINGS_FILE))) { System.out.println(projectPath.resolve(Settings.DEFAULT_SETTINGS_FILE)); } // Print gradle.properties if (Files.exists(projectPath.resolve("gradle.properties"))) { System.out.println(projectPath.resolve("gradle.properties")); } }
private boolean shouldConfigurePublications(Project project) { //Sanity system property. Semi-internal. boolean workaroundTurnedOff = "false".equals(System.getProperty("org.shipkit.publications-bug-workaround")); if (workaroundTurnedOff) { return true; } //Workaround for bintray plugin/Gradle bug (https://github.com/bintray/gradle-bintray-plugin/issues/159) return !project.getGradle().getStartParameter().getTaskNames().contains("tasks"); } }
public List<Parameter> getStackParameters(String stackName) { if (getProject().getGradle().getStartParameter().isOffline() == false) { Optional<Stack> stack = getStack(stackName); return stack.map(Stack::getParameters).orElse(Collections.emptyList()); } logger.info("offline mode: return empty parameters"); return Collections.emptyList(); }