/ - Diff - EDIT - EDIT Project Management

     */
     package eu.etaxonomy.cdm.common.monitor;
     import java.io.Serializable;
     import java.util.List;
     /**
-...
          * Sets the result of the monitored job
          * @param result of the monitored job
          */
         public void setResult(Object result);
         public void setResult(Serializable result);
         /**
          * Returns the reports generated by the monitored job
-...
          */
         public void setOwner(String owner);
         public void setFeedback(Object feedback);
         /**
          * Sets the feedback object the monitor is currently waiting for.
+         *
          * @param feedback
          */
         public void setFeedback(Serializable feedback);
         /**
          * Returns the most recently set feedback object
+         *
          * @return most recently set feedback object
          */
         public Serializable getFeedback();
         /**
          * Boolean flag to indicate whether the monitor is
          * waiting for feedback
+         *
          * @return true if monitor is waiting for feedback, o/w false
          */
         public boolean isWaitingForFeedback();
+    }

     */
     package eu.etaxonomy.cdm.common.monitor;
     import java.io.Serializable;
     import java.util.ArrayList;
     import java.util.List;
-...
      */
     public class RemotingProgressMonitor extends RestServiceProgressMonitor implements IRemotingProgressMonitor {
         private Object result;
         private Serializable result;
         private List<String> reports = new ArrayList<String>();
         private String owner;
         private Object feedback;
         private Serializable feedback;
         private transient Object feedbackLock;
         private boolean isWaitingForFeedback = false;
-...
          * {@inheritDoc}
          */
         @Override
         public void setResult(Object result) {
         public void setResult(Serializable result) {
             this.result = result;
+        }
-...
+        }
         /**
          * {@inheritDoc}
          */
-...
          */
         @Override
         public void waitForFeedback() {
             synchronized (feedback) {
             if(feedbackLock == null) {
                 feedbackLock =  new Object();
+            }
             synchronized (feedbackLock) {
                 feedback = null;
                 while(feedback == null) {
                     isWaitingForFeedback = true;
                     try {
                         feedback.wait();
                         feedbackLock.wait();
                     } catch (InterruptedException ie) {
                         throw new IllegalStateException(ie);
+                    }
-...
+            }
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setFeedback(Object feedback) {
             synchronized (feedback) {
         public void setFeedback(Serializable feedback) {
             synchronized (feedbackLock) {
                 this.feedback = feedback;
                 this.feedback.notifyAll();
                 this.feedbackLock.notifyAll();
                 isWaitingForFeedback = false;
+              }
+            }
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public Serializable getFeedback() {
             return feedback;
+        }
         /**
-...
             return isWaitingForFeedback;
+        }
+    }

     import java.io.ByteArrayInputStream;
     import java.io.FileOutputStream;
     import java.io.IOException;
     import java.io.Serializable;
     import java.nio.file.Files;
     import java.nio.file.Path;
     import java.util.UUID;
-...
             final IRemotingProgressMonitor monitor = new RemotingProgressMonitor();
             RemotingProgressMonitorThread monitThread = new RemotingProgressMonitorThread(monitor) {
                 @Override
                 public Object doRun(IRemotingProgressMonitor monitor) {
                 public Serializable doRun(IRemotingProgressMonitor monitor) {
                     configurator.setProgressMonitor(monitor);
                     ImportResult result = importData(configurator, importData, type);
                     for(byte[] report : result.getReports()) {

     */
     package eu.etaxonomy.cdm.api.service;
     import java.io.Serializable;
     import java.util.UUID;
     import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
-...
          */
         public boolean isMonitorThreadRunning(UUID uuid);
         public void setFeedback(UUID uuid, Serializable feedback);
+    }

     */
     package eu.etaxonomy.cdm.api.service;
     import java.util.List;
     import java.util.UUID;
     import eu.etaxonomy.cdm.api.service.dto.CdmEntityIdentifier;
-...
          * @param monitor
          * @return
          */
         public String longRunningMethod(IRemotingProgressMonitor monitor, RuntimeException ex);
         public String longRunningMethod(IRemotingProgressMonitor monitor, RuntimeException ex, List<String> feedbacks);
         /**
          * @return
          */
         public UUID monitLongRunningMethod(RuntimeException ex);
         public UUID monitLongRunningMethod(RuntimeException ex, List<String> feedbacks);

     */
     package eu.etaxonomy.cdm.api.service;
     import java.io.Serializable;
     import java.util.UUID;
     import org.springframework.beans.factory.annotation.Autowired;
-...
+            }
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setFeedback(UUID uuid, Serializable feedback) {
             IRemotingProgressMonitor remotingMonitor = getRemotingMonitor(uuid);
             if(remotingMonitor != null) {
                 remotingMonitor.setFeedback(feedback);
+            }
+        }
+    }

     */
     package eu.etaxonomy.cdm.api.service;
     import java.io.Serializable;
     import java.util.List;
     import java.util.UUID;
     import org.apache.log4j.Logger;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.security.access.prepost.PreAuthorize;
     import org.springframework.stereotype.Service;
-...
     @Service
     public class TestServiceImpl implements ITestService {
         private static final Logger logger = Logger.getLogger(TestServiceImpl.class);
         @Autowired
         ITaxonNodeService taxonNodeService;
-...
         @Override
         public UUID monitLongRunningMethod(final RuntimeException ex) {
         public UUID monitLongRunningMethod(final RuntimeException ex, final List<String> feedbacks) {
             RemotingProgressMonitor monitor = new RemotingProgressMonitor();
             RemotingProgressMonitorThread monitThread = new RemotingProgressMonitorThread(monitor) {
                 @Override
                 public Object doRun(IRemotingProgressMonitor monitor)  {
                     Object result = longRunningMethod(monitor, ex);
                 public Serializable doRun(IRemotingProgressMonitor monitor)  {
                     Serializable result = longRunningMethod(monitor, ex, feedbacks);
                     if(!monitor.isCanceled()) {
                         monitor.addReport("Report");
+                    }
-...
+        }
         @Override
         public String longRunningMethod(IRemotingProgressMonitor monitor, RuntimeException ex) {
         public String longRunningMethod(IRemotingProgressMonitor monitor, RuntimeException ex, List<String> feedbacks) {
             int noOfSteps = 10;
             int stepToThrowException = noOfSteps / 2;
             int stepToWaitForFeedback = noOfSteps / 2;
             monitor.beginTask("Long Running Task", noOfSteps);
             for(int i=0; i<noOfSteps; i++) {
                 try {
-...
                     if(i == stepToThrowException && ex != null) {
                         throw ex;
+                    }
                     if(feedbacks != null && feedbacks.size() > 0 && i == stepToWaitForFeedback) {
                         for(String feedback : feedbacks) {
                             logger.warn("Monitor waiting for feedback");
                             monitor.waitForFeedback();
                             logger.warn(" .. feedback received : " + monitor.getFeedback());
                             monitor.addReport(feedback);
+                        }
+                    }
                     if(monitor.isCanceled()) {
                         return "Cancelled";
+                    }

     */
     package eu.etaxonomy.cdm.api.service.util;
     import java.io.Serializable;
     import java.util.concurrent.ConcurrentHashMap;
     import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
-...
          * @param monitor to be updated by the monitored job
          * @return result object
          */
         public abstract Object doRun(IRemotingProgressMonitor monitor);
         public abstract Serializable doRun(IRemotingProgressMonitor monitor);
         /**
          * Returns a currently running monitor thread corresponding to the

Project

General

Profile

EDIT

Revision eeedb131

Added by Cherian Mathew over 8 years ago