geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From djen...@apache.org
Subject svn commit: r706357 [4/13] - in /geronimo/server/trunk/plugins/connector-1_6: ./ client-transaction-1_6/ client-transaction-1_6/src/ client-transaction-1_6/src/main/ client-transaction-1_6/src/main/history/ client-transaction-1_6/src/main/plan/ client-...
Date Mon, 20 Oct 2008 18:23:42 GMT
Added: geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
URL: http://svn.apache.org/viewvc/geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java?rev=706357&view=auto
==============================================================================
--- geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
(added)
+++ geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
Mon Oct 20 11:23:36 2008
@@ -0,0 +1,508 @@
+/**
+ *  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.geronimo.connector.deployment;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Resource;
+import javax.naming.Reference;
+import javax.xml.namespace.QName;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.geronimo.common.DeploymentException;
+import org.apache.geronimo.common.UnresolvedReferenceException;
+import org.apache.geronimo.gbean.AbstractNameQuery;
+import org.apache.geronimo.gbean.GBeanInfo;
+import org.apache.geronimo.gbean.GBeanInfoBuilder;
+import org.apache.geronimo.j2ee.deployment.EARContext;
+import org.apache.geronimo.j2ee.deployment.Module;
+import org.apache.geronimo.j2ee.deployment.annotation.AnnotatedApp;
+import org.apache.geronimo.j2ee.deployment.annotation.ResourceAnnotationHelper;
+import org.apache.geronimo.j2ee.j2eeobjectnames.NameFactory;
+import org.apache.geronimo.kernel.GBeanNotFoundException;
+import org.apache.geronimo.kernel.config.Configuration;
+import org.apache.geronimo.kernel.repository.Environment;
+import org.apache.geronimo.naming.deployment.AbstractNamingBuilder;
+import org.apache.geronimo.naming.reference.ResourceReferenceFactory;
+import org.apache.geronimo.naming.reference.UserTransactionReference;
+import org.apache.geronimo.xbeans.geronimo.naming.GerMessageDestinationDocument;
+import org.apache.geronimo.xbeans.geronimo.naming.GerMessageDestinationType;
+import org.apache.geronimo.xbeans.geronimo.naming.GerPatternType;
+import org.apache.geronimo.xbeans.geronimo.naming.GerResourceEnvRefDocument;
+import org.apache.geronimo.xbeans.geronimo.naming.GerResourceEnvRefType;
+import org.apache.geronimo.xbeans.javaee.DescriptionType;
+import org.apache.geronimo.xbeans.javaee.FullyQualifiedClassType;
+import org.apache.geronimo.xbeans.javaee.InjectionTargetType;
+import org.apache.geronimo.xbeans.javaee.JndiNameType;
+import org.apache.geronimo.xbeans.javaee.MessageDestinationRefType;
+import org.apache.geronimo.xbeans.javaee.MessageDestinationType;
+import org.apache.geronimo.xbeans.javaee.MessageDestinationTypeType;
+import org.apache.geronimo.xbeans.javaee.ResourceEnvRefType;
+import org.apache.geronimo.xbeans.javaee.XsdStringType;
+import org.apache.xmlbeans.QNameSet;
+import org.apache.xmlbeans.XmlObject;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class AdminObjectRefBuilder extends AbstractNamingBuilder {
+    private static final Logger log = LoggerFactory.getLogger(AdminObjectRefBuilder.class);
+    private final QNameSet adminOjbectRefQNameSet;
+    private final QNameSet messageDestinationQNameSet;
+    private final QNameSet messageDestinationRefQNameSet;
+
+    private static final QName GER_ADMIN_OBJECT_REF_QNAME = GerResourceEnvRefDocument.type.getDocumentElementName();
+    private static final QNameSet GER_ADMIN_OBJECT_REF_QNAME_SET = QNameSet.singleton(GER_ADMIN_OBJECT_REF_QNAME);
+    private static final QName GER_MESSAGE_DESTINATION_QNAME = GerMessageDestinationDocument.type.getDocumentElementName();
+    private static final QNameSet GER_MESSAGE_DESTINATION_QNAME_SET = QNameSet.singleton(GER_MESSAGE_DESTINATION_QNAME);
+
+    public AdminObjectRefBuilder(Environment defaultEnvironment, String[] eeNamespaces) {
+        super(defaultEnvironment);
+        adminOjbectRefQNameSet = buildQNameSet(eeNamespaces, "resource-env-ref");
+        messageDestinationQNameSet = buildQNameSet(eeNamespaces, "message-destination");
+        messageDestinationRefQNameSet = buildQNameSet(eeNamespaces, "message-destination-ref");
+    }
+
+    protected boolean willMergeEnvironment(XmlObject specDD, XmlObject plan) {
+        return specDD.selectChildren(adminOjbectRefQNameSet).length > 0 || specDD.selectChildren(messageDestinationRefQNameSet).length
> 0;
+    }
+
+    public void initContext(XmlObject specDD, XmlObject plan, Module module) throws DeploymentException
{
+        List<MessageDestinationType> specDestinations = convert(specDD.selectChildren(messageDestinationQNameSet),
JEE_CONVERTER, MessageDestinationType.class, MessageDestinationType.type);
+        XmlObject[] gerDestinations = plan.selectChildren(GER_MESSAGE_DESTINATION_QNAME_SET);
+        Map<String, GerMessageDestinationType> nameMap = new HashMap<String, GerMessageDestinationType>();
+        for (XmlObject gerDestination : gerDestinations) {
+            GerMessageDestinationType destination = (GerMessageDestinationType) gerDestination.copy().changeType(GerMessageDestinationType.type);
+            String name = destination.getMessageDestinationName().trim();
+            nameMap.put(name, destination);
+            boolean found = false;
+            for (MessageDestinationType specDestination : specDestinations) {
+                if (specDestination.getMessageDestinationName().getStringValue().trim().equals(name))
{
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                throw new DeploymentException("No spec DD message-destination for " + name);
+            }
+        }
+        module.getRootEarContext().registerMessageDestionations(module.getName(), nameMap);
+    }
+
+
+    public void buildNaming(XmlObject specDD, XmlObject plan, Module module, Map componentContext)
throws DeploymentException {
+        XmlObject[] gerResourceEnvRefsUntyped = plan == null ? NO_REFS : plan.selectChildren(GER_ADMIN_OBJECT_REF_QNAME_SET);
+        Map<String, GerResourceEnvRefType> refMap = mapResourceEnvRefs(gerResourceEnvRefsUntyped);
+        int initialGerRefSize = refMap.size();
+        Map<String, Map<String, GerMessageDestinationType>> messageDestinations
= module.getRootEarContext().getMessageDestinations();
+
+        // Discover and process any @Resource annotations (if !metadata-complete)
+        if (module.getClassFinder() != null) {
+
+            // Process all the annotations for this naming builder type
+            try {
+                ResourceAnnotationHelper.processAnnotations(module.getAnnotatedApp(), module.getClassFinder(),
new AdminObjectRefProcessor(refMap, messageDestinations, module.getEarContext()));
+            }
+            catch (Exception e) {
+                log.warn("Unable to process @Resource annotations for module" + module.getName(),
e);
+            }
+        }
+
+        List<ResourceEnvRefType> resourceEnvRefsUntyped = convert(specDD.selectChildren(adminOjbectRefQNameSet),
JEE_CONVERTER, ResourceEnvRefType.class, ResourceEnvRefType.type);
+        int unresolvedRefSize = resourceEnvRefsUntyped.size();
+        ClassLoader cl = module.getEarContext().getClassLoader();
+        for (ResourceEnvRefType resourceEnvRef : resourceEnvRefsUntyped) {
+            String name = resourceEnvRef.getResourceEnvRefName().getStringValue().trim();
+            if (lookupJndiContextMap(componentContext, ENV + name) != null) {
+                // some other builder handled this entry already
+                continue;
+            }
+            addInjections(name, resourceEnvRef.getInjectionTargetArray(), componentContext);
+            String type = resourceEnvRef.getResourceEnvRefType().getStringValue().trim();
+            Class iface;
+            try {
+                iface = cl.loadClass(type);
+            } catch (ClassNotFoundException e) {
+                throw new DeploymentException("could not load class " + type, e);
+            }
+            GerResourceEnvRefType gerResourceEnvRef = refMap.get(name);
+            refMap.remove(name);
+            try {
+                String refType = getStringValue(resourceEnvRef.getResourceEnvRefType());
+                if (refType.equals("javax.transaction.UserTransaction")) {
+                    Reference ref = new UserTransactionReference();
+                    getJndiContextMap(componentContext).put(ENV + name, ref);
+                } else {
+                    AbstractNameQuery containerId = getAdminObjectContainerId(name, gerResourceEnvRef);
+                    ResourceReferenceFactory<RuntimeException> ref = buildAdminObjectReference(module,
containerId, iface);
+                    getJndiContextMap(componentContext).put(ENV + name, ref);
+                }
+            } catch (UnresolvedReferenceException e) {
+                throw new DeploymentException("Unable to resolve resource env reference '"
+ name + "' (" + (e.isMultiple() ? "found multiple matching resources" : "no matching resources
found") + ")", e);
+            }
+        }
+        
+        if (refMap.size() > 0 && ((initialGerRefSize - unresolvedRefSize) != refMap.size()))
{
+            log.warn("Failed to build reference to Admin object reference "+refMap.keySet()+"
defined in plan file, reason - corresponding entry in deployment descriptor missing.");
+        }
+        
+        //message-destination-refs
+        List<MessageDestinationRefType> messageDestinationRefsUntyped = convert(specDD.selectChildren(messageDestinationRefQNameSet),
JEE_CONVERTER, MessageDestinationRefType.class, MessageDestinationRefType.type);
+
+        for (MessageDestinationRefType messageDestinationRef : messageDestinationRefsUntyped)
{
+            String name = getStringValue(messageDestinationRef.getMessageDestinationRefName());
+            if (lookupJndiContextMap(componentContext, ENV + name) != null) {
+                // some other builder handled this entry already
+                continue;
+            }
+            addInjections(name, messageDestinationRef.getInjectionTargetArray(), componentContext);
+            String linkName = getStringValue(messageDestinationRef.getMessageDestinationLink());
+            //TODO figure out something better to do here!
+            if (linkName == null) {
+                linkName = name;
+            }
+            String type = getStringValue(messageDestinationRef.getMessageDestinationType());
+            if (type == null) {
+                //must have an injection target to determine type EE5.8.1.3
+                InjectionTargetType[] targets = messageDestinationRef.getInjectionTargetArray();
+                if (targets.length == 0) {
+                    throw new DeploymentException("No type for message-destination-ref can
be determined from explicit specification or injection target: " + messageDestinationRef);
+                }
+                type = getStringValue(targets[0].getInjectionTargetClass());
+                if (type == null) {
+                    throw new DeploymentException("no type for message destination ref in
injection target: " + targets[0]);
+                }
+            }
+            Class iface;
+            try {
+                iface = cl.loadClass(type);
+            } catch (ClassNotFoundException e) {
+                throw new DeploymentException("could not load class " + type, e);
+            }
+            String moduleURI = null;
+            GerMessageDestinationType destination = getMessageDestination(linkName, messageDestinations);
+            if (destination != null) {
+                if (destination.isSetAdminObjectLink()) {
+                    if (destination.isSetAdminObjectModule()) {
+                        moduleURI = destination.getAdminObjectModule().trim();
+                    }
+                    linkName = destination.getAdminObjectLink().trim();
+                }
+            } else {
+                //well, we know for sure an admin object is not going to be defined in a
modules that can have a message-destination
+                int pos = linkName.indexOf('#');
+                if (pos > -1) {
+                    //AMM -- the following line causes blowups; e.g. to look in DayTrader
EJB module for a RA -- why is that?!?
+                    //moduleURI = linkName.substring(0, pos);
+                    linkName = linkName.substring(pos + 1);
+                }
+            }
+
+            //try to resolve ref based only matching resource-ref-name
+            //throws exception if it can't locate ref.
+            AbstractNameQuery containerId = buildAbstractNameQuery(null, moduleURI, linkName,
NameFactory.JCA_ADMIN_OBJECT, NameFactory.RESOURCE_ADAPTER_MODULE);
+            ResourceReferenceFactory<RuntimeException> ref = buildAdminObjectReference(module,
containerId, iface);
+            getJndiContextMap(componentContext).put(ENV + name, ref);
+
+        }
+
+    }
+
+    public static GerMessageDestinationType getMessageDestination(String messageDestinationLink,
Map<String, Map<String, GerMessageDestinationType>> messageDestinations) throws
DeploymentException {
+        GerMessageDestinationType destination = null;
+        int pos = messageDestinationLink.indexOf('#');
+        if (pos > -1) {
+            String targetModule = messageDestinationLink.substring(0, pos);
+            Map<String, GerMessageDestinationType> destinations = messageDestinations.get(targetModule);
+            // Hmmm...if we don't find the module then something is wrong in the deployment.
+            if (destinations == null) {
+                StringBuffer sb = new StringBuffer();
+                for (Object o : messageDestinations.keySet()) {
+                    sb.append(o).append("\n");
+                }
+                throw new DeploymentException("Unknown module " + targetModule + " when processing
message destination " + messageDestinationLink +
+                        "\nKnown modules in deployable unit are:\n" + sb.toString());
+            }
+            messageDestinationLink = messageDestinationLink.substring(pos + 1);
+            destination = destinations.get(messageDestinationLink);
+        } else {
+            for (Map<String, GerMessageDestinationType> destinations : messageDestinations.values())
{
+                GerMessageDestinationType destinationTest = destinations.get(messageDestinationLink);
+                if (destinationTest != null) {
+                    if (destination != null) {
+                        throw new DeploymentException("Duplicate message destination " +
messageDestinationLink + " accessed from a message-destination-link without a module");
+                    }
+                    destination = destinationTest;
+                }
+            }
+        }
+        return destination;
+    }
+
+
+    private ResourceReferenceFactory<RuntimeException> buildAdminObjectReference(Module
module, AbstractNameQuery containerId, Class iface) throws DeploymentException {
+        Configuration localConfiguration = module.getEarContext().getConfiguration();
+        try {
+            localConfiguration.findGBean(containerId);
+        } catch (GBeanNotFoundException e) {
+            throw new DeploymentException("Can not resolve admin object ref " + containerId
+ " in configuration " + localConfiguration.getId(), e);
+        }
+        return new ResourceReferenceFactory<RuntimeException>(module.getConfigId(),
containerId, iface);
+    }
+
+    private static AbstractNameQuery getAdminObjectContainerId(String name, GerResourceEnvRefType
gerResourceEnvRef) {
+        AbstractNameQuery containerId;
+        if (gerResourceEnvRef == null) {
+            containerId = buildAbstractNameQuery(null, null, name, NameFactory.JCA_ADMIN_OBJECT,
NameFactory.RESOURCE_ADAPTER_MODULE);
+        } else if (gerResourceEnvRef.isSetMessageDestinationLink()) {
+            containerId = buildAbstractNameQuery(null, null, gerResourceEnvRef.getMessageDestinationLink().trim(),
NameFactory.JCA_ADMIN_OBJECT, NameFactory.RESOURCE_ADAPTER_MODULE);
+        } else if (gerResourceEnvRef.isSetAdminObjectLink()) {
+            String moduleURI = null;
+            if (gerResourceEnvRef.isSetAdminObjectModule()) {
+                moduleURI = gerResourceEnvRef.getAdminObjectModule().trim();
+            }
+            containerId = buildAbstractNameQuery(null, moduleURI, gerResourceEnvRef.getAdminObjectLink().trim(),
NameFactory.JCA_ADMIN_OBJECT, NameFactory.RESOURCE_ADAPTER_MODULE);
+        } else {
+            //construct name from components
+            GerPatternType patternType = gerResourceEnvRef.getPattern();
+            containerId = buildAbstractNameQuery(patternType, NameFactory.JCA_ADMIN_OBJECT,
NameFactory.RESOURCE_ADAPTER_MODULE, null);
+        }
+        return containerId;
+    }
+
+    private static Map<String, GerResourceEnvRefType> mapResourceEnvRefs(XmlObject[]
refs) {
+        Map<String, GerResourceEnvRefType> refMap = new HashMap<String, GerResourceEnvRefType>();
+        if (refs != null) {
+            for (XmlObject ref1 : refs) {
+                GerResourceEnvRefType ref = (GerResourceEnvRefType) ref1.copy().changeType(GerResourceEnvRefType.type);
+                refMap.put(ref.getRefName().trim(), ref);
+            }
+        }
+        return refMap;
+    }
+
+    public QNameSet getSpecQNameSet() {
+        return adminOjbectRefQNameSet;
+    }
+
+    public QNameSet getPlanQNameSet() {
+        return GER_ADMIN_OBJECT_REF_QNAME_SET;
+    }
+
+    public static class AdminObjectRefProcessor extends ResourceAnnotationHelper.ResourceProcessor
{
+        public static final AdminObjectRefProcessor INSTANCE = new AdminObjectRefProcessor(null,
null, null);
+
+        private final EARContext earContext;
+        private final Map<String, GerResourceEnvRefType> refMap;
+        private final Map<String, Map<String, GerMessageDestinationType>> messageDestinations;
+
+        public AdminObjectRefProcessor(Map<String, GerResourceEnvRefType> refMap, Map<String,
Map<String, GerMessageDestinationType>> messageDestinations, EARContext earContext)
{
+            this.refMap = refMap;
+            this.messageDestinations = messageDestinations;
+            this.earContext = earContext;
+        }
+
+        public boolean processResource(AnnotatedApp annotatedApp, Resource annotation, Class
cls, Method method, Field field) throws DeploymentException {
+            String resourceName = getResourceName(annotation, method, field);
+            String resourceType = getResourceType(annotation, method, field);
+
+            if (resourceType.equals("javax.ejb.SessionContext")) return true;
+            if (resourceType.equals("javax.ejb.MessageDrivenContext")) return true;
+            if (resourceType.equals("javax.ejb.EntityContext")) return true;
+            if (resourceType.equals("javax.ejb.TimerService")) return true;
+
+            //If it already exists in xml as a message-destination-ref or resource-env-ref,
we are done.
+            MessageDestinationRefType[] messageDestinationRefs = annotatedApp.getMessageDestinationRefArray();
+            for (MessageDestinationRefType messageDestinationRef : messageDestinationRefs)
{
+                if (messageDestinationRef.getMessageDestinationRefName().getStringValue().trim().equals(resourceName))
{
+                    if (method != null || field != null) {
+                        InjectionTargetType[] targets = messageDestinationRef.getInjectionTargetArray();
+                        if (!hasTarget(method, field, targets)) {
+                            configureInjectionTarget(messageDestinationRef.addNewInjectionTarget(),
method, field);
+                        }
+                    }
+                    return true;
+                }
+            }
+            ResourceEnvRefType[] ResourceEnvRefs = annotatedApp.getResourceEnvRefArray();
+            for (ResourceEnvRefType resourceEnvRefType : ResourceEnvRefs) {
+                if (resourceEnvRefType.getResourceEnvRefName().getStringValue().trim().equals(resourceName))
{
+                    if (method != null || field != null) {
+                        InjectionTargetType[] targets = resourceEnvRefType.getInjectionTargetArray();
+                        if (!hasTarget(method, field, targets)) {
+                            configureInjectionTarget(resourceEnvRefType.addNewInjectionTarget(),
method, field);
+                        }
+                    }
+                    return true;
+                }
+            }
+
+            //if it maps to a message-destination in the geronimo plan, it's a message-destination.
+            GerMessageDestinationType gerMessageDestinationType = null;
+            if (messageDestinations != null) {
+                gerMessageDestinationType = getMessageDestination(resourceName, messageDestinations);
+            }
+            if (gerMessageDestinationType != null) {
+                addMethodDestinationRef(annotatedApp, resourceName, resourceType, method,
field, annotation);
+                return true;
+            } else {
+                //if it maps to a resource-env-ref in the geronimo plan, it's a resource-ref
+                GerResourceEnvRefType resourceEnvRefType = null;
+                if (refMap != null) {
+                    resourceEnvRefType = refMap.get(resourceName);
+                }
+                if (resourceEnvRefType != null || resourceType.equals("javax.transaction.UserTransaction"))
{
+                    //mapped resource-env-ref
+                    addResourceEnvRef(annotatedApp, resourceName, resourceType, method, field,
annotation);
+                    return true;
+                } else {
+                    if (earContext != null) {
+                        // look for an JCAAdminObject gbean with the right name
+                        AbstractNameQuery containerId = buildAbstractNameQuery(null, null,
resourceName,
+                                NameFactory.JCA_ADMIN_OBJECT, NameFactory.RESOURCE_ADAPTER_MODULE);
+                        try {
+                            earContext.findGBean(containerId);
+                        } catch (GBeanNotFoundException e) {
+                            // not identifiable as an admin object ref
+                            return false;
+                        }
+                    } else {
+                        if (!("javax.jms.Queue".equals(resourceType) || "javax.jms.Topic".equals(resourceType)

+                                || "javax.jms.Destination".equals(resourceType))) {
+                            // not identifiable as an admin object ref
+                            return false;
+                        }
+                    }
+                    addResourceEnvRef(annotatedApp, resourceName, resourceType, method, field,
annotation);
+                    return true;
+                }
+            }
+        }
+
+        private void addResourceEnvRef(AnnotatedApp annotatedApp, String resourceName, String
resourceType, Method method, Field field, Resource annotation) {
+            ResourceEnvRefType resourceEnvRef = annotatedApp.addNewResourceEnvRef();
+
+            //------------------------------------------------------------------------------
+            // <resource-env-ref> required elements:
+            //------------------------------------------------------------------------------
+
+            // resource-env-ref-name
+            JndiNameType resourceEnvRefName = resourceEnvRef.addNewResourceEnvRefName();
+            resourceEnvRefName.setStringValue(resourceName);
+            resourceEnvRef.setResourceEnvRefName(resourceEnvRefName);
+
+            if (!resourceType.equals("")) {
+                // resource-env-ref-type
+                FullyQualifiedClassType qualifiedClass = resourceEnvRef.addNewResourceEnvRefType();
+                qualifiedClass.setStringValue(resourceType);
+                resourceEnvRef.setResourceEnvRefType(qualifiedClass);
+            }
+            if (method != null || field != null) {
+                // injectionTarget
+                InjectionTargetType injectionTarget = resourceEnvRef.addNewInjectionTarget();
+                configureInjectionTarget(injectionTarget, method, field);
+            }
+
+            //------------------------------------------------------------------------------
+            // <resource-env-ref> optional elements:
+            //------------------------------------------------------------------------------
+
+            // description
+            String descriptionAnnotation = annotation.description();
+            if (!descriptionAnnotation.equals("")) {
+                DescriptionType description = resourceEnvRef.addNewDescription();
+                description.setStringValue(descriptionAnnotation);
+            }
+
+            // mappedName
+            String mappdedNameAnnotation = annotation.mappedName();
+            if (!mappdedNameAnnotation.equals("")) {
+                XsdStringType mappedName = resourceEnvRef.addNewMappedName();
+                mappedName.setStringValue(mappdedNameAnnotation);
+                resourceEnvRef.setMappedName(mappedName);
+            }
+        }
+
+        private void addMethodDestinationRef(AnnotatedApp annotatedApp, String resourceName,
String resourceType, Method method, Field field, Resource annotation) {
+            MessageDestinationRefType messageDestinationRef = annotatedApp.addNewMessageDestinationRef();
+
+            //------------------------------------------------------------------------------
+            // <message-destination-ref> required elements:
+            //------------------------------------------------------------------------------
+
+            // message-destination-ref-name
+            JndiNameType messageDestinationRefName = messageDestinationRef.addNewMessageDestinationRefName();
+            messageDestinationRefName.setStringValue(resourceName);
+            messageDestinationRef.setMessageDestinationRefName(messageDestinationRefName);
+
+            if (!resourceType.equals("")) {
+                // message-destination-ref-type
+                MessageDestinationTypeType msgDestType = messageDestinationRef.addNewMessageDestinationType();
+                msgDestType.setStringValue(resourceType);
+                messageDestinationRef.setMessageDestinationType(msgDestType);
+            }
+            if (method != null || field != null) {
+                // injectionTarget
+                InjectionTargetType injectionTarget = messageDestinationRef.addNewInjectionTarget();
+                configureInjectionTarget(injectionTarget, method, field);
+            }
+
+            //------------------------------------------------------------------------------
+            // <message-destination-ref> optional elements:
+            //------------------------------------------------------------------------------
+
+            // description
+            String descriptionAnnotation = annotation.description();
+            if (!descriptionAnnotation.equals("")) {
+                DescriptionType description = messageDestinationRef.addNewDescription();
+                description.setStringValue(descriptionAnnotation);
+            }
+
+            // mappedName
+            String mappdedNameAnnotation = annotation.mappedName();
+            if (!mappdedNameAnnotation.equals("")) {
+                XsdStringType mappedName = messageDestinationRef.addNewMappedName();
+                mappedName.setStringValue(mappdedNameAnnotation);
+                messageDestinationRef.setMappedName(mappedName);
+            }
+        }
+    }
+
+    public static final GBeanInfo GBEAN_INFO;
+
+    static {
+        GBeanInfoBuilder infoBuilder = GBeanInfoBuilder.createStatic(AdminObjectRefBuilder.class,
NameFactory.MODULE_BUILDER);
+        infoBuilder.addAttribute("eeNamespaces", String[].class, true, true);
+        infoBuilder.addAttribute("defaultEnvironment", Environment.class, true, true);
+
+        infoBuilder.setConstructor(new String[]{"defaultEnvironment", "eeNamespaces"});
+
+        GBEAN_INFO = infoBuilder.getBeanInfo();
+    }
+
+    public static GBeanInfo getGBeanInfo
+            () {
+        return GBEAN_INFO;
+    }
+
+}

Propchange: geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision

Propchange: geronimo/server/trunk/plugins/connector-1_6/geronimo-connector-builder-1_6/src/main/java/org/apache/geronimo/connector/deployment/AdminObjectRefBuilder.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message