/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates, IBM Corporation. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 05/16/2008-1.0M8 Guy Pelletier
* - 218084: Implement metadata merging functionality between mapping files
* 05/23/2008-1.0M8 Guy Pelletier
* - 211330: Add attributes-complete support to the EclipseLink-ORM.XML Schema
* 12/10/2008-1.1 Michael O'Brien
* - 257606: Add orm.xml schema validation true/(false) flag support in persistence.xml
* 01/28/2009-2.0 Guy Pelletier
* - 248293: JPA 2.0 Element Collections (part 1)
* 03/27/2009-2.0 Guy Pelletier
* - 241413: JPA 2.0 Add EclipseLink support for Map type attributes
* 03/08/2010-2.1 Guy Pelletier
* - 303632: Add attribute-type for mapping attributes to EclipseLink-ORM
* 05/14/2010-2.1 Guy Pelletier
* - 253083: Add support for dynamic persistence using ORM.xml/eclipselink-orm.xml
* 04/01/2011-2.3 Guy Pelletier
* - 337323: Multi-tenant with shared schema support (part 2)
* 09/20/2011-2.3.1 Guy Pelletier
* - 357476: Change caching default to ISOLATED for multitenant's using a shared EMF.
* 06/20/2012-2.5 Guy Pelletier
* - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
* 10/09/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 08/18/2014-2.5 Jody Grassel (IBM Corporation)
* - 440802: xml-mapping-metadata-complete does not exclude @Entity annotated entities
******************************************************************************/
package org.eclipse.persistence.internal.jpa.metadata;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.persistence.spi.PersistenceUnitInfo;
import org.eclipse.persistence.config.DescriptorCustomizer;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.exceptions.PersistenceUnitLoadingException;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl;
import org.eclipse.persistence.internal.jpa.deployment.PersistenceUnitProcessor;
import org.eclipse.persistence.internal.jpa.deployment.PersistenceUnitProcessor.Mode;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ConverterAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.MappedSuperclassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAsmFactory;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataClass;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataFactory;
import org.eclipse.persistence.internal.jpa.metadata.converters.StructConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings;
import org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappingsReader;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jpa.Archive;
import org.eclipse.persistence.jpa.metadata.MetadataSource;
import org.eclipse.persistence.logging.AbstractSessionLog;
import org.eclipse.persistence.logging.SessionLog;
/**
* INTERNAL:
* The object/relational metadata processor for the EJB3.0 specification.
*
* @author Guy Pelletier
* @since TopLink EJB 3.0 Reference Implementation
*/
public class MetadataProcessor {
protected ClassLoader m_loader;
protected MetadataFactory m_factory;
protected MetadataProject m_project;
protected AbstractSession m_session;
protected Map m_predeployProperties;
protected MetadataProcessor m_compositeProcessor;
protected Set<MetadataProcessor> m_compositeMemberProcessors;
protected MetadataSource m_metadataSource;
/**
* INTERNAL:
* Empty processor to be used as a composite processor.
*/
public MetadataProcessor() {}
/**
* INTERNAL:
* Called from EntityManagerSetupImpl. The 'real' EJB 3.0 processing
* that includes XML and annotations.
*/
public MetadataProcessor(PersistenceUnitInfo puInfo, AbstractSession session, ClassLoader loader, boolean weaveLazy, boolean weaveEager, boolean weaveFetchGroups, boolean multitenantSharedEmf, boolean multitenantSharedCache, Map predeployProperties, MetadataProcessor compositeProcessor) {
m_loader = loader;
m_session = session;
m_project = new MetadataProject(puInfo, session, weaveLazy, weaveEager, weaveFetchGroups, multitenantSharedEmf, multitenantSharedCache);
m_predeployProperties = predeployProperties;
m_compositeProcessor = compositeProcessor;
if (m_compositeProcessor != null) {
m_compositeProcessor.addCompositeMemberProcessor(this);
m_project.setCompositeProcessor(m_compositeProcessor);
}
}
/**
* INTERNAL:
* Add containedProcessor to compositeProcessor.
*/
public void addCompositeMemberProcessor(MetadataProcessor compositeMemberProcessor) {
if (m_compositeMemberProcessors == null) {
m_compositeMemberProcessors = new HashSet();
}
m_compositeMemberProcessors.add(compositeMemberProcessor);
}
/**
* INTERNAL:
* Method to place EntityListener's on the descriptors from the given
* session. This call is made from the EntityManagerSetup deploy call.
*/
public void addEntityListeners() {
// Process the listeners for all the class accessors, but before
// doing so, update the accessors associated class since the loader
// should have changed changed.
for (EntityAccessor accessor : m_project.getEntityAccessors()) {
accessor.setJavaClass(accessor.getDescriptor().getJavaClass());
accessor.processListeners(m_loader);
}
}
/**
* INTERNAL:
* Method to place NamedQueries and NamedNativeQueries on the given session.
* This call is made from the EntityManagerSetup deploy call.
*/
public void addNamedQueries() {
m_project.processQueries();
}
/**
* INTERNAL:
* During EntityManagerSetup deploy, using the real class loader we must
* create our dynamic classes.
*/
public void createDynamicClasses() {
m_project.createDynamicClasses(m_loader);
}
public void createRestInterfaces(){
m_project.createRestInterfaces(m_loader);
}
/**
* INTERNAL:
* Return compositeProcessor.
*/
public MetadataProcessor getCompositeProcessor() {
return m_compositeProcessor;
}
/**
* INTERNAL:
*/
public MetadataFactory getMetadataFactory() {
return m_factory;
}
/**
* INTERNAL:
*/
public MetadataSource getMetadataSource(){
return m_metadataSource;
}
/**
* INTERNAL:
* Returns projects owned by compositeProcessor minus the passed project.
*/
public Set<MetadataProject> getPearProjects(MetadataProject project) {
Set<MetadataProject> pearProjects = new HashSet();
if (m_compositeMemberProcessors != null) {
for(MetadataProcessor processor : m_compositeMemberProcessors) {
MetadataProject pearProject = processor.getProject();
if(pearProject != project) {
pearProjects.add(pearProject);
}
}
}
return pearProjects;
}
/**
* INTERNAL:
* Return a set of class names for each entity, embeddable and mapped
* superclass found in the mapping files to be processed by the
* MetadataProcessor.
*/
public Set<String> getPersistenceUnitClassSetFromMappingFiles() {
HashSet<String> classSet = new HashSet<String>();
for (XMLEntityMappings entityMappings : m_project.getEntityMappings()) {
for (ClassAccessor entity : entityMappings.getEntities()) {
classSet.add(entityMappings.getPackageQualifiedClassName(entity.getClassName()));
}
for (ClassAccessor embeddable : entityMappings.getEmbeddables()) {
classSet.add(entityMappings.getPackageQualifiedClassName(embeddable.getClassName()));
}
for (ClassAccessor mappedSuperclass : entityMappings.getMappedSuperclasses()) {
classSet.add(entityMappings.getPackageQualifiedClassName(mappedSuperclass.getClassName()));
}
}
return classSet;
}
/**
* INTERNAL:
*/
public MetadataProject getProject() {
return m_project;
}
/**
* INTERNAL:
* Adds a list of StructConverter string names that were defined in the
* metadata of this project to the native EclipseLink project.
*
* These StructConverters can be added to the Project to be processed later
*/
public void addStructConverterNames() {
List<String> structConverters = new ArrayList<String>();
for (StructConverterMetadata converter: m_project.getStructConverters()) {
structConverters.add(converter.getConverterClassName());
}
if (!structConverters.isEmpty()) {
m_session.getProject().setStructConverters(structConverters);
}
}
/**
* INTERNAL:
* Handle an exception that occurred while processing ORM xml.
*/
protected void handleORMException(RuntimeException e, String mappingFile, boolean throwException){
if (m_session == null) {
// Metadata processor is mainly used with a session. Java SE
// bootstrapping uses some functions such as ORM processing without
// a session. In these cases, it is impossible to get the session
// to properly handle the exception. As a result we log an error.
// The same code will be called later in the bootstrapping code
// and the error will be handled then.
AbstractSessionLog.getLog().log(SessionLog.WARNING, SessionLog.METADATA, EntityManagerSetupImpl.ERROR_LOADING_XML_FILE, new Object[] {mappingFile, e});
} else if (!throwException) {
// fail quietly
m_session.log(SessionLog.WARNING, SessionLog.METADATA, EntityManagerSetupImpl.ERROR_LOADING_XML_FILE, new Object[] {mappingFile, e});
} else {
// fail loudly
m_session.handleException(e);
}
}
/**
* INTERNAL:
* This method is responsible for discovering all the entity classes for
* this PU and adding corresponding MetadataDescriptor in the
* MetadataProject.
*
* This method will also gather all the weavable classes for this PU.
* Currently, entity and embeddable classes are weavable.
*
* NOTE: The order of processing should not be changed as the steps are
* dependent on one another.
*/
protected void initPersistenceUnitClasses() {
// 1 - Iterate through the classes that are defined in the <mapping>
// files and add them to the map. This will merge the accessors where
// necessary.
HashMap<String, EntityAccessor> entities = new HashMap<String, EntityAccessor>();
HashMap<String, EmbeddableAccessor> embeddables = new HashMap<String, EmbeddableAccessor>();
for (XMLEntityMappings entityMappings : m_project.getEntityMappings()) {
entityMappings.initPersistenceUnitClasses(entities, embeddables);
}
// 2 - Iterate through all the XML entities and add them to the project
// and apply any persistence unit defaults.
for (EntityAccessor entity : entities.values()) {
// This will apply global persistence unit defaults.
m_project.addEntityAccessor(entity);
// This will override any global settings.
entity.getEntityMappings().processEntityMappingsDefaults(entity);
}
// 3 - Iterate though all the XML embeddables and add them to the
// project and apply any persistence unit defaults.
for (EmbeddableAccessor embeddable : embeddables.values()) {
// This will apply global persistence unit defaults.
m_project.addEmbeddableAccessor(embeddable);
// This will override any global settings.
embeddable.getEntityMappings().processEntityMappingsDefaults(embeddable);
}
// Check if the xml-mapping-metadata-complete was declared. If so, then ignore <class> entries defined
// in the persistence unit, as by definition only elements declared in ORM XML are to be permitted.
if (m_project.getPersistenceUnitMetadata() != null && m_project.getPersistenceUnitMetadata().isXMLMappingMetadataComplete()) {
return;
}
// 4 - Iterate through the classes that are referenced from the
// persistence.xml file.
PersistenceUnitInfo persistenceUnitInfo = m_project.getPersistenceUnitInfo();
List<String> classNames = new ArrayList<String>();
// Add all the <class> specifications.
classNames.addAll(persistenceUnitInfo.getManagedClassNames());
// Add all the classes from the <jar> specifications.
for (URL url : persistenceUnitInfo.getJarFileUrls()) {
classNames.addAll(PersistenceUnitProcessor.getClassNamesFromURL(url, m_loader, null));
}
// Add all the classes off the classpath at the persistence unit root url.
Set<String> unlistedClasses = Collections.EMPTY_SET;
if (! persistenceUnitInfo.excludeUnlistedClasses()) {
unlistedClasses = PersistenceUnitProcessor.getClassNamesFromURL(persistenceUnitInfo.getPersistenceUnitRootUrl(), m_loader, m_predeployProperties);
}
// 5 - Go through all the class names we found and add those classes
// that have not yet been added. Be sure to check that the accessor
// does not already exist since adding an accessor will merge its
// contents with an existing accessor and we only want that to happen
// in the XML case. Also, don't add an entity accessor if an embeddable
// accessor to the same class exists (and vice versa). XML accessors
// are loaded first, so preserve what we find there.
Iterator<String> iterator = classNames.iterator();
boolean unlisted = false;
while (iterator.hasNext() || !unlisted) {
if (!iterator.hasNext() && !unlisted) {
iterator = unlistedClasses.iterator();
unlisted = true;
}
if (iterator.hasNext()) {
String className = iterator.next();
MetadataClass candidateClass = m_factory.getMetadataClass(className, unlisted);
// JBoss Bug 227630: Do not process a null class whether it was from a
// NPE or a CNF, a warning or exception is thrown in loadClass()
if (candidateClass != null) {
if (PersistenceUnitProcessor.isEntity(candidateClass) && ! m_project.hasEntity(candidateClass) && ! m_project.hasEmbeddable(candidateClass)) {
m_project.addEntityAccessor(new EntityAccessor(PersistenceUnitProcessor.getEntityAnnotation(candidateClass), candidateClass, m_project));
} else if (PersistenceUnitProcessor.isEmbeddable(candidateClass) && ! m_project.hasEmbeddable(candidateClass) && ! m_project.hasEntity(candidateClass)) {
m_project.addEmbeddableAccessor(new EmbeddableAccessor(PersistenceUnitProcessor.getEmbeddableAnnotation(candidateClass), candidateClass, m_project));
} else if (PersistenceUnitProcessor.isStaticMetamodelClass(candidateClass)) {
m_project.addStaticMetamodelClass(PersistenceUnitProcessor.getStaticMetamodelAnnotation(candidateClass), candidateClass);
} else if (PersistenceUnitProcessor.isConverter(candidateClass) && ! m_project.hasConverterAccessor(candidateClass)) {
m_project.addConverterAccessor(new ConverterAccessor(PersistenceUnitProcessor.getConverterAnnotation(candidateClass), candidateClass, m_project));
} else if (PersistenceUnitProcessor.isMappedSuperclass(candidateClass) && ! m_project.hasMappedSuperclass(candidateClass)) {
// ensure mapped superclasses will be added to the metamodel even if they do not have entity subclasses
// add the mapped superclass to keep track of it in case it is not processed later (has no subclasses).
m_project.addMappedSuperclass(new MappedSuperclassAccessor(
PersistenceUnitProcessor.getMappedSuperclassAnnotation(candidateClass),
candidateClass, m_project));
}
}
}
}
}
/**
* INTERNAL:
* This method is responsible for figuring out list of mapping files to
* read into XMLEntityMappings objects and store on the project. Note,
* the order the files are discovered and read is very important so do
* not change the order of invocation.
*/
public void loadMappingFiles(boolean throwExceptionOnFail) {
// Read all the standard XML mapping files first.
loadStandardMappingFiles(MetadataHelper.JPA_ORM_FILE);
// Read all the explicitly specified mapping files second.
loadSpecifiedMappingFiles(throwExceptionOnFail);
// Read all the standard eclipselink files last (if the user hasn't
// explicitly excluded them). The eclipselink orm files will be
// processed last therefore allowing them to override and merge
// metadata where necessary. Note: we want the eclipselink orm
// metadata to merge into standard jpa files and not vice versa.
// Loading them last will ensure this happens.
Boolean excludeEclipseLinkORM = Boolean.valueOf((String) m_project.getPersistenceUnitInfo().getProperties().get(PersistenceUnitProperties.EXCLUDE_ECLIPSELINK_ORM_FILE));
if (! excludeEclipseLinkORM) {
loadStandardMappingFiles(MetadataHelper.ECLIPSELINK_ORM_FILE);
}
if (m_metadataSource !=null) {
XMLEntityMappings entityMappings = m_metadataSource.getEntityMappings(this.m_predeployProperties, m_loader, m_session.getSessionLog());
if (entityMappings != null) {
m_project.addEntityMappings(entityMappings);
}
}
}
/**
* INTERNAL:
*/
protected void loadSpecifiedMappingFiles(boolean throwExceptionOnFail) {
PersistenceUnitInfo puInfo = m_project.getPersistenceUnitInfo();
for (String mappingFileName : puInfo.getMappingFileNames()) {
try {
Enumeration<URL> mappingFileURLs = m_loader.getResources(mappingFileName);
if (!mappingFileURLs.hasMoreElements()){
mappingFileURLs = m_loader.getResources("/./" + mappingFileName);
}
if (mappingFileURLs.hasMoreElements()) {
URL nextURL = mappingFileURLs.nextElement();
if (nextURL == null) {
nextURL = mappingFileURLs.nextElement();
}
if (mappingFileURLs.hasMoreElements()) {
// Switched to warning, same file can be on the classpath twice in some deployments,
// should not be an error.
Throwable throwable = ValidationException.nonUniqueMappingFileName(puInfo.getPersistenceUnitName(), mappingFileName);
getSessionLog().logThrowable(SessionLog.FINER, SessionLog.METADATA, throwable);
}
// Read the document through OX and add it to the project.
m_project.addEntityMappings(XMLEntityMappingsReader.read(nextURL, m_loader, m_project.getPersistenceUnitInfo().getProperties()));
} else {
handleORMException(ValidationException.mappingFileNotFound(puInfo.getPersistenceUnitName(), mappingFileName), mappingFileName, throwExceptionOnFail);
}
} catch (IOException e) {
handleORMException(PersistenceUnitLoadingException.exceptionLoadingORMXML(mappingFileName, e), mappingFileName, throwExceptionOnFail);
}
}
}
/**
* INTERNAL:
*/
protected void loadStandardMappingFiles(String ormXMLFile) {
PersistenceUnitInfo puInfo = m_project.getPersistenceUnitInfo();
Collection<URL> rootUrls = new HashSet<URL>(puInfo.getJarFileUrls());
rootUrls.add(puInfo.getPersistenceUnitRootUrl());
for (URL rootURL : rootUrls) {
getSessionLog().log(SessionLog.FINER, SessionLog.METADATA, "searching_for_default_mapping_file", new Object[] { ormXMLFile, rootURL }, true);
URL ormURL = null;
Archive par = null;
try {
par = PersistenceUnitProcessor.getArchiveFactory(m_loader).createArchive(rootURL, null);
if (par != null) {
ormURL = par.getEntryAsURL(ormXMLFile);
if (ormURL != null) {
getSessionLog().log(SessionLog.FINER, SessionLog.METADATA, "found_default_mapping_file", new Object[] { ormURL, rootURL }, true);
// Read the document through OX and add it to the project., pass persistence unit properties for any orm properties set there
XMLEntityMappings entityMappings = XMLEntityMappingsReader.read(ormURL, m_loader, m_project.getPersistenceUnitInfo().getProperties());
entityMappings.setIsEclipseLinkORMFile(ormXMLFile.equals(MetadataHelper.ECLIPSELINK_ORM_FILE));
m_project.addEntityMappings(entityMappings);
}
}
} catch (IOException e) {
throw new RuntimeException(e);
} catch (URISyntaxException e) {
throw new RuntimeException(e);
} finally {
if (par != null) {
par.close();
}
}
}
}
/**
* INTERNAL:
* Return the SessionLog from the Session. If the session is null,
* return the AbstractSessionLog's SessionLog.
* @return SessionLog
*/
protected SessionLog getSessionLog() {
if (m_session != null) {
return m_session.getSessionLog();
} else {
return AbstractSessionLog.getLog();
}
}
/**
* INTERNAL:
* Process the customizer for those entities and embeddables that have one
* defined. This must be the last thing called on this processor before
* cleanup.
*/
public void processCustomizers() {
for (ClassAccessor classAccessor: m_project.getAccessorsWithCustomizer()) {
DescriptorCustomizer customizer = (DescriptorCustomizer) MetadataHelper.getClassInstance(classAccessor.getCustomizerClass().getName(), m_loader);
try {
customizer.customize(classAccessor.getDescriptor().getClassDescriptor());
} catch (Exception e) {
getSessionLog().logThrowable(SessionLog.FINER, SessionLog.METADATA, e);
}
}
}
/**
* INTERNAL:
* Performs the initialization of the persistence unit classes and then
* processes the xml metadata.
* Note: Do not change the order of invocation of various methods.
*/
public void processEntityMappings(PersistenceUnitProcessor.Mode mode) {
if (mode == PersistenceUnitProcessor.Mode.ALL || mode == PersistenceUnitProcessor.Mode.COMPOSITE_MEMBER_INITIAL) {
m_factory = new MetadataAsmFactory(m_project.getLogger(), m_loader);
// 1 - Process persistence unit meta data/defaults defined in ORM XML
// instance documents in the persistence unit. If multiple conflicting
// persistence unit meta data is found, this call will throw an
// exception. The meta data we find here will be applied in the
// initialize call below.
for (XMLEntityMappings entityMappings : m_project.getEntityMappings()) {
// Since this our first iteration through the entity mappings list,
// set the project and loader references. This is very important
// and must be done first!
entityMappings.setLoader(m_loader);
entityMappings.setProject(m_project);
entityMappings.setMetadataFactory(m_factory);
// Process the persistence unit metadata if defined.
entityMappings.processPersistenceUnitMetadata();
}
// 2 - Initialize all the persistence unit class with the meta data we
// processed in step 1.
initPersistenceUnitClasses();
// 3 - Now process the entity mappings metadata.
for (XMLEntityMappings entityMappings : m_project.getEntityMappings()) {
entityMappings.process();
}
}
}
/**
* INTERNAL:
* Process the ORM metadata on this processors metadata project
* (representing a single persistence-unit)
*/
public void processORMMetadata(PersistenceUnitProcessor.Mode mode) {
if (mode == Mode.ALL || mode == Mode.COMPOSITE_MEMBER_INITIAL) {
m_project.processStage1();
m_project.processStage2();
}
if (mode != PersistenceUnitProcessor.Mode.COMPOSITE_MEMBER_INITIAL) {
m_project.processStage3(mode);
}
}
/**
* INTERNAL:
* Use this method to set the correct class loader that should be used
* during processing. Currently, the class loader should only change
* once, from preDeploy to deploy.
*/
public void setClassLoader(ClassLoader loader) {
m_loader = loader;
m_factory.setLoader(loader);
// Update the loader on all the entity mappings for this project.
for (XMLEntityMappings entityMappings : m_project.getEntityMappings()) {
entityMappings.setLoader(m_loader);
}
}
/**
* INTERNAL:
* Use this method to set the MetadataSource class to use for loading
* extensible mappings
*/
public void setMetadataSource(MetadataSource source){
m_metadataSource = source;
}
}