//
// ========================================================================
// Copyright (c) 1995-2014 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.deploy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import org.eclipse.jetty.deploy.bindings.StandardDeployer;
import org.eclipse.jetty.deploy.bindings.StandardStarter;
import org.eclipse.jetty.deploy.bindings.StandardStopper;
import org.eclipse.jetty.deploy.bindings.StandardUndeployer;
import org.eclipse.jetty.deploy.graph.Edge;
import org.eclipse.jetty.deploy.graph.Node;
import org.eclipse.jetty.deploy.graph.Path;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.util.AttributesMap;
import org.eclipse.jetty.util.annotation.ManagedAttribute;
import org.eclipse.jetty.util.annotation.ManagedObject;
import org.eclipse.jetty.util.annotation.ManagedOperation;
import org.eclipse.jetty.util.annotation.Name;
import org.eclipse.jetty.util.component.ContainerLifeCycle;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
/**
* The Deployment Manager.
* <p>
* Responsibilities:
* <p>
* <img src="doc-files/DeploymentManager_Roles.png">
* <ol>
* <li>Tracking Apps and their LifeCycle Location</li>
* <li>Managing AppProviders and the Apps that they provide.</li>
* <li>Executing AppLifeCycle on App based on current and desired LifeCycle Location.</li>
* </ol>
* <p>
* <img src="doc-files/DeploymentManager.png">
*/
@ManagedObject("Deployment Manager")
public class DeploymentManager extends ContainerLifeCycle
{
private static final Logger LOG = Log.getLogger(DeploymentManager.class);
/**
* Represents a single tracked app within the deployment manager.
*/
public class AppEntry
{
/**
* Version of the app.
*
* Note: Auto-increments on each {@link DeploymentManager#addApp(App)}
*/
private int version;
/**
* The app being tracked.
*/
private App app;
/**
* The lifecycle node location of this App
*/
private Node lifecyleNode;
/**
* Tracking the various AppState timestamps (in system milliseconds)
*/
private Map<Node, Long> stateTimestamps = new HashMap<Node, Long>();
public App getApp()
{
return app;
}
public Node getLifecyleNode()
{
return lifecyleNode;
}
public Map<Node, Long> getStateTimestamps()
{
return stateTimestamps;
}
public int getVersion()
{
return version;
}
void setLifeCycleNode(Node node)
{
this.lifecyleNode = node;
this.stateTimestamps.put(node,Long.valueOf(System.currentTimeMillis()));
}
}
private final List<AppProvider> _providers = new ArrayList<AppProvider>();
private final AppLifeCycle _lifecycle = new AppLifeCycle();
private final Queue<AppEntry> _apps = new ConcurrentLinkedQueue<AppEntry>();
private AttributesMap _contextAttributes = new AttributesMap();
private ContextHandlerCollection _contexts;
private boolean _useStandardBindings = true;
private String _defaultLifeCycleGoal = AppLifeCycle.STARTED;
/**
* Receive an app for processing.
*
* Most commonly used by the various {@link AppProvider} implementations.
*/
public void addApp(App app)
{
LOG.debug("Deployable added: {}",app.getOriginId());
AppEntry entry = new AppEntry();
entry.app = app;
entry.setLifeCycleNode(_lifecycle.getNodeByName("undeployed"));
_apps.add(entry);
if (isRunning() && _defaultLifeCycleGoal != null)
{
// Immediately attempt to go to default lifecycle state
this.requestAppGoal(entry,_defaultLifeCycleGoal);
}
}
/* ------------------------------------------------------------ */
/** Set the AppProviders.
* The providers passed are added via {@link #addBean(Object)} so that
* their lifecycles may be managed as a {@link ContainerLifeCycle}.
* @param providers
*/
public void setAppProviders(Collection<AppProvider> providers)
{
if (isRunning())
throw new IllegalStateException();
_providers.clear();
removeBeans();
for (AppProvider provider:providers)
if (_providers.add(provider))
addBean(provider);
}
@ManagedAttribute("Application Providers")
public Collection<AppProvider> getAppProviders()
{
return Collections.unmodifiableList(_providers);
}
public void addAppProvider(AppProvider provider)
{
if (isRunning())
throw new IllegalStateException();
_providers.add(provider);
addBean(provider);
}
public void setLifeCycleBindings(Collection<AppLifeCycle.Binding> bindings)
{
if (isRunning())
throw new IllegalStateException();
for (AppLifeCycle.Binding b : _lifecycle.getBindings())
_lifecycle.removeBinding(b);
for (AppLifeCycle.Binding b : bindings)
_lifecycle.addBinding(b);
}
public Collection<AppLifeCycle.Binding> getLifeCycleBindings()
{
return Collections.unmodifiableSet(_lifecycle.getBindings());
}
public void addLifeCycleBinding(AppLifeCycle.Binding binding)
{
_lifecycle.addBinding(binding);
}
/**
* Convenience method to allow for insertion of nodes into the lifecycle.
*
* @param existingFromNodeName
* @param existingToNodeName
* @param insertedNodeName
*/
public void insertLifeCycleNode(String existingFromNodeName, String existingToNodeName, String insertedNodeName)
{
Node fromNode = _lifecycle.getNodeByName(existingFromNodeName);
Node toNode = _lifecycle.getNodeByName(existingToNodeName);
Edge edge = new Edge(fromNode,toNode);
_lifecycle.insertNode(edge,insertedNodeName);
}
@Override
protected void doStart() throws Exception
{
if (getContexts()==null)
throw new IllegalStateException("No Contexts");
if (_useStandardBindings)
{
LOG.debug("DeploymentManager using standard bindings");
addLifeCycleBinding(new StandardDeployer());
addLifeCycleBinding(new StandardStarter());
addLifeCycleBinding(new StandardStopper());
addLifeCycleBinding(new StandardUndeployer());
}
// Start all of the AppProviders
for (AppProvider provider : _providers)
{
startAppProvider(provider);
}
super.doStart();
}
@Override
protected void doStop() throws Exception
{
// Stop all of the AppProviders
for (AppProvider provider : _providers)
{
try
{
provider.stop();
}
catch (Exception e)
{
LOG.warn("Unable to start AppProvider",e);
}
}
super.doStop();
}
private AppEntry findAppByOriginId(String originId)
{
if (originId == null)
{
return null;
}
for (AppEntry entry : _apps)
{
if (originId.equals(entry.app.getOriginId()))
{
return entry;
}
}
return null;
}
public App getAppByOriginId(String originId)
{
AppEntry entry = findAppByOriginId(originId);
if (entry == null)
{
return null;
}
return entry.app;
}
public Collection<AppEntry> getAppEntries()
{
return _apps;
}
@ManagedAttribute("Deployed Apps")
public Collection<App> getApps()
{
List<App> ret = new ArrayList<App>();
for (AppEntry entry : _apps)
{
ret.add(entry.app);
}
return ret;
}
/**
* Get Set of {@link App}s by {@link Node}
*
* @param node
* the node to look for.
* @return the collection of apps for the node
*/
public Collection<App> getApps(Node node)
{
List<App> ret = new ArrayList<App>();
for (AppEntry entry : _apps)
{
if (entry.lifecyleNode == node)
{
ret.add(entry.app);
}
}
return ret;
}
public List<App> getAppsWithSameContext(App app)
{
List<App> ret = new ArrayList<App>();
if (app == null)
{
return ret;
}
String contextId = app.getContextPath();
if (contextId == null)
{
// No context? Likely not deployed or started yet.
return ret;
}
for (AppEntry entry : _apps)
{
if (entry.app.equals(app))
{
// Its the input app. skip it.
// TODO: is this filter needed?
continue;
}
if (contextId.equals(entry.app.getContextPath()))
{
ret.add(entry.app);
}
}
return ret;
}
/**
* Get a contextAttribute that will be set for every Context deployed by this provider.
*
* @param name
* @return the context attribute value
*/
public Object getContextAttribute(String name)
{
return _contextAttributes.getAttribute(name);
}
public AttributesMap getContextAttributes()
{
return _contextAttributes;
}
@ManagedAttribute("Deployed Contexts")
public ContextHandlerCollection getContexts()
{
return _contexts;
}
public String getDefaultLifeCycleGoal()
{
return _defaultLifeCycleGoal;
}
public AppLifeCycle getLifeCycle()
{
return _lifecycle;
}
public Server getServer()
{
if (_contexts == null)
{
return null;
}
return _contexts.getServer();
}
/**
* Remove the app from the tracking of the DeploymentManager
*
* @param app
* if the app is Unavailable remove it from the deployment manager.
*/
public void removeApp(App app)
{
Iterator<AppEntry> it = _apps.iterator();
while (it.hasNext())
{
AppEntry entry = it.next();
if (entry.app.equals(app))
{
if (! AppLifeCycle.UNDEPLOYED.equals(entry.lifecyleNode.getName()))
requestAppGoal(entry.app,AppLifeCycle.UNDEPLOYED);
it.remove();
LOG.debug("Deployable removed: {}",entry.app);
}
}
}
public void removeAppProvider(AppProvider provider)
{
if(_providers.remove(provider))
removeBean(provider);
try
{
provider.stop();
}
catch (Exception e)
{
LOG.warn("Unable to stop Provider",e);
}
}
/**
* Remove a contextAttribute that will be set for every Context deployed by this provider.
*
* @param name
*/
public void removeContextAttribute(String name)
{
_contextAttributes.removeAttribute(name);
}
/**
* Move an {@link App} through the {@link AppLifeCycle} to the desired {@link Node}, executing each lifecycle step
* in the process to reach the desired state.
*
* @param app
* the app to move through the process
* @param nodeName
* the name of the node to attain
*/
public void requestAppGoal(App app, String nodeName)
{
AppEntry appentry = findAppByOriginId(app.getOriginId());
if (appentry == null)
{
throw new IllegalStateException("App not being tracked by Deployment Manager: " + app);
}
requestAppGoal(appentry,nodeName);
}
/**
* Move an {@link App} through the {@link AppLifeCycle} to the desired {@link Node}, executing each lifecycle step
* in the process to reach the desired state.
*
* @param appentry
* the internal appentry to move through the process
* @param nodeName
* the name of the node to attain
*/
private void requestAppGoal(AppEntry appentry, String nodeName)
{
Node destinationNode = _lifecycle.getNodeByName(nodeName);
if (destinationNode == null)
{
throw new IllegalStateException("Node not present in Deployment Manager: " + nodeName);
}
// Compute lifecycle steps
Path path = _lifecycle.getPath(appentry.lifecyleNode,destinationNode);
if (path.isEmpty())
{
// nothing to do. already there.
return;
}
// Execute each Node binding. Stopping at any thrown exception.
try
{
Iterator<Node> it = path.getNodes().iterator();
if (it.hasNext()) // Any entries?
{
// The first entry in the path is always the start node
// We don't want to run bindings on that entry (again)
it.next(); // skip first entry
while (it.hasNext())
{
Node node = it.next();
LOG.debug("Executing Node {}",node);
_lifecycle.runBindings(node,appentry.app,this);
appentry.setLifeCycleNode(node);
}
}
}
catch (Throwable t)
{
LOG.warn("Unable to reach node goal: " + nodeName,t);
}
}
/**
* Move an {@link App} through the {@link AppLifeCycle} to the desired {@link Node}, executing each lifecycle step
* in the process to reach the desired state.
*
* @param appId
* the id of the app to move through the process
* @param nodeName
* the name of the node to attain
*/
@ManagedOperation(value="request the app to be moved to the specified lifecycle node", impact="ACTION")
public void requestAppGoal(@Name("appId") String appId, @Name("nodeName") String nodeName)
{
AppEntry appentry = findAppByOriginId(appId);
if (appentry == null)
{
throw new IllegalStateException("App not being tracked by Deployment Manager: " + appId);
}
requestAppGoal(appentry,nodeName);
}
/**
* Set a contextAttribute that will be set for every Context deployed by this provider.
*
* @param name
* @param value
*/
public void setContextAttribute(String name, Object value)
{
_contextAttributes.setAttribute(name,value);
}
public void setContextAttributes(AttributesMap contextAttributes)
{
this._contextAttributes = contextAttributes;
}
public void setContexts(ContextHandlerCollection contexts)
{
this._contexts = contexts;
}
public void setDefaultLifeCycleGoal(String defaultLifeCycleState)
{
this._defaultLifeCycleGoal = defaultLifeCycleState;
}
private void startAppProvider(AppProvider provider)
{
try
{
provider.setDeploymentManager(this);
provider.start();
}
catch (Exception e)
{
LOG.warn("Unable to start AppProvider",e);
}
}
public void undeployAll()
{
LOG.debug("Undeploy All");
for (AppEntry appentry : _apps)
{
requestAppGoal(appentry,"undeployed");
}
}
public boolean isUseStandardBindings()
{
return _useStandardBindings;
}
public void setUseStandardBindings(boolean useStandardBindings)
{
this._useStandardBindings = useStandardBindings;
}
public Collection<Node> getNodes()
{
return _lifecycle.getNodes();
}
@ManagedOperation(value="list apps that are located at specified App LifeCycle nodes", impact="ACTION")
public Collection<App> getApps(@Name("nodeName") String nodeName)
{
return getApps(_lifecycle.getNodeByName(nodeName));
}
}