diff options
Diffstat (limited to '')
3 files changed, 440 insertions, 0 deletions
diff --git a/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyAnnotationsProcessor.java b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyAnnotationsProcessor.java new file mode 100644 index 0000000000..8dfd8175e4 --- /dev/null +++ b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyAnnotationsProcessor.java @@ -0,0 +1,85 @@ +/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.tomcat;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import javax.naming.NamingException;
+import javax.servlet.ServletContext;
+
+import org.apache.AnnotationProcessor;
+import org.apache.catalina.util.DefaultAnnotationProcessor;
+
+public class TuscanyAnnotationsProcessor implements AnnotationProcessor {
+
+ private TuscanyStandardContext tuscanyStandardContext;
+ private AnnotationProcessor tomcatAnnotationProcessor;
+ private Method tuscanyInjectMethod;
+
+ public TuscanyAnnotationsProcessor(TuscanyStandardContext tuscanyStandardContext, javax.naming.Context context) {
+ this.tuscanyStandardContext = tuscanyStandardContext;
+ this.tomcatAnnotationProcessor = new DefaultAnnotationProcessor(context);
+ initInjectMethod(tuscanyStandardContext);
+ }
+
+ private void initInjectMethod(TuscanyStandardContext tuscanyStandardContext) {
+
+ // this needs to use reflection as the tuscany-hook module can't have any
+ // dependencies on the tuscany runtime modules as they're not
+ // in the server classpath
+ // TODO: is there a nicer way ?
+
+ ClassLoader cl = tuscanyStandardContext.getParentClassLoader();
+ try {
+ Class<?> c = Class.forName("org.apache.tuscany.sca.implementation.web.runtime.utils.ContextHelper", true, cl);
+ if (c != null) {
+ this.tuscanyInjectMethod = c.getMethod("inject", new Class[]{Object.class, ServletContext.class});
+ }
+ } catch (Exception e){
+ // ignore
+ }
+ }
+
+ public void postConstruct(Object instance) throws IllegalAccessException, InvocationTargetException {
+ tomcatAnnotationProcessor.postConstruct(instance);
+ }
+
+ public void preDestroy(Object instance) throws IllegalAccessException, InvocationTargetException {
+ tomcatAnnotationProcessor.preDestroy(instance);
+ }
+
+ public void processAnnotations(Object instance) throws IllegalAccessException, InvocationTargetException, NamingException {
+ if (tuscanyInjectMethod != null) {
+ ServletContext sc = tuscanyStandardContext.getServletContext();
+ if (sc != null) {
+ Object rc = sc.getAttribute("org.apache.tuscany.sca.implementation.web.RuntimeComponent");
+ if (rc != null) {
+ try {
+ tuscanyInjectMethod.invoke(null, instance, sc);
+ } catch (Exception e) {
+ throw new InvocationTargetException(e);
+ }
+ }
+ }
+ }
+ tomcatAnnotationProcessor.processAnnotations(instance);
+ }
+}
diff --git a/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyLifecycleListener.java b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyLifecycleListener.java new file mode 100644 index 0000000000..ab96376020 --- /dev/null +++ b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyLifecycleListener.java @@ -0,0 +1,170 @@ +/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.tomcat;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Properties;
+import java.util.logging.Logger;
+
+import org.apache.catalina.Container;
+import org.apache.catalina.LifecycleEvent;
+import org.apache.catalina.LifecycleListener;
+import org.apache.catalina.ServerFactory;
+import org.apache.catalina.Service;
+import org.apache.catalina.connector.Connector;
+import org.apache.catalina.core.StandardEngine;
+import org.apache.catalina.core.StandardHost;
+import org.apache.catalina.core.StandardServer;
+import org.apache.catalina.core.StandardService;
+import org.apache.catalina.startup.HostConfig;
+
+/**
+ * A Tomcat LifecycleListener that initilizes the Tuscany Tomcat integration.
+ * It sets a System property with the location of the Tuscany runtime .war
+ * and configures each Tomcat Connector to use the TuscanyStandardContext.
+ *
+ * To configure Tomcat to use this add the following to the Tomcat conf/server.xml
+ * <Listener className="org.apache.tuscany.sca.tomcat.TuscanyLifecycleListener"/>
+ */
+public class TuscanyLifecycleListener implements LifecycleListener {
+ private static final Logger log = Logger.getLogger(TuscanyLifecycleListener.class.getName());
+
+ public static final String TUSCANY_WAR_PROP = "org.apache.tuscany.sca.tomcat.war";
+
+ private static boolean running;
+
+ public static boolean isRunning() {
+ return running;
+ }
+
+ static final String TUSCANY_SHARED_PROP = "org.apache.tuscany.sca.tomcat.shared";
+
+ public TuscanyLifecycleListener() {
+ running = true;
+ log.info("Apache Tuscany initilizing");
+ }
+
+ public void lifecycleEvent(LifecycleEvent event) {
+ if ("init".equals(event.getType()) && (event.getSource() instanceof StandardServer)) {
+ File webappDir = findTuscanyWar();
+ if (webappDir == null) {
+ log.severe("Tuscany disabled as Tuscany webapp not found");
+ } else {
+ System.setProperty(TUSCANY_WAR_PROP, webappDir.getAbsolutePath());
+ System.setProperty("org.apache.tuscany.sca.contribution.processor.ValidationSchemaExtensionPoint.enabled", "false");
+ File propFile = new File(webappDir, "tuscany.properties");
+ if (propFile.isFile()) {
+ try {
+ FileInputStream is = new FileInputStream(propFile);
+ Properties props = new Properties();
+ props.load(is);
+ is.close();
+ System.setProperty(TUSCANY_SHARED_PROP, props.getProperty("singleton", "false"));
+ } catch (IOException e) {
+ // Ignore
+ }
+ }
+ log.info("Using Tuscany webapp: " + webappDir.getAbsolutePath());
+ StandardServer server = (StandardServer)event.getSource();
+ StandardService catalina = (StandardService)server.findService("Catalina");
+ for (Connector connector : catalina.findConnectors()) {
+ for (Container container : connector.getContainer().findChildren()) {
+ if (container instanceof StandardHost) {
+ for (LifecycleListener listener : ((StandardHost)container).findLifecycleListeners()) {
+ if (listener instanceof HostConfig) {
+ ((HostConfig)listener)
+ .setContextClass("org.apache.tuscany.sca.tomcat.TuscanyStandardContext");
+ log.info("Tuscany enabled on connector: " + container.getName()
+ + ":"
+ + connector.getPort());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private static File findTuscanyWar() {
+
+ // in Tomcat 5.5 the Tuscany war is in the server/webapps director
+ String catalinaBase = System.getProperty("catalina.base");
+ File serverWebapps = new File(catalinaBase, "server/webapps");
+ File tuscanyWar = findTuscanyWar(serverWebapps);
+ if (tuscanyWar != null) {
+ return tuscanyWar;
+ }
+
+ // in Tomcat 6 the Tuscany war is normally in webapps, but we just scan all hosts directories
+ for (Service service : ServerFactory.getServer().findServices()) {
+ Container container = service.getContainer();
+ if (container instanceof StandardEngine) {
+ StandardEngine engine = (StandardEngine)container;
+ for (Container child : engine.findChildren()) {
+ if (child instanceof StandardHost) {
+ StandardHost host = (StandardHost)child;
+ String appBase = host.getAppBase();
+
+ // determine the host dir (normally webapps)
+ File hostDir = new File(appBase);
+ if (!hostDir.isAbsolute()) {
+ hostDir = new File(catalinaBase, appBase);
+ }
+
+ tuscanyWar = findTuscanyWar(hostDir);
+ if (tuscanyWar != null) {
+ return tuscanyWar;
+ }
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ private static File findTuscanyWar(File hostDir) {
+ if (!hostDir.isDirectory()) {
+ return null;
+ }
+
+ // iterate over the contexts
+ for (File contextDir : hostDir.listFiles()) {
+ // does this war have a web-inf lib dir
+ File hookLib = new File(contextDir, "tomcat-lib");
+ if (!hookLib.isDirectory()) {
+ continue;
+ }
+ // iterate over the libs looking for the tuscany-tomcat-*.jar
+ for (File file : hookLib.listFiles()) {
+ if (file.getName().startsWith("tuscany-tomcat-hook-") && file.getName().endsWith(".jar")) {
+ // this should be in the Tuscany war...
+ // make sure it has a runtime directory
+ if (new File(contextDir, "tuscany-lib").isDirectory()) {
+ return contextDir;
+ }
+ }
+ }
+ }
+ return null;
+ }
+}
diff --git a/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyStandardContext.java b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyStandardContext.java new file mode 100644 index 0000000000..94b7152610 --- /dev/null +++ b/branches/sca-java-2.0-M3/distribution/tomcat/tomcat-hook/src/main/java/org/apache/tuscany/sca/tomcat/TuscanyStandardContext.java @@ -0,0 +1,185 @@ +/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.tuscany.sca.tomcat;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.logging.Logger;
+
+import javax.naming.NameClassPair;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+
+import org.apache.catalina.Loader;
+import org.apache.catalina.core.StandardContext;
+import org.apache.catalina.deploy.FilterDef;
+
+/**
+ * A Tuscany StandardContext to initilize SCA applications.
+ * There is a StandardContext instance for each webapp and its
+ * called to handle all start/stop/etc requests. This intercepts
+ * the start and inserts any required Tuscany configuration.
+ */
+public class TuscanyStandardContext extends StandardContext {
+ private static final long serialVersionUID = 1L;
+ private static final Logger log = Logger.getLogger(TuscanyStandardContext.class.getName());
+
+ protected static final String TUSCANY_FILTER_NAME = "TuscanyFilter";
+ protected static final String TUSCANY_SERVLET_FILTER = "org.apache.tuscany.sca.host.webapp.TuscanyServletFilter";
+ protected static final String TUSCANY_CONTEXT_LISTENER = "org.apache.tuscany.sca.host.webapp.TuscanyContextListener";
+ protected static final String TUSCANY_MANAGER_LISTENER = "org.apache.tuscany.sca.tomcat.foo.TuscanyTomcatNode";
+
+ private boolean isSCAApp;
+
+ // TODO: this gives an instance per webapp, work out how to have only one per server
+ private static URLClassLoader tuscanyClassLoader;
+
+ /**
+ * Overrides the getLoader method in the Tomcat StandardContext as its a convenient
+ * point to insert the Tuscany initilization. This gets called the first time during
+ * StandardContext.start after the webapp resources have been created so this can
+ * use getResources() to look for the SCA web.composite or sca-contribution.xml files,
+ * but its still early enough in start to insert the required Tuscany config.
+ */
+ @Override
+ public Loader getLoader() {
+ if (loader != null) {
+ return loader;
+ }
+
+ ClassLoader parent = getParentClassLoader();
+ if (isSCAApp = isSCAApplication() || isTuscanyManager()) {
+ String sharedProp = System.getProperty(TuscanyLifecycleListener.TUSCANY_SHARED_PROP, "false");
+ boolean shared = "true".equalsIgnoreCase(sharedProp);
+ if (!shared) {
+ setParentClassLoader(copy(getTuscanyClassloader(parent)));
+ } else {
+ // The default parent classloader is the one for the webapp
+ setParentClassLoader(getTuscanyClassloader(parent));
+ }
+ }
+
+ return super.getLoader();
+ }
+
+ @Override
+ public boolean listenerStart() {
+ if (isTuscanyManager()) {
+ // this isn't great having the manager app config scattered about different modules
+ // but is temp until this is all tidied up in a refactor after the basics are working
+ addApplicationListener(TUSCANY_MANAGER_LISTENER);
+ } else if (isSCAApp) {
+ enableTuscany();
+ }
+ return super.listenerStart();
+ }
+
+ private void enableTuscany() {
+
+ for (String listener : findApplicationListeners()) {
+ if (TUSCANY_CONTEXT_LISTENER.equals(listener)) {
+ // The web application already has the context listener configured
+ return;
+ }
+ }
+
+ for (FilterDef filterDef : findFilterDefs()) {
+ if (TUSCANY_SERVLET_FILTER.equals(filterDef.getFilterClass())) {
+ // The web application already has the filter configured
+ return;
+ }
+ }
+
+ addApplicationListener(TUSCANY_CONTEXT_LISTENER);
+
+ FilterDef filterDef = new FilterDef();
+ filterDef.setFilterName(TUSCANY_FILTER_NAME);
+ filterDef.setFilterClass(TUSCANY_SERVLET_FILTER);
+ addFilterDef(filterDef);
+
+ if (isUseNaming() && getNamingContextListener() != null) {
+ setAnnotationProcessor(new TuscanyAnnotationsProcessor(this, getNamingContextListener().getEnvContext()));
+ } else {
+ setAnnotationProcessor(new TuscanyAnnotationsProcessor(this, null));
+ }
+
+ log.info("Tuscany SCA is enabled for: " + this.getName());
+ }
+
+ private boolean isSCAApplication() {
+ Object o = null;
+ try {
+ o = getResources().lookup("WEB-INF/web.composite");
+ } catch (NamingException e) {
+ }
+ if (o == null) {
+ try {
+ o = getResources().lookup("META-INF/sca-contribution.xml");
+ } catch (NamingException e) {
+ }
+ }
+ if (o == null) {
+ return false;
+ }
+
+ // Try to see if the Tuscany jars are packaged in the webapp
+ NamingEnumeration<NameClassPair> enumeration;
+ try {
+ enumeration = getResources().list("WEB-INF/lib");
+ while (enumeration.hasMoreElements()) {
+ String jar = enumeration.nextElement().getName();
+ if (jar.startsWith("tuscany-")) {
+ // Do not alter is
+ log.info("Tuscany SCA ignoring webapp with embedded Tuscany runtime: " + this.getName());
+ return false;
+ }
+ }
+ } catch (NamingException e) {
+ }
+ return true;
+ }
+
+ private boolean isTuscanyManager() {
+ return "/tuscany".equals(getName());
+ }
+
+ private static URLClassLoader copy(URLClassLoader classLoader) {
+ return new URLClassLoader(classLoader.getURLs(), classLoader.getParent());
+ }
+
+ private synchronized URLClassLoader getTuscanyClassloader(ClassLoader parent) {
+ if (tuscanyClassLoader == null) {
+ File tuscanyWar = new File(System.getProperty(TuscanyLifecycleListener.TUSCANY_WAR_PROP));
+ File[] runtimeJars = new File(tuscanyWar, "tuscany-lib").listFiles();
+ try {
+ URL[] jarURLs = new URL[runtimeJars.length];
+ for (int i = 0; i < jarURLs.length; i++) {
+ jarURLs[i] = runtimeJars[i].toURI().toURL();
+ }
+ tuscanyClassLoader = new URLClassLoader(jarURLs, parent);
+ return tuscanyClassLoader;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+ return tuscanyClassLoader;
+ }
+}
|