Improve logging and project structure

git-svn-id: https://svn.argeo.org/slc/trunk@1706 4cfe0d0a-d680-48aa-b62c-e0a02a3f76cc

diff --git a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServer.java b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServer.java
index 76828b5bcf0a9653fe32bebac368a1e7f19fdae2..ec5f3c50623a06620e38b3fbbe5f0c6f2d1b5845 100644 (file)
--- a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServer.java
+++ b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServer.java
@@ -1,5 +1,5 @@
 package org.argeo.slc.detached;
 
 public interface DetachedExecutionServer {
-       public DetachedAnswer executeStep(DetachedRequest request);
+       public DetachedAnswer executeRequest(DetachedRequest request);
 }

diff --git a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServerImpl.java b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServerImpl.java
index 5d168675c9a766cb888b1c2e84d146573cf3f9c6..718809ec01689017332d5767ad5d67f6a2b924e2 100644 (file)
--- a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServerImpl.java
+++ b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/DetachedExecutionServerImpl.java
@@ -20,23 +20,16 @@ public class DetachedExecutionServerImpl implements DetachedExecutionServer {
        private int skipCount = 0;
 
        private BundleContext bundleContext;
-       //private DetachedDriver driver;
-
-       //private boolean active = false;
-
-//     public void setDriver(DetachedDriver driver) {
-//             this.driver = driver;
-//     }
 
        public DetachedExecutionServerImpl() {
                detachedContext = new DetachedContextImpl();
                sessions = new Vector();
        }
 
-       public synchronized DetachedAnswer executeStep(DetachedRequest request) {
+       public synchronized DetachedAnswer executeRequest(DetachedRequest request) {
                DetachedAnswer answer = null;
                try {
-                       DetachedStep step = null;
+                       // DetachedStep step = null;
 
                        // Find action
                        ServiceReference[] refs = bundleContext.getAllServiceReferences(
@@ -57,77 +50,21 @@ public class DetachedExecutionServerImpl implements DetachedExecutionServer {
 
                        // Execute actions
                        if (obj instanceof DetachedStep) {
-                               if (getCurrentSession() == null)
-                                       throw new DetachedException("No open session.");
-
-                               StringBuffer skippedLog = new StringBuffer();
-                               boolean execute = true;
-                               if (getPreviousSession() != null
-                                               && !getPreviousSession().isClosed()) {
-                                       if (getCurrentSession().getDoItAgainPolicy().equals(
-                                                       DetachedSession.SKIP_UNTIL_ERROR)) {
-                                               // Skip execution of already successful steps
-                                               if (getPreviousSession().getAnswers().size() > skipCount) {
-                                                       DetachedAnswer previousAnswer = (DetachedAnswer) getPreviousSession()
-                                                                       .getAnswers().get(skipCount);
-                                                       DetachedRequest previousRequest = (DetachedRequest) getPreviousSession()
-                                                                       .getRequests().get(skipCount);
-                                                       // Check paths
-                                                       if (!previousRequest.getPath().equals(
-                                                                       request.getPath())) {
-                                                               String msg = "New request is not consistent with previous path. previousPath="
-                                                                               + previousRequest.getPath()
-                                                                               + ", newPath="
-                                                                               + request.getPath()
-                                                                               + "\n";
-                                                               skippedLog.append(msg);
-                                                               log.warn(msg);
-                                                       }
-
-                                                       if (previousAnswer.getStatus() != DetachedAnswer.ERROR) {
-                                                               execute = false;
-                                                       }
-                                               } else {
-                                                       // went further as skip count, doing nothing.
-                                               }
-                                       }
-                               }
-
-                               if (execute) {
-                                       step = (DetachedStep) obj;
-                                       answer = step.execute(detachedContext, request);
-                               } else {
-                                       skippedLog.append("Skipped path " + request.getPath()
-                                                       + " (skipCount=" + skipCount + ")");
-                                       answer = new DetachedAnswer(request);
-                                       answer.setStatus(DetachedAnswer.SKIPPED);
-                                       answer.setLog(skippedLog.toString());
-                               }
+                               answer = processStep((DetachedStep) obj, request);
 
                        } else if (obj instanceof DetachedAdminCommand) {
-                               if (obj instanceof OpenSession) {
-                                       if (getCurrentSession() != null)
-                                               throw new DetachedException(
-                                                               "There is already an open session #"
-                                                                               + getCurrentSession().getUuid());
-                                       sessions.add(((OpenSession) obj).execute(request,
-                                                       bundleContext));
-                                       answer = new DetachedAnswer(request, "Session #"
-                                                       + getCurrentSession().getUuid() + " open.");
-                               } else if (obj instanceof CloseSession) {
-                                       if (getCurrentSession() == null)
-                                               throw new DetachedException(
-                                                               "There is no open session to close");
-                                       answer = new DetachedAnswer(request, "Session #"
-                                                       + getCurrentSession().getUuid() + " closed.");
-                                       answer.setStatus(DetachedAnswer.CLOSED_SESSION);
-                               }
+                               answer = processAdminCommand((DetachedAdminCommand) obj,
+                                               request);
                        }
 
-                       if (answer == null)
+                       if (answer == null) {
                                throw new DetachedException("Unknown action type "
                                                + obj.getClass() + " for action with ref "
                                                + request.getRef());
+                       } else {
+                               log.info("Processed '" + request.getRef() + "' (path="
+                                               + request.getPath() + ")");
+                       }
 
                } catch (DetachedException e) {
                        answer = new DetachedAnswer(request);
@@ -144,6 +81,78 @@ public class DetachedExecutionServerImpl implements DetachedExecutionServer {
                return answer;
        }
 
+       protected DetachedAnswer processStep(DetachedStep obj,
+                       DetachedRequest request) {
+               DetachedAnswer answer;
+               if (getCurrentSession() == null)
+                       throw new DetachedException("No open session.");
+
+               StringBuffer skippedLog = new StringBuffer();
+               boolean execute = true;
+               if (getPreviousSession() != null && !getPreviousSession().isClosed()) {
+                       if (getCurrentSession().getDoItAgainPolicy().equals(
+                                       DetachedSession.SKIP_UNTIL_ERROR)) {
+                               // Skip execution of already successful steps
+                               if (getPreviousSession().getAnswers().size() > skipCount) {
+                                       DetachedAnswer previousAnswer = (DetachedAnswer) getPreviousSession()
+                                                       .getAnswers().get(skipCount);
+                                       DetachedRequest previousRequest = (DetachedRequest) getPreviousSession()
+                                                       .getRequests().get(skipCount);
+                                       // Check paths
+                                       if (!previousRequest.getPath().equals(request.getPath())) {
+                                               String msg = "New request is not consistent with previous path. previousPath="
+                                                               + previousRequest.getPath()
+                                                               + ", newPath="
+                                                               + request.getPath() + "\n";
+                                               skippedLog.append(msg);
+                                               log.warn(msg);
+                                       }
+
+                                       if (previousAnswer.getStatus() != DetachedAnswer.ERROR) {
+                                               execute = false;
+                                       }
+                               } else {
+                                       // went further as skip count, doing nothing.
+                               }
+                       }
+               }
+
+               if (execute) {
+                       DetachedStep step = (DetachedStep) obj;
+                       answer = step.execute(detachedContext, request);
+               } else {
+                       skippedLog.append("Skipped path " + request.getPath()
+                                       + " (skipCount=" + skipCount + ")");
+                       answer = new DetachedAnswer(request);
+                       answer.setStatus(DetachedAnswer.SKIPPED);
+                       answer.setLog(skippedLog.toString());
+               }
+               return answer;
+       }
+
+       protected DetachedAnswer processAdminCommand(DetachedAdminCommand obj,
+                       DetachedRequest request) {
+               DetachedAnswer answer;
+               if (obj instanceof OpenSession) {
+                       if (getCurrentSession() != null)
+                               throw new DetachedException(
+                                               "There is already an open session #"
+                                                               + getCurrentSession().getUuid());
+                       sessions.add(((OpenSession) obj).execute(request, bundleContext));
+                       answer = new DetachedAnswer(request, "Session #"
+                                       + getCurrentSession().getUuid() + " open.");
+               } else if (obj instanceof CloseSession) {
+                       if (getCurrentSession() == null)
+                               throw new DetachedException("There is no open session to close");
+                       answer = new DetachedAnswer(request, "Session #"
+                                       + getCurrentSession().getUuid() + " closed.");
+                       answer.setStatus(DetachedAnswer.CLOSED_SESSION);
+               } else {
+                       answer = null;
+               }
+               return answer;
+       }
+
        protected final DetachedSession getCurrentSession() {
                if (sessions.size() == 0) {
                        return null;
@@ -171,28 +180,6 @@ public class DetachedExecutionServerImpl implements DetachedExecutionServer {
 
        public void init(BundleContext bundleContext) {
                this.bundleContext = bundleContext;
-//             Thread driverThread = new Thread(new Runnable() {
-//
-//                     public void run() {
-//                             while (active) {
-//                                     try {
-//                                             DetachedRequest request = driver.receiveRequest();
-//                                             DetachedAnswer answer = executeStep(request);
-//                                             driver.sendAnswer(answer);
-//                                     } catch (Exception e) {
-//                                             if (e instanceof RuntimeException)
-//                                                     throw (RuntimeException) e;
-//                                             else
-//                                                     e.printStackTrace();
-//                                     }
-//                             }
-//
-//                     }
-//             }, "driverThread");
-//
-//             active = true;
-//
-//             driverThread.start();
        }
 
 }

diff --git a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/AbstractDriver.java b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/AbstractDriver.java
index 8ba2de1fad18f60c25ef24d673c6eebcd483106d..846e0cc033a868604e9a6200c32a1922789a2af9 100644 (file)
--- a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/AbstractDriver.java
+++ b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/AbstractDriver.java
@@ -9,6 +9,7 @@ import org.argeo.slc.detached.DetachedXmlConverter;
 public abstract class AbstractDriver implements DetachedDriver {
        private boolean active = true;
        private DetachedExecutionServer executionServer = null;
+       private long receiveAnswerTimeout = 10000l;
 
        private DetachedXmlConverter xmlConverter = null;
 
@@ -23,7 +24,7 @@ public abstract class AbstractDriver implements DetachedDriver {
                                                if (!active)
                                                        break;
                                                DetachedAnswer answer = executionServer
-                                                               .executeStep(request);
+                                                               .executeRequest(request);
                                                sendAnswer(answer);
                                        } catch (Exception e) {
                                                if (e instanceof RuntimeException)
@@ -64,4 +65,12 @@ public abstract class AbstractDriver implements DetachedDriver {
                this.xmlConverter = xmlConverter;
        }
 
+       public long getReceiveAnswerTimeout() {
+               return receiveAnswerTimeout;
+       }
+
+       public void setReceiveAnswerTimeout(long reveiveTimeout) {
+               this.receiveAnswerTimeout = reveiveTimeout;
+       }
+
 }

diff --git a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/FileDriver.java b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/FileDriver.java
index 5b47e32d64ec5d7eceede9d23a0d7fed4f74d218..2c6429ded5ec9da0ded40a2b96bc1c2b884936e7 100644 (file)
--- a/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/FileDriver.java
+++ b/org.argeo.slc.detached/src/main/java/org/argeo/slc/detached/drivers/FileDriver.java
@@ -41,32 +41,36 @@ public class FileDriver extends AbstractDriver implements DetachedClient,
 
        public synchronized DetachedRequest receiveRequest() throws Exception {
                DetachedRequest request = (DetachedRequest) receiveFile(requestsDir,
-                               processedRequestsDir);
+                               processedRequestsDir, 0);
                if (request != null)
-                       log.debug("Received detached request #" + request.getUuid()
-                                       + " for ref '" + request.getRef() + "', path="
-                                       + request.getPath());
+                       if (log.isTraceEnabled())
+                               log.trace("Received detached request #" + request.getUuid()
+                                               + " for ref '" + request.getRef() + "', path="
+                                               + request.getPath());
                return request;
        }
 
        public void sendAnswer(DetachedAnswer answer) throws Exception {
                sendFile(answersDir, answer);
-               log.debug("Sent     detached answer  #" + answer.getUuid());
+               if (log.isTraceEnabled())
+                       log.trace("Sent     detached answer  #" + answer.getUuid());
        }
 
        public DetachedAnswer receiveAnswer() throws Exception {
                DetachedAnswer answer = (DetachedAnswer) receiveFile(answersDir,
-                               processedAnswersDir);
+                               processedAnswersDir, getReceiveAnswerTimeout());
                if (answer != null)
-                       log.debug("Received detached answer  #" + answer.getUuid());
+                       if (log.isTraceEnabled())
+                               log.trace("Received detached answer  #" + answer.getUuid());
                return answer;
        }
 
        public void sendRequest(DetachedRequest request) throws Exception {
                sendFile(requestsDir, request);
-               log.debug("Sent     detached request #" + request.getUuid()
-                               + " for ref '" + request.getRef() + "', path="
-                               + request.getPath());
+               if (log.isTraceEnabled())
+                       log.trace("Sent     detached request #" + request.getUuid()
+                                       + " for ref '" + request.getRef() + "', path="
+                                       + request.getPath());
        }
 
        protected void sendFile(File dir, DetachedCommunication detCom)
@@ -99,8 +103,13 @@ public class FileDriver extends AbstractDriver implements DetachedClient,
                lockFile.delete();
        }
 
+       /**
+        * @param timeout
+        *            in ms, 0 is no timeout
+        */
        protected synchronized DetachedCommunication receiveFile(File dir,
-                       File processedDir) throws Exception {
+                       File processedDir, long timeout) throws Exception {
+               long begin = System.currentTimeMillis();
                File file = null;
                while (file == null && isActive()) {
                        if (!dir.exists())
@@ -116,6 +125,12 @@ public class FileDriver extends AbstractDriver implements DetachedClient,
                                        // silent
                                }
                        }
+
+                       long duration = System.currentTimeMillis() - begin;
+                       if (timeout != 0 && duration > timeout) {
+                               throw new DetachedException("Receive file timed out after "
+                                               + duration + "ms.");
+                       }
                }
 
                if (!isActive())
@@ -149,9 +164,6 @@ public class FileDriver extends AbstractDriver implements DetachedClient,
                }
                // Move to processed dir
                FileUtils.moveFileToDirectory(file, processedDir, false);
-               // file.renameTo(new File(processedDir.getAbsolutePath() +
-               // File.separator
-               // + file.getName()));
                return detCom;
        }