@Override public String toString() { return "Weld instance for deployment " + BeanManagerProxy.unwrap(rootBeanManager).getContextId(); }
static void containerInitialized(Container container, BeanManagerImpl rootBeanManager, WeldDeployment deployment) { containers.put(container, new WeldProvider.CdiImpl(container, new BeanManagerProxy(rootBeanManager), deployment)); }
@Override public void init(FilterConfig filterConfig) throws ServletException { if (beanManager == null) { beanManager = BeanManagerProxy.tryUnwrap(filterConfig.getServletContext().getAttribute(WELD_SERVLET_BEAN_MANAGER_KEY)); if (beanManager == null) { throw ProbeLogger.LOG.probeFilterUnableToOperate(BeanManagerImpl.class); } } ProbeExtension probeExtension = beanManager.getExtension(ProbeExtension.class); if (probeExtension == null) { throw ProbeLogger.LOG.probeFilterUnableToOperate(ProbeExtension.class); } probe = probeExtension.getProbe(); if (!probe.isInitialized()) { throw ProbeLogger.LOG.probeNotInitialized(); } jsonDataProvider = probeExtension.getJsonDataProvider(); WeldConfiguration configuration = beanManager.getServices().get(WeldConfiguration.class); if (configuration.getBooleanProperty(ConfigurationKey.PROBE_EMBED_INFO_SNIPPET)) { snippetBase = initSnippetBase(filterConfig.getServletContext()); } String exclude = configuration.getStringProperty(ConfigurationKey.PROBE_INVOCATION_MONITOR_EXCLUDE_TYPE); skipMonitoring = !exclude.isEmpty() && Pattern.compile(exclude).matcher(ProbeFilter.class.getName()).matches(); String allowRemoteAddress = configuration.getStringProperty(ConfigurationKey.PROBE_ALLOW_REMOTE_ADDRESS); allowRemoteAddressPattern = allowRemoteAddress.isEmpty() ? null : Pattern.compile(allowRemoteAddress); }
public void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event, BeanManager beanManager) { ProbeLogger.LOG.developmentModeEnabled(); final BeanManagerImpl manager = BeanManagerProxy.unwrap(beanManager); manager.addValidationFailureCallback(new BiConsumer<Exception, Environment>() { @Override public void accept(Exception exception, Environment environment) { // Note that eventual problems are ignored during callback invocation probe.init(manager); Reports.generateValidationReport(probe, exception, environment, manager); } }); event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(Monitored.class, beanManager), Monitored.class.getName()); event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(MonitoredComponent.class, beanManager), MonitoredComponent.class.getName()); event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(InvocationMonitor.class, beanManager), InvocationMonitor.class.getName()); WeldConfiguration configuration = manager.getServices().get(WeldConfiguration.class); String exclude = configuration.getStringProperty(ConfigurationKey.PROBE_INVOCATION_MONITOR_EXCLUDE_TYPE); this.invocationMonitorExcludePattern = exclude.isEmpty() ? null : Pattern.compile(exclude); this.jsonDataProvider = new DefaultJsonDataProvider(probe, manager); this.eventMonitorContainerLifecycleEvents = configuration.getBooleanProperty(ConfigurationKey.PROBE_EVENT_MONITOR_CONTAINER_LIFECYCLE_EVENTS); addContainerLifecycleEvent(event, null, beanManager); }
public void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager beanManager) { BeanManagerImpl weldManager = BeanManagerProxy.unwrap(beanManager); String exclude = weldManager.getServices().get(WeldConfiguration.class).getStringProperty(ConfigurationKey.PROBE_EVENT_MONITOR_EXCLUDE_TYPE); event.addObserverMethod(new ProbeObserver(weldManager, exclude.isEmpty() ? null : Pattern.compile(exclude), probe)); addContainerLifecycleEvent(event, null, beanManager); }
@Override public void contextInitialized(ServletContextEvent sce) { final ServletContext ctx = sce.getServletContext(); // First try to use the context id obtained from the servlet context (OSGi, Servlet containers, etc.) if (beanManager == null) { String contextId = ctx.getInitParameter(Container.CONTEXT_ID_KEY); if (contextId != null) { List<BeanManagerImpl> managers = new ArrayList<BeanManagerImpl>(Container.instance(contextId).beanDeploymentArchives().values()); Collections.sort(managers, BeanManagers.ID_COMPARATOR); beanManager = managers.get(0); } } // servlet containers may not be able to inject fields in a servlet listener if (beanManager == null) { beanManager = BeanManagerProxy.unwrap(CDI.current().getBeanManager()); } HttpContextActivationFilter filter = ServletUtils.getContextActivationFilter(beanManager, ctx); final boolean ignoreForwards = getBooleanInitParameter(ctx, InitParameters.CONTEXT_IGNORE_FORWARD, false); final boolean ignoreIncludes = getBooleanInitParameter(ctx, InitParameters.CONTEXT_IGNORE_INCLUDE, false); final boolean nestedInvocationGuard = getBooleanInitParameter(ctx, CONTEXT_IGNORE_GUARD_PARAMETER, true); final boolean lazyConversationContext = getBooleanInitParameter(ctx, CONVERSATION_CONTEXT_LAZY_PARAM, true); this.lifecycle = new HttpContextLifecycle(beanManager, filter, ignoreForwards, ignoreIncludes, lazyConversationContext, nestedInvocationGuard); if (Boolean.valueOf(ctx.getInitParameter(CONVERSATION_FILTER_REGISTERED))) { this.lifecycle.setConversationActivationEnabled(false); } this.lifecycle.contextInitialized(ctx); ctx.setAttribute(WeldInitialListener.class.getName(), this); }
@Override public InstanceHandle<T> createInstance() throws InstantiationException { Object manager = context.getAttribute(WeldServletLifecycle.BEAN_MANAGER_ATTRIBUTE_NAME); if (manager instanceof BeanManager) { UnmanagedInstance<T> instance = new Unmanaged<T>(BeanManagerProxy.unwrap((BeanManager) manager), clazz).newInstance(); instance.produce().inject().postConstruct(); return new WeldInstanceHandle<T>(instance); } else { // fallback return delegate.createInstance(); } }
@Override public void sessionDestroyed(HttpSessionEvent event) { final ServletContext ctx = event.getSession().getServletContext(); // First try to use the context id obtained from the servlet context (OSGi, Servlet containers, etc.) if (beanManager == null) { synchronized (this) { if (beanManager == null) { String contextId = ctx.getInitParameter(Container.CONTEXT_ID_KEY); if (contextId != null) { List<BeanManagerImpl> managers = new ArrayList<BeanManagerImpl>(Container.instance(contextId).beanDeploymentArchives().values()); Collections.sort(managers, BeanManagers.ID_COMPARATOR); beanManager = managers.get(0); } } // servlet containers may not be able to inject fields in a servlet listener if (beanManager == null) { beanManager = BeanManagerProxy.unwrap(CDI.current().getBeanManager()); } } } if (!getSessionContext().isActive()) { HttpSessionDestructionContext context = getHttpSessionDestructionContext(); context.associate(event.getSession()); context.activate(); } }
public void registerWeldSEContexts(@Observes AfterBeanDiscovery event, BeanManager manager) { if (ignoreEvent(event)) { return; } final String contextId = BeanManagerProxy.unwrap(manager).getContextId(); this.threadContext = new ThreadContext(contextId); event.addContext(threadContext); // Register WeldContainer as a singleton event.addBean(new WeldContainerBean(contextId)); }
@Override public Comparator<Handler<?>> getPriorityComparator() { return new PriorityComparator(BeanManagerProxy.unwrap(getBeanManager()).getServices().get(AnnotationApiAbstraction.class)); }
private BeanManagerImpl getBeanManager() { final BeanManager beanManager = this.beanManager; return beanManager == null ? null : BeanManagerProxy.unwrap(beanManager); }
private InjectionTarget getInjectionTarget(Class<?> clazz) { InjectionTarget<?> target = injectionTargets.get(clazz); if (target != null) { return target; } final BeanManagerImpl beanManager = BeanManagerProxy.unwrap(beanManagerSupplier.get()); Bean<?> bean = null; Set<Bean<?>> beans = new HashSet<>(beanManager.getBeans(clazz, Any.Literal.INSTANCE)); Iterator<Bean<?>> it = beans.iterator(); //we may have resolved some sub-classes //go through and remove them from the bean set while (it.hasNext()) { Bean<?> b = it.next(); if(b.getBeanClass() != clazz) { it.remove(); } } if(beans.size() == 1) { bean = beans.iterator().next(); } InjectionTarget<?> newTarget = InjectionTargets.createInjectionTarget(clazz, bean, beanManager, true); target = injectionTargets.putIfAbsent(clazz, newTarget); if (target == null) { return newTarget; } else { return target; } }
@Override public WeldInstance<Object> createInstance() { checkContainerState("createInstance()", ContainerState.VALIDATED); return delegate().createInstance(); }
@Override public <T> WeldCreationalContext<T> createCreationalContext(Contextual<T> contextual) { return delegate().createCreationalContext(contextual); }
@Override public Object getReference(Bean<?> bean, Type beanType, CreationalContext<?> ctx) { checkContainerState("getReference()", ContainerState.VALIDATED); return super.getReference(bean, beanType, ctx); }
public static BeanManagerImpl unwrap(BeanManager manager) { BeanManagerImpl instance = tryUnwrap(manager); if (instance == null) { throw new IllegalArgumentException("Unknown BeanManager " + manager); } return instance; }
@Override public <T> EjbDescriptor<T> getEjbDescriptor(String ejbName) { return delegate().getEjbDescriptor(ejbName); }