001: /*
002: * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
003: *
004: * This file is part of Resin(R) Open Source
005: *
006: * Each copy or derived work must preserve the copyright notice and this
007: * notice unmodified.
008: *
009: * Resin Open Source is free software; you can redistribute it and/or modify
010: * it under the terms of the GNU General Public License as published by
011: * the Free Software Foundation; either version 2 of the License, or
012: * (at your option) any later version.
013: *
014: * Resin Open Source is distributed in the hope that it will be useful,
015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
017: * of NON-INFRINGEMENT. See the GNU General Public License for more
018: * details.
019: *
020: * You should have received a copy of the GNU General Public License
021: * along with Resin Open Source; if not, write to the
022: *
023: * Free Software Foundation, Inc.
024: * 59 Temple Place, Suite 330
025: * Boston, MA 02111-1307 USA
026: *
027: * @author Scott Ferguson
028: */
029:
030: package com.caucho.server.dispatch;
031:
032: import com.caucho.config.ConfigELContext;
033: import com.caucho.config.ConfigException;
034: import com.caucho.config.program.ContainerProgram;
035: import com.caucho.el.EL;
036: import com.caucho.el.MapVariableResolver;
037: import com.caucho.server.webapp.WebApp;
038: import com.caucho.util.L10N;
039:
040: import javax.el.ELContext;
041: import javax.servlet.ServletContext;
042: import javax.servlet.ServletException;
043: import java.util.ArrayList;
044: import java.util.HashMap;
045: import java.util.logging.Level;
046:
047: /**
048: * Configuration for a servlet.
049: */
050: public class ServletMapping extends ServletConfigImpl {
051: private static final L10N L = new L10N(ServletMapping.class);
052:
053: private ArrayList<Mapping> _mappingList = new ArrayList<Mapping>();
054:
055: private boolean _isStrictMapping;
056:
057: /**
058: * Creates a new servlet mapping object.
059: */
060: public ServletMapping() {
061: }
062:
063: /**
064: * Sets the url pattern
065: */
066: public void addURLPattern(String pattern) {
067: if (pattern.indexOf('\n') > -1)
068: throw new ConfigException(L.l(
069: "`{0}' cannot contain newline", "url-pattern"));
070:
071: _mappingList.add(new Mapping(pattern, null));
072:
073: // server/13f4
074: if (getServletName() == null)
075: setServletName(pattern);
076: }
077:
078: /**
079: * Sets the url regexp
080: */
081: public void addURLRegexp(String pattern) {
082: _mappingList.add(new Mapping(null, pattern));
083: }
084:
085: /**
086: * True if strict mapping should be enabled.
087: */
088: public boolean isStrictMapping() {
089: return _isStrictMapping;
090: }
091:
092: /**
093: * Set if strict mapping should be enabled.
094: */
095: public void setStrictMapping(boolean isStrictMapping) {
096: _isStrictMapping = isStrictMapping;
097: }
098:
099: /**
100: * initialize.
101: */
102: public void init(ServletMapper mapper) throws ServletException {
103: boolean hasInit = false;
104:
105: for (int i = 0; i < _mappingList.size(); i++) {
106: Mapping mapping = _mappingList.get(i);
107:
108: String urlPattern = mapping.getUrlPattern();
109: String urlRegexp = mapping.getUrlRegexp();
110:
111: if (getServletName() == null
112: && getServletClassName() != null
113: && urlPattern != null) {
114: setServletName(urlPattern);
115: }
116:
117: if (urlPattern != null && !hasInit) {
118: hasInit = true;
119: super .init();
120:
121: if (getServletClassName() != null)
122: mapper.getServletManager().addServlet(this );
123: }
124:
125: if (urlPattern != null)
126: mapper
127: .addUrlMapping(urlPattern, getServletName(),
128: this );
129: else
130: mapper.addUrlRegexp(urlRegexp, this );
131: }
132:
133: /*
134: if (_urlRegexp == null) {
135: if (getServletName() == null && getServletClassName() != null) {
136: // server/13f4
137: }
138:
139: }
140: */
141: }
142:
143: /**
144: * Initialize for a regexp.
145: */
146: String initRegexp(ServletContext webApp, ServletManager manager,
147: ArrayList<String> vars) throws ServletException {
148: ELContext env = EL.getEnvironment();
149: HashMap<String, Object> map = new HashMap<String, Object>();
150: map.put("regexp", vars);
151:
152: ELContext mapEnv = new ConfigELContext(new MapVariableResolver(
153: map));
154:
155: String rawName = getServletName();
156: String rawClassName = getServletClassName();
157:
158: if (rawName == null)
159: rawName = rawClassName;
160:
161: if (rawClassName == null)
162: rawClassName = rawName;
163:
164: try {
165: String servletName = EL.evalString(rawName, mapEnv);
166:
167: if (manager.getServletConfig(servletName) != null)
168: return servletName;
169:
170: String className = EL.evalString(rawClassName, mapEnv);
171:
172: try {
173: WebApp app = (WebApp) getServletContext();
174:
175: Class cl = Class.forName(className, false, app
176: .getClassLoader());
177: } catch (ClassNotFoundException e) {
178: log.log(Level.WARNING, e.toString(), e);
179:
180: return null;
181: }
182:
183: ServletConfigImpl config = new ServletConfigImpl();
184:
185: config.setServletName(servletName);
186: config.setServletClass(className);
187: config.setServletContext(webApp);
188:
189: ContainerProgram program = getInit();
190:
191: if (program != null)
192: config.setInit(program);
193:
194: config.init();
195:
196: manager.addServlet(config);
197:
198: return servletName;
199: } catch (RuntimeException e) {
200: throw e;
201: } catch (ServletException e) {
202: throw e;
203: } catch (Throwable e) {
204: throw new ServletException(e);
205: }
206: }
207:
208: /**
209: * Returns a printable representation of the servlet config object.
210: */
211: public String toString() {
212: StringBuilder builder = new StringBuilder();
213:
214: builder.append("ServletMapping[");
215:
216: for (int i = 0; i < _mappingList.size(); i++) {
217: Mapping mapping = _mappingList.get(i);
218:
219: if (mapping.getUrlPattern() != null) {
220: builder.append("url-pattern=");
221: builder.append(mapping.getUrlPattern());
222: builder.append(", ");
223: } else if (mapping.getUrlRegexp() != null) {
224: builder.append("url-regexp=");
225: builder.append(mapping.getUrlRegexp());
226: builder.append(", ");
227: }
228: }
229:
230: builder.append(", name=");
231: builder.append(getServletName());
232: builder.append("]");
233:
234: return builder.toString();
235: }
236:
237: static class Mapping {
238: private final String _urlPattern;
239: private final String _urlRegexp;
240:
241: Mapping(String urlPattern, String urlRegexp) {
242: _urlPattern = urlPattern;
243: _urlRegexp = urlRegexp;
244: }
245:
246: String getUrlPattern() {
247: return _urlPattern;
248: }
249:
250: String getUrlRegexp() {
251: return _urlRegexp;
252: }
253:
254: public String toString() {
255: return "ServletMapping[" + _urlPattern + ", " + _urlRegexp
256: + "]";
257: }
258: }
259: }
|