| /* |
| * 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.cocoon.components.slide.impl; |
| |
| import java.util.Hashtable; |
| |
| import org.apache.avalon.framework.activity.Disposable; |
| import org.apache.avalon.framework.activity.Initializable; |
| import org.apache.avalon.framework.configuration.Configurable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.configuration.SAXConfigurationHandler; |
| import org.apache.avalon.framework.context.ContextException; |
| import org.apache.avalon.framework.context.Contextualizable; |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.avalon.framework.service.Serviceable; |
| import org.apache.avalon.framework.thread.ThreadSafe; |
| import org.apache.cocoon.Constants; |
| import org.apache.cocoon.components.slide.SlideRepository; |
| import org.apache.cocoon.environment.Context; |
| import org.apache.excalibur.source.Source; |
| import org.apache.excalibur.source.SourceResolver; |
| import org.apache.excalibur.xml.sax.SAXParser; |
| import org.apache.slide.common.Domain; |
| import org.apache.slide.common.EmbeddedDomain; |
| import org.apache.slide.common.NamespaceAccessToken; |
| import org.xml.sax.InputSource; |
| |
| /** |
| * The class represent a manger for slide repositories |
| * |
| * @version CVS $Id$ |
| */ |
| public class SlideRepositoryImpl extends AbstractLogEnabled |
| implements SlideRepository, Contextualizable, Serviceable, Configurable, |
| Initializable, Disposable, ThreadSafe { |
| |
| private ServiceManager manager; |
| |
| /** |
| * The SlideRepository will handle the domain lifecycle only, |
| * if it is not already initialzed. |
| */ |
| private EmbeddedDomain domain = null; |
| |
| private String file; |
| private String contextpath; |
| private String workdir; |
| |
| |
| public SlideRepositoryImpl() { |
| } |
| |
| public void service(ServiceManager manager) throws ServiceException { |
| this.manager = manager; |
| } |
| |
| public void contextualize(org.apache.avalon.framework.context.Context context) |
| throws ContextException { |
| Context ctx = ((Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT)); |
| this.contextpath = ctx.getRealPath("/"); |
| this.workdir = context.get(Constants.CONTEXT_WORK_DIR).toString(); |
| } |
| |
| public void configure(Configuration configuration) |
| throws ConfigurationException { |
| |
| this.file = configuration.getAttribute("file", "WEB-INF/slide.xconf"); |
| } |
| |
| public void initialize() throws Exception { |
| |
| if (Domain.isInitialized()) { |
| return; |
| } |
| |
| getLogger().info("Initializing domain."); |
| |
| this.domain = new EmbeddedDomain(); |
| // FIXME Could not remove deprecated method, because some important |
| // messages were thrown over the domain logger |
| domain.setLogger(new SlideLoggerAdapter(getLogger())); |
| |
| SourceResolver resolver = null; |
| SAXParser parser = null; |
| Source source = null; |
| Configuration configuration = null; |
| try { |
| resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE); |
| |
| parser = (SAXParser) this.manager.lookup(SAXParser.ROLE); |
| SAXConfigurationHandler confighandler = new SAXConfigurationHandler(); |
| |
| source = resolver.resolveURI(this.file); |
| parser.parse(new InputSource(source.getInputStream()),confighandler); |
| configuration = confighandler.getConfiguration(); |
| |
| } finally { |
| if (source != null) { |
| resolver.release(source); |
| } |
| if (parser != null) { |
| this.manager.release(parser); |
| } |
| if (resolver != null) { |
| this.manager.release(resolver); |
| } |
| } |
| |
| Configuration[] parameters = configuration.getChildren("parameter"); |
| Hashtable table = new Hashtable(); |
| for (int i = 0; i < parameters.length; i++) { |
| String name = parameters[i].getAttribute("name"); |
| table.put(name, parameters[i].getValue("")); |
| } |
| table.put("contextpath", this.contextpath); |
| table.put("workdir", this.workdir); |
| this.domain.setParameters(table); |
| |
| domain.setDefaultNamespace(configuration.getAttribute("default","cocoon")); |
| Configuration[] namespace = configuration.getChildren("namespace"); |
| |
| for (int i = 0; i< namespace.length; i++) { |
| String name = namespace[i].getAttribute("name"); |
| Configuration definition = namespace[i].getChild("definition"); |
| Configuration config = namespace[i].getChild("configuration"); |
| Configuration data = namespace[i].getChild("data"); |
| |
| getLogger().info("Initializing namespace: " + name); |
| |
| domain.addNamespace(name, |
| new SlideLoggerAdapter(getLogger().getChildLogger(name)), |
| new SlideConfigurationAdapter(definition), |
| new SlideConfigurationAdapter(config), |
| new SlideConfigurationAdapter(data)); |
| |
| } |
| |
| domain.start(); |
| Domain.setInitialized(true); |
| } |
| |
| public void dispose() { |
| try { |
| domain.stop(); |
| } catch (Exception e) { |
| getLogger().error("Could not stop domain", e); |
| } |
| } |
| |
| /** |
| * Returns a token for the access of the default namespace. |
| * |
| * @return NamespaceAccessToken Access token to the namespace |
| */ |
| public NamespaceAccessToken getDefaultNamespaceToken() { |
| |
| if (domain != null) { |
| return this.domain.getNamespaceToken(this.domain.getDefaultNamespace()); |
| } |
| |
| return Domain.accessNamespace(null, Domain.getDefaultNamespace()); |
| } |
| |
| /** |
| * Returns a token for the access of a namespace. |
| * |
| * @param namespaceName Name of the namespace on which access is requested |
| * @return NamespaceAccessToken Access token to the namespace |
| */ |
| public NamespaceAccessToken getNamespaceToken(String namespaceName) { |
| |
| if (namespaceName == null) { |
| return getDefaultNamespaceToken(); |
| } |
| |
| if (domain != null) { |
| return this.domain.getNamespaceToken(namespaceName); |
| } |
| |
| return Domain.accessNamespace(null, namespaceName); |
| } |
| } |