package org.jboss.deployment;
import java.io.File;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.net.URL;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import org.jboss.mx.loading.RepositoryClassLoader;
import org.jboss.mx.util.MBeanProxyExt;
import org.jboss.system.ServiceControllerMBean;
import org.jboss.xml.binding.ObjectModelFactory;
import org.jboss.xml.binding.Unmarshaller;
import org.jboss.util.xml.JBossEntityResolver;
import org.xml.sax.InputSource;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.Document;
import org.dom4j.DocumentType;
public abstract class SimpleSubDeployerSupport extends SubDeployerSupport
{
private ServiceControllerMBean serviceController;
private boolean registeredClassLoader = false;
public abstract String getExtension();
public abstract String getMetaDataURL();
public abstract String getObjectName(DeploymentInfo di) throws DeploymentException;
public abstract String getDeploymentClass();
public abstract ObjectModelFactory getObjectModelFactory();
public boolean accepts(DeploymentInfo di)
{
String urlStr = di.url.toString();
String extension = getExtension();
return urlStr.endsWith(extension) || urlStr.endsWith(extension + '/');
}
public void init(DeploymentInfo di) throws DeploymentException
{
URL url = getMetaDataResource(di);
parseMetaData(di, url);
resolveWatch(di, url);
super.init(di);
}
public void create(DeploymentInfo di) throws DeploymentException
{
determineObjectName(di);
ObjectName uclName = registerClassLoader(di);
try
{
registerDeployment(di, uclName);
try
{
createService(di);
try
{
super.create(di);
}
catch (Throwable t)
{
destroyService(di);
}
}
catch (Throwable t)
{
unregisterDeployment(di);
throw t;
}
}
catch (Throwable t)
{
unregisterClassLoader(di);
DeploymentException.rethrowAsDeploymentException("Error creating deployment " + di.url, t);
}
}
public void start(DeploymentInfo di) throws DeploymentException
{
startService(di);
try
{
super.start(di);
}
catch (Throwable t)
{
stopService(di);
DeploymentException.rethrowAsDeploymentException("Error in start for deployment " + di.url, t);
}
}
public void stop(DeploymentInfo di) throws DeploymentException
{
stopService(di);
super.stop(di);
}
public void destroy(DeploymentInfo di) throws DeploymentException
{
destroyService(di);
super.destroy(di);
}
public void postRegister(Boolean done)
{
super.postRegister(done);
if (done.booleanValue())
{
serviceController = (ServiceControllerMBean)
MBeanProxyExt.create(ServiceControllerMBean.class,
ServiceControllerMBean.OBJECT_NAME,
server);
}
}
protected URL getMetaDataResource(DeploymentInfo di) throws DeploymentException
{
URL url = di.localCl.findResource(getMetaDataURL());
if (url == null)
throw new DeploymentException("Could not find meta data " + getMetaDataURL() + " for deployment " + di.url);
return url;
}
protected void parseMetaData(DeploymentInfo di, URL url) throws DeploymentException
{
InputSource source = new InputSource(url.toString());
try
{
Unmarshaller unmarshaller = new Unmarshaller();
ObjectModelFactory factory = getObjectModelFactory();
di.metaData = unmarshaller.unmarshal(source, factory, null);
}
catch (Throwable t)
{
DeploymentException.rethrowAsDeploymentException("Error parsing meta data " + url, t);
}
}
protected void resolveWatch(DeploymentInfo di, URL url) throws DeploymentException
{
di.watch = di.url;
if (di.url.getProtocol().equals("file"))
{
File file = new File(di.url.getFile());
if (file.isDirectory())
di.watch = url;
}
}
protected void determineObjectName(DeploymentInfo di) throws DeploymentException
{
String objectName = getObjectName(di);
try
{
di.deployedObject = new ObjectName(objectName);
}
catch (MalformedObjectNameException e)
{
throw new DeploymentException("INTERNAL ERROR: Bad object name. " + objectName);
}
}
protected ObjectName registerClassLoader(DeploymentInfo di) throws DeploymentException
{
ObjectName uclName = null;
try
{
RepositoryClassLoader ucl = di.ucl;
uclName = ucl.getObjectName();
if (server.isRegistered(uclName) == false)
{
server.registerMBean(di.ucl, uclName);
registeredClassLoader = true;
}
}
catch (Throwable t)
{
DeploymentException.rethrowAsDeploymentException("Error registering classloader " + uclName, t);
}
return uclName;
}
protected void unregisterClassLoader(DeploymentInfo di)
{
ObjectName uclName = null;
try
{
RepositoryClassLoader ucl = di.ucl;
uclName = ucl.getObjectName();
if (registeredClassLoader && server.isRegistered(uclName) == false)
{
server.unregisterMBean(uclName);
registeredClassLoader = false;
}
}
catch (Throwable t)
{
log.warn("Error unregistering classloader " + uclName, t);
}
}
protected void registerDeployment(DeploymentInfo di, ObjectName uclName) throws DeploymentException
{
try
{
String deploymentClass = getDeploymentClass();
server.createMBean(deploymentClass, di.deployedObject, uclName, new Object[] { di }, new String[] { DeploymentInfo.class.getName() });
}
catch (Throwable t)
{
DeploymentException.rethrowAsDeploymentException("Error registering deployment " + di.url, t);
}
}
protected void unregisterDeployment(DeploymentInfo di)
{
try
{
if (server.isRegistered(di.deployedObject))
server.unregisterMBean(di.deployedObject);
}
catch (Throwable t)
{
log.warn("Error unregistering deployment " + di.deployedObject, t);
}
}
protected void createService(DeploymentInfo di) throws DeploymentException
{
try
{
serviceController.create(di.deployedObject);
}
catch (Throwable t)
{
DeploymentException.rethrowAsDeploymentException("Error in create for deployment " + di.url, t);
}
}
protected void startService(DeploymentInfo di) throws DeploymentException
{
try
{
serviceController.start(di.deployedObject);
}
catch (Throwable t)
{
DeploymentException.rethrowAsDeploymentException("Error in start for deployment " + di.url, t);
}
}
protected void stopService(DeploymentInfo di)
{
try
{
serviceController.stop(di.deployedObject);
}
catch (Throwable t)
{
log.warn("Error in stop for deployment " + di.url, t);
}
}
protected void destroyService(DeploymentInfo di) throws DeploymentException
{
try
{
serviceController.destroy(di.deployedObject);
}
catch (Throwable t)
{
log.warn("Error in destroy for deployment " + di.url, t);
}
try
{
serviceController.remove(di.deployedObject);
}
catch (Throwable t)
{
log.warn("Error in remove for deployment " + di.url, t);
}
}
}