    001// Copyright 2011 The Apache Software Foundation
    002//
    003// Licensed under the Apache License, Version 2.0 (the "License");
    004// you may not use this file except in compliance with the License.
    005// You may obtain a copy of the License at
    006//
    007// http://www.apache.org/licenses/LICENSE-2.0
    008//
    009// Unless required by applicable law or agreed to in writing, software
    010// distributed under the License is distributed on an "AS IS" BASIS,
    011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    012// See the License for the specific language governing permissions and
    013// limitations under the License.
    014
    015package org.apache.tapestry5.internal.jpa;
    016
    017import org.apache.tapestry5.commons.util.CollectionFactory;
    018import org.apache.tapestry5.jpa.TapestryPersistenceUnitInfo;
    019
    020import javax.naming.Context;
    021import javax.naming.InitialContext;
    022import javax.naming.NamingException;
    023import javax.persistence.SharedCacheMode;
    024import javax.persistence.ValidationMode;
    025import javax.persistence.spi.ClassTransformer;
    026import javax.persistence.spi.PersistenceUnitTransactionType;
    027import javax.sql.DataSource;
    028import java.net.MalformedURLException;
    029import java.net.URL;
    030import java.util.Collections;
    031import java.util.List;
    032import java.util.Map;
    033import java.util.Properties;
    034import java.util.Set;
    035
    036public class PersistenceUnitInfoImpl implements TapestryPersistenceUnitInfo
    037{
    038    private String persistenceUnitName;
    039
    040    private String persistenceProviderClassName;
    041
    042    private String persistenceXMLSchemaVersion;
    043
    044    private PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
    045
    046    private DataSource nonJtaDataSource;
    047
    048    private DataSource jtaDataSource;
    049
    050    private ValidationMode validationMode;
    051
    052    private SharedCacheMode sharedCacheMode;
    053
    054    private boolean excludeUnlistedClasses = true;
    055
    056    private final Set<String> managedClassNames = CollectionFactory.newSet();
    057
    058    private final Set<String> mappingFilesNames = CollectionFactory.newSet();
    059
    060    private final List<URL> jarFileUrls = CollectionFactory.newList();
    061
    062    private final Properties properties = new Properties();
    063
    064                private Map entityManagerProperties;
    065
    066    public PersistenceUnitInfoImpl(String persistenceUnitName)
    067    {
    068        this.persistenceUnitName = persistenceUnitName;
    069    }
    070
    071    /**
    072     * {@inheritDoc}
    073     */
    074    @Override
    075    public String getPersistenceUnitName()
    076    {
    077        return persistenceUnitName;
    078    }
    079
    080    /**
    081     * {@inheritDoc}
    082     */
    083    @Override
    084    public String getPersistenceProviderClassName()
    085    {
    086        return persistenceProviderClassName;
    087    }
    088
    089    /**
    090     * {@inheritDoc}
    091     */
    092    @Override
    093    public TapestryPersistenceUnitInfo persistenceProviderClassName(final String persistenceProviderClassName)
    094    {
    095        this.persistenceProviderClassName = persistenceProviderClassName;
    096
    097        return this;
    098    }
    099
    100    /**
    101     * {@inheritDoc}
    102     */
    103    @Override
    104    public PersistenceUnitTransactionType getTransactionType()
    105    {
    106        return transactionType;
    107    }
    108
    109    /**
    110     * {@inheritDoc}
    111     */
    112    @Override
    113    public TapestryPersistenceUnitInfo transactionType(final PersistenceUnitTransactionType transactionType)
    114    {
    115        this.transactionType = transactionType;
    116
    117        return this;
    118    }
    119
    120    /**
    121     * {@inheritDoc}
    122     */
    123    @Override
    124    public DataSource getJtaDataSource()
    125    {
    126        return jtaDataSource;
    127    }
    128
    129    /**
    130     * {@inheritDoc}
    131     */
    132    @Override
    133    public DataSource getNonJtaDataSource()
    134    {
    135        return nonJtaDataSource;
    136    }
    137
    138    /**
    139     * {@inheritDoc}
    140     */
    141    @Override
    142    public TapestryPersistenceUnitInfo nonJtaDataSource(final String nonJtaDataSource)
    143    {
    144        this.nonJtaDataSource = lookupDataSource(nonJtaDataSource);
    145
    146        return this;
    147    }
    148
    149    /**
    150     * {@inheritDoc}
    151     */
    152    @Override
    153    public TapestryPersistenceUnitInfo jtaDataSource(final String jtaDataSource)
    154    {
    155        this.jtaDataSource = lookupDataSource(jtaDataSource);
    156
    157        return this;
    158    }
    159
    160    /**
    161     * {@inheritDoc}
    162     */
    163    @Override
    164    public List<String> getMappingFileNames()
    165    {
    166        List<String> tmp = CollectionFactory.newList(mappingFilesNames);
    167        return Collections.unmodifiableList(tmp);
    168    }
    169
    170    /**
    171     * {@inheritDoc}
    172     */
    173    @Override
    174    public TapestryPersistenceUnitInfo addMappingFileName(final String fileName)
    175    {
    176        mappingFilesNames.add(fileName);
    177
    178        return this;
    179
    180    }
    181
    182    /**
    183     * {@inheritDoc}
    184     */
    185    @Override
    186    public TapestryPersistenceUnitInfo addJarFileUrl(URL url)
    187    {
    188        jarFileUrls.add(url);
    189
    190        return this;
    191    }
    192
    193    /**
    194     * {@inheritDoc}
    195     */
    196    @Override
    197    public TapestryPersistenceUnitInfo addJarFileUrl(String url)
    198    {
    199        try
    200        {
    201            return addJarFileUrl(new URL(getPersistenceUnitRootUrl(), url));
    202        } catch (MalformedURLException e)
    203        {
    204            throw new RuntimeException(e);
    205        }
    206    }
    207
    208
    209    /**
    210     * {@inheritDoc}
    211     */
    212    @Override
    213    public TapestryPersistenceUnitInfo addProperty(String name, String value)
    214    {
    215        getProperties().put(name, value);
    216
    217        return this;
    218    }
    219
    220
    221    /**
    222     * {@inheritDoc}
    223     */
    224    @Override
    225    public TapestryPersistenceUnitInfo excludeUnlistedClasses(boolean exclude)
    226    {
    227        this.excludeUnlistedClasses = exclude;
    228
    229        return this;
    230    }
    231
    232    /**
    233     * {@inheritDoc}
    234     */
    235    @Override
    236    public List<URL> getJarFileUrls()
    237    {
    238        return Collections.unmodifiableList(jarFileUrls);
    239    }
    240
    241    /**
    242     * {@inheritDoc}
    243     */
    244    @Override
    245    public URL getPersistenceUnitRootUrl()
    246    {
    247        return getClass().getResource("/");
    248    }
    249
    250    /**
    251     * {@inheritDoc}
    252     */
    253    @Override
    254    public List<String> getManagedClassNames()
    255    {
    256        List<String> tmp = CollectionFactory.newList(managedClassNames);
    257        return Collections.<String>unmodifiableList(tmp);
    258    }
    259
    260    /**
    261     * {@inheritDoc}
    262     */
    263    @Override
    264    public TapestryPersistenceUnitInfo addManagedClassName(final String className)
    265    {
    266        managedClassNames.add(className);
    267
    268        return this;
    269    }
    270
    271    /**
    272     * {@inheritDoc}
    273     */
    274    @Override
    275    public TapestryPersistenceUnitInfo addManagedClass(final Class<?> clazz)
    276    {
    277        addManagedClassName(clazz.getName());
    278
    279        return this;
    280    }
    281
    282    /**
    283     * {@inheritDoc}
    284     */
    285    @Override
    286    public boolean excludeUnlistedClasses()
    287    {
    288        return excludeUnlistedClasses;
    289    }
    290
    291    /**
    292     * {@inheritDoc}
    293     */
    294    @Override
    295    public SharedCacheMode getSharedCacheMode()
    296    {
    297        return sharedCacheMode;
    298    }
    299
    300    /**
    301     * {@inheritDoc}
    302     */
    303    @Override
    304    public TapestryPersistenceUnitInfo sharedCacheMode(final SharedCacheMode cacheMode)
    305    {
    306        sharedCacheMode = cacheMode;
    307
    308        return this;
    309    }
    310
    311    /**
    312     * {@inheritDoc}
    313     */
    314    @Override
    315    public ValidationMode getValidationMode()
    316    {
    317        return validationMode;
    318    }
    319
    320    /**
    321     * {@inheritDoc}
    322     */
    323    @Override
    324    public TapestryPersistenceUnitInfo validationMode(final ValidationMode validationMode)
    325    {
    326        this.validationMode = validationMode;
    327
    328        return this;
    329    }
    330
    331    /**
    332     * {@inheritDoc}
    333     */
    334    @Override
    335    public Properties getProperties()
    336    {
    337        return properties;
    338    }
    339
    340    /**
    341     * {@inheritDoc}
    342     */
    343    @Override
    344    public String getPersistenceXMLSchemaVersion()
    345    {
    346        return persistenceXMLSchemaVersion;
    347    }
    348
    349    public void setPersistenceXMLSchemaVersion(final String version)
    350    {
    351        persistenceXMLSchemaVersion = version;
    352    }
    353
    354    /**
    355     * {@inheritDoc}
    356     */
    357    @Override
    358    public ClassLoader getClassLoader()
    359    {
    360        return Thread.currentThread().getContextClassLoader();
    361    }
    362
    363    /**
    364     * {@inheritDoc}
    365     */
    366    @Override
    367    public void addTransformer(final ClassTransformer transformer)
    368    {
    369
    370    }
    371
    372    /**
    373     * {@inheritDoc}
    374     */
    375    @Override
    376    public ClassLoader getNewTempClassLoader()
    377    {
    378        return getClassLoader();
    379    }
    380
    381
    382    private DataSource lookupDataSource(final String name)
    383    {
    384        try
    385        {
    386            // TODO: Create InitialContext with environment properties?
    387            final Context initContext = new InitialContext();
    388
    389            final Context envContext = (Context) initContext.lookup("java:comp/env");
    390
    391            return (DataSource) envContext.lookup(name);
    392        } catch (final NamingException e)
    393        {
    394            throw new RuntimeException(e);
    395        }
    396
    397    }
    398
    399    @Override
    400    public TapestryPersistenceUnitInfo setEntityManagerProperties(Map properties) {
    401        entityManagerProperties = properties;
    402        return this;
    403    }
    404
    405    @Override
    406    public Map getEntityManagerProperties() {
    407        return entityManagerProperties;
    408    }
    409
    410
    411}