Application with embedded Jetty showing "page not found" if launched as jar

Question

I have an application that uses embedded jetty. When I run this application in Netbeans IDE then I can browse my site @ localhost:8080/

When I launch the jar file of my application from command line: java -jar app.jar then browsing localhost:8080/ jetty server says "page not found"

What am I missing here? Can't figure out the problem.

EDIT:

Netbeans project is uploaded to Github

Everything works fine if I run this project in Netbeans. But when I take the jar file with lib folder and run it in cmd like this: java -jar EmbeddedJettyJspJstl.jar

Then navigating to http://localhost:8080/test I get errors:

org.apache.jasper.JasperException: java.lang.ClassNotFoundException: org.apache.jsp.WEB_002dINF.jstl_jsp

org.apache.jasper.JasperException: The absolute uri: http://java.sun.com/jsp/jstl/core cannot be resolved in either web.xml or the jar files deployed with this application

My JSP page uses JSTL and looks like it is not locating the jstl libraries?

And this is the code that starts the server:

package server;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;

import org.eclipse.jetty.jmx.MBeanContainer;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.AllowSymLinkAliasChecker;
import org.eclipse.jetty.server.handler.DefaultHandler;
import org.eclipse.jetty.server.handler.HandlerList;
import org.eclipse.jetty.webapp.Configuration;
import org.eclipse.jetty.webapp.WebAppContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author lkallas
 */
public class JettyServer {

    // Resource path pointing to where the WEBROOT is
    private static final String WEBROOT = "/webapp/";
    private static final Logger logger = LoggerFactory.getLogger(JettyServer.class);

    public void start() throws IOException, InterruptedException, URISyntaxException {

        Server server = new Server();

        // HTTP connector
        ServerConnector connector = new ServerConnector(server);
        connector.setHost("localhost");
        connector.setPort(8080);
        connector.setIdleTimeout(30000);

        // Set the connector
        server.addConnector(connector);

        // Setup JMX for web applications
        MBeanContainer mbContainer = new MBeanContainer(
                ManagementFactory.getPlatformMBeanServer());
        server.addBean(mbContainer);

        //Setting up web application
        WebAppContext webapp = new WebAppContext();
        webapp.setAttribute("javax.servlet.context.tempdir", getScratchDir());
        webapp.setDescriptor(WEBROOT + "WEB-INF/web.xml");
        webapp.setResourceBase(getWebRootResourceUri().toASCIIString());
        webapp.setContextPath("/");
        webapp.setWar(getWebRootResourceUri().toASCIIString());
        webapp.addAliasCheck(new AllowSymLinkAliasChecker());

        //For debugging
        logger.info("Descriptor file: {}", webapp.getDescriptor());
        logger.info("Resource base: {}", getWebRootResourceUri().toASCIIString());
        logger.info("WAR location: {}", webapp.getWar());

        HandlerList handlerList = new HandlerList();
        handlerList.setHandlers(new Handler[]{webapp, new DefaultHandler()});

        // This webapp will use jsps and jstl. We need to enable the
        // AnnotationConfiguration in order to correctly
        // set up the jsp container
        Configuration.ClassList classlist = Configuration.ClassList
                .setServerDefault(server);
        classlist.addBefore(
                "org.eclipse.jetty.webapp.JettyWebXmlConfiguration",
                "org.eclipse.jetty.annotations.AnnotationConfiguration");

        // Set the ContainerIncludeJarPattern so that jetty examines these
        // container-path jars for tlds, web-fragments etc.
        // If you omit the jar that contains the jstl .tlds, the jsp engine will
        // scan for them instead.
        webapp.setAttribute("org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern", ".*/[^/]*taglibs.*\.jar$");

        // A WebAppContext is a ContextHandler as well so it needs to be set to
        // the server so it is aware of where to send the appropriate requests.
        server.setHandler(handlerList);

        try {
            server.start();

        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }

        server.dumpStdErr();

    }

    /**
     * Establish Scratch directory for the servlet context (used by JSP
     * compilation)
     */
    private File getScratchDir() throws IOException {
        File tempDir = new File(System.getProperty("java.io.tmpdir"));
        File scratchDir = new File(tempDir.toString(), "embedded-jetty");

        if (!scratchDir.exists()) {
            if (!scratchDir.mkdirs()) {
                throw new IOException("Unable to create scratch directory: " + scratchDir);
            }
        }
        return scratchDir;
    }

    /**
     * Get webroot URI.
     *
     * @return
     * @throws FileNotFoundException
     * @throws URISyntaxException
     */
    private URI getWebRootResourceUri() throws FileNotFoundException, URISyntaxException {
        URL indexUri = this.getClass().getResource(WEBROOT);
        if (indexUri == null) {
            throw new FileNotFoundException("Unable to find resource " + WEBROOT);
        }
        logger.debug("WEBROOT: {}", indexUri.toURI().toASCIIString());
        return indexUri.toURI();
    }

}