Refine search
@Override @SuppressWarnings("unchecked") public <T> List<ServiceHolder<T>> getAllServiceHolders(Class<T> contract, Annotation... qualifiers) { return getServiceLocator().getAllServiceHandles(contract, qualifiers).stream() .map(sh -> new ServiceHolderImpl<>( sh.getService(), (Class<T>) sh.getActiveDescriptor().getImplementationClass(), sh.getActiveDescriptor().getContractTypes(), sh.getActiveDescriptor().getRanking())) .collect(Collectors.toList()); }
/** * This method will add the ability to use the {@link Immediate} scope to * the given locator. If the locator already has a {@link Context} implementation * that handles the {@link Immediate} scope this method does nothing. The Immediate * scope will start in the suspended state, allowing the caller to customize the * Immediate scope using the {@link ImmediateController} * <p> * * @param locator The non-null locator to enable the Immediate scope on * @return The ImmediateController that can be used to further configure * the Immediate scope * @throws MultiException if there were errors when committing the service */ public static ImmediateController enableImmediateScopeSuspended(ServiceLocator locator) { List<ServiceHandle<?>> immediateContexts = locator.getAllServiceHandles((new TypeLiteral<Context<Immediate>>() {}).getType()); for (ServiceHandle<?> immediateContext : immediateContexts) { ActiveDescriptor<?> contextDescriptor = immediateContext.getActiveDescriptor(); if (contextDescriptor.getLocatorId() == locator.getLocatorId()) { return locator.getService(ImmediateController.class); } } addClasses(locator, ImmediateContext.class, ImmediateHelper.class); return locator.getService(ImmediateController.class); }
@Override public Object create(Context ic) throws NamingException { ActiveDescriptor<?> descriptor = habitat.getBestDescriptor( BuilderHelper.createContractFilter("javax.transaction.UserTransaction")); if (descriptor == null) return null; return habitat.getServiceHandle(descriptor).getService(); } }, false);
public void lookupConnectorServiceAndEnsureNotActive() { SimpleConnector sc = habitat.getService(SimpleConnector.class); System.out.println("[lookupConnectorService] Got sc : " + sc.getClass().getName()); ServiceHandle inhabitant1 = habitat.getServiceHandle(ConfigInjector.class, "simple-connector"); assert(sc != null && !inhabitant1.isActive()); }
errorHandlers = locator.getAllServices(ImmediateErrorHandler.class); handle.destroy(); locator.getServiceHandle(ad).getService();
@Override public Injectee apply(CacheKey cacheKey) { Injectee injectee = cacheKey.getInjectee(); if (injectee.getParent() != null) { if (Field.class.isAssignableFrom(injectee.getParent().getClass())) { Field f = (Field) injectee.getParent(); if (foreignRequestScopedComponents.get().contains(f.getDeclaringClass())) { final Class<?> clazz = f.getType(); if (serviceLocator.getServiceHandle(clazz).getActiveDescriptor().getScopeAnnotation() == RequestScoped.class) { final AbstractActiveDescriptor<Object> descriptor = BuilderHelper.activeLink(clazz) .to(clazz) .in(RequestScoped.class) .build(); return new DescriptorOverridingInjectee(injectee, descriptor); } } } } return injectee; } });
if ((injectee.getInjecteeClass() != null) && ( injectee.getInjecteeClass().getName().equals( handle.getActiveDescriptor().getImplementation()))) { jitResolver = handle.getService(); if (jitResolver.getActiveDescriptor().getScope() == null || PerLookup.class.getName().equals(jitResolver.getActiveDescriptor().getScope())) { jitResolver.destroy();
@Override public Object getInstance(ForeignDescriptor foreignDescriptor) { return getServiceLocator().getServiceHandle((ActiveDescriptor<?>) foreignDescriptor.get()).getService(); }
public Class getClassForFullName(String configBeanClassName) { ActiveDescriptor<?> descriptor = serviceLocator.getBestDescriptor(BuilderHelper.createContractFilter(configBeanClassName)); if (descriptor != null) { if (!descriptor.isReified()) { descriptor = serviceLocator.reifyDescriptor(descriptor); } return getClassFromDescriptor(descriptor); } else { descriptor = serviceLocator.getBestDescriptor(BuilderHelper.createContractFilter(configBeanClassName + "Injector")); if (!descriptor.isReified()) { descriptor = serviceLocator.reifyDescriptor(descriptor); } ConfigInjector injector = (ConfigInjector) serviceLocator.getServiceHandle(descriptor).getService(); return getClassFromInjector(injector); } }
public void onShutdown() { // Cleanup if TM was loaded if (tm == null) { ServiceHandle<JavaEETransactionManager> inhabitant = habitat.getServiceHandle(JavaEETransactionManager.class); if (inhabitant != null && inhabitant.isActive()) { tm = inhabitant.getService(); } } if (tm != null) { _logger.fine("ON TM SHUTDOWN STARTED"); tm.shutdown(); _logger.fine("ON TM SHUTDOWN FINISHED"); } }
@SuppressWarnings("unchecked") private void reupClassAnalyzers() { List<ServiceHandle<?>> allAnalyzers = protectedGetAllServiceHandles(ClassAnalyzer.class); synchronized (classAnalyzerLock) { classAnalyzers.clear(); for (ServiceHandle<?> handle : allAnalyzers) { ActiveDescriptor<?> descriptor = handle.getActiveDescriptor(); String name = descriptor.getName(); if (name == null) continue; ClassAnalyzer created = ((ServiceHandle<ClassAnalyzer>) handle).getService(); if (created == null) continue; classAnalyzers.put(name, created); } } }
public static List<ConfigurationDeploymentDescriptorFile> getConfigurationDeploymentDescriptorFiles(ServiceLocator habitat, String containerType) { List<ConfigurationDeploymentDescriptorFile> confDDFiles = new ArrayList<ConfigurationDeploymentDescriptorFile>(); for (ServiceHandle<?> serviceHandle : habitat.getAllServiceHandles(ConfigurationDeploymentDescriptorFileFor.class)) { ActiveDescriptor<?> descriptor = serviceHandle.getActiveDescriptor(); String indexedType = descriptor.getMetadata().get(ConfigurationDeploymentDescriptorFileFor.DESCRIPTOR_FOR).get(0); if(indexedType.equals(containerType)) { ConfigurationDeploymentDescriptorFile confDD = (ConfigurationDeploymentDescriptorFile) serviceHandle.getService(); confDDFiles.add(confDD); } } return confDDFiles; }
private void dumpInhabitantsImplementingContractPattern(String pattern, StringBuilder sb) { sb.append("\n*********** List of all services for contract named like " + contract + " **************\n"); List<ActiveDescriptor<?>> allDescriptors = serviceLocator.getDescriptors(BuilderHelper.allFilter()); HashSet<String> allContracts = new HashSet<String>(); for (ActiveDescriptor<?> aDescriptor : allDescriptors) { allContracts.addAll(aDescriptor.getAdvertisedContracts()); } Iterator<String> it = allContracts.iterator(); while (it.hasNext()) { String cn = it.next(); if (cn.toLowerCase(Locale.ENGLISH).indexOf(pattern.toLowerCase(Locale.ENGLISH)) < 0) continue; sb.append("\n-----------------------------\n"); for ( ActiveDescriptor<?> descriptor : serviceLocator.getDescriptors(BuilderHelper.createContractFilter(cn))) { sb.append("Inhabitant-Metadata: " + descriptor.getMetadata()); sb.append("\n"); boolean isStarted = Boolean.parseBoolean(started); if (isStarted) { ServiceHandle<?> handle = serviceLocator.getServiceHandle(descriptor); sb.append((handle.isActive() ? " started" : " not started")); } } } }
private void reupInjectionResolvers() { HashMap<Class<? extends Annotation>, InjectionResolver<?>> newResolvers = new HashMap<Class<? extends Annotation>, InjectionResolver<?>>(); Filter injectionResolverFilter = BuilderHelper.createContractFilter( InjectionResolver.class.getName()); List<ActiveDescriptor<?>> resolverDescriptors = protectedGetDescriptors(injectionResolverFilter); for (ActiveDescriptor<?> resolverDescriptor : resolverDescriptors) { Class<? extends Annotation> iResolve = Utilities.getInjectionResolverType(resolverDescriptor); if (iResolve != null && !newResolvers.containsKey(iResolve)) { InjectionResolver<?> resolver = (InjectionResolver<?>) getServiceHandle(resolverDescriptor).getService(); newResolvers.put(iResolve, resolver); } } synchronized (allResolvers) { allResolvers.clear(); allResolvers.putAll(newResolvers); } injecteeToResolverCache.clear(); }
private void callAllConfigurationListeners(List<ServiceHandle<?>> allListeners) { if (allListeners == null) return; for (ServiceHandle<?> listener : allListeners) { ActiveDescriptor<?> listenerDescriptor = listener.getActiveDescriptor(); if (listenerDescriptor.getLocatorId() != id) continue; try { ((DynamicConfigurationListener) listener.getService()).configurationChanged(); } catch (Throwable th) { // Intentionally ignore } } }
/** * For when the server shuts down */ @Override public void shutdown() { List<ImmediateErrorHandler> errorHandlers = locator.getAllServices(ImmediateErrorHandler.class); synchronized (this) { for (Map.Entry<ActiveDescriptor<?>, HandleAndService> entry : new HashSet<Map.Entry<ActiveDescriptor<?>, HandleAndService>>(currentImmediateServices.entrySet())) { HandleAndService has = entry.getValue(); ServiceHandle<?> handle = has.getHandle(); if (handle != null) { handle.destroy(); } else { destroyOne(entry.getKey(), errorHandlers); } } } }
public void lookupInjectorByName() { ServiceHandle inhabitant1 = habitat.getServiceHandle(ConfigInjector.class, "simple-connector"); ServiceHandle inhabitant2 = habitat.getServiceHandle(ConfigInjector.class, "ejb-container-availability"); assert(inhabitant1 != null && inhabitant2 != null && inhabitant1.getActiveDescriptor().getImplementation().equals(SimpleConnectorInjector.class.getName()) && inhabitant2.getActiveDescriptor().getImplementation().equals(EjbContainerAvailabilityInjector.class.getName())); }
@SuppressWarnings("unchecked") public Archivist getArchivist(String archiveType) { ActiveDescriptor<Archivist> best = (ActiveDescriptor<Archivist>) habitat.getBestDescriptor(new ArchivistFilter(archiveType, ARCHIVE_TYPE, Archivist.class)); if (best == null) return null; return habitat.getServiceHandle(best).getService(); }
@SuppressWarnings("unused") @PostConstruct private void postConstruct() { fighterFishHandles = locator.getAllServiceHandles( BuilderHelper.createContractFilter(FIGHTERFISH_START_SERVICE)); for (ServiceHandle<?> fighterFishHandle : fighterFishHandles) { fighterFishHandle.getService(); } }
@Override public Object provide() { return handle.getService(); }