| /******************************************************************************* |
| * 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.ofbiz.entity.config.model; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.HashMap; |
| |
| import org.apache.ofbiz.base.lang.ThreadSafe; |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.UtilProperties; |
| import org.apache.ofbiz.base.util.UtilURL; |
| import org.apache.ofbiz.base.util.UtilXml; |
| import org.apache.ofbiz.entity.GenericEntityConfException; |
| import org.w3c.dom.Element; |
| |
| /** |
| * A singleton class that models the <code><entity-config></code> element. |
| * |
| * @see <code>entity-config.xsd</code> |
| */ |
| @ThreadSafe |
| public final class EntityConfig { |
| public static final String ENTITY_ENGINE_XML_FILENAME = "entityengine.xml"; |
| |
| private static final String module = EntityConfig.class.getName(); |
| |
| private static final EntityConfig instance = createNewInstance(); |
| private final List<ResourceLoader> resourceLoaderList; // <resource-loader> |
| private final Map<String, ResourceLoader> resourceLoaderMap; // <resource-loader> |
| private final TransactionFactory transactionFactory; // <transaction-factory> |
| private final ConnectionFactory connectionFactory; // <connection-factory> |
| private final DebugXaResources debugXaResources; // <debug-xa-resources> |
| private final List<DelegatorElement> delegatorList; // <delegator> |
| private final Map<String, DelegatorElement> delegatorMap; // <delegator> |
| private final List<EntityModelReader> entityModelReaderList; // <entity-model-reader> |
| private final Map<String, EntityModelReader> entityModelReaderMap; // <entity-model-reader> |
| private final List<EntityGroupReader> entityGroupReaderList; // <entity-group-reader> |
| private final Map<String, EntityGroupReader> entityGroupReaderMap; // <entity-group-reader> |
| private final List<EntityEcaReader> entityEcaReaderList; // <entity-eca-reader> |
| private final Map<String, EntityEcaReader> entityEcaReaderMap; // <entity-eca-reader> |
| private final List<EntityDataReader> entityDataReaderList; // <entity-data-reader> |
| private final Map<String, EntityDataReader> entityDataReaderMap; // <entity-data-reader> |
| private final List<FieldType> fieldTypeList; // <field-type> |
| private final Map<String, FieldType> fieldTypeMap; // <field-type> |
| private final List<Datasource> datasourceList; // <datasource> |
| private final Map<String, Datasource> datasourceMap; |
| |
| private EntityConfig() throws GenericEntityConfException { |
| Element element; |
| URL confUrl = UtilURL.fromResource(ENTITY_ENGINE_XML_FILENAME); |
| if (confUrl == null) { |
| throw new GenericEntityConfException("Could not find the " + ENTITY_ENGINE_XML_FILENAME + " file"); |
| } |
| try { |
| element = UtilXml.readXmlDocument(confUrl, true, true).getDocumentElement(); |
| } catch (Exception e) { |
| throw new GenericEntityConfException("Exception thrown while reading " + ENTITY_ENGINE_XML_FILENAME + ": ", e); |
| } |
| |
| List<? extends Element> resourceLoaderElementList = UtilXml.childElementList(element, "resource-loader"); |
| if (resourceLoaderElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <resource-loader> are missing"); |
| } else { |
| List<ResourceLoader> resourceLoaderList = new ArrayList<ResourceLoader>(resourceLoaderElementList.size()); |
| Map<String, ResourceLoader> resourceLoaderMap = new HashMap<String, ResourceLoader>(); |
| for (Element resourceLoaderElement : resourceLoaderElementList) { |
| ResourceLoader resourceLoader = new ResourceLoader(resourceLoaderElement); |
| resourceLoaderList.add(resourceLoader); |
| resourceLoaderMap.put(resourceLoader.getName(), resourceLoader); |
| } |
| this.resourceLoaderList = Collections.unmodifiableList(resourceLoaderList); |
| this.resourceLoaderMap = Collections.unmodifiableMap(resourceLoaderMap); |
| } |
| Element transactionFactoryElement = UtilXml.firstChildElement(element, "transaction-factory"); |
| if (transactionFactoryElement == null) { |
| throw new GenericEntityConfException("<entity-config> element child element <transaction-factory> is missing"); |
| } else { |
| this.transactionFactory = new TransactionFactory(transactionFactoryElement); |
| } |
| Element connectionFactoryElement = UtilXml.firstChildElement(element, "connection-factory"); |
| if (connectionFactoryElement != null) { |
| this.connectionFactory = new ConnectionFactory(connectionFactoryElement); |
| } else { |
| this.connectionFactory = null; |
| } |
| Element debugXaResourcesElement = UtilXml.firstChildElement(element, "debug-xa-resources"); |
| if (debugXaResourcesElement == null) { |
| throw new GenericEntityConfException("<entity-config> element child element <debug-xa-resources> is missing"); |
| } else { |
| this.debugXaResources = new DebugXaResources(debugXaResourcesElement); |
| } |
| List<? extends Element> delegatorElementList = UtilXml.childElementList(element, "delegator"); |
| if (delegatorElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <delegator> are missing"); |
| } else { |
| List<DelegatorElement> delegatorList = new ArrayList<DelegatorElement>(delegatorElementList.size()); |
| Map<String, DelegatorElement> delegatorMap = new HashMap<String, DelegatorElement>(); |
| for (Element delegatorElement : delegatorElementList) { |
| DelegatorElement delegator = new DelegatorElement(delegatorElement); |
| delegatorList.add(delegator); |
| delegatorMap.put(delegator.getName(), delegator); |
| } |
| this.delegatorList = Collections.unmodifiableList(delegatorList); |
| this.delegatorMap = Collections.unmodifiableMap(delegatorMap); |
| } |
| List<? extends Element> entityModelReaderElementList = UtilXml.childElementList(element, "entity-model-reader"); |
| if (entityModelReaderElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <entity-model-reader> are missing"); |
| } else { |
| List<EntityModelReader> entityModelReaderList = new ArrayList<EntityModelReader>(entityModelReaderElementList.size()); |
| Map<String, EntityModelReader> entityModelReaderMap = new HashMap<String, EntityModelReader>(); |
| for (Element entityModelReaderElement : entityModelReaderElementList) { |
| EntityModelReader entityModelReader = new EntityModelReader(entityModelReaderElement); |
| entityModelReaderList.add(entityModelReader); |
| entityModelReaderMap.put(entityModelReader.getName(), entityModelReader); |
| } |
| this.entityModelReaderList = Collections.unmodifiableList(entityModelReaderList); |
| this.entityModelReaderMap = Collections.unmodifiableMap(entityModelReaderMap); |
| } |
| List<? extends Element> entityGroupReaderElementList = UtilXml.childElementList(element, "entity-group-reader"); |
| if (entityGroupReaderElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <entity-group-reader> are missing"); |
| } else { |
| List<EntityGroupReader> entityGroupReaderList = new ArrayList<EntityGroupReader>(entityGroupReaderElementList.size()); |
| Map<String, EntityGroupReader> entityGroupReaderMap = new HashMap<String, EntityGroupReader>(); |
| for (Element entityGroupReaderElement : entityGroupReaderElementList) { |
| EntityGroupReader entityGroupReader = new EntityGroupReader(entityGroupReaderElement); |
| entityGroupReaderList.add(entityGroupReader); |
| entityGroupReaderMap.put(entityGroupReader.getName(), entityGroupReader); |
| } |
| this.entityGroupReaderList = Collections.unmodifiableList(entityGroupReaderList); |
| this.entityGroupReaderMap = Collections.unmodifiableMap(entityGroupReaderMap); |
| } |
| List<? extends Element> entityEcaReaderElementList = UtilXml.childElementList(element, "entity-eca-reader"); |
| if (entityEcaReaderElementList.isEmpty()) { |
| this.entityEcaReaderList = Collections.emptyList(); |
| this.entityEcaReaderMap = Collections.emptyMap(); |
| } else { |
| List<EntityEcaReader> entityEcaReaderList = new ArrayList<EntityEcaReader>(entityEcaReaderElementList.size()); |
| Map<String, EntityEcaReader> entityEcaReaderMap = new HashMap<String, EntityEcaReader>(); |
| for (Element entityEcaReaderElement : entityEcaReaderElementList) { |
| EntityEcaReader entityEcaReader = new EntityEcaReader(entityEcaReaderElement); |
| entityEcaReaderList.add(new EntityEcaReader(entityEcaReaderElement)); |
| entityEcaReaderMap.put(entityEcaReader.getName(), entityEcaReader); |
| } |
| this.entityEcaReaderList = Collections.unmodifiableList(entityEcaReaderList); |
| this.entityEcaReaderMap = Collections.unmodifiableMap(entityEcaReaderMap); |
| } |
| List<? extends Element> entityDataReaderElementList = UtilXml.childElementList(element, "entity-data-reader"); |
| if (entityDataReaderElementList.isEmpty()) { |
| this.entityDataReaderList = Collections.emptyList(); |
| this.entityDataReaderMap = Collections.emptyMap(); |
| } else { |
| List<EntityDataReader> entityDataReaderList = new ArrayList<EntityDataReader>(entityDataReaderElementList.size()); |
| Map<String, EntityDataReader> entityDataReaderMap = new HashMap<String, EntityDataReader>(); |
| for (Element entityDataReaderElement : entityDataReaderElementList) { |
| EntityDataReader entityDataReader = new EntityDataReader(entityDataReaderElement); |
| entityDataReaderList.add(entityDataReader); |
| entityDataReaderMap.put(entityDataReader.getName(), entityDataReader); |
| } |
| this.entityDataReaderList = Collections.unmodifiableList(entityDataReaderList); |
| this.entityDataReaderMap = Collections.unmodifiableMap(entityDataReaderMap); |
| } |
| List<? extends Element> fieldTypeElementList = UtilXml.childElementList(element, "field-type"); |
| if (fieldTypeElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <field-type> are missing"); |
| } else { |
| List<FieldType> fieldTypeList = new ArrayList<FieldType>(fieldTypeElementList.size()); |
| Map<String, FieldType> fieldTypeMap = new HashMap<String, FieldType>(); |
| for (Element fieldTypeElement : fieldTypeElementList) { |
| FieldType fieldType = new FieldType(fieldTypeElement); |
| fieldTypeList.add(fieldType); |
| fieldTypeMap.put(fieldType.getName(), fieldType); |
| } |
| this.fieldTypeList = Collections.unmodifiableList(fieldTypeList); |
| this.fieldTypeMap = Collections.unmodifiableMap(fieldTypeMap); |
| } |
| List<? extends Element> datasourceElementList = UtilXml.childElementList(element, "datasource"); |
| if (datasourceElementList.isEmpty()) { |
| throw new GenericEntityConfException("<entity-config> element child elements <datasource> are missing"); |
| } else { |
| List<Datasource> datasourceList = new ArrayList<Datasource>(datasourceElementList.size()); |
| Map<String, Datasource> datasourceMap = new HashMap<String, Datasource>(); |
| for (Element datasourceElement : datasourceElementList) { |
| Datasource datasource = new Datasource(datasourceElement); |
| datasourceList.add(datasource); |
| datasourceMap.put(datasource.getName(), datasource); |
| } |
| this.datasourceList = Collections.unmodifiableList(datasourceList); |
| this.datasourceMap = Collections.unmodifiableMap(datasourceMap); |
| } |
| } |
| |
| private static EntityConfig createNewInstance() { |
| EntityConfig entityConfig = null; |
| try { |
| entityConfig = new EntityConfig(); |
| } catch (GenericEntityConfException gece) { |
| Debug.logError(gece, module); |
| } |
| return entityConfig; |
| } |
| |
| public static EntityConfig getInstance() throws GenericEntityConfException { |
| if (instance == null) { |
| throw new GenericEntityConfException("EntityConfig is not initialized."); |
| } |
| return instance; |
| } |
| |
| public static String createConfigFileLineNumberText(Element element) { |
| if (element.getUserData("startLine") != null) { |
| return " [" + ENTITY_ENGINE_XML_FILENAME + " line " + element.getUserData("startLine") + "]"; |
| } |
| return ""; |
| } |
| |
| /** Returns the specified <code><resource-loader></code> child element, or <code>null</code> if no child element was found. */ |
| public ResourceLoader getResourceLoader(String name) { |
| return this.resourceLoaderMap.get(name); |
| } |
| |
| /** Returns the <code><resource-loader></code> child elements. */ |
| public List<ResourceLoader> getResourceLoaderList() { |
| return this.resourceLoaderList; |
| } |
| |
| /** Returns the <code><transaction-factory></code> child element, or <code>null</code> if no child element was found. */ |
| public TransactionFactory getTransactionFactory() { |
| return this.transactionFactory; |
| } |
| |
| /** Returns the <code><connection-factory></code> child element, or <code>null</code> if no child element was found. */ |
| public ConnectionFactory getConnectionFactory() { |
| return this.connectionFactory; |
| } |
| |
| /** Returns the <code><debug-xa-resources></code> child element, or <code>null</code> if no child element was found. */ |
| public DebugXaResources getDebugXaResources() { |
| return this.debugXaResources; |
| } |
| |
| /** Returns the specified <code><delegator></code> child element, or <code>null</code> if no child element was found. */ |
| public DelegatorElement getDelegator(String name) { |
| return this.delegatorMap.get(name); |
| } |
| |
| /** Returns the <code><delegator></code> child elements. */ |
| public List<DelegatorElement> getDelegatorList() { |
| return this.delegatorList; |
| } |
| |
| /** Returns the specified <code><entity-model-reader></code> child element, or <code>null</code> if no child element was found. */ |
| public EntityModelReader getEntityModelReader(String name) { |
| return this.entityModelReaderMap.get(name); |
| } |
| |
| /** Returns the <code><entity-model-reader></code> child elements. */ |
| public List<EntityModelReader> getEntityModelReaderList() { |
| return this.entityModelReaderList; |
| } |
| |
| /** Returns the specified <code><entity-group-reader></code> child element, or <code>null</code> if no child element was found. */ |
| public EntityGroupReader getEntityGroupReader(String name) { |
| return this.entityGroupReaderMap.get(name); |
| } |
| |
| /** Returns the <code><entity-group-reader></code> child elements. */ |
| public List<EntityGroupReader> getEntityGroupReaderList() { |
| return this.entityGroupReaderList; |
| } |
| |
| /** Returns the specified <code><entity-eca-reader></code> child element, or <code>null</code> if no child element was found. */ |
| public EntityEcaReader getEntityEcaReader(String name) { |
| return this.entityEcaReaderMap.get(name); |
| } |
| |
| /** Returns the <code><entity-eca-reader></code> child elements. */ |
| public List<EntityEcaReader> getEntityEcaReaderList() { |
| return this.entityEcaReaderList; |
| } |
| |
| /** Returns the specified <code><entity-data-reader></code> child element, or <code>null</code> if no child element was found. */ |
| public EntityDataReader getEntityDataReader(String name) { |
| return this.entityDataReaderMap.get(name); |
| } |
| |
| /** Returns the <code><entity-data-reader></code> child elements. */ |
| public List<EntityDataReader> getEntityDataReaderList() { |
| return this.entityDataReaderList; |
| } |
| |
| /** Returns the specified <code><field-type></code> child element, or <code>null</code> if no child element was found. */ |
| public FieldType getFieldType(String name) { |
| return this.fieldTypeMap.get(name); |
| } |
| |
| /** Returns the <code><field-type></code> child elements. */ |
| public List<FieldType> getFieldTypeList() { |
| return this.fieldTypeList; |
| } |
| |
| /** Returns the <code><datasource></code> child elements. */ |
| public List<Datasource> getDatasourceList() { |
| return this.datasourceList; |
| } |
| |
| /** Returns the specified <code><datasource></code> child element or <code>null</code> if it does not exist. */ |
| /* |
| public Datasource getDatasource(String name) { |
| return this.datasourceMap.get(name); |
| } |
| */ |
| public static Datasource getDatasource(String name) { |
| try { |
| return getInstance().datasourceMap.get(name); |
| } catch (GenericEntityConfException e) { |
| // FIXME: Doing this so we don't have to rewrite the entire API. |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /** |
| * Returns the configured JDBC password. |
| * |
| * @param inlineJdbcElement |
| * @return The configured JDBC password. |
| * @throws GenericEntityConfException If the password was not found. |
| * |
| * @see <code>entity-config.xsd</code> |
| */ |
| public static String getJdbcPassword(InlineJdbc inlineJdbcElement) throws GenericEntityConfException { |
| String jdbcPassword = inlineJdbcElement.getJdbcPassword(); |
| if (!jdbcPassword.isEmpty()) { |
| return jdbcPassword; |
| } |
| String jdbcPasswordLookup = inlineJdbcElement.getJdbcPasswordLookup(); |
| if (jdbcPasswordLookup.isEmpty()) { |
| throw new GenericEntityConfException("No jdbc-password or jdbc-password-lookup specified for inline-jdbc element, line: " + inlineJdbcElement.getLineNumber()); |
| } |
| String key = "jdbc-password.".concat(jdbcPasswordLookup); |
| jdbcPassword = UtilProperties.getPropertyValue("passwords", key); |
| if (jdbcPassword.isEmpty()) { |
| throw new GenericEntityConfException("'" + key + "' property not found in passwords.properties file for inline-jdbc element, line: " + inlineJdbcElement.getLineNumber()); |
| } |
| return jdbcPassword; |
| } |
| |
| /** Returns the <code><datasource></code> child elements as a <code>Map</code>. */ |
| public Map<String, Datasource> getDatasourceMap() { |
| return this.datasourceMap; |
| } |
| } |