001    package org.apache.turbine.services.naming;
002    
003    
004    /*
005     * Licensed to the Apache Software Foundation (ASF) under one
006     * or more contributor license agreements.  See the NOTICE file
007     * distributed with this work for additional information
008     * regarding copyright ownership.  The ASF licenses this file
009     * to you under the Apache License, Version 2.0 (the
010     * "License"); you may not use this file except in compliance
011     * with the License.  You may obtain a copy of the License at
012     *
013     *   http://www.apache.org/licenses/LICENSE-2.0
014     *
015     * Unless required by applicable law or agreed to in writing,
016     * software distributed under the License is distributed on an
017     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
018     * KIND, either express or implied.  See the License for the
019     * specific language governing permissions and limitations
020     * under the License.
021     */
022    
023    
024    import java.util.HashMap;
025    import java.util.Iterator;
026    import java.util.Map;
027    import java.util.Properties;
028    
029    import javax.naming.Context;
030    import javax.naming.InitialContext;
031    import javax.naming.NamingException;
032    
033    import org.apache.commons.configuration.Configuration;
034    import org.apache.commons.logging.Log;
035    import org.apache.commons.logging.LogFactory;
036    import org.apache.turbine.Turbine;
037    import org.apache.turbine.services.InitializationException;
038    import org.apache.turbine.services.TurbineBaseService;
039    
040    /**
041     * This class is the default implementation of NamingService, which
042     * provides JNDI naming contexts.
043     *
044     * @author <a href="mailto:greg@shwoop.com">Greg Ritter</a>
045     * @author <a href="mailto:colin.chalmers@maxware.nl">Colin Chalmers</a>
046     * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
047     * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a>
048     * @version $Id: TurbineNamingService.java 1078552 2011-03-06 19:58:46Z tv $
049     */
050    public class TurbineNamingService
051            extends TurbineBaseService
052            implements NamingService
053    {
054        /** Logging */
055        private static Log log = LogFactory.getLog(TurbineNamingService.class);
056    
057        /**
058         * A global Map of Property objects which are initialised using
059         * parameters from the ResourcesFile
060         */
061        private static Map<String, Properties> contextPropsList = null;
062    
063        /** All initial contexts known to this service */
064        private final Map<String, InitialContext> initialContexts = new HashMap<String, InitialContext>();
065    
066        /**
067         * Called the first time the Service is used.<br>
068         *
069         */
070        @Override
071        public void init()
072                throws InitializationException
073        {
074            // Context properties are specified in lines in the properties
075            // file that begin with "context.contextname.", allowing
076            // multiple named contexts to be used.  Everything after the
077            // "contextname."  is the name of the property that will be
078            // used by the InitialContext class to create a new context
079            // instance.
080    
081            Configuration conf = Turbine.getConfiguration();
082            try
083            {
084                contextPropsList = new HashMap<String, Properties>();
085    
086                for (Iterator contextKeys = conf.subset("context").getKeys();
087                     contextKeys.hasNext();)
088                {
089                    String key = (String) contextKeys.next();
090                    int end = key.indexOf(".");
091    
092                    if (end == -1)
093                    {
094                        continue;
095                    }
096    
097                    String contextName = key.substring(0, end);
098                    Properties contextProps = null;
099    
100                    if (contextPropsList.containsKey(contextName))
101                    {
102                        contextProps = contextPropsList.get(contextName);
103                    }
104                    else
105                    {
106                        contextProps = new Properties();
107                    }
108    
109                    contextProps.put(key.substring(end + 1),
110                            conf.getString(key));
111    
112                    contextPropsList.put(contextName, contextProps);
113                }
114    
115                for (Iterator contextPropsKeys = contextPropsList.keySet().iterator();
116                     contextPropsKeys.hasNext();)
117                {
118                    String key = (String) contextPropsKeys.next();
119                    Properties contextProps = contextPropsList.get(key);
120                    InitialContext context = new InitialContext(contextProps);
121                    initialContexts.put(key, context);
122                }
123    
124                setInit(true);
125            }
126            catch (NamingException e)
127            {
128                log.error("Failed to initialize JDNI contexts!", e);
129    
130                throw new InitializationException(
131                        "Failed to initialize JDNI contexts!");
132            }
133        }
134    
135    
136        /**
137         * Return the Context with the specified name.  The Context is
138         * constructed using the properties for the context with the
139         * specified name; ie. those properties that start with
140         * "services.servicename.properties.name.".
141         *
142         * @param contextName The name of the context.
143         * @return The context with the specified name, or null if no
144         * context exists with that name.
145         */
146        public Context getContext(String contextName)
147        {
148            // Get just the properties for the context with the specified
149            // name.
150            Properties contextProps = null;
151    
152            if (contextPropsList.containsKey(contextName))
153            {
154                contextProps = contextPropsList.get(contextName);
155            }
156            else
157            {
158                contextProps = new Properties();
159            }
160    
161            // Construct a new context with the properties.
162            try
163            {
164                return new InitialContext(contextProps);
165            }
166            catch (Exception e)
167            {
168                return null;
169            }
170        }
171    }