View Javadoc

1   //========================================================================
2   //$Id: RewriteHandler.java 1918 2010-10-06 18:48:08Z jesse $
3   //Copyright 2004-2005 Mort Bay Consulting Pty. Ltd.
4   //------------------------------------------------------------------------
5   //Licensed under the Apache License, Version 2.0 (the "License");
6   //you may not use this file except in compliance with the License.
7   //You may obtain a copy of the License at 
8   //http://www.apache.org/licenses/LICENSE-2.0
9   //Unless required by applicable law or agreed to in writing, software
10  //distributed under the License is distributed on an "AS IS" BASIS,
11  //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  //See the License for the specific language governing permissions and
13  //limitations under the License.
14  //========================================================================
15  package org.mortbay.jetty.handler.rewrite;
16  
17  import java.io.IOException;
18  
19  import javax.servlet.ServletException;
20  import javax.servlet.http.HttpServletRequest;
21  import javax.servlet.http.HttpServletResponse;
22  
23  import org.mortbay.jetty.HttpConnection;
24  import org.mortbay.jetty.Request;
25  import org.mortbay.jetty.handler.HandlerWrapper;
26  import org.mortbay.jetty.servlet.PathMap;
27  import org.mortbay.log.Log;
28  import org.mortbay.util.LazyList;
29  
30  /* ------------------------------------------------------------ */
31  /**
32   *<p> The RewriteHandler is responsible for managing a list of rules to be applied to requests. 
33   * Its capabilities are not only limited to url rewrites such as RewritePatternRule or RewriteRegexRule; 
34   * there is also handling for cookies, headers, redirection, setting status or error codes 
35   * whenever the rule finds a match. 
36   * 
37   * <p> The rules can be matched by the ff. options: pattern matching of PathMap 
38   * (class PatternRule), regular expressions (class RegexRule) or certain conditions set 
39   * (e.g. MsieSslRule - the requests must be in SSL mode).
40   * 
41   * Here are the list of rules:
42   * <ul>
43   * <li> CookiePatternRule - adds a new cookie in response. </li>
44   * <li> HeaderPatternRule - adds/modifies the HTTP headers in response. </li>
45   * <li> RedirectPatternRule - sets the redirect location. </li>
46   * <li> ResponsePatternRule - sets the status/error codes. </li>
47   * <li> RewritePatternRule - rewrites the requested URI. </li>
48   * <li> RewriteRegexRule - rewrites the requested URI using regular expression for pattern matching. </li>
49   * <li> MsieSslRule - disables the keep alive on SSL for IE5 and IE6. </li>
50   * <li> LegacyRule - the old version of rewrite. </li>
51   * <li> ForwardedSchemeHeaderRule - set the scheme according to the headers present. </li>
52   * </ul>
53   *
54   * <p> The rules can be grouped into rule containers (class RuleContainerRule), and will only 
55   * be applied if the request matches the conditions for their container
56   * (e.g., by virtual host name)
57   *
58   * Here are a list of rule containers:
59   * <ul>
60   * <li> VirtualHostRuleContainer - checks whether the request matches one of a set of virtual host names.</li>
61   * <li> LowThreadsRuleContainer - checks whether the threadpool is low on threads</li>
62   * </ul>
63   * 
64   */
65  public class RewriteHandler extends HandlerWrapper
66  {
67      
68      private RuleContainer _rules;
69      
70      /* ------------------------------------------------------------ */
71      public RewriteHandler()
72      {
73          _rules = new RuleContainer();
74      }
75  
76      /* ------------------------------------------------------------ */
77      /**
78       * To enable configuration from jetty.xml on rewriteRequestURI, rewritePathInfo and
79       * originalPathAttribute
80       * 
81       * @param legacyRule old style rewrite rule
82       */
83      public void setLegacyRule(LegacyRule legacyRule)
84      {
85          _rules.setLegacyRule(legacyRule);
86      }
87  
88      /* ------------------------------------------------------------ */
89      /**
90       * Returns the list of rules.
91       * @return an array of {@link Rule}.
92       */
93      public Rule[] getRules()
94      {
95          return _rules.getRules();
96      }
97  
98      /* ------------------------------------------------------------ */
99      /**
100      * Assigns the rules to process.
101      * @param rules an array of {@link Rule}. 
102      */
103     public void setRules(Rule[] rules)
104     {
105         _rules.setRules(rules);
106     }
107 
108     /*------------------------------------------------------------ */
109     /**
110      * Assigns the rules to process.
111      * @param rules a {@link RuleContainer} containing other rules to process
112      */
113     public void setRules(RuleContainer rules)
114     {
115         _rules = rules;
116     }
117 
118     /* ------------------------------------------------------------ */
119     /**
120      * Add a Rule
121      * @param rule The rule to add to the end of the rules array
122      */
123     public void addRule(Rule rule)
124     {
125         _rules.addRule(rule);
126     }
127    
128 
129     /* ------------------------------------------------------------ */
130     /**
131      * @return the rewriteRequestURI If true, this handler will rewrite the value
132      * returned by {@link HttpServletRequest#getRequestURI()}.
133      */
134     public boolean isRewriteRequestURI()
135     {
136         return _rules.isRewriteRequestURI();
137     }
138 
139     /* ------------------------------------------------------------ */
140     /**
141      * @param rewriteRequestURI true if this handler will rewrite the value
142      * returned by {@link HttpServletRequest#getRequestURI()}.
143      */
144     public void setRewriteRequestURI(boolean rewriteRequestURI)
145     {
146         _rules.setRewriteRequestURI(rewriteRequestURI);
147     }
148 
149     /* ------------------------------------------------------------ */
150     /**
151      * @return true if this handler will rewrite the value
152      * returned by {@link HttpServletRequest#getPathInfo()}.
153      */
154     public boolean isRewritePathInfo()
155     {
156         return _rules.isRewritePathInfo();
157     }
158 
159     /* ------------------------------------------------------------ */
160     /**
161      * @param rewritePathInfo true if this handler will rewrite the value
162      * returned by {@link HttpServletRequest#getPathInfo()}.
163      */
164     public void setRewritePathInfo(boolean rewritePathInfo)
165     {
166         _rules.setRewritePathInfo(rewritePathInfo);
167     }
168 
169     /* ------------------------------------------------------------ */
170     /**
171      * @return the originalPathAttribute. If non null, this string will be used
172      * as the attribute name to store the original request path.
173      */
174     public String getOriginalPathAttribute()
175     {
176         return _rules.getOriginalPathAttribute();
177     }
178 
179     /* ------------------------------------------------------------ */
180     /**
181      * @param originalPathAttribute If non null, this string will be used
182      * as the attribute name to store the original request path.
183      */
184     public void setOriginalPathAttribute(String originalPathAttribute)
185     {
186         _rules.setOriginalPathAttribute(originalPathAttribute);
187     }
188 
189 
190     /* ------------------------------------------------------------ */
191     /**
192      * @deprecated 
193      */
194     public PathMap getRewrite()
195     {
196         return _rules.getRewrite();
197     }
198 
199     /* ------------------------------------------------------------ */
200     /**
201      * @deprecated
202      */
203     public void setRewrite(PathMap rewrite)
204     {
205         _rules.setRewrite(rewrite);
206     }
207 
208     /* ------------------------------------------------------------ */
209     /**
210      * @deprecated
211      */
212     public void addRewriteRule(String pattern, String prefix)
213     {
214         _rules.addRewriteRule(pattern,prefix);
215     }
216     
217     /* ------------------------------------------------------------ */
218     /* (non-Javadoc)
219      * @see org.mortbay.jetty.handler.HandlerWrapper#handle(java.lang.String, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, int)
220      */
221     public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException
222     {
223         if (isStarted())
224         { 
225             String returned = _rules.matchAndApply(target, request, response);
226             target = (returned == null) ? target : returned;
227             
228             Request baseRequest = (request instanceof Request?(Request)request:HttpConnection.getCurrentConnection().getRequest());
229             
230             if (!baseRequest.isHandled())
231             {
232                 super.handle(target, request, response, dispatch);
233             }
234         }
235     }
236     
237 }