public void removeInterceptorStack(String stackName) { Interceptor[] interceptors = stacks.remove(stackName); if (interceptors == null) { AdviceStack stack = AspectManager.instance().getAdviceStack(stackName); if (stack == null) throw new RuntimeException("Stack " + stackName + " not found."); return; } int interceptorsRemoved = 0; for (Interceptor interceptor: interceptors) { interceptorsRemoved += internalRemoveInterceptor(interceptor.getName()); } if (interceptorChainObserver != null) { this.interceptorChainObserver.instanceInterceptorsRemoved(this, interceptorsRemoved); } }
@Override public DomainDefinition getContainer(String name) { DomainDefinition container = null; if (parentFirst) { container = parent.getContainer(name); if (container != null) return container; } container = super.getContainer(name); if (container != null) return container; return parent.getContainer(name); }
public String getManagerFQN() { return parent.getManagerFQN() + name + "/"; }
public ClassPool getPoolForLoader(ClassLoader cl) { return AspectManager.instance().registerClassLoader(cl); }
private byte[] aspectTransform(String className, ClassLoader loader, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) { try { //Make sure that we use the correct classloader, in order to get the correct domain if it is a scoped loader return AspectManager.instance(loader).transform(loader, className, classBeingRedefined, protectionDomain, classfileBuffer); } catch (Exception e) { throw new RuntimeException(e); } } }
public static CtClass classToJavassist(Class<?> clazz) throws NotFoundException { ClassPool pool = AspectManager.instance().findClassPool(clazz); CtClass ct = pool.get(clazz.getName()); return ct; }
protected ConsumerContainer getConsumerContainer(int ejbIndex, JBossConsumerBeanMetaData beanMetaData) throws Exception { String containerName = getAspectDomain(ejbIndex, defaultConsumerDomain); DomainDefinition domain = AspectManager.instance().getContainer(containerName); if (domain == null) { throw new RuntimeException("Could not get container for bean class " + beanMetaData.getEjbClass() + " with bean name " + beanMetaData.getEjbName() + " because no container configured with name '" + containerName + "'"); } return new ConsumerContainer(ejbNames.get(ejbIndex), (Domain) domain.getManager(), di.getClassLoader(), className, ctxProperties, deployment, beanMetaData); }
private Field[] interceptGetDeclaredFields(Class<?> clazz) { ClassAdvisor advisor = AspectManager.instance().getAdvisorIfAdvised(clazz); if (advisor == null) { return getDeclaredFields(clazz); } else { Field[] advisedFields = advisor.getAdvisedFields(); ArrayList<Field> fields = new ArrayList<Field>(advisedFields.length); for (int i = 0; i < advisedFields.length; i++) { Field f = advisedFields[i]; if (clazz.equals(f.getDeclaringClass())) { fields.add(f); } } return fields.toArray(new Field[fields.size()]); } }
private void initClassContainer() { if (Advised.class.isAssignableFrom(key.getClazz())) { classAdvisor = AspectManager.instance().getAdvisor(key.getClazz()); } else { classAdvisor = getCachedContainer(manager); if (classAdvisor == null) { classAdvisor = createAndCacheContainer(); } } }
private static Interceptor[] finalizeChain(ArrayList<Interceptor> newinterceptors) { Interceptor[] interceptors = (newinterceptors.size() > 0) ? newinterceptors.toArray(new Interceptor[newinterceptors.size()]) : null; if (interceptors != null) { if (interceptors[0] instanceof GeneratedAdvisorInterceptor) { } interceptors = PrecedenceSorter.applyPrecedence(interceptors, AspectManager.instance()); } return interceptors; }
@Override public AdviceStack getAdviceStack(String name) { AdviceStack factory = null; if (parentFirst) { factory = parent.getAdviceStack(name); if (factory != null) return factory; } factory = super.getAdviceStack(name); if (factory != null) return factory; return parent.getAdviceStack(name); }
public static void premain(String agentArgs, Instrumentation inst) { instrumentation = inst; StandaloneClassPoolFactory factory = new StandaloneClassPoolFactory(); AspectManager.setClassPoolFactory(factory); // necessary for configuration AspectManager.instance(); if (agentArgs != null && agentArgs.indexOf("-hotSwap") != -1) { // setting dynamic aop strategy: hot swap classes through InstrumentationAdapter DynamicAOPStrategy strategy = new HotSwapStrategy(new InstrumentationAdapter(inst)); AspectManager.instance().setDynamicAOPStrategy(strategy); AspectManager.setPrune(false); // no prune } inst.addTransformer(new AOPTransformer()); } }
manager = new AspectManager(); manager.setExclude(list); manager.setInclude(list); manager.setIgnore(list); manager.setIncludedInvisibleAnnotations(list);
aspectManager = AspectManager.instance(superPool.getClassLoader()); if (manager.isNonAdvisableClassName(clazz.getName())) manager.attachMetaData(advisor, clazz, true); manager.applyInterfaceIntroductions(advisor, clazz); transformed = instrumentor.transform(clazz, advisor);
AdviceStack stack = getAdvisor().getManager().getAdviceStack("HomeCallbackStack"); Interceptor interceptors[]; if(stack == null) throw new IllegalStateException("EJBTHREE-1995: " + getAdvisor().getManager().getManagerFQN() + " does not define a HomeCallbackStack");
Advisor existing = AspectManager.instance().getAnyAdvisorIfAdvised(clazz); if (existing != null) manager.initialiseClassAdvisor(clazz, GeneratedClassAdvisor.this);
InterceptorFactory factory = manager.getInterceptorFactory(iname); if (factory == null) throw new RuntimeException("unable to resolve interceptor-ref: " + iname); interceptors.add(factory); AdviceStack stack = manager.getAdviceStack(name); if (stack == null) throw new Exception("there is no <stack> defined for name: " + name); interceptors.addAll(stack.getInterceptorFactories());
public Object visit(ASTCFlow node, Object data) { AspectManager manager = null; if (invocation.getAdvisor() == null) manager = AspectManager.instance(); else manager = invocation.getAdvisor().getManager(); CFlowStack cflow = manager.getCFlowStack(node.getPointcutName()); //Use the current advisor to guess the classloader ClassLoader cl = invocation.getAdvisor().getClassLoader(); if (cl == null) { //Fall back to context classloader if null cl = SecurityActions.getContextClassLoader(); } if (cflow != null) return new Boolean(cflow.matches(getStack(), cl)); DynamicCFlow dcflow = manager.getDynamicCFlow(node.getPointcutName(), cl); return new Boolean(dcflow.shouldExecute(invocation)); } }
public static boolean matchesTypedef(CtClass clazz, ClassExpression classExpr, Advisor advisor) { String original = classExpr.getOriginal(); String typedefName = original.substring("$typedef{".length(), original.lastIndexOf("}")); AspectManager manager = (advisor != null) ? advisor.getManager() : AspectManager.instance(); Typedef typedef = manager.getTypedef(typedefName); if (typedef == null) return false; return typedef.matches(advisor, clazz); }
public Object visit(ASTCall node, Object data) { try { if (!(node.getBehavior() instanceof ASTMethod)) return Boolean.FALSE; ASTMethod astMethod = (ASTMethod) node.getBehavior(); Advisor calledAdvisor = AspectManager.instance().getTempClassAdvisorIfNotExist(calledClass); MethodMatcher methodMatcher = new MethodMatcher(calledAdvisor, calledMethod, null); if (!(methodMatcher.matches(astMethod)).booleanValue()) return Boolean.FALSE; return Boolean.TRUE; } catch (Exception e) { throw new RuntimeException(e); //To change body of catch statement use Options | File Templates. } }