(17);
}
+ public long getTransactionStartTime()
+ {
+ return txnStartTime;
+ }
+
public String getTransactionId()
{
return txnId;
diff --git a/source/java/org/alfresco/repo/transaction/AlfrescoTransactionSupportTest.java b/source/java/org/alfresco/repo/transaction/AlfrescoTransactionSupportTest.java
index 3b55349df3..505d7aa08a 100644
--- a/source/java/org/alfresco/repo/transaction/AlfrescoTransactionSupportTest.java
+++ b/source/java/org/alfresco/repo/transaction/AlfrescoTransactionSupportTest.java
@@ -65,15 +65,20 @@ public class AlfrescoTransactionSupportTest extends TestCase
TransactionService transactionService = serviceRegistry.getTransactionService();
UserTransaction txn = transactionService.getUserTransaction();
assertNull("Thread shouldn't have a txn ID", AlfrescoTransactionSupport.getTransactionId());
+ assertEquals("No transaction start time expected", -1, AlfrescoTransactionSupport.getTransactionStartTime());
- // begine the txn
+ // begin the txn
txn.begin();
String txnId = AlfrescoTransactionSupport.getTransactionId();
assertNotNull("Expected thread to have a txn id", txnId);
+ long txnStartTime = AlfrescoTransactionSupport.getTransactionStartTime();
+ assertTrue("Expected a transaction start time", txnStartTime > 0);
- // check that the txn id doesn't change
+ // check that the txn id and time doesn't change
String txnIdCheck = AlfrescoTransactionSupport.getTransactionId();
assertEquals("Transaction ID changed on same thread", txnId, txnIdCheck);
+ long txnStartTimeCheck = AlfrescoTransactionSupport.getTransactionStartTime();
+ assertEquals("Transaction start time changed on same thread", txnStartTime, txnStartTimeCheck);
// begin a new, inner transaction
{
@@ -81,12 +86,19 @@ public class AlfrescoTransactionSupportTest extends TestCase
String txnIdInner = AlfrescoTransactionSupport.getTransactionId();
assertEquals("Inner transaction not started, so txn ID should not change", txnId, txnIdInner);
+ long txnStartTimeInner = AlfrescoTransactionSupport.getTransactionStartTime();
+ assertEquals("Inner transaction not started, so txn start time should not change", txnStartTime, txnStartTimeInner);
// begin the nested txn
txnInner.begin();
// check the ID for the outer transaction
txnIdInner = AlfrescoTransactionSupport.getTransactionId();
assertNotSame("Inner txn ID must be different from outer txn ID", txnIdInner, txnId);
+ // Check the time against the outer transaction
+ txnStartTimeInner = AlfrescoTransactionSupport.getTransactionStartTime();
+ assertTrue(
+ "Inner transaction start time should be greater or equal (accuracy) to the outer's",
+ txnStartTime <= txnStartTimeInner);
// rollback the nested txn
txnInner.rollback();
diff --git a/source/java/org/alfresco/repo/transaction/TransactionResourceInterceptor.java b/source/java/org/alfresco/repo/transaction/TransactionResourceInterceptor.java
new file mode 100644
index 0000000000..b1a2af12cd
--- /dev/null
+++ b/source/java/org/alfresco/repo/transaction/TransactionResourceInterceptor.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2005-2007 Alfresco Software Limited.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ * As a special exception to the terms and conditions of version 2.0 of
+ * the GPL, you may redistribute this Program in connection with Free/Libre
+ * and Open Source Software ("FLOSS") applications as described in Alfresco's
+ * FLOSS exception. You should have recieved a copy of the text describing
+ * the FLOSS exception, and it is also available here:
+ * http://www.alfresco.com/legal/licensing
+ */
+package org.alfresco.repo.transaction;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.alfresco.util.resource.MethodResourceManager;
+import org.alfresco.util.resource.MethodResourceManager.MethodStatistics;
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+/**
+ * This interceptor gathers basic method call statistics and calls the
+ * {@link org.alfresco.util.resource.MethodResourceManager resource managers} for
+ * further processing. The resource managers are called after the method
+ * invocations, but it doesn't matter too much since they are called on a time
+ * frequency basis.
+ *
+ * It acts as a sampling tool, but doesn't make any decisions or take any action
+ * with regard system or transaction-related resources. All samples are stored
+ * against the current transaction. If there is no current transaction then no
+ * action will be taken with respect to the resource management.
+ *
+ * The default is to activate after 10s and call through every 5s.
+ *
+ * This class supports both interceptor-based calling as well as manual calling.
+ * Long-running processes can call an this manually on every iteration and
+ * get the same behaviour of regular calls to the resouce managers.
+ *
+ * @see org.alfresco.util.resource.MethodResourceManager
+ *
+ * @author Derek Hulley
+ */
+public class TransactionResourceInterceptor implements MethodInterceptor
+{
+ private List methodResourceManagers;
+ /** Default 10000ms (10s) */
+ private long elapsedTimeBeforeActivationMillis = 10000L;
+ /** Default 5000ms (5s) */
+ private long resourceManagerCallFrequencyMillis = 5000L;
+ /** When the last call to the resource managers was made by this instance */
+ private volatile long lastCallMillis;
+
+ /**
+ * A resource key unique to this interceptor. This avoids clashes with other instances up
+ * and down the stack operating in the same transaction.
+ */
+ private String resourceKey;
+
+ public TransactionResourceInterceptor()
+ {
+ resourceKey = "MethodStats" + super.toString();
+ }
+
+ /**
+ * Set the method-based resource managers that will be notified of the statistics.
+ *
+ * @param methodResourceManagers a list of resource managers - may be null or empty
+ */
+ public void setMethodResourceManagers(List methodResourceManagers)
+ {
+ this.methodResourceManagers = methodResourceManagers;
+ }
+
+ /**
+ * Set the minimum number of seconds that a transaction must have been running for
+ * before method sampling begins. The interceptor does nothing prior to this.
+ *
+ * @param elapsedTimeBeforeActivationMillis an initial idle time in milliseconds
+ */
+ public void setElapsedTimeBeforeActivationMillis(long elapsedTimeBeforeActivationMillis)
+ {
+ this.elapsedTimeBeforeActivationMillis = elapsedTimeBeforeActivationMillis;
+ }
+
+ /**
+ * Set the approximate time between calls to the
+ * {@link #setMethodResourceManagers(List) registered resource managers}. This applies to this instance
+ * of the interceptor and not to the transaction. If a single instance of this
+ * class is used in multiple places, then the resource managers will still only get called at a steady
+ * rate. This is mainly in order to streamline the interception prior to the activation phase, but suits
+ * the resource managers since they get given the exact methods that were called anyway.
+ *
+ * @param resourceManagerCallFrequencyMillis an approximate time between calls to the resource managers
+ */
+ public void setResourceManagerCallFrequencyMillis(long resourceManagerCallFrequencyMillis)
+ {
+ this.resourceManagerCallFrequencyMillis = resourceManagerCallFrequencyMillis;
+ }
+
+ public Object invoke(MethodInvocation invocation) throws Throwable
+ {
+ if (methodResourceManagers == null || methodResourceManagers.size() == 0)
+ {
+ // We just ignore everything
+ return invocation.proceed();
+ }
+
+ // Get the txn start time
+ long txnStartTime = AlfrescoTransactionSupport.getTransactionStartTime();
+ if (txnStartTime < 0)
+ {
+ // There is no transaction
+ return invocation.proceed();
+ }
+
+ // Check if the required time has passed
+ long now = System.currentTimeMillis();
+ long txnElapsedTime = (now - txnStartTime);
+ if (txnElapsedTime < elapsedTimeBeforeActivationMillis)
+ {
+ // It's not been long enough
+ return invocation.proceed();
+ }
+
+ // We need to start timing the method calls
+ Method calledMethod = invocation.getMethod();
+ long beforeNs = System.nanoTime();
+ Object ret = invocation.proceed();
+ long deltaNs = System.nanoTime() - beforeNs;
+
+ // Get the method stats
+ @SuppressWarnings("unchecked")
+ Map methodStatsByMethod =
+ (Map) AlfrescoTransactionSupport.getResource(resourceKey);
+ if (methodStatsByMethod == null)
+ {
+ methodStatsByMethod = new HashMap(11);
+ AlfrescoTransactionSupport.bindResource(resourceKey, methodStatsByMethod);
+ }
+
+ // Update method stats
+ MethodStatistics calledMethodStats = methodStatsByMethod.get(calledMethod);
+ if (calledMethodStats == null)
+ {
+ calledMethodStats = new MethodStatistics();
+ methodStatsByMethod.put(calledMethod, calledMethodStats);
+ }
+ calledMethodStats.accumulateNs(deltaNs);
+
+ // Check if we need to call the resource managers to clean up
+ if ((now - lastCallMillis) >= resourceManagerCallFrequencyMillis)
+ {
+ for (MethodResourceManager resourceManager : methodResourceManagers)
+ {
+ resourceManager.manageResources(methodStatsByMethod, txnElapsedTime, calledMethod);
+ }
+ lastCallMillis = now;
+ }
+
+ // Done
+ return ret;
+ }
+
+ /**
+ * An alternative method allowing a manual call to check the resources. This is useful
+ * in the cases where long running iterations don't necessarily pass through the
+ * necessary API stack, or where the specific resources in hand can't be dealt with
+ * blindly before and after resource management. The elapsed time should be that of the
+ * iteration within the method (it is assumed that there won't be more than one).
+ *
+ * If you have a loop in a method that doesn't call anything that can be intercepted
+ * and handle safely, then get a pre-configured instance (usually from the application context)
+ * and mimic the interceptor call.
+ *
+ * You should get the Method, which is used for informational purposes, in a
+ * single call when you calling code is loaded by the classloader. Introspecting every time
+ * you wish to call this method is unnecessary.
+ *
+ * @param calledMethod the method that this check applies to
+ * @param deltaNs the time in milliseconds that the repeated operation took
+ */
+ public void performManualCheck(Method calledMethod, long deltaNs)
+ {
+ /*
+ * This is mainly duplicated code, but it can be heavily used so nice patterns
+ * are not preferable to speed of execution.
+ */
+
+ if (methodResourceManagers == null || methodResourceManagers.size() == 0)
+ {
+ // We just ignore everything
+ return;
+ }
+
+ // Get the txn start time
+ long txnStartTime = AlfrescoTransactionSupport.getTransactionStartTime();
+ if (txnStartTime < 0)
+ {
+ // There is no transaction
+ return;
+ }
+
+ // Check if the required time has passed
+ long now = System.currentTimeMillis();
+ long txnElapsedTime = (now - txnStartTime);
+ if (txnElapsedTime < elapsedTimeBeforeActivationMillis)
+ {
+ // It's not been long enough
+ return;
+ }
+
+ // Get the method stats
+ @SuppressWarnings("unchecked")
+ Map methodStatsByMethod =
+ (Map) AlfrescoTransactionSupport.getResource(resourceKey);
+ if (methodStatsByMethod == null)
+ {
+ methodStatsByMethod = new HashMap(11);
+ AlfrescoTransactionSupport.bindResource(resourceKey, methodStatsByMethod);
+ }
+
+ // Update method stats
+ MethodStatistics calledMethodStats = methodStatsByMethod.get(calledMethod);
+ if (calledMethodStats == null)
+ {
+ calledMethodStats = new MethodStatistics();
+ methodStatsByMethod.put(calledMethod, calledMethodStats);
+ }
+ calledMethodStats.accumulateNs(deltaNs);
+
+ // Check if we need to call the resource managers to clean up
+ if ((now - lastCallMillis) >= resourceManagerCallFrequencyMillis)
+ {
+ for (MethodResourceManager resourceManager : methodResourceManagers)
+ {
+ resourceManager.manageResources(methodStatsByMethod, txnElapsedTime, calledMethod);
+ }
+ lastCallMillis = now;
+ }
+ // Done
+ return;
+ }
+}
diff --git a/source/java/org/alfresco/util/resource/MethodResourceManager.java b/source/java/org/alfresco/util/resource/MethodResourceManager.java
new file mode 100644
index 0000000000..bc9a449f30
--- /dev/null
+++ b/source/java/org/alfresco/util/resource/MethodResourceManager.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2005-2007 Alfresco Software Limited.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ * As a special exception to the terms and conditions of version 2.0 of
+ * the GPL, you may redistribute this Program in connection with Free/Libre
+ * and Open Source Software ("FLOSS") applications as described in Alfresco's
+ * FLOSS exception. You should have recieved a copy of the text describing
+ * the FLOSS exception, and it is also available here:
+ * http://www.alfresco.com/legal/licensing
+ */
+package org.alfresco.util.resource;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+/**
+ * A controller of system or in-transaction resources. Given a few statistics
+ * regarding a method's call history, and using whatever other measurements
+ * are needed, implementations will decide whether and how to clear up
+ * sufficient system resources.
+ *
+ * @author Derek Hulley
+ */
+public interface MethodResourceManager
+{
+ /**
+ * Helper class to carry basic method call statistics.
+ */
+ public static class MethodStatistics
+ {
+ private long callCount;
+ private long accumulatedTimeNs;
+ public void accumulateNs(long durationNs)
+ {
+ accumulatedTimeNs += durationNs;
+ callCount++;
+ }
+ public long getAccumulatedTimeNs()
+ {
+ return accumulatedTimeNs;
+ }
+ public long getCallCount()
+ {
+ return callCount;
+ }
+ /**
+ * @return Returns the average call time in nanoseconds
+ */
+ public double getAverageCallTimeNs()
+ {
+ if (callCount == 0)
+ {
+ return 0.0D;
+ }
+ return (double) accumulatedTimeNs / (double) callCount;
+ }
+ }
+
+ /**
+ * Check and free any required resources for an imminent. Details of the
+ * current transaction and some gathered information about previous calls
+ * to associated methods is also provided.
+ *
+ * @param methodStatsByMethod all known methods and their basic call stats
+ * @param transactionElapsedTimeNs the elapsed time in the current transaction
+ * @param currentMethod the method about to be called
+ */
+ public void manageResources(
+ Map methodStatsByMethod,
+ long transactionElapsedTimeNs,
+ Method currentMethod);
+}
diff --git a/source/test-resources/session-size-test-context.xml b/source/test-resources/session-size-test-context.xml
new file mode 100644
index 0000000000..dc5e7758f1
--- /dev/null
+++ b/source/test-resources/session-size-test-context.xml
@@ -0,0 +1,72 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 10000
+
+
+ 5000
+
+
+
+
+
+
+ testSessionSizeResourceInterceptor
+
+
+
+
+
+
+
+