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.service.impl;
016    
017    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskConstants;
018    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskExecutor;
019    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskStatus;
020    import com.liferay.portal.kernel.backgroundtask.BackgroundTaskStatusRegistry;
021    import com.liferay.portal.kernel.bean.BeanReference;
022    import com.liferay.portal.kernel.cluster.Clusterable;
023    import com.liferay.portal.kernel.exception.PortalException;
024    import com.liferay.portal.kernel.messaging.DestinationNames;
025    import com.liferay.portal.kernel.messaging.Message;
026    import com.liferay.portal.kernel.messaging.MessageBusUtil;
027    import com.liferay.portal.kernel.repository.model.Folder;
028    import com.liferay.portal.kernel.transaction.TransactionCommitCallbackRegistryUtil;
029    import com.liferay.portal.kernel.util.ContentTypes;
030    import com.liferay.portal.kernel.util.OrderByComparator;
031    import com.liferay.portal.kernel.util.StringPool;
032    import com.liferay.portal.kernel.util.StringUtil;
033    import com.liferay.portal.kernel.util.Validator;
034    import com.liferay.portal.model.BackgroundTask;
035    import com.liferay.portal.model.Lock;
036    import com.liferay.portal.model.User;
037    import com.liferay.portal.portletfilerepository.PortletFileRepositoryUtil;
038    import com.liferay.portal.service.ServiceContext;
039    import com.liferay.portal.service.base.BackgroundTaskLocalServiceBaseImpl;
040    import com.liferay.portal.util.PortletKeys;
041    import com.liferay.portlet.documentlibrary.model.DLFolderConstants;
042    
043    import java.io.File;
044    import java.io.InputStream;
045    import java.io.Serializable;
046    
047    import java.util.Date;
048    import java.util.List;
049    import java.util.Map;
050    import java.util.concurrent.Callable;
051    
052    /**
053     * @author Daniel Kocsis
054     * @author Michael C. Han
055     */
056    public class BackgroundTaskLocalServiceImpl
057            extends BackgroundTaskLocalServiceBaseImpl {
058    
059            @Override
060            public BackgroundTask addBackgroundTask(
061                            long userId, long groupId, String name,
062                            String[] servletContextNames, Class<?> taskExecutorClass,
063                            Map<String, Serializable> taskContextMap,
064                            ServiceContext serviceContext)
065                    throws PortalException {
066    
067                    User user = userPersistence.findByPrimaryKey(userId);
068                    Date now = new Date();
069    
070                    final long backgroundTaskId = counterLocalService.increment();
071    
072                    BackgroundTask backgroundTask = backgroundTaskPersistence.create(
073                            backgroundTaskId);
074    
075                    backgroundTask.setCompanyId(user.getCompanyId());
076                    backgroundTask.setCreateDate(serviceContext.getCreateDate(now));
077                    backgroundTask.setGroupId(groupId);
078                    backgroundTask.setModifiedDate(serviceContext.getModifiedDate(now));
079                    backgroundTask.setUserId(userId);
080                    backgroundTask.setUserName(user.getFullName());
081                    backgroundTask.setName(name);
082                    backgroundTask.setServletContextNames(
083                            StringUtil.merge(servletContextNames));
084                    backgroundTask.setTaskExecutorClassName(taskExecutorClass.getName());
085    
086                    if (taskContextMap != null) {
087                            backgroundTask.setTaskContextMap(taskContextMap);
088                    }
089    
090                    backgroundTask.setStatus(BackgroundTaskConstants.STATUS_NEW);
091    
092                    backgroundTaskPersistence.update(backgroundTask);
093    
094                    TransactionCommitCallbackRegistryUtil.registerCallback(
095                            new Callable<Void>() {
096    
097                                    @Override
098                                    public Void call() throws Exception {
099                                            backgroundTaskLocalService.triggerBackgroundTask(
100                                                    backgroundTaskId);
101    
102                                            return null;
103                                    }
104    
105                            });
106    
107                    return backgroundTask;
108            }
109    
110            @Override
111            public void addBackgroundTaskAttachment(
112                            long userId, long backgroundTaskId, String fileName, File file)
113                    throws PortalException {
114    
115                    BackgroundTask backgroundTask = getBackgroundTask(backgroundTaskId);
116    
117                    Folder folder = backgroundTask.addAttachmentsFolder();
118    
119                    PortletFileRepositoryUtil.addPortletFileEntry(
120                            backgroundTask.getGroupId(), userId, BackgroundTask.class.getName(),
121                            backgroundTask.getPrimaryKey(), PortletKeys.BACKGROUND_TASK,
122                            folder.getFolderId(), file, fileName, ContentTypes.APPLICATION_ZIP,
123                            false);
124            }
125    
126            @Override
127            public void addBackgroundTaskAttachment(
128                            long userId, long backgroundTaskId, String fileName,
129                            InputStream inputStream)
130                    throws PortalException {
131    
132                    BackgroundTask backgroundTask = getBackgroundTask(backgroundTaskId);
133    
134                    Folder folder = backgroundTask.addAttachmentsFolder();
135    
136                    PortletFileRepositoryUtil.addPortletFileEntry(
137                            backgroundTask.getGroupId(), userId, BackgroundTask.class.getName(),
138                            backgroundTask.getPrimaryKey(), PortletKeys.BACKGROUND_TASK,
139                            folder.getFolderId(), inputStream, fileName,
140                            ContentTypes.APPLICATION_ZIP, false);
141            }
142    
143            @Override
144            public BackgroundTask amendBackgroundTask(
145                    long backgroundTaskId, Map<String, Serializable> taskContextMap,
146                    int status, ServiceContext serviceContext) {
147    
148                    return amendBackgroundTask(
149                            backgroundTaskId, taskContextMap, status, null, serviceContext);
150            }
151    
152            @Override
153            public BackgroundTask amendBackgroundTask(
154                    long backgroundTaskId, Map<String, Serializable> taskContextMap,
155                    int status, String statusMessage, ServiceContext serviceContext) {
156    
157                    Date now = new Date();
158    
159                    BackgroundTask backgroundTask =
160                            backgroundTaskPersistence.fetchByPrimaryKey(backgroundTaskId);
161    
162                    if (backgroundTask == null) {
163                            return null;
164                    }
165    
166                    backgroundTask.setModifiedDate(serviceContext.getModifiedDate(now));
167    
168                    if (taskContextMap != null) {
169                            backgroundTask.setTaskContextMap(taskContextMap);
170                    }
171    
172                    if ((status == BackgroundTaskConstants.STATUS_FAILED) ||
173                            (status == BackgroundTaskConstants.STATUS_SUCCESSFUL)) {
174    
175                            backgroundTask.setCompleted(true);
176                            backgroundTask.setCompletionDate(now);
177                    }
178    
179                    backgroundTask.setStatus(status);
180    
181                    if (Validator.isNotNull(statusMessage)) {
182                            backgroundTask.setStatusMessage(statusMessage);
183                    }
184    
185                    backgroundTaskPersistence.update(backgroundTask);
186    
187                    return backgroundTask;
188            }
189    
190            @Clusterable(onMaster = true)
191            @Override
192            public void cleanUpBackgroundTask(
193                    final BackgroundTask backgroundTask, final int status) {
194    
195                    try {
196                            Lock lock = lockLocalService.getLock(
197                                    BackgroundTaskExecutor.class.getName(),
198                                    backgroundTask.getTaskExecutorClassName());
199    
200                            String owner =
201                                    backgroundTask.getName() + StringPool.POUND +
202                                            backgroundTask.getBackgroundTaskId();
203    
204                            if (owner.equals(lock.getOwner())) {
205                                    lockLocalService.unlock(
206                                            BackgroundTaskExecutor.class.getName(),
207                                            backgroundTask.getTaskExecutorClassName());
208                            }
209                    }
210                    catch (Exception e) {
211                    }
212    
213                    TransactionCommitCallbackRegistryUtil.registerCallback(
214                            new Callable<Void>() {
215    
216                                    @Override
217                                    public Void call() throws Exception {
218                                            Message message = new Message();
219    
220                                            message.put(
221                                                    "backgroundTaskId",
222                                                    backgroundTask.getBackgroundTaskId());
223                                            message.put("name", backgroundTask.getName());
224                                            message.put("status", status);
225                                            message.put(
226                                                    "taskExecutorClassName",
227                                                    backgroundTask.getTaskExecutorClassName());
228    
229                                            MessageBusUtil.sendMessage(
230                                                    DestinationNames.BACKGROUND_TASK_STATUS, message);
231    
232                                            return null;
233                                    }
234    
235                            }
236                    );
237            }
238    
239            @Clusterable(onMaster = true)
240            @Override
241            public void cleanUpBackgroundTasks() {
242                    List<BackgroundTask> backgroundTasks =
243                            backgroundTaskPersistence.findByStatus(
244                                    BackgroundTaskConstants.STATUS_IN_PROGRESS);
245    
246                    for (BackgroundTask backgroundTask : backgroundTasks) {
247                            backgroundTask.setStatus(BackgroundTaskConstants.STATUS_FAILED);
248    
249                            cleanUpBackgroundTask(
250                                    backgroundTask, BackgroundTaskConstants.STATUS_FAILED);
251                    }
252            }
253    
254            @Override
255            public BackgroundTask deleteBackgroundTask(BackgroundTask backgroundTask)
256                    throws PortalException {
257    
258                    long folderId = backgroundTask.getAttachmentsFolderId();
259    
260                    if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
261                            PortletFileRepositoryUtil.deletePortletFolder(folderId);
262                    }
263    
264                    if (backgroundTask.getStatus() ==
265                                    BackgroundTaskConstants.STATUS_IN_PROGRESS) {
266    
267                            cleanUpBackgroundTask(
268                                    backgroundTask, BackgroundTaskConstants.STATUS_CANCELLED);
269                    }
270    
271                    return backgroundTaskPersistence.remove(backgroundTask);
272            }
273    
274            @Override
275            public BackgroundTask deleteBackgroundTask(long backgroundTaskId)
276                    throws PortalException {
277    
278                    BackgroundTask backgroundTask =
279                            backgroundTaskPersistence.findByPrimaryKey(backgroundTaskId);
280    
281                    return deleteBackgroundTask(backgroundTask);
282            }
283    
284            @Override
285            public void deleteCompanyBackgroundTasks(long companyId)
286                    throws PortalException {
287    
288                    List<BackgroundTask> backgroundTasks =
289                            backgroundTaskPersistence.findByCompanyId(companyId);
290    
291                    for (BackgroundTask backgroundTask : backgroundTasks) {
292                            deleteBackgroundTask(backgroundTask);
293                    }
294            }
295    
296            @Override
297            public void deleteGroupBackgroundTasks(long groupId)
298                    throws PortalException {
299    
300                    List<BackgroundTask> backgroundTasks =
301                            backgroundTaskPersistence.findByGroupId(groupId);
302    
303                    for (BackgroundTask backgroundTask : backgroundTasks) {
304                            deleteBackgroundTask(backgroundTask);
305                    }
306            }
307    
308            @Override
309            public BackgroundTask fetchBackgroundTask(long backgroundTaskId) {
310                    return backgroundTaskPersistence.fetchByPrimaryKey(backgroundTaskId);
311            }
312    
313            @Override
314            public BackgroundTask fetchFirstBackgroundTask(
315                    long groupId, String taskExecutorClassName, boolean completed,
316                    OrderByComparator<BackgroundTask> orderByComparator) {
317    
318                    return backgroundTaskPersistence.fetchByG_T_C_First(
319                            groupId, taskExecutorClassName, completed, orderByComparator);
320            }
321    
322            @Override
323            public BackgroundTask fetchFirstBackgroundTask(
324                    String taskExecutorClassName, int status) {
325    
326                    return fetchFirstBackgroundTask(taskExecutorClassName, status, null);
327            }
328    
329            @Override
330            public BackgroundTask fetchFirstBackgroundTask(
331                    String taskExecutorClassName, int status,
332                    OrderByComparator<BackgroundTask> orderByComparator) {
333    
334                    return backgroundTaskPersistence.fetchByT_S_First(
335                            taskExecutorClassName, status, orderByComparator);
336            }
337    
338            @Override
339            public BackgroundTask getBackgroundTask(long backgroundTaskId)
340                    throws PortalException {
341    
342                    return backgroundTaskPersistence.findByPrimaryKey(backgroundTaskId);
343            }
344    
345            @Override
346            public List<BackgroundTask> getBackgroundTasks(long groupId, int status) {
347                    return backgroundTaskPersistence.findByG_S(groupId, status);
348            }
349    
350            @Override
351            public List<BackgroundTask> getBackgroundTasks(
352                    long groupId, String taskExecutorClassName) {
353    
354                    return backgroundTaskPersistence.findByG_T(
355                            groupId, taskExecutorClassName);
356            }
357    
358            @Override
359            public List<BackgroundTask> getBackgroundTasks(
360                    long groupId, String taskExecutorClassName, int status) {
361    
362                    return backgroundTaskPersistence.findByG_T_S(
363                            groupId, taskExecutorClassName, status);
364            }
365    
366            @Override
367            public List<BackgroundTask> getBackgroundTasks(
368                    long groupId, String taskExecutorClassName, int start, int end,
369                    OrderByComparator<BackgroundTask> orderByComparator) {
370    
371                    return backgroundTaskPersistence.findByG_T(
372                            groupId, taskExecutorClassName, start, end, orderByComparator);
373            }
374    
375            @Override
376            public List<BackgroundTask> getBackgroundTasks(
377                    long groupId, String name, String taskExecutorClassName, int start,
378                    int end, OrderByComparator<BackgroundTask> orderByComparator) {
379    
380                    return backgroundTaskPersistence.findByG_N_T(
381                            groupId, name, taskExecutorClassName, start, end,
382                            orderByComparator);
383            }
384    
385            @Override
386            public List<BackgroundTask> getBackgroundTasks(
387                    long groupId, String[] taskExecutorClassNames) {
388    
389                    return backgroundTaskPersistence.findByG_T(
390                            groupId, taskExecutorClassNames);
391            }
392    
393            @Override
394            public List<BackgroundTask> getBackgroundTasks(
395                    long groupId, String[] taskExecutorClassNames, int status) {
396    
397                    return backgroundTaskPersistence.findByG_T_S(
398                            groupId, taskExecutorClassNames, status);
399            }
400    
401            @Override
402            public List<BackgroundTask> getBackgroundTasks(
403                    long groupId, String[] taskExecutorClassNames, int start, int end,
404                    OrderByComparator<BackgroundTask> orderByComparator) {
405    
406                    return backgroundTaskPersistence.findByG_T(
407                            groupId, taskExecutorClassNames, start, end, orderByComparator);
408            }
409    
410            @Override
411            public List<BackgroundTask> getBackgroundTasks(
412                    String taskExecutorClassName, int status) {
413    
414                    return backgroundTaskPersistence.findByT_S(
415                            taskExecutorClassName, status);
416            }
417    
418            @Override
419            public List<BackgroundTask> getBackgroundTasks(
420                    String taskExecutorClassName, int status, int start, int end,
421                    OrderByComparator<BackgroundTask> orderByComparator) {
422    
423                    return backgroundTaskPersistence.findByT_S(
424                            taskExecutorClassName, status, start, end, orderByComparator);
425            }
426    
427            @Override
428            public List<BackgroundTask> getBackgroundTasks(
429                    String[] taskExecutorClassNames, int status) {
430    
431                    return backgroundTaskPersistence.findByT_S(
432                            taskExecutorClassNames, status);
433            }
434    
435            @Override
436            public List<BackgroundTask> getBackgroundTasks(
437                    String[] taskExecutorClassNames, int status, int start, int end,
438                    OrderByComparator<BackgroundTask> orderByComparator) {
439    
440                    return backgroundTaskPersistence.findByT_S(
441                            taskExecutorClassNames, status, start, end, orderByComparator);
442            }
443    
444            @Override
445            public int getBackgroundTasksCount(
446                    long groupId, String taskExecutorClassName) {
447    
448                    return backgroundTaskPersistence.countByG_T(
449                            groupId, taskExecutorClassName);
450            }
451    
452            @Override
453            public int getBackgroundTasksCount(
454                    long groupId, String taskExecutorClassName, boolean completed) {
455    
456                    return backgroundTaskPersistence.countByG_T_C(
457                            groupId, taskExecutorClassName, completed);
458            }
459    
460            @Override
461            public int getBackgroundTasksCount(
462                    long groupId, String name, String taskExecutorClassName) {
463    
464                    return backgroundTaskPersistence.countByG_N_T(
465                            groupId, name, taskExecutorClassName);
466            }
467    
468            @Override
469            public int getBackgroundTasksCount(
470                    long groupId, String name, String taskExecutorClassName,
471                    boolean completed) {
472    
473                    return backgroundTaskPersistence.countByG_N_T_C(
474                            groupId, name, taskExecutorClassName, completed);
475            }
476    
477            @Override
478            public int getBackgroundTasksCount(
479                    long groupId, String[] taskExecutorClassNames) {
480    
481                    return backgroundTaskPersistence.countByG_T(
482                            groupId, taskExecutorClassNames);
483            }
484    
485            @Override
486            public int getBackgroundTasksCount(
487                    long groupId, String[] taskExecutorClassNames, boolean completed) {
488    
489                    return backgroundTaskPersistence.countByG_T_C(
490                            groupId, taskExecutorClassNames, completed);
491            }
492    
493            @Clusterable(onMaster = true)
494            @Override
495            public String getBackgroundTaskStatusJSON(long backgroundTaskId) {
496                    BackgroundTaskStatus backgroundTaskStatus =
497                            _backgroundTaskStatusRegistry.getBackgroundTaskStatus(
498                                    backgroundTaskId);
499    
500                    if (backgroundTaskStatus != null) {
501                            return backgroundTaskStatus.getAttributesJSON();
502                    }
503    
504                    return StringPool.BLANK;
505            }
506    
507            @Clusterable(onMaster = true)
508            @Override
509            public void resumeBackgroundTask(long backgroundTaskId) {
510                    BackgroundTask backgroundTask =
511                            backgroundTaskPersistence.fetchByPrimaryKey(backgroundTaskId);
512    
513                    if ((backgroundTask == null) ||
514                            (backgroundTask.getStatus() !=
515                                    BackgroundTaskConstants.STATUS_QUEUED)) {
516    
517                            return;
518                    }
519    
520                    Message message = new Message();
521    
522                    message.put("backgroundTaskId", backgroundTaskId);
523    
524                    MessageBusUtil.sendMessage(DestinationNames.BACKGROUND_TASK, message);
525            }
526    
527            @Clusterable(onMaster = true)
528            @Override
529            public void triggerBackgroundTask(long backgroundTaskId) {
530                    Message message = new Message();
531    
532                    message.put("backgroundTaskId", backgroundTaskId);
533    
534                    MessageBusUtil.sendMessage(DestinationNames.BACKGROUND_TASK, message);
535            }
536    
537            @BeanReference(type = BackgroundTaskStatusRegistry.class)
538            private BackgroundTaskStatusRegistry _backgroundTaskStatusRegistry;
539    
540    }