001
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
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 }