001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.geronimo.persistence.builder;
018
019 import java.io.File;
020 import java.io.IOException;
021 import java.net.URI;
022 import java.net.URISyntaxException;
023 import java.net.URL;
024 import java.util.ArrayList;
025 import java.util.Collection;
026 import java.util.HashMap;
027 import java.util.List;
028 import java.util.Map;
029 import java.util.Properties;
030 import java.util.jar.JarFile;
031
032 import javax.xml.namespace.QName;
033
034 import org.apache.geronimo.common.DeploymentException;
035 import org.apache.geronimo.deployment.ClassPathList;
036 import org.apache.geronimo.deployment.ModuleIDBuilder;
037 import org.apache.geronimo.deployment.service.EnvironmentBuilder;
038 import org.apache.geronimo.deployment.xmlbeans.XmlBeansUtil;
039 import org.apache.geronimo.gbean.AbstractName;
040 import org.apache.geronimo.gbean.AbstractNameQuery;
041 import org.apache.geronimo.gbean.GBeanData;
042 import org.apache.geronimo.gbean.GBeanInfo;
043 import org.apache.geronimo.gbean.GBeanInfoBuilder;
044 import org.apache.geronimo.j2ee.deployment.EARContext;
045 import org.apache.geronimo.j2ee.deployment.Module;
046 import org.apache.geronimo.j2ee.deployment.ModuleBuilderExtension;
047 import org.apache.geronimo.j2ee.j2eeobjectnames.NameFactory;
048 import org.apache.geronimo.kernel.GBeanAlreadyExistsException;
049 import org.apache.geronimo.kernel.Naming;
050 import org.apache.geronimo.kernel.config.ConfigurationStore;
051 import org.apache.geronimo.kernel.repository.Environment;
052 import org.apache.geronimo.persistence.PersistenceUnitGBean;
053 import org.apache.geronimo.xbeans.persistence.PersistenceDocument;
054 import org.apache.xbean.finder.ResourceFinder;
055 import org.apache.xmlbeans.QNameSet;
056 import org.apache.xmlbeans.XmlException;
057 import org.apache.xmlbeans.XmlObject;
058
059 /**
060 * @version $Rev: 566785 $ $Date: 2007-08-16 13:24:26 -0400 (Thu, 16 Aug 2007) $
061 */
062 public class PersistenceUnitBuilder implements ModuleBuilderExtension {
063 private static final QName PERSISTENCE_QNAME = PersistenceDocument.type.getDocumentElementName();
064
065 private final Environment defaultEnvironment;
066 private final String defaultPersistenceProviderClassName;
067 private final Properties defaultPersistenceUnitProperties;
068 private final AbstractNameQuery defaultJtaDataSourceName;
069 private final AbstractNameQuery defaultNonJtaDataSourceName;
070 private final AbstractNameQuery extendedEntityManagerRegistryName;
071 private static final String ANON_PU_NAME = "AnonymousPersistenceUnit";
072
073 public PersistenceUnitBuilder(Environment defaultEnvironment,
074 String defaultPersistenceProviderClassName,
075 String defaultJtaDataSourceName,
076 String defaultNonJtaDataSourceName,
077 AbstractNameQuery extendedEntityManagerRegistryName, Properties defaultPersistenceUnitProperties) throws URISyntaxException {
078 this.defaultEnvironment = defaultEnvironment;
079 this.defaultPersistenceProviderClassName = defaultPersistenceProviderClassName;
080 this.defaultJtaDataSourceName = defaultJtaDataSourceName == null ? null : getAbstractNameQuery(defaultJtaDataSourceName);
081 this.defaultNonJtaDataSourceName = defaultNonJtaDataSourceName == null ? null : getAbstractNameQuery(defaultNonJtaDataSourceName);
082 this.extendedEntityManagerRegistryName = extendedEntityManagerRegistryName;
083 this.defaultPersistenceUnitProperties = defaultPersistenceUnitProperties == null ? new Properties() : defaultPersistenceUnitProperties;
084 }
085
086 public void createModule(Module module, Object plan, JarFile moduleFile, String targetPath, URL specDDUrl, Environment environment, Object moduleContextInfo, AbstractName earName, Naming naming, ModuleIDBuilder idBuilder) throws DeploymentException {
087 }
088
089 public void installModule(JarFile earFile, EARContext earContext, Module module, Collection configurationStores, ConfigurationStore targetConfigurationStore, Collection repository) throws DeploymentException {
090 }
091
092 public void initContext(EARContext earContext, Module module, ClassLoader cl) throws DeploymentException {
093 XmlObject container = module.getVendorDD();
094 EARContext moduleContext = module.getEarContext();
095 XmlObject[] raws = container.selectChildren(PERSISTENCE_QNAME);
096
097 Map<String, PersistenceDocument.Persistence.PersistenceUnit> overrides = new HashMap<String, PersistenceDocument.Persistence.PersistenceUnit>();
098 for (XmlObject raw : raws) {
099 PersistenceDocument.Persistence persistence = (PersistenceDocument.Persistence) raw.copy().changeType(PersistenceDocument.Persistence.type);
100 for (PersistenceDocument.Persistence.PersistenceUnit unit : persistence.getPersistenceUnitArray()) {
101 overrides.put(unit.getName().trim(), unit);
102 }
103 // buildPersistenceUnits(persistence, module, module.getTargetPath());
104 }
105 try {
106 File rootBaseFile = module.getRootEarContext().getConfiguration().getConfigurationDir();
107 String rootBase = rootBaseFile.toURI().normalize().toString();
108 URI moduleBaseURI = moduleContext.getBaseDir().toURI();
109 Map rootGeneralData = module.getRootEarContext().getGeneralData();
110 ClassPathList manifestcp = (ClassPathList) module.getEarContext().getGeneralData().get(ClassPathList.class);
111 if (manifestcp == null) {
112 manifestcp = new ClassPathList();
113 manifestcp.add(module.getTargetPath());
114 }
115 URL[] urls = new URL[manifestcp.size()];
116 int i = 0;
117 for (String path : manifestcp) {
118 path = path.replaceAll(" ", "%20");
119 URL url = moduleBaseURI.resolve(path).toURL();
120 urls[i++] = url;
121 }
122 ResourceFinder finder = new ResourceFinder("", null, urls);
123 List<URL> knownPersistenceUrls = (List<URL>) rootGeneralData.get(PersistenceUnitBuilder.class.getName());
124 if (knownPersistenceUrls == null) {
125 knownPersistenceUrls = new ArrayList<URL>();
126 rootGeneralData.put(PersistenceUnitBuilder.class.getName(), knownPersistenceUrls);
127 }
128 List<URL> persistenceUrls = finder.findAll("META-INF/persistence.xml");
129 persistenceUrls.removeAll(knownPersistenceUrls);
130 if (raws.length > 0 || persistenceUrls.size() > 0) {
131 EnvironmentBuilder.mergeEnvironments(module.getEnvironment(), defaultEnvironment);
132 }
133 for (URL persistenceUrl : persistenceUrls) {
134 String persistenceLocation;
135 try {
136 persistenceLocation = persistenceUrl.toURI().toString();
137 } catch (URISyntaxException e) {
138 //????
139 continue;
140 }
141 int pos = persistenceLocation.indexOf(rootBase);
142 if (pos < 0) {
143 //not in the ear
144 continue;
145 }
146 int endPos = persistenceLocation.lastIndexOf("!/");
147 if (endPos < 0) {
148 // if unable to find the '!/' marker, try to see if this is
149 // a war file with the persistence.xml directly embeded - no ejb-jar
150 endPos = persistenceLocation.lastIndexOf("META-INF");
151 }
152 if (endPos >= 0) {
153 //path relative to ear base uri
154 String relative = persistenceLocation.substring(pos + rootBase.length(), endPos);
155 //find path relative to module base uri
156 relative = module.getRelativePath(relative);
157 PersistenceDocument persistenceDocument;
158 try {
159 XmlObject xmlObject = XmlBeansUtil.parse(persistenceUrl, moduleContext.getClassLoader());
160 persistenceDocument = (PersistenceDocument) xmlObject.changeType(PersistenceDocument.type);
161 } catch (XmlException e) {
162 throw new DeploymentException("Could not parse persistence.xml file: " + persistenceUrl, e);
163 }
164 PersistenceDocument.Persistence persistence = persistenceDocument.getPersistence();
165 buildPersistenceUnits(persistence, overrides, module, relative);
166 knownPersistenceUrls.add(persistenceUrl);
167 } else {
168 throw new DeploymentException("Could not find persistence.xml file: " + persistenceUrl);
169 }
170 }
171 } catch (IOException e) {
172 throw new DeploymentException("Could not look for META-INF/persistence.xml files", e);
173 }
174
175 for (PersistenceDocument.Persistence.PersistenceUnit persistenceUnit : overrides.values()) {
176 GBeanData data = installPersistenceUnitGBean(persistenceUnit, module, module.getTargetPath());
177 respectExcludeUnlistedClasses(data);
178 }
179 }
180
181 public void addGBeans(EARContext earContext, Module module, ClassLoader cl, Collection repository) throws DeploymentException {
182 }
183
184 private void buildPersistenceUnits(PersistenceDocument.Persistence persistence, Map<String, PersistenceDocument.Persistence.PersistenceUnit> overrides, Module module, String persistenceModulePath) throws DeploymentException {
185 PersistenceDocument.Persistence.PersistenceUnit[] persistenceUnits = persistence.getPersistenceUnitArray();
186 for (PersistenceDocument.Persistence.PersistenceUnit persistenceUnit : persistenceUnits) {
187 GBeanData data = installPersistenceUnitGBean(persistenceUnit, module, persistenceModulePath);
188 String unitName = persistenceUnit.getName().trim();
189 if (overrides.get(unitName) != null) {
190 setOverrideableProperties(overrides.remove(unitName), data);
191 }
192 respectExcludeUnlistedClasses(data);
193 }
194 }
195
196 private GBeanData installPersistenceUnitGBean(PersistenceDocument.Persistence.PersistenceUnit persistenceUnit, Module module, String persistenceModulePath) throws DeploymentException {
197 EARContext moduleContext = module.getEarContext();
198 String persistenceUnitName = persistenceUnit.getName().trim();
199 if (persistenceUnitName.length() == 0) {
200 persistenceUnitName = ANON_PU_NAME;
201 }
202 AbstractName abstractName;
203 if (persistenceModulePath == null || persistenceModulePath.length() == 0) {
204 abstractName = moduleContext.getNaming().createChildName(module.getModuleName(), persistenceUnitName, PersistenceUnitGBean.GBEAN_INFO.getJ2eeType());
205 } else {
206 abstractName = moduleContext.getNaming().createChildName(module.getModuleName(), persistenceModulePath, NameFactory.PERSISTENCE_UNIT_MODULE);
207 abstractName = moduleContext.getNaming().createChildName(abstractName, persistenceUnitName, PersistenceUnitGBean.GBEAN_INFO.getJ2eeType());
208 }
209 GBeanData gbeanData = new GBeanData(abstractName, PersistenceUnitGBean.GBEAN_INFO);
210 try {
211 moduleContext.addGBean(gbeanData);
212 } catch (GBeanAlreadyExistsException e) {
213 throw new DeploymentException("Duplicate persistenceUnit name " + persistenceUnitName, e);
214 }
215 gbeanData.setAttribute("persistenceUnitName", persistenceUnitName);
216 gbeanData.setAttribute("persistenceUnitRoot", persistenceModulePath);
217
218 //set defaults:
219 gbeanData.setAttribute("persistenceProviderClassName", defaultPersistenceProviderClassName);
220 //spec 6.2.1.2 the default is JTA
221 gbeanData.setAttribute("persistenceUnitTransactionType", "JTA");
222 if (defaultJtaDataSourceName != null) {
223 gbeanData.setReferencePattern("JtaDataSourceWrapper", defaultJtaDataSourceName);
224 }
225 if (defaultNonJtaDataSourceName != null) {
226 gbeanData.setReferencePattern("NonJtaDataSourceWrapper", defaultNonJtaDataSourceName);
227 }
228
229 gbeanData.setAttribute("mappingFileNames", new ArrayList<String>());
230 gbeanData.setAttribute("excludeUnlistedClasses", false);
231 gbeanData.setAttribute("managedClassNames", new ArrayList<String>());
232 gbeanData.setAttribute("jarFileUrls", new ArrayList<String>());
233 Properties properties = new Properties();
234 gbeanData.setAttribute("properties", properties);
235 properties.putAll(defaultPersistenceUnitProperties);
236 AbstractNameQuery transactionManagerName = moduleContext.getTransactionManagerName();
237 gbeanData.setReferencePattern("TransactionManager", transactionManagerName);
238 gbeanData.setReferencePattern("EntityManagerRegistry", extendedEntityManagerRegistryName);
239
240 setOverrideableProperties(persistenceUnit, gbeanData);
241 return gbeanData;
242 }
243
244 private void setOverrideableProperties(PersistenceDocument.Persistence.PersistenceUnit persistenceUnit, GBeanData gbeanData) throws DeploymentException {
245 if (persistenceUnit.isSetProvider()) {
246 gbeanData.setAttribute("persistenceProviderClassName", persistenceUnit.getProvider().trim());
247 }
248 if (persistenceUnit.isSetTransactionType()) {
249 gbeanData.setAttribute("persistenceUnitTransactionType", persistenceUnit.getTransactionType().toString());
250 }
251 if (persistenceUnit.isSetJtaDataSource()) {
252 String jtaDataSourceString = persistenceUnit.getJtaDataSource().trim();
253 try {
254 AbstractNameQuery jtaDataSourceNameQuery = getAbstractNameQuery(jtaDataSourceString);
255 gbeanData.setReferencePattern("JtaDataSourceWrapper", jtaDataSourceNameQuery);
256 } catch (URISyntaxException e) {
257 throw new DeploymentException("Could not create jta-data-source AbstractNameQuery from string: " + jtaDataSourceString, e);
258 }
259 }
260
261 if (persistenceUnit.isSetNonJtaDataSource()) {
262 String nonJtaDataSourceString = persistenceUnit.getNonJtaDataSource().trim();
263 try {
264 AbstractNameQuery nonJtaDataSourceNameQuery = getAbstractNameQuery(nonJtaDataSourceString);
265 gbeanData.setReferencePattern("NonJtaDataSourceWrapper", nonJtaDataSourceNameQuery);
266 } catch (URISyntaxException e) {
267 throw new DeploymentException("Could not create non-jta-data-source AbstractNameQuery from string: " + nonJtaDataSourceString, e);
268 }
269 }
270
271 List<String> mappingFileNames = (List<String>) gbeanData.getAttribute("mappingFileNames");
272 String[] mappingFileNameStrings = persistenceUnit.getMappingFileArray();
273 for (String mappingFileNameString : mappingFileNameStrings) {
274 mappingFileNames.add(mappingFileNameString.trim());
275 }
276
277 if (persistenceUnit.isSetExcludeUnlistedClasses()) {
278 gbeanData.setAttribute("excludeUnlistedClasses", persistenceUnit.getExcludeUnlistedClasses());
279 }
280
281 String[] managedClassNameStrings = persistenceUnit.getClass1Array();
282 List<String> managedClassNames = (List<String>) gbeanData.getAttribute("managedClassNames");
283 for (String managedClassNameString : managedClassNameStrings) {
284 managedClassNames.add(managedClassNameString.trim());
285 }
286 List<String> jarFileUrls = (List<String>) gbeanData.getAttribute("jarFileUrls");
287 //add the specified locations in the ear
288 String[] jarFileUrlStrings = persistenceUnit.getJarFileArray();
289 for (String jarFileUrlString : jarFileUrlStrings) {
290 jarFileUrls.add(jarFileUrlString.trim());
291 }
292
293 if (persistenceUnit.isSetProperties()) {
294 Properties properties = (Properties) gbeanData.getAttribute("properties");
295 PersistenceDocument.Persistence.PersistenceUnit.Properties.Property[] propertyObjects = persistenceUnit.getProperties().getPropertyArray();
296 for (PersistenceDocument.Persistence.PersistenceUnit.Properties.Property propertyObject : propertyObjects) {
297 String key = propertyObject.getName().trim();
298 String value = propertyObject.getValue().trim();
299 properties.setProperty(key, value);
300 }
301 }
302
303 }
304
305 private void respectExcludeUnlistedClasses(GBeanData gbeanData) {
306 boolean excludeUnlistedClasses = (Boolean) gbeanData.getAttribute("excludeUnlistedClasses");
307
308 if (excludeUnlistedClasses) {
309 gbeanData.clearAttribute("jarFileUrls");
310 } else {
311 gbeanData.clearAttribute("managedClassNames");
312 }
313 }
314
315 private AbstractNameQuery getAbstractNameQuery(String dataSourceString) throws URISyntaxException {
316 if (dataSourceString.indexOf('=') == -1) {
317 dataSourceString = "?name=" + dataSourceString;
318 }
319 AbstractNameQuery dataSourceNameQuery = new AbstractNameQuery(new URI(dataSourceString + "#org.apache.geronimo.connector.outbound.ConnectionFactorySource"));
320 return dataSourceNameQuery;
321 }
322
323 public QNameSet getSpecQNameSet() {
324 return QNameSet.EMPTY;
325 }
326
327 public QNameSet getPlanQNameSet() {
328 return QNameSet.singleton(PERSISTENCE_QNAME);
329 }
330
331 public static final GBeanInfo GBEAN_INFO;
332
333 static {
334 GBeanInfoBuilder infoBuilder = GBeanInfoBuilder.createStatic(PersistenceUnitBuilder.class, NameFactory.MODULE_BUILDER);
335
336 infoBuilder.addAttribute("defaultEnvironment", Environment.class, true, true);
337 infoBuilder.addAttribute("defaultPersistenceProviderClassName", String.class, true, true);
338 infoBuilder.addAttribute("defaultJtaDataSourceName", String.class, true, true);
339 infoBuilder.addAttribute("defaultNonJtaDataSourceName", String.class, true, true);
340 infoBuilder.addAttribute("extendedEntityManagerRegistryName", AbstractNameQuery.class, true, true);
341 infoBuilder.addAttribute("defaultPersistenceUnitProperties", Properties.class, true, true);
342
343 infoBuilder.setConstructor(new String[]{
344 "defaultEnvironment",
345 "defaultPersistenceProviderClassName",
346 "defaultJtaDataSourceName",
347 "defaultNonJtaDataSourceName",
348 "extendedEntityManagerRegistryName",
349 "defaultPersistenceUnitProperties"
350 });
351
352 GBEAN_INFO = infoBuilder.getBeanInfo();
353
354 }
355
356 public static GBeanInfo getGBeanInfo() {
357 return GBEAN_INFO;
358 }
359
360
361 }