| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.pluto.container.driver; |
| |
| import java.io.IOException; |
| import java.util.Timer; |
| import java.util.TimerTask; |
| |
| import javax.portlet.ActionRequest; |
| import javax.portlet.ActionResponse; |
| import javax.portlet.EventPortlet; |
| import javax.portlet.EventRequest; |
| import javax.portlet.EventResponse; |
| import javax.portlet.Portlet; |
| import javax.portlet.PortletConfig; |
| import javax.portlet.PortletException; |
| import javax.portlet.PortletRequest; |
| import javax.portlet.PortletResponse; |
| import javax.portlet.RenderRequest; |
| import javax.portlet.RenderResponse; |
| import javax.portlet.ResourceRequest; |
| import javax.portlet.ResourceResponse; |
| import javax.portlet.ResourceServingPortlet; |
| import javax.portlet.UnavailableException; |
| import javax.servlet.ServletConfig; |
| import javax.servlet.ServletContext; |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServlet; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.apache.pluto.container.FilterManager; |
| import org.apache.pluto.container.PortletContainerException; |
| import org.apache.pluto.container.PortletInvokerService; |
| import org.apache.pluto.container.PortletRequestContext; |
| import org.apache.pluto.container.PortletResponseContext; |
| import org.apache.pluto.container.PortletWindow; |
| import org.apache.pluto.container.om.portlet.PortletDefinition; |
| |
| /** |
| * Portlet Invocation Servlet. This servlet recieves cross context requests from |
| * the the container and services the portlet request for the specified method. |
| * |
| * @version 1.1 |
| * @since 09/22/2004 |
| */ |
| public class PortletServlet extends HttpServlet |
| { |
| private static final long serialVersionUID = -5096339022539360365L; |
| |
| static class NullPortlet implements EventPortlet, ResourceServingPortlet, Portlet |
| { |
| public void processEvent(EventRequest arg0, EventResponse arg1) |
| throws PortletException, IOException |
| { |
| } |
| |
| public void serveResource(ResourceRequest arg0, ResourceResponse arg1) |
| throws PortletException, IOException |
| { |
| } |
| |
| public void destroy() |
| { |
| } |
| |
| public void init(PortletConfig arg0) throws PortletException |
| { |
| } |
| |
| public void processAction(ActionRequest arg0, ActionResponse arg1) |
| throws PortletException, IOException |
| { |
| } |
| |
| public void render(RenderRequest arg0, RenderResponse arg1) |
| throws PortletException, IOException |
| { |
| } |
| } |
| |
| // Private Member Variables ------------------------------------------------ |
| /** |
| * The portlet name as defined in the portlet app descriptor. |
| */ |
| private String portletName; |
| |
| /** |
| * The portlet instance wrapped by this servlet. |
| */ |
| private Portlet portlet; |
| |
| /** |
| * The internal portlet context instance. |
| */ |
| private DriverPortletContext portletContext; |
| |
| /** |
| * The internal portlet config instance. |
| */ |
| private DriverPortletConfig portletConfig; |
| |
| /** |
| * The Event Portlet instance (the same object as portlet) wrapped by this |
| * servlet. |
| */ |
| private EventPortlet eventPortlet; |
| |
| /** The resource serving portlet instance wrapped by this servlet. */ |
| private ResourceServingPortlet resourceServingPortlet; |
| |
| private PortletContextService contextService; |
| |
| private boolean started = false; |
| Timer startTimer; |
| |
| // HttpServlet Impl -------------------------------------------------------- |
| |
| public String getServletInfo() |
| { |
| return "Pluto PortletServlet [" + portletName + "]"; |
| } |
| |
| /** |
| * Initialize the portlet invocation servlet. |
| * |
| * @throws ServletException |
| * if an error occurs while loading portlet. |
| */ |
| public void init(ServletConfig config) throws ServletException |
| { |
| |
| // Call the super initialization method. |
| super.init(config); |
| |
| // Retrieve portlet name as defined as an initialization parameter. |
| portletName = getInitParameter("portlet-name"); |
| |
| started = false; |
| |
| startTimer = new Timer(true); |
| final ServletContext servletContext = getServletContext(); |
| final ClassLoader paClassLoader = Thread.currentThread().getContextClassLoader(); |
| startTimer.schedule(new TimerTask() |
| { |
| public void run() |
| { |
| synchronized(servletContext) |
| { |
| if (startTimer != null) |
| { |
| if (attemptRegistration(servletContext, paClassLoader )) |
| { |
| startTimer.cancel(); |
| startTimer = null; |
| } |
| } |
| } |
| } |
| }, 1, 10000); |
| } |
| |
| protected boolean attemptRegistration(ServletContext context, ClassLoader paClassLoader) |
| { |
| if (PlutoServices.getServices() != null) |
| { |
| contextService = PlutoServices.getServices().getPortletContextService(); |
| try |
| { |
| ServletConfig sConfig = getServletConfig(); |
| if (sConfig == null) |
| { |
| String msg = "Problem obtaining servlet configuration(getServletConfig() returns null)."; |
| context.log(msg); |
| return true; |
| } |
| |
| String applicationName = contextService.register(sConfig); |
| started = true; |
| portletContext = contextService.getPortletContext(applicationName); |
| portletConfig = contextService.getPortletConfig(applicationName, portletName); |
| |
| } |
| catch (PortletContainerException ex) |
| { |
| context.log(ex.getMessage(),ex); |
| return true; |
| } |
| |
| PortletDefinition portletDD = portletConfig.getPortletDefinition(); |
| |
| // Create and initialize the portlet wrapped in the servlet. |
| try |
| { |
| Class<?> clazz = paClassLoader.loadClass((portletDD.getPortletClass())); |
| portlet = (Portlet) clazz.newInstance(); |
| portlet.init(portletConfig); |
| initializeEventPortlet(); |
| initializeResourceServingPortlet(); |
| return true; |
| } |
| catch (Exception ex) |
| { |
| context.log(ex.getMessage(),ex); |
| // take out of service |
| portlet = null; |
| portletConfig = null; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public void destroy() |
| { |
| synchronized(getServletContext()) |
| { |
| if ( startTimer != null ) |
| { |
| startTimer.cancel(); |
| startTimer = null; |
| } |
| else if ( started && portletContext != null) |
| { |
| started = false; |
| contextService.unregister(portletContext); |
| if (portlet != null) |
| { |
| try |
| { |
| portlet.destroy(); |
| } |
| catch (Exception e) |
| { |
| // ignore |
| } |
| portlet = null; |
| } |
| } |
| super.destroy(); |
| } |
| } |
| |
| protected void doGet(HttpServletRequest request, |
| HttpServletResponse response) throws ServletException, IOException |
| { |
| dispatch(request, response); |
| } |
| |
| protected void doPost(HttpServletRequest request, |
| HttpServletResponse response) throws ServletException, IOException |
| { |
| dispatch(request, response); |
| } |
| |
| protected void doPut(HttpServletRequest request, |
| HttpServletResponse response) throws ServletException, IOException |
| { |
| dispatch(request, response); |
| } |
| |
| // Private Methods --------------------------------------------------------- |
| |
| /** |
| * Dispatch the request to the appropriate portlet methods. This method |
| * assumes that the following attributes are set in the servlet request |
| * scope: |
| * <ul> |
| * <li>METHOD_ID: indicating which method to dispatch.</li> |
| * <li>PORTLET_REQUEST: the internal portlet request.</li> |
| * <li>PORTLET_RESPONSE: the internal portlet response.</li> |
| * </ul> |
| * |
| * @param request |
| * the servlet request. |
| * @param response |
| * the servlet response. |
| * @throws ServletException |
| * @throws IOException |
| */ |
| private void dispatch(HttpServletRequest request, |
| HttpServletResponse response) throws ServletException, IOException |
| { |
| if (portlet == null) |
| { |
| throw new javax.servlet.UnavailableException("Portlet "+portletName+" unavailable"); |
| } |
| |
| // Retrieve attributes from the servlet request. |
| Integer methodId = (Integer) request.getAttribute(PortletInvokerService.METHOD_ID); |
| |
| final PortletRequest portletRequest = (PortletRequest)request.getAttribute(PortletInvokerService.PORTLET_REQUEST); |
| |
| final PortletResponse portletResponse = (PortletResponse)request.getAttribute(PortletInvokerService.PORTLET_RESPONSE); |
| |
| final PortletRequestContext requestContext = (PortletRequestContext)portletRequest.getAttribute(PortletInvokerService.REQUEST_CONTEXT); |
| final PortletResponseContext responseContext = (PortletResponseContext)portletRequest.getAttribute(PortletInvokerService.RESPONSE_CONTEXT); |
| |
| final FilterManager filterManager = (FilterManager)request.getAttribute(PortletInvokerService.FILTER_MANAGER); |
| |
| request.removeAttribute(PortletInvokerService.METHOD_ID); |
| request.removeAttribute(PortletInvokerService.PORTLET_REQUEST); |
| request.removeAttribute(PortletInvokerService.PORTLET_RESPONSE); |
| request.removeAttribute(PortletInvokerService.FILTER_MANAGER); |
| |
| requestContext.init(portletConfig, getServletContext(), request, response); |
| responseContext.init(request, response); |
| |
| PortletWindow window = requestContext.getPortletWindow(); |
| |
| PortletInvocationEvent event = new PortletInvocationEvent(portletRequest, window, methodId.intValue()); |
| |
| notify(event, true, null); |
| |
| // FilterManager filtermanager = (FilterManager) request.getAttribute( |
| // "filter-manager"); |
| |
| try |
| { |
| |
| // The requested method is RENDER: call Portlet.render(..) |
| if (methodId == PortletInvokerService.METHOD_RENDER) |
| { |
| RenderRequest renderRequest = (RenderRequest) portletRequest; |
| RenderResponse renderResponse = (RenderResponse) portletResponse; |
| filterManager.processFilter(renderRequest, renderResponse, |
| portlet, portletContext); |
| } |
| |
| // The requested method is RESOURCE: call |
| // ResourceServingPortlet.serveResource(..) |
| else if (methodId == PortletInvokerService.METHOD_RESOURCE) |
| { |
| ResourceRequest resourceRequest = (ResourceRequest) portletRequest; |
| ResourceResponse resourceResponse = (ResourceResponse) portletResponse; |
| filterManager.processFilter(resourceRequest, resourceResponse, |
| resourceServingPortlet, portletContext); |
| } |
| |
| // The requested method is ACTION: call Portlet.processAction(..) |
| else if (methodId == PortletInvokerService.METHOD_ACTION) |
| { |
| ActionRequest actionRequest = (ActionRequest) portletRequest; |
| ActionResponse actionResponse = (ActionResponse) portletResponse; |
| filterManager.processFilter(actionRequest, actionResponse, |
| portlet, portletContext); |
| } |
| |
| // The request methode is Event: call Portlet.processEvent(..) |
| else if (methodId == PortletInvokerService.METHOD_EVENT) |
| { |
| EventRequest eventRequest = (EventRequest) portletRequest; |
| EventResponse eventResponse = (EventResponse) portletResponse; |
| filterManager.processFilter(eventRequest, eventResponse, |
| eventPortlet, portletContext); |
| } |
| // The requested method is ADMIN: call handlers. |
| else if (methodId == PortletInvokerService.METHOD_ADMIN) |
| { |
| PortalAdministrationService pas = PlutoServices.getServices().getPortalAdministrationService(); |
| |
| for (AdministrativeRequestListener l : pas.getAdministrativeRequestListeners()) |
| { |
| l.administer(portletRequest, portletResponse); |
| } |
| } |
| |
| // The requested method is LOAD: do nothing. |
| else if (methodId == PortletInvokerService.METHOD_LOAD) |
| { |
| // Do nothing. |
| } |
| |
| notify(event, false, null); |
| |
| } |
| catch (UnavailableException ex) |
| { |
| // |
| // if (e.isPermanent()) { throw new |
| // UnavailableException(e.getMessage()); } else { throw new |
| // UnavailableException(e.getMessage(), e.getUnavailableSeconds()); |
| // } |
| // |
| |
| // Portlet.destroy() isn't called by Tomcat, so we have to fix it. |
| try |
| { |
| portlet.destroy(); |
| } |
| catch (Throwable th) |
| { |
| // Don't care for Exception |
| this.getServletContext().log("Error during portlet destroy.", th); |
| } |
| // take portlet out of service |
| portlet = null; |
| |
| // TODO: Handle everything as permanently for now. |
| throw new javax.servlet.UnavailableException(ex.getMessage()); |
| |
| } |
| catch (PortletException ex) |
| { |
| notify(event, false, ex); |
| throw new ServletException(ex); |
| |
| } |
| } |
| |
| protected void notify(PortletInvocationEvent event, boolean pre, Throwable e) |
| { |
| PortalAdministrationService pas = PlutoServices.getServices().getPortalAdministrationService(); |
| |
| for (PortletInvocationListener listener : pas.getPortletInvocationListeners()) |
| { |
| if (pre) |
| { |
| listener.onBegin(event); |
| } |
| else if (e == null) |
| { |
| listener.onEnd(event); |
| } |
| else |
| { |
| listener.onError(event, e); |
| } |
| } |
| } |
| |
| private void initializeEventPortlet() |
| { |
| if (portlet instanceof EventPortlet) |
| { |
| eventPortlet = (EventPortlet) portlet; |
| } |
| else |
| { |
| eventPortlet = new NullPortlet(); |
| } |
| } |
| |
| private void initializeResourceServingPortlet() |
| { |
| if (portlet instanceof ResourceServingPortlet) |
| { |
| resourceServingPortlet = (ResourceServingPortlet) portlet; |
| } |
| else |
| { |
| resourceServingPortlet = new NullPortlet(); |
| } |
| } |
| } |
