jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ju...@apache.org
Subject svn commit: r995004 - /jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java
Date Wed, 08 Sep 2010 12:07:46 GMT
Author: jukka
Date: Wed Sep  8 12:07:46 2010
New Revision: 995004

URL: http://svn.apache.org/viewvc?rev=995004&view=rev
Log:
JCR-2741: Improved logging for session operations

Restructure the SessionState code for more consistent handling and logging of operations.

Modified:
    jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java

Modified: jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java?rev=995004&r1=995003&r2=995004&view=diff
==============================================================================
--- jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java
(original)
+++ jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/session/SessionState.java
Wed Sep  8 12:07:46 2010
@@ -109,7 +109,7 @@ public class SessionState {
         if (!isAlive()) {
             throw new RepositoryException(
                     "This session has been closed. See the chained exception"
-                    + " for a trace of where the session was closed", closed);
+                    + " for a trace of where the session was closed.", closed);
         }
     }
 
@@ -123,23 +123,99 @@ public class SessionState {
      */
     public <T> T perform(SessionOperation<T> operation)
             throws RepositoryException {
-        LogState state = new LogState(
+        // Set MDC variables to reflect the current session and this operation
+        LogState logState = new LogState(
                 "jcr.session", context.toString(),
                 "jcr.operation", operation.toString());
         try {
-            if (log.isDebugEnabled()) {
-                long start = System.nanoTime();
+            // Acquire the exclusive lock for accessing session internals.
+            // No other session should be holding the lock, so we log a
+            // message to let the user know of such cases.
+            if (!lock.tryLock()) {
+                if (isWriteOperation
+                        && operation instanceof SessionWriteOperation) {
+                    log.warn("Attempt to perform {} while another thread"
+                            + " is concurrently modifying the session."
+                            + " Blocking until the other thread is finished"
+                            + " using this session.", operation);
+                } else {
+                    log.debug("Attempt to perform {} while another thread"
+                            + " is concurrently accessing the session."
+                            + " Blocking until the other thread is finished"
+                            + " using this session.", operation);
+                }
+                lock.lock();
+            }
+
+            try {
+                // Check that the session is still alive
+                checkAlive();
+
+                // Raise the isWriteOperation flag for write operations.
+                // The flag is used to set the appropriate log level above.
+                boolean wasWriteOperation = isWriteOperation;
+                if (!wasWriteOperation
+                        && operation instanceof SessionWriteOperation) {
+                    isWriteOperation = true;
+                }
                 try {
-                    return internalPerform(operation);
+                    // Perform the actual operation, optionally with debug logs
+                    if (log.isDebugEnabled()) {
+                        log.debug("Performing {}", operation);
+                        long start = System.nanoTime();
+                        try {
+                            return operation.perform(context);
+                        } finally {
+                            log.debug("{} performed in {}ns",
+                                    operation, System.nanoTime() - start);
+                        }
+                    } else {
+                        return operation.perform(context);
+                    }
                 } finally {
-                    log.debug("{} performed in {}ns",
-                            operation, System.nanoTime() - start);
+                    isWriteOperation = wasWriteOperation;
                 }
-            } else {
-                return internalPerform(operation);
+            } finally {
+                lock.unlock();
             }
         } finally {
-            state.reset();
+            logState.reset();
+        }
+    }
+
+    /**
+     * Closes this session.
+     *
+     * @return <code>true</code> if the session was closed, or
+     *         <code>false</code> if the session had already been closed
+     */
+    public boolean close() {
+        LogState logState = new LogState(
+                "jcr.session", context.toString(),
+                "jcr.operation", "close()");
+        try {
+            if (!lock.tryLock()) {
+                log.warn("Attempt to close a session while another thread is"
+                        + " concurrently accessing the session. Blocking until"
+                        + " the other thread is finished using this session.");
+                lock.lock();
+            }
+            try {
+                if (isAlive()) {
+                    closed = new Exception(
+                            "Stack trace of where " + context + " was closed");
+                    return true;
+                } else {
+                    log.warn("This session has already been closed. See the"
+                            + " chained exception for a trace of where the "
+                            + " session was closed.", closed);
+                    return false;
+                }
+            } finally {
+                lock.unlock();
+            }
+        } finally {
+            logState.reset();
         }
     }
 
@@ -172,70 +248,4 @@ public class SessionState {
 
     }
 
-    /**
-     * The actual implementation of the {@link #perform(SessionOperation)}
-     * method, extracted since the public method is already filled with
-     * somewhat complex logging and timing logic.
-     *
-     * @param operation session operation
-     * @return the return value of the executed operation
-     * @throws RepositoryException if the operation fails or
-     *                             if the session has already been closed
-     */
-    private <T> T internalPerform(SessionOperation<T> operation)
-            throws RepositoryException {
-        if (!lock.tryLock()) {
-            if (isWriteOperation && operation instanceof SessionWriteOperation) {
-                log.warn("Attempt to perform {} while another thread is"
-                        + " concurrently modifying the session. Blocking until"
-                        + " the other thread is finished using this session.",
-                        operation);
-            } else {
-                log.debug("Attempt to perform {} while another thread is"
-                        + " concurrently accessing the session. Blocking until"
-                        + " the other thread is finished using this session.",
-                        operation);
-            }
-            lock.lock();
-        }
-        boolean wasWriteOperation = isWriteOperation;
-        if (!wasWriteOperation && operation instanceof SessionWriteOperation) {
-            isWriteOperation = true;
-        }
-        try {
-            checkAlive();
-            log.debug("Performing {}", operation);
-            return operation.perform(context);
-        } finally {
-            isWriteOperation = wasWriteOperation;
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Closes this session.
-     *
-     * @return <code>true</code> if the session was closed, or
-     *         <code>false</code> if the session had already been closed
-     */
-    public boolean close() {
-        if (!lock.tryLock()) {
-            log.warn("Attempt to close a session while another thread is"
-                    + " concurrently accessing the session. Blocking until"
-                    + " the other thread is finished using this session.");
-            lock.lock();
-        }
-        try {
-            if (isAlive()) {
-                closed = new Exception();
-                return true;
-            } else {
-                log.warn("This session has already been closed", closed);
-                return false;
-            }
-        } finally {
-            lock.unlock();
-        }
-    }
-
 }



Mime
View raw message