/**
* Adapts the source object to a view object.
*
* @param mapper An action that is invoked for each source object in the graph that is to be
* adapted. The action can influence how the source object is adapted via the provided {@link
* SourceObjectMapping}.
*/
public <T, S> T adapt(
Class<T> targetType, S sourceObject, Action<? super SourceObjectMapping> mapper) {
if (sourceObject == null) {
return null;
}
Class<? extends T> wrapperType = targetTypeProvider.getTargetType(targetType, sourceObject);
DefaultSourceObjectMapping mapping =
new DefaultSourceObjectMapping(sourceObject, targetType, wrapperType);
mapper.execute(mapping);
wrapperType = mapping.wrapperType.asSubclass(targetType);
if (wrapperType.isInstance(sourceObject)) {
return wrapperType.cast(sourceObject);
}
if (targetType.isEnum()) {
return adaptToEnum(targetType, sourceObject);
}
MixInMethodInvoker mixInMethodInvoker = null;
if (mapping.mixInType != null) {
mixInMethodInvoker =
new MixInMethodInvoker(
mapping.mixInType, new AdaptingMethodInvoker(mapper, new ReflectionMethodInvoker()));
}
MethodInvoker overrideInvoker = chainInvokers(mixInMethodInvoker, mapping.overrideInvoker);
Object proxy =
Proxy.newProxyInstance(
wrapperType.getClassLoader(),
new Class<?>[] {wrapperType},
new InvocationHandlerImpl(sourceObject, overrideInvoker, mapper));
if (mixInMethodInvoker != null) {
mixInMethodInvoker.setProxy(proxy);
}
return wrapperType.cast(proxy);
}
public void execute(WorkerContext workerContext) {
LoggingManagerInternal loggingManager = createLoggingManager();
loggingManager.setLevel(logLevel).start();
FilteringClassLoader filteredWorkerClassLoader =
new FilteringClassLoader(getClass().getClassLoader());
filteredWorkerClassLoader.allowPackage("org.slf4j");
filteredWorkerClassLoader.allowClass(Action.class);
filteredWorkerClassLoader.allowClass(WorkerContext.class);
ClassLoader applicationClassLoader = workerContext.getApplicationClassLoader();
FilteringClassLoader filteredApplication = new FilteringClassLoader(applicationClassLoader);
ObservableUrlClassLoader implementationClassLoader =
createImplementationClassLoader(filteredWorkerClassLoader, filteredApplication);
// Configure classpaths
for (String sharedPackage : sharedPackages) {
filteredApplication.allowPackage(sharedPackage);
}
implementationClassLoader.addURLs(implementationClassPath);
// Deserialize the worker action
Action<WorkerContext> action;
try {
ObjectInputStream instr =
new ClassLoaderObjectInputStream(
new ByteArrayInputStream(serializedWorkerAction), implementationClassLoader);
action = (Action<WorkerContext>) instr.readObject();
} catch (Exception e) {
throw UncheckedException.asUncheckedException(e);
}
action.execute(workerContext);
}
public void start() {
WorkerProcessBuilder builder = workerFactory.create();
builder.applicationClasspath(classPathRegistry.getClassPath("ANT").getAsFiles());
builder.sharedPackages("org.apache.tools.ant");
builder.getJavaCommand().systemProperty("test.system.property", "value");
builder.getJavaCommand().environment("TEST_ENV_VAR", "value");
builder.worker(action);
if (mainClass != null) {
builder.getJavaCommand().setMain(mainClass);
}
proc = builder.build();
try {
proc.start();
assertFalse(startFails);
} catch (ExecException e) {
assertTrue(startFails);
return;
}
proc.getConnection().addIncoming(TestListenerInterface.class, exceptionListener);
if (serverAction != null) {
serverAction.execute(proc.getConnection());
}
}
@Override
public DeploymentDescriptor securityRole(Action<? super EarSecurityRole> action) {
EarSecurityRole role = instantiator.newInstance(DefaultEarSecurityRole.class);
action.execute(role);
securityRoles.add(role);
return this;
}
private BuildResult run(Action<GradleExecutionResult> resultVerification) {
if (projectDirectory == null) {
throw new InvalidRunnerConfigurationException(
"Please specify a project directory before executing the build");
}
File testKitDir = createTestKitDir(testKitDirProvider);
GradleDistribution effectiveDistribution =
distribution == null ? findGradleInstallFromGradleRunner() : distribution;
GradleExecutionResult execResult =
gradleExecutor.run(
new GradleExecutionParameters(
effectiveDistribution,
testKitDir,
projectDirectory,
arguments,
jvmArguments,
classpath,
debug,
standardOutput,
standardError));
resultVerification.execute(execResult);
return createBuildResult(execResult);
}
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);
}
@Override
public synchronized Long maybeStoreEntry(Action<Long> storeEntryAction) {
if (assignedId == null) {
assignedId = nextId;
storeEntryAction.execute(assignedId);
}
return assignedId;
}
public void execute(ExecutionListener executionListener) {
try {
action.execute(executionListener);
} catch (ReportedException e) {
executionListener.onFailure(e.getCause());
} catch (Throwable t) {
reporter.reportException(t);
executionListener.onFailure(t);
}
}
private void eachLine(Action<String> action) {
BufferedReader reader = new BufferedReader(new StringReader(getOutput()));
String line;
try {
while ((line = reader.readLine()) != null) {
action.execute(line);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
NoInputsRuleAction that = (NoInputsRuleAction) o;
return action.equals(that.action);
}
public Void call() throws Exception {
final ObservableUrlClassLoader applicationClassLoader = createApplicationClassLoader();
WorkerContext context =
new WorkerContext() {
public ClassLoader getApplicationClassLoader() {
return applicationClassLoader;
}
};
worker.execute(context);
return null;
}
public PersistentCache open(
File cacheDir,
String displayName,
CacheUsage usage,
CacheValidator cacheValidator,
Map<String, ?> properties,
FileLockManager.LockMode lockMode,
Action<? super PersistentCache> initializer) {
GFileUtils.mkdirs(cacheDir);
InMemoryCache cache = new InMemoryCache(cacheDir);
if (initializer != null) {
initializer.execute(cache);
}
return cache;
}
private BuildResult run(Action<GradleExecutionResult> resultVerification) {
if (projectDirectory == null) {
throw new InvalidRunnerConfigurationException(
"Please specify a project directory before executing the build");
}
GradleExecutionResult execResult =
gradleExecutor.run(
gradleHome, gradleUserHomeDir, projectDirectory, arguments, jvmArguments);
resultVerification.execute(execResult);
return new DefaultBuildResult(
execResult.getStandardOutput(), execResult.getStandardError(), execResult.getTasks());
}
public void resolve(DependencyMetaData dependency, BuildableComponentIdResolveResult result) {
ModuleVersionSelector module = dependency.getRequested();
DefaultDependencyResolveDetails details = new DefaultDependencyResolveDetails(module);
try {
rule.execute(details);
} catch (Throwable e) {
result.failed(new ModuleVersionResolveException(module, e));
return;
}
if (details.isUpdated()) {
DependencyMetaData substitutedDependency =
dependency.withRequestedVersion(details.getTarget());
resolver.resolve(substitutedDependency, result);
result.setSelectionReason(details.getSelectionReason());
return;
}
resolver.resolve(dependency, result);
}
public void onCreate(ModelNodeInternal node) {
if (boundTo != null) {
throw new IllegalStateException(
String.format(
"Reference %s for %s is already bound to %s.",
predicate.getReference(), referrer, boundTo));
}
ModelPromise promise = node.getPromise();
if (isTypeCompatible(promise)) {
boundTo = node;
bindAction.execute(this);
} else {
throw new InvalidModelRuleException(
referrer,
new ModelRuleBindingException(
IncompatibleTypeReferenceReporter.of(
node, promise, predicate.getReference(), writable)
.asString()));
}
}
protected LocallyAvailableResource doAdd(
File destination, String failureDescription, Action<File> action) {
try {
GFileUtils.parentMkdirs(destination);
File inProgressMarkerFile = getInProgressMarkerFile(destination);
GFileUtils.touch(inProgressMarkerFile);
try {
deleteAction.delete(destination);
action.execute(destination);
} catch (Throwable t) {
deleteAction.delete(destination);
throw t;
} finally {
deleteAction.delete(inProgressMarkerFile);
}
} catch (Throwable t) {
throw new GradleException(failureDescription, t);
}
return entryAt(destination);
}
RemoteTestClassProcessor forkProcess() {
WorkerProcessBuilder builder = workerFactory.create();
builder.setBaseName("Gradle Test Executor");
builder.applicationClasspath(classPath);
builder.setLoadApplicationInSystemClassLoader(true);
builder.worker(new TestWorker(processorFactory));
options.copyTo(builder.getJavaCommand());
buildConfigAction.execute(builder);
workerProcess = builder.build();
workerProcess.start();
ObjectConnection connection = workerProcess.getConnection();
connection.useParameterSerializer(TestEventSerializer.create());
connection.addIncoming(TestResultProcessor.class, resultProcessor);
RemoteTestClassProcessor remoteProcessor =
connection.addOutgoing(RemoteTestClassProcessor.class);
connection.connect();
remoteProcessor.startProcessing();
return remoteProcessor;
}
public GradleExecuter using(Action<GradleExecuter> action) {
action.execute(executer);
return executer;
}
public IvyArtifact artifact(Object source, Action<? super IvyArtifact> config) {
IvyArtifact artifact = artifact(source);
config.execute(artifact);
return artifact;
}
public void descriptor(Action<? super IvyModuleDescriptorSpec> configure) {
configure.execute(descriptor);
}
public void configurations(Action<? super IvyConfigurationContainer> config) {
config.execute(configurations);
}
public void source(Action<? super SourceDirectorySet> config) {
config.execute(getSource());
}
public MavenArtifact addArtifact(Object source, Action<? super MavenArtifact> config) {
MavenArtifact artifact = addArtifact(source);
config.execute(artifact);
return artifact;
}
public void visitClasses(Action<? super TestClassResult> visitor) {
for (TestClassResult classResult : results.values()) {
visitor.execute(classResult);
}
}
public void execute(T subject, List<?> inputs) {
action.execute(subject);
}
public void walk(Action<? super CopySpecInternal> action) {
action.execute(this);
for (CopySpecInternal child : getChildren()) {
child.walk(action);
}
}
@Override
public int hashCode() {
return action.hashCode();
}
@Test
public void executorDoesNotInterruptExecutionInCaseOfError() {
action.execute(javaExecSpec);
verify(javaExecSpec).setIgnoreExitValue(true);
}
@Override
public void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs) {
configAction.execute(view);
}
public void copyTo(OutputStream outstr) {
generator.execute(outstr);
}