Examples with GzipHandler org.eclipse.jetty.server.handler.gzip.GzipHandler used on opensource projects

Example 31 with GzipHandler

use of org.eclipse.jetty.server.handler.gzip.GzipHandler in project structr by structr.

the class HttpService method initialize.

@Override
public boolean initialize(final StructrServices services) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    final LicenseManager licenseManager = services.getLicenseManager();
    final boolean isTest = Services.isTesting();
    String sourceJarName = getClass().getProtectionDomain().getCodeSource().getLocation().toString();
    if (!isTest && StringUtils.stripEnd(sourceJarName, System.getProperty("file.separator")).endsWith("classes")) {
        String jarFile = System.getProperty("jarFile");
        if (StringUtils.isEmpty(jarFile)) {
            throw new IllegalArgumentException(getClass().getName() + " was started in an environment where the classloader cannot determine the JAR file containing the main class.\n" + "Please specify the path to the JAR file in the parameter -DjarFile.\n" + "Example: -DjarFile=${project.build.directory}/${project.artifactId}-${project.version}.jar");
        }
        sourceJarName = jarFile;
    }
    // load configuration from properties file
    maxIdleTime = Services.parseInt(System.getProperty("maxIdleTime"), 30000);
    requestHeaderSize = Services.parseInt(System.getProperty("requestHeaderSize"), 8192);
    if (Settings.Async.getValue()) {
        logger.info("Running in asynchronous mode");
    }
    // other properties
    final String keyStorePath = Settings.KeystorePath.getValue();
    final String keyStorePassword = Settings.KeystorePassword.getValue();
    final String contextPath = System.getProperty("contextPath", "/");
    final boolean enableHttps = Settings.HttpsEnabled.getValue();
    final boolean enableGzipCompression = Settings.GzipCompression.getValue();
    final boolean logRequests = Settings.RequestLogging.getValue();
    final String logPrefix = Settings.LogPrefix.getValue();
    final String host = Settings.ApplicationHost.getValue();
    final int httpsPort = Settings.HttpsPort.getValue();
    boolean enableRewriteFilter = true;
    // get current base path
    String basePath = System.getProperty("home", Settings.getBasePath());
    if (StringUtils.isEmpty(basePath)) {
        // use cwd and, if that fails, /tmp as a fallback
        basePath = System.getProperty("user.dir", "/tmp");
    }
    // create base directory if it does not exist
    final File baseDir = new File(basePath);
    if (!baseDir.exists()) {
        baseDir.mkdirs();
    }
    server = new Server(Settings.HttpPort.getValue());
    final ContextHandlerCollection contexts = new ContextHandlerCollection();
    contexts.addHandler(new DefaultHandler());
    final ServletContextHandler servletContext = new ServletContextHandler(server, contextPath, true, true);
    if (enableGzipCompression) {
        gzipHandler = new GzipHandler();
        gzipHandler.setIncludedMimeTypes("text/html", "text/plain", "text/css", "text/javascript", "application/json");
        gzipHandler.setInflateBufferSize(32768);
        gzipHandler.setMinGzipSize(256);
        gzipHandler.setCompressionLevel(9);
        gzipHandler.setIncludedMethods("GET", "POST", "PUT", "HEAD", "DELETE");
        gzipHandler.addIncludedPaths("/*");
        gzipHandler.setDispatcherTypes(EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC));
    }
    servletContext.setGzipHandler(gzipHandler);
    final List<Connector> connectors = new LinkedList<>();
    // create resource collection from base path & source JAR
    try {
        servletContext.setBaseResource(new ResourceCollection(Resource.newResource(basePath), JarResource.newJarResource(Resource.newResource(sourceJarName))));
    } catch (Throwable t) {
        logger.warn("Base resource {} not usable: {}", new Object[] { basePath, t.getMessage() });
    }
    // this is needed for the filters to work on the root context "/"
    servletContext.addServlet("org.eclipse.jetty.servlet.DefaultServlet", "/");
    servletContext.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
    if (Settings.ConfigServletEnabled.getValue()) {
        // configuration wizard entry point
        servletContext.addServlet("org.structr.rest.servlet.ConfigServlet", "/structr/config/*");
    }
    // CMIS setup
    if (Settings.CmisEnabled.getValue() && (licenseManager == null || licenseManager.isModuleLicensed("cmis"))) {
        try {
            servletContext.addEventListener(new CmisRepositoryContextListener());
            final ServletHolder cmisAtomHolder = servletContext.addServlet(CmisAtomPubServlet.class.getName(), "/structr/cmis/atom/*");
            cmisAtomHolder.setInitParameter("callContextHandler", BasicAuthCallContextHandler.class.getName());
            cmisAtomHolder.setInitParameter("cmisVersion", "1.1");
            final ServletHolder cmisBrowserHolder = servletContext.addServlet(CmisBrowserBindingServlet.class.getName(), "/structr/cmis/browser/*");
            cmisBrowserHolder.setInitParameter("callContextHandler", BasicAuthCallContextHandler.class.getName());
            cmisBrowserHolder.setInitParameter("cmisVersion", "1.1");
        } catch (Throwable t) {
            logger.warn("Cannot initialize CMIS servlet", t);
        }
    }
    sessionCache = new DefaultSessionCache(servletContext.getSessionHandler());
    if (licenseManager != null) {
        final String hardwareId = licenseManager.getHardwareFingerprint();
        DefaultSessionIdManager idManager = new DefaultSessionIdManager(server);
        idManager.setWorkerName(hardwareId);
        sessionCache.getSessionHandler().setSessionIdManager(idManager);
    }
    final StructrSessionDataStore sessionDataStore = new StructrSessionDataStore();
    // sessionDataStore.setSavePeriodSec(60);
    sessionCache.setSessionDataStore(sessionDataStore);
    // sessionCache.setSaveOnCreate(true);
    sessionCache.setSaveOnInactiveEviction(false);
    sessionCache.setRemoveUnloadableSessions(true);
    servletContext.getSessionHandler().setSessionCache(sessionCache);
    if (enableRewriteFilter) {
        final FilterHolder rewriteFilter = new FilterHolder(UrlRewriteFilter.class);
        rewriteFilter.setInitParameter("confPath", "urlrewrite.xml");
        servletContext.addFilter(rewriteFilter, "/*", EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC));
    }
    contexts.addHandler(servletContext);
    // enable request logging
    if (logRequests) {
        final String etcPath = basePath + "/etc";
        final File etcDir = new File(etcPath);
        if (!etcDir.exists()) {
            etcDir.mkdir();
        }
        final String logbackConfFilePath = basePath + "/etc/logback-access.xml";
        final File logbackConfFile = new File(logbackConfFilePath);
        if (!logbackConfFile.exists()) {
            // synthesize a logback accees log config file
            List<String> config = new LinkedList<>();
            config.add("<configuration>");
            config.add("  <appender name=\"FILE\" class=\"ch.qos.logback.core.rolling.RollingFileAppender\">");
            config.add("    <rollingPolicy class=\"ch.qos.logback.core.rolling.TimeBasedRollingPolicy\">");
            config.add("      <fileNamePattern>logs/" + logPrefix + "-%d{yyyy_MM_dd}.request.log.zip</fileNamePattern>");
            config.add("    </rollingPolicy>");
            config.add("    <encoder>");
            config.add("      <charset>UTF-8</charset>");
            config.add("      <pattern>%h %l %u %t \"%r\" %s %b %n%fullRequest%n%n%fullResponse</pattern>");
            config.add("    </encoder>");
            config.add("  </appender>");
            config.add("  <appender-ref ref=\"FILE\" />");
            config.add("</configuration>");
            try {
                logbackConfFile.createNewFile();
                FileUtils.writeLines(logbackConfFile, "UTF-8", config);
            } catch (IOException ioex) {
                logger.warn("Unable to write logback configuration.", ioex);
            }
        }
        final FilterHolder loggingFilter = new FilterHolder(TeeFilter.class);
        servletContext.addFilter(loggingFilter, "/*", EnumSet.of(DispatcherType.REQUEST, Settings.Async.getValue() ? DispatcherType.ASYNC : DispatcherType.FORWARD));
        loggingFilter.setInitParameter("includes", "");
        final RequestLogHandler requestLogHandler = new RequestLogHandler();
        final String logPath = basePath + "/logs";
        final File logDir = new File(logPath);
        // Create logs directory if not existing
        if (!logDir.exists()) {
            logDir.mkdir();
        }
        final RequestLogImpl requestLog = new RequestLogImpl();
        requestLog.setName("REQUESTLOG");
        requestLog.start();
        requestLogHandler.setRequestLog(requestLog);
        final HandlerCollection handlers = new HandlerCollection();
        handlers.setHandlers(new Handler[] { contexts, requestLogHandler });
        server.setHandler(handlers);
    } else {
        server.setHandler(contexts);
    }
    final List<ContextHandler> resourceHandler = collectResourceHandlers();
    for (ContextHandler contextHandler : resourceHandler) {
        contexts.addHandler(contextHandler);
    }
    final Map<String, ServletHolder> servlets = collectServlets(licenseManager);
    // add servlet elements
    int position = 1;
    for (Map.Entry<String, ServletHolder> servlet : servlets.entrySet()) {
        final ServletHolder servletHolder = servlet.getValue();
        final String path = servlet.getKey();
        servletHolder.setInitOrder(position++);
        logger.info("Adding servlet {} for {}", new Object[] { servletHolder, path });
        servletContext.addServlet(servletHolder, path);
    }
    contexts.addHandler(servletContext);
    if (StringUtils.isNotBlank(host) && Settings.HttpPort.getValue() > -1) {
        httpConfig = new HttpConfiguration();
        httpConfig.setSecureScheme("https");
        httpConfig.setSecurePort(httpsPort);
        // httpConfig.setOutputBufferSize(8192);
        httpConfig.setRequestHeaderSize(requestHeaderSize);
        final ServerConnector httpConnector = new ServerConnector(server, new HttpConnectionFactory(httpConfig));
        httpConnector.setHost(host);
        httpConnector.setPort(Settings.HttpPort.getValue());
        connectors.add(httpConnector);
    } else {
        logger.warn("Unable to configure HTTP server port, please make sure that {} and {} are set correctly in structr.conf.", Settings.ApplicationHost.getKey(), Settings.HttpPort.getKey());
    }
    if (enableHttps) {
        if (httpsPort > -1 && keyStorePath != null && !keyStorePath.isEmpty() && keyStorePassword != null) {
            httpsConfig = new HttpConfiguration(httpConfig);
            httpsConfig.addCustomizer(new SecureRequestCustomizer());
            final SslContextFactory sslContextFactory = new SslContextFactory();
            sslContextFactory.setKeyStorePath(keyStorePath);
            sslContextFactory.setKeyStorePassword(keyStorePassword);
            final ServerConnector https = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig));
            https.setPort(httpsPort);
            https.setIdleTimeout(500000);
            https.setHost(host);
            https.setPort(httpsPort);
            connectors.add(https);
        } else {
            logger.warn("Unable to configure SSL, please make sure that {}, {} and {} are set correctly in structr.conf.", new Object[] { Settings.HttpsPort.getKey(), Settings.KeystorePath.getKey(), Settings.KeystorePassword.getKey() });
        }
    }
    if (!connectors.isEmpty()) {
        server.setConnectors(connectors.toArray(new Connector[0]));
    } else {
        logger.error("No connectors configured, aborting.");
        System.exit(0);
    }
    server.setStopTimeout(1000);
    server.setStopAtShutdown(true);
    return true;
}

Example 32 with GzipHandler

use of org.eclipse.jetty.server.handler.gzip.GzipHandler in project Openfire by igniterealtime.

the class HttpBindManager method createBoshHandler.

/**
 * Creates a Jetty context handler that can be used to expose BOSH (HTTP-Bind) functionality.
 *
 * Note that an invocation of this method will not register the handler (and thus make the related functionality
 * available to the end user). Instead, the created handler is returned by this method, and will need to be
 * registered with the embedded Jetty webserver by the caller.
 *
 * @return A Jetty context handler (never null).
 */
protected Handler createBoshHandler() {
    final int options;
    if (isHttpCompressionEnabled()) {
        options = ServletContextHandler.SESSIONS | ServletContextHandler.GZIP;
    } else {
        options = ServletContextHandler.SESSIONS;
    }
    final ServletContextHandler context = new ServletContextHandler(null, "/http-bind", options);
    // Ensure the JSP engine is initialized correctly (in order to be able to cope with Tomcat/Jasper precompiled JSPs).
    final List<ContainerInitializer> initializers = new ArrayList<>();
    initializers.add(new ContainerInitializer(new JasperInitializer(), null));
    context.setAttribute("org.eclipse.jetty.containerInitializers", initializers);
    context.setAttribute(InstanceManager.class.getName(), new SimpleInstanceManager());
    // Generic configuration of the context.
    context.setAllowNullPathInfo(true);
    // Add the functionality-providers.
    context.addServlet(new ServletHolder(new HttpBindServlet()), "/*");
    // Add compression filter when needed.
    if (isHttpCompressionEnabled()) {
        final GzipHandler gzipHandler = context.getGzipHandler();
        gzipHandler.addIncludedPaths("/*");
        gzipHandler.addIncludedMethods(HttpMethod.POST.asString());
    }
    return context;
}