org.codehaus.groovy.transform.TimedInterruptibleASTTransformation.groovy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of groovy Show documentation
Show all versions of groovy Show documentation
Groovy: A powerful, dynamic language for the JVM
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.codehaus.groovy.transform
import groovy.transform.TimedInterrupt
import org.codehaus.groovy.ast.ASTNode
import org.codehaus.groovy.ast.AnnotatedNode
import org.codehaus.groovy.ast.AnnotationNode
import org.codehaus.groovy.ast.ClassCodeVisitorSupport
import org.codehaus.groovy.ast.ClassHelper
import org.codehaus.groovy.ast.ClassNode
import org.codehaus.groovy.ast.FieldNode
import org.codehaus.groovy.ast.MethodNode
import org.codehaus.groovy.ast.PropertyNode
import org.codehaus.groovy.ast.expr.ClosureExpression
import org.codehaus.groovy.ast.expr.ConstantExpression
import org.codehaus.groovy.ast.expr.DeclarationExpression
import org.codehaus.groovy.ast.expr.Expression
import org.codehaus.groovy.ast.stmt.BlockStatement
import org.codehaus.groovy.ast.stmt.DoWhileStatement
import org.codehaus.groovy.ast.stmt.ForStatement
import org.codehaus.groovy.ast.stmt.WhileStatement
import org.codehaus.groovy.control.CompilePhase
import org.codehaus.groovy.control.SourceUnit
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeoutException
import static org.codehaus.groovy.ast.ClassHelper.make
import static org.codehaus.groovy.ast.tools.GeneralUtils.args
import static org.codehaus.groovy.ast.tools.GeneralUtils.callX
import static org.codehaus.groovy.ast.tools.GeneralUtils.classX
import static org.codehaus.groovy.ast.tools.GeneralUtils.constX
import static org.codehaus.groovy.ast.tools.GeneralUtils.ctorX
import static org.codehaus.groovy.ast.tools.GeneralUtils.ifS
import static org.codehaus.groovy.ast.tools.GeneralUtils.ltX
import static org.codehaus.groovy.ast.tools.GeneralUtils.plusX
import static org.codehaus.groovy.ast.tools.GeneralUtils.propX
import static org.codehaus.groovy.ast.tools.GeneralUtils.throwS
import static org.codehaus.groovy.ast.tools.GeneralUtils.varX
/**
* Allows "interrupt-safe" executions of scripts by adding timer expiration
* checks on loops (for, while, do) and first statement of closures. By default,
* also adds an interrupt check statement on the beginning of method calls.
*
* @author Cedric Champeau
* @author Hamlet D'Arcy
* @author Paul King
* @see groovy.transform.ThreadInterrupt
* @since 1.8.0
*/
@GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION)
public class TimedInterruptibleASTTransformation extends AbstractASTTransformation {
private static final ClassNode MY_TYPE = make(TimedInterrupt)
private static final String CHECK_METHOD_START_MEMBER = 'checkOnMethodStart'
private static final String APPLY_TO_ALL_CLASSES = 'applyToAllClasses'
private static final String APPLY_TO_ALL_MEMBERS = 'applyToAllMembers'
private static final String THROWN_EXCEPTION_TYPE = "thrown"
public void visit(ASTNode[] nodes, SourceUnit source) {
init(nodes, source);
AnnotationNode node = nodes[0]
AnnotatedNode annotatedNode = nodes[1]
if (!MY_TYPE.equals(node.getClassNode())) {
internalError("Transformation called from wrong annotation: $node.classNode.name")
}
def checkOnMethodStart = getConstantAnnotationParameter(node, CHECK_METHOD_START_MEMBER, Boolean.TYPE, true)
def applyToAllMembers = getConstantAnnotationParameter(node, APPLY_TO_ALL_MEMBERS, Boolean.TYPE, true)
def applyToAllClasses = applyToAllMembers ? getConstantAnnotationParameter(node, APPLY_TO_ALL_CLASSES, Boolean.TYPE, true) : false
def maximum = getConstantAnnotationParameter(node, 'value', Long.TYPE, Long.MAX_VALUE)
def thrown = AbstractInterruptibleASTTransformation.getClassAnnotationParameter(node, THROWN_EXCEPTION_TYPE, make(TimeoutException))
Expression unit = node.getMember('unit') ?: propX(classX(TimeUnit), "SECONDS")
// should be limited to the current SourceUnit or propagated to the whole CompilationUnit
// DO NOT inline visitor creation in code below. It has state that must not persist between calls
if (applyToAllClasses) {
// guard every class and method defined in this script
source.getAST()?.classes?.each { ClassNode it ->
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitClass(it)
}
} else if (annotatedNode instanceof ClassNode) {
// only guard this particular class
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitClass annotatedNode
} else if (!applyToAllMembers && annotatedNode instanceof MethodNode) {
// only guard this particular method (plus initCode for class)
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitMethod annotatedNode
visitor.visitClass annotatedNode.declaringClass
} else if (!applyToAllMembers && annotatedNode instanceof FieldNode) {
// only guard this particular field (plus initCode for class)
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitField annotatedNode
visitor.visitClass annotatedNode.declaringClass
} else if (!applyToAllMembers && annotatedNode instanceof DeclarationExpression) {
// only guard this particular declaration (plus initCode for class)
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitDeclarationExpression annotatedNode
visitor.visitClass annotatedNode.declaringClass
} else {
// only guard the script class
source.getAST()?.classes?.each { ClassNode it ->
if (it.isScript()) {
def visitor = new TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, node.hashCode())
visitor.visitClass(it)
}
}
}
}
static def getConstantAnnotationParameter(AnnotationNode node, String parameterName, Class type, defaultValue) {
def member = node.getMember(parameterName)
if (member) {
if (member instanceof ConstantExpression) {
// TODO not sure this try offers value - testing Groovy annotation type handing - throw GroovyBugError or remove?
try {
return member.value.asType(type)
} catch (ignore) {
internalError("Expecting boolean value for ${parameterName} annotation parameter. Found $member")
}
} else {
internalError("Expecting boolean value for ${parameterName} annotation parameter. Found $member")
}
}
return defaultValue
}
private static void internalError(String message) {
throw new RuntimeException("Internal error: $message")
}
private static class TimedInterruptionVisitor extends ClassCodeVisitorSupport {
final private SourceUnit source
final private boolean checkOnMethodStart
final private boolean applyToAllClasses
final private boolean applyToAllMembers
private FieldNode expireTimeField = null
private FieldNode startTimeField = null
private final Expression unit
private final maximum
private final ClassNode thrown
private final String basename
TimedInterruptionVisitor(source, checkOnMethodStart, applyToAllClasses, applyToAllMembers, maximum, unit, thrown, hash) {
this.source = source
this.checkOnMethodStart = checkOnMethodStart
this.applyToAllClasses = applyToAllClasses
this.applyToAllMembers = applyToAllMembers
this.unit = unit
this.maximum = maximum
this.thrown = thrown
this.basename = 'timedInterrupt' + hash
}
/**
* @return Returns the interruption check statement.
*/
final createInterruptStatement() {
ifS(
ltX(
propX(varX("this"), basename + '$expireTime'),
callX(make(System), 'nanoTime')
),
throwS(
ctorX(thrown,
args(
plusX(
constX('Execution timed out after ' + maximum + ' units. Start time: '),
propX(varX("this"), basename + '$startTime'),
)
)
)
)
)
}
/**
* Takes a statement and wraps it into a block statement which first element is the interruption check statement.
* @param statement the statement to be wrapped
* @return a {@link BlockStatement block statement} which first element is for checking interruption, and the
* second one the statement to be wrapped.
*/
private wrapBlock(statement) {
def stmt = new BlockStatement();
stmt.addStatement(createInterruptStatement());
stmt.addStatement(statement);
stmt
}
@Override
void visitClass(ClassNode node) {
if (node.getDeclaredField(basename + '$expireTime')) {
return
}
expireTimeField = node.addField(basename + '$expireTime',
ACC_FINAL | ACC_PRIVATE,
ClassHelper.long_TYPE,
plusX(
callX(make(System), 'nanoTime'),
callX(
propX(classX(TimeUnit), 'NANOSECONDS'),
'convert',
args(constX(maximum, true), unit)
)
)
);
expireTimeField.synthetic = true
startTimeField = node.addField(basename + '$startTime',
ACC_FINAL | ACC_PRIVATE,
make(Date),
ctorX(make(Date))
)
startTimeField.synthetic = true
// force these fields to be initialized first
node.fields.remove(expireTimeField)
node.fields.remove(startTimeField)
node.fields.add(0, startTimeField)
node.fields.add(0, expireTimeField)
if (applyToAllMembers) {
super.visitClass node
}
}
@Override
void visitClosureExpression(ClosureExpression closureExpr) {
def code = closureExpr.code
if (code instanceof BlockStatement) {
code.statements.add(0, createInterruptStatement())
} else {
closureExpr.code = wrapBlock(code)
}
super.visitClosureExpression closureExpr
}
@Override
void visitField(FieldNode node) {
if (!node.isStatic() && !node.isSynthetic()) {
super.visitField node
}
}
@Override
void visitProperty(PropertyNode node) {
if (!node.isStatic() && !node.isSynthetic()) {
super.visitProperty node
}
}
/**
* Shortcut method which avoids duplicating code for every type of loop.
* Actually wraps the loopBlock of different types of loop statements.
*/
private visitLoop(loopStatement) {
def statement = loopStatement.loopBlock
loopStatement.loopBlock = wrapBlock(statement)
}
@Override
void visitForLoop(ForStatement forStatement) {
visitLoop(forStatement)
super.visitForLoop(forStatement)
}
@Override
void visitDoWhileLoop(final DoWhileStatement doWhileStatement) {
visitLoop(doWhileStatement)
super.visitDoWhileLoop(doWhileStatement)
}
@Override
void visitWhileLoop(final WhileStatement whileStatement) {
visitLoop(whileStatement)
super.visitWhileLoop(whileStatement)
}
@Override
void visitMethod(MethodNode node) {
if (checkOnMethodStart && !node.isSynthetic() && !node.isStatic() && !node.isAbstract()) {
def code = node.code
node.code = wrapBlock(code);
}
if (!node.isSynthetic() && !node.isStatic()) {
super.visitMethod(node)
}
}
protected SourceUnit getSourceUnit() {
return source;
}
}
}