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.RenderRequest;
26  import javax.portlet.RenderResponse;
27  import javax.servlet.ServletConfig;
28  import javax.servlet.http.HttpServletRequest;
29  import javax.servlet.http.HttpServletResponse;
30  
31  import org.apache.pluto.core.InternalActionResponse;
32  import org.apache.pluto.factory.PortletObjectAccess;
33  import org.apache.pluto.invoker.PortletInvoker;
34  import org.apache.pluto.invoker.PortletInvokerAccess;
35  import org.apache.pluto.om.window.PortletWindow;
36  import org.apache.pluto.services.PortletContainerEnvironment;
37  import org.apache.pluto.services.information.DynamicInformationProvider;
38  import org.apache.pluto.services.information.InformationProviderAccess;
39  import org.apache.pluto.services.information.PortletURLProvider;
40  import org.apache.pluto.services.log.Logger;
41  import org.apache.pluto.services.log.LogService;
42  
43  /***
44   *  Implements the Pluto Container.
45   * 
46   * @version $Id: PortletContainerImpl.java 35989 2004-05-27 11:53:44Z cziegeler $
47   */
48  public class PortletContainerImpl implements PortletContainer
49  {
50  
51      private String uniqueContainerName;
52      private boolean initialized;
53  
54      private Logger log = null;
55  
56      public void init(String uniqueContainerName,
57                       ServletConfig servletConfig,
58                       PortletContainerEnvironment environment,
59                       Properties properties)
60      throws PortletContainerException
61      {
62          this.uniqueContainerName = uniqueContainerName;
63          PortletContainerServices.createReference(uniqueContainerName, environment);
64          initialized = true;
65  
66          // Initialize the Logger that we will use
67          // from here forward for this Container:
68          log = ((LogService)environment
69                  .getContainerService(LogService.class))
70                  .getLogger(getClass());
71      }
72  
73      public void shutdown() throws PortletContainerException
74      {
75          PortletContainerServices.destroyReference(uniqueContainerName);
76      }
77  
78  
79      public void renderPortlet(PortletWindow portletWindow,
80                                HttpServletRequest servletRequest,
81                                HttpServletResponse servletResponse )
82      throws PortletException, IOException, PortletContainerException
83      {
84          PortletContainerServices.prepare(uniqueContainerName);
85          PortletInvoker invoker = null;
86          
87          if (log.isDebugEnabled())
88          {
89              log.debug("PortletContainerImpl.portletService(" + portletWindow.getId() + ") called.");
90          }
91  
92          try
93          {
94              RenderRequest renderRequest = PortletObjectAccess.getRenderRequest(portletWindow, 
95                                                                                 servletRequest, 
96                                                                                 servletResponse);
97  
98              RenderResponse renderResponse = PortletObjectAccess.getRenderResponse(portletWindow, 
99                                                                                    servletRequest, 
100                                                                                   servletResponse);
101 
102             invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
103             invoker.render(renderRequest, renderResponse);
104         }
105         finally
106         {
107             PortletInvokerAccess.releasePortletInvoker(invoker);            
108             PortletContainerServices.release();
109         }
110 
111     }
112 
113 
114     public void processPortletAction(PortletWindow portletWindow,
115                                      HttpServletRequest servletRequest,
116                                      HttpServletResponse servletResponse)
117     throws PortletException, IOException, PortletContainerException
118     {
119         PortletContainerServices.prepare(uniqueContainerName);
120         PortletInvoker invoker = null;
121 
122         if (log.isDebugEnabled())
123         {
124             log.debug("PortletContainerImpl.performPortletAction(" + portletWindow.getId() + ") called.");
125         }
126 
127         String location = null;
128 
129         InternalActionResponse _actionResponse = null;
130         ActionRequest actionRequest = null;
131 
132         try
133         {
134             /*ActionRequest*/ 
135             actionRequest = 
136             PortletObjectAccess.getActionRequest(portletWindow, 
137                                                  servletRequest, 
138                                                  servletResponse);
139 
140             ActionResponse actionResponse = PortletObjectAccess.getActionResponse(portletWindow, 
141                                                                                   servletRequest, 
142                                                                                   servletResponse);
143             invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
144 
145             _actionResponse = (InternalActionResponse)actionResponse;
146 
147             // call action() at the portlet
148             invoker.action(actionRequest, actionResponse);
149 
150             location = _actionResponse.getRedirectLocation();
151         }
152         catch (PortletException e)
153         {
154             throw e;
155         }
156         catch (IOException e)
157         {
158             throw e;
159         }
160         catch (RuntimeException e)
161         {
162             throw e;
163         }
164         finally
165         {
166             try
167             {
168 				redirect(location, portletWindow, servletRequest, servletResponse, _actionResponse);
169             }
170             finally
171             {
172                 PortletInvokerAccess.releasePortletInvoker(invoker);                            
173                 PortletContainerServices.release();
174             }
175         }
176     }
177 
178     public void portletLoad ( PortletWindow portletWindow,
179                               HttpServletRequest servletRequest,
180                               HttpServletResponse servletResponse )
181     throws PortletException, PortletContainerException
182     {
183         PortletContainerServices.prepare(uniqueContainerName);
184         PortletInvoker invoker = null;
185 
186         if (log.isDebugEnabled())
187             log.debug("PortletContainerImpl.portletLoad("+portletWindow.getId()+") called.");
188 
189         RenderRequest renderRequest = PortletObjectAccess.getRenderRequest(portletWindow, 
190                                                                            servletRequest, 
191                                                                            servletResponse);
192 
193         RenderResponse renderResponse = PortletObjectAccess.getRenderResponse(portletWindow, 
194                                                                               servletRequest, 
195                                                                               servletResponse);
196 
197         invoker = PortletInvokerAccess.getPortletInvoker(portletWindow.getPortletEntity().getPortletDefinition());
198 
199         try
200         {
201             invoker.load(renderRequest, renderResponse);
202         }
203         finally
204         {
205             PortletInvokerAccess.releasePortletInvoker(invoker);                        
206             PortletContainerServices.release();            
207         }
208 
209     }
210 
211     public boolean isInitialized()
212     {
213         return initialized;
214     }
215 
216     protected void redirect(String location, 
217                               PortletWindow portletWindow, 
218                               HttpServletRequest servletRequest, 
219                               HttpServletResponse servletResponse, 
220                               InternalActionResponse _actionResponse) 
221     throws IOException {
222 	    if (location == null && _actionResponse != null)
223 	    {
224 	        DynamicInformationProvider provider = InformationProviderAccess.getDynamicProvider(servletRequest);
225 	
226 	        //TODO: don't send changes in case of exception -> PORTLET:SPEC:17
227 	
228 	        // get the changings of this portlet entity that might be set during action handling
229 	        // change portlet mode
230 	        if (_actionResponse.getChangedPortletMode() != null)
231 	        {
232 	            InformationProviderAccess.getDynamicProvider(servletRequest)
233 	                .getPortletActionProvider(portletWindow)
234 	                .changePortletMode(_actionResponse.getChangedPortletMode());
235 	        }
236 	        // change window state
237 	        if (_actionResponse.getChangedWindowState() != null)
238 	        {
239 	            InformationProviderAccess.getDynamicProvider(servletRequest)
240 	                .getPortletActionProvider(portletWindow)
241 	                .changePortletWindowState(_actionResponse.getChangedWindowState());
242 	        }
243 	        // get render parameters
244 	        Map renderParameter = _actionResponse.getRenderParameters();
245 	
246 	        PortletURLProvider redirectURL = provider.getPortletURLProvider(portletWindow);
247 	
248 	        if (provider.getPortletMode(portletWindow)!=null)
249 	        {
250 	            redirectURL.setPortletMode(provider.getPortletMode(portletWindow));
251 	        }
252 	        if (provider.getWindowState(portletWindow)!=null)
253 	        {
254 	            redirectURL.setWindowState(provider.getWindowState(portletWindow));
255 	        }
256 	        if (servletRequest.isSecure())
257 	        {
258 	            redirectURL.setSecure(); // TBD
259 	        }
260 	        redirectURL.clearParameters();
261 	        redirectURL.setParameters(renderParameter);
262 	
263 	        location = servletResponse.encodeRedirectURL(redirectURL.toString());
264 	    }
265 	
266 	    javax.servlet.http.HttpServletResponse redirectResponse = servletResponse;
267 	    while (redirectResponse instanceof javax.servlet.http.HttpServletResponseWrapper)
268 	    {
269 	        redirectResponse = (javax.servlet.http.HttpServletResponse)
270 	                           ((javax.servlet.http.HttpServletResponseWrapper)redirectResponse).getResponse();
271 	    }
272 	    redirectResponse.sendRedirect(location);
273 	
274 	    }
275 }