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