public <T> T createProxy(
ModelElementState state,
StructSchema<T> viewSchema,
@Nullable StructSchema<? extends T> delegateSchema,
TypeConverter typeConverter) {
try {
Class<? extends T> generatedClass = getGeneratedImplementation(viewSchema, delegateSchema);
if (generatedClass == null) {
throw new IllegalStateException(
"No managed implementation class available for: " + viewSchema.getType());
}
if (delegateSchema == null) {
Constructor<? extends T> constructor =
generatedClass.getConstructor(ModelElementState.class, TypeConverter.class);
return constructor.newInstance(state, typeConverter);
} else {
ModelType<? extends T> delegateType = delegateSchema.getType();
Object delegate = state.getBackingNode().getPrivateData(delegateType);
Constructor<? extends T> constructor =
generatedClass.getConstructor(
ModelElementState.class, TypeConverter.class, delegateType.getConcreteClass());
return constructor.newInstance(state, typeConverter, delegate);
}
} catch (InvocationTargetException e) {
throw UncheckedException.throwAsUncheckedException(e.getTargetException());
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
@Override
public NodeInitializer getNodeInitializer(NodeInitializerContext<?> nodeInitializerContext) {
try {
return cache.get(nodeInitializerContext);
} catch (ExecutionException e) {
throw UncheckedException.throwAsUncheckedException(e);
} catch (UncheckedExecutionException e) {
throw UncheckedException.throwAsUncheckedException(e.getCause());
}
}
/**
* Creates a new rule source instance to be applied to a model element.
*
* @throws InvalidModelRuleDeclarationException On badly formed rule source class.
*/
public <T> ExtractedRuleSource<T> extract(Class<T> source)
throws InvalidModelRuleDeclarationException {
try {
return cache.get(source).newInstance(source);
} catch (ExecutionException e) {
throw UncheckedException.throwAsUncheckedException(e);
} catch (UncheckedExecutionException e) {
throw UncheckedException.throwAsUncheckedException(e.getCause());
}
}
@Override
public T create() {
Class<T> concreteClass = type.getConcreteClass();
try {
Constructor<T> declaredConstructor = concreteClass.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
return declaredConstructor.newInstance();
} catch (InvocationTargetException e) {
throw UncheckedException.throwAsUncheckedException(e.getTargetException());
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
public Object take(long timeoutValue, TimeUnit timeoutUnits) {
Object result;
try {
result = queue.poll(timeoutValue, timeoutUnits);
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
if (result instanceof Throwable) {
Throwable failure = (Throwable) result;
throw UncheckedException.throwAsUncheckedException(failure);
}
return result == END ? null : result;
}
public void add(Object message) {
try {
queue.put(message);
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
private void onFinishCommand() {
lock.lock();
try {
String execution = currentCommandExecution;
LOGGER.debug("onFinishCommand() called while execution = {}", execution);
currentCommandExecution = null;
onDisconnect = null;
updateActivityTimestamp();
switch (state) {
case Running:
try {
onFinishCommand.run();
condition.signalAll();
} catch (Throwable throwable) {
setState(State.Broken);
throw UncheckedException.throwAsUncheckedException(throwable);
}
break;
case StopRequested:
stop();
break;
case Stopped:
break;
default:
throw new IllegalStateException("Daemon is in unexpected state: " + state);
}
} finally {
lock.unlock();
}
}
public T parseNotation(Object notation) {
if (notation == null) {
return null;
}
if (notation instanceof CharSequence
|| notation instanceof Number
|| notation instanceof Boolean) {
return (T) notation.toString();
}
if (notation instanceof Closure) {
final Closure closure = (Closure) notation;
final Object called = closure.call();
return parseNotation(called);
}
if (notation instanceof Callable) {
try {
final Callable callableNotation = (Callable) notation;
final Object called = callableNotation.call();
return parseNotation(called);
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
DeprecationLogger.nagUserOfDeprecated(
String.format(
"Converting class %s to path using toString() method", notation.getClass().getName()),
"Please use java.io.File, java.lang.CharSequence, java.lang.Number, java.util.concurrent.Callable or groovy.lang.Closure");
return (T) notation.toString();
}
public T receive() {
lock.lock();
try {
while (true) {
DelayedMessage message = queue.peek();
if (message == null && stopping) {
return null;
}
if (message == null) {
condition.await();
continue;
}
long now = timeProvider.getCurrentTime();
if (message.dispatchTime > now) {
condition.awaitUntil(new Date(message.dispatchTime));
} else {
queue.poll();
if (queue.isEmpty()) {
condition.signalAll();
}
return message.message;
}
}
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
} finally {
lock.unlock();
}
}
private void onStartCommand(String commandDisplayName, Runnable onDisconnect) {
lock.lock();
try {
switch (state) {
case Broken:
throw new DaemonUnavailableException("This daemon is in a broken state and will stop.");
case StopRequested:
throw new DaemonUnavailableException("This daemon is currently stopping.");
case Stopped:
throw new DaemonUnavailableException("This daemon has stopped.");
}
if (currentCommandExecution != null) {
throw new DaemonUnavailableException(
String.format("This daemon is currently executing: %s", currentCommandExecution));
}
LOGGER.debug(
"onStartCommand({}) called after {} minutes of idle",
commandDisplayName,
getIdleMinutes());
try {
onStartCommand.run();
currentCommandExecution = commandDisplayName;
this.onDisconnect = onDisconnect;
updateActivityTimestamp();
condition.signalAll();
} catch (Throwable throwable) {
setState(State.Broken);
throw UncheckedException.throwAsUncheckedException(throwable);
}
} finally {
lock.unlock();
}
}
public DualPaneUIVersion1 createDualPaneUI() {
TestSingleDualPaneUIInteractionVersion1 testSingleDualPaneUIInteractionVersion1 =
new TestSingleDualPaneUIInteractionVersion1(
new TestAlternateUIInteractionVersion1(), new TestSettingsNodeVersion1());
DualPaneUIVersion1 dualPane;
try {
dualPane =
UIFactory.createDualPaneUI(
getClass().getClassLoader(),
dist.getGradleHomeDir(),
testSingleDualPaneUIInteractionVersion1,
false);
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
// make sure we got something
Assert.assertNotNull(dualPane);
dualPane.setCurrentDirectory(dist.getTestDir());
dualPane.addCommandLineArgumentAlteringListener(
new ExtraTestCommandLineOptionsListener(dist.getUserHomeDir()));
return dualPane;
}
public void setValue(Object target, Object value) {
try {
field.set(target, value);
} catch (IllegalAccessException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
public void waitFor() {
try {
latch.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
@Override
public F getValue(T target) {
try {
return fieldType.cast(field.get(target));
} catch (IllegalAccessException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
public void setValue(Object target, Object value) {
try {
method.invoke(target, value);
} catch (InvocationTargetException e) {
throw UncheckedException.unwrapAndRethrow(e);
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
public F getValue(T target) {
try {
return returnType.cast(method.invoke(target));
} catch (InvocationTargetException e) {
throw UncheckedException.unwrapAndRethrow(e);
} catch (Exception e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
private void rethrowFailures() {
if (failures.isEmpty()) {
return;
}
if (failures.size() > 1) {
throw new MultipleBuildFailures(failures);
}
throw UncheckedException.throwAsUncheckedException(failures.get(0));
}
private Object newInstanceOf(String className) {
// we must use a String literal here, otherwise using things like Foo.class.name will trigger
// unnecessary
// loading of classes in the classloader of the DefaultIsolatedAntBuilder, which is not what we
// want.
try {
return antAdapterLoader.loadClass(className).newInstance();
} catch (Exception e) {
// should never happen
throw UncheckedException.throwAsUncheckedException(e);
}
}
static {
Method equalsMethod;
Method hashCodeMethod;
try {
equalsMethod = Object.class.getMethod("equals", Object.class);
hashCodeMethod = Object.class.getMethod("hashCode");
} catch (NoSuchMethodException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
EQUALS_METHOD = equalsMethod;
HASHCODE_METHOD = hashCodeMethod;
}
public CrossVersionResultsStore(File dbFile) {
this.dbFile = dbFile;
db = new H2FileDb(dbFile, new CrossVersionResultsSchemaInitializer());
// Ignore some broken samples before the given date
DateFormat timeStampFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
timeStampFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
try {
ignoreV17Before = timeStampFormat.parse("2013-07-03 00:00:00").getTime();
} catch (ParseException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
private String getTestReportUrl() {
// File.toURI().toString() leads to an URL like this on Mac: file:/reports/index.html
// This URL is not recognized by the Mac terminal (too few leading slashes). We solve
// this be creating an URI with an empty authority.
File indexFile = new File(getTestReportDir(), "index.html");
try {
if (OperatingSystem.current().isWindows()) {
return indexFile.toURI().toString();
}
return new URI("file", "", indexFile.toString(), null, null).toString();
} catch (URISyntaxException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
private void doWriteAction(Runnable action) {
if (mode != LockMode.Exclusive) {
throw new InsufficientLockModeException("An exclusive lock is required for this operation");
}
try {
integrityViolated = true;
markDirty();
action.run();
markClean();
integrityViolated = false;
} catch (Throwable t) {
throw UncheckedException.throwAsUncheckedException(t);
}
}
private void restoreOwner() {
lock.lock();
try {
while (owner != null) {
try {
condition.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
owner = Thread.currentThread();
} finally {
lock.unlock();
}
}
public Boolean transform(NetworkInterface original) {
try {
try {
return (Boolean) method.invoke(original);
} catch (InvocationTargetException e) {
if (!(e.getCause() instanceof SocketException)) {
throw e.getCause();
}
// Ignore - treat as if we don't know
return null;
}
} catch (Throwable throwable) {
throw UncheckedException.throwAsUncheckedException(throwable);
}
}
protected void disposeBuilder(Object antBuilder, Object antLogger) {
try {
Object project = getProject(antBuilder);
Class<?> projectClass = project.getClass();
ClassLoader cl = projectClass.getClassLoader();
// remove build listener
Class<?> buildListenerClass = cl.loadClass("org.apache.tools.ant.BuildListener");
Method removeBuildListener =
projectClass.getDeclaredMethod("removeBuildListener", buildListenerClass);
removeBuildListener.invoke(project, antLogger);
antBuilder.getClass().getDeclaredMethod("close").invoke(antBuilder);
} catch (Exception ex) {
throw UncheckedException.throwAsUncheckedException(ex);
}
}
private void stopMonitoring() {
lock.lock();
try {
while (notifying) {
try {
condition.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
handler = null;
} finally {
lock.unlock();
}
}
private void takeOwnership(String operationDisplayName) {
lock.lock();
try {
while (owner != null && owner != Thread.currentThread()) {
try {
condition.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
owner = Thread.currentThread();
operations.pushCacheAction(operationDisplayName);
} finally {
lock.unlock();
}
}
/** Blocks until all queued messages are delivered. */
public void stop() {
lock.lock();
try {
stopping = true;
condition.signalAll();
while (!queue.isEmpty()) {
try {
condition.await();
} catch (InterruptedException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
} finally {
lock.unlock();
}
}
private URI getDistribution(
String repositoryUrl, GradleVersion version, String archiveName, String archiveClassifier) {
try {
return new URI(
repositoryUrl
+ "/"
+ archiveName
+ "-"
+ version.getVersion()
+ "-"
+ archiveClassifier
+ ".zip");
} catch (URISyntaxException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
}
public void onOutput(long classId, long testId, TestOutputEvent outputEvent) {
boolean stdout = outputEvent.getDestination() == TestOutputEvent.Destination.StdOut;
mark(classId, testId, stdout);
output.writeBoolean(stdout);
output.writeLong(classId);
output.writeLong(testId);
byte[] bytes;
try {
bytes = outputEvent.getMessage().getBytes(messageStorageCharset.name());
} catch (UnsupportedEncodingException e) {
throw UncheckedException.throwAsUncheckedException(e);
}
output.writeInt(bytes.length);
output.writeBytes(bytes);
}