org.gradle.api.invocation.Gradle Java Examples

public File getBaseDirectory(Object scope, String key, CacheBuilder.VersionStrategy versionStrategy) {
    if (key.equalsIgnoreCase("projects") || key.equalsIgnoreCase("tasks") || !key.matches("\\p{Alpha}+[-//.\\w]*")) {
        throw new IllegalArgumentException(String.format("Unsupported cache key '%s'.", key));
    }
    if (scope == null) {
        return getCacheDir(globalCacheDir, versionStrategy, key);
    }
    if (scope instanceof Gradle) {
        Gradle gradle = (Gradle) scope;
        return getCacheDir(getBuildCacheDir(gradle.getRootProject()), versionStrategy, key);
    }
    if (scope instanceof Project) {
        Project project = (Project) scope;
        return getCacheDir(getBuildCacheDir(project.getRootProject()), versionStrategy, String.format("projects/%s/%s", project.getPath().replace(':', '_'), key));
    }
    if (scope instanceof Task) {
        Task task = (Task) scope;
        return getCacheDir(getBuildCacheDir(task.getProject().getRootProject()), versionStrategy, String.format("tasks/%s/%s", task.getPath().replace(':', '_'), key));
    }
    throw new IllegalArgumentException(String.format("Don't know how to determine the cache directory for scope of type %s.", scope.getClass().getSimpleName()));
}
 

private void ensureStackdriver(Gradle gradle) {
  // make sure we only initialize stackdriver once as gradle daemon is not guaranteed to restart
  // across gradle invocations.
  if (!STACKDRIVER_INITIALIZED.compareAndSet(false, true)) {
    logger.lifecycle("Stackdriver exporter already initialized.");
    return;
  }
  logger.lifecycle("Initializing Stackdriver exporter.");

  try {
    StackdriverStatsExporter.createAndRegister(
        StackdriverStatsConfiguration.builder()
            .setExportInterval(Duration.fromMillis(STACKDRIVER_UPLOAD_PERIOD_MS))
            .build());

    // make sure gradle does not exit before metrics get uploaded to stackdriver.
    gradle.addBuildListener(new DrainingBuildListener(STACKDRIVER_UPLOAD_PERIOD_MS, logger));
  } catch (IOException e) {
    throw new GradleException("Could not configure metrics exporter", e);
  }
}
 

public DefaultGradle(Gradle parent, StartParameter startParameter, ServiceRegistryFactory parentRegistry) {
    this.parent = parent;
    this.startParameter = startParameter;
    this.services = parentRegistry.createFor(this);
    this.listenerManager = services.get(ListenerManager.class);
    taskGraph = services.get(TaskGraphExecuter.class);
    distributionLocator = services.get(GradleDistributionLocator.class);
    classLoaderScope = services.get(ClassLoaderScope.class);
    pluginContainer = services.get(PluginContainer.class);
    fileResolver = services.get(FileResolver.class);
    scriptPluginFactory = services.get(ScriptPluginFactory.class);
    scriptHandlerFactory = services.get(ScriptHandlerFactory.class);
    buildListenerBroadcast = listenerManager.createAnonymousBroadcaster(BuildListener.class);
    projectEvaluationListenerBroadcast = listenerManager.createAnonymousBroadcaster(ProjectEvaluationListener.class);
    buildListenerBroadcast.add(new BuildAdapter() {
        @Override
        public void projectsLoaded(Gradle gradle) {
            rootProjectActions.execute(rootProject);
            rootProjectActions = null;
        }
    });
}
 

public void applyToGradle(Gradle gradle) {
    if(isOfflineMode(gradle)) {
        gradle.rootProject(project -> {
            createMetricsExtension(project);
            project.getLogger().warn("Build is running offline. Metrics will not be collected.");
        });
        return;
    }
    if(isMetricsDisabled(gradle)) {
        gradle.rootProject(project -> {
            createMetricsExtension(project);
            project.getLogger().warn("Metrics have been disabled for this build.");
        });
        return;
    }
    BuildMetrics buildMetrics = initializeBuildMetrics(gradle);
    createAndRegisterGradleBuildMetricsCollector(gradle, buildMetrics);
    gradle.rootProject(this::configureProject);
}
 

public DefaultGradle(Gradle parent, StartParameter startParameter, ServiceRegistryFactory parentRegistry) {
    this.parent = parent;
    this.startParameter = startParameter;
    this.services = parentRegistry.createFor(this);
    this.listenerManager = services.get(ListenerManager.class);
    taskGraph = services.get(TaskGraphExecuter.class);
    distributionLocator = services.get(GradleDistributionLocator.class);
    classLoaderScope = services.get(ClassLoaderScopeRegistry.class).getCoreAndPluginsScope();
    pluginContainer = services.get(PluginContainer.class);
    fileResolver = services.get(FileResolver.class);
    scriptPluginFactory = services.get(ScriptPluginFactory.class);
    scriptHandlerFactory = services.get(ScriptHandlerFactory.class);
    buildListenerBroadcast = listenerManager.createAnonymousBroadcaster(BuildListener.class);
    projectEvaluationListenerBroadcast = listenerManager.createAnonymousBroadcaster(ProjectEvaluationListener.class);
    buildListenerBroadcast.add(new BuildAdapter() {
        @Override
        public void projectsLoaded(Gradle gradle) {
            rootProjectActions.execute(rootProject);
            rootProjectActions = null;
        }
    });
}
 

protected boolean isMetricsDisabled(Gradle gradle) {
    String metricsEnabledParameter = gradle.getStartParameter().getProjectProperties().get(METRICS_ENABLED_PROPERTY);
    boolean metricsDisabled = metricsEnabledParameter != null && metricsEnabledParameter.equals("false");
    if(metricsDisabled) {
        return true;
    }
    File gradleProperties = new File(gradle.getStartParameter().getProjectDir(), "gradle.properties");
    if(gradleProperties.exists()) {
        try (Stream<String> stream = Files.lines(gradleProperties.toPath())) {
            return stream.anyMatch(line ->
                    line.contains(METRICS_ENABLED_PROPERTY) && line.contains("false"));
        } catch (IOException e) {
            return false;
        }
    }
    return false;
}
 

public File getBaseDirectory(Object scope, String key, CacheBuilder.VersionStrategy versionStrategy) {
    if (key.equalsIgnoreCase("projects") || key.equalsIgnoreCase("tasks") || !key.matches("\\p{Alpha}+[-//.\\w]*")) {
        throw new IllegalArgumentException(String.format("Unsupported cache key '%s'.", key));
    }
    if (scope == null) {
        return getCacheDir(globalCacheDir, versionStrategy, key);
    }
    if (scope instanceof Gradle) {
        Gradle gradle = (Gradle) scope;
        return getCacheDir(getBuildCacheDir(gradle.getRootProject()), versionStrategy, key);
    }
    if (scope instanceof Project) {
        Project project = (Project) scope;
        return getCacheDir(getBuildCacheDir(project.getRootProject()), versionStrategy, String.format("projects/%s/%s", project.getPath().replace(':', '_'), key));
    }
    if (scope instanceof Task) {
        Task task = (Task) scope;
        return getCacheDir(getBuildCacheDir(task.getProject().getRootProject()), versionStrategy, String.format("tasks/%s/%s", task.getPath().replace(':', '_'), key));
    }
    throw new IllegalArgumentException(String.format("Don't know how to determine the cache directory for scope of type %s.", scope.getClass().getSimpleName()));
}
 

public File getBaseDirectory(Object scope, String key, CacheBuilder.VersionStrategy versionStrategy) {
    if (key.equalsIgnoreCase("projects") || key.equalsIgnoreCase("tasks") || !key.matches("\\p{Alpha}+[-//.\\w]*")) {
        throw new IllegalArgumentException(String.format("Unsupported cache key '%s'.", key));
    }
    if (scope == null) {
        return getCacheDir(globalCacheDir, versionStrategy, key);
    }
    if (scope instanceof Gradle) {
        Gradle gradle = (Gradle) scope;
        return getCacheDir(getBuildCacheDir(gradle.getRootProject()), versionStrategy, key);
    }
    if (scope instanceof Project) {
        Project project = (Project) scope;
        return getCacheDir(getBuildCacheDir(project.getRootProject()), versionStrategy, String.format("projects/%s/%s", project.getPath().replace(':', '_'), key));
    }
    if (scope instanceof Task) {
        Task task = (Task) scope;
        return getCacheDir(getBuildCacheDir(task.getProject().getRootProject()), versionStrategy, String.format("tasks/%s/%s", task.getPath().replace(':', '_'), key));
    }
    throw new IllegalArgumentException(String.format("Don't know how to determine the cache directory for scope of type %s.", scope.getClass().getSimpleName()));
}
 

public void buildStarted(Gradle gradle) {
    StartParameter startParameter = gradle.getStartParameter();
    logger.info("Starting Build");
    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());
}
 

/**
 * This gets the port out of the start parameters. Why? Because this is meant to be run from the init script and the system properties haven't been set yet. That is due to how gradle is run from
 * the bat file/shell script. It has to manually set the java system properties (-D). I don't this is a desired side-effect.
 *
 * @param gradle the gradle object
 * @return an integer or null if we didn't get the port.
 */
private static Integer getPort(Gradle gradle) {
    String portText = gradle.getStartParameter().getSystemPropertiesArgs().get(ProtocolConstants.PORT_NUMBER_SYSTEM_PROPERTY);
    if (portText == null) {
        LOGGER.error("Failed to set " + ProtocolConstants.PORT_NUMBER_SYSTEM_PROPERTY + " system property");
        return null;
    }

    try {
        return Integer.parseInt(portText);
    } catch (NumberFormatException e) {
        LOGGER.error("Invalid " + ProtocolConstants.PORT_NUMBER_SYSTEM_PROPERTY + " system property", e);
        return null;
    }
}
 

private String getDisplayName(Task task) {
    Gradle build = task.getProject().getGradle();
    if (build.getParent() == null) {
        // The main build, use the task path
        return task.getPath();
    }
    // A nested build, use a discriminator
    return Project.PATH_SEPARATOR + build.getRootProject().getName() + task.getPath();
}
 

public void buildStarted(Gradle gradle) {
    StartParameter startParameter = gradle.getStartParameter();
    logger.info("Starting Build");
    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());
}
 

public void buildStarted(Gradle gradle) {
    StartParameter startParameter = gradle.getStartParameter();
    logger.info("Starting Build");
    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());
}
 

public DefaultTaskArtifactStateCacheAccess(Gradle gradle, CacheRepository cacheRepository, CacheDecorator decorator) {
    this.inMemoryDecorator = decorator;
    cache = cacheRepository
            .cache(gradle, "taskArtifacts")
            .withDisplayName("task history cache")
            .withLockOptions(mode(FileLockManager.LockMode.None)) // Lock on demand
            .open();
}
 

TaskArtifactStateCacheAccess createCacheAccess(Gradle gradle, CacheRepository cacheRepository, InMemoryTaskArtifactCache inMemoryTaskArtifactCache, GradleBuildEnvironment environment) {
    CacheDecorator decorator;
    if (environment.isLongLivingProcess()) {
        decorator = inMemoryTaskArtifactCache;
    } else {
        decorator = new NoOpDecorator();
    }
    return new DefaultTaskArtifactStateCacheAccess(gradle, cacheRepository, decorator);
}
 

TaskArtifactStateCacheAccess createCacheAccess(Gradle gradle, CacheRepository cacheRepository, InMemoryTaskArtifactCache inMemoryTaskArtifactCache, GradleBuildEnvironment environment) {
    CacheDecorator decorator;
    if (environment.isLongLivingProcess()) {
        decorator = inMemoryTaskArtifactCache;
    } else {
        decorator = new NoOpDecorator();
    }
    return new DefaultTaskArtifactStateCacheAccess(gradle, cacheRepository, decorator);
}
 

public GradleBuildComparison(
        ComparableGradleBuildExecuter sourceBuildExecuter,
        ComparableGradleBuildExecuter targetBuildExecuter,
        Logger logger,
        ProgressLogger progressLogger,
        Gradle gradle) {
    this.sourceBuildExecuter = sourceBuildExecuter;
    this.targetBuildExecuter = targetBuildExecuter;
    this.logger = logger;
    this.progressLogger = progressLogger;
    this.gradle = gradle;
}
 

public GradleBuildComparison(
        ComparableGradleBuildExecuter sourceBuildExecuter,
        ComparableGradleBuildExecuter targetBuildExecuter,
        Logger logger,
        ProgressLogger progressLogger,
        Gradle gradle) {
    this.sourceBuildExecuter = sourceBuildExecuter;
    this.targetBuildExecuter = targetBuildExecuter;
    this.logger = logger;
    this.progressLogger = progressLogger;
    this.gradle = gradle;
}
 

public GradleBuildComparison(
        ComparableGradleBuildExecuter sourceBuildExecuter,
        ComparableGradleBuildExecuter targetBuildExecuter,
        Logger logger,
        ProgressLogger progressLogger,
        Gradle gradle) {
    this.sourceBuildExecuter = sourceBuildExecuter;
    this.targetBuildExecuter = targetBuildExecuter;
    this.logger = logger;
    this.progressLogger = progressLogger;
    this.gradle = gradle;
}
 

public DefaultTaskArtifactStateCacheAccess(Gradle gradle, CacheRepository cacheRepository, CacheDecorator decorator) {
    this.inMemoryDecorator = decorator;
    cache = cacheRepository
            .cache(gradle, "taskArtifacts")
            .withDisplayName("task history cache")
            .withLockOptions(mode(FileLockManager.LockMode.None)) // Lock on demand
            .open();
}
 

public void buildStarted(Gradle gradle) {
    StartParameter startParameter = gradle.getStartParameter();
    logger.info("Starting Build");
    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());
}
 

TaskArtifactStateCacheAccess createCacheAccess(Gradle gradle, CacheRepository cacheRepository, InMemoryTaskArtifactCache inMemoryTaskArtifactCache, GradleBuildEnvironment environment) {
    CacheDecorator decorator;
    if (environment.isLongLivingProcess()) {
        decorator = inMemoryTaskArtifactCache;
    } else {
        decorator = new NoOpDecorator();
    }
    return new DefaultTaskArtifactStateCacheAccess(gradle, cacheRepository, decorator);
}
 

/**
 * This starts a gradle client for doing regular execution of a command. It expects the port number to set as a system property. Note: this is using gradle to find the port. See getPort().
 *
 * @param gradle the gradle object.
 */
public static void invokeExecuteGradleClient(Gradle gradle) {
    Integer port = getPort(gradle);
    if (port == null) {
        return;
    }

    ExecuteGradleCommandClientProtocol protocol = new ExecuteGradleCommandClientProtocol(gradle);
    GradleClient client = new GradleClient();
    client.start(protocol, port);
}
 

@Override
public void buildStarted(Gradle gradle) {
    buildStack.add(0, (GradleInternal) gradle);
}
 

public void buildStarted(Gradle build) {
    //we'll never get this message because execution has started before we were instantiated (and before we were able to add our listener).
}
 

public BuildResult(Gradle gradle, Throwable failure) {
    this.gradle = gradle;
    this.failure = failure;
}
 

public ExecuteGradleCommandClientProtocol(Gradle gradle) {
    this.gradle = gradle;
}
 

public void projectsLoaded(Gradle gradle) {
}
 

@Override
public void projectsEvaluated(Gradle gradle) {
    buildDir = gradle.getRootProject().getBuildDir();
}
 

@Override
public void buildStarted(Gradle gradle) {
    buildStack.add(0, (GradleInternal) gradle);
}