/** * Configure and initialize the set of filters for this Context. * Return <code>true</code> if all filter initialization completed * successfully, or <code>false</code> otherwise. */ public boolean filterStart() { if (log.isLoggable(Level.FINE)) log.log(Level.FINE, "Starting filters"); // Instantiate and record a FilterConfig for each defined filter boolean ok = true; synchronized (filterConfigs) { filterConfigs.clear(); for (String name : filterDefs.keySet()) { String safeName = neutralizeForLog(name); if(log.isLoggable(Level.FINE)) { log.log(Level.FINE, " Starting filter '" + safeName + "'"); } try { filterConfigs.put(name, new ApplicationFilterConfig(this, filterDefs.get(name))); } catch(Throwable t) { String msg = MessageFormat.format(rb.getString(LogFacade.STARTING_FILTER_EXCEPTION), safeName); getServletContext().log(msg, t); ok = false; } } } return (ok); }
getFilter(); } else { this.filter = filterDef.getFilter(); getInstanceManager().newInstance(filter); initFilter();
/** * Finalize and release the set of filters for this Context. * Return <code>true</code> if all filter finalization completed * successfully, or <code>false</code> otherwise. */ public boolean filterStop() { if (log.isLoggable(Level.FINE)) log.log(Level.FINE, "Stopping filters"); // Release all Filter and FilterConfig instances synchronized (filterConfigs) { for (String filterName : filterConfigs.keySet()) { String safeFilterName = neutralizeForLog(filterName); if(log.isLoggable(Level.FINE)) { log.log(Level.FINE, " Stopping filter '" + safeFilterName + "'"); } ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)filterConfigs.get(filterName); filterConfig.release(); } filterConfigs.clear(); } return (true); }
/** * Identifies the Filters, if any, in this FilterChain that do not support * async. * * @param result The Set to which the fully qualified class names of each * Filter in this FilterChain that does not support async will * be added */ public void findNonAsyncFilters(Set<String> result) { for (int i = 0; i < n ; i++) { ApplicationFilterConfig filter = filters[i]; if ("false".equalsIgnoreCase(filter.getFilterDef().getAsyncSupported())) { result.add(filter.getFilterClass()); } } } }
public Map<String, FilterRegistration> getFilterRegistrations() { if (restricted) { throw MESSAGES.restrictedListenerCannotCallMethod(); } HashMap<String, FilterRegistration> result = new HashMap<String, FilterRegistration>(); ApplicationFilterConfig[] filterConfigs = context.findApplicationFilterConfigs(); for (int i = 0; i < filterConfigs.length; i++) { result.put(filterConfigs[i].getFilterName(), filterConfigs[i].getFacade()); } return Collections.unmodifiableMap(result); }
super(); this.context = context; setFilterDef(filterDef); getFilter(); } catch(InstantiationException iex) { throw iex;
private void unregsiterJMX() { // unregister this component if (oname != null) { try { Registry.getRegistry(null, null).unregisterComponent(oname); } catch(Exception ex) { CatalinaLogger.CORE_LOGGER.filterJmxUnregistrationFailed(getFilterClass(), getFilterName(), ex); } } }
private void initFilter() throws ServletException { if (context instanceof StandardContext && context.getSwallowOutput()) { try { SystemLogHandler.startCapture(); filter.init(this); } finally { String capturedlog = SystemLogHandler.stopCapture(); if (capturedlog != null && capturedlog.length() > 0) { getServletContext().log(capturedlog); } } } else { filter.init(this); } // Expose filter via JMX registerJMX(); }
ApplicationFilterConfig filterConfig = filterConfigsIterator.next(); try { filterConfig.getFilter(); } catch (Throwable t) { getLogger().error(MESSAGES.errorStartingFilter(filterConfig.getFilterName()), t); ok = false; getLogger().debug(" Starting filter '" + name + "'"); try { filterConfig = new ApplicationFilterConfig(this, (FilterDef) filterDefs.get(name)); filterConfig.getFilter(); filterConfigs.put(name, filterConfig); } catch (Throwable t) {
setFilterDef(filterDef); if (filterDef.getFilter() != null) { this.filter = filterDef.getFilter(); getInstanceManager().newInstance(filter); initFilter();
/** * Return the application Filter we are configured for. * * @exception ClassCastException if the specified class does not implement * the <code>javax.servlet.Filter</code> interface * @exception ClassNotFoundException if the filter class cannot be found * @exception IllegalAccessException if the filter class cannot be * publicly instantiated * @exception InstantiationException if an exception occurs while * instantiating the filter object * @exception ServletException if thrown by the filter's init() method * @throws NamingException * @throws InvocationTargetException */ Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException, InstantiationException, ServletException, InvocationTargetException, NamingException { // Return the existing filter instance, if any if (this.filter != null) return (this.filter); // Identify the class loader we will be using String filterClass = filterDef.getFilterClass(); this.filter = (Filter) getInstanceManager().newInstance(filterClass); initFilter(); return (this.filter); }
ApplicationFilterConfig filterConfig = filters[pos++]; try { Filter filter = filterConfig.getFilter(); filterConfig.getFilterDef().getAsyncSupported())) { request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
ApplicationFilterConfig filterConfig = filterConfigsIterator.next(); try { filterConfig.getFilter(); } catch (Throwable t) { getLogger().error ApplicationFilterConfig filterConfig = null; try { filterConfig = new ApplicationFilterConfig (this, (FilterDef) filterDefs.get(name)); filterConfig.getFilter(); filterConfigs.put(name, filterConfig); } catch (Throwable t) {
public String getClassName() { return config.getFilterDef().getFilterClass(); }
if (container instanceof StandardContext) { for (ApplicationFilterConfig filterConfig : ((StandardContext) container).findApplicationFilterConfigs()) { if (filterConfig.getFilterInstance() == filter) { return null; filterDef.setFilterClass(filter.getClass().getName()); context.addFilterDef(filterDef); ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(context, filterDef); filterConfig.setDynamic(true); filterConfig.setFilter(filter); context.addApplicationFilterConfig(filterConfig); return (FilterRegistration.Dynamic) filterConfig.getFacade();
getFilter(); } else { this.filter = filterDef.getFilter(); context.getInstanceManager().newInstance(filter); initFilter();
/** * Return the name of the filter we are configuring. */ public String getFilterName() { return config.getFilterName(); }
public FilterRegistration.Dynamic addFilter(String filterName, String className) throws IllegalArgumentException, IllegalStateException { if (restricted) { throw new UnsupportedOperationException(sm.getString("applicationContext.restricted")); } if (!context.isStarting()) { throw new IllegalStateException(sm.getString("applicationContext.alreadyInitialized", getContextPath())); } if (context.findFilterDef(filterName) != null) { return null; } FilterDef filterDef = new FilterDef(); filterDef.setFilterName(filterName); filterDef.setFilterClass(className); context.addFilterDef(filterDef); ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(context, filterDef); filterConfig.setDynamic(true); context.addApplicationFilterConfig(filterConfig); return (FilterRegistration.Dynamic) filterConfig.getFacade(); }
/** * Release the Filter instance associated with this FilterConfig, * if there is one. */ void release() { unregisterJMX(); if (this.filter != null) { if (Globals.IS_SECURITY_ENABLED) { try { SecurityUtil.doAsPrivilege("destroy", filter); } catch(java.lang.Exception ex){ context.getLogger().error("ApplicationFilterConfig.doAsPrivilege", ex); } SecurityUtil.remove(filter); } else { filter.destroy(); } if (!context.getIgnoreAnnotations()) { try { ((StandardContext) context).getInstanceManager().destroyInstance(this.filter); } catch (Exception e) { context.getLogger().error("ApplicationFilterConfig.preDestroy", e); } } } this.filter = null; }