CmsFlexRequest


1   /*
2    * File   : $Source: /usr/local/cvs/opencms/src/org/opencms/flex/CmsFlexRequest.java,v $
3    * Date   : $Date: 2006/03/27 14:52:35 $
4    * Version: $Revision: 1.37 $
5    *
6    * This library is part of OpenCms -
7    * the Open Source Content Mananagement System
8    *
9    * Copyright (c) 2005 Alkacon Software GmbH (http://www.alkacon.com)
10   *
11   * This library is free software; you can redistribute it and/or
12   * modify it under the terms of the GNU Lesser General Public
13   * License as published by the Free Software Foundation; either
14   * version 2.1 of the License, or (at your option) any later version.
15   *
16   * This library is distributed in the hope that it will be useful,
17   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19   * Lesser General Public License for more details.
20   *
21   * For further information about Alkacon Software GmbH, please see the
22   * company website: http://www.alkacon.com
23   *
24   * For further information about OpenCms, please see the
25   * project website: http://www.opencms.org
26   * 
27   * You should have received a copy of the GNU Lesser General Public
28   * License along with this library; if not, write to the Free Software
29   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
30   */
31  
32  package org.opencms.flex;
33  
34  import org.opencms.file.CmsObject;
35  import org.opencms.main.CmsEvent;
36  import org.opencms.main.CmsLog;
37  import org.opencms.main.I_CmsEventListener;
38  import org.opencms.main.OpenCms;
39  import org.opencms.security.CmsRole;
40  import org.opencms.staticexport.CmsLinkManager;
41  
42  import java.util.Arrays  ;
43  import java.util.Collections  ;
44  import java.util.Enumeration  ;
45  import java.util.HashMap  ;
46  import java.util.Iterator  ;
47  import java.util.List  ;
48  import java.util.Map  ;
49  import java.util.Vector  ;
50  
51  import javax.servlet.http.HttpServletRequest  ;
52  import javax.servlet.http.HttpServletRequestWrapper  ;
53  
54  import org.apache.commons.logging.Log;
55  
56  /**
57   * Wrapper class for a HttpServletRequest.<p>
58   *
59   * This class wraps the standard HttpServletRequest so that it's output can be delivered to
60   * the CmsFlexCache.<p>
61   *
62   * @author Alexander Kandzior 
63   * 
64   * @version $Revision: 1.37 $ 
65   * 
66   * @since 6.0.0 
67   */
68  public class CmsFlexRequest extends HttpServletRequestWrapper   {
69  
70      /** Request parameter for FlexCache commands. */
71      public static final String   PARAMETER_FLEX = "_flex";
72  
73      /** The log object for this class. */
74      private static final Log LOG = CmsLog.getLog(CmsFlexRequest.class);
75  
76      /** Flag to decide if this request can be cached or not. */
77      private boolean m_canCache;
78  
79      /** The CmsFlexController for this request. */
80      private CmsFlexController m_controller;
81  
82      /** Flag to force a JSP recompile. */
83      private boolean m_doRecompile;
84  
85      /** The requested resources element URI in the OpenCms VFS. */
86      private String   m_elementUri;
87  
88      /** The site root of the requested resource. */
89      private String   m_elementUriSiteRoot;
90  
91      /** List of all include calls (to prevent an endless inclusion loop). */
92      private List   m_includeCalls;
93  
94      /** Flag to check if this request is in the online project or not. */
95      private boolean m_isOnline;
96  
97      /** The CmsFlexRequestKey for this request. */
98      private CmsFlexRequestKey m_key;
99  
100     /** Map of parameters from the original request. */
101     private Map   m_parameters;
102 
103     /** Stores the request URI after it was once calculated. */
104     private String   m_requestUri;
105 
106     /** Stores the request URL after it was once calculated. */
107     private StringBuffer   m_requestUrl;
108 
109     /**
110      * Creates a new CmsFlexRequest wrapper which is most likley the "Top"
111      * request wrapper, i.e. the wrapper that is constructed around the
112      * first "real" (not wrapped) request.<p>
113      *
114      * @param req the request to wrap
115      * @param controller the controller to use
116      */
117     public CmsFlexRequest(HttpServletRequest   req, CmsFlexController controller) {
118 
119         super(req);
120         m_controller = controller;
121         CmsObject cms = m_controller.getCmsObject();
122         m_elementUri = cms.getSitePath(m_controller.getCmsResource());
123         m_elementUriSiteRoot = cms.getRequestContext().getSiteRoot();
124         m_includeCalls = new Vector  ();
125         m_parameters = req.getParameterMap();
126         m_isOnline = cms.getRequestContext().currentProject().isOnlineProject();
127         String  [] paras = req.getParameterValues(PARAMETER_FLEX);
128         boolean nocachepara = false;
129         boolean dorecompile = false;
130         if (paras != null) {
131             if (cms.hasRole(CmsRole.WORKPLACE_MANAGER)) {
132                 List   l = Arrays.asList(paras);
133                 boolean firstCall = controller.isEmptyRequestList();
134                 nocachepara = l.contains("nocache");
135                 dorecompile = l.contains("recompile");
136                 boolean p_on = l.contains("online");
137                 boolean p_off = l.contains("offline");
138                 if (l.contains("purge") && firstCall) {
139                     OpenCms.fireCmsEvent(new CmsEvent(
140                         I_CmsEventListener.EVENT_FLEX_PURGE_JSP_REPOSITORY,
141                         new HashMap  (0)));
142                     OpenCms.fireCmsEvent(new CmsEvent(
143                         I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
144                         Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_ENTRIES))));
145                     dorecompile = false;
146                 } else if ((l.contains("clearcache") || dorecompile) && firstCall) {
147                     if (!(p_on || p_off)) {
148                         OpenCms.fireCmsEvent(new CmsEvent(
149                             I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
150                             Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_ALL))));
151                     } else {
152                         if (p_on) {
153                             OpenCms.fireCmsEvent(new CmsEvent(
154                                 I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
155                                 Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_ONLINE_ALL))));
156                         }
157                         if (p_off) {
158                             OpenCms.fireCmsEvent(new CmsEvent(
159                                 I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
160                                 Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_OFFLINE_ALL))));
161                         }
162                     }
163                 } else if (l.contains("clearvariations") && firstCall) {
164                     if (!(p_on || p_off)) {
165                         OpenCms.fireCmsEvent(new CmsEvent(
166                             I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
167                             Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_ENTRIES))));
168                     } else {
169                         if (p_on) {
170                             OpenCms.fireCmsEvent(new CmsEvent(
171                                 I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
172                                 Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_ONLINE_ENTRIES))));
173                         }
174                         if (p_off) {
175                             OpenCms.fireCmsEvent(new CmsEvent(
176                                 I_CmsEventListener.EVENT_FLEX_CACHE_CLEAR,
177                                 Collections.singletonMap("action", new Integer  (CmsFlexCache.CLEAR_OFFLINE_ENTRIES))));
178                         }
179                     }
180                 }
181             }
182         }
183         m_canCache = (((m_isOnline || m_controller.getCmsCache().cacheOffline()) && !nocachepara) || dorecompile);
184         m_doRecompile = dorecompile;
185         if (LOG.isDebugEnabled()) {
186             LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUEST_CREATED_NEW_REQUEST_1, m_elementUri));
187         }
188     }
189 
190     /** 
191      * Constructs a new wrapper layer around an (already wrapped) CmsFlexRequest.<p>
192      *
193      * @param req the request to be wrapped
194      * @param controller the controller to use
195      * @param resource the target resource that has been requested
196      */
197     CmsFlexRequest(HttpServletRequest   req, CmsFlexController controller, String   resource) {
198 
199         super(req);
200         m_controller = controller;
201         m_elementUri = CmsLinkManager.getAbsoluteUri(resource, m_controller.getCurrentRequest().getElementUri());
202         m_elementUriSiteRoot = m_controller.getCurrentRequest().m_elementUriSiteRoot;
203         m_isOnline = m_controller.getCurrentRequest().isOnline();
204         m_canCache = m_controller.getCurrentRequest().isCacheable();
205         m_doRecompile = m_controller.getCurrentRequest().isDoRecompile();
206         m_includeCalls = m_controller.getCurrentRequest().getCmsIncludeCalls();
207         m_parameters = req.getParameterMap();
208         if (LOG.isDebugEnabled()) {
209             LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUEST_REUSING_FLEX_REQUEST_1, m_elementUri));
210         }
211     }
212 
213     /**
214      * Adds the specified Map to the paramters of the request,
215      * added parametes will not overwrite existing parameters in the 
216      * request.<p> 
217      * 
218      * Remember that the value for a parameter name in
219      * a HttpRequest is a String array. If a parameter name already
220      * exists in the HttpRequest, the values will be added to the existing
221      * value array. Multiple occurences of the same value for one 
222      * paramter are also possible.<p>
223      * 
224      * @param map the map to add
225      * @return the merged map of parameters
226      */
227     public Map   addParameterMap(Map   map) {
228 
229         if (map == null) {
230             return m_parameters;
231         }
232         if ((m_parameters == null) || (m_parameters.size() == 0)) {
233             m_parameters = Collections.unmodifiableMap(map);
234         } else {
235             HashMap   parameters = new HashMap  ();
236             parameters.putAll(m_parameters);
237 
238             Iterator   it = map.keySet().iterator();
239             while (it.hasNext()) {
240                 String   key = (String  )it.next();
241                 // Check if the parameter name (key) exists
242                 if (parameters.containsKey(key)) {
243 
244                     String  [] oldValues = (String  [])parameters.get(key);
245                     String  [] newValues = (String  [])map.get(key);
246 
247                     String  [] mergeValues = new String  [oldValues.length + newValues.length];
248                     System.arraycopy(newValues, 0, mergeValues, 0, newValues.length);
249                     System.arraycopy(oldValues, 0, mergeValues, newValues.length, oldValues.length);
250 
251                     parameters.put(key, mergeValues);
252                 } else {
253                     // No: Add new value array
254                     parameters.put(key, map.get(key));
255                 }
256             }
257             m_parameters = Collections.unmodifiableMap(parameters);
258         }
259 
260         return m_parameters;
261     }
262 
263     /** 
264      * Returns the full element URI site root path to the resource currently processed.<p>
265      * 
266      * @return the name of the resource currently processed
267      */
268     public String   getElementRootPath() {
269 
270         return m_controller.getCmsObject().getRequestContext().addSiteRoot(m_elementUriSiteRoot, m_elementUri);
271     }
272 
273     /** 
274      * Returns the element URI of the resource currently processed,
275      * relative to the current site root.<p>
276      * 
277      * This might be the name of an included resource,
278      * not neccesarily the name the resource requested by the user.
279      * 
280      * @return the name of the resource currently processed
281      */
282     public String   getElementUri() {
283 
284         return m_elementUri;
285     }
286 
287     /**
288      * Return the value of the specified request parameter, if any; otherwise,
289      * return <code>null</code>.<p>
290      * 
291      * If there is more than one value defined,
292      * return only the first one.<p>
293      *
294      * @param name the name of the desired request parameter
295      * @return the value of the specified request parameter
296      * @see javax.servlet.ServletRequest#getParameter(java.lang.String)
297      */
298     public String   getParameter(String   name) {
299 
300         String  [] values = (String  [])m_parameters.get(name);
301         if (values != null) {
302             return (values[0]);
303         } else {
304             return (null);
305         }
306     }
307 
308     /**
309      * Returns a <code>Map</code> of the parameters of this request.<p>
310      * 
311      * Request parameters are extra information sent with the request.
312      * For HTTP servlets, parameters are contained in the query string
313      * or posted form data.<p>
314      *
315      * @return a <code>Map</code> containing parameter names as keys
316      *  and parameter values as map values
317      * @see javax.servlet.ServletRequest#getParameterMap()
318      */
319     public Map   getParameterMap() {
320 
321         return m_parameters;
322     }
323 
324     /**
325      * Return the names of all defined request parameters for this request.<p>
326      * 
327      * @return the names of all defined request parameters for this request
328      * @see javax.servlet.ServletRequest#getParameterNames()
329      */
330     public Enumeration   getParameterNames() {
331 
332         Vector   v = new Vector  ();
333         v.addAll(m_parameters.keySet());
334         return (v.elements());
335     }
336 
337     /**
338      * Returns the defined values for the specified request parameter, if any;
339      * otherwise, return <code>null</code>.
340      *
341      * @param name Name of the desired request parameter
342      * @return the defined values for the specified request parameter, if any;
343      *          <code>null</code> otherwise
344      * @see javax.servlet.ServletRequest#getParameterValues(java.lang.String)
345      */
346     public String  [] getParameterValues(String   name) {
347 
348         return (String  [])m_parameters.get(name);
349     }
350 
351     /** 
352      * Allows requests to be dispatched to internal VFS resources or 
353      * external JSP pages, overloads the standard servlet API <code>getRequestDispatcher()</code> method.<p>
354      *
355      * @param target the target for the request dispatcher
356      * @return a special RequestDispatcher that allows access to VFS resources
357      */
358     public javax.servlet.RequestDispatcher   getRequestDispatcher(String   target) {
359 
360         String   absolutUri = CmsLinkManager.getAbsoluteUri(target, m_controller.getCurrentRequest().getElementUri());
361         return new CmsFlexRequestDispatcher(
362             m_controller.getTopRequest().getRequestDispatcher(absolutUri),
363             absolutUri,
364             null);
365     }
366 
367     /** 
368      * Replacement for the standard servlet API getRequestDispatcher() method.<p>
369      * 
370      * This variation is used if an external file (probably JSP) is dispached to.
371      * This external file must have a "mirror" version, i.e. a file in the OpenCms VFS
372      * that represents the external file.<p>
373      *
374      * @param vfs_target the OpenCms file that is a "mirror" version of the external file
375      * @param ext_target the external file (outside the OpenCms VFS)
376      * @return the constructed CmsFlexRequestDispatcher
377      */
378     public CmsFlexRequestDispatcher getRequestDispatcherToExternal(String   vfs_target, String   ext_target) {
379 
380         return new CmsFlexRequestDispatcher(
381             m_controller.getTopRequest().getRequestDispatcher(ext_target),
382             CmsLinkManager.getAbsoluteUri(vfs_target, m_controller.getCmsObject().getRequestContext().getUri()),
383             ext_target);
384     }
385 
386     /** 
387      * Wraps the request URI, overloading the standard API.<p>
388      * 
389      * This ensures that any wrapped request will use the "faked"
390      * target parameters. Remember that for the real request,
391      * a mixture of PathInfo and other request information is used to
392      * idenify the target.<p>
393      *
394      * @return a faked URI that will point to the wrapped target in the VFS 
395      * @see javax.servlet.http.HttpServletRequest#getRequestURI()
396      */
397     public String   getRequestURI() {
398 
399         if (m_requestUri != null) {
400             return m_requestUri;
401         }
402         StringBuffer   buf = new StringBuffer  (128);
403         buf.append(OpenCms.getSystemInfo().getOpenCmsContext());
404         buf.append(getElementUri());
405         m_requestUri = buf.toString();
406         return m_requestUri;
407     }
408 
409     /** 
410      * Wraps the request URL, overloading the standard API,
411      * the wrapped URL will always point to the currently included VFS resource.<p>
412      *
413      * @return a faked URL that will point to the included target in the VFS
414      * @see javax.servlet.http.HttpServletRequest#getRequestURL()
415      */
416     public StringBuffer   getRequestURL() {
417 
418         if (m_requestUrl != null) {
419             return m_requestUrl;
420         }
421         StringBuffer   buf = new StringBuffer  (128);
422         buf.append(getScheme());
423         buf.append("://");
424         buf.append(getServerName());
425         buf.append(":");
426         buf.append(getServerPort());
427         buf.append(getRequestURI());
428         m_requestUrl = buf;
429         return m_requestUrl;
430     }
431 
432     /** 
433      * Checks if JSPs should always be recompiled.<p>
434      * 
435      * This is useful in case directive based includes are used
436      * with &lt;%@ include file="..." %&gt; on a JSP.
437      * Note that this also forces the request not to be cached.<p>
438      *
439      * @return true if JSPs should be recompiled, false otherwise
440      */
441     public boolean isDoRecompile() {
442 
443         return m_doRecompile;
444     }
445 
446     /** 
447      * Indicates that this request belongs to an online project.<p>
448      * 
449      * This is required to distinguish between online and offline
450      * resources in the cache. Since the resources have the same name,
451      * a suffix [online] or [offline] is added to distinguish the strings
452      * when building cache keys.
453      * Any resource from a request that isOnline() will be saved with
454      * the [online] suffix and vice versa.<p>
455      * 
456      * Resources in the OpenCms workplace are not distinguised between 
457      * online and offline but have their own suffix [workplace].
458      * The assumption is that if you do change the workplace, this is
459      * only on true development macines so you can do the cache clearing 
460      * manually if required.<p> 
461      *
462      * The suffixes are used so that we have a simple String name
463      * for the resources in the cache. This makes it easy to
464      * use a standard HashMap for storage of the resources.<p>
465      *
466      * @return true if an online resource was requested, false otherwise
467      */
468     public boolean isOnline() {
469 
470         return m_isOnline;
471     }
472 
473     /**
474      * Sets the specified Map as paramter map of the request.<p>
475      * 
476      * The map set should be immutable. 
477      * This will completly replace the parameter map. 
478      * Use this in combination with getParameterMap() and
479      * addParameterMap() in case you want to set the old status
480      * of the parameter map after you have modified it for
481      * a specific operation.<p>
482      * 
483      * @param map the map to set
484      */
485     public void setParameterMap(Map   map) {
486 
487         m_parameters = map;
488     }
489 
490     /**
491      * @see java.lang.Object#toString()
492      */
493     public String   toString() {
494 
495         // return the uri of the element requested for this request, useful in debugging
496         return m_elementUri;
497     }
498 
499     /**
500      * Returns the List of include calls which will be passed to the next wrapping layer.<p>
501      * 
502      * The set of include calls is maintained to dectect 
503      * an endless inclusion loop.<p>
504      * 
505      * @return the List of include calls
506      */
507     protected List   getCmsIncludeCalls() {
508 
509         return m_includeCalls;
510     }
511 
512     /**
513      * Adds another include call to this wrapper.<p>
514      * 
515      * The set of include calls is maintained to dectect 
516      * an endless inclusion loop.<p>
517      * 
518      * @param target the target name (absolute OpenCms URI) to add
519      */
520     void addInlucdeCall(String   target) {
521 
522         m_includeCalls.add(target);
523     }
524 
525     /**
526      * Checks if a given target is already included in a top-layer of this
527      * wrapped request.<p>
528      * 
529      * The set of include calls is maintained to dectect 
530      * an endless inclusion loop.<p>
531      * 
532      * @param target the target name (absolute OpenCms URI) to check for
533      * @return true if the target is already included, false otherwise
534      */
535     boolean containsIncludeCall(String   target) {
536 
537         return m_includeCalls.contains(target);
538     }
539 
540     /** 
541      * Returns the CmsFlexCacheKey for this request,
542      * the key will be calculated if neccessary.<p>
543      * 
544      * @return the CmsFlexCacheKey for this request
545      */
546     CmsFlexRequestKey getCmsCacheKey() {
547 
548         // The key for this request is only calculated if actually requested
549         if (m_key == null) {
550             m_key = new CmsFlexRequestKey(this, m_elementUri, m_isOnline);
551         }
552         return m_key;
553     }
554 
555     /** 
556      * This is needed to decide if this request can be cached or not.<p>
557      * 
558      * Using the request to decide if caching is used or not
559      * makes it possible to set caching to false e.g. on a per-user
560      * or per-project basis.<p>
561      *
562      * @return true if the request is cacheable, false otherwise
563      */
564     boolean isCacheable() {
565 
566         return m_canCache;
567     }
568 
569     /**
570      * Removes an include call from this wrapper.<p>
571      * 
572      * The set of include calls is maintained to dectect 
573      * an endless inclusion loop.<p>
574      * 
575      * @param target the target name (absolute OpenCms URI) to remove
576      */
577     void removeIncludeCall(String   target) {
578 
579         m_includeCalls.remove(target);
580     }
581 }
582
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags