| /* |
| * Copyright 2004,2004 The Apache Software Foundation. |
| * |
| * Licensed 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.cocoon.portal.impl; |
| |
| import java.util.Map; |
| import java.util.Properties; |
| |
| import javax.portlet.PortletMode; |
| import javax.portlet.WindowState; |
| import javax.servlet.ServletConfig; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| import org.apache.avalon.framework.activity.Disposable; |
| import org.apache.avalon.framework.activity.Initializable; |
| import org.apache.avalon.framework.container.ContainerUtil; |
| import org.apache.avalon.framework.context.Context; |
| import org.apache.avalon.framework.context.ContextException; |
| import org.apache.avalon.framework.context.Contextualizable; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.components.ContextHelper; |
| import org.apache.cocoon.environment.http.HttpEnvironment; |
| import org.apache.cocoon.portal.PortalManager; |
| import org.apache.cocoon.portal.event.Event; |
| import org.apache.cocoon.portal.event.EventManager; |
| import org.apache.cocoon.portal.event.Filter; |
| import org.apache.cocoon.portal.event.Subscriber; |
| import org.apache.cocoon.portal.pluto.PortletContainerEnvironmentImpl; |
| import org.apache.cocoon.portal.pluto.PortletURLProviderImpl; |
| import org.apache.cocoon.portal.pluto.servlet.ServletRequestImpl; |
| import org.apache.cocoon.portal.pluto.servlet.ServletResponseImpl; |
| import org.apache.cocoon.servlet.CocoonServlet; |
| import org.apache.pluto.PortletContainer; |
| import org.apache.pluto.PortletContainerException; |
| import org.apache.pluto.PortletContainerImpl; |
| import org.apache.pluto.om.window.PortletWindow; |
| import org.apache.pluto.services.PortletContainerEnvironment; |
| import org.apache.pluto.services.information.DynamicInformationProvider; |
| import org.apache.pluto.services.information.InformationProviderService; |
| import org.apache.pluto.services.information.PortletActionProvider; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * Extends the PortalManager by initializing Pluto |
| * |
| * @author <a href="mailto:cziegeler@apache.org">Carsten Ziegeler</a> |
| * |
| * @version CVS $Id: PortletPortalManager.java,v 1.5 2004/03/05 13:02:13 bdelacretaz Exp $ |
| */ |
| public class PortletPortalManager |
| extends PortalManagerImpl |
| implements Initializable, Contextualizable, Disposable, Subscriber { |
| |
| public static ThreadLocal copletInstanceData = new InheritableThreadLocal(); |
| |
| /** The servlet configuration for pluto */ |
| protected ServletConfig servletConfig; |
| |
| /** The Portlet Container */ |
| protected PortletContainer portletContainer; |
| |
| /** The Portlet Container environment */ |
| protected PortletContainerEnvironmentImpl portletContainerEnvironment; |
| |
| /** The component context */ |
| protected Context context; |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.context.Contextualizable#contextualize(org.apache.avalon.framework.context.Context) |
| */ |
| public void contextualize(Context context) throws ContextException { |
| this.context = context; |
| try { |
| this.servletConfig = (ServletConfig) context.get(CocoonServlet.CONTEXT_SERVLET_CONFIG); |
| // we have to somehow pass this component down to other components! |
| // This is ugly, but it's the only chance for sofisticated component containers |
| // that wrap component implementations! |
| this.servletConfig.getServletContext().setAttribute(PortalManager.ROLE, this); |
| } catch (ContextException ignore) { |
| // we ignore the context exception |
| // this avoids startup errors if the portal is configured for the CLI |
| // environment |
| this.getLogger().warn("The JSR-168 support is disabled as the servlet context is not available.", ignore); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.service.Serviceable#service(org.apache.avalon.framework.service.ServiceManager) |
| */ |
| public void service(ServiceManager manager) throws ServiceException { |
| super.service(manager); |
| EventManager eventManager = null; |
| try { |
| eventManager = (EventManager)this.manager.lookup(EventManager.ROLE); |
| eventManager.getRegister().subscribe(this); |
| } finally { |
| this.manager.release(eventManager); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.activity.Disposable#dispose() |
| */ |
| public void dispose() { |
| try { |
| if (this.portletContainer != null ) { |
| this.portletContainer.shutdown(); |
| this.portletContainer = null; |
| } |
| ContainerUtil.dispose(this.portletContainerEnvironment); |
| this.portletContainerEnvironment = null; |
| } catch (Throwable t) { |
| this.getLogger().error("Destruction failed!", t); |
| } |
| if ( this.servletConfig != null ) { |
| this.servletConfig.getServletContext().removeAttribute(PortalManager.ROLE); |
| this.servletConfig = null; |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.activity.Initializable#initialize() |
| */ |
| public void initialize() throws Exception { |
| if ( this.servletConfig != null ) { |
| this.initContainer(); |
| } |
| } |
| |
| /** |
| * Return the portlet container |
| */ |
| public PortletContainer getPortletContainer() { |
| return this.portletContainer; |
| } |
| |
| /** |
| * Return the portlet container environment |
| */ |
| public PortletContainerEnvironment getPortletContainerEnvironment() { |
| return this.portletContainerEnvironment; |
| } |
| |
| /** |
| * Initialize the container |
| */ |
| public void initContainer() throws Exception { |
| this.portletContainer = new PortletContainerImpl(); |
| |
| if (!portletContainer.isInitialized()) { |
| this.getLogger().debug ("Initializing PortletContainer..."); |
| |
| final String uniqueContainerName = "cocoon-portal"; |
| |
| this.portletContainerEnvironment = new PortletContainerEnvironmentImpl(); |
| ContainerUtil.enableLogging(this.portletContainerEnvironment, this.getLogger()); |
| ContainerUtil.contextualize(this.portletContainerEnvironment, this.context); |
| ContainerUtil.service(this.portletContainerEnvironment, this.manager); |
| ContainerUtil.initialize(this.portletContainerEnvironment); |
| |
| Properties properties = new Properties(); |
| |
| try { |
| portletContainer.init(uniqueContainerName, servletConfig, this.portletContainerEnvironment, properties); |
| } catch (PortletContainerException exc) { |
| throw new ProcessingException("Initialization of the portlet container failed.", exc); |
| } |
| } else { |
| this.getLogger().debug("PortletContainer already initialized."); |
| } |
| |
| this.getLogger().debug("PortletContainer initialized."); |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.portal.PortalManager#process() |
| */ |
| public void process() throws ProcessingException { |
| // process the events |
| super.process(); |
| |
| // if we aren't running in a servlet environment, just skip the JSR-168 part |
| if ( this.servletConfig == null ) { |
| return; |
| } |
| |
| // do we already have an environment? |
| // if not, create one |
| final Map objectModel = ContextHelper.getObjectModel(this.context); |
| |
| PortletURLProviderImpl event = (PortletURLProviderImpl) objectModel.get("portlet-event"); |
| if ( event != null ) { |
| PortletWindow actionWindow = event.getPortletWindow(); |
| try { |
| final ServletRequestImpl req = (ServletRequestImpl) objectModel.get("portlet-request"); |
| final ServletResponseImpl res= (ServletResponseImpl)objectModel.get("portlet-response"); |
| this.portletContainer.processPortletAction(actionWindow, req.getRequest(actionWindow), res); |
| |
| final String redirectURL = res.getRedirectURL(); |
| HttpServletResponse response = (HttpServletResponse) objectModel.get(HttpEnvironment.HTTP_RESPONSE_OBJECT); |
| response.sendRedirect(redirectURL); |
| } catch (Exception ignore) { |
| this.getLogger().error("Error during processing of portlet action.", ignore); |
| } |
| } else if ( objectModel.get("portlet-response") == null ) { |
| final HttpServletResponse res = (HttpServletResponse) objectModel.get(HttpEnvironment.HTTP_RESPONSE_OBJECT); |
| objectModel.put("portlet-response", new ServletResponseImpl(res)); |
| final ServletRequestImpl req = new ServletRequestImpl((HttpServletRequest) objectModel.get(HttpEnvironment.HTTP_REQUEST_OBJECT), null); |
| objectModel.put("portlet-request", req); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.portal.PortalManager#showPortal(org.xml.sax.ContentHandler, org.apache.avalon.framework.parameters.Parameters) |
| */ |
| public void showPortal(ContentHandler contentHandler, Parameters parameters) |
| throws SAXException { |
| final Map objectModel = ContextHelper.getObjectModel(this.context); |
| |
| // don't generate a response, if we issued a redirect |
| if (objectModel.get("portlet-event") == null) { |
| super.showPortal(contentHandler, parameters); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.portal.event.Subscriber#getEventType() |
| */ |
| public Class getEventType() { |
| return PortletURLProviderImpl.class; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.portal.event.Subscriber#getFilter() |
| */ |
| public Filter getFilter() { |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.portal.event.Subscriber#inform(org.apache.cocoon.portal.event.Event) |
| */ |
| public void inform(Event e) { |
| PortletURLProviderImpl event = (PortletURLProviderImpl)e; |
| final Map objectModel = ContextHelper.getObjectModel(this.context); |
| final ServletRequestImpl req = new ServletRequestImpl((HttpServletRequest) objectModel.get(HttpEnvironment.HTTP_REQUEST_OBJECT), event); |
| final HttpServletResponse res = new ServletResponseImpl((HttpServletResponse) objectModel.get(HttpEnvironment.HTTP_RESPONSE_OBJECT)); |
| objectModel.put("portlet-response", res); |
| objectModel.put("portlet-request", req); |
| |
| if ( event.isAction() ) { |
| // This means we can only have ONE portlet event per request! |
| objectModel.put("portlet-event", event); |
| } else { |
| DynamicInformationProvider dynProv; |
| InformationProviderService ips; |
| PortletActionProvider pap; |
| |
| ips = (InformationProviderService)this.portletContainerEnvironment.getContainerService(InformationProviderService.class); |
| dynProv = ips.getDynamicProvider(req); |
| pap = dynProv.getPortletActionProvider(event.getPortletWindow()); |
| final PortletMode mode = event.getPortletMode(); |
| if ( mode != null ) { |
| pap.changePortletMode(mode); |
| } |
| final WindowState state = event.getWindowState(); |
| if ( state != null ) { |
| pap.changePortletWindowState(state); |
| } |
| } |
| } |
| |
| } |
| |
