merge default into branch

Author: David R. MacIver

src/com/rabbitmq/client/Channel.java

@@ -61,7 +61,7 @@
  *
  */
 
-public interface Channel extends ShutdownNotifier{
+public interface Channel extends ShutdownNotifier {
     /**
      * Retrieve this channel's channel number.
      * @return the channel number

src/com/rabbitmq/client/ShutdownSignalException.java

@@ -30,6 +30,8 @@
 //
 package com.rabbitmq.client;
 
+import com.rabbitmq.utility.SensibleClone;
+
 /**
  * Encapsulates a shutdown condition for a connection to an AMQP broker.
  * Depending on HardError when calling
@@ -38,7 +40,7 @@
  * this exception.
  */
 
-public class ShutdownSignalException extends RuntimeException {
+public class ShutdownSignalException extends RuntimeException implements SensibleClone<ShutdownSignalException> {
     /** True if the connection is shut down, or false if this signal refers to a channel */
     private final boolean _hardError;
 
@@ -92,6 +94,14 @@ public ShutdownSignalException(boolean hardError,
     /** @return Reference to Connection or Channel object that fired the signal **/
     public Object getReference() { return _ref; }
 
+    public ShutdownSignalException sensibleClone() {
+        try {
+            return (ShutdownSignalException)super.clone();
+        } catch (CloneNotSupportedException e) {
+            // You've got to be kidding me
+            throw new Error(e);
+        }
+    }
 }
 
 

src/com/rabbitmq/utility/BlockingValueOrException.java

@@ -32,7 +32,7 @@
 
 import java.util.concurrent.TimeoutException;
 
-public class BlockingValueOrException<V, E extends Throwable>
+public class BlockingValueOrException<V, E extends Throwable & SensibleClone<E>>
     extends BlockingCell<ValueOrException<V, E>>
 {
     public void setValue(V v) {

src/com/rabbitmq/utility/SensibleClone.java

@@ -0,0 +1,46 @@
+//   The contents of this file are subject to the Mozilla Public License
+//   Version 1.1 (the "License"); you may not use this file except in
+//   compliance with the License. You may obtain a copy of the License at
+//   http://www.mozilla.org/MPL/
+//
+//   Software distributed under the License is distributed on an "AS IS"
+//   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+//   License for the specific language governing rights and limitations
+//   under the License.
+//
+//   The Original Code is RabbitMQ.
+//
+//   The Initial Developers of the Original Code are LShift Ltd,
+//   Cohesive Financial Technologies LLC, and Rabbit Technologies Ltd.
+//
+//   Portions created before 22-Nov-2008 00:00:00 GMT by LShift Ltd,
+//   Cohesive Financial Technologies LLC, or Rabbit Technologies Ltd
+//   are Copyright (C) 2007-2008 LShift Ltd, Cohesive Financial
+//   Technologies LLC, and Rabbit Technologies Ltd.
+//
+//   Portions created by LShift Ltd are Copyright (C) 2007-2009 LShift
+//   Ltd. Portions created by Cohesive Financial Technologies LLC are
+//   Copyright (C) 2007-2009 Cohesive Financial Technologies
+//   LLC. Portions created by Rabbit Technologies Ltd are Copyright
+//   (C) 2007-2009 Rabbit Technologies Ltd.
+//
+//   All Rights Reserved.
+//
+//   Contributor(s): ______________________________________.
+//
+package com.rabbitmq.utility;
+
+/** 
+ * This interface exists as a workaround for the annoyingness of java.lang.Cloneable.
+ * It is used for generic methods which need to accept something they can actually clone
+ * (Object.clone is protected and java.lang.Cloneable does not define a public clone method)
+ * and want to provide some guarantees of the type of the cloned object. 
+ */
+public interface SensibleClone<T extends SensibleClone<T>> extends Cloneable {
+
+  /**
+   * Like Object.clone but sensible; in particular, public and declared to return
+   * the right type. 
+   */
+  public T sensibleClone();
+}

src/com/rabbitmq/utility/Utility.java

@@ -39,7 +39,50 @@
  */
 
 public class Utility {
+    static class ThrowableCreatedElsewhere extends Throwable {
+        public ThrowableCreatedElsewhere(Throwable throwable) {
+          super(throwable.getClass() + " created elsewhere");
+          this.setStackTrace(throwable.getStackTrace());
+        }
+
+        @Override public Throwable fillInStackTrace(){ 
+            return this; 
+        } 
+    }
+
+    public static <T extends Throwable & SensibleClone<T>> T fixStackTrace(T throwable) {
+      throwable = throwable.sensibleClone();
+
+      if(throwable.getCause() == null) {
+        // We'd like to preserve the original stack trace in the cause.
+        // Unfortunately Java doesn't let you set the cause once it's been
+        // set once. This means we have to choose between either 
+        //  - not preserving the type
+        //  - sometimes losing the original stack trace
+        //  - performing nasty reflective voodoo which may or may not work
+        // We only lose the original stack trace when there's a root cause
+        // which will hopefully be enlightening enough on its own that it 
+        // doesn't matter too much. 
+        try {
+          throwable.initCause(new ThrowableCreatedElsewhere(throwable));
+        } catch(IllegalStateException e) {
+          // This exception was explicitly initialised with a null cause. 
+          // Alas this means we can't set the cause even though it has none. 
+          // Thanks. 
+        }
+      }
+
+
+      throwable.fillInStackTrace();
+      // We want to remove fixStackTrace from the trace.
+      StackTraceElement[] existing = throwable.getStackTrace();
+      StackTraceElement[] newTrace = new StackTraceElement[existing.length - 1];
+      System.arraycopy(existing, 1, newTrace, 0, newTrace.length);
+      throwable.setStackTrace(newTrace);
+      return throwable;
+    }
 
+  
     public static String makeStackTrace(Throwable throwable) {
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         PrintStream printStream = new PrintStream(outputStream);

src/com/rabbitmq/utility/ValueOrException.java

@@ -30,7 +30,7 @@
 //
 package com.rabbitmq.utility;
 
-public class ValueOrException<V, E extends Throwable> {
+public class ValueOrException<V, E extends Throwable & SensibleClone<E>> {
     private final boolean _useValue;
     private final V _value;
     private final E _exception;
@@ -57,7 +57,7 @@ private ValueOrException(V value, E exception, boolean useValue) {
      * @param value the value to wrap as a ValueOrException
      * @return the wrapped value
      */
-    public static <V, E extends Throwable> ValueOrException<V, E> makeValue(V value) {
+    public static <V, E extends Throwable & SensibleClone<E>> ValueOrException<V, E> makeValue(V value) {
         return new ValueOrException<V, E>(value, null, true);
     }
 
@@ -66,7 +66,7 @@ public static <V, E extends Throwable> ValueOrException<V, E> makeValue(V value)
      * @param exception the exception to wrap as a ValueOrException
      * @return the wrapped exception
      */
-    public static <V, E extends Throwable> ValueOrException<V, E> makeException(E exception) {
+    public static <V, E extends Throwable & SensibleClone<E>> ValueOrException<V, E> makeException(E exception) {
         return new ValueOrException<V, E>(null, exception, false);
     }
 
@@ -78,7 +78,7 @@ public V getValue() throws E {
         if (_useValue) {
             return _value;
         } else {
-            throw _exception;
+            throw Utility.fixStackTrace(_exception);
         }
     }
 }

test/src/com/rabbitmq/client/test/ValueOrExceptionTest.java

@@ -30,39 +30,59 @@
 //
 package com.rabbitmq.client.test;
 
-import java.io.IOException;
-
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
 import com.rabbitmq.utility.ValueOrException;
+import com.rabbitmq.utility.SensibleClone;
 
 
 public class ValueOrExceptionTest extends TestCase {
+    public static class InsufficientMagicException extends Exception 
+      implements SensibleClone<InsufficientMagicException> {
+      public InsufficientMagicException(String message) {
+        super(message);
+      }
+
+      public InsufficientMagicException sensibleClone() {
+        return new InsufficientMagicException(getMessage());
+      }
+    }
+
+
     public static TestSuite suite()
     {
         TestSuite suite = new TestSuite("valueOrEx");
         suite.addTestSuite(ValueOrExceptionTest.class);
         return suite;
     }
 
-    public void testStoresValue() throws IOException {
+    public void testStoresValue() throws InsufficientMagicException {
         Integer value = new Integer(3);
-        ValueOrException<Integer, IOException> valueOrEx = ValueOrException.<Integer, IOException>makeValue(value);
 
+        ValueOrException<Integer, InsufficientMagicException> valueOrEx = 
+            ValueOrException.<Integer, InsufficientMagicException>makeValue(value);
+        
         Integer returnedValue = valueOrEx.getValue();
         assertTrue(returnedValue == value);
     }
 
-    public void testStoresException() {
-        IOException exception = new IOException("dummy message");
-        ValueOrException<Integer, IOException> valueOrEx = ValueOrException.<Integer, IOException>makeException(exception);
+    public void testClonesException() {
+        InsufficientMagicException exception = 
+            new InsufficientMagicException("dummy message");
+        ValueOrException<Integer, InsufficientMagicException> valueOrEx 
+            = ValueOrException.makeException(exception);
 
         try {
             valueOrEx.getValue();
             fail("Expected exception");
-        } catch(IOException returnedException) {
-            assertTrue(returnedException == exception);
+        } catch(InsufficientMagicException returnedException) {
+            assertTrue(returnedException != exception);
+            assertEquals(returnedException.getMessage(), exception.getMessage());
+            boolean inGetValue = false;
+            for(StackTraceElement elt : returnedException.getStackTrace())
+              inGetValue |= "getValue".equals(elt.getMethodName());
+            assertTrue(inGetValue);
         }
     }
 }

test/src/com/rabbitmq/client/test/performance/ScalabilityTest.java

@@ -213,7 +213,7 @@ public static void main(String[] args) throws Exception {
     }
 
 
-    public Results run() throws Exception{
+    public Results run() throws Exception {
         Connection con = new ConnectionFactory().newConnection(params.host, params.port);
         Channel channel = con.createChannel();
 

test/src/com/rabbitmq/client/test/server/DurableBindingLifecycle.java

@@ -76,7 +76,7 @@ public void testDurableBindingRecovery() throws IOException {
 
         restart();
 
-        for (int i = 0; i < N; i++){
+        for (int i = 0; i < N; i++) {
             basicPublishVolatile(X, K);
         }
 
@@ -113,7 +113,7 @@ public void testDurableBindingsDeletion() throws IOException {
 
         declareDurableTopicExchange(X);
 
-        for (int i = 0; i < N; i++){
+        for (int i = 0; i < N; i++) {
             basicPublishVolatile(X, K);
         }
 

test/src/com/rabbitmq/examples/ManyConnections.java

@@ -90,7 +90,7 @@ public void run() {
 
     public static void runChannel(int threadNumber,
 				  Connection conn,
-				  Channel ch){
+				  Channel ch) {
 	try {
 	    int delayLen = (int) (1000 / rate);
 	    long startTime = System.currentTimeMillis();