001: package org.apache.turbine.services.naming;
002:
003: /*
004: * Licensed to the Apache Software Foundation (ASF) under one
005: * or more contributor license agreements. See the NOTICE file
006: * distributed with this work for additional information
007: * regarding copyright ownership. The ASF licenses this file
008: * to you under the Apache License, Version 2.0 (the
009: * "License"); you may not use this file except in compliance
010: * with the License. You may obtain a copy of the License at
011: *
012: * http://www.apache.org/licenses/LICENSE-2.0
013: *
014: * Unless required by applicable law or agreed to in writing,
015: * software distributed under the License is distributed on an
016: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017: * KIND, either express or implied. See the License for the
018: * specific language governing permissions and limitations
019: * under the License.
020: */
021:
022: import java.util.HashMap;
023: import java.util.Iterator;
024: import java.util.Map;
025: import java.util.Properties;
026:
027: import javax.naming.Context;
028: import javax.naming.InitialContext;
029:
030: import org.apache.commons.configuration.Configuration;
031:
032: import org.apache.commons.logging.Log;
033: import org.apache.commons.logging.LogFactory;
034:
035: import org.apache.turbine.Turbine;
036: import org.apache.turbine.services.InitializationException;
037: import org.apache.turbine.services.TurbineBaseService;
038: import org.apache.turbine.util.RunData;
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: * @version $Id: TurbineNamingService.java 534527 2007-05-02 16:10:59Z tv $
048: */
049: public class TurbineNamingService extends TurbineBaseService implements
050: NamingService {
051: /** Logging */
052: private static Log log = LogFactory
053: .getLog(TurbineNamingService.class);
054:
055: /**
056: * A global Map of Property objects which are initialised using
057: * parameters from the ResourcesFile
058: */
059: private Map contextPropsList = null;
060:
061: /** All initial contexts known to this service */
062: private Map initialContexts = new HashMap();
063:
064: /**
065: * Called the first time the Service is used.<br>
066: *
067: */
068: public void init() throws InitializationException {
069: // Context properties are specified in lines in the properties
070: // file that begin with "context.contextname.", allowing
071: // multiple named contexts to be used. Everything after the
072: // "contextname." is the name of the property that will be
073: // used by the InitialContext class to create a new context
074: // instance.
075:
076: Configuration conf = Turbine.getConfiguration();
077: try {
078: contextPropsList = new HashMap();
079:
080: for (Iterator contextKeys = conf.subset("context")
081: .getKeys(); contextKeys.hasNext();) {
082: String key = (String) contextKeys.next();
083: int end = key.indexOf(".");
084:
085: if (end == -1) {
086: continue;
087: }
088:
089: String contextName = key.substring(0, end);
090: Properties contextProps = null;
091:
092: if (contextPropsList.containsKey(contextName)) {
093: contextProps = (Properties) contextPropsList
094: .get(contextName);
095: } else {
096: contextProps = new Properties();
097: }
098:
099: contextProps.put(key.substring(end + 1), conf
100: .getString(key));
101:
102: contextPropsList.put(contextName, contextProps);
103: }
104:
105: for (Iterator contextPropsKeys = contextPropsList.keySet()
106: .iterator(); contextPropsKeys.hasNext();) {
107: String key = (String) contextPropsKeys.next();
108: Properties contextProps = (Properties) contextPropsList
109: .get(key);
110: InitialContext context = new InitialContext(
111: contextProps);
112: initialContexts.put(key, context);
113: }
114:
115: setInit(true);
116: } catch (Exception e) {
117: log.error("Failed to initialize JDNI contexts!", e);
118:
119: throw new InitializationException(
120: "Failed to initialize JDNI contexts!");
121: }
122: }
123:
124: /**
125: * Places the contexts defined in the TurbineResources instance
126: * (if any) into the data.contexts Map.
127: *
128: * @param data The RunData object for the current request.
129: * @exception InitializationException, if there was a problem
130: * during initialization.
131: * @deprecated This should never have been here. No replacement.
132: */
133: public void init(RunData data) throws InitializationException {
134: try {
135: if (contextPropsList == null) {
136: init();
137: }
138:
139: for (Iterator it = contextPropsList.keySet().iterator(); it
140: .hasNext();) {
141: String key = (String) it.next();
142: Properties contextProps = (Properties) contextPropsList
143: .get(key);
144: InitialContext context = new InitialContext(
145: contextProps);
146: data.getJNDIContexts().put(key, context);
147: }
148: } catch (Exception e) {
149: log.error("Failed to initialize JDNI contexts!", e);
150:
151: throw new InitializationException(
152: "Failed to initialize JDNI contexts!");
153: }
154: }
155:
156: /**
157: * Return the Context with the specified name. The Context is
158: * constructed using the properties for the context with the
159: * specified name; ie. those properties that start with
160: * "services.servicename.properties.name.".
161: *
162: * @param contextName The name of the context.
163: * @return The context with the specified name, or null if no
164: * context exists with that name.
165: */
166: public Context getContext(String contextName) {
167: // Get just the properties for the context with the specified
168: // name.
169: Properties contextProps = null;
170:
171: if (contextPropsList.containsKey(contextName)) {
172: contextProps = (Properties) contextPropsList
173: .get(contextName);
174: } else {
175: contextProps = new Properties();
176: }
177:
178: // Construct a new context with the properties.
179: try {
180: return new InitialContext(contextProps);
181: } catch (Exception e) {
182: return null;
183: }
184: }
185: }
|