Examples with ServletPathSpec org.eclipse.jetty.http.pathmap.ServletPathSpec used on opensource projects

Example 1 with ServletPathSpec

use of org.eclipse.jetty.http.pathmap.ServletPathSpec in project jetty.project by eclipse.

the class ServletHandler method updateMappings.

/* ------------------------------------------------------------ */
protected synchronized void updateMappings() {
    // update filter mappings
    if (_filterMappings == null) {
        _filterPathMappings = null;
        _filterNameMappings = null;
    } else {
        _filterPathMappings = new ArrayList<>();
        _filterNameMappings = new MultiMap<>();
        for (FilterMapping filtermapping : _filterMappings) {
            FilterHolder filter_holder = _filterNameMap.get(filtermapping.getFilterName());
            if (filter_holder == null)
                throw new IllegalStateException("No filter named " + filtermapping.getFilterName());
            filtermapping.setFilterHolder(filter_holder);
            if (filtermapping.getPathSpecs() != null)
                _filterPathMappings.add(filtermapping);
            if (filtermapping.getServletNames() != null) {
                String[] names = filtermapping.getServletNames();
                for (String name : names) {
                    if (name != null)
                        _filterNameMappings.add(name, filtermapping);
                }
            }
        }
    }
    // Map servlet paths to holders
    if (_servletMappings == null || _servletNameMap == null) {
        _servletPathMap = null;
    } else {
        PathMappings<ServletHolder> pm = new PathMappings<>();
        Map<String, ServletMapping> servletPathMappings = new HashMap<>();
        //create a map of paths to set of ServletMappings that define that mapping
        HashMap<String, List<ServletMapping>> sms = new HashMap<>();
        for (ServletMapping servletMapping : _servletMappings) {
            String[] pathSpecs = servletMapping.getPathSpecs();
            if (pathSpecs != null) {
                for (String pathSpec : pathSpecs) {
                    List<ServletMapping> mappings = sms.get(pathSpec);
                    if (mappings == null) {
                        mappings = new ArrayList<>();
                        sms.put(pathSpec, mappings);
                    }
                    mappings.add(servletMapping);
                }
            }
        }
        //evaluate path to servlet map based on servlet mappings
        for (String pathSpec : sms.keySet()) {
            //for each path, look at the mappings where it is referenced
            //if a mapping is for a servlet that is not enabled, skip it
            List<ServletMapping> mappings = sms.get(pathSpec);
            ServletMapping finalMapping = null;
            for (ServletMapping mapping : mappings) {
                //Get servlet associated with the mapping and check it is enabled
                ServletHolder servlet_holder = _servletNameMap.get(mapping.getServletName());
                if (servlet_holder == null)
                    throw new IllegalStateException("No such servlet: " + mapping.getServletName());
                //if the servlet related to the mapping is not enabled, skip it from consideration
                if (!servlet_holder.isEnabled())
                    continue;
                //only accept a default mapping if we don't have any other
                if (finalMapping == null)
                    finalMapping = mapping;
                else {
                    //if the candidate is a default, or we're allowing duplicate mappings
                    if (finalMapping.isDefault())
                        finalMapping = mapping;
                    else if (isAllowDuplicateMappings()) {
                        LOG.warn("Multiple servlets map to path {}: {} and {}, choosing {}", pathSpec, finalMapping.getServletName(), mapping.getServletName(), mapping);
                        finalMapping = mapping;
                    } else {
                        //existing candidate isn't a default, if the one we're looking at isn't a default either, then its an error
                        if (!mapping.isDefault()) {
                            ServletHolder finalMappedServlet = _servletNameMap.get(finalMapping.getServletName());
                            throw new IllegalStateException("Multiple servlets map to path " + pathSpec + ": " + finalMappedServlet.getName() + "[mapped:" + finalMapping.getSource() + "]," + mapping.getServletName() + "[mapped:" + mapping.getSource() + "]");
                        }
                    }
                }
            }
            if (finalMapping == null)
                throw new IllegalStateException("No acceptable servlet mappings for " + pathSpec);
            if (LOG.isDebugEnabled())
                LOG.debug("Path={}[{}] mapped to servlet={}[{}]", pathSpec, finalMapping.getSource(), finalMapping.getServletName(), _servletNameMap.get(finalMapping.getServletName()).getSource());
            servletPathMappings.put(pathSpec, finalMapping);
            pm.put(new ServletPathSpec(pathSpec), _servletNameMap.get(finalMapping.getServletName()));
        }
        _servletPathMap = pm;
    }
    // flush filter chain cache
    if (_chainCache != null) {
        for (int i = _chainCache.length; i-- > 0; ) {
            if (_chainCache[i] != null)
                _chainCache[i].clear();
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("filterNameMap=" + _filterNameMap);
        LOG.debug("pathFilters=" + _filterPathMappings);
        LOG.debug("servletFilterMap=" + _filterNameMappings);
        LOG.debug("servletPathMap=" + _servletPathMap);
        LOG.debug("servletNameMap=" + _servletNameMap);
    }
    try {
        if (_contextHandler != null && _contextHandler.isStarted() || _contextHandler == null && isStarted())
            initialize();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

Example 2 with ServletPathSpec

use of org.eclipse.jetty.http.pathmap.ServletPathSpec in project spark by perwendel.

the class WebSocketServletContextHandlerFactory method create.

/**
 * Creates a new websocket servlet context handler.
 *
 * @param webSocketHandlers          webSocketHandlers
 * @param webSocketIdleTimeoutMillis webSocketIdleTimeoutMillis
 * @return a new websocket servlet context handler or 'null' if creation failed.
 */
public static ServletContextHandler create(Map<String, WebSocketHandlerWrapper> webSocketHandlers, Optional<Integer> webSocketIdleTimeoutMillis) {
    ServletContextHandler webSocketServletContextHandler = null;
    if (webSocketHandlers != null) {
        try {
            webSocketServletContextHandler = new ServletContextHandler(null, "/", true, false);
            WebSocketUpgradeFilter webSocketUpgradeFilter = WebSocketUpgradeFilter.configureContext(webSocketServletContextHandler);
            if (webSocketIdleTimeoutMillis.isPresent()) {
                webSocketUpgradeFilter.getFactory().getPolicy().setIdleTimeout(webSocketIdleTimeoutMillis.get());
            }
            // Since we are configuring WebSockets before the ServletContextHandler and WebSocketUpgradeFilter is
            // even initialized / started, then we have to pre-populate the configuration that will eventually
            // be used by Jetty's WebSocketUpgradeFilter.
            NativeWebSocketConfiguration webSocketConfiguration = (NativeWebSocketConfiguration) webSocketServletContextHandler.getServletContext().getAttribute(NativeWebSocketConfiguration.class.getName());
            for (String path : webSocketHandlers.keySet()) {
                WebSocketCreator webSocketCreator = WebSocketCreatorFactory.create(webSocketHandlers.get(path));
                webSocketConfiguration.addMapping(new ServletPathSpec(path), webSocketCreator);
            }
        } catch (Exception ex) {
            logger.error("creation of websocket context handler failed.", ex);
            webSocketServletContextHandler = null;
        }
    }
    return webSocketServletContextHandler;
}