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 import eu.etaxonomy.cdm.model.metadata.SecReferenceHandlingEnum;
  39
  40 /**
  41  * @author k.luther
  42  * @since 04 May 2018
  43  */
  44 @Service("longRunningTasksService")
  45 @Transactional(readOnly = false)
  46 public class LongRunningTasksService implements ILongRunningTasksService{
  47
  48     @Autowired
  49     private ITaxonNodeService taxonNodeService;
  50
  51     @Autowired
  52     private IDescriptiveDataSetService descriptiveDataSetService;
  53
  54     @Autowired
  55     private IProgressMonitorService progressMonitorService;
  56
  57     @Autowired
  58     private CacheUpdater updater;
  59
  60     @Autowired
  61     private SortIndexUpdaterWrapper sortIndexUpdater;
  62
  63     @Autowired
  64     @Qualifier("cdmRepository")
  65     private ICdmRepository repository;
  66
  67     @Override
  68     public UUID monitGetRowWrapper(UUID descriptiveDataSetUuid) {
  69         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
  70             @Override
  71             public Serializable doRun(IRemotingProgressMonitor monitor) {
  72                 return (Serializable)descriptiveDataSetService.getRowWrapper(descriptiveDataSetUuid, monitor);
  73             }
  74         };
  75         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
  76         monitorThread.setPriority(3);
  77         monitorThread.start();
  78         return uuid;
  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                     String warning = "Memory problem. Java Virtual Machine limits exceeded. Task was interrupted";
  97                     monitor.warning(warning, e);
  98                     monitor.addReport(warning);
  99                 }
 100                 monitor.setResult(updateResult);
 101                 return updateResult;
 102
 103             }
 104         };
 105         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 106         monitorThread.setPriority(2);
 107         monitorThread.start();
 108         return uuid;
 109     }
 110
 111     @Override
 112     public UUID addRowWrapperToDataset(Collection<SpecimenRowWrapperDTO> wrapper, UUID datasetUuid){
 113         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 114             @Override
 115             public Serializable doRun(IRemotingProgressMonitor monitor) {
 116                 UpdateResult updateResult = descriptiveDataSetService.addRowWrapperToDataset(wrapper, datasetUuid);
 117                 for(Exception e : updateResult.getExceptions()) {
 118                     monitor.addReport(e.getMessage());
 119                 }
 120                 monitor.setResult(updateResult);
 121                 return updateResult;
 122             }
 123         };
 124         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 125         monitorThread.setPriority(2);
 126         monitorThread.start();
 127         return uuid;
 128     }
 129
 130     @Override
 131     public UUID generatePolytomousKey(UUID datasetUuid, UUID taxonUuid){
 132         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 133             @Override
 134             public Serializable doRun(IRemotingProgressMonitor monitor) {
 135                 UpdateResult updateResult = descriptiveDataSetService.generatePolytomousKey(datasetUuid, taxonUuid);
 136                 for(Exception e : updateResult.getExceptions()) {
 137                     monitor.addReport(e.getMessage());
 138                 }
 139                 monitor.setResult(updateResult);
 140                 return updateResult;
 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         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 163         monitorThread.setPriority(2);
 164         monitorThread.start();
 165         return uuid;
 166     }
 167
 168     @Override
 169     public UUID monitLongRunningTask(ForSubtreeConfiguratorBase config) {
 170
 171         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 172             @Override
 173             public Serializable doRun(IRemotingProgressMonitor monitor) {
 174                 config.setMonitor(monitor);
 175
 176                 UpdateResult result = updateData(config);
 177                 for(Exception e : result.getExceptions()) {
 178                     monitor.addReport(e.getMessage());
 179                 }
 180                 monitor.setResult(result);
 181                 return result;
 182             }
 183         };
 184         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 185         monitorThread.setPriority(2);
 186         monitorThread.start();
 187         return uuid;
 188     }
 189
 190     private UpdateResult updateData(ForSubtreeConfiguratorBase config){
 191         if (config instanceof SecundumForSubtreeConfigurator){
 192             return taxonNodeService.setSecundumForSubtree((SecundumForSubtreeConfigurator)config);
 193         }else{
 194             return taxonNodeService.setPublishForSubtree((PublishForSubtreeConfigurator) config);
 195         }
 196     }
 197
 198     @Override
 199     public UUID monitLongRunningTask(Set<UUID> movingUuids, UUID targetTreeNodeUuid, int movingType, SecReferenceHandlingEnum secHandling, UUID secUuid) {
 200
 201         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 202             @Override
 203             public Serializable doRun(IRemotingProgressMonitor remotingMonitor) {
 204                 UpdateResult result;
 205
 206                 result = taxonNodeService.moveTaxonNodes(movingUuids,targetTreeNodeUuid, movingType, secHandling, secUuid, remotingMonitor);
 207                 for(Exception e : result.getExceptions()) {
 208                     remotingMonitor.addReport(e.getMessage());
 209                 }
 210                 remotingMonitor.setResult(result);
 211                 return result;
 212             }
 213         };
 214         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 215         monitorThread.setPriority(2);
 216         monitorThread.start();
 217         return uuid;
 218     }
 219
 220     @Override
 221     public UUID monitLongRunningTask(CacheUpdaterConfigurator configurator) {
 222         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 223             @Override
 224             public Serializable doRun(IRemotingProgressMonitor monitor) {
 225                 UpdateResult result;
 226
 227                 configurator.setMonitor(monitor);
 228
 229                 result = updater.doInvoke(configurator);
 230
 231                 for(Exception e : result.getExceptions()) {
 232                     monitor.addReport(e.getMessage());
 233                 }
 234                 monitor.setResult(result);
 235                 return result;
 236             }
 237         };
 238         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 239         monitorThread.setPriority(2);
 240         monitorThread.start();
 241         return uuid;
 242     }
 243
 244     @Override
 245     public UUID monitLongRunningTask(SortIndexUpdaterConfigurator configurator) {
 246         RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {
 247             @Override
 248             public Serializable doRun(IRemotingProgressMonitor monitor) {
 249
 250                 configurator.setMonitor(monitor);
 251                 UpdateResult result = sortIndexUpdater.doInvoke(configurator);
 252
 253                 for(Exception e : result.getExceptions()) {
 254                     monitor.addReport(e.getMessage());
 255                 }
 256                 monitor.setResult(result);
 257                 return result;
 258             }
 259         };
 260         UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);
 261         monitorThread.setPriority(2);
 262         monitorThread.start();
 263         return uuid;
 264     }
 265 }