ConnectorModuleBuilder


1   /**
2    *  Licensed to the Apache Software Foundation (ASF) under one or more
3    *  contributor license agreements.  See the NOTICE file distributed with
4    *  this work for additional information regarding copyright ownership.
5    *  The ASF licenses this file to You under the Apache License, Version 2.0
6    *  (the "License"); you may not use this file except in compliance with
7    *  the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   *  Unless required by applicable law or agreed to in writing, software
12   *  distributed under the License is distributed on an "AS IS" BASIS,
13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   *  See the License for the specific language governing permissions and
15   *  limitations under the License.
16   */
17  package org.apache.geronimo.connector.deployment;
18  
19  import java.beans.Introspector  ;
20  import java.beans.PropertyEditor  ;
21  import java.io.File  ;
22  import java.io.IOException  ;
23  import java.lang.reflect.Method  ;
24  import java.net.URI  ;
25  import java.net.URL  ;
26  import java.util.ArrayList  ;
27  import java.util.Collection  ;
28  import java.util.Date  ;
29  import java.util.Enumeration  ;
30  import java.util.HashMap  ;
31  import java.util.HashSet  ;
32  import java.util.Iterator  ;
33  import java.util.LinkedHashMap  ;
34  import java.util.Map  ;
35  import java.util.Set  ;
36  import java.util.jar.JarFile  ;
37  import java.util.zip.ZipEntry  ;
38  
39  import javax.naming.Reference  ;
40  import javax.xml.namespace.QName  ;
41  
42  import org.apache.commons.logging.Log;
43  import org.apache.commons.logging.LogFactory;
44  import org.apache.geronimo.common.DeploymentException;
45  import org.apache.geronimo.common.UnresolvedReferenceException;
46  import org.apache.geronimo.common.propertyeditor.PropertyEditors;
47  import org.apache.geronimo.connector.ActivationSpecWrapperGBean;
48  import org.apache.geronimo.connector.AdminObjectWrapper;
49  import org.apache.geronimo.connector.AdminObjectWrapperGBean;
50  import org.apache.geronimo.connector.JCAResourceImplGBean;
51  import org.apache.geronimo.connector.ResourceAdapterImplGBean;
52  import org.apache.geronimo.connector.ResourceAdapterModuleImplGBean;
53  import org.apache.geronimo.connector.ResourceAdapterWrapperGBean;
54  import org.apache.geronimo.connector.outbound.JCAConnectionFactoryImplGBean;
55  import org.apache.geronimo.connector.outbound.ManagedConnectionFactoryWrapper;
56  import org.apache.geronimo.connector.outbound.ManagedConnectionFactoryWrapperGBean;
57  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.LocalTransactions;
58  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.NoPool;
59  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.NoTransactions;
60  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.PartitionedPool;
61  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.PoolingSupport;
62  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.SinglePool;
63  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.TransactionLog;
64  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.TransactionSupport;
65  import org.apache.geronimo.connector.outbound.connectionmanagerconfig.XATransactions;
66  import org.apache.geronimo.deployment.ModuleIDBuilder;
67  import org.apache.geronimo.deployment.NamespaceDrivenBuilder;
68  import org.apache.geronimo.deployment.NamespaceDrivenBuilderCollection;
69  import org.apache.geronimo.deployment.service.EnvironmentBuilder;
70  import org.apache.geronimo.deployment.service.GBeanBuilder;
71  import org.apache.geronimo.deployment.util.DeploymentUtil;
72  import org.apache.geronimo.deployment.xbeans.EnvironmentType;
73  import org.apache.geronimo.deployment.xmlbeans.XmlBeansUtil;
74  import org.apache.geronimo.gbean.AbstractName;
75  import org.apache.geronimo.gbean.AbstractNameQuery;
76  import org.apache.geronimo.gbean.DynamicGAttributeInfo;
77  import org.apache.geronimo.gbean.GAttributeInfo;
78  import org.apache.geronimo.gbean.GBeanData;
79  import org.apache.geronimo.gbean.GBeanInfo;
80  import org.apache.geronimo.gbean.GBeanInfoBuilder;
81  import org.apache.geronimo.gbean.InvalidConfigurationException;
82  import org.apache.geronimo.j2ee.deployment.ActivationSpecInfoLocator;
83  import org.apache.geronimo.j2ee.deployment.ConnectorModule;
84  import org.apache.geronimo.j2ee.deployment.EARContext;
85  import org.apache.geronimo.j2ee.deployment.Module;
86  import org.apache.geronimo.j2ee.deployment.ModuleBuilder;
87  import org.apache.geronimo.j2ee.j2eeobjectnames.NameFactory;
88  import org.apache.geronimo.kernel.GBeanAlreadyExistsException;
89  import org.apache.geronimo.kernel.GBeanNotFoundException;
90  import org.apache.geronimo.kernel.Naming;
91  import org.apache.geronimo.kernel.config.Configuration;
92  import org.apache.geronimo.kernel.config.ConfigurationStore;
93  import org.apache.geronimo.kernel.repository.Environment;
94  import org.apache.geronimo.management.JCAConnectionFactory;
95  import org.apache.geronimo.management.geronimo.JCAAdminObject;
96  import org.apache.geronimo.management.geronimo.JCAResourceAdapter;
97  import org.apache.geronimo.management.geronimo.ResourceAdapterModule;
98  import org.apache.geronimo.naming.deployment.ENCConfigBuilder;
99  import org.apache.geronimo.naming.reference.ResourceReference;
100 import org.apache.geronimo.schema.SchemaConversionUtils;
101 import org.apache.geronimo.xbeans.geronimo.GerAdminobjectInstanceType;
102 import org.apache.geronimo.xbeans.geronimo.GerAdminobjectType;
103 import org.apache.geronimo.xbeans.geronimo.GerConfigPropertySettingType;
104 import org.apache.geronimo.xbeans.geronimo.GerConnectionDefinitionType;
105 import org.apache.geronimo.xbeans.geronimo.GerConnectiondefinitionInstanceType;
106 import org.apache.geronimo.xbeans.geronimo.GerConnectionmanagerType;
107 import org.apache.geronimo.xbeans.geronimo.GerConnectorDocument;
108 import org.apache.geronimo.xbeans.geronimo.GerConnectorType;
109 import org.apache.geronimo.xbeans.geronimo.GerPartitionedpoolType;
110 import org.apache.geronimo.xbeans.geronimo.GerResourceadapterType;
111 import org.apache.geronimo.xbeans.geronimo.GerSinglepoolType;
112 import org.apache.geronimo.xbeans.j2ee.ActivationspecType;
113 import org.apache.geronimo.xbeans.j2ee.AdminobjectType;
114 import org.apache.geronimo.xbeans.j2ee.ConfigPropertyType;
115 import org.apache.geronimo.xbeans.j2ee.ConnectionDefinitionType;
116 import org.apache.geronimo.xbeans.j2ee.ConnectorDocument;
117 import org.apache.geronimo.xbeans.j2ee.ConnectorType;
118 import org.apache.geronimo.xbeans.j2ee.MessagelistenerType;
119 import org.apache.geronimo.xbeans.j2ee.ResourceadapterType;
120 import org.apache.xmlbeans.XmlCursor;
121 import org.apache.xmlbeans.XmlDocumentProperties;
122 import org.apache.xmlbeans.XmlException;
123 import org.apache.xmlbeans.XmlObject;
124 
125 /**
126  * @version $Rev:385659 $ $Date: 2006-11-16 23:35:17 -0500 (Thu, 16 Nov 2006) $
127  */
128 public class ConnectorModuleBuilder implements ModuleBuilder, ActivationSpecInfoLocator {
129     private final static Log log = LogFactory.getLog(ConnectorModuleBuilder.class);
130 
131     private static QName   CONNECTOR_QNAME = GerConnectorDocument.type.getDocumentElementName();
132     static final String   GERCONNECTOR_NAMESPACE = CONNECTOR_QNAME.getNamespaceURI();
133 
134     private final int defaultMaxSize;
135     private final int defaultMinSize;
136     private final int defaultBlockingTimeoutMilliseconds;
137     private final int defaultIdleTimeoutMinutes;
138     private final boolean defaultXATransactionCaching;
139     private final boolean defaultXAThreadCaching;
140     private final Environment defaultEnvironment;
141     private final NamespaceDrivenBuilderCollection serviceBuilders;
142     private static final QName   RESOURCE_ADAPTER_VERSION = new QName  (SchemaConversionUtils.J2EE_NAMESPACE, "resourceadapter-version");
143 
144     public ConnectorModuleBuilder(Environment defaultEnvironment,
145             int defaultMaxSize,
146             int defaultMinSize,
147             int defaultBlockingTimeoutMilliseconds,
148             int defaultIdleTimeoutMinutes,
149             boolean defaultXATransactionCaching,
150             boolean defaultXAThreadCaching,
151             Collection   serviceBuilders) {
152         this.defaultEnvironment = defaultEnvironment;
153 
154         this.defaultMaxSize = defaultMaxSize;
155         this.defaultMinSize = defaultMinSize;
156         this.defaultBlockingTimeoutMilliseconds = defaultBlockingTimeoutMilliseconds;
157         this.defaultIdleTimeoutMinutes = defaultIdleTimeoutMinutes;
158         this.defaultXATransactionCaching = defaultXATransactionCaching;
159         this.defaultXAThreadCaching = defaultXAThreadCaching;
160         this.serviceBuilders = new NamespaceDrivenBuilderCollection(serviceBuilders, GBeanBuilder.SERVICE_QNAME);
161     }
162 
163     public Module createModule(File   plan, JarFile   moduleFile, Naming naming, ModuleIDBuilder idBuilder) throws DeploymentException {
164         return createModule(plan, moduleFile, "rar", null, null, null, naming, idBuilder);
165     }
166 
167     public Module createModule(Object   plan, JarFile   moduleFile, String   targetPath, URL   specDDUrl, Environment environment, Object   moduleContextInfo, AbstractName earName, Naming naming, ModuleIDBuilder idBuilder) throws DeploymentException {
168         return createModule(plan, moduleFile, targetPath, specDDUrl, environment, earName, naming, idBuilder);
169     }
170 
171     private Module createModule(Object   plan, JarFile   moduleFile, String   targetPath, URL   specDDUrl, Environment earEnvironment, AbstractName earName, Naming naming, ModuleIDBuilder idBuilder) throws DeploymentException {
172         assert moduleFile != null: "moduleFile is null";
173         assert targetPath != null: "targetPath is null";
174         assert !targetPath.endsWith("/"): "targetPath must not end with a '/'";
175 
176         String   specDD;
177         XmlObject connector;
178         try {
179             if (specDDUrl == null) {
180                 specDDUrl = DeploymentUtil.createJarURL(moduleFile, "META-INF/ra.xml");
181             }
182 
183             // read in the entire specDD as a string, we need this for getDeploymentDescriptor
184             // on the J2ee management object
185             specDD = DeploymentUtil.readAll(specDDUrl);
186         } catch (Exception   e) {
187             //no ra.xml, not for us.
188             return null;
189         }
190         //we found ra.xml, if it won't parse it's an error.
191         try {
192             // parse it
193             XmlObject xmlObject = XmlBeansUtil.parse(specDD);
194             ConnectorDocument connectorDoc = convertToConnectorSchema(xmlObject);
195             connector = connectorDoc.getConnector();
196         } catch (XmlException e) {
197             throw new DeploymentException("Could not parse ra.xml descriptor", e);
198         }
199         GerConnectorType gerConnector = null;
200         try {
201             // load the geronimo connector plan from either the supplied plan or from the earFile
202             try {
203                 if (plan instanceof XmlObject) {
204                     gerConnector = (GerConnectorType) SchemaConversionUtils.getNestedObjectAsType((XmlObject) plan,
205                             CONNECTOR_QNAME,
206                             GerConnectorType.type);
207                 } else {
208                     GerConnectorDocument gerConnectorDoc;
209                     ArrayList   errors = new ArrayList  ();
210                     if (plan != null) {
211                         gerConnectorDoc = GerConnectorDocument.Factory.parse((File  ) plan, XmlBeansUtil.createXmlOptions(errors));
212                     } else {
213                         URL   path = DeploymentUtil.createJarURL(moduleFile, "META-INF/geronimo-ra.xml");
214                         gerConnectorDoc = GerConnectorDocument.Factory.parse(path, XmlBeansUtil.createXmlOptions(errors));
215                     }
216                     if (errors.size() > 0) {
217                         throw new DeploymentException("Could not parse connector doc: " + errors);
218                     }
219                     if (gerConnectorDoc != null) {
220                         gerConnector = gerConnectorDoc.getConnector();
221                     }
222                 }
223             } catch (IOException   e) {
224                 //do nothing
225             }
226 
227             // if we got one extract the validate it otherwise create a default one
228             if (gerConnector == null) {
229                 throw new DeploymentException("A connector module must be deployed using a Geronimo deployment plan" +
230                         " (either META-INF/geronimo-ra.xml in the RAR file or a standalone deployment plan passed to the deployer).");
231             }
232             ConnectorPlanRectifier.rectifyPlan(gerConnector);
233             XmlCursor cursor = gerConnector.newCursor();
234             try {
235                 SchemaConversionUtils.convertToGeronimoSubSchemas(cursor);
236             } finally {
237                 cursor.dispose();
238             }
239 
240             XmlBeansUtil.validateDD(gerConnector);
241         } catch (XmlException e) {
242             throw new DeploymentException(e);
243         }
244 
245         EnvironmentType environmentType = gerConnector.getEnvironment();
246         Environment environment = EnvironmentBuilder.buildEnvironment(environmentType, defaultEnvironment);
247         if (earEnvironment != null) {
248             EnvironmentBuilder.mergeEnvironments(earEnvironment, environment);
249             environment = earEnvironment;
250             if (!environment.getConfigId().isResolved()) {
251                 throw new IllegalStateException  ("Connector module ID should be fully resolved (not " + environment.getConfigId() + ")");
252             }
253         } else {
254             idBuilder.resolve(environment, new File  (moduleFile.getName()).getName(), "rar");
255         }
256 
257         AbstractName moduleName;
258         if (earName == null) {
259             earName = naming.createRootName(environment.getConfigId(), NameFactory.NULL, NameFactory.J2EE_APPLICATION);
260             moduleName = naming.createChildName(earName, environment.getConfigId().toString(), NameFactory.RESOURCE_ADAPTER_MODULE);
261         } else {
262             moduleName = naming.createChildName(earName, targetPath, NameFactory.RESOURCE_ADAPTER_MODULE);
263         }
264 
265         boolean standAlone = earEnvironment == null;
266         return new ConnectorModule(standAlone, moduleName, environment, moduleFile, targetPath, connector, gerConnector, specDD);
267     }
268 
269     static ConnectorDocument convertToConnectorSchema(XmlObject xmlObject) throws XmlException {
270         if (ConnectorDocument.type.equals(xmlObject.schemaType())) {
271             XmlBeansUtil.validateDD(xmlObject);
272             return (ConnectorDocument) xmlObject;
273         }
274         XmlCursor cursor = xmlObject.newCursor();
275         XmlDocumentProperties xmlDocumentProperties = cursor.documentProperties();
276         String   publicId = xmlDocumentProperties.getDoctypePublicId();
277         try {
278             if ("-//Sun Microsystems, Inc.//DTD Connector 1.0//EN".equals(publicId)) {
279                 XmlCursor moveable = xmlObject.newCursor();
280                 try {
281                     String   schemaLocationURL = "http://java.sun.com/xml/ns/j2ee/connector_1_5.xsd";
282                     String   version = "1.5";
283                     SchemaConversionUtils.convertToSchema(cursor, SchemaConversionUtils.J2EE_NAMESPACE, schemaLocationURL, version);
284                     cursor.toStartDoc();
285                     cursor.toChild(SchemaConversionUtils.J2EE_NAMESPACE, "connector");
286                     cursor.toFirstChild();
287                     SchemaConversionUtils.convertToDescriptionGroup(SchemaConversionUtils.J2EE_NAMESPACE, cursor, moveable);
288                     cursor.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "spec-version");
289                     cursor.removeXml();
290                     cursor.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "version");
291                     cursor.setName(RESOURCE_ADAPTER_VERSION);
292                     cursor.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "resourceadapter");
293                     moveable.toCursor(cursor);
294                     cursor.toFirstChild();
295                     cursor.beginElement("outbound-resourceadapter", SchemaConversionUtils.J2EE_NAMESPACE);
296                     cursor.beginElement("connection-definition", SchemaConversionUtils.J2EE_NAMESPACE);
297                     moveable.toChild(SchemaConversionUtils.J2EE_NAMESPACE, "managedconnectionfactory-class");
298                     moveable.push();
299                     //from moveable to cursor
300                     moveable.moveXml(cursor);
301                     while (moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "config-property")) {
302                         moveable.moveXml(cursor);
303                     }
304                     moveable.pop();
305                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "connectionfactory-interface");
306                     moveable.moveXml(cursor);
307                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "connectionfactory-impl-class");
308                     moveable.moveXml(cursor);
309                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "connection-interface");
310                     moveable.moveXml(cursor);
311                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "connection-impl-class");
312                     moveable.moveXml(cursor);
313                     //get out of connection-definition element
314                     cursor.toNextToken();
315                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "transaction-support");
316                     moveable.moveXml(cursor);
317                     while (moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "authentication-mechanism")) {
318                         moveable.moveXml(cursor);
319                     }
320                     moveable.toNextSibling(SchemaConversionUtils.J2EE_NAMESPACE, "reauthentication-support");
321                     moveable.moveXml(cursor);
322                 } finally {
323                     moveable.dispose();
324                 }
325 
326             }
327         } finally {
328             cursor.dispose();
329         }
330         XmlObject result = xmlObject.changeType(ConnectorDocument.type);
331         if (result != null) {
332             XmlBeansUtil.validateDD(result);
333             return (ConnectorDocument) result;
334         }
335         XmlBeansUtil.validateDD(xmlObject);
336         return (ConnectorDocument) xmlObject;
337 
338     }
339 
340     public void installModule(JarFile   earFile, EARContext earContext, Module module, Collection   configurationStores, ConfigurationStore targetConfigurationStore, Collection   repository) throws DeploymentException {
341         try {
342             JarFile   moduleFile = module.getModuleFile();
343 
344             // add the manifest classpath entries declared in the connector to the class loader
345             // we have to explicitly add these since we are unpacking the connector module
346             // and the url class loader will not pick up a manifiest from an unpacked dir
347             // N.B. If we ever introduce a separate configuration/module for a rar inside an ear
348             // this will need to be modified to use "../" instead of module.getTargetPath().
349             // See AbstractWebModuleBuilder.
350             earContext.addManifestClassPath(moduleFile, URI.create(module.getTargetPath()));
351 
352             URI   targetURI = URI.create(module.getTargetPath() + "/");
353             Enumeration   entries = moduleFile.entries();
354             while (entries.hasMoreElements()) {
355                 ZipEntry   entry = (ZipEntry  ) entries.nextElement();
356                 URI   target = targetURI.resolve(entry.getName());
357                 if (entry.getName().endsWith(".jar")) {
358                     earContext.addInclude(target, moduleFile, entry);
359                 } else {
360                     earContext.addFile(target, moduleFile, entry);
361                 }
362             }
363 
364         } catch (IOException   e) {
365             throw new DeploymentException("Problem deploying connector", e);
366         }
367     }
368 
369     public void initContext(EARContext earContext, Module module, ClassLoader   cl) throws DeploymentException {
370         ConnectorModule resourceModule = (ConnectorModule) module;
371 
372         final ConnectorType connector = (ConnectorType) module.getSpecDD();
373 
374         /*
375         The chain of idiotic jsr-77 meaningless objects is:
376         ResourceAdapterModule (1)  >
377         ResourceAdapter (n, but there can only be 1 resource adapter in a rar, so we use 1) >
378         JCAResource (1) >
379         JCAConnectionFactory (n) >
380         JCAManagedConnectionFactory (1)
381         We also include:
382         JCAResourceAdapter (n)  (from JCAResource) (actual instance of ResourceAdapter)
383         TODO include admin objects (n) from JCAResource presumably
384         */
385         AbstractName resourceAdapterModuleName = resourceModule.getModuleName();
386 
387         AbstractName resourceAdapterjsr77Name = earContext.getNaming().createChildName(resourceAdapterModuleName, module.getName(), NameFactory.RESOURCE_ADAPTER);
388         AbstractName jcaResourcejsr77Name = earContext.getNaming().createChildName(resourceAdapterjsr77Name, module.getName(), NameFactory.JCA_RESOURCE);
389 
390         //set up the metadata for the ResourceAdapterModule
391         GBeanData resourceAdapterModuleData = new GBeanData(resourceAdapterModuleName, ResourceAdapterModuleImplGBean.GBEAN_INFO);
392         // initalize the GBean
393         if (earContext.getServerName() != null) {
394             //app clients don't have a Server gbean
395             resourceAdapterModuleData.setReferencePattern(NameFactory.J2EE_SERVER, earContext.getServerName());
396             //app clients don't have an application name either
397             if (!earContext.getModuleName().equals(resourceAdapterModuleName)) {
398                 resourceAdapterModuleData.setReferencePattern(NameFactory.J2EE_APPLICATION, earContext.getModuleName());
399             }
400         }
401         resourceAdapterModuleData.setReferencePattern("ResourceAdapter", resourceAdapterjsr77Name);
402 
403         resourceAdapterModuleData.setAttribute("deploymentDescriptor", module.getOriginalSpecDD());
404         resourceAdapterModuleData.setAttribute("displayName", connector.getDisplayNameArray().length == 0 ? null : connector.getDisplayNameArray(0).getStringValue());
405         resourceAdapterModuleData.setAttribute("description", connector.getDescriptionArray().length == 0 ? null : connector.getDescriptionArray(0).getStringValue());
406         resourceAdapterModuleData.setAttribute("vendorName", connector.getVendorName().getStringValue());
407         resourceAdapterModuleData.setAttribute("EISType", connector.getEisType().getStringValue());
408         resourceAdapterModuleData.setAttribute("resourceAdapterVersion", connector.getResourceadapterVersion().getStringValue());
409 
410         ResourceadapterType resourceadapter = connector.getResourceadapter();
411         // Create the resource adapter gbean
412         if (resourceadapter.isSetResourceadapterClass()) {
413             GBeanInfoBuilder resourceAdapterInfoBuilder = new GBeanInfoBuilder(ResourceAdapterWrapperGBean.class, ResourceAdapterWrapperGBean.GBEAN_INFO);
414             GBeanData resourceAdapterGBeanData = setUpDynamicGBean(resourceAdapterInfoBuilder, resourceadapter.getConfigPropertyArray(), cl);
415 
416             resourceAdapterGBeanData.setAttribute("resourceAdapterClass", resourceadapter.getResourceadapterClass().getStringValue().trim());
417             resourceAdapterModuleData.setAttribute("resourceAdapterGBeanData", resourceAdapterGBeanData);
418         }
419 
420         if (resourceadapter.isSetInboundResourceadapter() && resourceadapter.getInboundResourceadapter().isSetMessageadapter())
421         {
422             Map   activationSpecInfoMap = getActivationSpecInfoMap(resourceadapter.getInboundResourceadapter().getMessageadapter().getMessagelistenerArray(), cl);
423             resourceAdapterModuleData.setAttribute("activationSpecInfoMap", activationSpecInfoMap);
424         }
425         Map   adminObjectInfoMap = getAdminObjectInfoMap(resourceadapter.getAdminobjectArray(), cl);
426         resourceAdapterModuleData.setAttribute("adminObjectInfoMap", adminObjectInfoMap);
427         if (resourceadapter.isSetOutboundResourceadapter()) {
428             Map   managedConnectionFactoryInfoMap = getManagedConnectionFactoryInfoMap(resourceadapter.getOutboundResourceadapter().getConnectionDefinitionArray(), cl);
429             resourceAdapterModuleData.setAttribute("managedConnectionFactoryInfoMap", managedConnectionFactoryInfoMap);
430         }
431 
432         try {
433             earContext.addGBean(resourceAdapterModuleData);
434         } catch (GBeanAlreadyExistsException e) {
435             throw new DeploymentException("Could not add resource adapter module gbean to context", e);
436         }
437 
438         //construct the bogus resource adapter and jca resource placeholders
439         GBeanData resourceAdapterData = new GBeanData(resourceAdapterjsr77Name, ResourceAdapterImplGBean.GBEAN_INFO);
440         resourceAdapterData.setReferencePattern("JCAResource", jcaResourcejsr77Name);
441         try {
442             earContext.addGBean(resourceAdapterData);
443         } catch (GBeanAlreadyExistsException e) {
444             throw new DeploymentException("Could not add resource adapter gbean to context", e);
445         }
446 
447         GBeanData jcaResourceData = new GBeanData(jcaResourcejsr77Name, JCAResourceImplGBean.GBEAN_INFO);
448         Map   thisModule = new LinkedHashMap  (2);
449         thisModule .put(NameFactory.J2EE_APPLICATION, resourceAdapterModuleName.getNameProperty(NameFactory.J2EE_APPLICATION));
450         thisModule .put(NameFactory.RESOURCE_ADAPTER_MODULE, resourceAdapterModuleName.getNameProperty(NameFactory.J2EE_NAME));
451         jcaResourceData.setReferencePattern("ConnectionFactories", new AbstractNameQuery(resourceAdapterModuleName.getArtifact(), thisModule, JCAConnectionFactory.class.getName()));
452         jcaResourceData.setReferencePattern("ResourceAdapters", new AbstractNameQuery(resourceAdapterModuleName.getArtifact(), thisModule, JCAResourceAdapter.class.getName()));
453         jcaResourceData.setReferencePattern("AdminObjects", new AbstractNameQuery(resourceAdapterModuleName.getArtifact(), thisModule, JCAAdminObject.class.getName()));
454 
455         try {
456             earContext.addGBean(jcaResourceData);
457         } catch (GBeanAlreadyExistsException e) {
458             throw new DeploymentException("Could not add jca resource gbean to context", e);
459         }
460 
461         GerConnectorType geronimoConnector = (GerConnectorType) module.getVendorDD();
462 
463         serviceBuilders.build(geronimoConnector, earContext, earContext);
464 
465         addConnectorGBeans(earContext, jcaResourcejsr77Name, resourceAdapterModuleData, connector, geronimoConnector, cl);
466 
467     }
468 
469     public void addGBeans(EARContext earContext, Module module, ClassLoader   cl, Collection   repository) throws DeploymentException {
470         //all our gbeans are added in  the initContext step
471     }
472 
473     public String   getSchemaNamespace() {
474         return GERCONNECTOR_NAMESPACE;
475     }
476 
477     private void addConnectorGBeans(EARContext earContext, AbstractName jcaResourceName, GBeanData resourceAdapterModuleData, ConnectorType connector, GerConnectorType geronimoConnector, ClassLoader   cl) throws DeploymentException {
478         ResourceadapterType resourceadapter = connector.getResourceadapter();
479 
480         GerResourceadapterType[] geronimoResourceAdapters = geronimoConnector.getResourceadapterArray();
481         for (int k = 0; k < geronimoResourceAdapters.length; k++) {
482             GerResourceadapterType geronimoResourceAdapter = geronimoResourceAdapters[k];
483 
484             // Resource Adapter
485             AbstractName resourceAdapterAbstractName = null;
486             if (resourceadapter.isSetResourceadapterClass()) {
487                 GBeanData resourceAdapterGBeanData = locateResourceAdapterGBeanData(resourceAdapterModuleData);
488                 GBeanData resourceAdapterInstanceGBeanData = new GBeanData(resourceAdapterGBeanData);
489 
490                 setDynamicGBeanDataAttributes(resourceAdapterInstanceGBeanData, geronimoResourceAdapter.getResourceadapterInstance().getConfigPropertySettingArray(), cl);
491 
492                 // set the work manager name
493                 AbstractNameQuery workManagerName = ENCConfigBuilder.getGBeanQuery(NameFactory.JCA_WORK_MANAGER, geronimoResourceAdapter.getResourceadapterInstance().getWorkmanager());
494                 resourceAdapterInstanceGBeanData.setReferencePattern("WorkManager", workManagerName);
495 
496                 // set the xa terminator name which is the same as our transaction manager
497                 resourceAdapterInstanceGBeanData.setReferencePattern("XATerminator", earContext.getTransactionManagerName());
498 
499                 String   resourceAdapterName = geronimoResourceAdapter.getResourceadapterInstance().getResourceadapterName();
500                 resourceAdapterAbstractName = earContext.getNaming().createChildName(jcaResourceName, resourceAdapterName, NameFactory.JCA_RESOURCE_ADAPTER);
501                 resourceAdapterInstanceGBeanData.setAbstractName(resourceAdapterAbstractName);
502                 try {
503                     earContext.addGBean(resourceAdapterInstanceGBeanData);
504                 } catch (GBeanAlreadyExistsException e) {
505                     throw new DeploymentException("Could not add resource adapter instance gbean to context", e);
506                 }
507             }
508 
509             // Outbound Managed Connection Factories (think JDBC data source or JMS connection factory)
510 
511             // ManagedConnectionFactory setup
512             if (geronimoResourceAdapter.isSetOutboundResourceadapter()) {
513                 if (!resourceadapter.isSetOutboundResourceadapter()) {
514                     throw new DeploymentException("Geronimo plan configures an outbound resource adapter but ra.xml does not describe any");
515                 }
516                 String   transactionSupport = resourceadapter.getOutboundResourceadapter().getTransactionSupport().getStringValue().trim();
517                 for (int i = 0; i < geronimoResourceAdapter.getOutboundResourceadapter().getConnectionDefinitionArray().length; i++)
518                 {
519                     GerConnectionDefinitionType geronimoConnectionDefinition = geronimoResourceAdapter.getOutboundResourceadapter().getConnectionDefinitionArray(i);
520                     assert geronimoConnectionDefinition != null: "Null GeronimoConnectionDefinition";
521 
522                     String   connectionFactoryInterfaceName = geronimoConnectionDefinition.getConnectionfactoryInterface().trim();
523                     GBeanData connectionFactoryGBeanData = locateConnectionFactoryInfo(resourceAdapterModuleData, connectionFactoryInterfaceName);
524 
525                     if (connectionFactoryGBeanData == null) {
526                         throw new DeploymentException("No connection definition for ConnectionFactory class: " + connectionFactoryInterfaceName);
527                     }
528 
529                     for (int j = 0; j < geronimoConnectionDefinition.getConnectiondefinitionInstanceArray().length; j++)
530                     {
531                         GerConnectiondefinitionInstanceType connectionfactoryInstance = geronimoConnectionDefinition.getConnectiondefinitionInstanceArray()[j];
532 
533                         addOutboundGBeans(earContext, jcaResourceName, resourceAdapterAbstractName, connectionFactoryGBeanData, connectionfactoryInstance, transactionSupport, cl);
534                     }
535                 }
536             }
537         }
538         // admin objects (think message queues and topics)
539 
540         // add configured admin objects
541         for (int i = 0; i < geronimoConnector.getAdminobjectArray().length; i++) {
542             GerAdminobjectType gerAdminObject = geronimoConnector.getAdminobjectArray()[i];
543 
544             String   adminObjectInterface = gerAdminObject.getAdminobjectInterface().trim();
545             GBeanData adminObjectGBeanData = locateAdminObjectInfo(resourceAdapterModuleData, adminObjectInterface);
546 
547             if (adminObjectGBeanData == null) {
548                 throw new DeploymentException("No admin object declared for interface: " + adminObjectInterface);
549             }
550 
551             for (int j = 0; j < gerAdminObject.getAdminobjectInstanceArray().length; j++) {
552                 GBeanData adminObjectInstanceGBeanData = new GBeanData(adminObjectGBeanData);
553                 GerAdminobjectInstanceType gerAdminObjectInstance = gerAdminObject.getAdminobjectInstanceArray()[j];
554                 setDynamicGBeanDataAttributes(adminObjectInstanceGBeanData, gerAdminObjectInstance.getConfigPropertySettingArray(), cl);
555                 // add it
556                 AbstractName adminObjectAbstractName = earContext.getNaming().createChildName(jcaResourceName, gerAdminObjectInstance.getMessageDestinationName().trim(), NameFactory.JCA_ADMIN_OBJECT);
557                 adminObjectInstanceGBeanData.setAbstractName(adminObjectAbstractName);
558                 try {
559                     earContext.addGBean(adminObjectInstanceGBeanData);
560                 } catch (GBeanAlreadyExistsException e) {
561                     throw new DeploymentException("Could not add admin object gbean to context", e);
562                 }
563             }
564         }
565     }
566 
567     private Map   getActivationSpecInfoMap(MessagelistenerType[] messagelistenerArray, ClassLoader   cl) throws DeploymentException {
568         Map   activationSpecInfos = new HashMap  ();
569         for (int i = 0; i < messagelistenerArray.length; i++) {
570             MessagelistenerType messagelistenerType = messagelistenerArray[i];
571             String   messageListenerInterface = messagelistenerType.getMessagelistenerType().getStringValue().trim();
572             ActivationspecType activationspec = messagelistenerType.getActivationspec();
573             String   activationSpecClassName = activationspec.getActivationspecClass().getStringValue().trim();
574             GBeanInfoBuilder infoBuilder = new GBeanInfoBuilder(ActivationSpecWrapperGBean.class, ActivationSpecWrapperGBean.GBEAN_INFO);
575 
576             //add all javabean properties that have both getter and setter.  Ignore the "required" flag from the dd.
577             Map   getters = new HashMap  ();
578             Set   setters = new HashSet  ();
579             Method  [] methods;
580             try {
581                 Class   activationSpecClass = cl.loadClass(activationSpecClassName);
582                 methods = activationSpecClass.getMethods();
583             } catch (ClassNotFoundException   e) {
584                 throw new DeploymentException("Can not load activation spec class", e);
585             }
586             for (int j = 0; j < methods.length; j++) {
587                 Method   method = methods[j];
588                 String   methodName = method.getName();
589                 if ((methodName.startsWith("get") || methodName.startsWith("is")) && method.getParameterTypes().length == 0)
590                 {
591                     String   attributeName = (methodName.startsWith("get")) ? methodName.substring(3) : methodName.substring(2);
592                     getters.put(Introspector.decapitalize(attributeName), method.getReturnType().getName());
593                 } else if (methodName.startsWith("set") && method.getParameterTypes().length == 1) {
594                     setters.add(Introspector.decapitalize(methodName.substring(3)));
595                 }
596             }
597             getters.keySet().retainAll(setters);
598             getters.remove("resourceAdapter");
599 
600             for (Iterator   iterator = getters.entrySet().iterator(); iterator.hasNext();) {
601                 Map.Entry