/*
* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.deployment.services;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.enterprise.deploy.shared.ModuleType;
import javax.enterprise.deploy.spi.exceptions.TargetException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import org.jboss.dependency.spi.Controller;
import org.jboss.deployers.client.spi.Deployment;
import org.jboss.deployers.plugins.main.MainDeployerImpl;
import org.jboss.deployers.spi.DeploymentState;
import org.jboss.deployers.structure.spi.DeploymentContext;
import org.jboss.deployers.structure.spi.DeploymentUnit;
import org.jboss.deployers.vfs.spi.client.VFSDeploymentFactory;
import org.jboss.deployment.spi.SerializableTargetModuleID;
import org.jboss.logging.Logger;
import org.jboss.mx.util.MBeanServerLocator;
import org.jboss.system.metadata.ServiceMetaData;
import org.jboss.util.file.Files;
import org.jboss.virtual.VFS;
import org.jboss.virtual.VirtualFile;
/**
* A service that supports the JSR-88 DeploymentManager operations.
*
* @author Scott.Stark@jboss.org
* @author adrian@jboss.org
* @version $Revision: 84628 $
*/
public class DeploymentManagerService
implements DeploymentManagerServiceMBean
{
private static Logger log = Logger.getLogger(DeploymentManagerService.class);
/** The deployment factory */
VFSDeploymentFactory deploymentFactory = VFSDeploymentFactory.getInstance();
/**
* Map<deployURL, TargetID> of the deployment modules.
*/
private Map<String, SerializableTargetModuleID> moduleMap =
Collections.synchronizedMap(new HashMap<String, SerializableTargetModuleID>());
/**
* The type of attachment used to identify a CAR
*/
private Class carDeployerType;
/**
* The type of attachment used to identify a EAR
*/
private Class earDeployerType;
/**
* The type of attachment used to identify a EJB
*/
private Class ejbDeployerType;
private Class ejb3DeployerType;
/**
* The type of attachment used to identify a RAR
*/
private Class rarDeployerType;
/**
* The type of attachment used to identify a WAR
*/
private Class warDeployerType;
/**
* The MainDeployer
*/
private MainDeployerImpl mainDeployer;
/**
* The controller
*/
private Controller controller;
/**
* The local directory for uploaded content.
*/
private File uploadDir;
private boolean failOnCollision;
private boolean deleteOnUndeploy;
/**
* Get the deployment name
*
* @param file the file
* @return the name;
*/
public static String getDeploymentName(VirtualFile file)
{
if (file == null)
throw new IllegalArgumentException("Null file");
try
{
URI uri = file.toURI();
return uri.toString();
}
catch (Exception e)
{
throw new IllegalArgumentException("File does not have a valid uri: " + file, e);
}
}
public MainDeployerImpl getMainDeployer()
{
return mainDeployer;
}
public void setMainDeployer(MainDeployerImpl mainDeployer)
{
this.mainDeployer = mainDeployer;
}
public Controller getController()
{
return controller;
}
public void setController(Controller controller)
{
this.controller = controller;
}
public Class getCarDeployerType()
{
return carDeployerType;
}
public void setCarDeployerType(Class carDeployerType)
{
this.carDeployerType = carDeployerType;
}
public Class getEarDeployerType()
{
return earDeployerType;
}
public void setEarDeployerType(Class earDeployerType)
{
this.earDeployerType = earDeployerType;
}
public Class getEjbDeployerType()
{
return ejbDeployerType;
}
public void setEjbDeployerType(Class ejbDeployerType)
{
this.ejbDeployerType = ejbDeployerType;
}
public Class getEjb3DeployerType()
{
return ejb3DeployerType;
}
public void setEjb3DeployerType(Class ejb3DeployerType)
{
this.ejb3DeployerType = ejb3DeployerType;
}
public Class getRarDeployerType()
{
return rarDeployerType;
}
public void setRarDeployerType(Class rarDeployerType)
{
this.rarDeployerType = rarDeployerType;
}
public Class getWarDeployerType()
{
return warDeployerType;
}
public void setWarDeployerType(Class warDeployerType)
{
this.warDeployerType = warDeployerType;
}
public void setModuleMap(Map<String, SerializableTargetModuleID> moduleMap)
{
this.moduleMap = moduleMap;
}
public File getUploadDir()
{
return this.uploadDir;
}
public void setUploadDir(File uploadDir)
{
this.uploadDir = uploadDir;
}
public boolean isDeleteOnUndeploy()
{
return deleteOnUndeploy;
}
public void setDeleteOnUndeploy(boolean deleteOnUndeploy)
{
this.deleteOnUndeploy = deleteOnUndeploy;
}
public boolean isFailOnCollision()
{
return failOnCollision;
}
public void setFailOnCollision(boolean failOnCollision)
{
this.failOnCollision = failOnCollision;
}
public Map getModuleMap()
{
return Collections.unmodifiableMap(moduleMap);
}
public void deploy(SerializableTargetModuleID moduleID) throws Exception
{
String url = moduleID.getModuleID();
// Create a status object
URL deployURL = new URL(url);
int contentLength = deployURL.openConnection().getContentLength();
log.debug("Begin deploy, url: " + deployURL + ", contentLength: " + contentLength);
// Create the local path
File path = new File(deployURL.getFile());
String archive = path.getName();
File deployFile = new File(uploadDir, archive);
if (failOnCollision && deployFile.exists())
throw new IOException("deployURL(" + deployURL + ") collides with: " + deployFile.getPath());
if (deployFile.exists())
Files.delete(deployFile);
File parentFile = deployFile.getParentFile();
if (parentFile.exists() == false)
{
if (parentFile.mkdirs() == false)
throw new IOException("Failed to create local path: " + parentFile);
}
InputStream is = moduleID.getContentIS();
if( is == null )
{
is = deployURL.openStream();
}
BufferedInputStream bis = new BufferedInputStream(is);
byte[] buffer = new byte[4096];
FileOutputStream fos = new FileOutputStream(deployFile);
BufferedOutputStream bos = new BufferedOutputStream(fos);
int count = 0;
while ((count = bis.read(buffer)) > 0)
{
bos.write(buffer, 0, count);
}
bis.close();
bos.close();
moduleMap.put(url, moduleID);
// TODO: arrange deploy_phase2 (and TC glue code).
deploy_phase2(url);
}
/* Invoke the method on the contexts */
public void hack(SerializableTargetModuleID moduleID, DeploymentContext info, String method)
{
try {
MBeanServer server = MBeanServerLocator.locateJBoss();
String objNames = getComponentName(info);
String contexts = null;
if (objNames != null)
{
String token = ":war=";
int i = objNames.indexOf(token);
if (i == -1)
return;
i = i + token.length();
contexts = objNames.substring(i);
}
String onStr = "*:j2eeType=WebModule,*,J2EEApplication=none,J2EEServer=none";
ObjectName objectName = new ObjectName(onStr);
Set mbeans = server.queryNames(objectName, null);
if (mbeans != null && mbeans.size () > 0 && contexts != null)
{
for (Iterator iter = mbeans.iterator(); iter.hasNext();)
{
ObjectName inst = (ObjectName) iter.next();
String name = inst.toString();
String token = ".*" + contexts + ".*";
if (name.matches(token))
{
server.invoke(inst, method, new Object[] {}, new String[] {});
}
}
}
} catch (Throwable e)
{
log.info("hack: failed" + e);
}
}
public void start(String url) throws Exception
{
SerializableTargetModuleID moduleID = (SerializableTargetModuleID)moduleMap.get(url);
if (moduleID == null)
throw new IOException("deployURL(" + url + ") has not been distributed");
if (moduleID.isRunning()) {
log.error("start, url: " + url + " Already started");
return;
}
URL deployURL = new URL(url);
// Build the local path
File path = new File(deployURL.getFile());
String archive = path.getName();
File deployFile = new File(uploadDir, archive);
VirtualFile root = VFS.getRoot(deployFile.toURI());
Deployment deployment = mainDeployer.getDeployment(getDeploymentName(root));
/* TODO: that is a hack */
if (deployment == null)
{
deployment = deploymentFactory.createVFSDeployment(root);
mainDeployer.addDeployment(deployment);
mainDeployer.process();
moduleID.setRunning(true);
moduleID.clearChildModuleIDs();
// Repopulate the child modules
DeploymentContext context = mainDeployer.getDeploymentContext(deployment.getName());
fillChildrenTargetModuleID(moduleID, context);
}
// hack(moduleID, context, "start");
}
/*
* Get the component name.
*/
private String getComponentName(DeploymentContext context)
{
if (context == null)
return null;
DeploymentUnit u = context.getDeploymentUnit();
ServiceMetaData data = u.getAttachment(ServiceMetaData.class);
if (data == null)
return null;
ObjectName objectName = data.getObjectName();
return objectName.toString();
}
public void deploy_phase2(String url) throws Exception
{
SerializableTargetModuleID moduleID = moduleMap.get(url);
if (moduleID == null)
throw new IOException("deployURL(" + url + ") has not been distributed");
if (moduleID.isRunning())
{
return;
}
URL deployURL = new URL(url);
// Build the local path
File path = new File(deployURL.getFile());
String archive = path.getName();
File deployFile = new File(uploadDir, archive);
if (deployFile.exists() == false)
throw new IOException("deployURL(" + url + ") has no local archive");
VirtualFile root = VFS.getRoot(deployFile.toURI());
Deployment deployment = deploymentFactory.createVFSDeployment(root);
mainDeployer.addDeployment(deployment);
DeploymentContext context = null;
try
{
mainDeployer.process();
context = mainDeployer.getDeploymentContext(deployment.getName());
mainDeployer.checkComplete(deployment);
}
catch (Exception e)
{
/* destroy the context */
hack(moduleID, context, "destroy");
/* clear the child */
moduleID.clearChildModuleIDs();
/* remove the deployment */
mainDeployer.removeDeployment(getDeploymentName(root));
mainDeployer.process();
/* remove the map */
if (deleteOnUndeploy)
Files.delete(deployFile);
moduleMap.remove(url);
throw e;
}
moduleID.setRunning(true);
moduleID.clearChildModuleIDs();
// Repopulate the child modules
fillChildrenTargetModuleID(moduleID, context);
// TODO: invoke the start.
// hack(moduleID, context, "start");
}
public void stop(String url) throws Exception
{
SerializableTargetModuleID moduleID = (SerializableTargetModuleID)moduleMap.get(url);
if (moduleID == null)
throw new IOException("deployURL(" + url + ") has not been distributed");
URL deployURL = new URL(url);
// Build the local path
File path = new File(deployURL.getFile());
String archive = path.getName();
File deployFile = new File(uploadDir, archive);
if (deployFile.exists() == false)
throw new IOException("deployURL(" + url + ") has no local archive");
VirtualFile root = VFS.getRoot(deployFile.toURI());
mainDeployer.removeDeployment(getDeploymentName(root));
mainDeployer.process();
moduleID.setRunning(false);
}
public void undeploy(String url) throws Exception
{
SerializableTargetModuleID moduleID = (SerializableTargetModuleID)moduleMap.get(url);
if (moduleID == null)
return;
// If the module is still running, stop it
if (moduleID.isRunning())
stop(url);
URL deployURL = new URL(url);
// Build the local path
File path = new File(deployURL.getFile());
String archive = path.getName();
File deployFile = new File(uploadDir, archive);
if (deployFile.exists() == false)
throw new IOException("deployURL(" + url + ") has not been distributed");
if (deleteOnUndeploy)
Files.delete(deployFile);
moduleMap.remove(url);
}
public SerializableTargetModuleID[] getAvailableModules(int moduleType)
throws TargetException
{
ArrayList<SerializableTargetModuleID> matches = new ArrayList<SerializableTargetModuleID>();
Iterator<SerializableTargetModuleID> modules = moduleMap.values().iterator();
while (modules.hasNext())
{
SerializableTargetModuleID module = modules.next();
if (module.getModuleType() == moduleType)
matches.add(module);
}
SerializableTargetModuleID[] ids = new SerializableTargetModuleID[matches.size()];
matches.toArray(ids);
return ids;
}
/**
* Travers the deployment children to build up the jsr88 module children
* @param moduleID
* @param info
*/
private void fillChildrenTargetModuleID(SerializableTargetModuleID moduleID,
DeploymentContext info)
{
List<DeploymentContext> children = info.getChildren();
for(DeploymentContext ctx : children)
{
try
{
ModuleType type = getModuleType(ctx);
// Discard unknown ModuleTypes
if (type != null)
{
String module = ctx.getName();
// TODO, DEPLOYED may not be the same as running?
boolean isRunning = ctx.getState() == DeploymentState.DEPLOYED;
SerializableTargetModuleID child = new SerializableTargetModuleID(moduleID, module, type.getValue(), isRunning);
moduleID.addChildTargetModuleID(child);
fillChildrenTargetModuleID(child, ctx);
}
}
catch (UnsupportedOperationException e)
{
if (log.isTraceEnabled())
log.trace("Ignoring", e);
}
}
}
/**
* Determine the module type by looking for an attachment that identifies
* the deployer type.
*
* @param info
* @return
*/
private ModuleType getModuleType(DeploymentContext info)
{
ModuleType type = null;
DeploymentUnit unit = info.getDeploymentUnit();
if (unit.getAttachment(carDeployerType) != null)
{
type = ModuleType.CAR;
}
else if (unit.getAttachment(ejbDeployerType) != null
|| unit.getAttachment(ejb3DeployerType) != null)
{
type = ModuleType.EJB;
}
else if (unit.getAttachment(earDeployerType) != null)
{
type = ModuleType.EAR;
}
else if (unit.getAttachment(rarDeployerType) != null)
{
type = ModuleType.RAR;
}
else if (unit.getAttachment(warDeployerType) != null)
{
type = ModuleType.WAR;
}
return type;
}
}