jetty-ant/src/main/java/org/eclipse/jetty/ant/ServerProxyImpl.java

//
//  ========================================================================
//  Copyright (c) 1995-2012 Sabre Holdings.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//


package org.eclipse.jetty.ant;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jetty.ant.types.Connector;
import org.eclipse.jetty.ant.types.ContextHandlers;
import org.eclipse.jetty.ant.utils.ServerProxy;
import org.eclipse.jetty.ant.utils.TaskLog;
import org.eclipse.jetty.security.LoginService;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.RequestLog;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.ShutdownMonitor;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.server.handler.DefaultHandler;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.RequestLogHandler;
import org.eclipse.jetty.util.Scanner;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.xml.XmlConfiguration;
import org.xml.sax.SAXException;



/**
 * A proxy class for interaction with Jetty server object. Used to have some
 * level of abstraction over standard Jetty classes.
 */
public class ServerProxyImpl implements ServerProxy
{

    /** Proxied Jetty server object. */
    private Server server;
    
    /** Temporary files directory. */
    private File tempDirectory;
    
    /** Collection of context handlers (web application contexts). */
    private ContextHandlerCollection contexts;

    /** Location of jetty.xml file. */
    private File jettyXml;

    /** List of connectors. */
    private List<Connector> connectors;

    /** Request logger. */
    private RequestLog requestLog;

    /** User realms. */
    private List<LoginService> loginServices;

    /** List of added web applications. */
    private List<AntWebAppContext> webApplications = new ArrayList<AntWebAppContext>();

    /** other contexts to deploy */
    private ContextHandlers contextHandlers;

    /** scan interval for changed files */
    private int scanIntervalSecs;

    /** port to listen for stop command */
    private int stopPort;

    /** security key for stop command */
    private String stopKey;

    /** wait for all jetty threads to exit or continue */
    private boolean daemon;


    private boolean configured = false;


    
    /**
     * WebAppScannerListener
     *
     * Handle notifications that files we are interested in have changed
     * during execution.
     * 
     */
    public static class WebAppScannerListener implements Scanner.BulkListener
    {     
        AntWebAppContext awc;

        public WebAppScannerListener (AntWebAppContext awc)
        {
            this.awc = awc;
        }

        public void filesChanged(List<String> changedFileNames)
        {
            boolean isScanned = false;
            try
            {
                Iterator<String> itor = changedFileNames.iterator();
                while (!isScanned && itor.hasNext())
                {
                    isScanned = awc.isScanned(Resource.newResource(itor.next()).getFile());
                }
                if (isScanned)
                {
                    awc.stop();
                    awc.start();
                }
            }
            catch (Exception e)
            {
                TaskLog.log(e.getMessage());
            }
        }

    }


    /**
     * Default constructor. Creates a new Jetty server with a standard connector
     * listening on a given port.
     */
    public ServerProxyImpl ()
    {
        server = new Server();
        server.setStopAtShutdown(true);
    }

   
    public void addWebApplication(AntWebAppContext webApp)
    {
       webApplications.add(webApp);
    }

    public int getStopPort()
    {
        return stopPort;
    }

    public void setStopPort(int stopPort)
    {
        this.stopPort = stopPort;
    }

    public String getStopKey()
    {
        return stopKey;
    }

    public void setStopKey(String stopKey)
    {
        this.stopKey = stopKey;
    }

    public File getJettyXml()
    {
        return jettyXml;
    }

    public void setJettyXml(File jettyXml)
    {
        this.jettyXml = jettyXml;
    }

    public List<Connector> getConnectors()
    {
        return connectors;
    }

    public void setConnectors(List<Connector> connectors)
    {
        this.connectors = connectors;
    }

    public RequestLog getRequestLog()
    {
        return requestLog;
    }

    public void setRequestLog(RequestLog requestLog)
    {
        this.requestLog = requestLog;
    }

    public List<LoginService> getLoginServices()
    {
        return loginServices;
    }

    public void setLoginServices(List<LoginService> loginServices)
    {
        this.loginServices = loginServices;
    }

    public List<AntWebAppContext> getWebApplications()
    {
        return webApplications;
    }

    public void setWebApplications(List<AntWebAppContext> webApplications)
    {
        this.webApplications = webApplications;
    }

    
    public File getTempDirectory()
    {
        return tempDirectory;
    }


    public void setTempDirectory(File tempDirectory)
    {
        this.tempDirectory = tempDirectory;
    }


    /**
     * @see org.eclipse.jetty.ant.utils.ServerProxy#start()
     */
    public void start()
    {
        try
        {
            configure();
            
            configureWebApps();
            
            server.start();
         
            System.setProperty("jetty.ant.server.port","" + ((ServerConnector)server.getConnectors()[0]).getLocalPort());
            
            String host = ((ServerConnector)server.getConnectors()[0]).getHost();
            
            if (host == null)
            {
                System.setProperty("jetty.ant.server.host", "localhost");
            }
            else
            {
                System.setProperty("jetty.ant.server.host", host);
            }
            
            startScanners();
            
            TaskLog.log("Jetty AntTask Started");

            if (!daemon)
                server.join();
        }
        catch (InterruptedException e)
        {
            new RuntimeException(e);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            new RuntimeException(e);
        }
    }



  
    /**
     * @see org.eclipse.jetty.ant.utils.ServerProxy#getProxiedObject()
     */
    public Object getProxiedObject()
    {
        return server;
    }


    /**
     * @return the daemon
     */
    public boolean isDaemon()
    {
        return daemon;
    }


    /**
     * @param daemon the daemon to set
     */
    public void setDaemon(boolean daemon)
    {       
        this.daemon = daemon;
    }


    /**
     * @return the contextHandlers
     */
    public ContextHandlers getContextHandlers()
    {
        return contextHandlers;
    }


    /**
     * @param contextHandlers the contextHandlers to set
     */
    public void setContextHandlers (ContextHandlers contextHandlers)
    {
        this.contextHandlers = contextHandlers;
    }


    public int getScanIntervalSecs()
    {
        return scanIntervalSecs;
    }


    public void setScanIntervalSecs(int scanIntervalSecs)
    {
        this.scanIntervalSecs = scanIntervalSecs;
    }
    

    /**
     * Configures Jetty server before adding any web applications to it.
     */
    private void configure()
    {
        if (configured)
            return;
        
        configured = true;

        if(stopPort>0 && stopKey!=null)
        {
            ShutdownMonitor monitor = ShutdownMonitor.getInstance();
            monitor.setPort(stopPort);
            monitor.setKey(stopKey);
            monitor.setExitVm(false);
        }
        
        if (tempDirectory != null && !tempDirectory.exists())
            tempDirectory.mkdirs();
        
        // Applies external configuration via jetty.xml
        applyJettyXml();

        // Configures connectors for this server instance.
        if (connectors != null)
        {
            for (Connector c:connectors)
            {
                ServerConnector jc = new ServerConnector(server);

                jc.setPort(c.getPort());
                jc.setIdleTimeout(c.getMaxIdleTime());

                server.addConnector(jc);
            }
        }

        // Configures login services
        if (loginServices != null)
        {
            for (LoginService ls:loginServices)
            {
                server.addBean(ls);
            }
        }

        // Does not cache resources, to prevent Windows from locking files
        Resource.setDefaultUseCaches(false);

        // Set default server handlers
        configureHandlers();
    }
    
    
    /**
     * 
     */
    private void configureHandlers()
    {
        RequestLogHandler requestLogHandler = new RequestLogHandler();
        if (requestLog != null)
            requestLogHandler.setRequestLog(requestLog);

        contexts = (ContextHandlerCollection) server
                .getChildHandlerByClass(ContextHandlerCollection.class);
        if (contexts == null)
        {
            contexts = new ContextHandlerCollection();
            HandlerCollection handlers = (HandlerCollection) server
                    .getChildHandlerByClass(HandlerCollection.class);
            if (handlers == null)
            {
                handlers = new HandlerCollection();
                server.setHandler(handlers);
                handlers.setHandlers(new Handler[] { contexts, new DefaultHandler(),
                        requestLogHandler });
            }
            else
            {
                handlers.addHandler(contexts);
            }
        }
        
        //if there are any extra contexts to deploy
        if (contextHandlers != null && contextHandlers.getContextHandlers() != null)
        {
            for (ContextHandler c:contextHandlers.getContextHandlers())
                contexts.addHandler(c);
        }
    }



    
    /**
     * Applies jetty.xml configuration to the Jetty server instance.
     */
    private void applyJettyXml()
    {
        if (jettyXml != null && jettyXml.exists())
        {
            TaskLog.log("Configuring jetty from xml configuration file = "
                    + jettyXml.getAbsolutePath());
            XmlConfiguration configuration;
            try
            {
                configuration = new XmlConfiguration(Resource.toURL(jettyXml));
                configuration.configure(server);
            }
            catch (MalformedURLException e)
            {
                throw new RuntimeException(e);
            }
            catch (SAXException e)
            {
                throw new RuntimeException(e);
            }
            catch (IOException e)
            {
                throw new RuntimeException(e);
            }
            catch (Exception e)
            {
                throw new RuntimeException(e);
            }
        }
    }

    
    /**
     * Starts web applications' scanners.
     */
    private void startScanners() throws Exception
    {
        for (AntWebAppContext awc:webApplications)
        {
            if (scanIntervalSecs <= 0)
                return;

            List<File> scanList = awc.getScanFiles();
 
            TaskLog.log("Web application '" + awc + "': starting scanner at interval of "
                    + scanIntervalSecs + " seconds.");
            Scanner.Listener changeListener = new WebAppScannerListener(awc);
            Scanner scanner = new Scanner();
            scanner.setScanInterval(scanIntervalSecs);
            scanner.addListener(changeListener);
            scanner.setScanDirs(scanList);
            scanner.setReportExistingFilesOnStartup(false);
            scanner.start();
        }  
    }
    
    
    /**
     * 
     */
    private void configureWebApps()
    {
        for (AntWebAppContext awc:webApplications)
        {
            awc.setAttribute(AntWebAppContext.BASETEMPDIR, tempDirectory);
            if (contexts != null)
                contexts.addHandler(awc);
        }
    }
    
}