// ========================================================================
// Copyright (c) 2010-2011 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// 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.overlays;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Timer;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Pattern;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.eclipse.jetty.deploy.App;
import org.eclipse.jetty.deploy.AppProvider;
import org.eclipse.jetty.deploy.ConfigurationManager;
import org.eclipse.jetty.deploy.DeploymentManager;
import org.eclipse.jetty.jndi.java.javaRootURLContext;
import org.eclipse.jetty.jndi.local.localContextRoot;
import org.eclipse.jetty.server.ResourceCache;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.servlet.Holder;
import org.eclipse.jetty.servlet.ServletHandler;
import org.eclipse.jetty.util.IO;
import org.eclipse.jetty.util.Scanner;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.resource.JarResource;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.util.resource.ResourceCollection;
import org.eclipse.jetty.webapp.JettyWebXmlConfiguration;
import org.eclipse.jetty.webapp.WebAppClassLoader;
import org.eclipse.jetty.webapp.WebAppContext;
import org.eclipse.jetty.xml.XmlConfiguration;
import org.xml.sax.SAXException;
/**
* Overlayed AppProvider
* <p>
* This {@link AppProvider} implementation can deploy either {@link WebAppContext}s or plain
* {@link ContextHandler}s that are assembled from a series of overlays:
* <dl>
* <dt>webapp</dt><dd>The webapp overlay is a WAR file or docroot directory. The intent is that
* the WAR should be deployed to this AppProvider unchanged from how it was delivered. All configuration
* and extension should be able to be done in an overlay.</dd>
* <dt>template</dt><dd>A template overlay is applied to a WAR file to configure it for all instances of
* the webapp to be deployed in the server(s)</dd>
* <dt>node</dt><dd>A node overlay is applied to a template to configure it all instances of the template
* with node specific information (eg IP address, DB servers etc.).</dd>
* <dt>instance</dt><dd>An instance overlay is applied to a node and/or template to configure it
* for a specific instance of the template (eg per tenant configuration).</dd>
* </dl>
* <p>
* Each overlays may provide the following files and subdirectories:<dl>
* <dt>WEB-INF/lib-overlay</dt>
* <dd>The lib-overlay directory can contain jars that are applied to a {@link URLClassLoader} that is
* available before any overlay.xml files are executed, so that classes from these jars may be used by the
* overlay.xml.</dd>
*
* <dt>WEB-INF/overlay.xml</dt>
* <dd>This {@link XmlConfiguration} formatted file must exist in the WEB-INF directory of an overlay and is
* used to configure a {@link ContextHandler} or {@link WebAppContext}. The overlay.xml from the template
* overlay can be used to instantiate the ContextHandler instance, so a derived class maybe used.</dd>
*
* <dt>WEB-INF/template.xml</dt>
* <dd>This {@link XmlConfiguration} formatted file if it exists in a template or node overlay, is applied to a shared instance of {@link TemplateContext}.
* Any ID's created in a template are available as ID's in overlay.xml for an instance.</dd>
*
* <dt>WEB-INF/webdefault.xml</dt>
* <dd>If present in an overlay, then the most specific version is passed to
* {@link WebAppContext#setDefaultsDescriptor(String)}. Typically this is set in the template overlay.</dd>
*
* <dt>WEB-INF/web-overlay.xml</dt>
* <dd>The web-overlay.xml file of an overlay is applied to a web application as
* with {@link WebAppContext#addOverrideDescriptor(String)}. This allows incremental changes to web.xml without
* totally replacing it (see webapp). Typically this is used to set init parameters.</dd>
*
* <dt>.</dt>
* <dd>This root directory contains static content that overlays the static content of the webapp
* or earlier overlays. Using this directory, files like index.html or logo.png can be added or replaced. It can
* also be used to replace files within WEB-INF including web.xml classes and libs.</dd>
* </dl>
* <p>
* Any init parameters set on the context, filters or servlets may have parameterized values, with the parameters
* including:
* <dl>
* <dt>${overlays.dir}</dt>
* <dd>the root overlay scan directory as a canonical file name.</dd>
* <dt>${overlay.webapp}</dt>
* <dd>the webapp name, same as {@link Webapp#getName()}.</dd>
* <dt>${overlay.template}</dt>
* <dd>the template name, as {@link Template#getName()}.</dd>
* <dt>${overlay.template.name}</dt>
* <dd>the template classifier, as {@link Template#getTemplateName()}.</dd>
* <dt>${overlay.template.classifier}</dt>
* <dd>the template classifier, as {@link Template#getClassifier()()}.</dd>
* <dt>${overlay.node}</dt>
* <dd>the node name, as {@link Node#getName()}.</dd>
* <dt>${overlay.instance}</dt>
* <dd>the instance name, {@link Instance#getName()}.</dd>
* <dt>${overlay.instance.classifier}</dt>
* <dd>the instance name, {@link Instance#getClassifier()()}.</dd>
* <dt>${*}</dt>
* <dd>Any properties obtained via {@link #getConfigurationManager()}.{@link ConfigurationManager#getProperties()}</dd>
* <dd></dd>
* </dl>
* <p>
* The OverlayedAppProvider will scan the "webapps", "templates", "nodes" and "instances" subdirectories of
* the directory configured with {@link #setScanDir(File)}. New webapps and overlays and modified files within
* the overlays will trigger hot deployment, redeployment or undeployment. The scan for modified files is
* restricted to only top level files (eg overlay.xml) and the files matching WEB-INF/*.xml WEB-INF/lib/*
* and WEB-INF/classes/*. The webapps/overlays may be directory structures or war/jar archives.
* <p>
* The filenames of the templates and instances are used to match them together and with a webapplication.
* A webapp may be named anyway, but it is good practise to include a version number (eg webapps/foo-1.2.3.war
* or webapps/foo-1.2.3/). A template for that webapplication must have a name that includes the template name
* and the war name separated by '=' (eg templates/myFoo=foo-1.2.3.jar or templates/myFoo=foo-1.2.3/).
* An instance overlay is named with the template name and an arbitrary instance name separated by '='
* (eg instances/myFoo=instance1.jar instances/myFoo=instance2/ etc.).
* <p>
* If a template name does not include a webapp name, then the template is created as a ContextHandler
* instead of a WebAppContext (with the exact type being determined by overlay.xml).
*/
public class OverlayedAppProvider extends AbstractLifeCycle implements AppProvider
{
private final static Logger __log=org.eclipse.jetty.util.log.Log.getLogger("OverlayedAppProvider");
/**
* Property set for overlay.xml and template.xml files that gives the root overlay scan directory as a canonical file name.
*/
public final static String OVERLAYS_DIR="overlays.dir";
/**
* Property set for overlay.xml and template.xml files that gives the current webapp name, as {@link Webapp#getName()}.
*/
public final static String OVERLAY_WEBAPP="overlay.webapp";
/**
* Property set for overlay.xml and template.xml files that gives the current template full name, as {@link Template#getName()}.
*/
public final static String OVERLAY_TEMPLATE="overlay.template";
/**
* Property set for overlay.xml and template.xml files that gives the current template name, as {@link Template#getTemplateName()}.
*/
public final static String OVERLAY_TEMPLATE_NAME="overlay.template.name";
/**
* Property set for overlay.xml and template.xml files that gives the current template classifier, as {@link Template#getClassifier()}.
*/
public final static String OVERLAY_TEMPLATE_CLASSIFIER="overlay.template.classifier";
/**
* Property set for overlay.xml and template.xml files that gives the current node name, as {@link Node#getName()}.
*/
public final static String OVERLAY_NODE="overlay.node";
/**
* Property set for overlay.xml and template.xml files that gives the current instance name, {@link Instance#getName()}.
*/
public final static String OVERLAY_INSTANCE="overlay.instance";
/**
* Property set for overlay.xml and template.xml files that gives the current instance clasifier, {@link Instance#getClassifier()}.
*/
public final static String OVERLAY_INSTANCE_CLASSIFIER="overlay.instance.classifier";
public final static String WEBAPPS="webapps";
public final static String TEMPLATES="templates";
public final static String NODES="nodes";
public final static String INSTANCES="instances";
public final static String LIB="WEB-INF/lib-overlay";
public final static String WEBAPP=".";
public final static String OVERLAY_XML="WEB-INF/overlay.xml";
public final static String TEMPLATE_XML="WEB-INF/template.xml";
public final static String WEB_DEFAULT_XML="WEB-INF/web-default.xml";
public final static String WEB_FRAGMENT_XML="WEB-INF/web-overlay.xml";
enum Monitor { WEBAPPS,TEMPLATES,NODES,INSTANCES} ;
public final static List<Pattern> __scanPatterns = new ArrayList<Pattern>();
static
{
List<String> regexes = new ArrayList<String>();
for (String s:new String[] {".war",".jar","/WEB-INF/syslib/[^/]*","/WEB-INF/lib/[^/]*","/WEB-INF/classes/[^/]*","/WEB-INF/[^/]*\\.xml",})
{
regexes.add(WEBAPPS+"/[^/]*"+s);
regexes.add(TEMPLATES+"/[^/]*"+s);
regexes.add(NODES+"/[^/]*"+s);
regexes.add(INSTANCES+"/[^/]*"+s);
}
for (String s: regexes)
__scanPatterns.add(Pattern.compile(s,Pattern.CASE_INSENSITIVE));
};
private String _nodeName;
private File _scanDir;
private File _tmpDir;
private String _scanDirURI;
private long _loading;
private Node _node;
private final Map<String,Webapp> _webapps = new HashMap<String,Webapp>();
private final Map<String,Template> _templates = new HashMap<String,Template>();
private final Map<String,Instance> _instances = new HashMap<String,Instance>();
private final Map<String,OverlayedApp> _deployed = new HashMap<String,OverlayedApp>();
private final Map<String,TemplateContext> _shared = new HashMap<String, TemplateContext>();
private boolean _copydir=false;
private DeploymentManager _deploymentManager;
private ConfigurationManager _configurationManager;
private String _serverID="Server";
private final Set<Layer> _removedLayers = new HashSet<Layer>();
private Timer _sessionScavenger = new Timer();
private final Scanner _scanner = new Scanner();
private final Scanner.BulkListener _listener = new Scanner.BulkListener()
{
public void filesChanged(List<String> filenames) throws Exception
{
__log.debug("Changed {}",filenames);
Set<String> changes = new HashSet<String>();
for (String filename:filenames)
{
File file=new File(filename);
if (file.getName().startsWith(".") || file.getName().endsWith(".swp"))
continue;
String relname=file.toURI().getPath().substring(_scanDirURI.length());
File rel = new File(relname);
String dir=null;
String name=null;
String parent=rel.getParent();
while (parent!=null)
{
name=rel.getName();
dir=parent;
rel=rel.getParentFile();
parent=rel.getParent();
}
String uri=dir+"/"+name;
for (Pattern p : __scanPatterns)
{
if (p.matcher(relname).matches())
{
__log.debug("{} == {}",relname,p.pattern());
changes.add(uri);
}
else
__log.debug("{} != {}",relname,p.pattern());
}
}
if (changes.size()>0)
OverlayedAppProvider.this.updateLayers(changes);
}
};
/* ------------------------------------------------------------ */
public OverlayedAppProvider()
{
try
{
_nodeName=InetAddress.getLocalHost().getHostName();
}
catch(UnknownHostException e)
{
__log.debug(e);
_nodeName="unknown";
}
}
/* ------------------------------------------------------------ */
public void setDeploymentManager(DeploymentManager deploymentManager)
{
_deploymentManager=deploymentManager;
}
/* ------------------------------------------------------------ */
public DeploymentManager getDeploymentManager()
{
return _deploymentManager;
}
/* ------------------------------------------------------------ */
public ConfigurationManager getConfigurationManager()
{
return _configurationManager;
}
/* ------------------------------------------------------------ */
/** Set the configurationManager.
* @param configurationManager the configurationManager to set
*/
public void setConfigurationManager(ConfigurationManager configurationManager)
{
_configurationManager = configurationManager;
}
/* ------------------------------------------------------------ */
/**
* @return The name in {@link XmlConfiguration#getIdMap()} of the {@link Server} instance. Default "Server".
*/
public String getServerID()
{
return _serverID;
}
/* ------------------------------------------------------------ */
/**
* @param serverID The name in {@link XmlConfiguration#getIdMap()} of the {@link Server} instance.
*/
public void setServerID(String serverID)
{
_serverID = serverID;
}
/**
* Create Context Handler.
* <p>
* Callback from the deployment manager to create a context handler instance.
* @see org.eclipse.jetty.deploy.AppProvider#createContextHandler(org.eclipse.jetty.deploy.App)
*/
public synchronized ContextHandler createContextHandler(App app) throws Exception
{
final OverlayedApp overlayed = (OverlayedApp)app;
final String origin = overlayed.getOriginId();
final Instance instance = overlayed.getInstance();
final Template template = instance.getTemplate();
final Webapp webapp = template.getWebapp();
final Node node = _node;
// remember the original loader
ClassLoader orig_loader = Thread.currentThread().getContextClassLoader();
try
{
// Look for existing shared resources
String key=(node==null?"":node.getLoadedKey())+template.getLoadedKey()+(webapp==null?"":webapp.getLoadedKey());
instance.setSharedKey(key);
TemplateContext shared=_shared.get(key);
// Create shared resourced
if (shared==null)
shared=createTemplateContext(key,webapp,template,node,orig_loader);
// Build the instance lib loader
ClassLoader shared_loader = shared.getWebappLoader()!=null?shared.getWebappLoader():(shared.getLibLoader()!=null?shared.getLibLoader():orig_loader);
ClassLoader loader = shared_loader;
Resource instance_lib = instance.getResource(LIB);
if (instance_lib.exists())
{
List<URL> libs = new ArrayList<URL>();
for (String jar :instance_lib.list())
{
if (!jar.toLowerCase().endsWith(".jar"))
continue;
libs.add(instance_lib.addPath(jar).getURL());
}
__log.debug("{}: libs={}",origin,libs);
loader = URLClassLoader.newInstance(libs.toArray(new URL[]{}),loader);
}
// set the thread loader
Thread.currentThread().setContextClassLoader(loader);
// Create properties to be shared by overlay.xmls
Map<String,Object> idMap = new HashMap<String,Object>();
idMap.putAll(shared.getIdMap());
idMap.put(_serverID,getDeploymentManager().getServer());
// Create the instance context for the template
ContextHandler context=null;
Resource template_context_xml = template.getResource(OVERLAY_XML);
if (template_context_xml.exists())
{
__log.debug("{}: overlay.xml={}",origin,template_context_xml);
XmlConfiguration xmlc = newXmlConfiguration(template_context_xml.getURL(),idMap,template,instance);
context=(ContextHandler)xmlc.configure();
idMap=xmlc.getIdMap();
}
else if (webapp==null)
// If there is no webapp, this is a plain context
context=new ContextHandler();
else
// It is a webapp context
context=new WebAppContext();
// Set the resource base
final Resource instance_webapp = instance.getResource(WEBAPP);
if (instance_webapp.exists())
{
context.setBaseResource(new ResourceCollection(instance_webapp,shared.getBaseResource()));
// Create the resource cache
ResourceCache cache = new ResourceCache(shared.getResourceCache(),instance_webapp,context.getMimeTypes());
context.setAttribute(ResourceCache.class.getCanonicalName(),cache);
}
else
{
context.setBaseResource(shared.getBaseResource());
context.setAttribute(ResourceCache.class.getCanonicalName(),shared.getResourceCache());
}
__log.debug("{}: baseResource={}",origin,context.getResourceBase());
// Set the shared session scavenger timer
context.setAttribute("org.eclipse.jetty.server.session.timer", _sessionScavenger);
// Apply any node or instance overlay.xml
for (Resource context_xml : getLayeredResources(OVERLAY_XML,node,instance))
{
__log.debug("{}: overlay.xml={}",origin,context_xml);
XmlConfiguration xmlc = newXmlConfiguration(context_xml.getURL(),idMap,template,instance);
xmlc.getIdMap().put("Cache",context.getAttribute(ResourceCache.class.getCanonicalName()));
xmlc.configure(context);
idMap=xmlc.getIdMap();
}
// Is it a webapp?
if (context instanceof WebAppContext)
{
final WebAppContext webappcontext = (WebAppContext)context;
if (Arrays.asList(((WebAppContext)context).getServerClasses()).toString().equals(Arrays.asList(WebAppContext.__dftServerClasses).toString()))
{
__log.debug("clear server classes");
webappcontext.setServerClasses(null);
}
// set classloader
webappcontext.setCopyWebDir(false);
webappcontext.setCopyWebInf(false);
webappcontext.setExtractWAR(false);
if (instance_webapp.exists())
{
final Resource classes=instance_webapp.addPath("WEB-INF/classes");
final Resource lib=instance_webapp.addPath("WEB-INF/lib");
if (classes.exists()||lib.exists())
{
final AtomicBoolean locked =new AtomicBoolean(false);
WebAppClassLoader webapp_loader=new WebAppClassLoader(loader,webappcontext)
{
@Override
public void addClassPath(Resource resource) throws IOException
{
if (!locked.get())
super.addClassPath(resource);
}
@Override
public void addClassPath(String classPath) throws IOException
{
if (!locked.get())
super.addClassPath(classPath);
}
@Override
public void addJars(Resource lib)
{
if (!locked.get())
super.addJars(lib);
}
};
if (classes.exists())
webapp_loader.addClassPath(classes);
if (lib.exists())
webapp_loader.addJars(lib);
locked.set(true);
loader=webapp_loader;
}
}
// Make sure loader is unique for JNDI
if (loader==shared_loader)
loader = new URLClassLoader(new URL[]{},shared_loader);
// add default descriptor
List<Resource> webdefaults=getLayeredResources(WEB_DEFAULT_XML,instance,node,template);
if (webdefaults.size()>0)
{
Resource webdefault = webdefaults.get(0);
__log.debug("{}: defaultweb={}",origin,webdefault);
webappcontext.setDefaultsDescriptor(webdefault.toString());
}
// add overlay descriptors
for (Resource override : getLayeredResources(WEB_FRAGMENT_XML,template,node,instance))
{
__log.debug("{}: web override={}",origin,override);
webappcontext.addOverrideDescriptor(override.toString());
}
}
context.setClassLoader(loader);
__log.debug("{}: baseResource={}",origin,context.getBaseResource());
Resource jetty_web_xml = context.getResource("/WEB-INF/"+JettyWebXmlConfiguration.JETTY_WEB_XML);
if (jetty_web_xml!=null && jetty_web_xml.exists())
context.setAttribute(JettyWebXmlConfiguration.XML_CONFIGURATION,newXmlConfiguration(jetty_web_xml.getURL(),idMap,template,instance));
// Add listener to expand parameters from descriptors before other listeners execute
Map<String,String> params = new HashMap<String,String>();
populateParameters(params,template,instance);
context.addEventListener(new ParameterExpander(params,context));
System.err.println("created:\n"+context.dump());
return context;
}
finally
{
Thread.currentThread().setContextClassLoader(orig_loader);
}
}
/* ------------------------------------------------------------ */
private XmlConfiguration newXmlConfiguration(URL url, Map<String, Object> idMap, Template template, Instance instance) throws SAXException, IOException
{
XmlConfiguration xmlc = new XmlConfiguration(url);
populateParameters(xmlc.getProperties(),template,instance);
xmlc.getIdMap().putAll(idMap);
return xmlc;
}
/* ------------------------------------------------------------ */
private void populateParameters(Map<String,String> params,Template template, Instance instance)
{
try
{
params.put(OVERLAYS_DIR,_scanDir.getCanonicalPath());
if (template!=null)
{
params.put(OVERLAY_TEMPLATE,template.getName());
params.put(OVERLAY_TEMPLATE_NAME,template.getTemplateName());
params.put(OVERLAY_TEMPLATE_CLASSIFIER,template.getClassifier());
params.put(OVERLAY_WEBAPP,template.getWebapp()==null?null:template.getWebapp().getName());
}
if (_node!=null)
params.put(OVERLAY_NODE,_node.getName());
if (instance!=null)
{
params.put(OVERLAY_INSTANCE,instance.getName());
params.put(OVERLAY_INSTANCE_CLASSIFIER,instance.getClassifier());
}
if (getConfigurationManager()!=null)
params.putAll(getConfigurationManager().getProperties());
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
/* ------------------------------------------------------------ */
private TemplateContext createTemplateContext(final String key, Webapp webapp, Template template, Node node, ClassLoader parent) throws Exception
{
__log.info("created {}",key);
// look for libs
// If we have libs directories, create classloader and make it available to
// the XMLconfiguration
List<URL> libs = new ArrayList<URL>();
for (Resource lib : getLayeredResources(LIB,node,template))
{
for (String jar :lib.list())
{
if (!jar.toLowerCase().endsWith(".jar"))
continue;
libs.add(lib.addPath(jar).getURL());
}
}
final ClassLoader libLoader;
if (libs.size()>0)
{
__log.debug("{}: libs={}",key,libs);
libLoader=new URLClassLoader(libs.toArray(new URL[]{}),parent)
{
public String toString() {return "libLoader@"+Long.toHexString(hashCode())+"-lib-"+key;}
};
}
else
libLoader=parent;
Thread.currentThread().setContextClassLoader(libLoader);
// Make the shared resourceBase
List<Resource> bases = new ArrayList<Resource>();
for (Resource wa : getLayers(node,template))
bases.add(wa);
if (webapp!=null)
bases.add(webapp.getBaseResource());
Resource baseResource = bases.size()==1?bases.get(0):new ResourceCollection(bases.toArray(new Resource[bases.size()]));
__log.debug("{}: baseResource={}",key,baseResource);
// Make the shared context
TemplateContext shared = new TemplateContext(key,getDeploymentManager().getServer(),baseResource,libLoader);
_shared.put(key,shared);
// Create properties to be shared by overlay.xmls
Map<String,Object> idMap = new HashMap<String,Object>();
idMap.put(_serverID,getDeploymentManager().getServer());
// Create the shared context for the template
// This instance will never be start, but is used to capture the
// shared results of running the template and node overlay.xml files.
// If there is a template overlay.xml, give it the chance to create the ContextHandler instance
// otherwise create an instance ourselves
for (Resource template_xml : getLayeredResources(TEMPLATE_XML,template,node))
{
__log.debug("{}: template.xml={}",key,template_xml);
XmlConfiguration xmlc = newXmlConfiguration(template_xml.getURL(),idMap,template,null);
xmlc.getIdMap().putAll(idMap);
xmlc.configure(shared);
idMap=xmlc.getIdMap();
}
shared.setIdMap(idMap);
shared.start();
return shared;
}
/* ------------------------------------------------------------ */
/**
* @return The node name (defaults to hostname)
*/
public String getNodeName()
{
return _nodeName;
}
/* ------------------------------------------------------------ */
/**
* @param nodeName Set the node name
*/
public void setNodeName(String nodeName)
{
_nodeName = nodeName;
}
/* ------------------------------------------------------------ */
/** Get the scanDir.
* @return the scanDir
*/
public File getScanDir()
{
return _scanDir;
}
/* ------------------------------------------------------------ */
/** Set the scanDir.
* @param scanDir the scanDir to set
*/
public void setScanDir(File scanDir)
{
_scanDir = scanDir;
}
/* ------------------------------------------------------------ */
/** Set the temporary directory.
* @param tmpDir the directory for temporary files. If null, then getScanDir()+"/tmp" is used if it exists, else the system default is used.
*/
public void setTmpDir(File tmpDir)
{
_tmpDir=tmpDir;
}
/* ------------------------------------------------------------ */
/** Get the temporary directory.
* return the tmpDir. If null, then getScanDir()+"/tmp" is used if it exists, else the system default is used.
*/
public File getTmpDir()
{
return _tmpDir;
}
/* ------------------------------------------------------------ */
/**
* @return The scan interval
* @see org.eclipse.jetty.util.Scanner#getScanInterval()
*/
public int getScanInterval()
{
return _scanner.getScanInterval();
}
/* ------------------------------------------------------------ */
/**
* @param scanInterval The scan interval
* @see org.eclipse.jetty.util.Scanner#setScanInterval(int)
*/
public void setScanInterval(int scanInterval)
{
_scanner.setScanInterval(scanInterval);
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.util.Scanner#scan()
*/
public void scan()
{
_scanner.scan();
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStart()
*/
@Override
protected void doStart() throws Exception
{
__log.info("Node={} Scan=",_nodeName,_scanDir);
if (_scanDir==null || !_scanDir.exists())
throw new IllegalStateException("!scandir");
_scanDirURI=_scanDir.toURI().getPath();
_scanner.setScanDepth(6); // enough for templates/name/webapps/WEB-INF/lib/foo.jar
List<File> dirs = Arrays.asList(new File[]
{
new File(_scanDir,WEBAPPS),
new File(_scanDir,TEMPLATES),
new File(_scanDir,NODES),
new File(_scanDir,INSTANCES)
});
for (File file : dirs)
{
if (!file.exists() && !file.isDirectory())
__log.warn("No directory: "+file.getAbsolutePath());
}
_scanner.setScanDirs(dirs);
_scanner.addListener(_listener);
_scanner.start();
super.doStart();
}
/* ------------------------------------------------------------ */
/**
* @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStop()
*/
@Override
protected void doStop() throws Exception
{
_scanner.removeListener(_listener);
_scanner.stop();
if (_deploymentManager.isRunning())
{
for (App app: _deployed.values())
_deploymentManager.removeApp(app);
}
_deployed.clear();
for (Layer layer : _webapps.values())
layer.release();
_webapps.clear();
for (Layer layer : _templates.values())
layer.release();
_templates.clear();
if (_node!=null)
_node.release();
for (Layer layer : _instances.values())
layer.release();
_instances.clear();
super.doStop();
}
/* ------------------------------------------------------------ */
protected synchronized void updateLayers(Set<String> layerURIs)
{
_loading=System.currentTimeMillis();
for (String ruri: layerURIs)
{
try
{
// Decompose the name
File directory;
File archive;
File origin = new File(new URI(_scanDir.toURI()+ruri));
String name=origin.getName();
Monitor monitor = Monitor.valueOf(origin.getParentFile().getName().toUpperCase());
String ext=".war";
// check directory vs archive
if (origin.isDirectory() || !origin.exists() && !ruri.toLowerCase().endsWith(ext))
{
// directories have priority over archives
directory=origin;
archive=new File(directory.toString()+ext);
}
else
{
// check extension name
if (!ruri.toLowerCase().endsWith(ext))
continue;
name=name.substring(0,name.length()-4);
archive=origin;
directory=new File(new URI(_scanDir.toURI()+ruri.substring(0,ruri.length()-4)));
// Look to see if directory exists
if (directory.exists())
{
__log.info("Directory exists, ignoring change to {}",ruri);
continue;
}
}
Layer layer=null;
switch(monitor)
{
case WEBAPPS:
if (origin.exists())
layer=loadWebapp(name,origin);
else
{
removeWebapp(name);
if (origin==directory && archive.exists())
layer=loadWebapp(name,archive);
}
break;
case TEMPLATES:
if (origin.exists())
layer=loadTemplate(name,origin);
else
{
removeTemplate(name);
if (origin==directory && archive.exists())
layer=loadTemplate(name,archive);
}
break;
case NODES:
if (name.equalsIgnoreCase(_nodeName))
{
if (origin.exists())
layer=loadNode(origin);
else
{
removeNode();
if (origin==directory && archive.exists())
layer=loadNode(archive);
}
}
break;
case INSTANCES:
if (origin.exists())
layer=loadInstance(name,origin);
else
{
removeInstance(name);
if (origin==directory && archive.exists())
layer=loadInstance(name,archive);
}
break;
}
if (layer!=null)
__log.info("loaded {}",layer.getLoadedKey());
}
catch(Exception e)
{
__log.warn(e);
}
}
redeploy();
// Release removed layers
for (Layer layer : _removedLayers)
{
if (layer!=null)
{
__log.info("unload {}",layer.getLoadedKey());
layer.release();
}
}
_removedLayers.clear();
if (__log.isDebugEnabled())
{
System.err.println("updated:");
System.err.println("java:"+javaRootURLContext.getRoot().dump());
System.err.println("local:"+localContextRoot.getRoot().dump());
if (getDeploymentManager()!=null && getDeploymentManager().getServer()!=null)
System.err.println(getDeploymentManager().getServer().dump());
}
}
/* ------------------------------------------------------------ */
protected File tmpdir(String name,String suffix) throws IOException
{
File dir=_tmpDir;
if (dir==null || !dir.isDirectory() || !dir.canWrite())
{
dir=new File(_scanDir,"tmp");
if (!dir.isDirectory() || !dir.canWrite())
dir=null;
}
File tmp = File.createTempFile(name+"_","."+suffix,dir);
tmp=tmp.getCanonicalFile();
if (tmp.exists())
IO.delete(tmp);
tmp.mkdir();
tmp.deleteOnExit();
return tmp;
}
/* ------------------------------------------------------------ */
/**
* Walks the defined webapps, templates, nodes and instances to
* determine what should be deployed, then adjust reality to match.
*/
protected void redeploy()
{
Map<String,Template> templates = new ConcurrentHashMap<String,Template>();
// Check for duplicate templates
for (Template template : _templates.values())
{
Template other=templates.get(template.getTemplateName());
if (other!=null)
{
__log.warn("Multiple Templates: {} & {}",template.getName(),other.getName());
if (other.getName().compareToIgnoreCase(template.getName())<=0)
continue;
}
templates.put(template.getTemplateName(),template);
}
// Match webapps to templates
for (Template template : templates.values())
{
String webappname=template.getClassifier();
if (webappname==null)
continue;
Webapp webapp = _webapps.get(webappname);
if (webapp==null)
{
__log.warn("No webapp found for template: {}",template.getName());
templates.remove(template.getTemplateName());
}
else
{
template.setWebapp(webapp);
}
}
// Match instance to templates and check if what needs to be deployed or undeployed.
Set<String> deployed = new HashSet<String>();
List<Instance> deploy = new ArrayList<Instance>();
for (Instance instance : _instances.values())
{
Template template=templates.get(instance.getTemplateName());
instance.setTemplate(template);
if (template!=null)
{
String key=instance.getInstanceKey();
App app = _deployed.get(key);
if (app==null)
deploy.add(instance);
else
deployed.add(key);
}
}
// Look for deployed apps that need to be undeployed
List<String> undeploy = new ArrayList<String>();
for (String key : _deployed.keySet())
{
if (!deployed.contains(key))
undeploy.add(key);
}
// Do the undeploys
for (String key : undeploy)
{
App app = _deployed.remove(key);
if (app!=null)
{
__log.info("Undeploy {}",key);
_deploymentManager.removeApp(app);
}
}
// ready the deploys
for (Instance instance : deploy)
{
String key=instance.getInstanceKey();
OverlayedApp app = new OverlayedApp(_deploymentManager,this,key,instance);
_deployed.put(key,app);
}
// Remove unused Shared stuff
Set<String> sharedKeys = new HashSet<String>(_shared.keySet());
for (OverlayedApp app : _deployed.values())
{
Instance instance = app.getInstance();
sharedKeys.remove(instance.getSharedKey());
}
for (String sharedKey: sharedKeys)
{
__log.debug("Remove "+sharedKey);
TemplateContext shared=_shared.remove(sharedKey);
if (shared!=null)
{
try
{
shared.stop();
}
catch(Exception e)
{
__log.warn(e);
}
shared.destroy();
}
}
// Do the deploys
for (Instance instance : deploy)
{
String key=instance.getInstanceKey();
OverlayedApp app = _deployed.get(key);
__log.info("Deploy {}",key);
_deploymentManager.addApp(app);
}
}
/* ------------------------------------------------------------ */
protected void removeInstance(String name)
{
_removedLayers.add(_instances.remove(name));
}
/* ------------------------------------------------------------ */
protected Instance loadInstance(String name, File origin)
throws IOException
{
Instance instance=new Instance(name,origin);
_removedLayers.add(_instances.put(name,instance));
return instance;
}
/* ------------------------------------------------------------ */
protected void removeNode()
{
if (_node!=null)
_removedLayers.add(_node);
_node=null;
}
/* ------------------------------------------------------------ */
protected Node loadNode(File origin)
throws IOException
{
if (_node!=null)
_removedLayers.add(_node);
_node=new Node(_nodeName,origin);
return _node;
}
/* ------------------------------------------------------------ */
protected void removeTemplate(String name)
{
_removedLayers.add(_templates.remove(name));
}
/* ------------------------------------------------------------ */
protected Template loadTemplate(String name, File origin)
throws IOException
{
Template template=new Template(name,origin);
_removedLayers.add(_templates.put(name,template));
return template;
}
protected void removeWebapp(String name)
{
_removedLayers.add(_webapps.remove(name));
}
/* ------------------------------------------------------------ */
protected Webapp loadWebapp(String name, File origin)
throws IOException
{
Webapp webapp = new Webapp(name,origin);
_removedLayers.add(_webapps.put(name,webapp));
return webapp;
}
/* ------------------------------------------------------------ */
private static List<Resource> getLayers(Layer... layers)
{
List<Resource> resources = new ArrayList<Resource>();
for (Layer layer: layers)
{
if (layer==null)
continue;
Resource resource = layer.getBaseResource();
if (resource.exists())
resources.add(resource);
}
return resources;
}
/* ------------------------------------------------------------ */
private static List<Resource> getLayeredResources(String path, Layer... layers)
{
List<Resource> resources = new ArrayList<Resource>();
for (Layer layer: layers)
{
if (layer==null)
continue;
Resource resource = layer.getResource(path);
if (resource.exists())
resources.add(resource);
}
return resources;
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
class Layer
{
private final String _name;
private final File _origin;
private final long _loaded=_loading;
private final Resource _resourceBase;
private final boolean _resourceBaseIsCopy;
public Layer(String name, File origin)
throws IOException
{
super();
_name = name;
_origin = origin;
Resource resource = Resource.newResource(origin.toURI());
if (resource.isDirectory())
{
if (_copydir)
{
File tmp=tmpdir(name,"extract");
__log.info("Extract {} to {}",origin,tmp);
IO.copyDir(origin,tmp);
_resourceBase=Resource.newResource(tmp.toURI());
_resourceBaseIsCopy=true;
}
else
{
_resourceBase=resource;
_resourceBaseIsCopy=false;
}
}
else
{
Resource jar = JarResource.newJarResource(resource);
File tmp=tmpdir(name,"extract");
__log.info("Extract {} to {}",jar,tmp);
jar.copyTo(tmp);
_resourceBase=Resource.newResource(tmp.toURI());
_resourceBaseIsCopy=true;
}
}
public String getName()
{
return _name;
}
public File getOrigin()
{
return _origin;
}
public long getLoaded()
{
return _loaded;
}
public Resource getBaseResource()
{
return _resourceBase;
}
public Resource getResource(String path)
{
try
{
return getBaseResource().addPath(path);
}
catch(Exception e)
{
__log.warn(e);
}
return null;
}
public String getLoadedKey()
{
return _name+"@"+_loaded;
}
public void release()
{
if (_resourceBaseIsCopy)
{
try
{
File file = _resourceBase.getFile();
if (file!=null)
IO.delete(file);
}
catch(Exception e)
{
__log.warn(e);
}
}
}
public String toString()
{
return getLoadedKey();
}
}
class Webapp extends Layer
{
public Webapp(String name, File origin) throws IOException
{
super(name,origin);
}
}
class Overlay extends Layer
{
public Overlay(String name, File origin) throws IOException
{
super(name,origin);
}
public Resource getContext()
{
return getResource(OVERLAY_XML);
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
class Node extends Overlay
{
public Node(String name, File origin) throws IOException
{
super(name,origin);
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
class ClassifiedOverlay extends Overlay
{
private final String _templateName;
private final String _classifier;
public ClassifiedOverlay(String name, File origin) throws IOException
{
super(name,origin);
int l=1;
int e=name.indexOf('=');
if (e<0)
{
l=2;
e=name.indexOf("--");
}
_templateName=e>=0?name.substring(0,e):name;
_classifier=e>=0?name.substring(e+l):null;
}
public String getTemplateName()
{
return _templateName;
}
public String getClassifier()
{
return _classifier;
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
class Template extends ClassifiedOverlay
{
private Webapp _webapp;
public Webapp getWebapp()
{
return _webapp;
}
public void setWebapp(Webapp webapp)
{
_webapp = webapp;
}
public Template(String name, File origin) throws IOException
{
super(name,origin);
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
class Instance extends ClassifiedOverlay
{
Template _template;
String _sharedKey;
public Instance(String name, File origin) throws IOException
{
super(name,origin);
if (getClassifier()==null)
throw new IllegalArgumentException("Instance without '=':"+name);
}
public void setSharedKey(String key)
{
_sharedKey=key;
}
public String getSharedKey()
{
return _sharedKey;
}
public void setTemplate(Template template)
{
_template=template;
}
public Template getTemplate()
{
return _template;
}
public String getInstanceKey()
{
return
(_template.getWebapp()==null?"":_template.getWebapp().getLoadedKey())+"|"+
_template.getLoadedKey()+"|"+
(_node==null?"":_node.getLoadedKey())+"|"+
getLoadedKey();
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
static class OverlayedApp extends App
{
final Instance _instance;
public OverlayedApp(DeploymentManager manager, AppProvider provider, String originId, Instance instance)
{
super(manager,provider,originId);
_instance=instance;
}
public Instance getInstance()
{
return _instance;
}
}
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
/* ------------------------------------------------------------ */
private final class ParameterExpander implements ServletContextListener
{
private final Map<String, String> _params;
private final ContextHandler _ctx;
private ParameterExpander(Map<String, String> params, ContextHandler ctx)
{
_params = params;
_ctx = ctx;
}
public void contextInitialized(ServletContextEvent sce)
{
Enumeration<String> e=_ctx.getInitParameterNames();
while (e.hasMoreElements())
{
String name = e.nextElement();
_ctx.setInitParameter(name,expandParameter(_ctx.getInitParameter(name)));
}
ServletHandler servletHandler = _ctx.getChildHandlerByClass(ServletHandler.class);
if (servletHandler!=null)
{
List<Holder<?>> holders = new ArrayList<Holder<?>>();
if (servletHandler.getFilters()!=null)
holders.addAll(Arrays.asList(servletHandler.getFilters()));
if (servletHandler.getHandler()!=null)
holders.addAll(Arrays.asList(servletHandler.getServlets()));
for (Holder<?> holder: holders)
{
e=holder.getInitParameterNames();
while (e.hasMoreElements())
{
String name = e.nextElement();
holder.setInitParameter(name,expandParameter(holder.getInitParameter(name)));
}
}
}
}
private String expandParameter(String value)
{
int i=0;
while (true)
{
int open=value.indexOf("${",i);
if (open<0)
return value;
int close=value.indexOf("}",open);
if (close<0)
return value;
String param = value.substring(open+2,close);
if (_params.containsKey(param))
{
String tmp=value.substring(0,open)+_params.get(param);
i=tmp.length();
value=tmp+value.substring(close+1);
}
else
i=close+1;
}
}
public void contextDestroyed(ServletContextEvent sce)
{
}
}
}