private <T extends ComponentSpec> void registerImplementation(
ComponentSpecFactory components, List<ModelView<?>> inputs) {
ServiceRegistry serviceRegistry =
ModelViews.assertType(inputs.get(0), ModelType.of(ServiceRegistry.class)).getInstance();
final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
final ProjectIdentifier projectIdentifier =
ModelViews.assertType(inputs.get(1), ModelType.of(ProjectIdentifier.class)).getInstance();
final ProjectSourceSet projectSourceSet =
ModelViews.assertType(inputs.get(2), ModelType.of(ProjectSourceSet.class)).getInstance();
components.registerFactory(
Cast.<ModelType<ComponentSpec>>uncheckedCast(publicType),
descriptor,
new BiFunction<ComponentSpec, String, MutableModelNode>() {
@Override
public ComponentSpec apply(String name, MutableModelNode modelNode) {
ComponentSpecIdentifier id =
new DefaultComponentSpecIdentifier(projectIdentifier.getPath(), name);
return BaseComponentSpec.create(
implementationType.getConcreteClass(),
id,
modelNode,
projectSourceSet,
instantiator);
}
});
components.registerImplementation(
Cast.<ModelType<T>>uncheckedCast(publicType),
descriptor,
Cast.<ModelType<? extends T>>uncheckedCast(implementationType));
if (COMPONENT_SPEC_INTERNAL_MODEL_TYPE.isAssignableFrom(implementationType)) {
components.registerInternalView(publicType, descriptor, COMPONENT_SPEC_INTERNAL_MODEL_TYPE);
}
}
private Runnable runBuildInSingleUseDaemon(
StartParameter startParameter,
DaemonParameters daemonParameters,
ServiceRegistry loggingServices) {
// (SF) this is a workaround until this story is completed. I'm hardcoding setting the idle
// timeout to be max X mins.
// this way we avoid potential runaway daemons that steal resources on linux and break builds on
// windows.
// We might leave that in if we decide it's a good idea for an extra safety net.
int maxTimeout = 2 * 60 * 1000;
if (daemonParameters.getIdleTimeout() > maxTimeout) {
daemonParameters.setIdleTimeout(maxTimeout);
}
// end of workaround.
// Create a client that will not match any existing daemons, so it will always startup a new one
ServiceRegistry clientSharedServices = createGlobalClientServices();
ServiceRegistry clientServices =
clientSharedServices
.get(DaemonClientFactory.class)
.createSingleUseDaemonClientServices(
loggingServices.get(OutputEventListener.class), daemonParameters, System.in);
DaemonClient client = clientServices.get(DaemonClient.class);
return runBuild(startParameter, daemonParameters, client, clientSharedServices);
}
private BuildActionExecuter<ProviderOperationParameters> createExecuter(
ProviderOperationParameters operationParameters) {
LoggingServiceRegistry loggingServices;
Parameters params = initParams(operationParameters);
BuildActionExecuter<BuildActionParameters> executer;
if (Boolean.TRUE.equals(operationParameters.isEmbedded())) {
loggingServices = this.loggingServices;
executer = embeddedExecutor;
} else {
if (Boolean.TRUE.equals(operationParameters.isColorOutput())) {
PrintStream outStr = new PrintStream(operationParameters.getStandardOutput());
DefaultColorMap colourMap = new DefaultColorMap();
colourMap.setUseColor(true);
Console console = new AnsiConsole(outStr, outStr, colourMap, true);
loggingServices = this.loggingServices.newColoredLogging(console);
} else {
loggingServices = this.loggingServices.newToolingApiLogging();
}
loggingServices
.get(OutputEventRenderer.class)
.configure(operationParameters.getBuildLogLevel());
ServiceRegistry clientServices =
daemonClientFactory.createBuildClientServices(
loggingServices.get(OutputEventListener.class),
params.daemonParams,
operationParameters.getStandardInput(SafeStreams.emptyInput()));
executer = clientServices.get(DaemonClient.class);
}
Factory<LoggingManagerInternal> loggingManagerFactory =
loggingServices.getFactory(LoggingManagerInternal.class);
return new LoggingBridgingBuildActionExecuter(
new DaemonBuildActionExecuter(executer, params.daemonParams), loggingManagerFactory);
}
@Defaults
public static void addToolChain(
NativeToolChainRegistryInternal toolChainRegistry, ServiceRegistry serviceRegistry) {
final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
final BuildOperationProcessor buildOperationProcessor =
serviceRegistry.get(BuildOperationProcessor.class);
final CompilerMetaDataProviderFactory metaDataProviderFactory =
serviceRegistry.get(CompilerMetaDataProviderFactory.class);
toolChainRegistry.registerFactory(
Clang.class,
new NamedDomainObjectFactory<Clang>() {
public Clang create(String name) {
return instantiator.newInstance(
ClangToolChain.class,
name,
buildOperationProcessor,
OperatingSystem.current(),
fileResolver,
execActionFactory,
metaDataProviderFactory,
instantiator);
}
});
toolChainRegistry.registerDefaultToolChain(ClangToolChain.DEFAULT_NAME, Clang.class);
}
@Model
public static VisualStudioExtensionInternal visualStudio(ServiceRegistry serviceRegistry) {
Instantiator instantiator = serviceRegistry.get(Instantiator.class);
ProjectLocator projectLocator = serviceRegistry.get(ProjectLocator.class);
FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
return instantiator.newInstance(
DefaultVisualStudioExtension.class, instantiator, projectLocator, fileResolver);
}
private void _forceProjectHierarchyEvaluation(Project project) {
GradleInternal gradleInternal = (GradleInternal) project.getGradle();
ServiceRegistry serviceRegistry = gradleInternal.getServices();
ProjectConfigurer projectConfigurer = serviceRegistry.get(ProjectConfigurer.class);
projectConfigurer.configureHierarchy((ProjectInternal) project);
}
private Runnable stopAllDaemons(
DaemonParameters daemonParameters, ServiceRegistry loggingServices) {
ServiceRegistry clientSharedServices = createGlobalClientServices();
ServiceRegistry clientServices =
clientSharedServices
.get(DaemonClientFactory.class)
.createStopDaemonServices(
loggingServices.get(OutputEventListener.class), daemonParameters);
DaemonStopClient stopClient = clientServices.get(DaemonStopClient.class);
return new StopDaemonAction(stopClient);
}
public DefaultGradleLauncherFactory(ServiceRegistry globalServices) {
sharedServices = globalServices;
tracker = new NestedBuildTracker();
// Register default loggers
ListenerManager listenerManager = sharedServices.get(ListenerManager.class);
listenerManager.addListener(
new BuildProgressLogger(sharedServices.get(ProgressLoggerFactory.class)));
listenerManager.useLogger(
new DependencyResolutionLogger(sharedServices.get(ProgressLoggerFactory.class)));
GradleLauncher.injectCustomFactory(this);
}
/** This is used by consumers 1.0-milestone-3 and later */
public DefaultConnection() {
LOGGER.debug("Tooling API provider {} created.", GradleVersion.current().getVersion());
LoggingServiceRegistry loggingServices = LoggingServiceRegistry.newEmbeddableLogging();
services =
ServiceRegistryBuilder.builder()
.displayName("Connection services")
.parent(loggingServices)
.parent(NativeServices.getInstance())
.provider(new ConnectionScopeServices(loggingServices))
.build();
adapter = services.get(ProtocolToModelAdapter.class);
connection = services.get(ProviderConnection.class);
}
private Runnable runBuildWithDaemon(
StartParameter startParameter,
DaemonParameters daemonParameters,
ServiceRegistry loggingServices) {
// Create a client that will match based on the daemon startup parameters.
ServiceRegistry clientSharedServices = createGlobalClientServices();
ServiceRegistry clientServices =
clientSharedServices
.get(DaemonClientFactory.class)
.createBuildClientServices(
loggingServices.get(OutputEventListener.class), daemonParameters, System.in);
DaemonClient client = clientServices.get(DaemonClient.class);
return runBuild(startParameter, daemonParameters, client, clientSharedServices);
}
public ConfigurationContainerInternal getConfigurationContainer() {
if (configurationContainer == null) {
final Instantiator instantiator = parent.get(Instantiator.class);
ConfigurationResolver resolver = createDependencyResolver(getResolveRepositoryHandler());
configurationContainer =
instantiator.newInstance(
DefaultConfigurationContainer.class,
resolver,
instantiator,
domainObjectContext,
parent.get(ListenerManager.class),
dependencyMetaDataProvider);
}
return configurationContainer;
}
@Override
public ComponentResolvers create(ResolveContext context) {
final ModelSchemaStore schemaStore = registry.get(ModelSchemaStore.class);
VariantsMetaData variants = ((LocalComponentResolveContext) context).getVariants();
JvmLocalLibraryMetaDataAdapter libraryMetaDataAdapter = new JvmLocalLibraryMetaDataAdapter();
LocalLibraryDependencyResolver<JvmBinarySpec> delegate =
new LocalLibraryDependencyResolver<JvmBinarySpec>(
JvmBinarySpec.class,
projectModelResolver,
registry.getAll(VariantAxisCompatibilityFactory.class),
variants,
schemaStore,
libraryMetaDataAdapter,
new DefaultLibraryResolutionErrorMessageBuilder(variants, schemaStore));
return DelegatingComponentResolvers.of(delegate);
}
public DependencyHandler getDependencyHandler() {
if (dependencyHandler == null) {
dependencyHandler =
new DefaultDependencyHandler(
getConfigurationContainer(), parent.get(DependencyFactory.class), projectFinder);
}
return dependencyHandler;
}
public void execute(ExecutionListener executionListener) {
LoggingManagerInternal loggingManager =
loggingServices.getFactory(LoggingManagerInternal.class).create();
loggingManager.setLevel(loggingConfiguration.getLogLevel());
loggingManager.colorStdOutAndStdErr(loggingConfiguration.isColorOutput());
loggingManager.start();
action.execute(executionListener);
}
public DefaultComponentMetadataHandler getComponentMetadataHandler() {
if (componentMetadataHandler == null) {
Instantiator instantiator = parent.get(Instantiator.class);
componentMetadataHandler =
instantiator.newInstance(DefaultComponentMetadataHandler.class, instantiator);
}
return componentMetadataHandler;
}
/**
* Converts the given command-line arguments to a {@code Runnable} action which performs the
* action requested by the command-line args. Does not have any side-effects. Each action will
* call the supplied {@link org.gradle.launcher.exec.ExecutionListener} once it has completed.
*
* <p>Implementation note: attempt to defer as much as possible until action execution time.
*
* @param args The command-line arguments.
* @return The action to execute.
*/
public Action<ExecutionListener> convert(List<String> args) {
CommandLineParser parser = new CommandLineParser();
CommandLineConverter<StartParameter> startParameterConverter = createStartParameterConverter();
startParameterConverter.configure(parser);
parser.option(HELP, "?", "help").hasDescription("Shows this help message.");
parser.option(VERSION, "version").hasDescription("Print version info.");
parser.option(GUI).hasDescription("Launches the Gradle GUI.");
parser
.option(FOREGROUND)
.hasDescription("Starts the Gradle daemon in the foreground.")
.experimental();
parser
.option(DAEMON)
.hasDescription(
"Uses the Gradle daemon to run the build. Starts the daemon if not running.");
parser.option(NO_DAEMON).hasDescription("Do not use the Gradle daemon to run the build.");
parser.option(STOP).hasDescription("Stops the Gradle daemon if it is running.");
LoggingConfiguration loggingConfiguration = new LoggingConfiguration();
ServiceRegistry loggingServices = createLoggingServices();
Action<ExecutionListener> action;
try {
ParsedCommandLine commandLine = parser.parse(args);
@SuppressWarnings("unchecked")
CommandLineConverter<LoggingConfiguration> loggingConfigurationConverter =
(CommandLineConverter<LoggingConfiguration>)
loggingServices.get(CommandLineConverter.class);
loggingConfigurationConverter.convert(commandLine, loggingConfiguration);
action = createAction(parser, commandLine, startParameterConverter, loggingServices);
} catch (CommandLineArgumentException e) {
action = new CommandLineParseFailureAction(parser, e);
}
return new WithLoggingAction(
loggingConfiguration,
loggingServices,
new ExceptionReportingAction(
action,
new BuildExceptionReporter(
loggingServices.get(StyledTextOutputFactory.class),
loggingConfiguration,
clientMetaData())));
}
private DefaultRepositoryHandler createRepositoryHandler() {
Instantiator instantiator = parent.get(Instantiator.class);
ResolverFactory resolverFactory =
new DefaultResolverFactory(
get(LocalMavenCacheLocator.class),
fileResolver,
instantiator,
get(RepositoryTransportFactory.class));
return instantiator.newInstance(
DefaultRepositoryHandler.class, resolverFactory, instantiator);
}
private Runnable runBuildInProcess(
StartParameter startParameter,
DaemonParameters daemonParameters,
ServiceRegistry loggingServices) {
ServiceRegistry globalServices =
ServiceRegistryBuilder.builder()
.displayName("Global services")
.parent(loggingServices)
.parent(NativeServices.getInstance())
.provider(new GlobalScopeServices(startParameter.isContinuous()))
.build();
BuildActionExecuter<BuildActionParameters> executer = globalServices.get(BuildExecuter.class);
StyledTextOutputFactory textOutputFactory = globalServices.get(StyledTextOutputFactory.class);
DocumentationRegistry documentationRegistry = globalServices.get(DocumentationRegistry.class);
DaemonUsageSuggestingBuildActionExecuter daemonUsageSuggestingExecuter =
new DaemonUsageSuggestingBuildActionExecuter(
executer, textOutputFactory, documentationRegistry);
return runBuild(
startParameter, daemonParameters, daemonUsageSuggestingExecuter, globalServices);
}
// TODO:DAZ Test suites should belong to ComponentSpecContainer, and we could rely on more
// conventions from the base plugins
@Defaults
public void createGoogleTestTestSuitePerComponent(
TestSuiteContainer testSuites,
NamedDomainObjectSet<NativeComponentSpec> components,
ProjectSourceSet projectSourceSet,
ServiceRegistry serviceRegistry) {
Instantiator instantiator = serviceRegistry.get(Instantiator.class);
FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
for (NativeComponentSpec component : components) {
testSuites.add(
createGoogleTestTestSuite(component, instantiator, projectSourceSet, fileResolver));
}
}
private DefaultGoogleTestTestSuiteBinary createTestBinary(
ServiceRegistry serviceRegistry,
GoogleTestTestSuiteSpec googleTestTestSuite,
NativeBinarySpec testedBinary,
ITaskFactory taskFactory) {
BinaryNamingScheme namingScheme =
new DefaultBinaryNamingSchemeBuilder(
((NativeBinarySpecInternal) testedBinary).getNamingScheme())
.withComponentName(googleTestTestSuite.getBaseName())
.withTypeString("GoogleTestExe")
.build();
Instantiator instantiator = serviceRegistry.get(Instantiator.class);
NativeDependencyResolver resolver = serviceRegistry.get(NativeDependencyResolver.class);
return DefaultGoogleTestTestSuiteBinary.create(
googleTestTestSuite,
(NativeBinarySpecInternal) testedBinary,
namingScheme,
resolver,
instantiator,
taskFactory);
}
public ResolverFactory getResolverFactory() {
if (resolverFactory == null) {
Instantiator instantiator = parent.get(Instantiator.class);
//noinspection unchecked
resolverFactory =
new DefaultResolverFactory(
get(LocalMavenRepositoryLocator.class),
fileResolver,
instantiator,
get(RepositoryTransportFactory.class),
get(LocallyAvailableResourceFinder.class),
get(ByUrlCachedExternalResourceIndex.class));
}
return resolverFactory;
}
public BaseRepositoryFactory getBaseRepositoryFactory() {
if (baseRepositoryFactory == null) {
Instantiator instantiator = parent.get(Instantiator.class);
//noinspection unchecked
baseRepositoryFactory =
new DefaultBaseRepositoryFactory(
get(LocalMavenRepositoryLocator.class),
fileResolver,
instantiator,
get(RepositoryTransportFactory.class),
get(LocallyAvailableResourceFinder.class),
getComponentMetadataHandler(),
get(LegacyDependencyResolverRepositoryFactory.class));
}
return baseRepositoryFactory;
}
public BaseRepositoryFactory getBaseRepositoryFactory() {
if (baseRepositoryFactory == null) {
Instantiator instantiator = parent.get(Instantiator.class);
//noinspection unchecked
baseRepositoryFactory =
new DefaultBaseRepositoryFactory(
get(LocalMavenRepositoryLocator.class),
fileResolver,
instantiator,
get(RepositoryTransportFactory.class),
get(LocallyAvailableResourceFinder.class),
get(ProgressLoggerFactory.class),
get(LocalFileRepositoryCacheManager.class),
get(DownloadingRepositoryCacheManager.class),
new DefaultArtifactPublisherFactory(
new Transformer<ArtifactPublisher, ResolverProvider>() {
public ArtifactPublisher transform(ResolverProvider resolverProvider) {
return createArtifactPublisher(resolverProvider);
}
}));
}
return baseRepositoryFactory;
}
@Model
ScalaToolChain scalaToolChain(ServiceRegistry serviceRegistry) {
return serviceRegistry.get(ScalaToolChain.class);
}
public void removeListener(Object listener) {
sharedServices.get(ListenerManager.class).removeListener(listener);
}
protected TaskClassValidatorExtractor createTaskClassValidatorExtractor(
ServiceRegistry registry) {
return new DefaultTaskClassValidatorExtractor(registry.getAll(PropertyAnnotationHandler.class));
}
public void addListener(Object listener) {
sharedServices.get(ListenerManager.class).addListener(listener);
}
public StartParameter createStartParameter(String... commandLineArgs) {
if (commandLineConverter == null) {
commandLineConverter = sharedServices.get(CommandLineConverter.class);
}
return commandLineConverter.convert(Arrays.asList(commandLineArgs));
}
private DefaultRepositoryHandler createRepositoryHandler() {
Instantiator instantiator = parent.get(Instantiator.class);
return instantiator.newInstance(
DefaultRepositoryHandler.class, getRepositoryFactory(), instantiator);
}
@Model
TestSuiteContainer testSuites(ServiceRegistry serviceRegistry) {
Instantiator instantiator = serviceRegistry.get(Instantiator.class);
return instantiator.newInstance(DefaultTestSuiteContainer.class, instantiator);
}