001    /**
002     * Copyright (c) 2000-present 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.pop;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.pop.MessageListener;
020    import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
021    import com.liferay.portal.kernel.scheduler.SchedulerEntry;
022    import com.liferay.portal.kernel.scheduler.SchedulerEntryImpl;
023    import com.liferay.portal.kernel.scheduler.StorageType;
024    import com.liferay.portal.kernel.scheduler.TimeUnit;
025    import com.liferay.portal.kernel.scheduler.TriggerType;
026    import com.liferay.portal.kernel.util.ClassUtil;
027    import com.liferay.portal.pop.messaging.POPNotificationsMessageListener;
028    import com.liferay.portal.util.PropsValues;
029    import com.liferay.registry.Registry;
030    import com.liferay.registry.RegistryUtil;
031    import com.liferay.registry.ServiceReference;
032    import com.liferay.registry.ServiceRegistration;
033    import com.liferay.registry.ServiceTracker;
034    import com.liferay.registry.ServiceTrackerCustomizer;
035    import com.liferay.registry.collections.ServiceRegistrationMap;
036    
037    import java.util.ArrayList;
038    import java.util.Collections;
039    import java.util.List;
040    
041    /**
042     * @author Brian Wing Shun Chan
043     */
044    public class POPServerUtil {
045    
046            public static void addListener(MessageListener listener) throws Exception {
047                    _instance._addListener(listener);
048            }
049    
050            public static void deleteListener(MessageListener listener)
051                    throws Exception {
052    
053                    _instance._deleteListener(listener);
054            }
055    
056            public static List<MessageListener> getListeners() throws Exception {
057                    return _instance._getListeners();
058            }
059    
060            public static void start() {
061                    _instance._start();
062            }
063    
064            private POPServerUtil() {
065                    Registry registry = RegistryUtil.getRegistry();
066    
067                    _serviceTracker = registry.trackServices(
068                            MessageListener.class,
069                            new MessageListenerServiceTrackerCustomizer());
070    
071                    _serviceTracker.open();
072            }
073    
074            private void _addListener(MessageListener listener) {
075                    if (listener == null) {
076                            if (_log.isDebugEnabled()) {
077                                    _log.debug("Do not add null listener");
078                            }
079    
080                            return;
081                    }
082    
083                    Registry registry = RegistryUtil.getRegistry();
084    
085                    ServiceRegistration<MessageListener> serviceRegistration =
086                            registry.registerService(MessageListener.class, listener);
087    
088                    _serviceRegistrations.put(listener, serviceRegistration);
089            }
090    
091            private void _deleteListener(MessageListener listener) {
092                    if (listener == null) {
093                            if (_log.isDebugEnabled()) {
094                                    _log.debug("Do not delete null listener");
095                            }
096    
097                            return;
098                    }
099    
100                    ServiceRegistration<MessageListener> serviceRegistration =
101                            _serviceRegistrations.remove(listener);
102    
103                    if (serviceRegistration != null) {
104                            serviceRegistration.unregister();
105                    }
106            }
107    
108            private List<MessageListener> _getListeners() {
109                    if (_log.isDebugEnabled()) {
110                            _log.debug("Listeners size " + _listeners.size());
111                    }
112    
113                    return Collections.unmodifiableList(_listeners);
114            }
115    
116            private void _start() {
117                    if (_log.isDebugEnabled()) {
118                            _log.debug("Start");
119                    }
120    
121                    try {
122                            SchedulerEntry schedulerEntry = new SchedulerEntryImpl();
123    
124                            schedulerEntry.setEventListenerClass(
125                                    POPNotificationsMessageListener.class.getName());
126                            schedulerEntry.setTimeUnit(TimeUnit.MINUTE);
127                            schedulerEntry.setTriggerType(TriggerType.SIMPLE);
128                            schedulerEntry.setTriggerValue(
129                                    PropsValues.POP_SERVER_NOTIFICATIONS_INTERVAL);
130    
131                            SchedulerEngineHelperUtil.schedule(
132                                    schedulerEntry, StorageType.MEMORY_CLUSTERED, null, 0);
133                    }
134                    catch (Exception e) {
135                            _log.error(e, e);
136                    }
137            }
138    
139            private static final Log _log = LogFactoryUtil.getLog(POPServerUtil.class);
140    
141            private static final POPServerUtil _instance = new POPServerUtil();
142    
143            private final List<MessageListener> _listeners = new ArrayList<>();
144            private final ServiceRegistrationMap<MessageListener>
145                    _serviceRegistrations = new ServiceRegistrationMap<>();
146            private final ServiceTracker<MessageListener, MessageListenerWrapper>
147                    _serviceTracker;
148    
149            private class MessageListenerServiceTrackerCustomizer
150                    implements ServiceTrackerCustomizer
151                            <MessageListener, MessageListenerWrapper> {
152    
153                    @Override
154                    public MessageListenerWrapper addingService(
155                            ServiceReference<MessageListener> serviceReference) {
156    
157                            Registry registry = RegistryUtil.getRegistry();
158    
159                            MessageListener messageListener = registry.getService(
160                                    serviceReference);
161    
162                            if (_log.isDebugEnabled()) {
163                                    _log.debug(
164                                            "Add listener " + messageListener.getClass().getName());
165                            }
166    
167                            MessageListenerWrapper messageListenerWrapper =
168                                    new MessageListenerWrapper(messageListener);
169    
170                            _deleteListener(messageListenerWrapper);
171    
172                            _listeners.add(messageListenerWrapper);
173    
174                            if (_log.isDebugEnabled()) {
175                                    _log.debug("Listeners size " + _listeners.size());
176                            }
177    
178                            return messageListenerWrapper;
179                    }
180    
181                    @Override
182                    public void modifiedService(
183                            ServiceReference<MessageListener> serviceReference,
184                            MessageListenerWrapper messageListenerWrapper) {
185                    }
186    
187                    @Override
188                    public void removedService(
189                            ServiceReference<MessageListener> serviceReference,
190                            MessageListenerWrapper messageListenerWrapper) {
191    
192                            Registry registry = RegistryUtil.getRegistry();
193    
194                            registry.ungetService(serviceReference);
195    
196                            MessageListener messageListener =
197                                    messageListenerWrapper.getMessageListener();
198    
199                            if (_log.isDebugEnabled()) {
200                                    _log.debug(
201                                            "Delete listener " +
202                                                    ClassUtil.getClassName(messageListener));
203                            }
204    
205                            _listeners.remove(messageListenerWrapper);
206    
207                            if (_log.isDebugEnabled()) {
208                                    _log.debug("Listeners size " + _listeners.size());
209                            }
210                    }
211    
212            }
213    
214    }