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.scheduler.messaging;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.messaging.DestinationNames;
020    import com.liferay.portal.kernel.messaging.Message;
021    import com.liferay.portal.kernel.messaging.MessageBusUtil;
022    import com.liferay.portal.kernel.messaging.MessageListener;
023    import com.liferay.portal.kernel.messaging.MessageListenerException;
024    import com.liferay.portal.kernel.scheduler.JobState;
025    import com.liferay.portal.kernel.scheduler.SchedulerEngine;
026    import com.liferay.portal.kernel.scheduler.SchedulerEngineHelperUtil;
027    import com.liferay.portal.kernel.scheduler.SchedulerException;
028    import com.liferay.portal.kernel.scheduler.StorageType;
029    import com.liferay.portal.kernel.scheduler.TriggerState;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
032    
033    import java.util.Date;
034    
035    /**
036     * @author Shuyang Zhou
037     */
038    public class SchedulerEventMessageListenerWrapper implements MessageListener {
039    
040            public void afterPropertiesSet() {
041                    if (_jobName.length() > SchedulerEngine.GROUP_NAME_MAX_LENGTH) {
042                            _jobName = _jobName.substring(
043                                    0, SchedulerEngine.GROUP_NAME_MAX_LENGTH);
044                    }
045    
046                    if (_groupName.length() > SchedulerEngine.JOB_NAME_MAX_LENGTH) {
047                            _groupName = _groupName.substring(
048                                    0, SchedulerEngine.JOB_NAME_MAX_LENGTH);
049                    }
050    
051                    _receiverKey = new ReceiverKey(_jobName, _groupName);
052    
053                    if (_messageListenerUUID == null) {
054                            _messageListenerUUID = PortalUUIDUtil.generate();
055                    }
056            }
057    
058            public String getMessageListenerUUID() {
059                    return _messageListenerUUID;
060            }
061    
062            @Override
063            public void receive(Message message) throws MessageListenerException {
064                    String destinationName = GetterUtil.getString(
065                            message.getString(SchedulerEngine.DESTINATION_NAME));
066    
067                    if (destinationName.equals(DestinationNames.SCHEDULER_DISPATCH)) {
068                            ReceiverKey receiverKey = (ReceiverKey)message.get(
069                                    SchedulerEngine.RECEIVER_KEY);
070    
071                            if (!_receiverKey.equals(receiverKey)) {
072                                    return;
073                            }
074                    }
075    
076                    try {
077                            _messageListener.receive(message);
078                    }
079                    catch (Exception e) {
080                            handleException(message, e);
081    
082                            if (e instanceof MessageListenerException) {
083                                    throw (MessageListenerException)e;
084                            }
085                            else {
086                                    throw new MessageListenerException(e);
087                            }
088                    }
089                    finally {
090                            TriggerState triggerState = null;
091    
092                            if (message.getBoolean(SchedulerEngine.DISABLE)) {
093                                    triggerState = TriggerState.COMPLETE;
094    
095                                    if (destinationName.equals(
096                                                    DestinationNames.SCHEDULER_DISPATCH)) {
097    
098                                            MessageBusUtil.unregisterMessageListener(
099                                                    destinationName, this);
100                                    }
101    
102                                    String jobName = message.getString(SchedulerEngine.JOB_NAME);
103                                    String groupName = message.getString(
104                                            SchedulerEngine.GROUP_NAME);
105                                    StorageType storageType = (StorageType)message.get(
106                                            SchedulerEngine.STORAGE_TYPE);
107    
108                                    try {
109                                            SchedulerEngineHelperUtil.delete(
110                                                    jobName, groupName, storageType);
111                                    }
112                                    catch (SchedulerException se) {
113                                            if (_log.isInfoEnabled()) {
114                                                    _log.info(
115                                                            "Unable to delete job " + jobName + " in group " +
116                                                                    groupName,
117                                                            se);
118                                            }
119                                    }
120                            }
121                            else {
122                                    triggerState = TriggerState.NORMAL;
123                            }
124    
125                            try {
126                                    SchedulerEngineHelperUtil.auditSchedulerJobs(
127                                            message, triggerState);
128                            }
129                            catch (Exception e) {
130                                    if (_log.isInfoEnabled()) {
131                                            _log.info("Unable to send audit message", e);
132                                    }
133                            }
134                    }
135            }
136    
137            /**
138             * @deprecated As of 6.2.0, replaced by {@link #setGroupName(String)}
139             */
140            public void setClassName(String className) {
141                    _groupName = className;
142                    _jobName = className;
143            }
144    
145            public void setGroupName(String groupName) {
146                    _groupName = groupName;
147            }
148    
149            public void setJobName(String jobName) {
150                    _jobName = jobName;
151            }
152    
153            public void setMessageListener(MessageListener messageListener) {
154                    _messageListener = messageListener;
155            }
156    
157            public void setMessageListenerUUID(String messageListenerUUID) {
158                    _messageListenerUUID = messageListenerUUID;
159            }
160    
161            protected void handleException(Message message, Exception exception) {
162                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
163    
164                    if (jobState != null) {
165                            jobState.addException(exception, new Date());
166                    }
167            }
168    
169            private static Log _log = LogFactoryUtil.getLog(
170                    SchedulerEventMessageListenerWrapper.class);
171    
172            private String _groupName;
173            private String _jobName;
174            private MessageListener _messageListener;
175            private String _messageListenerUUID;
176            private ReceiverKey _receiverKey;
177    
178    }