| /* |
| * 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.lenya.cms.publication; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.DefaultConfiguration; |
| import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder; |
| import org.apache.avalon.framework.configuration.DefaultConfigurationSerializer; |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.lenya.cms.repository.Node; |
| import org.apache.lenya.cms.repository.Session; |
| import org.apache.lenya.util.Assert; |
| |
| /** |
| * A publication's configuration. Keep in sync with |
| * src/resources/build/publication.rng! |
| */ |
| public class PublicationConfiguration extends AbstractLogEnabled implements Publication { |
| |
| private String id; |
| private String name; |
| private String description; |
| private String version; |
| private String lenyaVersion; |
| private String lenyaRevision; |
| private String cocoonVersion; |
| |
| private File servletContext; |
| private DocumentIdToPathMapper mapper = null; |
| private SortedSet languages = new TreeSet(); |
| private String defaultLanguage = null; |
| private String breadcrumbprefix = null; |
| private String instantiatorHint = null; |
| private String contentDir = null; |
| private SortedSet modules = new TreeSet(); |
| private String contextPath; |
| |
| private boolean isConfigLoaded = false; |
| |
| /** |
| * <code>CONFIGURATION_FILE</code> The publication configuration file |
| */ |
| public static final String CONFIGURATION_FILE = CONFIGURATION_PATH + File.separator |
| + "publication.xml"; |
| |
| private static final String CONFIGURATION_NAMESPACE = "http://apache.org/cocoon/lenya/publication/1.1"; |
| |
| // properties marked with "*" are currently not parsed by this class. |
| private static final String ELEMENT_NAME = "name"; |
| private static final String ELEMENT_DESCRIPTION = "description"; // * |
| private static final String ELEMENT_VERSION = "version"; // * |
| private static final String ELEMENT_LENYA_VERSION = "lenya-version"; // * |
| private static final String ELEMENT_LENYA_REVISION = "lenya-revision"; // * |
| private static final String ELEMENT_COCOON_VERSION = "cocoon-version"; // * |
| private static final String ELEMENT_LANGUAGES = "languages"; |
| private static final String ELEMENT_LANGUAGE = "language"; |
| private static final String ATTRIBUTE_DEFAULT_LANGUAGE = "default"; |
| private static final String ELEMENT_TEMPLATE = "template"; |
| private static final String ATTRIBUTE_ID = "id"; |
| private static final String ELEMENT_TEMPLATE_INSTANTIATOR = "template-instantiator"; |
| private static final String ATTRIBUTE_NAME = "name"; |
| private static final String ELEMENT_PATH_MAPPER = "path-mapper"; |
| private static final String ELEMENT_DOCUMENT_BUILDER = "document-builder"; |
| private static final String ELEMENT_SITE_MANAGER = "site-manager"; |
| private static final String ELEMENT_RESOURCE_TYPES = "resource-types";// * |
| private static final String ELEMENT_RESOURCE_TYPE = "resource-type";// * |
| private static final String ATTRIBUTE_WORKFLOW = "workflow"; |
| private static final String ELEMENT_MODULES = "modules";// * |
| private static final String ELEMENT_MODULE = "module";// * |
| private static final String ELEMENT_BREADCRUMB_PREFIX = "breadcrumb-prefix"; |
| private static final String ELEMENT_CONTENT_DIR = "content-dir"; |
| private static final String ATTRIBUTE_SRC = "src"; |
| private static final String ELEMENT_PROXIES = "proxies"; |
| private static final String ELEMENT_PROXY = "proxy"; |
| private static final String ATTRIBUTE_AREA = "area"; |
| private static final String ATTRIBUTE_URL = "url"; |
| private static final String ATTRIBUTE_SSL = "ssl"; |
| |
| protected static final String NAMESPACE = "http://apache.org/cocoon/lenya/publication/1.1"; |
| protected static final String NS_PREFIX = ""; |
| |
| /** |
| * Creates a new instance of Publication |
| * @param _id the publication id |
| * @param servletContextPath the servlet context directory of this publication |
| * @param servletContextUrlPath The servlet context path (URL snippet). |
| * @throws PublicationException if there was a problem reading the config |
| * file |
| */ |
| protected PublicationConfiguration(String _id, String servletContextPath, String servletContextUrlPath) |
| throws PublicationException { |
| this.id = _id; |
| this.servletContext = new File(servletContextPath); |
| this.contextPath = servletContextUrlPath; |
| } |
| |
| /** |
| * Loads the configuration. |
| */ |
| protected void loadConfiguration() { |
| |
| if (isConfigLoaded) { |
| return; |
| } |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Loading configuration for publication [" + getId() + "]"); |
| } |
| |
| File configFile = getConfigurationFile(); |
| |
| if (!configFile.exists()) { |
| getLogger().error( |
| "Config file [" + configFile.getAbsolutePath() + "] does not exist: ", |
| new RuntimeException()); |
| throw new RuntimeException("The configuration file [" + configFile |
| + "] does not exist!"); |
| } else { |
| getLogger().debug("Configuration file [" + configFile + "] exists."); |
| } |
| |
| final boolean ENABLE_XML_NAMESPACES = true; |
| DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder(ENABLE_XML_NAMESPACES); |
| |
| Configuration config; |
| |
| String pathMapperClassName = null; |
| |
| try { |
| config = builder.buildFromFile(configFile); |
| |
| String pubName = config.getChild(ELEMENT_NAME).getValue(null); |
| if (pubName == null) { |
| getLogger().warn("No publication name set for publication [" + getId() + |
| "], using default name."); |
| this.name = getId(); |
| } |
| else { |
| this.name = pubName; |
| } |
| |
| this.description = config.getChild(ELEMENT_DESCRIPTION).getValue(""); |
| this.version = config.getChild(ELEMENT_VERSION).getValue(""); |
| this.lenyaVersion = config.getChild(ELEMENT_LENYA_VERSION).getValue(""); |
| this.lenyaRevision = config.getChild(ELEMENT_LENYA_REVISION).getValue(""); |
| this.cocoonVersion = config.getChild(ELEMENT_COCOON_VERSION).getValue(""); |
| |
| try { |
| // one sanity check for the proper namespace. we should really |
| // do that for every element, |
| // but since ELEMENT_PATH_MAPPER is mandatory, this should catch |
| // most cases of forgotten namespace. |
| if (config.getChild(ELEMENT_PATH_MAPPER).getNamespace() != CONFIGURATION_NAMESPACE) { |
| getLogger().warn( |
| "Deprecated configuration: the publication configuration elements in " |
| + configFile + " must be in the " + CONFIGURATION_NAMESPACE |
| + " namespace." |
| + " See webapp/lenya/resources/schemas/publication.xml."); |
| } |
| pathMapperClassName = config.getChild(ELEMENT_PATH_MAPPER).getValue(); |
| Class pathMapperClass = Class.forName(pathMapperClassName); |
| this.mapper = (DocumentIdToPathMapper) pathMapperClass.newInstance(); |
| } catch (final ClassNotFoundException e) { |
| throw new PublicationException("Cannot instantiate documentToPathMapper: [" |
| + pathMapperClassName + "]", e); |
| } |
| |
| Configuration documentBuilderConfiguration = config.getChild(ELEMENT_DOCUMENT_BUILDER, |
| false); |
| if (documentBuilderConfiguration != null) { |
| this.documentBuilderHint = documentBuilderConfiguration |
| .getAttribute(ATTRIBUTE_NAME); |
| } |
| |
| Configuration[] _languages = config.getChild(ELEMENT_LANGUAGES).getChildren( |
| ELEMENT_LANGUAGE); |
| for (int i = 0; i < _languages.length; i++) { |
| Configuration languageConfig = _languages[i]; |
| String language = languageConfig.getValue(); |
| this.languages.add(language); |
| if (languageConfig.getAttribute(ATTRIBUTE_DEFAULT_LANGUAGE, null) != null) { |
| this.defaultLanguage = language; |
| } |
| } |
| |
| Configuration siteManagerConfiguration = config.getChild(ELEMENT_SITE_MANAGER, false); |
| if (siteManagerConfiguration != null) { |
| this.siteManagerName = siteManagerConfiguration.getAttribute(ATTRIBUTE_NAME); |
| } |
| |
| Configuration proxiesConfig = config.getChild(ELEMENT_PROXIES); |
| Configuration[] proxyConfigs = proxiesConfig.getChildren(ELEMENT_PROXY); |
| for (int i = 0; i < proxyConfigs.length; i++) { |
| String url = proxyConfigs[i].getAttribute(ATTRIBUTE_URL); |
| String ssl = proxyConfigs[i].getAttribute(ATTRIBUTE_SSL); |
| String area = proxyConfigs[i].getAttribute(ATTRIBUTE_AREA); |
| |
| Object key = getProxyKey(area, Boolean.valueOf(ssl).booleanValue()); |
| Proxy proxy = new Proxy(getDefaultProxyUrl(area)); |
| proxy.setUrl(url); |
| this.areaSsl2proxy.put(key, proxy); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( |
| "Adding proxy URL: [" + url + "] for area=[" + area + "] SSL=[" + ssl |
| + "]"); |
| } |
| } |
| |
| Configuration templateConfig = config.getChild(ELEMENT_TEMPLATE, false); |
| if (templateConfig != null) { |
| this.template = templateConfig.getAttribute(ATTRIBUTE_ID); |
| } |
| |
| Configuration templateInstantiatorConfig = config.getChild( |
| ELEMENT_TEMPLATE_INSTANTIATOR, false); |
| if (templateInstantiatorConfig != null) { |
| this.instantiatorHint = templateInstantiatorConfig |
| .getAttribute(PublicationConfiguration.ATTRIBUTE_NAME); |
| } |
| |
| Configuration contentDirConfig = config.getChild(ELEMENT_CONTENT_DIR, false); |
| if (contentDirConfig != null) { |
| this.contentDir = contentDirConfig.getAttribute(ATTRIBUTE_SRC); |
| getLogger().info( |
| "Content directory loaded from pub configuration: " + this.contentDir); |
| } else { |
| getLogger().info("No content directory specified within pub configuration!"); |
| } |
| |
| Configuration resourceTypeConfig = config.getChild(ELEMENT_RESOURCE_TYPES); |
| if (resourceTypeConfig != null) { |
| Configuration[] resourceTypeConfigs = resourceTypeConfig |
| .getChildren(ELEMENT_RESOURCE_TYPE); |
| for (int i = 0; i < resourceTypeConfigs.length; i++) { |
| String name = resourceTypeConfigs[i].getAttribute(ATTRIBUTE_NAME); |
| this.resourceTypes.add(name); |
| |
| String workflow = resourceTypeConfigs[i].getAttribute(ATTRIBUTE_WORKFLOW, null); |
| if (workflow != null) { |
| this.resourceType2workflow.put(name, workflow); |
| } |
| } |
| } |
| |
| Configuration modulesConf = config.getChild(ELEMENT_MODULES); |
| if (modulesConf != null) { |
| Configuration[] modulesConfigs = modulesConf.getChildren(ELEMENT_MODULE); |
| for (int i = 0; i < modulesConfigs.length; i++) { |
| String name = modulesConfigs[i].getAttribute(ATTRIBUTE_NAME); |
| this.modules.add(name); |
| } |
| } |
| |
| } catch (final Exception e) { |
| throw new RuntimeException("Problem with config file: " + configFile.getAbsolutePath(), |
| e); |
| } |
| |
| this.breadcrumbprefix = config.getChild(ELEMENT_BREADCRUMB_PREFIX).getValue(""); |
| |
| isConfigLoaded = true; |
| } |
| |
| protected String getDefaultProxyUrl(String area) { |
| return this.contextPath + "/" + this.id + "/" + area; |
| } |
| |
| /** |
| * @return The configuration file ({@link #CONFIGURATION_FILE}). |
| */ |
| protected File getConfigurationFile() { |
| File configFile = new File(getDirectory(), CONFIGURATION_FILE); |
| return configFile; |
| } |
| |
| /** |
| * Returns the publication ID. |
| * @return A string value. |
| */ |
| public String getId() { |
| return this.id; |
| } |
| |
| /** |
| * Returns the servlet context this publication belongs to (usually, the |
| * <code>webapps/lenya</code> directory). |
| * @return A <code>File</code> object. |
| */ |
| public File getServletContext() { |
| return this.servletContext; |
| } |
| |
| /** |
| * Returns the publication directory. |
| * @return A <code>File</code> object. |
| */ |
| public File getDirectory() { |
| return new File(getServletContext(), PUBLICATION_PREFIX + File.separator + getId()); |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getContentDirectory(String) |
| */ |
| public File getContentDirectory(String area) { |
| return new File(getContentDir(), area); |
| } |
| |
| /** |
| * Set the path mapper |
| * @param _mapper The path mapper |
| */ |
| public void setPathMapper(DefaultDocumentIdToPathMapper _mapper) { |
| assert _mapper != null; |
| this.mapper = _mapper; |
| } |
| |
| /** |
| * Returns the path mapper. |
| * @return a <code>DocumentIdToPathMapper</code> |
| */ |
| public DocumentIdToPathMapper getPathMapper() { |
| if (this.mapper == null) { |
| loadConfiguration(); |
| } |
| return this.mapper; |
| } |
| |
| /** |
| * Get the default language |
| * @return the default language |
| */ |
| public String getDefaultLanguage() { |
| if (this.defaultLanguage == null) { |
| loadConfiguration(); |
| } |
| return this.defaultLanguage; |
| } |
| |
| /** |
| * Set the default language |
| * @param language the default language |
| */ |
| public void setDefaultLanguage(String language) { |
| Assert.notNull(language); |
| if (!Arrays.asList(getLanguages()).contains(language)) { |
| throw new IllegalArgumentException("The publication [" + this + |
| "] doesn't contain the language [" + language + "]!"); |
| } |
| this.defaultLanguage = language; |
| } |
| |
| /** |
| * Get all available languages for this publication |
| * @return an <code>Array</code> of languages |
| */ |
| public String[] getLanguages() { |
| loadConfiguration(); |
| return (String[]) this.languages.toArray(new String[this.languages.size()]); |
| } |
| |
| /** |
| * Get the breadcrumb prefix. It can be used as a prefix if a publication is |
| * part of a larger site |
| * @return the breadcrumb prefix |
| */ |
| public String getBreadcrumbPrefix() { |
| loadConfiguration(); |
| return this.breadcrumbprefix; |
| } |
| |
| private String documentBuilderHint; |
| |
| /** |
| * Returns the document builder of this instance. |
| * @return A document builder. |
| */ |
| public String getDocumentBuilderHint() { |
| loadConfiguration(); |
| return this.documentBuilderHint; |
| } |
| |
| /** |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| public boolean equals(Object object) { |
| boolean equals = false; |
| |
| if (getClass().isInstance(object)) { |
| Publication publication = (Publication) object; |
| equals = getId().equals(publication.getId()) |
| && getServletContext().equals(publication.getServletContext()); |
| } |
| |
| return equals; |
| } |
| |
| /** |
| * @see java.lang.Object#hashCode() |
| */ |
| public int hashCode() { |
| String key = getServletContext() + ":" + getId(); |
| return key.hashCode(); |
| } |
| |
| private Map areaSsl2proxy = new HashMap(); |
| |
| /** |
| * Generates a hash key for a area-SSL combination. |
| * @param area The area. |
| * @param isSslProtected If the proxy is assigned for SSL-protected pages. |
| * @return An object. |
| */ |
| protected String getProxyKey(String area, boolean isSslProtected) { |
| return area + ":" + isSslProtected; |
| } |
| |
| protected String getProxyUrl(String area, boolean isSslProtected) { |
| loadConfiguration(); |
| Object key = getProxyKey(area, isSslProtected); |
| return (String) this.areaSsl2proxy.get(key); |
| } |
| |
| |
| public Proxy getProxy(Document document, boolean isSslProtected) { |
| return getProxy(document.getArea(), isSslProtected); |
| } |
| |
| public Proxy getProxy(String area, boolean isSslProtected) { |
| String key = getProxyKey(area, isSslProtected); |
| Proxy proxy = (Proxy) this.areaSsl2proxy.get(key); |
| if (proxy == null) { |
| proxy = new Proxy(getDefaultProxyUrl(area)); |
| this.areaSsl2proxy.put(key, proxy); |
| } |
| return proxy; |
| } |
| |
| private String siteManagerName; |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#exists() |
| */ |
| public boolean exists() { |
| return getConfigurationFile().exists(); |
| } |
| |
| private String template; |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getTemplateId() |
| */ |
| public String getTemplateId() { |
| loadConfiguration(); |
| return template; |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getSiteManagerHint() |
| */ |
| public String getSiteManagerHint() { |
| loadConfiguration(); |
| return this.siteManagerName; |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getInstantiatorHint() |
| */ |
| public String getInstantiatorHint() { |
| loadConfiguration(); |
| return this.instantiatorHint; |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getContentDir() |
| */ |
| public String getContentDir() { |
| loadConfiguration(); |
| if (this.contentDir == null) { |
| this.contentDir = getDefaultContentDir(); |
| } |
| return this.contentDir; |
| } |
| |
| protected String getDefaultContentDir() { |
| return new File(getDirectory(), CONTENT_PATH).getAbsolutePath(); |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getSourceURI() |
| */ |
| public String getSourceURI() { |
| return Node.LENYA_PROTOCOL + PUBLICATION_PREFIX_URI + "/" + this.id; |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getContentURI(java.lang.String) |
| */ |
| public String getContentURI(String area) { |
| return getSourceURI() + "/" + CONTENT_PATH + "/" + area; |
| } |
| |
| private Map resourceType2workflow = new HashMap(); |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getWorkflowSchema(org.apache.lenya.cms.publication.ResourceType) |
| */ |
| public String getWorkflowSchema(ResourceType resourceType) { |
| return (String) this.resourceType2workflow.get(resourceType.getName()); |
| } |
| |
| private SortedSet resourceTypes = new TreeSet(); |
| |
| /** |
| * @see org.apache.lenya.cms.publication.Publication#getResourceTypeNames() |
| */ |
| public String[] getResourceTypeNames() { |
| loadConfiguration(); |
| return (String[]) this.resourceTypes.toArray(new String[this.resourceTypes.size()]); |
| } |
| |
| public String toString() { |
| return getId(); |
| } |
| |
| public Area getArea(String name) throws PublicationException { |
| throw new IllegalStateException("Not implemented!"); |
| } |
| |
| private String[] areas; |
| |
| public String[] getAreaNames() { |
| // TODO: make this more generic. |
| if (this.areas == null) { |
| List list = new ArrayList(); |
| list.add(Publication.AUTHORING_AREA); |
| list.add(Publication.LIVE_AREA); |
| list.add(Publication.STAGING_AREA); |
| list.add(Publication.TRASH_AREA); |
| list.add(Publication.ARCHIVE_AREA); |
| this.areas = (String[]) list.toArray(new String[list.size()]); |
| } |
| return this.areas; |
| } |
| |
| public DocumentFactory getFactory() { |
| throw new IllegalStateException("Not implemented!"); |
| } |
| |
| public DocumentBuilder getDocumentBuilder() { |
| return null; |
| } |
| |
| public String getName() { |
| loadConfiguration(); |
| return this.name; |
| } |
| |
| public Session getSession() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public void addLanguage(String language) { |
| Assert.notNull("language", language); |
| this.languages.add(language); |
| } |
| |
| public void removeLanguage(String language) { |
| Assert.notNull("language", language); |
| if (!Arrays.asList(getLanguages()).contains(language)) { |
| throw new IllegalArgumentException("The publication [" + this + |
| "] doesn't contain the language [" + language + "]!"); |
| } |
| if (language.equals(getDefaultLanguage())) { |
| throw new IllegalArgumentException("Can't remove the language [" + language + |
| "] because it is the default language."); |
| } |
| this.languages.remove(language); |
| } |
| |
| public void setName(String name) { |
| Assert.notNull("name", name); |
| Assert.isTrue("name not empty", name.length() > 0); |
| this.name = name; |
| } |
| |
| protected DefaultConfiguration createConfig(String name) { |
| return new DefaultConfiguration(name, "", NAMESPACE, NS_PREFIX); |
| } |
| |
| protected DefaultConfiguration createConfig(String name, String value) { |
| DefaultConfiguration config = createConfig(name); |
| config.setValue(value); |
| return config; |
| } |
| |
| protected DefaultConfiguration createConfig(String name, String attrName, String attrValue) { |
| DefaultConfiguration config = createConfig(name); |
| config.setAttribute(attrName, attrValue); |
| return config; |
| } |
| |
| public void saveConfiguration() { |
| File configFile = getConfigurationFile(); |
| |
| DefaultConfiguration config = new DefaultConfiguration("publication", "", NAMESPACE, NS_PREFIX); |
| |
| try { |
| |
| config.addChild(createConfig(ELEMENT_NAME, getName())); |
| config.addChild(createConfig(ELEMENT_DESCRIPTION, this.description)); |
| config.addChild(createConfig(ELEMENT_VERSION, this.version)); |
| config.addChild(createConfig(ELEMENT_LENYA_VERSION, this.lenyaVersion)); |
| config.addChild(createConfig(ELEMENT_LENYA_REVISION, this.lenyaRevision)); |
| config.addChild(createConfig(ELEMENT_COCOON_VERSION, this.cocoonVersion)); |
| |
| config.addChild(createConfig(ELEMENT_PATH_MAPPER, getPathMapper().getClass().getName())); |
| config.addChild(createConfig(ELEMENT_DOCUMENT_BUILDER, ATTRIBUTE_NAME, getDocumentBuilderHint())); |
| |
| String[] languages = getLanguages(); |
| String defaultLanguage = getDefaultLanguage(); |
| |
| DefaultConfiguration languagesConfig = createConfig(ELEMENT_LANGUAGES); |
| for (int i = 0; i < languages.length; i++) { |
| DefaultConfiguration languageConfig = createConfig(ELEMENT_LANGUAGE); |
| languageConfig.setValue(languages[i]); |
| if (languages[i].equals(defaultLanguage)) { |
| languageConfig.setAttribute(ATTRIBUTE_DEFAULT_LANGUAGE, true); |
| } |
| languagesConfig.addChild(languageConfig); |
| } |
| config.addChild(languagesConfig); |
| |
| config.addChild(createConfig(ELEMENT_SITE_MANAGER, ATTRIBUTE_NAME, getSiteManagerHint())); |
| |
| DefaultConfiguration proxiesConfig = createConfig(ELEMENT_PROXIES); |
| config.addChild(proxiesConfig); |
| Boolean[] booleans = { Boolean.FALSE, Boolean.TRUE }; |
| String[] areas = getAreaNames(); |
| for (int b = 0; b < booleans.length; b++) { |
| for (int a = 0; a < areas.length; a++) { |
| boolean ssl = booleans[b].booleanValue(); |
| |
| Proxy proxy = getProxy(areas[a], ssl); |
| |
| // add only proxy URLs for non-default proxies |
| if (!proxy.getUrl().equals(proxy.getDefaultUrl())) { |
| DefaultConfiguration proxyConf = createConfig(ELEMENT_PROXY); |
| proxyConf.setAttribute(ATTRIBUTE_AREA, areas[a]); |
| proxyConf.setAttribute(ATTRIBUTE_SSL, ssl); |
| proxyConf.setAttribute(ATTRIBUTE_URL, proxy.getUrl()); |
| proxiesConfig.addChild(proxyConf); |
| } |
| |
| } |
| } |
| |
| String template = getTemplateId(); |
| if (template != null) { |
| config.addChild(createConfig(ELEMENT_TEMPLATE, ATTRIBUTE_ID, template)); |
| } |
| |
| String instantiatorHint = getInstantiatorHint(); |
| if (instantiatorHint != null) { |
| config.addChild(createConfig(ELEMENT_TEMPLATE_INSTANTIATOR, ATTRIBUTE_NAME, instantiatorHint)); |
| } |
| |
| String contentDir = getContentDir(); |
| if (!contentDir.equals(getDefaultContentDir())) { |
| config.addChild(createConfig(ELEMENT_CONTENT_DIR, ATTRIBUTE_SRC, this.contentDir)); |
| } |
| |
| DefaultConfiguration resourceTypesConf = createConfig(ELEMENT_RESOURCE_TYPES); |
| config.addChild(resourceTypesConf); |
| String[] resourceTypes = getResourceTypeNames(); |
| for (int i = 0; i < resourceTypes.length; i++) { |
| String type = resourceTypes[i]; |
| DefaultConfiguration resourceTypeConf = createConfig(ELEMENT_RESOURCE_TYPE, ATTRIBUTE_NAME, type); |
| if (this.resourceType2workflow.containsKey(type)) { |
| resourceTypeConf.setAttribute(ATTRIBUTE_WORKFLOW, (String) |
| this.resourceType2workflow.get(type)); |
| } |
| resourceTypesConf.addChild(resourceTypeConf); |
| } |
| |
| DefaultConfiguration modulesConf = createConfig(ELEMENT_MODULES); |
| config.addChild(modulesConf); |
| String[] modules = getModuleNames(); |
| for (int i = 0; i < modules.length; i++) { |
| DefaultConfiguration moduleConf = createConfig(ELEMENT_MODULE, ATTRIBUTE_NAME, modules[i]); |
| modulesConf.addChild(moduleConf); |
| } |
| |
| config.addChild(createConfig(ELEMENT_BREADCRUMB_PREFIX, getBreadcrumbPrefix())); |
| |
| DefaultConfigurationSerializer serializer = new DefaultConfigurationSerializer(); |
| serializer.setIndent(true); |
| serializer.serializeToFile(getConfigurationFile(), config); |
| |
| } catch (final Exception e) { |
| throw new RuntimeException("Problem with config file: " + configFile.getAbsolutePath(), |
| e); |
| } |
| } |
| |
| public String[] getModuleNames() { |
| return (String[]) this.modules.toArray(new String[this.modules.size()]); |
| } |
| |
| } |