io.github.factoryfx.jetty.JettyServerBuilder Maven / Gradle / Ivy

Go to download
package io.github.factoryfx.jetty;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.factoryfx.factory.FactoryBase;
import io.github.factoryfx.factory.builder.MicroserviceBuilder;
import io.github.factoryfx.jetty.ssl.SslContextFactoryFactory;

import javax.servlet.DispatcherType;
import javax.servlet.Servlet;
import javax.ws.rs.ext.ExceptionMapper;
import java.util.ArrayList;
import java.util.zip.Deflater;

/**
 * The builder builds the factory structure for a jetty server not the jetty liveobject

 * The factory structure matches the jetty internal architecture and the JettyServerBuilder creates a default configuration for that.
 * 

 * jetty builder

 * {@literal    =>jetty factories}

 * {@literal           =>real jetty server}

 *
 * @param  server root
 */
public class JettyServerBuilder> {
    public JettyServerFactory jettyServerFactory;
    private final JerseyServletFactory defaultJerseyServlet;
    private final UpdateableServletFactory updateableServletFactory;
    private final ServletAndPathFactory defaultJerseyServletAndPathFactory;
    private final ThreadPoolFactory threadPoolFactory;

    public JettyServerBuilder(){
        this.jettyServerFactory=new JettyServerFactory<>();

        this.threadPoolFactory=new ThreadPoolFactory<>();
        this.threadPoolFactory.poolSize.set(200);
        this.jettyServerFactory.threadPool.set(threadPoolFactory);

        HttpServerConnectorFactory serverConnectorFactory = new HttpServerConnectorFactory<>();
        serverConnectorFactory.host.set("localhost");
        jettyServerFactory.connectors.add(serverConnectorFactory);


        HandlerCollectionFactory handlerCollection = new HandlerCollectionFactory<>();
        jettyServerFactory.handler.set(handlerCollection);

        GzipHandlerFactory gzipHandler = new GzipHandlerFactory<>();
        gzipHandler.minGzipSize.set(0);
        gzipHandler.compressionLevel.set(Deflater.DEFAULT_COMPRESSION);
        gzipHandler.deflaterPoolCapacity.set(-1);
        gzipHandler.dispatcherTypes.add(DispatcherType.REQUEST);
        gzipHandler.inflateBufferSize.set(-1);
        gzipHandler.syncFlush.set(false);
        handlerCollection.handlers.add(gzipHandler);

        ServletContextHandlerFactory servletContextHandlerFactory = new ServletContextHandlerFactory<>();
        handlerCollection.handlers.add(servletContextHandlerFactory);

        updateableServletFactory = new UpdateableServletFactory<>();
        servletContextHandlerFactory.updatableRootServlet.set(updateableServletFactory);

        defaultJerseyServlet = new JerseyServletFactory<>();
        defaultJerseyServlet.objectMapper.set(new DefaultObjectMapperFactory<>());
        defaultJerseyServlet.restLogging.set(new Slf4LoggingFeatureFactory<>());
        defaultJerseyServlet.additionalJaxrsComponents.set(new ArrayList<>());

        defaultJerseyServletAndPathFactory = new ServletAndPathFactory<>();
        defaultJerseyServletAndPathFactory.pathSpec.set("/*");
        defaultJerseyServletAndPathFactory.servlet.set(defaultJerseyServlet);
        updateableServletFactory.servletAndPaths.add(defaultJerseyServletAndPathFactory);
    }

    public > S buildTo(S derivedJettyServerFactory){
        derivedJettyServerFactory.threadPool.set(this.jettyServerFactory.threadPool.get());
        derivedJettyServerFactory.handler.set(this.jettyServerFactory.handler.get());
        derivedJettyServerFactory.connectors.set(this.jettyServerFactory.connectors);
        return derivedJettyServerFactory;
    }

    /** if jettyServerFactory is the root use {@link #buildTo}
     *
     * @return JettyServerFactory
     */
    public JettyServerFactory build(){
        return jettyServerFactory;
    }

    @SuppressWarnings("unchecked")
    public R buildAsRoot(R JettyTestServerFactory){



        return JettyTestServerFactory;
    }

    public JettyServerBuilder withPort(int port){
        jettyServerFactory.connectors.get(0).port.set(port);
        return this;
    }

    public JettyServerBuilder withHost(String host){
        jettyServerFactory.connectors.get(0).host.set(host);
        return this;
    }

    public JettyServerBuilder withHostWildcard(){
        return withHost("0.0.0.0");
    }

    /**
     *  jetty for example picks a free port
     * read port: ((ServerConnector)server.getConnectors()[0]).getLocalPort().
     * @return builder
     */
    public JettyServerBuilder withRandomPort(){
        jettyServerFactory.connectors.get(0).port.set(0);
        return this;
    }

    public JettyServerBuilder withResource(FactoryBase resource){
        if (!updateableServletFactory.servletAndPaths.contains(defaultJerseyServletAndPathFactory)) {
            throw new IllegalStateException("Can't add resource because DefaultJerseyServlet is removed ");
        }
        defaultJerseyServlet.resources.add(resource);
        return this;
    }

    public JettyServerBuilder withAdditionalConnector(HttpServerConnectorFactory httpServerConnectorFactory){
        jettyServerFactory.connectors.add(httpServerConnectorFactory);
        return this;
    }

    /**
     * set the base pathSpec for resources default is: /*
     *
     * @param pathSpec servlet spec path
     * @return builder
     */
    public JettyServerBuilder withResourcePathSpec(String pathSpec){
        defaultJerseyServletAndPathFactory.pathSpec.set(pathSpec);
        return this;
    }

    public JettyServerBuilder withJaxrsComponent(Object jaxrsComponent){
        defaultJerseyServlet.additionalJaxrsComponents.get().add(jaxrsComponent);
        return this;
    }

    public JettyServerBuilder removeDefaultJerseyServlet(){
        if (!defaultJerseyServlet.resources.isEmpty()){
            throw new IllegalStateException("DefaultJerseyServlet cannot be removed if it contains resources");
        }
        updateableServletFactory.servletAndPaths.remove(defaultJerseyServletAndPathFactory);
        return this;
    }

    public JettyServerBuilder withServlet(String pathSpec, FactoryBase servlet){
        ServletAndPathFactory servletAndPathFactory = new ServletAndPathFactory<>();
        servletAndPathFactory.pathSpec.set(pathSpec);
        servletAndPathFactory.servlet.set(servlet);
        updateableServletFactory.servletAndPaths.add(servletAndPathFactory);
        return this;
    }

    public JettyServerBuilder withSsl(SslContextFactoryFactory ssl) {
        jettyServerFactory.connectors.get(0).ssl.set(ssl);
        return this;
    }

    /**
     * default is 200
     * @param size jetty thread pool size
     */
    public void withThreadPoolSize(int size){
        this.threadPoolFactory.poolSize.set(size);
    }

    public JettyServerBuilder withDefaultJerseyObjectMapper(FactoryBase objectMapperFactory){
        defaultJerseyServlet.objectMapper.set(objectMapperFactory);
        return this;
    }

    public JettyServerBuilder withExceptionMapper(ExceptionMapper exceptionMapper) {
        defaultJerseyServlet.exceptionMapper.set(exceptionMapper);
        return this;
    }
}