001    /**
002     * Copyright (c) 2000-2012 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.portal.kernel.messaging;
016    
017    import com.liferay.portal.kernel.messaging.sender.MessageSender;
018    import com.liferay.portal.kernel.messaging.sender.SynchronousMessageSender;
019    import com.liferay.portal.kernel.security.pacl.PACLConstants;
020    import com.liferay.portal.kernel.security.pacl.permission.PortalMessageBusPermission;
021    import com.liferay.portal.kernel.security.pacl.permission.PortalRuntimePermission;
022    
023    import java.security.Permission;
024    
025    /**
026     * @author Michael C. Han
027     * @author Raymond Augé
028     */
029    public class MessageBusUtil {
030    
031            public static void addDestination(Destination destination) {
032                    getInstance()._addDestination(destination);
033            }
034    
035            public static Message createResponseMessage(Message requestMessage) {
036                    Message responseMessage = new Message();
037    
038                    responseMessage.setDestinationName(
039                            requestMessage.getResponseDestinationName());
040                    responseMessage.setResponseId(requestMessage.getResponseId());
041    
042                    return responseMessage;
043            }
044    
045            public static Message createResponseMessage(
046                    Message requestMessage, Object payload) {
047    
048                    Message responseMessage = createResponseMessage(requestMessage);
049    
050                    responseMessage.setPayload(payload);
051    
052                    return responseMessage;
053            }
054    
055            public static MessageBusUtil getInstance() {
056                    PortalRuntimePermission.checkGetBeanProperty(MessageBusUtil.class);
057    
058                    return _instance;
059            }
060    
061            public static MessageBus getMessageBus() {
062                    return getInstance()._messageBus;
063            }
064    
065            public static MessageSender getMessageSender() {
066                    return getInstance()._messageSender;
067            }
068    
069            public static boolean hasMessageListener(String destination) {
070                    return getInstance()._hasMessageListener(destination);
071            }
072    
073            public static void init(
074                    MessageBus messageBus, MessageSender messageSender,
075                    SynchronousMessageSender synchronousMessageSender) {
076    
077                    getInstance()._init(
078                            messageBus, messageSender, synchronousMessageSender);
079            }
080    
081            public static void registerMessageListener(
082                    String destinationName, MessageListener messageListener) {
083    
084                    getInstance()._registerMessageListener(
085                            destinationName, messageListener);
086            }
087    
088            public static void removeDestination(String destinationName) {
089                    getInstance()._removeDestination(destinationName);
090            }
091    
092            public static void sendMessage(String destinationName, Message message) {
093                    getInstance()._sendMessage(destinationName, message);
094            }
095    
096            public static void sendMessage(String destinationName, Object payload) {
097                    getInstance()._sendMessage(destinationName, payload);
098            }
099    
100            public static Object sendSynchronousMessage(
101                            String destinationName, Message message)
102                    throws MessageBusException {
103    
104                    return getInstance()._sendSynchronousMessage(destinationName, message);
105            }
106    
107            public static Object sendSynchronousMessage(
108                            String destinationName, Message message, long timeout)
109                    throws MessageBusException {
110    
111                    return getInstance()._sendSynchronousMessage(
112                            destinationName, message, timeout);
113            }
114    
115            public static Object sendSynchronousMessage(
116                            String destinationName, Object payload)
117                    throws MessageBusException {
118    
119                    return getInstance()._sendSynchronousMessage(
120                            destinationName, payload, null);
121            }
122    
123            public static Object sendSynchronousMessage(
124                            String destinationName, Object payload, long timeout)
125                    throws MessageBusException {
126    
127                    return getInstance()._sendSynchronousMessage(
128                            destinationName, payload, null, timeout);
129            }
130    
131            public static Object sendSynchronousMessage(
132                            String destinationName, Object payload,
133                            String responseDestinationName)
134                    throws MessageBusException {
135    
136                    return getInstance()._sendSynchronousMessage(
137                            destinationName, payload, responseDestinationName);
138            }
139    
140            public static Object sendSynchronousMessage(
141                            String destinationName, Object payload,
142                            String responseDestinationName, long timeout)
143                    throws MessageBusException {
144    
145                    return getInstance()._sendSynchronousMessage(
146                            destinationName, payload, responseDestinationName, timeout);
147            }
148    
149            public static void shutdown() {
150                    getInstance()._shutdown();
151            }
152    
153            public static void shutdown(boolean force) {
154                    getInstance()._shutdown(force);
155            }
156    
157            public static boolean unregisterMessageListener(
158                    String destinationName, MessageListener messageListener) {
159    
160                    return getInstance()._unregisterMessageListener(
161                            destinationName, messageListener);
162            }
163    
164            private MessageBusUtil() {
165            }
166    
167            private void _addDestination(Destination destination) {
168                    _messageBus.addDestination(destination);
169            }
170    
171            private boolean _hasMessageListener(String destinationName) {
172                    return _messageBus.hasMessageListener(destinationName);
173            }
174    
175            private void _init(
176                    MessageBus messageBus, MessageSender messageSender,
177                    SynchronousMessageSender synchronousMessageSender) {
178    
179                    _messageBus = messageBus;
180                    _messageSender = messageSender;
181                    _synchronousMessageSender = synchronousMessageSender;
182            }
183    
184            private void _registerMessageListener(
185                    String destinationName, MessageListener messageListener) {
186    
187                    _messageBus.registerMessageListener(destinationName, messageListener);
188            }
189    
190            private void _removeDestination(String destinationName) {
191                    _messageBus.removeDestination(destinationName);
192            }
193    
194            private void _sendMessage(String destinationName, Message message) {
195                    SecurityManager securityManager = System.getSecurityManager();
196    
197                    if (securityManager != null) {
198                            Permission permission = new PortalMessageBusPermission(
199                                    PACLConstants.PORTAL_MESSAGE_BUS_PERMISSION_SEND,
200                                    destinationName);
201    
202                            securityManager.checkPermission(permission);
203                    }
204    
205                    _messageBus.sendMessage(destinationName, message);
206            }
207    
208            private void _sendMessage(String destinationName, Object payload) {
209                    Message message = new Message();
210    
211                    message.setPayload(payload);
212    
213                    _sendMessage(destinationName, message);
214            }
215    
216            private Object _sendSynchronousMessage(
217                            String destinationName, Message message)
218                    throws MessageBusException {
219    
220                    return _synchronousMessageSender.send(destinationName, message);
221            }
222    
223            private Object _sendSynchronousMessage(
224                            String destinationName, Message message, long timeout)
225                    throws MessageBusException {
226    
227                    return _synchronousMessageSender.send(
228                            destinationName, message, timeout);
229            }
230    
231            private Object _sendSynchronousMessage(
232                            String destinationName, Object payload,
233                            String responseDestinationName)
234                    throws MessageBusException {
235    
236                    Message message = new Message();
237    
238                    message.setResponseDestinationName(responseDestinationName);
239                    message.setPayload(payload);
240    
241                    return _sendSynchronousMessage(destinationName, message);
242            }
243    
244            private Object _sendSynchronousMessage(
245                            String destinationName, Object payload,
246                            String responseDestinationName, long timeout)
247                    throws MessageBusException {
248    
249                    Message message = new Message();
250    
251                    message.setResponseDestinationName(responseDestinationName);
252                    message.setPayload(payload);
253    
254                    return _sendSynchronousMessage(destinationName, message, timeout);
255            }
256    
257            private void _shutdown() {
258                    _messageBus.shutdown();
259            }
260    
261            private void _shutdown(boolean force) {
262                    _messageBus.shutdown(force);
263            }
264    
265            private boolean _unregisterMessageListener(
266                    String destinationName, MessageListener messageListener) {
267    
268                    return _messageBus.unregisterMessageListener(
269                            destinationName, messageListener);
270            }
271    
272            private static MessageBusUtil _instance = new MessageBusUtil();
273    
274            private MessageBus _messageBus;
275            private MessageSender _messageSender;
276            private SynchronousMessageSender _synchronousMessageSender;
277    
278    }