Class pointcut that intercepts a method call with field access - aop

Question

I am writing some aspects to make my gradle pugin development a little cleaner. In gradle, there is an interface, like this
interface Plugin {
def apply(Project project);
}
Applied to a plugin
class MyPlugin implements Plugin<Project> {
def apply(Project project) {
do stuff
}
}
Now, i want to be able to annotate this class like this
#OnlyAllowedOnRoot
class MyPlugin implements Plugin<Project> {
def apply(Project project) {
do stuff
}
}
and have a pointcut that fires when the 'apply' method is fired, and pick up the parameter. because the logic for the pointcut would be
if (project.rootProject.name != project.name) {
throw new GradleScriptExeption("This plugin can only be applied to root")
}
how would I do this? This example is the foundation for about a dozen other pointcuts i would want to write, but i really don't know where to start. I know i can annotate the apply method directly, but im worried about readability, which is mostly the reason why im doing this to begin with. I can if i have to, but id rather not. And because of the lifecycle of Gradle, it must be checked when the 'apply' method is called, it can't be checked at the instantiation.

Answer 1

Here is a complete example, but in Java, not in Groovy. It should not make any difference if you use Groovy, though. BTW, I did not want to add the Gradle API as a dependency to my project, so I just replicated the relevant parts of its API with the right package names and signatures. Not being a Gradle user myself, I implemented the root project property hierarchically as a direct parent, not as an absolute root. If Gradle does it differently, just adjust the condition in the aspect throwing the exception back to your own sample code.
Gradle API:
package org.gradle.api;
public class Project {
private String name;
private Project rootProject;
public Project(String name, Project rootProject) {
this.name = name;
this.rootProject = rootProject;
}
public String getName() {
return name;
}
public Project getRootProject() {
return rootProject;
}
#Override
public String toString() {
return "Project(name = " + name + ", rootProject = " + rootProject + ")";
}
}
package org.gradle.api;
public interface Plugin<T> {
void apply(T target);
}
package org.gradle.api;
public class GradleScriptExeption extends RuntimeException {
private static final long serialVersionUID = 1L;
public GradleScriptExeption(String message, Throwable cause) {
super(message, cause);
}
}
Marker annotation + plugins:
package de.scrum_master.app;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
class NormalPlugin implements Plugin<Project> {
public void apply(Project project) {}
}
package de.scrum_master.app;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Retention;
#Retention(RUNTIME)
public #interface OnlyAllowedOnRoot {}
package de.scrum_master.app;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
#OnlyAllowedOnRoot
class RootPlugin implements Plugin<Project> {
public void apply(Project project) {}
}
Driver application:
package de.scrum_master.app;
import org.gradle.api.Project;
public class Application {
public static void main(String[] args) {
Project rootProject = new Project("root", null);
Project childProject = new Project("child", rootProject);
Project grandChildProject = new Project("grandchild", childProject);
NormalPlugin normalPlugin = new NormalPlugin();
normalPlugin.apply(rootProject);
normalPlugin.apply(childProject);
normalPlugin.apply(grandChildProject);
RootPlugin rootPlugin = new RootPlugin();
rootPlugin.apply(rootProject);
rootPlugin.apply(childProject);
rootPlugin.apply(grandChildProject);
}
}
Aspect:
package de.scrum_master.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.gradle.api.GradleScriptExeption;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
#Aspect
public class GradlePluginAspect {
#Pointcut("execution(void apply(*)) && target(plugin) && args(project)")
private static void pluginExecution(Plugin plugin, Project project) {}
#Before("pluginExecution(plugin, project) && #target(de.scrum_master.app.OnlyAllowedOnRoot)")
public void illegalRootPlugin(JoinPoint thisJoinPoint, Plugin plugin, Project project) {
if (project.getRootProject() != null)
throw new GradleScriptExeption("Cannot apply " + plugin.getClass().getSimpleName() + " to non-root project " + project, null);
}
#Before("pluginExecution(plugin, project)")
public void logPluginApply(JoinPoint thisJoinPoint, Plugin plugin, Project project) {
System.out.println("Applying " + plugin.getClass().getSimpleName() + " to " + project);
}
}
Console log:
Applying NormalPlugin to Project(name = root, rootProject = null)
Applying NormalPlugin to Project(name = child, rootProject = Project(name = root, rootProject = null))
Applying NormalPlugin to Project(name = grandchild, rootProject = Project(name = child, rootProject = Project(name = root, rootProject = null)))
Applying RootPlugin to Project(name = root, rootProject = null)
Exception in thread "main" org.gradle.api.GradleScriptExeption: Cannot apply RootPlugin to non-root project Project(name = child, rootProject = Project(name = root, rootProject = null))
at de.scrum_master.aspect.GradlePluginAspect.illegalRootPlugin(GradlePluginAspect.aj:19)
at de.scrum_master.app.RootPlugin.apply(RootPlugin.java:8)
at de.scrum_master.app.Application.main(Application.java:18)