public Kernel getKernel() { KernelController controller = (KernelController) getController(); if (controller == null) throw new IllegalStateException("Context is not installed in controller"); return controller.getKernel(); }
public void start() { // Bootstrap the repository if (repository == null && controller instanceof KernelController) { KernelController kernelController = (KernelController) controller; repository = kernelController.getKernel().getMetaDataRepository().getMetaDataRepository(); } }
/** * Remove any previously added metadata * * @param context the context */ private void removeMetaData(KernelControllerContext context) { try { KernelController controller = (KernelController)context.getController(); KernelMetaDataRepository repository = controller.getKernel().getMetaDataRepository(); repository.removeMetaData(context); } catch (Throwable ignored) { log.warn("Unexpected error removing metadata: ", ignored); } }
public ReflectProvider create(DeploymentUnit unit) { DeploymentUnit top = unit.getTopLevel(); ControllerContext context = top.getAttachment(ControllerContext.class); if (context == null) throw new IllegalArgumentException("Not a kernel bound deployment unit: " + unit); Controller controller = context.getController(); if (controller instanceof KernelController == false) throw new IllegalArgumentException("Not a kernel controller: " + controller); KernelController kc = (KernelController) controller; Kernel kernel = kc.getKernel(); KernelConfigurator configurator = kernel.getConfigurator(); return new ConfiguratorReflectProvider(configurator); } }
@Override public <T> AnnotatedType<T> decorateAnnotatedType(AnnotatedType<T> delegate, KernelControllerContext context) { KernelController controller = (KernelController)context.getController(); Kernel kernel = controller.getKernel(); KernelMetaDataRepository repository = kernel.getMetaDataRepository(); MetaData metaData = repository.getMetaData(context); return decorateAnnotatedType(delegate, metaData); } }
@Override protected MetaDataRetrieval createMetaDataRetrieval(ControllerContext context, List<MetaDataRetrieval> retrievals) { Controller controller = context.getController(); if (controller instanceof KernelController) { KernelController kernelController = (KernelController) controller; MetaDataRetrieval result = kernelController.getKernel().getMetaDataRepository().createMetaDataRetrieval(context, retrievals); if (result != null) return result; } return super.createMetaDataRetrieval(context, retrievals); } }
protected void uninstallActionInternal(KernelControllerContext context) { KernelController controller = (KernelController) context.getController(); Kernel kernel = controller.getKernel(); org.jboss.kernel.spi.registry.KernelRegistry registry = kernel.getRegistry(); Object name = context.getName(); try { controller.removeSupplies(context); } catch (Throwable t) { log.warn("Ignoring removing supplies at uninstall " + name, t); } try { registry.unregisterEntry(name); } catch (Throwable t) { log.warn("Ignoring unregistered entry at uninstall " + name, t); } }
protected ClassInfo getClassInfo(KernelControllerContext context) throws Throwable { if (bean != null) { KernelController controller = (KernelController) context.getController(); ControllerContext beanContext = controller.getContext(bean, ControllerState.INSTANTIATED); if (beanContext != null) { KernelConfigurator configurator = controller.getKernel().getConfigurator(); Object target = beanContext.getTarget(); return configurator.getClassInfo(target.getClass()); } else { throw new IllegalArgumentException("Cannot determine install bean class: " + this); } } return super.getClassInfo(context); }
protected void uninstallAction(ControllerContext context) { ScopeKey scopeKey = getScopeKey(context); if (scopeKey != null) { Controller controller = context.getController(); if (controller instanceof KernelController == false) throw new IllegalArgumentException("Can only handle kernel controller: " + controller); KernelController kernelController = (KernelController)controller; KernelMetaDataRepository repository = kernelController.getKernel().getMetaDataRepository(); // find scoped controller MutableMetaDataRepository mmdr = repository.getMetaDataRepository(); ScopeHierarchyBuilder.cleanControllerHierarchy(mmdr, scopeKey, context); } } }
@SuppressWarnings("unchecked") protected void installActionInternal(KernelControllerContext context) throws Throwable { BeanInfo info = context.getBeanInfo(); if (info != null) { KernelController controller = (KernelController)context.getController(); KernelConfig config = controller.getKernel().getConfig(); DependencyBuilder dependencyBuilder = config.getDependencyBuilder(); KernelMetaDataRepository repository = controller.getKernel().getMetaDataRepository(); MetaData md = repository.getMetaData(context); // add custom dependencies (e.g. AOP layer). List<DependencyBuilderListItem> dependencies = dependencyBuilder.getDependencies(info, md); if (log.isTraceEnabled()) log.trace("Extra dependencies for " + context.getName() + " " + dependencies); if (dependencies != null && dependencies.isEmpty() == false) { for (DependencyBuilderListItem dependencyItem : dependencies) { dependencyItem.addDependency(context); } } // handle custom annotations applyAnnotations(context); } }
protected void installAction(ControllerContext context) throws Throwable { ScopeKey scopeKey = getScopeKey(context); if (scopeKey != null) { Controller controller = context.getController(); if (controller instanceof KernelController == false) throw new IllegalArgumentException("Can only handle kernel controller: " + controller); KernelController kernelController = (KernelController)controller; KernelMetaDataRepository repository = kernelController.getKernel().getMetaDataRepository(); MutableMetaDataRepository mmdr = repository.getMetaDataRepository(); MetaDataRetrieval mdr = mmdr.getMetaDataRetrieval(scopeKey); if (mdr == null) throw new IllegalArgumentException("No metadata retrieval for scope: " + scopeKey); MetaDataItem<ScopedKernelController> controllerItem = mdr.retrieveMetaData(ScopedKernelController.class); if (controllerItem == null) throw new IllegalArgumentException("Scoped controller should exist: " + scopeKey); ScopedKernelController scopedController = controllerItem.getValue(); scopedController.addScopedControllerContext(context); } }
protected void removeScoping(KernelControllerContext context) throws Throwable { ScopeKey scopeKey = context.getScopeInfo().getInstallScope(); if (scopeKey != null) { KernelController controller = (KernelController)context.getController(); KernelMetaDataRepository repository = controller.getKernel().getMetaDataRepository(); // find scoped controller MutableMetaDataRepository mmdr = repository.getMetaDataRepository(); ScopeHierarchyBuilder.cleanControllerHierarchy(mmdr, scopeKey, context); } }
public void initialVisit(MetaDataVisitor vistor) { if (beanName == null) throw new IllegalArgumentException("Null bean name."); KernelController controller = (KernelController)vistor.getControllerContext().getController(); Kernel kernel = controller.getKernel(); AbstractConstructorMetaData constructor = new AbstractConstructorMetaData(); constructor.setFactoryClass(factoryClassName); constructor.setFactoryMethod("getProxy"); List<ParameterMetaData> parameters = new ArrayList<ParameterMetaData>(); parameters.add(new AbstractParameterMetaData(kernel)); parameters.add(new AbstractParameterMetaData(beanName)); parameters.add(new AbstractParameterMetaData(Boolean.TYPE.getName(), exposeClass)); parameters.add(new AbstractParameterMetaData(new AbstractValueMetaData(interfaces))); constructor.setParameters(parameters); setConstructor(constructor); vistor.addDependency(new AbstractDependencyItem(getName(), beanName, ControllerState.INSTANTIATED, ControllerState.DESCRIBED)); super.initialVisit(vistor); }
protected void applyScoping(KernelControllerContext context) throws Throwable { KernelController controller = (KernelController)context.getController(); KernelMetaDataRepository repository = controller.getKernel().getMetaDataRepository(); ScopeKey scopeKey = getInstallScopeKey(context, repository); if (scopeKey != null) { scopeKey.freeze(); context.getScopeInfo().setInstallScope(scopeKey); if (controller instanceof AbstractKernelController == false) throw new IllegalArgumentException("Can only handle AbstractKernelController: " + controller); MutableMetaDataRepository mmdr = repository.getMetaDataRepository(); AbstractController abstractController = ScopeHierarchyBuilder.buildControllerHierarchy((AbstractKernelController)controller, mmdr, scopeKey); if (abstractController instanceof ScopedKernelController == false) throw new IllegalArgumentException("Should be ScopedKernelController instance: " + abstractController); ScopedKernelController scopedController = (ScopedKernelController)abstractController; scopedController.addScopedControllerContext(context); } }
/** * Check if the bean has the WeldEnabled annotation * * @param context the kernel controller context * @param type the annotated type * @return true if bean has web beans annotations */ private boolean hasWeldEnabledAnnotation(KernelControllerContext context, AnnotatedType<?> type) { if (type != null) return type.getAnnotation(WeldEnabled.class) != null; KernelController controller = (KernelController)context.getController(); Kernel kernel = controller.getKernel(); KernelMetaDataRepository repository = kernel.getMetaDataRepository(); MetaData metaData = repository.getMetaData(context); return metaData.isAnnotationPresent(WeldEnabled.class); }
ClassLoader cl = Configurator.getClassLoader(context.getBeanMetaData()); KernelController controller = (KernelController) context.getController(); KernelConfigurator configurator = controller.getKernel().getConfigurator(); return applyCollectionOrMapCheck(configurator.getClassInfo(type, cl));
public Object getValue(TypeInfo info, ClassLoader cl) throws Throwable { ControllerState state = dependentState; if (state == null) state = ControllerState.INSTALLED; KernelController controller = (KernelController)context.getController(); ControllerContext lookup = controller.getContext(getUnderlyingValue(), state); if (lookup == null) throw new Error("Should not be here - dependency failed - " + this); if (lookup instanceof InvokeDispatchContext == false) throw new IllegalArgumentException("Underlying context is not InvokeDispatchContext: " + context); Kernel kernel = controller.getKernel(); KernelConfigurator configurator = kernel.getConfigurator(); Object result = InvokeDispatchHelper.invoke( configurator, lookup.getTarget(), (InvokeDispatchContext)lookup, getMethod(), getParameters() ); if (result == null) result = defaultValue; return info != null ? info.convertValue(result) : result; }
protected void installActionInternal(KernelControllerContext context) throws Throwable { KernelController controller = (KernelController) context.getController(); Kernel kernel = controller.getKernel(); org.jboss.kernel.spi.registry.KernelRegistry registry = kernel.getRegistry(); BeanMetaData metaData = context.getBeanMetaData(); Object name = metaData.getName(); registry.registerEntry(name, context); try { controller.addSupplies(context); } catch (Throwable t) { try { registry.unregisterEntry(name); } catch (Throwable x) { log.warn("Ignoring error reversing install, throwing original error " + name, x); } throw t; } }
Kernel kernel = controller.getKernel(); KernelConfigurator configurator = kernel.getConfigurator();
protected void installActionInternal(KernelControllerContext context) throws Throwable Kernel kernel = controller.getKernel(); KernelConfigurator configurator = kernel.getConfigurator(); context.setBeanInfo(info); KernelMetaDataRepository repository = controller.getKernel().getMetaDataRepository(); ClassLoader oldCL = SecurityActions.setContextClassLoader(context); try