View Javadoc

1   /*
2    * Copyright 2003,2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.pluto;
17  
18  import java.io.IOException;
19  import java.util.Map;
20  import java.util.Properties;
21  
22  import javax.portlet.ActionRequest;
23  import javax.portlet.ActionResponse;
24  import javax.portlet.PortletException;
25  import javax.portlet.PortletMode;
26  import javax.portlet.RenderRequest;
27  import javax.portlet.RenderResponse;
28  import javax.portlet.WindowState;
29  import javax.servlet.ServletConfig;
30  import javax.servlet.http.HttpServletRequest;
31  import javax.servlet.http.HttpServletResponse;
32  
33  import org.apache.pluto.core.InternalActionResponse;
34  import org.apache.pluto.factory.PortletObjectAccess;
35  import org.apache.pluto.invoker.PortletInvoker;
36  import org.apache.pluto.invoker.PortletInvokerAccess;
37  import org.apache.pluto.om.window.PortletWindow;
38  import org.apache.pluto.services.PortletContainerEnvironment;
39  import org.apache.pluto.services.information.DynamicInformationProvider;
40  import org.apache.pluto.services.information.InformationProviderAccess;
41  import org.apache.pluto.services.information.PortletURLProvider;
42  import org.apache.pluto.services.log.LogService;
43  import org.apache.pluto.services.log.Logger;
44  
45  /***
46   *  Implements the Pluto Container.
47   * 
48   * @version $Id: PortletContainerImpl.java 219193 2005-07-15 12:57:13Z blumm $
49   */
50  public class PortletContainerImpl implements PortletContainer
51  {
52  
53      private String uniqueContainerName;
54      private boolean initialized;
55      
56      private static String CONTAINER_SUPPORTS_BUFFERING = "portletcontainer.supportsBuffering";
57      private boolean supportsBuffering;
58  
59      private Logger log = null;
60  
61      public void init(String uniqueContainerName,
62                       ServletConfig servletConfig,
63                       PortletContainerEnvironment environment,
64                       Properties properties)
65      throws PortletContainerException
66      {
67          this.uniqueContainerName = uniqueContainerName;
68          PortletContainerServices.createReference(uniqueContainerName, environment);
69          initialized = true;
70  
71          // Initialize the Logger that we will use
72          // from here forward for this Container:
73          log = ((LogService)environment
74                  .getContainerService(LogService.class))
75                  .getLogger(getClass());
76          
77          Boolean b = (Boolean)properties.get(CONTAINER_SUPPORTS_BUFFERING);
78          if (b == null) {
79          	log.warn("org.apache.pluto.PortletContainerImpl#init(): " +
80          			"Couldn't retrieve parameter \"" + CONTAINER_SUPPORTS_BUFFERING + "\" from" +
81          			"passed properties object. Falling back to default value \"FALSE\"");
82          	supportsBuffering = false;
83          } else {
84          	supportsBuffering = b.booleanValue();
85          }
86      }
87  
88      public void shutdown() throws PortletContainerException
89      {
90          PortletContainerServices.destroyReference(uniqueContainerName);
91      }
92  
93  
94      public void renderPortlet(PortletWindow portletWindow,
95                                HttpServletRequest servletRequest,
96                                HttpServletResponse servletResponse )
97      throws PortletException, IOException, PortletContainerException
98      {
99          PortletContainerServices.prepare(uniqueContainerName);
100         PortletInvoker invoker = null;
101         
102         if (log.isDebugEnabled())
103         {
104             log.debug("PortletContainerImpl.portletService(" + portletWindow.getId() + ") called.");
105         }
106 
107         try
108         {
109             RenderRequest renderRequest = PortletObjectAccess.getRenderRequest(portletWindow, 
110                                                                                servletRequest, 
111                                                                                servletResponse);
112 
113             RenderResponse renderResponse = PortletObjectAccess.getRenderResponse(portletWindow, 
114                                                                                   servletRequest, 
115                                                                                   servletResponse,
116                                                                                   supportsBuffering);
117 
118             invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
119             invoker.render(renderRequest, renderResponse);
120         }
121         finally
122         {
123             PortletInvokerAccess.releasePortletInvoker(invoker);            
124             PortletContainerServices.release();
125         }
126 
127     }
128 
129 
130     public void processPortletAction(PortletWindow portletWindow,
131                                      HttpServletRequest servletRequest,
132                                      HttpServletResponse servletResponse)
133     throws PortletException, IOException, PortletContainerException
134     {
135         PortletContainerServices.prepare(uniqueContainerName);
136         PortletInvoker invoker = null;
137 
138         if (log.isDebugEnabled())
139         {
140             log.debug("PortletContainerImpl.performPortletAction(" + portletWindow.getId() + ") called.");
141         }
142 
143         String location = null;
144 
145         InternalActionResponse _actionResponse = null;
146         ActionRequest actionRequest = null;
147 
148         try
149         {
150             /*ActionRequest*/ 
151             actionRequest = 
152             PortletObjectAccess.getActionRequest(portletWindow, 
153                                                  servletRequest, 
154                                                  servletResponse);
155 
156             ActionResponse actionResponse = PortletObjectAccess.getActionResponse(portletWindow, 
157                                                                                   servletRequest, 
158                                                                                   servletResponse);
159             invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
160 
161             _actionResponse = (InternalActionResponse)actionResponse;
162 
163             // call action() at the portlet
164             invoker.action(actionRequest, actionResponse);
165 
166             location = _actionResponse.getRedirectLocation();
167         }
168         catch (PortletException e)
169         {
170             throw e;
171         }
172         catch (IOException e)
173         {
174             throw e;
175         }
176         catch (RuntimeException e)
177         {
178             throw e;
179         }
180         finally
181         {
182             try
183             {
184 				redirect(location, portletWindow, servletRequest, servletResponse, _actionResponse);
185             }
186             finally
187             {
188                 PortletInvokerAccess.releasePortletInvoker(invoker);                            
189                 PortletContainerServices.release();
190             }
191         }
192     }
193 
194     public void portletLoad ( PortletWindow portletWindow,
195                               HttpServletRequest servletRequest,
196                               HttpServletResponse servletResponse )
197     throws PortletException, PortletContainerException
198     {
199         PortletContainerServices.prepare(uniqueContainerName);
200         PortletInvoker invoker = null;
201 
202         if (log.isDebugEnabled())
203             log.debug("PortletContainerImpl.portletLoad("+portletWindow.getId()+") called.");
204 
205         RenderRequest renderRequest = PortletObjectAccess.getRenderRequest(portletWindow, 
206                                                                            servletRequest, 
207                                                                            servletResponse);
208 
209         RenderResponse renderResponse = PortletObjectAccess.getRenderResponse(portletWindow, 
210                                                                               servletRequest, 
211                                                                               servletResponse,
212                                                                               supportsBuffering);
213 
214         invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
215 
216         try
217         {
218             invoker.load(renderRequest, renderResponse);
219         }
220         finally
221         {
222             PortletInvokerAccess.releasePortletInvoker(invoker);                        
223             PortletContainerServices.release();            
224         }
225 
226     }
227 
228     public boolean isInitialized()
229     {
230         return initialized;
231     }
232 
233     protected void redirect(String location, 
234                               PortletWindow portletWindow, 
235                               HttpServletRequest servletRequest, 
236                               HttpServletResponse servletResponse, 
237                               InternalActionResponse _actionResponse) 
238     throws IOException {
239 	    if (location == null && _actionResponse != null)
240 	    {
241 	        DynamicInformationProvider provider = InformationProviderAccess.getDynamicProvider(servletRequest);
242 	
243 	        //TODO: don't send changes in case of exception -> PORTLET:SPEC:17
244 	
245             PortletMode portletMode = provider.getPortletMode(portletWindow);
246             WindowState windowState = provider.getWindowState(portletWindow);
247             
248 	        // get the changings of this portlet entity that might be set during action handling
249 	        // change portlet mode
250 	        if (_actionResponse.getChangedPortletMode() != null)
251 	        {
252                 portletMode = _actionResponse.getChangedPortletMode();
253 	            InformationProviderAccess.getDynamicProvider(servletRequest)
254 	                .getPortletActionProvider(portletWindow)
255 	                .changePortletMode(portletMode);
256 	        }
257 	        // change window state
258 	        if (_actionResponse.getChangedWindowState() != null)
259 	        {
260                 windowState = _actionResponse.getChangedWindowState();
261 	            InformationProviderAccess.getDynamicProvider(servletRequest)
262 	                .getPortletActionProvider(portletWindow)
263 	                .changePortletWindowState(windowState);
264 	        }
265 	        // get render parameters
266 	        Map renderParameter = _actionResponse.getRenderParameters();
267 	
268 	        PortletURLProvider redirectURL = provider.getPortletURLProvider(portletWindow);
269 	
270 	        if (provider.getPortletMode(portletWindow)!=null)
271 	        {
272 	            redirectURL.setPortletMode(portletMode);
273 	        }
274 	        if (provider.getWindowState(portletWindow)!=null)
275 	        {
276 	            redirectURL.setWindowState(windowState);
277 	        }
278 	        if (servletRequest.isSecure())
279 	        {
280 	            redirectURL.setSecure(); // TBD
281 	        }
282 	        redirectURL.clearParameters();
283 	        redirectURL.setParameters(renderParameter);
284 	
285 	        location = servletResponse.encodeRedirectURL(redirectURL.toString());
286 	    }
287 	
288 	    javax.servlet.http.HttpServletResponse redirectResponse = servletResponse;
289 	    while (redirectResponse instanceof javax.servlet.http.HttpServletResponseWrapper)
290 	    {
291 	        redirectResponse = (javax.servlet.http.HttpServletResponse)
292 	                           ((javax.servlet.http.HttpServletResponseWrapper)redirectResponse).getResponse();
293 	    }
294 	    redirectResponse.sendRedirect(location);
295 	
296 	    }
297 }