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