如何在eclipse中运行jetty中的多个webapps

Question

I'm trying to setup a development environment for a gradle multi web-app aplication in eclipse. The application is deployed in production on jetty so thats what I'd like to use in development. I'm having trouble getting eclipse to run all the webapps and be able to debug as well.

The solutions I've been able to find online use plugins which can only run single webapps. Or they run the webapps via gradle (gretty) in a server which then causes problems with debugging.

My source is a multi project gradle app. It compiles properly, there's docker scripts which can run the software. In eclipse everything compiles without errors and seems to work fine. I'm at a loss however how to actually run/debug all the webapps at the same time in jetty in eclipse. Something I can do with tomcat and websphere.

Can any of you kind peeps suggest me a method to allow me to debug this setup in eclipse? Ideally something I can configure from gradle. Should I build a project that runs an embedded server? (Can this auto detect and use my existing web.xml files?) Or should I proceed with gretty (can this debug via eclipse in a straightforward manner) Or is there some other tool I'm missing?

I can't be the only one with this setup. What is the common solution for this?

Answer 1

There's very little information on the internet that specifically adresses this issue. So I'll take the time to answer my own question in the hope it will help someone else.

Gretty can't handle this, gretty makes strong presumptions about your app, if you've built it from the get go to adhere to those presumptions you're fine and it can be a great help. But the solution remains slow and inflexible.

There are no eclipse plugins for jetty, even though jetty is an eclipse (foundation) project, wtp won't help you..

I eventually took the embedded jetty route. This seemed harder than it really was. But the end result works like a charm. Extremely fast startup times (Our 12 webapp project went from 30+ seconds to 5 seconds) (Gretty took minutes) The whole application became more clear. There is one simple java class that defines what is running. No hard to read XML.

Here's the basic structure

this.server = new Server(port);

setupAnnotationScanning(server);
setupJAASLoginService(server, config);

HandlerCollection hc = new HandlerCollection(true);
startWebApp(config, hc, "/app1", "app1");

// Root must be defined last or it will interfere with non root webapps
startWebApp(config, hc, "/", "rootapp");

server.setHandler(hc);

Annotated scanning is nice, I want it.

private static void setupAnnotationScanning(Server server) {
    Configuration.ClassList classlist = Configuration.ClassList.setServerDefault(server);
    classlist.addAfter("org.eclipse.jetty.webapp.FragmentConfiguration", "org.eclipse.jetty.plus.webapp.EnvConfiguration", "org.eclipse.jetty.plus.webapp.PlusConfiguration");
    classlist.addBefore("org.eclipse.jetty.webapp.JettyWebXmlConfiguration", "org.eclipse.jetty.annotations.AnnotationConfiguration");
}

JAAS login service was harder to setup, it presumes a config file on disk, I didn't have that root, and I wanted it from my own bootstrap property service anyway.

private static void setupJAASLoginService(Server server, BootstrapProperties config) throws Exception {
    JAASLoginService loginService = new JAASLoginService("ldaploginmodule");
    loginService.setName("WebRealm");
    loginService.setConfiguration(setupLDAPConfiguration(config));
    loginService.start();

    server.addBean(loginService);
}

private static javax.security.auth.login.Configuration setupLDAPConfiguration(BootstrapProperties config) {
  // Basically what I do here is make my own implementation of the Configuration and use it
  // The existing class assumes code to be in a very specific file location.
    return new javax.security.auth.login.Configuration() {
        @Override
        public AppConfigurationEntry[] getAppConfigurationEntry(String name) {
            Map<String, Object> options = new HashMap<String, Object>();

            options.put("authenticationMethod", "simple");
            options.put("bindDn", config.get("ldap.bind.user"));
            options.put("bindPassword", config.get("ldap.bind.password"));
            options.put("contextFactory", "com.sun.jndi.ldap.LdapCtxFactory");
            options.put("debug", "true");
            options.put("forceBindingLogin", "true");
            options.put("hostname", config.get("ldap.host"));
            options.put("port", config.get("ldap.port"));
            options.put("roleBaseDn", config.get("ldap.groups.dn") + "," + config.get("ldap.root.dn"));/**/
            options.put("roleMemberAttribute", "uniqueMember");
            options.put("roleNameAttribute", "cn");
            options.put("roleObjectClass", "groupOfUniqueNames");
            options.put("userBaseDn", config.get("ldap.people.dn") + "," + config.get("ldap.root.dn"));/**/
            options.put("userIdAttribute", "uid");
            options.put("userObjectClass", "caUser");
            options.put("userPasswordAttribute", "userPassword");
            options.put("userRdnAttribute", "cn");

            AppConfigurationEntry cfg = new AppConfigurationEntry("org.eclipse.jetty.jaas.spi.LdapLoginModule", LoginModuleControlFlag.REQUIRED, options);
            return new AppConfigurationEntry[] { cfg };
        }
    };
}

You'll probably have to change the options to match your own ldap. If you compare the above options to the file they're pretty much one on one mappings.

Now to setup a webapp:

Note that I'm starting this class from a folder that is the root of my multiproject folder, the webapps are in subfolders below that root.

Also note that appname must refer to a folder name. The appnames and folder names where they reside are the same in this setup.

private static void startWebApp(BootstrapProperties config, HandlerCollection hc, String contextRoot, String appName) throws Exception {
    boolean isProd = config.getBoolean("isProduction", false);

  // When running a production server you're probably working from warfiles.
  // In dev you're working from eclipse webapp folders (WebContent/webapp/the place where your index.html resides)
    String pathStr = isProd
            ? "dist/webapps/" + appName + ".war"
            : "webapps/" + appName;

    WebAppContext context = new WebAppContext();
    // This is where you can find the webapp on your server http://example.com{/contextRoot}
    context.setContextPath(contextRoot);
    // Optional, but I found it very useful for debugging
    context.addLifeCycleListener(LIFE_CYCLE_LISTENER);

    // Very important if you want JSTL to work, otherwise you get the error:
    // 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
    // This was very hard to figure out!
    context.setAttribute("org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern", ".*/[^/]*jstl.*\\.jar$");

    if (isProd) {
        // Again production server refers to warfile, simple basic function for jetty.
        context.setWar(pathStr);

    } else {
        // Otherwise things get a little more complicated
        // For me the app and classes folders are in two separate places.
        // But fortunately Jetty still supports that.
        Path path = Paths.get(pathStr);
        Path basePath = path.toRealPath();

        // These are folders in your eclipse projects 
        Path appFolder = basePath.resolve("webapp"); // WebContent also often used
        Path classesPath = basePath.resolve("bin/main"); 

        if (Files.exists(appFolder)) {
            context.setBaseResource(new PathResource(appFolder));
            LOGGER.log(Level.FINE, " webapp " + appFolder);
        }
        if (Files.exists(classesPath)) {
            context.setExtraClasspath(classesPath.toString());
            LOGGER.log(Level.FINE, " classes " + classesPath);
        }

        // A pure webapp project without classes works fine classesPath wont exist and is thus not added.
    }

    // Add to the handler context.
    hc.addHandler(context);
}