/** * Convenience method that tests if a class with the given FQN is present on the classpath. * * @param testClass * @return true if the class is present */ protected boolean testClassExists(final String testClass) { try { final boolean exists = testClass != null && testClass.length() > 0 && IOUtils.loadClass(null, testClass) != null; logger.debug(exists ? "Found {}" : "Not found {}", testClass); return exists; } catch (Exception ex) { return false; } }
@Override public void reportTypeAnnotation(Class<? extends Annotation> annotation, String className) { try { coreAnnotationsFound.set(true); handler.handleProcessor(loadClass(getClass(), className)); } catch (Exception e) { logger.warn("Error scanning @AtmosphereAnnotation", e); } } };
protected AtmosphereInterceptor newAInterceptor(Class<? extends AtmosphereInterceptor> a) { AtmosphereInterceptor ai = null; try { ai = newClassInstance(AtmosphereInterceptor.class, (Class<AtmosphereInterceptor>) IOUtils.loadClass(getClass(), a.getName())); logger.info("\t{} : {}", a.getName(), ai); } catch (Exception ex) { logger.warn("", ex); } return ai; }
private void initDefaultSerializer() { if (defaultSerializerClassName != null && !defaultSerializerClassName.isEmpty()) { try { @SuppressWarnings("unchecked") Class<Serializer> clazz = (Class<Serializer>) IOUtils.loadClass(Serializer.class, defaultSerializerClassName); if (Serializer.class.isAssignableFrom(clazz)) { defaultSerializerClass = clazz; } else { logger.error("Default Serializer class name does not implement Serializer interface"); defaultSerializerClassName = null; defaultSerializerClass = null; } } catch (Exception e) { logger.error("Unable to set default Serializer", e); defaultSerializerClassName = null; defaultSerializerClass = null; } } else { defaultSerializerClassName = null; defaultSerializerClass = null; } }
private static void fallbackToManualAnnotatedClasses(Class<?> mainClass, AtmosphereFramework f, AnnotationHandler handler) { logger.warn("Unable to detect annotations. Application may fail to deploy."); f.annotationScanned(true); for (Class a : coreAnnotations) { try { handler.handleProcessor(loadClass(mainClass, a.getName())); } catch (Exception e) { logger.trace("", e); } } }
public void initEndpointMapper() { String s = servletConfig.getInitParameter(ApplicationConfig.ENDPOINT_MAPPER); if (s != null) { try { endpointMapper = newClassInstance(EndpointMapper.class, (Class<EndpointMapper>) IOUtils.loadClass(this.getClass(), s)); logger.info("Installed EndpointMapper {} ", s); } catch (Exception ex) { logger.error("Cannot load the EndpointMapper {}", s, ex); } } endpointMapper.configure(config); }
protected void loadMetaService() { try { Map<String, MetaServiceAction> config = (Map<String, MetaServiceAction>) servletConfig.getServletContext().getAttribute(AtmosphereFramework.MetaServiceAction.class.getName()); if (config == null) { config = IOUtils.readServiceFile(metaServicePath + AtmosphereFramework.class.getName()); } for (final Map.Entry<String, MetaServiceAction> action : config.entrySet()) { final Class c = IOUtils.loadClass(AtmosphereFramework.class, action.getKey()); action.getValue().apply(this, c); } } catch (Exception ex) { logger.error("", ex); } }
@Override public void reportTypeAnnotation(Class<? extends Annotation> annotation, String className) { try { final Class<?> discoveredClass = loadClass(getClass(), className); handler.handleAnnotation(config.framework(), annotation, discoveredClass); } catch (Exception e) { logger.warn("Could not load discovered class", e); } }
protected void configureWebDotXmlAtmosphereHandler(ServletConfig sc) { String s = sc.getInitParameter(ATMOSPHERE_HANDLER); if (s != null) { try { String mapping = sc.getInitParameter(ATMOSPHERE_HANDLER_MAPPING); if (mapping == null) { mapping = Broadcaster.ROOT_MASTER; } addAtmosphereHandler(mapping, newClassInstance(AtmosphereHandler.class, (Class<AtmosphereHandler>) IOUtils.loadClass(getClass(), s))); } catch (Exception ex) { logger.warn("Unable to load WebSocketHandle instance", ex); } } }
protected void configureObjectFactory() { String s = config.getInitParameter(ApplicationConfig.OBJECT_FACTORY); if (s != null) { try { AtmosphereObjectFactory aci = (AtmosphereObjectFactory) IOUtils.loadClass(getClass(), s).newInstance(); if (aci != null) { logger.debug("Found ObjectFactory {}", aci.getClass().getName()); objectFactory(aci); } } catch (Exception ex) { logger.warn("Unable to load AtmosphereClassInstantiator instance", ex); } } if (!DefaultAtmosphereObjectFactory.class.isAssignableFrom(objectFactory.getClass())) { logger.trace("ObjectFactory already set to {}", objectFactory); return; } }
public static AtmosphereFramework newAtmosphereFramework(ServletContext sc, boolean isFilter, boolean autoDetectHandlers) { String metaServicePath = sc.getInitParameter(META_SERVICE_PATH) == null ? META_SERVICE : sc.getInitParameter(META_SERVICE_PATH); try { final Map<String, AtmosphereFramework.MetaServiceAction> config = IOUtils.readServiceFile(metaServicePath + AtmosphereFramework.class.getName()); sc.setAttribute(AtmosphereFramework.MetaServiceAction.class.getName(), config); for (final Map.Entry<String, AtmosphereFramework.MetaServiceAction> action : config.entrySet()) { final Class c = IOUtils.loadClass(AtmosphereFramework.class, action.getKey()); if (AtmosphereFramework.class.isAssignableFrom(c)) { logger.info("Found a definition of AtmosphereFramework {} under {}", c, metaServicePath); return newAtmosphereFramework(c, isFilter, autoDetectHandlers); } } } catch (Exception ex) { logger.error("", ex); } return newAtmosphereFramework(AtmosphereFramework.class, isFilter, autoDetectHandlers, sc); }
void configureBroadcasterFilter(List<String> list) { for (String broadcastFilter : list) { BroadcastFilter bf = null; try { bf = config.framework().newClassInstance(BroadcastFilter.class, (Class<BroadcastFilter>) IOUtils.loadClass(getClass(), broadcastFilter)); } catch (Exception e) { logger.warn("Error trying to instantiate BroadcastFilter: {}", broadcastFilter, e); } if (bf != null) { addFilter(bf); } } }
private void loadServlet(ServletConfig sc, URLClassLoader urlC) throws Exception { if (servletClassName != null && servlet == null) { try { servlet = config.framework().newClassInstance(Servlet.class, (Class<Servlet>) urlC.loadClass(servletClassName)); } catch (NullPointerException ex) { // We failed to load the servlet, let's try directly. servlet = config.framework().newClassInstance(Servlet.class, (Class<Servlet>) IOUtils.loadClass(getClass(), servletClassName)); } } if (servlet != null) { logger.info("Installing Servlet {}", servletClassName == null ? servlet.getClass().getName() : servletClassName); } else { logger.info("No servlet installed. Neither servlet nor servletClassName is set"); } }
public void configureBroadcasterFactory() { try { // Check auto supported one if (isBroadcasterSpecified == false) { broadcasterClassName = lookupDefaultBroadcasterType(broadcasterClassName); } if (broadcasterFactoryClassName != null && broadcasterFactory == null) { broadcasterFactory = newClassInstance(BroadcasterFactory.class, (Class<BroadcasterFactory>) IOUtils.loadClass(getClass(), broadcasterFactoryClassName)); Class<? extends Broadcaster> bc = (Class<? extends Broadcaster>) IOUtils.loadClass(getClass(), broadcasterClassName); broadcasterFactory.configure(bc, broadcasterLifeCyclePolicy, config); } if (broadcasterFactory == null) { Class<? extends Broadcaster> bc = (Class<? extends Broadcaster>) IOUtils.loadClass(getClass(), broadcasterClassName); broadcasterFactory = newClassInstance(BroadcasterFactory.class, DefaultBroadcasterFactory.class); broadcasterFactory.configure(bc, broadcasterLifeCyclePolicy, config); } for (BroadcasterListener b : broadcasterListeners) { broadcasterFactory.addBroadcasterListener(b); } } catch (Exception ex) { logger.error("Unable to configure Broadcaster/Factory/Cache", ex); } }
private Filter loadFilter(URLClassLoader urlC, String fClass) throws Exception { Filter f; try { f = config.framework().newClassInstance(Filter.class, (Class<Filter>) urlC.loadClass(fClass)); } catch (NullPointerException ex) { // We failed to load the Filter, let's try directly. f = config.framework().newClassInstance(Filter.class, (Class<Filter>) IOUtils.loadClass(getClass(), fClass)); } return f; }
protected void configureBroadcaster() { try { Iterator<Entry<String, AtmosphereHandlerWrapper>> i = atmosphereHandlers.entrySet().iterator(); AtmosphereHandlerWrapper w; Entry<String, AtmosphereHandlerWrapper> e; while (i.hasNext()) { e = i.next(); w = e.getValue(); if (w.broadcaster == null) { w.broadcaster = broadcasterFactory.get(w.mapping); } else { if (broadcasterCacheClassName != null && w.broadcaster.getBroadcasterConfig().getBroadcasterCache().getClass().getName().equals( DefaultBroadcasterCache.class.getName())) { BroadcasterCache cache = newClassInstance(BroadcasterCache.class, (Class<BroadcasterCache>) IOUtils.loadClass(getClass(), broadcasterCacheClassName)); cache.configure(config); w.broadcaster.getBroadcasterConfig().setBroadcasterCache(cache); } } } } catch (Exception ex) { logger.error("Unable to configure Broadcaster/Factory/Cache", ex); } }
public void initWebSocket() { if (webSocketProtocolInitialized) return; if (webSocketProtocol == null) { try { webSocketProtocol = newClassInstance(WebSocketProtocol.class, (Class<WebSocketProtocol>) IOUtils.loadClass(this.getClass(), webSocketProtocolClassName)); logger.info("Installed WebSocketProtocol {} ", webSocketProtocolClassName); } catch (Exception ex) { logger.error("Cannot load the WebSocketProtocol {}", getWebSocketProtocolClassName(), ex); try { webSocketProtocol = newClassInstance(WebSocketProtocol.class, SimpleHttpProtocol.class); } catch (Exception e) { } } } webSocketProtocolInitialized = true; webSocketProtocol.configure(config); }
private WebSocketProcessor createProcessor(AtmosphereFramework framework) { WebSocketProcessor processor = null; String webSocketProcessorName = framework.getWebSocketProcessorClassName(); if (!webSocketProcessorName.equalsIgnoreCase(DefaultWebSocketProcessor.class.getName())) { try { processor = framework.newClassInstance(WebSocketProcessor.class, (Class<WebSocketProcessor>) IOUtils.loadClass(getClass(), webSocketProcessorName)); } catch (Exception ex) { logger.error("Unable to create {}", webSocketProcessorName); processor = new DefaultWebSocketProcessor(); } } if (processor == null) { processor = new DefaultWebSocketProcessor(); } processor.configure(framework.getAtmosphereConfig()); return processor; } }
protected void configure(String broadcasterLifeCyclePolicy) { super.configure(broadcasterLifeCyclePolicy); String poolableProviderClass = config.getInitParameter(POOLEABLE_PROVIDER, UnboundedApachePoolableProvider.class.getName()); try { poolableProvider = config.framework().newClassInstance(PoolableProvider.class, (Class<PoolableProvider>) IOUtils.loadClass(PoolableProvider.class, poolableProviderClass)); } catch (Exception e) { throw new RuntimeException(e); } poolableProvider.configure(config); trackPooledBroadcaster = config.getInitParameter(SUPPORT_TRACKED_BROADCASTER, false); }
private void configureBroadcasterCache() { try { String className = config.framework().getBroadcasterCacheClassName(); if (className != null) { broadcasterCache = config.framework().newClassInstance(BroadcasterCache.class, (Class<BroadcasterCache>) IOUtils.loadClass(getClass(), className)); configureSharedCacheExecutor(); broadcasterCache.configure(config); } for (BroadcasterCacheInspector b : config.framework().inspectors()) { broadcasterCache.inspector(b); } for (BroadcasterCacheListener l : config.framework().broadcasterCacheListeners()) { broadcasterCache.addBroadcasterCacheListener(l); } } catch (Exception e) { throw new RuntimeException(e); } }