cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ProgressMonitorManager.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;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.UUID;
  16 import java.util.concurrent.ConcurrentHashMap;
  17
  18 import org.springframework.stereotype.Component;
  19
  20 import eu.etaxonomy.cdm.common.monitor.IRestServiceProgressMonitor;
  21
  22 /**
  23  * Manages monitors for long running jobs.
  24  *
  25  * @author cmathew
  26  * @date 14 Oct 2015
  27  *
  28  */
  29 @Component
  30 public class ProgressMonitorManager<T extends IRestServiceProgressMonitor> {
  31
  32     private final Map<UUID, T> monitors = new ConcurrentHashMap<UUID, T>();
  33
  34     private final Map<UUID, Long> timeoutMap = new HashMap<UUID, Long>();
  35
  36     private Thread cleanUpThread = null;
  37
  38     /**
  39      * Time out in minutes for monitors which are done.
  40      * A monitor which is set done will be removed after this interval.
  41      */
  42     private final int cleanUpTimeout = 1;
  43
  44     /**
  45      *
  46      */
  47     private final int cleanUpInterval = 1000 * 10; // 10 seconds
  48
  49     public ProgressMonitorManager() {
  50
  51         this.cleanUpThread = new Thread(){
  52
  53             @Override
  54             public void run() {
  55                 while(true){
  56                     scheduledCleanUp();
  57                     try {
  58                         sleep(cleanUpInterval);
  59                     } catch (InterruptedException e) {
  60                         /* IGNORE */
  61                     }
  62                 }
  63             }
  64
  65         };
  66         cleanUpThread.start();
  67     }
  68
  69     /**
  70      * run every n minutes clean up monitors which have been marked done x minutes ago
  71      */
  72     private void scheduledCleanUp() {
  73
  74         List<UUID> timedOutMonitors = new ArrayList<UUID>();
  75         IRestServiceProgressMonitor monitor;
  76
  77         long now = System.currentTimeMillis();
  78         long nextTimeout = now + cleanUpTimeout * 1000 * 60;
  79
  80
  81         // add monitors which are stopped or done to the timeoutMap
  82         for(UUID uuid : monitors.keySet()){
  83             monitor = monitors.get(uuid);
  84             if((monitor.isFailed() || monitor.isDone())){
  85                 if(!timeoutMap.containsKey(uuid)){
  86                     timeoutMap.put(uuid, nextTimeout);
  87                 }
  88             }
  89             if(monitor.hasFeedbackWaitTimedOut()) {
  90                 monitor.interrupt();
  91             }
  92         }
  93
  94         // check with monitor has timed out
  95         for(UUID uuid : timeoutMap.keySet()){
  96             if(timeoutMap.get(uuid) <= now){
  97                 timedOutMonitors.add(uuid);
  98             }
  99         }
 100
 101         //finally remove the monitors
 102         for(UUID uuid : timedOutMonitors){
 103             timeoutMap.remove(uuid);
 104             monitors.remove(uuid);
 105         }
 106
 107     }
 108
 109     public UUID registerMonitor(T monitor){
 110         UUID uuid = UUID.randomUUID();
 111         monitors.put(uuid, monitor);
 112         return uuid;
 113     }
 114
 115     public IRestServiceProgressMonitor getMonitor(UUID uuid) {
 116         if(uuid == null) {
 117             return null;
 118         }
 119         return monitors.get(uuid);
 120     }
 121
 122     /**
 123      * returns true if the {@link IRestServiceProgressMonitor} identified by the <code>uuid</code>
 124      * exists and if it is still indicating a running thread
 125      * @param uuid
 126      * @return
 127      */
 128     public boolean isMonitorRunning(UUID uuid) {
 129         IRestServiceProgressMonitor monitor = getMonitor(uuid);
 130         return monitor != null && !monitor.isCanceled() && !monitor.isDone() && !monitor.isFailed();
 131     }
 132
 133     public Map<UUID, T> getMonitors() {
 134         return monitors;
 135     }
 136
 137 }