cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/longrunningService/LongRunningTasksService.java

   1 /**
   2  * Copyright (C) 2015 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9 package eu.etaxonomy.cdm.api.service.longrunningService;
  10
  11 import java.io.Serializable;
  12 import java.util.Collection;
  13 import java.util.Set;
  14 import java.util.UUID;
  15
  16 import org.springframework.beans.factory.annotation.Autowired;
  17 import org.springframework.beans.factory.annotation.Qualifier;
  18 import org.springframework.stereotype.Service;
  19 import org.springframework.transaction.annotation.Transactional;
  20
  21 import eu.etaxonomy.cdm.api.application.ICdmRepository;
  22 import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;
  23 import eu.etaxonomy.cdm.api.service.IProgressMonitorService;
  24 import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
  25 import eu.etaxonomy.cdm.api.service.UpdateResult;
  26 import eu.etaxonomy.cdm.api.service.config.CacheUpdaterConfigurator;
  27 import eu.etaxonomy.cdm.api.service.config.DeleteDescriptiveDataSetConfigurator;
  28 import eu.etaxonomy.cdm.api.service.config.ForSubtreeConfiguratorBase;
  29 import eu.etaxonomy.cdm.api.service.config.PublishForSubtreeConfigurator;
  30 import eu.etaxonomy.cdm.api.service.config.SecundumForSubtreeConfigurator;
  31 import eu.etaxonomy.cdm.api.service.config.SortIndexUpdaterConfigurator;
  32 import eu.etaxonomy.cdm.api.service.description.DescriptionAggregationBase;
  33 import eu.etaxonomy.cdm.api.service.description.DescriptionAggregationConfigurationBase;
  34 import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;
  35 import eu.etaxonomy.cdm.common.JvmLimitsException;
  36 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
  37 import eu.etaxonomy.cdm.common.monitor.RemotingProgressMonitorThread;
  38
  39 /**
  40  * @author k.luther
  41  * @since 04 May 2018
  42  */
  43 @Service("longRunningTasksService")
  44 @Transactional(readOnly = false)
  45 public class LongRunningTasksService implements ILongRunningTasksService{
  46
  47     @Autowired
  48     private ITaxonNodeService taxonNodeService;
  49
  50     @Autowired
  51     private IDescriptiveDataSetService descriptiveDataSetService;
  52
  53     @Autowired
  54     private IProgressMonitorService progressMonitorService;
  55
  56     @Autowired
  57     private CacheUpdater updater;
  58
  59     @Autowired
  60     private SortIndexUpdaterWrapper sortIndexUpdater;
  61
  62     @Autowired
  63     @Qualifier("cdmRepository")
  64     private ICdmRepository repository;
  65
  66     @Override
  67     public UUID monitGetRowWrapper(UUID descriptiveDataSetUuid) {
  68         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
  69             @Override
  70             public Serializable doRun(IRemotingProgressMonitor monitor) {
  71                 return descriptiveDataSetService.getRowWrapper(descriptiveDataSetUuid, monitor);
  72             }
  73         };
  74         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
  75         monitorThread.setPriority(3);
  76         monitorThread.start();
  77         return uuid;
  78     }
  79
  80
  81     @Override
  82     public <T extends DescriptionAggregationBase<T,C>, C extends DescriptionAggregationConfigurationBase<T>>
  83                 UUID invoke(C config){
  84
  85         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
  86             @Override
  87             public Serializable doRun(IRemotingProgressMonitor monitor) {
  88                 T task = config.getTaskInstance();
  89                 UpdateResult updateResult = null;
  90                 try{
  91                     updateResult = task.invoke(config, repository);
  92                     for(Exception e : updateResult.getExceptions()) {
  93                         monitor.addReport(e.getMessage());
  94                     }
  95                 } catch (JvmLimitsException e) {
  96                     monitor.warning("Memory problem. Java Virtual Machine limits exceeded. Task was interrupted", e);
  97                 }
  98                 monitor.setResult(updateResult);
  99                 return updateResult;
 100
 101             }
 102         };
 103         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 104         monitorThread.setPriority(2);
 105         monitorThread.start();
 106         return uuid;
 107     }
 108
 109
 110     @Override
 111     public UUID addRowWrapperToDataset(Collection<SpecimenRowWrapperDTO> wrapper, UUID datasetUuid){
 112         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 113             @Override
 114             public Serializable doRun(IRemotingProgressMonitor monitor) {
 115                 UpdateResult updateResult = descriptiveDataSetService.addRowWrapperToDataset(wrapper, datasetUuid);
 116                 for(Exception e : updateResult.getExceptions()) {
 117                     monitor.addReport(e.getMessage());
 118                 }
 119                 monitor.setResult(updateResult);
 120                 return updateResult;
 121             }
 122         };
 123         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 124         monitorThread.setPriority(2);
 125         monitorThread.start();
 126         return uuid;
 127     }
 128
 129     @Override
 130     public UUID generatePolytomousKey(UUID datasetUuid, UUID taxonUuid){
 131         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 132             @Override
 133             public Serializable doRun(IRemotingProgressMonitor monitor) {
 134                 UpdateResult updateResult = descriptiveDataSetService.generatePolytomousKey(datasetUuid, taxonUuid);
 135                 for(Exception e : updateResult.getExceptions()) {
 136                     monitor.addReport(e.getMessage());
 137                 }
 138                 monitor.setResult(updateResult);
 139                 return updateResult;
 140
 141             }
 142         };
 143         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 144         monitorThread.setPriority(2);
 145         monitorThread.start();
 146         return uuid;
 147     }
 148
 149     @Override
 150     public UUID deleteDescriptiveDataset(UUID datasetUuid, DeleteDescriptiveDataSetConfigurator config){
 151         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 152             @Override
 153             public Serializable doRun(IRemotingProgressMonitor monitor) {
 154                 UpdateResult updateResult = descriptiveDataSetService.delete(datasetUuid, config, monitor);
 155                 for(Exception e : updateResult.getExceptions()) {
 156                     monitor.addReport(e.getMessage());
 157                 }
 158                 monitor.setResult(updateResult);
 159                 return updateResult;
 160
 161             }
 162         };
 163         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 164         monitorThread.setPriority(2);
 165         monitorThread.start();
 166         return uuid;
 167     }
 168
 169     @Override
 170     public UUID monitLongRunningTask(ForSubtreeConfiguratorBase config) {
 171
 172         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 173             @Override
 174             public Serializable doRun(IRemotingProgressMonitor monitor) {
 175                 config.setMonitor(monitor);
 176
 177                 UpdateResult result = updateData(config);
 178                 for(Exception e : result.getExceptions()) {
 179                     monitor.addReport(e.getMessage());
 180                 }
 181                 monitor.setResult(result);
 182                 return result;
 183             }
 184         };
 185         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 186         monitorThread.setPriority(2);
 187         monitorThread.start();
 188         return uuid;
 189     }
 190
 191     private UpdateResult updateData(ForSubtreeConfiguratorBase config){
 192         if (config instanceof SecundumForSubtreeConfigurator){
 193             return taxonNodeService.setSecundumForSubtree((SecundumForSubtreeConfigurator)config);
 194         }else{
 195             return taxonNodeService.setPublishForSubtree((PublishForSubtreeConfigurator) config);
 196         }
 197     }
 198
 199     @Override
 200     public UUID monitLongRunningTask(Set<UUID> movingUuids, UUID targetTreeNodeUuid, int movingType) {
 201
 202         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 203             @Override
 204             public Serializable doRun(IRemotingProgressMonitor remotingMonitor) {
 205                 UpdateResult result;
 206
 207                 result = taxonNodeService.moveTaxonNodes(movingUuids,targetTreeNodeUuid, movingType,  remotingMonitor);
 208                 for(Exception e : result.getExceptions()) {
 209                     remotingMonitor.addReport(e.getMessage());
 210                 }
 211                 remotingMonitor.setResult(result);
 212                 return result;
 213             }
 214         };
 215         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 216         monitorThread.setPriority(2);
 217         monitorThread.start();
 218         return uuid;
 219     }
 220
 221     @Override
 222     public UUID monitLongRunningTask(CacheUpdaterConfigurator configurator) {
 223         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 224             @Override
 225             public Serializable doRun(IRemotingProgressMonitor monitor) {
 226                 UpdateResult result;
 227
 228                 configurator.setMonitor(monitor);
 229
 230                 result = updater.doInvoke(configurator);
 231
 232                 for(Exception e : result.getExceptions()) {
 233                     monitor.addReport(e.getMessage());
 234                 }
 235                 monitor.setResult(result);
 236                 return result;
 237             }
 238         };
 239         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 240         monitorThread.setPriority(2);
 241         monitorThread.start();
 242         return uuid;
 243     }
 244
 245     @Override
 246     public UUID monitLongRunningTask(SortIndexUpdaterConfigurator configurator) {
 247         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 248             @Override
 249             public Serializable doRun(IRemotingProgressMonitor monitor) {
 250
 251                 configurator.setMonitor(monitor);
 252                 UpdateResult result = sortIndexUpdater.doInvoke(configurator);
 253
 254                 for(Exception e : result.getExceptions()) {
 255                     monitor.addReport(e.getMessage());
 256                 }
 257                 monitor.setResult(result);
 258                 return result;
 259             }
 260         };
 261         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 262         monitorThread.setPriority(2);
 263         monitorThread.start();
 264         return uuid;
 265     }
 266 }