001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet;
016    
017    import com.liferay.portal.kernel.monitoring.RequestStatus;
018    import com.liferay.portal.kernel.monitoring.statistics.DataSampleThreadLocal;
019    import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
020    import com.liferay.portal.monitoring.statistics.portlet.PortletRequestDataSample;
021    import com.liferay.portal.monitoring.statistics.portlet.PortletRequestType;
022    import com.liferay.portal.util.PropsValues;
023    
024    import java.io.IOException;
025    
026    import javax.portlet.ActionRequest;
027    import javax.portlet.ActionResponse;
028    import javax.portlet.EventRequest;
029    import javax.portlet.EventResponse;
030    import javax.portlet.Portlet;
031    import javax.portlet.PortletConfig;
032    import javax.portlet.PortletContext;
033    import javax.portlet.PortletException;
034    import javax.portlet.RenderRequest;
035    import javax.portlet.RenderResponse;
036    import javax.portlet.ResourceRequest;
037    import javax.portlet.ResourceResponse;
038    
039    /**
040     * @author Michael C. Han
041     * @author Karthik Sudarshan
042     * @author Raymond Aug??
043     */
044    public class MonitoringPortlet implements InvokerPortlet {
045    
046            public static boolean isMonitoringPortletActionRequest() {
047                    return _monitoringPortletActionRequest;
048            }
049    
050            public static boolean isMonitoringPortletEventRequest() {
051                    return _monitoringPortletEventRequest;
052            }
053    
054            public static boolean isMonitoringPortletRenderRequest() {
055                    return _monitoringPortletRenderRequest;
056            }
057    
058            public static boolean isMonitoringPortletResourceRequest() {
059                    return _monitoringPortletResourceRequest;
060            }
061    
062            public static void setMonitoringPortletActionRequest(
063                    boolean monitoringPortletActionRequest) {
064    
065                    _monitoringPortletActionRequest = monitoringPortletActionRequest;
066            }
067    
068            public static void setMonitoringPortletEventRequest(
069                    boolean monitoringPortletEventRequest) {
070    
071                    _monitoringPortletEventRequest = monitoringPortletEventRequest;
072            }
073    
074            public static void setMonitoringPortletRenderRequest(
075                    boolean monitoringPortletRenderRequest) {
076    
077                    _monitoringPortletRenderRequest = monitoringPortletRenderRequest;
078            }
079    
080            public static void setMonitoringPortletResourceRequest(
081                    boolean monitoringPortletResourceRequest) {
082    
083                    _monitoringPortletResourceRequest = monitoringPortletResourceRequest;
084            }
085    
086            public MonitoringPortlet() {
087            }
088    
089            public MonitoringPortlet(InvokerPortlet invokerPortlet) {
090                    _invokerPortlet = invokerPortlet;
091            }
092    
093            @Override
094            public void destroy() {
095                    _invokerPortlet.destroy();
096            }
097    
098            @Override
099            public Integer getExpCache() {
100                    return _invokerPortlet.getExpCache();
101            }
102    
103            @Override
104            public Portlet getPortlet() {
105                    return _invokerPortlet.getPortlet();
106            }
107    
108            @Override
109            public ClassLoader getPortletClassLoader() {
110                    return _invokerPortlet.getPortletClassLoader();
111            }
112    
113            @Override
114            public PortletConfig getPortletConfig() {
115                    return _invokerPortlet.getPortletConfig();
116            }
117    
118            @Override
119            public PortletContext getPortletContext() {
120                    return _invokerPortlet.getPortletContext();
121            }
122    
123            @Override
124            public Portlet getPortletInstance() {
125                    return _invokerPortlet.getPortletInstance();
126            }
127    
128            @Override
129            public void init(PortletConfig portletConfig) throws PortletException {
130                    LiferayPortletConfig liferayPortletConfig =
131                            (LiferayPortletConfig)portletConfig;
132    
133                    _invokerPortlet.init(liferayPortletConfig);
134    
135                    com.liferay.portal.model.Portlet portletModel =
136                            liferayPortletConfig.getPortlet();
137    
138                    _actionTimeout = portletModel.getActionTimeout();
139                    _renderTimeout = portletModel.getRenderTimeout();
140            }
141    
142            @Override
143            public boolean isCheckAuthToken() {
144                    return _invokerPortlet.isCheckAuthToken();
145            }
146    
147            @Override
148            public boolean isFacesPortlet() {
149                    return _invokerPortlet.isFacesPortlet();
150            }
151    
152            @Override
153            public boolean isStrutsBridgePortlet() {
154                    return _invokerPortlet.isStrutsBridgePortlet();
155            }
156    
157            @Override
158            public boolean isStrutsPortlet() {
159                    return _invokerPortlet.isStrutsPortlet();
160            }
161    
162            @Override
163            public void processAction(
164                            ActionRequest actionRequest, ActionResponse actionResponse)
165                    throws IOException, PortletException {
166    
167                    PortletRequestDataSample portletRequestDataSample = null;
168    
169                    try {
170                            if (_monitoringPortletActionRequest) {
171                                    portletRequestDataSample = new PortletRequestDataSample(
172                                            PortletRequestType.ACTION, actionRequest, actionResponse);
173    
174                                    portletRequestDataSample.setTimeout(_actionTimeout);
175    
176                                    portletRequestDataSample.prepare();
177    
178                                    DataSampleThreadLocal.initialize();
179                            }
180    
181                            _invokerPortlet.processAction(actionRequest, actionResponse);
182    
183                            if (_monitoringPortletActionRequest) {
184                                    portletRequestDataSample.capture(RequestStatus.SUCCESS);
185                            }
186                    }
187                    catch (Exception e) {
188                            _processException(
189                                    _monitoringPortletActionRequest, portletRequestDataSample, e);
190                    }
191                    finally {
192                            if (portletRequestDataSample != null) {
193                                    DataSampleThreadLocal.addDataSample(portletRequestDataSample);
194                            }
195                    }
196            }
197    
198            @Override
199            public void processEvent(
200                            EventRequest eventRequest, EventResponse eventResponse)
201                    throws IOException, PortletException {
202    
203                    PortletRequestDataSample portletRequestDataSample = null;
204    
205                    try {
206                            if (_monitoringPortletEventRequest) {
207                                    portletRequestDataSample = new PortletRequestDataSample(
208                                            PortletRequestType.EVENT, eventRequest, eventResponse);
209    
210                                    portletRequestDataSample.prepare();
211    
212                                    DataSampleThreadLocal.initialize();
213                            }
214    
215                            _invokerPortlet.processEvent(eventRequest, eventResponse);
216    
217                            if (_monitoringPortletEventRequest) {
218                                    portletRequestDataSample.capture(RequestStatus.SUCCESS);
219                            }
220                    }
221                    catch (Exception e) {
222                            _processException(
223                                    _monitoringPortletEventRequest, portletRequestDataSample, e);
224                    }
225                    finally {
226                            if (portletRequestDataSample != null) {
227                                    DataSampleThreadLocal.addDataSample(portletRequestDataSample);
228                            }
229                    }
230            }
231    
232            @Override
233            public void render(
234                            RenderRequest renderRequest, RenderResponse renderResponse)
235                    throws IOException, PortletException {
236    
237                    PortletRequestDataSample portletRequestDataSample = null;
238    
239                    try {
240                            if (_monitoringPortletRenderRequest) {
241                                    portletRequestDataSample = new PortletRequestDataSample(
242                                            PortletRequestType.RENDER, renderRequest, renderResponse);
243    
244                                    portletRequestDataSample.setTimeout(_renderTimeout);
245    
246                                    portletRequestDataSample.prepare();
247    
248                                    DataSampleThreadLocal.initialize();
249                            }
250    
251                            _invokerPortlet.render(renderRequest, renderResponse);
252    
253                            if (_monitoringPortletRenderRequest) {
254                                    portletRequestDataSample.capture(RequestStatus.SUCCESS);
255                            }
256                    }
257                    catch (Exception e) {
258                            _processException(
259                                    _monitoringPortletRenderRequest, portletRequestDataSample, e);
260                    }
261                    finally {
262                            if (portletRequestDataSample != null) {
263                                    DataSampleThreadLocal.addDataSample(portletRequestDataSample);
264                            }
265                    }
266            }
267    
268            @Override
269            public void serveResource(
270                            ResourceRequest resourceRequest, ResourceResponse resourceResponse)
271                    throws IOException, PortletException {
272    
273                    PortletRequestDataSample portletRequestDataSample = null;
274    
275                    try {
276                            if (_monitoringPortletResourceRequest) {
277                                    portletRequestDataSample = new PortletRequestDataSample(
278                                            PortletRequestType.RESOURCE, resourceRequest,
279                                            resourceResponse);
280    
281                                    portletRequestDataSample.prepare();
282    
283                                    DataSampleThreadLocal.initialize();
284                            }
285    
286                            _invokerPortlet.serveResource(resourceRequest, resourceResponse);
287    
288                            if (_monitoringPortletResourceRequest) {
289                                    portletRequestDataSample.capture(RequestStatus.SUCCESS);
290                            }
291                    }
292                    catch (Exception e) {
293                            _processException(
294                                    _monitoringPortletResourceRequest, portletRequestDataSample, e);
295                    }
296                    finally {
297                            if (portletRequestDataSample != null) {
298                                    DataSampleThreadLocal.addDataSample(portletRequestDataSample);
299                            }
300                    }
301            }
302    
303            public void setInvokerPortlet(InvokerPortlet invokerPortlet) {
304                    _invokerPortlet = invokerPortlet;
305            }
306    
307            @Override
308            public void setPortletFilters() throws PortletException {
309                    _invokerPortlet.setPortletFilters();
310            }
311    
312            private void _processException(
313                            boolean monitoringPortletRequest,
314                            PortletRequestDataSample portletRequestDataSample, Exception e)
315                    throws IOException, PortletException {
316    
317                    if (monitoringPortletRequest) {
318                            portletRequestDataSample.capture(RequestStatus.ERROR);
319                    }
320    
321                    if (e instanceof IOException) {
322                            throw (IOException)e;
323                    }
324                    else if (e instanceof PortletException) {
325                            throw (PortletException)e;
326                    }
327                    else {
328                            throw new PortletException("Unable to process portlet", e);
329                    }
330            }
331    
332            private static boolean _monitoringPortletActionRequest =
333                    PropsValues.MONITORING_PORTLET_ACTION_REQUEST;
334            private static boolean _monitoringPortletEventRequest =
335                    PropsValues.MONITORING_PORTLET_EVENT_REQUEST;
336            private static boolean _monitoringPortletRenderRequest =
337                    PropsValues.MONITORING_PORTLET_RENDER_REQUEST;
338            private static boolean _monitoringPortletResourceRequest =
339                    PropsValues.MONITORING_PORTLET_RESOURCE_REQUEST;
340    
341            private long _actionTimeout;
342            private InvokerPortlet _invokerPortlet;
343            private long _renderTimeout;
344    
345    }