/**
* Creates a single webapp configuration to be run in Tomcat.
*
* @param contextName the context name without leading slash, for example, "openmrs"
* @param port the port at which to run tomcat.
*/
public TomcatManager(String contextName, int port) {
// create server
container = new Embedded();
container.setCatalinaHome("tomcat");
// create context
Context rootContext = container.createContext("/" + contextName, contextName);
rootContext.setReloadable(true);
// create host
Host localHost = container.createHost("localhost", "webapps");
localHost.addChild(rootContext);
// create engine
Engine engine = container.createEngine();
engine.setName("Catalina");
engine.addChild(localHost);
engine.setDefaultHost(localHost.getName());
container.addEngine(engine);
// create http connector
Connector httpConnector = container.createConnector((InetAddress) null, port, false);
container.addConnector(httpConnector);
}
/** {@inheritDoc} */
public String getJvmRoute() {
if (jvmRoute_ == null) {
Engine e = getEngine();
jvmRoute_ = (e == null ? null : e.getJvmRoute());
}
return jvmRoute_;
}
/**
* Updates each ThreadPoolExecutor with the current time, which is the time when a context is
* being stopped.
*
* @param context the context being stopped, used to discover all the Connectors of its parent
* Service.
*/
public void stopIdleThreads(Context context) throws RemoteException, RemoteException {
if (serverStopping) return;
if (!(context instanceof StandardContextRemoteInterface)
|| !((StandardContextRemoteInterface) context).getRenewThreadsWhenStoppingContext()) {
log.debug(
"Not renewing threads when the context is stopping. " + "It is not configured to do it.");
return;
}
Engine engine = (Engine) context.getParent().getParent();
Service service = engine.getService();
ConnectorRemoteInterface[] connectors = service.findConnectors();
if (connectors != null) {
for (ConnectorRemoteInterface connector : connectors) {
ProtocolHandler handler = connector.getProtocolHandler();
Executor executor = null;
if (handler != null) {
executor = handler.getExecutor();
}
if (executor instanceof ThreadPoolExecutor2RemoteInterface) {
ThreadPoolExecutor2RemoteInterface threadPoolExecutor =
(ThreadPoolExecutor2RemoteInterface) executor;
threadPoolExecutor.contextStopping();
} else if (executor instanceof StandardThreadExecutorRemoteInterface) {
StandardThreadExecutorRemoteInterface stdThreadExecutor =
(StandardThreadExecutorRemoteInterface) executor;
stdThreadExecutor.contextStopping();
}
}
}
}
public void registerListenersForServer(Server server) throws RemoteException, RemoteException {
for (Service service : server.findServices()) {
Engine engine = (Engine) service.getContainer();
engine.addContainerListener(this);
registerListenersForEngine(engine);
}
}
private void initServer() throws Exception {
// point catalina at the provided home directory
server = new Embedded();
server.setCatalinaHome(catalinaHome.getAbsolutePath());
Engine engine = server.createEngine();
engine.setName("embedded");
server.addEngine(engine);
host = server.createHost("localhost", new File(catalinaHome, "webapps").getAbsolutePath());
engine.addChild(host);
engine.setDefaultHost(host.getName());
// bind to an available port
httpConnector = new EmbeddedConnector();
server.addConnector(httpConnector);
// disable session persistence on restart
sessions = new MemoryStore();
sessionManager = new PersistentManager();
sessionManager.setDistributable(false);
sessionManager.setSaveOnRestart(false);
sessionManager.setStore(sessions);
Context root = server.createContext("", new File(catalinaHome, "conf").getAbsolutePath());
root.setManager(sessionManager);
host.addChild(root);
}
@BeforeClass(alwaysRun = true)
public void setUpGlobal() throws Exception {
port1 = findFreePort();
embedded = new Embedded();
String path = new File(".").getAbsolutePath();
embedded.setCatalinaHome(path);
Engine engine = embedded.createEngine();
engine.setDefaultHost("127.0.0.1");
Host host = embedded.createHost("127.0.0.1", path);
engine.addChild(host);
Context c = embedded.createContext("/", path);
c.setReloadable(false);
Wrapper w = c.createWrapper();
w.addMapping("/*");
w.setServletClass(org.apache.catalina.servlets.WebdavServlet.class.getName());
w.addInitParameter("readonly", "false");
w.addInitParameter("listings", "true");
w.setLoadOnStartup(0);
c.addChild(w);
host.addChild(c);
Connector connector =
embedded.createConnector("127.0.0.1", port1, Http11NioProtocol.class.getName());
connector.setContainer(host);
embedded.addEngine(engine);
embedded.addConnector(connector);
embedded.start();
}
private void addInstanceIdToEngineName() {
int instanceId = containerCounter.incrementAndGet();
if (instanceId > 0) {
Engine engine = this.tomcat.getEngine();
engine.setName(engine.getName() + "-" + instanceId);
}
}
/**
* Doing the start, stop, reload and lazy unload of webapps inside all hosts respectively when
* getting request.
*
* @param nameOfOperation the operation to be performed in oder to hot update the host
* @throws CarbonException if errors occurs when hot update the host
*/
private void handleHotUpdateToHost(String nameOfOperation) throws CarbonException {
if (DataHolder.getHotUpdateService() != null) {
List<String> mappings =
URLMappingHolder.getInstance().getUrlMappingsPerApplication(this.context.getName());
Engine engine = DataHolder.getCarbonTomcatService().getTomcat().getEngine();
Context hostContext;
Host host;
for (String hostName : mappings) {
host = (Host) engine.findChild(hostName);
if (host != null) {
hostContext = (Context) host.findChild("/");
if (hostContext != null) {
if (nameOfOperation.equalsIgnoreCase("start")) {
start(hostContext);
} else if (nameOfOperation.equalsIgnoreCase("stop")) {
stop(hostContext);
} else if (nameOfOperation.equalsIgnoreCase("reload")) {
reload(hostContext);
} else if (nameOfOperation.equalsIgnoreCase("lazyunload")) {
lazyUnload(hostContext);
DataHolder.getHotUpdateService().removeHost(hostName);
} else if (nameOfOperation.equalsIgnoreCase("delete")) {
DataHolder.getHotUpdateService().deleteHost(hostName);
}
}
}
}
}
}
public static void setupContainer(String warName, String jvmRoute, Manager mgr) {
Engine engine = new MockEngine();
engine.setName(JVM_ROUTE_CACHE_NAME);
engine.setJvmRoute(jvmRoute);
Host host = new MockHost();
host.setName("localhost");
engine.addChild(host);
StandardContext context = new StandardContext();
context.setName(warName);
context.setDomain(jvmRoute);
host.addChild(context);
context.setManager(mgr);
}
/** Access to the engine, for further customization. */
public Engine getEngine() {
if (engine == null) {
getServer();
engine = new StandardEngine();
engine.setName("Tomcat");
engine.setDefaultHost(hostname);
if (defaultRealm == null) {
initSimpleAuth();
}
engine.setRealm(defaultRealm);
service.setContainer(engine);
}
return engine;
}
public void registerListenersForEngine(Engine engine) throws RemoteException, RemoteException {
for (Container hostContainer : engine.findChildren()) {
Host host = (Host) hostContainer;
host.addContainerListener(this);
registerListenersForHost(host);
}
}
public EmbeddedTomcat(String contextPath, int port, String jvmRoute)
throws MalformedURLException {
this.contextPath = contextPath;
this.port = port;
// create server
container = new Embedded();
container.setCatalinaHome(catalinaHome);
// Not really necessasry, but let's still do it...
container.setRealm(new MemoryRealm());
// create webapp loader
WebappLoader loader = new WebappLoader(this.getClass().getClassLoader());
if (classesDir != null) {
loader.addRepository(new File(classesDir).toURI().toURL().toString());
}
rootContext = container.createContext("", webappDir);
rootContext.setLoader(loader);
rootContext.setReloadable(true);
// Otherwise we get NPE when instantiating servlets
rootContext.setIgnoreAnnotations(true);
// create host
Host localHost = container.createHost("127.0.0.1", new File("").getAbsolutePath());
localHost.addChild(rootContext);
localHost.setDeployOnStartup(true);
// create engine
engine = container.createEngine();
engine.setName("localEngine");
engine.addChild(localHost);
engine.setDefaultHost(localHost.getName());
engine.setJvmRoute(jvmRoute);
engine.setService(new StandardService());
container.addEngine(engine);
// create http connector
Connector httpConnector = container.createConnector((InetAddress) null, port, false);
container.addConnector(httpConnector);
container.setAwait(true);
// Create the JVMRoute valve for session failover
ValveBase valve = new JvmRouteBinderValve();
((StandardEngine) engine).addValve(valve);
}
protected Realm getRealm(HttpServletRequest request) {
String serverName = request.getServerName();
String contextPath = request.getContextPath();
Host host = (Host) engine.findChild(serverName);
if (host == null) {
// if it cannot find host, then use the default host.
host = (Host) engine.findChild(engine.getDefaultHost());
if (host == null)
throw new NullPointerException(
"Could not find Tomcat host for: " + serverName + " or: " + engine.getDefaultHost());
}
Context context = (Context) host.findChild(contextPath);
if (context == null)
throw new NullPointerException("Could not find Tomcat context for: " + contextPath);
Realm realm = context.getRealm();
if (realm == null)
throw new NullPointerException(
"Could not find Tomcat realm for: " + serverName + "" + contextPath);
return realm;
}
/**
* Retrieve the JvmRoute for the enclosing Engine.
*
* @return the JvmRoute or null.
*/
public String getJvmRoute() {
Engine e = getEngine();
return e == null ? null : e.getJvmRoute();
}
private void bootstrap(String catalinaHome, String webRoot, int port, String address)
throws LifecycleException {
Engine engine = null;
// Create an embedded server
this.embedded = new Embedded();
this.embedded.setUseNaming(false);
this.embedded.setCatalinaHome(catalinaHome);
// set the memory realm
MemoryRealm memRealm = new MemoryRealm();
this.embedded.setRealm(memRealm);
engine = this.embedded.createEngine();
engine.setDefaultHost("localhost");
// Create a default virtual host
File tempHost = null;
try {
tempHost = File.createTempFile("empty", "");
tempHost.mkdirs();
log.debug("Embbed Host Root:" + tempHost.getAbsolutePath());
} catch (IOException e) {
tempHost = new File(".");
log.warn(e, e);
}
this.host = this.embedded.createHost("localhost", tempHost.getAbsolutePath());
engine.addChild(this.host);
// Create the ROOT context
this.rootcontext = this.embedded.createContext("", webRoot);
this.rootcontext.addApplicationListener(SiteLoader.class.getName());
this.rootcontext.setPrivileged(true);
this.rootcontext.setReloadable(false);
this.rootcontext.addWelcomeFile("index.jsp");
this.host.addChild(this.rootcontext);
// Install the assembled container hierarchy
this.embedded.addEngine(engine);
// String addr = null;
connector = this.embedded.createConnector(address, port, false);
if (connector == null) {
/*
* embedded.createConnector(...)
* seems to be broken.. it always returns a null connector.
* see work around below
*/
try {
connector = new Connector();
// httpConnector.setScheme("http");
connector.setSecure(false);
// address = InetAddress.getLocalHost();
IntrospectionUtils.setProperty(connector, "address", "" + address);
IntrospectionUtils.setProperty(connector, "port", "" + port);
} catch (Exception ex) {
ex.printStackTrace();
}
}
connector.setEnableLookups(false);
this.embedded.addConnector(connector);
// Start the embedded server
this.embedded.start();
}
public static void main(String[] args) {
System.setProperty("catalina.base", System.getProperty("user.dir"));
Connector connector = new HttpConnector();
Wrapper wrapper1 = new StandardWrapper();
wrapper1.setName("Primitive");
wrapper1.setServletClass("PrimitiveServlet");
Wrapper wrapper2 = new StandardWrapper();
wrapper2.setName("Modern");
wrapper2.setServletClass("ModernServlet");
Context context = new StandardContext();
// StandardContext's start method adds a default mapper
context.setPath("/app1");
context.setDocBase("app1");
context.addChild(wrapper1);
context.addChild(wrapper2);
LifecycleListener listener = new SimpleContextConfig();
((Lifecycle) context).addLifecycleListener(listener);
Host host = new StandardHost();
host.addChild(context);
host.setName("localhost");
host.setAppBase("webapps");
Loader loader = new WebappLoader();
context.setLoader(loader);
// context.addServletMapping(pattern, name);
context.addServletMapping("/Primitive", "Primitive");
context.addServletMapping("/Modern", "Modern");
Engine engine = new StandardEngine();
engine.addChild(host);
engine.setDefaultHost("localhost");
Service service = new StandardService();
service.setName("Stand-alone Service");
Server server = new StandardServer();
server.addService(service);
service.addConnector(connector);
// StandardService class's setContainer will call all its connector's setContainer method
service.setContainer(engine);
// Start the new server
if (server instanceof Lifecycle) {
try {
server.initialize();
((Lifecycle) server).start();
server.await();
// the program waits until the await method returns,
// i.e. until a shutdown command is received.
} catch (LifecycleException e) {
e.printStackTrace(System.out);
}
}
// Shut down the server
if (server instanceof Lifecycle) {
try {
((Lifecycle) server).stop();
} catch (LifecycleException e) {
e.printStackTrace(System.out);
}
}
}
