0037055: Connection leak in threads that makes use of the read only pool and are not encapsulated inside DalThreadHandler

diff --git a/src/org/openbravo/dal/core/SessionHandler.java b/src/org/openbravo/dal/core/SessionHandler.java
--- a/src/org/openbravo/dal/core/SessionHandler.java
+++ b/src/org/openbravo/dal/core/SessionHandler.java
@@ -265,7 +265,7 @@
   }
 
   /** Commits all remaining sessions and closes them */
-  void cleanUpSessions() {
+  public void cleanUpSessions() {
     for (String pool : sessions.keySet()) {
       commitAndCloseNoCheck(pool);
     }
diff --git a/src/org/openbravo/service/db/DalBaseProcess.java b/src/org/openbravo/service/db/DalBaseProcess.java
--- a/src/org/openbravo/service/db/DalBaseProcess.java
+++ b/src/org/openbravo/service/db/DalBaseProcess.java
@@ -25,6 +25,7 @@
 import org.openbravo.base.secureApp.VariablesSecureApp;
 import org.openbravo.client.kernel.RequestContext;
 import org.openbravo.dal.core.OBContext;
+import org.openbravo.dal.core.SessionHandler;
 import org.openbravo.dal.service.OBDal;
 import org.openbravo.scheduling.Process;
 import org.openbravo.scheduling.ProcessBundle;
@@ -111,6 +112,12 @@
         }
       }
 
+      // if the default connection should be closed after process execution, then close also other
+      // opened connections (if any)
+      if (bundle.getCloseConnection() && SessionHandler.existsOpenedSessions()) {
+        SessionHandler.getInstance().cleanUpSessions();
+      }
+
       // remove the context at the end, maybe the process scheduler
       // reuses the thread?
       OBContext.setOBContext(currentOBContext);
diff --git a/src/org/openbravo/service/importprocess/ImportEntryProcessor.java b/src/org/openbravo/service/importprocess/ImportEntryProcessor.java
--- a/src/org/openbravo/service/importprocess/ImportEntryProcessor.java
+++ b/src/org/openbravo/service/importprocess/ImportEntryProcessor.java
@@ -243,8 +243,10 @@
    * <li>OBContexts are temporary cached in a {@link WeakHashMap}</li>
    * <li>the process checks the {@link ImportEntry} status just before it is processed, it also
    * prevents the same {@link ImportEntry} to be processed twice by one thread</li>
-   * <li>each {@link ImportEntry} is processed in its own connection and transaction. Note the
-   * process here does not commit a transaction, the implementing subclass must do that.</li>
+   * <li>each {@link ImportEntry} is processed in its own connection and transaction. Note that the
+   * class delegates into the implementing subclass the ability of handling the commit/rollback of
+   * the transaction. But in order to prevent possible connection leaks, this class closes all the
+   * opened connections (if any) before ending.</li>
    * <li>the process sets admin mode, before calling the subclass</li>
    * <li>an error which ends up in the main loop here is stored in the {@link ImportEntry} in the
    * errorInfo property</li>
@@ -393,14 +395,13 @@
             OBDal.getInstance().commitAndClose();
           }
 
-          // the import entry processEntry calls should not leave an open active session
+          // close sessions in case the import entry processEntry left them opened
           if (SessionHandler.isSessionHandlerPresent()) {
-            // change to warning if the code in the subclasses really works correctly
-            logger
-                .warn("Session handler present after processing import entry, this indicates that the processing code "
-                    + "does not correctly clean/close the session after its last actions. This should be fixed.");
             OBDal.getInstance().commitAndClose();
           }
+          if (SessionHandler.existsOpenedSessions()) {
+            SessionHandler.getInstance().cleanUpSessions();
+          }
 
         } catch (Throwable t) {
           ImportProcessUtils.logError(logger, t);