Moving 2.x trunk

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@882795 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 322 insertions, 0 deletions

diff --git a/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/IContextLocator.java b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/IContextLocator.java
new file mode 100644
index 0000000000..589c240b84
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/IContextLocator.java
@@ -0,0 +1,60 @@
+/*
+ * 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.wicket;
+import javax.servlet.ServletContext;
+
+import org.apache.wicket.IClusterable;
+
+
+/**
+ * Interface representing object that can locate a spring context. The implementation should take up
+ * little room when serialized.
+ * 
+ * SpringObjectLocator uses this interface to locate the spring context so that it in turn can
+ * locate a bean.
+ * 
+ * Ideal implementations use a static lookup to locate the context.
+ * 
+ * For Example:
+ * 
+ * <pre>
+ * class SpringContextLocator implements ISpringContextLocator
+ * {
+ *      public ApplicationContext getSpringContext()
+ *      {
+ *              //MyApplication is the subclass of WebApplication used by the application
+ *              return ((MyApplication)Application.get()).getContext();
+ *      }
+ * }
+ * </pre>
+ * 
+ * @see SpringBeanLocator
+ * 
+ * Based on code from Apache Wicket by Igor Vaynberg
+ */
+public interface IContextLocator extends IClusterable
+{
+        /**
+         * Getter for spring application context
+         * 
+         * @return spring application context
+         */
+        ServletContext getServletContext();
+}
diff --git a/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyComponentInjector.java b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyComponentInjector.java
new file mode 100644
index 0000000000..b1e9097cdf
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyComponentInjector.java
@@ -0,0 +1,158 @@
+/*
+ * 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.wicket;
+import javax.servlet.ServletContext;
+
+import org.apache.wicket.Application;
+import org.apache.wicket.IClusterable;
+import org.apache.wicket.MetaDataKey;
+import org.apache.wicket.Session;
+import org.apache.wicket.application.IComponentInstantiationListener;
+import org.apache.wicket.injection.ComponentInjector;
+import org.apache.wicket.injection.web.InjectorHolder;
+import org.apache.wicket.model.Model;
+import org.apache.wicket.protocol.http.WebApplication;
+
+/**
+ * {@link IComponentInstantiationListener} that injects component properties annotated with {@link
+ * SpringBean} annotations.
+ * 
+ * To install in yourapplication.init() call
+ * <code>addComponentInstantiationListener(new SpringComponentInjector(this));</code> Non-wicket
+ * components such as {@link Session}, {@link Model}, and any other pojo can be injected by calling
+ * <code>InjectorHolder.getInjector().inject(this)</code> in their constructor.
+ * 
+ * Based on code from Apache Wicket by Igor Vaynberg and Justin Lee
+ */
+public class TuscanyComponentInjector extends ComponentInjector
+{
+
+        /**
+         * Metadata key used to store application context holder in application's metadata
+         */
+        private static MetaDataKey<ApplicationContextHolder> CONTEXT_KEY = new MetaDataKey<ApplicationContextHolder>()
+        {
+
+                private static final long serialVersionUID = 1L;
+
+        };
+
+        /**
+         * Constructor used when spring application context is declared in the spring standard way and
+         * can be located through {@link
+         * WebApplicationContextUtils#getRequiredWebApplicationContext(ServletContext)}
+         * 
+         * @param webapp
+         *              wicket web application
+         */
+        public TuscanyComponentInjector(WebApplication webapp)
+        {
+                // locate application context through spring's default location
+                // mechanism and pass it on to the proper constructor
+                this(webapp, webapp.getServletContext());
+        }
+
+        /**
+         * Constructor
+         * 
+         * @param webapp
+         *              wicket web application
+         * @param ctx
+         *              spring's application context
+         */
+        public TuscanyComponentInjector(WebApplication webapp, ServletContext ctx)
+        {
+                if (webapp == null)
+                {
+                        throw new IllegalArgumentException("Argument [[webapp]] cannot be null");
+                }
+
+                if (ctx == null)
+                {
+                        throw new IllegalArgumentException("Argument [[ctx]] cannot be null");
+                }
+
+                // store context in application's metadata ...
+                webapp.setMetaData(CONTEXT_KEY, new ApplicationContextHolder(ctx));
+
+                // ... and create and register the annotation aware injector
+                InjectorHolder.setInjector(new TuscanyInjector(new ContextLocator()));
+        }
+
+        /**
+         * This is a holder for the application context. The reason we need a holder is that metadata
+         * only supports storing serializable objects but application context is not. The holder acts as
+         * a serializable wrapper for the context. Notice that although holder implements IClusterable
+         * it really is not because it has a reference to non serializable context - but this is ok
+         * because metadata objects in application are never serialized.
+         * 
+         * @author ivaynberg
+         * 
+         */
+        private static class ApplicationContextHolder implements IClusterable
+        {
+                private static final long serialVersionUID = 1L;
+
+                private final ServletContext context;
+
+                /**
+                 * Constructor
+                 * 
+                 * @param context
+                 */
+                public ApplicationContextHolder(ServletContext context)
+                {
+                        this.context = context;
+                }
+
+                /**
+                 * @return the context
+                 */
+                public ServletContext getContext()
+                {
+                        return context;
+                }
+        }
+
+        /**
+         * A context locator that locates the context in application's metadata. This locator also keeps
+         * a transient cache of the lookup.
+         * 
+         * @author ivaynberg
+         * 
+         */
+        private static class ContextLocator implements IContextLocator
+        {
+                private transient ServletContext context;
+
+                private static final long serialVersionUID = 1L;
+
+                public ServletContext getServletContext()
+                {
+                        if (context == null)
+                        {
+                                context = (Application.get().getMetaData(CONTEXT_KEY)).getContext();
+                        }
+                        return context;
+                }
+
+        }
+
+}
diff --git a/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyFieldValueFactory.java b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyFieldValueFactory.java
new file mode 100644
index 0000000000..f2814fbcbe
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyFieldValueFactory.java
@@ -0,0 +1,66 @@
+/*
+ * 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.wicket;
+
+import java.lang.reflect.Field;
+
+import org.apache.tuscany.sca.implementation.web.runtime.utils.ContextHelper;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.wicket.injection.IFieldValueFactory;
+import org.oasisopen.sca.annotation.ComponentName;
+import org.oasisopen.sca.annotation.Context;
+import org.oasisopen.sca.annotation.Property;
+import org.oasisopen.sca.annotation.Reference;
+
+public class TuscanyFieldValueFactory implements IFieldValueFactory {
+
+    private IContextLocator contextLocator;
+    
+    public TuscanyFieldValueFactory(IContextLocator contextLocator) {
+        this.contextLocator = contextLocator;
+    }
+
+    public Object getFieldValue(Field field, Object instance) {
+        Object value = null;
+        if (field.isAnnotationPresent(Reference.class)) {
+            Reference ref = field.getAnnotation(Reference.class);
+            String name = ref.name() != null && !ref.name().equals("") ? ref.name() : field.getName();
+            value = ContextHelper.getReference(name, field.getType(), contextLocator.getServletContext());
+        } else if (field.isAnnotationPresent(Property.class)) {
+            Property prop = field.getAnnotation(Property.class);
+            String name = prop.name() != null && !prop.name().equals("") ? prop.name() : field.getName();
+            value = ContextHelper.getProperty(name, contextLocator.getServletContext());
+        } else if (field.isAnnotationPresent(ComponentName.class)) {
+            RuntimeComponent rc = (RuntimeComponent)contextLocator.getServletContext().getAttribute(ContextHelper.COMPONENT_ATTR);
+            value = rc.getName();
+        } else if (field.isAnnotationPresent(Context.class)) {
+            value = ContextHelper.getComponentContext(contextLocator.getServletContext());
+        }
+        return value;
+    }
+
+    public boolean supportsField(Field field) {
+        return field.isAnnotationPresent(Reference.class) 
+            || field.isAnnotationPresent(Property.class)
+            || field.isAnnotationPresent(Context.class)
+            || field.isAnnotationPresent(ComponentName.class);
+    }
+
+}
diff --git a/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyInjector.java b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyInjector.java
new file mode 100644
index 0000000000..03c44d96f6
--- /dev/null
+++ b/sca-java-2.x/trunk/modules/wicket/src/main/java/org/apache/tuscany/sca/wicket/TuscanyInjector.java
@@ -0,0 +1,38 @@
+/*
+ * 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.wicket;
+
+import org.apache.wicket.injection.ConfigurableInjector;
+import org.apache.wicket.injection.IFieldValueFactory;
+
+public class TuscanyInjector extends ConfigurableInjector {
+
+    private TuscanyFieldValueFactory factory;
+
+    public TuscanyInjector(IContextLocator contextLocator) {
+        factory = new TuscanyFieldValueFactory(contextLocator);
+    }
+
+    @Override
+    protected IFieldValueFactory getFieldValueFactory() {
+        return factory;
+    }
+
+}