Examples with ServletHolder org.eclipse.jetty.servlet.ServletHolder used on opensource projects

Example 11 with ServletHolder

use of org.eclipse.jetty.servlet.ServletHolder in project jetty.project by eclipse.

the class ProxyServletFailureTest method prepareServer.

private void prepareServer(HttpServlet servlet) throws Exception {
    QueuedThreadPool executor = new QueuedThreadPool();
    executor.setName("server");
    server = new Server(executor);
    serverConnector = new ServerConnector(server);
    server.addConnector(serverConnector);
    ServletContextHandler appCtx = new ServletContextHandler(server, "/", true, false);
    ServletHolder appServletHolder = new ServletHolder(servlet);
    appCtx.addServlet(appServletHolder, "/*");
    server.start();
}

Example 12 with ServletHolder

use of org.eclipse.jetty.servlet.ServletHolder in project jetty.project by eclipse.

the class StandardDescriptorProcessor method visitServlet.

public void visitServlet(WebAppContext context, Descriptor descriptor, XmlParser.Node node) {
    String id = node.getAttribute("id");
    // initialize holder
    String name = node.getString("servlet-name", false, true);
    ServletHolder holder = _servletHolderMap.get(name);
    //If servlet of that name does not already exist, create it.
    if (holder == null) {
        holder = context.getServletHandler().newServletHolder(new Source(Source.Origin.DESCRIPTOR, descriptor.getResource().toString()));
        holder.setName(name);
        _servletHolderMap.put(name, holder);
        _servletHolders.add(holder);
    }
    // init params
    Iterator<?> iParamsIter = node.iterator("init-param");
    while (iParamsIter.hasNext()) {
        XmlParser.Node paramNode = (XmlParser.Node) iParamsIter.next();
        String pname = paramNode.getString("param-name", false, true);
        String pvalue = paramNode.getString("param-value", false, true);
        String originName = name + ".servlet.init-param." + pname;
        Descriptor originDescriptor = context.getMetaData().getOriginDescriptor(originName);
        switch(context.getMetaData().getOrigin(originName)) {
            case NotSet:
                {
                    //init-param not already set, so set it
                    holder.setInitParameter(pname, pvalue);
                    context.getMetaData().setOrigin(originName, descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //otherwise just ignore it
                    if (!(descriptor instanceof FragmentDescriptor) && (descriptor != originDescriptor)) {
                        holder.setInitParameter(pname, pvalue);
                        context.getMetaData().setOrigin(originName, descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //previously set by a web-fragment, make sure that the value matches, otherwise its an error
                    if ((descriptor != originDescriptor) && !holder.getInitParameter(pname).equals(pvalue))
                        throw new IllegalStateException("Mismatching init-param " + pname + "=" + pvalue + " in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
    String servlet_class = node.getString("servlet-class", false, true);
    if ("".equals(servlet_class))
        servlet_class = null;
    //Handle the default jsp servlet instance
    if (id != null && id.equals("jsp") && servlet_class != null) {
        try {
            Loader.loadClass(servlet_class);
        } catch (ClassNotFoundException e) {
            LOG.info("NO JSP Support for {}, did not find {}", context.getContextPath(), servlet_class);
            servlet_class = "org.eclipse.jetty.servlet.NoJspServlet";
        }
    }
    //Set the servlet-class
    if (servlet_class != null) {
        ((WebDescriptor) descriptor).addClassName(servlet_class);
        switch(context.getMetaData().getOrigin(name + ".servlet.servlet-class")) {
            case NotSet:
                {
                    //the class of the servlet has not previously been set, so set it
                    holder.setClassName(servlet_class);
                    context.getMetaData().setOrigin(name + ".servlet.servlet-class", descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //the class of the servlet was set by a web xml file, only allow web-override/web-default to change it
                    if (!(descriptor instanceof FragmentDescriptor)) {
                        holder.setClassName(servlet_class);
                        context.getMetaData().setOrigin(name + ".servlet.servlet-class", descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //the class was set by another fragment, ensure this fragment's value is the same
                    if (!servlet_class.equals(holder.getClassName()))
                        throw new IllegalStateException("Conflicting servlet-class " + servlet_class + " in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
    // Handle JSP file
    String jsp_file = node.getString("jsp-file", false, true);
    if (jsp_file != null)
        holder.setForcedPath(jsp_file);
    // handle load-on-startup
    XmlParser.Node startup = node.get("load-on-startup");
    if (startup != null) {
        String s = startup.toString(false, true).toLowerCase(Locale.ENGLISH);
        int order = 0;
        if (s.startsWith("t")) {
            LOG.warn("Deprecated boolean load-on-startup.  Please use integer");
            order = 1;
        } else {
            try {
                if (s != null && s.trim().length() > 0)
                    order = Integer.parseInt(s);
            } catch (Exception e) {
                LOG.warn("Cannot parse load-on-startup " + s + ". Please use integer");
                LOG.ignore(e);
            }
        }
        switch(context.getMetaData().getOrigin(name + ".servlet.load-on-startup")) {
            case NotSet:
                {
                    //not already set, so set it now
                    holder.setInitOrder(order);
                    context.getMetaData().setOrigin(name + ".servlet.load-on-startup", descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //if it was already set by a web xml descriptor and we're parsing another web xml descriptor, then override it
                    if (!(descriptor instanceof FragmentDescriptor)) {
                        holder.setInitOrder(order);
                        context.getMetaData().setOrigin(name + ".servlet.load-on-startup", descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //it was already set by another fragment, if we're parsing a fragment, the values must match
                    if (order != holder.getInitOrder())
                        throw new IllegalStateException("Conflicting load-on-startup value in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
    Iterator<Node> sRefsIter = node.iterator("security-role-ref");
    while (sRefsIter.hasNext()) {
        XmlParser.Node securityRef = (XmlParser.Node) sRefsIter.next();
        String roleName = securityRef.getString("role-name", false, true);
        String roleLink = securityRef.getString("role-link", false, true);
        if (roleName != null && roleName.length() > 0 && roleLink != null && roleLink.length() > 0) {
            if (LOG.isDebugEnabled())
                LOG.debug("link role " + roleName + " to " + roleLink + " for " + this);
            switch(context.getMetaData().getOrigin(name + ".servlet.role-name." + roleName)) {
                case NotSet:
                    {
                        //set it
                        holder.setUserRoleLink(roleName, roleLink);
                        context.getMetaData().setOrigin(name + ".servlet.role-name." + roleName, descriptor);
                        break;
                    }
                case WebXml:
                case WebDefaults:
                case WebOverride:
                    {
                        //only another web xml descriptor (web-default,web-override web.xml) can override an already set value
                        if (!(descriptor instanceof FragmentDescriptor)) {
                            holder.setUserRoleLink(roleName, roleLink);
                            context.getMetaData().setOrigin(name + ".servlet.role-name." + roleName, descriptor);
                        }
                        break;
                    }
                case WebFragment:
                    {
                        if (!holder.getUserRoleLink(roleName).equals(roleLink))
                            throw new IllegalStateException("Conflicting role-link for role-name " + roleName + " for servlet " + name + " in " + descriptor.getResource());
                        break;
                    }
                default:
                    // TODO throw ISE?
                    LOG.warn(new Throwable());
            }
        } else {
            LOG.warn("Ignored invalid security-role-ref element: " + "servlet-name=" + holder.getName() + ", " + securityRef);
        }
    }
    XmlParser.Node run_as = node.get("run-as");
    if (run_as != null) {
        String roleName = run_as.getString("role-name", false, true);
        if (roleName != null) {
            switch(context.getMetaData().getOrigin(name + ".servlet.run-as")) {
                case NotSet:
                    {
                        //run-as not set, so set it
                        holder.setRunAsRole(roleName);
                        context.getMetaData().setOrigin(name + ".servlet.run-as", descriptor);
                        break;
                    }
                case WebXml:
                case WebDefaults:
                case WebOverride:
                    {
                        //run-as was set by a web xml, only allow it to be changed if we're currently parsing another web xml(override/default)
                        if (!(descriptor instanceof FragmentDescriptor)) {
                            holder.setRunAsRole(roleName);
                            context.getMetaData().setOrigin(name + ".servlet.run-as", descriptor);
                        }
                        break;
                    }
                case WebFragment:
                    {
                        //run-as was set by another fragment, this fragment must show the same value
                        if (!holder.getRunAsRole().equals(roleName))
                            throw new IllegalStateException("Conflicting run-as role " + roleName + " for servlet " + name + " in " + descriptor.getResource());
                        break;
                    }
                default:
                    // TODO throw ISE?
                    LOG.warn(new Throwable());
            }
        }
    }
    String async = node.getString("async-supported", false, true);
    if (async != null) {
        boolean val = async.length() == 0 || Boolean.valueOf(async);
        switch(context.getMetaData().getOrigin(name + ".servlet.async-supported")) {
            case NotSet:
                {
                    //set it
                    holder.setAsyncSupported(val);
                    context.getMetaData().setOrigin(name + ".servlet.async-supported", descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //async-supported set by previous web xml descriptor, only allow override if we're parsing another web descriptor(web.xml/web-override.xml/web-default.xml)
                    if (!(descriptor instanceof FragmentDescriptor)) {
                        holder.setAsyncSupported(val);
                        context.getMetaData().setOrigin(name + ".servlet.async-supported", descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //async-supported set by another fragment, this fragment's value must match
                    if (holder.isAsyncSupported() != val)
                        throw new IllegalStateException("Conflicting async-supported=" + async + " for servlet " + name + " in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
    String enabled = node.getString("enabled", false, true);
    if (enabled != null) {
        boolean is_enabled = enabled.length() == 0 || Boolean.valueOf(enabled);
        switch(context.getMetaData().getOrigin(name + ".servlet.enabled")) {
            case NotSet:
                {
                    //hasn't been set yet, so set it
                    holder.setEnabled(is_enabled);
                    context.getMetaData().setOrigin(name + ".servlet.enabled", descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //was set in a web xml descriptor, only allow override from another web xml descriptor
                    if (!(descriptor instanceof FragmentDescriptor)) {
                        holder.setEnabled(is_enabled);
                        context.getMetaData().setOrigin(name + ".servlet.enabled", descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //was set by another fragment, this fragment's value must match
                    if (holder.isEnabled() != is_enabled)
                        throw new IllegalStateException("Conflicting value of servlet enabled for servlet " + name + " in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
    /*
         * If multipart config not set, then set it and record it was by the web.xml or fragment.
         * If it was set by web.xml then if this is a fragment, ignore the settings.
         * If it was set by a fragment, if this is a fragment and the values are different, error!
         */
    XmlParser.Node multipart = node.get("multipart-config");
    if (multipart != null) {
        String location = multipart.getString("location", false, true);
        String maxFile = multipart.getString("max-file-size", false, true);
        String maxRequest = multipart.getString("max-request-size", false, true);
        String threshold = multipart.getString("file-size-threshold", false, true);
        MultipartConfigElement element = new MultipartConfigElement(location, (maxFile == null || "".equals(maxFile) ? -1L : Long.parseLong(maxFile)), (maxRequest == null || "".equals(maxRequest) ? -1L : Long.parseLong(maxRequest)), (threshold == null || "".equals(threshold) ? 0 : Integer.parseInt(threshold)));
        switch(context.getMetaData().getOrigin(name + ".servlet.multipart-config")) {
            case NotSet:
                {
                    //hasn't been set, so set it
                    holder.getRegistration().setMultipartConfig(element);
                    context.getMetaData().setOrigin(name + ".servlet.multipart-config", descriptor);
                    break;
                }
            case WebXml:
            case WebDefaults:
            case WebOverride:
                {
                    //was set in a web xml, only allow changes if we're parsing another web xml (web.xml/web-default.xml/web-override.xml)
                    if (!(descriptor instanceof FragmentDescriptor)) {
                        holder.getRegistration().setMultipartConfig(element);
                        context.getMetaData().setOrigin(name + ".servlet.multipart-config", descriptor);
                    }
                    break;
                }
            case WebFragment:
                {
                    //another fragment set the value, this fragment's values must match exactly or it is an error
                    MultipartConfigElement cfg = ((ServletHolder.Registration) holder.getRegistration()).getMultipartConfig();
                    if (cfg.getMaxFileSize() != element.getMaxFileSize())
                        throw new IllegalStateException("Conflicting multipart-config max-file-size for servlet " + name + " in " + descriptor.getResource());
                    if (cfg.getMaxRequestSize() != element.getMaxRequestSize())
                        throw new IllegalStateException("Conflicting multipart-config max-request-size for servlet " + name + " in " + descriptor.getResource());
                    if (cfg.getFileSizeThreshold() != element.getFileSizeThreshold())
                        throw new IllegalStateException("Conflicting multipart-config file-size-threshold for servlet " + name + " in " + descriptor.getResource());
                    if ((cfg.getLocation() != null && (element.getLocation() == null || element.getLocation().length() == 0)) || (cfg.getLocation() == null && (element.getLocation() != null || element.getLocation().length() > 0)))
                        throw new IllegalStateException("Conflicting multipart-config location for servlet " + name + " in " + descriptor.getResource());
                    break;
                }
            default:
                // TODO throw ISE?
                LOG.warn(new Throwable());
        }
    }
}

Example 13 with ServletHolder

use of org.eclipse.jetty.servlet.ServletHolder in project jetty.project by eclipse.

the class StandardDescriptorProcessor method start.

/**
     * {@inheritDoc}
     */
public void start(WebAppContext context, Descriptor descriptor) {
    for (FilterHolder h : context.getServletHandler().getFilters()) {
        _filterHolderMap.put(h.getName(), h);
        _filterHolders.add(h);
    }
    if (context.getServletHandler().getFilterMappings() != null)
        _filterMappings.addAll(Arrays.asList(context.getServletHandler().getFilterMappings()));
    for (ServletHolder h : context.getServletHandler().getServlets()) {
        _servletHolderMap.put(h.getName(), h);
        _servletHolders.add(h);
    }
    if (context.getServletHandler().getServletMappings() != null)
        _servletMappings.addAll(Arrays.asList(context.getServletHandler().getServletMappings()));
}

Example 14 with ServletHolder

use of org.eclipse.jetty.servlet.ServletHolder in project jetty.project by eclipse.

the class AbstractSessionExpiryTest method testRequestForSessionWithChangedTimeout.

@Test
public void testRequestForSessionWithChangedTimeout() throws Exception {
    String contextPath = "";
    String servletMapping = "/server";
    int inactivePeriod = 5;
    int scavengePeriod = 1;
    DefaultSessionCacheFactory cacheFactory = new DefaultSessionCacheFactory();
    cacheFactory.setEvictionPolicy(SessionCache.NEVER_EVICT);
    SessionDataStoreFactory storeFactory = createSessionDataStoreFactory();
    ((AbstractSessionDataStoreFactory) storeFactory).setGracePeriodSec(scavengePeriod);
    TestServer server1 = new TestServer(0, inactivePeriod, scavengePeriod, cacheFactory, storeFactory);
    ChangeTimeoutServlet servlet = new ChangeTimeoutServlet();
    ServletHolder holder = new ServletHolder(servlet);
    ServletContextHandler context = server1.addContext(contextPath);
    context.addServlet(holder, servletMapping);
    TestHttpSessionListener listener = new TestHttpSessionListener();
    context.getSessionHandler().addEventListener(listener);
    server1.start();
    int port1 = server1.getPort();
    try {
        HttpClient client = new HttpClient();
        client.start();
        String url = "http://localhost:" + port1 + contextPath + servletMapping;
        //make a request to set up a session on the server with the session manager's inactive timeout
        ContentResponse response = client.GET(url + "?action=init");
        assertEquals(HttpServletResponse.SC_OK, response.getStatus());
        String sessionCookie = response.getHeaders().get("Set-Cookie");
        assertTrue(sessionCookie != null);
        // Mangle the cookie, replacing Path with $Path, etc.
        sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
        //make another request to change the session timeout to a larger value
        int newInactivePeriod = 100;
        Request request = client.newRequest(url + "?action=change&val=" + newInactivePeriod);
        request.getHeaders().add("Cookie", sessionCookie);
        response = request.send();
        assertEquals(HttpServletResponse.SC_OK, response.getStatus());
        //stop and restart the session manager to ensure it needs to reload the session
        context.stop();
        context.start();
        //wait until the session manager timeout has passed and re-request the session
        //which should still be valid
        pause(inactivePeriod);
        request = client.newRequest(url + "?action=check");
        request.getHeaders().add("Cookie", sessionCookie);
        response = request.send();
        assertEquals(HttpServletResponse.SC_OK, response.getStatus());
        String sessionCookie2 = response.getHeaders().get("Set-Cookie");
        assertNull(sessionCookie2);
    } finally {
        server1.stop();
    }
}

Example 15 with ServletHolder

use of org.eclipse.jetty.servlet.ServletHolder in project jetty.project by eclipse.

the class AbstractSessionExpiryTest method testSessionNotExpired.

/**
     * Check session is preserved over stop/start
     * @throws Exception
     */
@Test
public void testSessionNotExpired() throws Exception {
    String contextPath = "";
    String servletMapping = "/server";
    int inactivePeriod = 20;
    int scavengePeriod = 10;
    DefaultSessionCacheFactory cacheFactory = new DefaultSessionCacheFactory();
    cacheFactory.setEvictionPolicy(SessionCache.NEVER_EVICT);
    SessionDataStoreFactory storeFactory = createSessionDataStoreFactory();
    ((AbstractSessionDataStoreFactory) storeFactory).setGracePeriodSec(scavengePeriod);
    TestServer server1 = new TestServer(0, inactivePeriod, scavengePeriod, cacheFactory, storeFactory);
    TestServlet servlet = new TestServlet();
    ServletHolder holder = new ServletHolder(servlet);
    server1.addContext(contextPath).addServlet(holder, servletMapping);
    HttpClient client = new HttpClient();
    try {
        server1.start();
        int port1 = server1.getPort();
        client.start();
        String url = "http://localhost:" + port1 + contextPath + servletMapping;
        //make a request to set up a session on the server
        ContentResponse response = client.GET(url + "?action=init");
        assertEquals(HttpServletResponse.SC_OK, response.getStatus());
        String sessionCookie = response.getHeaders().get("Set-Cookie");
        assertTrue(sessionCookie != null);
        // Mangle the cookie, replacing Path with $Path, etc.
        sessionCookie = sessionCookie.replaceFirst("(\\W)(P|p)ath=", "$1\\$Path=");
        //now stop the server
        server1.stop();
        //start the server again, before the session times out
        server1.start();
        port1 = server1.getPort();
        url = "http://localhost:" + port1 + contextPath + servletMapping;
        //make another request, the session should not have expired
        Request request = client.newRequest(url + "?action=notexpired");
        request.getHeaders().add("Cookie", sessionCookie);
        ContentResponse response2 = request.send();
        assertEquals(HttpServletResponse.SC_OK, response2.getStatus());
    } finally {
        client.stop();
        server1.stop();
    }
}