libraries/http/src/main/java/org/qi4j/library/http/AbstractJettyMixin.java

/*
 * Copyright (c) 2011, Paul Merlin. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package org.qi4j.library.http;

import java.net.InetAddress;
import java.net.UnknownHostException;
import javax.management.MBeanServer;
import javax.servlet.Filter;
import javax.servlet.Servlet;
import javax.servlet.ServletContextListener;
import org.eclipse.jetty.jmx.MBeanContainer;
import org.eclipse.jetty.security.SecurityHandler;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.ErrorHandler;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHandler;
import org.qi4j.api.service.ServiceReference;
import org.qi4j.functional.Iterables;
import org.qi4j.library.http.Interface.Protocol;

import static org.qi4j.library.http.JettyConfigurationHelper.addContextListeners;
import static org.qi4j.library.http.JettyConfigurationHelper.addFilters;
import static org.qi4j.library.http.JettyConfigurationHelper.addServlets;
import static org.qi4j.library.http.JettyConfigurationHelper.configureConnector;
import static org.qi4j.library.http.JettyConfigurationHelper.configureContext;
import static org.qi4j.library.http.JettyConfigurationHelper.configureHttp;
import static org.qi4j.library.http.JettyConfigurationHelper.configureServer;

public abstract class AbstractJettyMixin
    implements HttpService, JettyActivation
{

    private final String identity;

    private final Iterable<ServiceReference<ServletContextListener>> contextListeners;

    private final Iterable<ServiceReference<Servlet>> servlets;

    private final Iterable<ServiceReference<Filter>> filters;

    private final MBeanServer mBeanServer;

    private Server server;

    public AbstractJettyMixin( String identity, Server jettyServer,
                               Iterable<ServiceReference<ServletContextListener>> contextListeners,
                               Iterable<ServiceReference<Servlet>> servlets,
                               Iterable<ServiceReference<Filter>> filters,
                               MBeanServer mBeanServer )
    {
        this.identity = identity;
        this.server = jettyServer;
        this.contextListeners = Iterables.unique( contextListeners );
        this.servlets = Iterables.unique( servlets );
        this.filters = Iterables.unique( filters );
        this.mBeanServer = mBeanServer;
    }

    @Override
    public final void startJetty()
        throws Exception
    {
        // Configure Server
        configureServer( server, configuration() );

        // Set up HTTP
        HttpConfiguration httpConfig = new HttpConfiguration();
        configureHttp( httpConfig, configuration() );
        httpConfig = specializeHttp( httpConfig );

        // Set up connector
        ServerConnector connector = buildConnector( server, httpConfig );
        configureConnector( connector, configuration() );

        // Bind Connector to Server
        server.addConnector( connector );
        if( mBeanServer != null )
        {
            server.addEventListener( new MBeanContainer( mBeanServer ) );
        }

        // Prepare ServletContext
        ServletContextHandler root = new ServletContextHandler( server,
                                                                "/",
                                                                new SessionHandler(),
                                                                buildSecurityHandler(),
                                                                new ServletHandler(),
                                                                new ErrorHandler() );
        root.setDisplayName( identity );
        configureContext( root, configuration() );

        // Register ContextListeners, Servlets and Filters
        addContextListeners( root, contextListeners );
        addServlets( root, servlets );
        addFilters( root, filters );

        // Start
        server.start();
    }

    @Override
    public final void stopJetty()
        throws Exception
    {
        server.stop();
        for( Connector connector : server.getConnectors() )
        {
            connector.stop();
        }
        server = null;
    }

    @Override
    @SuppressWarnings( "ValueOfIncrementOrDecrementUsed" )
    public final Interface[] interfacesServed()
    {
        Connector[] connectors = server.getConnectors();
        Interface[] result = new Interface[ connectors.length ];
        int index = 0;
        for( Connector connector : connectors )
        {
            if( connector instanceof NetworkConnector )
            {
                NetworkConnector netConnector = (NetworkConnector) connector;
                String host = configuration().hostName().get();
                if( host == null )
                {
                    host = netConnector.getHost();
                    if( host == null ) // If serving all interfaces.
                    {
                        try
                        {
                            host = InetAddress.getLocalHost().getHostAddress();
                        }
                        catch( UnknownHostException e )
                        {
                            InternalError error = new InternalError( "UnknownHost for local interface." );
                            error.initCause( e );
                            throw error;
                        }
                    }
                }
                result[ index++] = new InterfaceImpl( host, netConnector.getPort(), servedProtocol() );
            }
        }
        return result;
    }

    protected abstract JettyConfiguration configuration();

    @SuppressWarnings( "NoopMethodInAbstractClass" )
    protected HttpConfiguration specializeHttp( HttpConfiguration httpConfig )
    {
        return httpConfig;
    }

    protected ServerConnector buildConnector( Server server, HttpConfiguration httpConfig )
    {
        return new ServerConnector( server, new HttpConnectionFactory( httpConfig ) );
    }

    protected SecurityHandler buildSecurityHandler()
    {
        return null;
    }

    protected abstract Protocol servedProtocol();

}