diff --git a/akka-amqp/src/main/scala/ConsumerActor.scala b/akka-amqp/src/main/scala/ConsumerActor.scala index 07dbd437ba..4bb46ceeec 100644 --- a/akka-amqp/src/main/scala/ConsumerActor.scala +++ b/akka-amqp/src/main/scala/ConsumerActor.scala @@ -39,7 +39,7 @@ private[amqp] class ConsumerActor(consumerParameters: ConsumerParameters) ch.queueDeclarePassive(name) } else { ch.queueDeclare( - name, queueDurable, queueExclusive, queueAutoDelete, + name, queueDurable, queueExclusive, queueAutoDelete, JavaConversions.asMap(configurationArguments)) } case None => diff --git a/akka-amqp/src/main/scala/RpcClientActor.scala b/akka-amqp/src/main/scala/RpcClientActor.scala index a3583d0ad7..0691e76884 100644 --- a/akka-amqp/src/main/scala/RpcClientActor.scala +++ b/akka-amqp/src/main/scala/RpcClientActor.scala @@ -14,7 +14,7 @@ class RpcClientActor[I,O]( exchangeParameters: ExchangeParameters, routingKey: String, serializer: RpcClientSerializer[I,O], - channelParameters: Option[ChannelParameters] = None) + channelParameters: Option[ChannelParameters] = None) extends FaultTolerantChannelActor(exchangeParameters, channelParameters) { import exchangeParameters._ diff --git a/akka-amqp/src/main/scala/RpcServerActor.scala b/akka-amqp/src/main/scala/RpcServerActor.scala index 0d6a8d2a89..309c7fa40c 100644 --- a/akka-amqp/src/main/scala/RpcServerActor.scala +++ b/akka-amqp/src/main/scala/RpcServerActor.scala @@ -9,8 +9,8 @@ import com.rabbitmq.client.AMQP.BasicProperties import se.scalablesolutions.akka.amqp.AMQP.RpcServerSerializer class RpcServerActor[I,O]( - producer: ActorRef, - serializer: RpcServerSerializer[I,O], + producer: ActorRef, + serializer: RpcServerSerializer[I,O], requestHandler: I => O) extends Actor { log.info("%s started", this) diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala index 0227e05d6d..30a362b856 100644 --- a/akka-core/src/main/scala/actor/Actor.scala +++ b/akka-core/src/main/scala/actor/Actor.scala @@ -97,7 +97,7 @@ object Actor extends Logging { type Receive = PartialFunction[Any, Unit] private[actor] val actorRefInCreation = new scala.util.DynamicVariable[Option[ActorRef]](None) - + /** * Creates an ActorRef out of the Actor with type T. * 
diff --git a/akka-core/src/main/scala/actor/ActorRef.scala b/akka-core/src/main/scala/actor/ActorRef.scala
index a3ef82f903..47ff788f1c 100644
--- a/akka-core/src/main/scala/actor/ActorRef.scala
+++ b/akka-core/src/main/scala/actor/ActorRef.scala
@@ -203,7 +203,7 @@ trait ActorRef extends TransactionManagement with java.lang.Comparable[ActorRef]
 
   protected[akka] def currentMessage_=(msg: Option[MessageInvocation]) = guard.withGuard { _currentMessage = msg }
   protected[akka] def currentMessage = guard.withGuard { _currentMessage }
-  
+
   /** comparison only takes uuid into account
    */
   def compareTo(other: ActorRef) = this.uuid.compareTo(other.uuid)
diff --git a/akka-core/src/main/scala/actor/ActorRegistry.scala b/akka-core/src/main/scala/actor/ActorRegistry.scala
index 532ead6754..1e097f9034 100644
--- a/akka-core/src/main/scala/actor/ActorRegistry.scala
+++ b/akka-core/src/main/scala/actor/ActorRegistry.scala
@@ -49,13 +49,13 @@ object ActorRegistry extends ListenerManagement {
 
   /**
    * Invokes the function on all known actors until it returns Some
-   * Returns None if the function never returns Some 
+   * Returns None if the function never returns Some
    */
   def find[T](f: (ActorRef) => Option[T]) : Option[T] = {
     val elements = actorsByUUID.elements
     while (elements.hasMoreElements) {
       val result = f(elements.nextElement)
-      
+
       if(result.isDefined)
         return result
     }
@@ -134,7 +134,7 @@ object ActorRegistry extends ListenerManagement {
       newSet add actor
 
       val oldSet = actorsById.putIfAbsent(id,newSet)
-      
+
       //Parry for two simultaneous putIfAbsent(id,newSet)
       if(oldSet ne null)
         oldSet add actor
diff --git a/akka-core/src/main/scala/actor/BootableActorLoaderService.scala b/akka-core/src/main/scala/actor/BootableActorLoaderService.scala
index 8fa68d189d..dfb8541396 100644
--- a/akka-core/src/main/scala/actor/BootableActorLoaderService.scala
+++ b/akka-core/src/main/scala/actor/BootableActorLoaderService.scala
@@ -83,7 +83,7 @@ trait BootableActorLoaderService extends Bootable with Logging {
     } else Thread.currentThread.getContextClassLoader)
   }
 
-  abstract override def onLoad = {  
+  abstract override def onLoad = {
     applicationLoader.foreach(_ => log.info("Creating /deploy class-loader"))
 
     super.onLoad
diff --git a/akka-core/src/main/scala/actor/UntypedActor.scala b/akka-core/src/main/scala/actor/UntypedActor.scala
index b0c4c2ff04..474c75e6de 100644
--- a/akka-core/src/main/scala/actor/UntypedActor.scala
+++ b/akka-core/src/main/scala/actor/UntypedActor.scala
@@ -14,7 +14,7 @@ import java.net.InetSocketAddress
 import scala.reflect.BeanProperty
 
 /**
- * Subclass this abstract class to create a MDB-style untyped actor. 
+ * Subclass this abstract class to create a MDB-style untyped actor.
  * 

  * This class is meant to be used from Java.
  * 

@@ -29,12 +29,12 @@ import scala.reflect.BeanProperty
  *          // Reply to original sender of message using the 'replyUnsafe' method
  *          getContext().replyUnsafe(msg + ":" + getContext().getUuid());
  *
- *        } else if (msg.equals("UseSender") && getContext().getSender().isDefined()) {     
+ *        } else if (msg.equals("UseSender") && getContext().getSender().isDefined()) {
  *          // Reply to original sender of message using the sender reference
  *          // also passing along my own refererence (the context)
- *          getContext().getSender().get().sendOneWay(msg, context); 
+ *          getContext().getSender().get().sendOneWay(msg, context);
  *
- *        } else if (msg.equals("UseSenderFuture") && getContext().getSenderFuture().isDefined()) {     
+ *        } else if (msg.equals("UseSenderFuture") && getContext().getSenderFuture().isDefined()) {
  *          // Reply to original sender of message using the sender future reference
  *          getContext().getSenderFuture().get().completeWithResult(msg);
  *
@@ -51,7 +51,7 @@ import scala.reflect.BeanProperty
  *        } else throw new IllegalArgumentException("Unknown message: " + message);
  *      } else throw new IllegalArgumentException("Unknown message: " + message);
  *    }
- *   
+ *
  *    public static void main(String[] args) {
  *      UntypedActorRef actor = UntypedActor.actorOf(SampleUntypedActor.class);
  *      actor.start();
@@ -96,7 +96,7 @@ abstract class RemoteUntypedActor(address: InetSocketAddress) extends UntypedAct
 /**
  * Factory object for creating and managing 'UntypedActor's. Meant to be used from Java.
  * 

- * Example on how to create an actor: 
+ * Example on how to create an actor:
  * 
  *   ActorRef actor = UntypedActor.actorOf(MyUntypedActor.class);
  *   actor.start();
@@ -111,11 +111,11 @@ abstract class RemoteUntypedActor(address: InetSocketAddress) extends UntypedAct
  * @author Jonas Bonér
  */
 object UntypedActor {
-  
+
   /**
    * Creates an ActorRef out of the Actor. Allows you to pass in the class for the Actor.
    * 

-   * Example in Java: 
+   * Example in Java:
    * 
    *   ActorRef actor = UntypedActor.actorOf(MyUntypedActor.class);
    *   actor.start();
@@ -134,13 +134,13 @@ object UntypedActor {
   }
 
   /**
-   * NOTE: Use this convenience method with care, do NOT make it possible to get a reference to the 
+   * NOTE: Use this convenience method with care, do NOT make it possible to get a reference to the
    * UntypedActor instance directly, but only through its 'UntypedActorRef' wrapper reference.
    * 

-   * Creates an ActorRef out of the Actor. Allows you to pass in the instance for the Actor. Only 
+   * Creates an ActorRef out of the Actor. Allows you to pass in the instance for the Actor. Only
    * use this method when you need to pass in constructor arguments into the 'UntypedActor'.
    * 

-   * Example in Java: 
+   * Example in Java:
    * 
    *   ActorRef actor = UntypedActor.actorOf(new MyUntypedActor("service:name", 5));
    *   actor.start();
@@ -156,7 +156,7 @@ object UntypedActor {
 }
 
 /**
- * Use this class if you need to wrap an 'ActorRef' in the more Java-friendly 'UntypedActorRef'.  
+ * Use this class if you need to wrap an 'ActorRef' in the more Java-friendly 'UntypedActorRef'.
  *
  * @author Jonas Bonér
  */
@@ -170,7 +170,7 @@ object UntypedActorRef {
  * @author Jonas Bonér
  */
 class UntypedActorRef(val actorRef: ActorRef) {
-  
+
   /**
    * Returns the uuid for the actor.
    */
@@ -186,14 +186,14 @@ class UntypedActorRef(val actorRef: ActorRef) {
    */
   def setId(id: String) = actorRef.id = id
   def getId(): String = actorRef.id
-  
+
   /**
    * Defines the default timeout for '!!' and '!!!' invocations,
    * e.g. the timeout for the future returned by the call to '!!' and '!!!'.
    */
   def setTimeout(timeout: Long) = actorRef.timeout = timeout
   def getTimeout(): Long = actorRef.timeout
-  
+
   /**
    * Defines the default timeout for an initial receive invocation.
    * When specified, the receive function should be able to handle a 'ReceiveTimeout' message.
@@ -269,7 +269,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * Is defined if the message was sent with sent with 'sendRequestReply' or 'sendRequestReplyFuture', else None.
    */
   def getSenderFuture(): Option[CompletableFuture[Any]] = actorRef.senderFuture
-  
+
   /**
    * Starts up the actor and its message queue.
    */
@@ -285,7 +285,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * Shuts down the actor its dispatcher and message queue.
    */
   def stop(): Unit = actorRef.stop()
-  
+
   /**
    * Sends a one-way asynchronous message. E.g. fire-and-forget semantics.
    * 

@@ -309,12 +309,12 @@ class UntypedActorRef(val actorRef: ActorRef) {
   def sendOneWay(message: AnyRef, sender: UntypedActorRef) =
     if (sender eq null) actorRef.!(message)(None)
     else actorRef.!(message)(Some(sender.actorRef))
-  
+
   /**
-   * Sends a message asynchronously and waits on a future for a reply message under the hood. The timeout is taken from 
-   * the default timeout in the Actor. 
+   * Sends a message asynchronously and waits on a future for a reply message under the hood. The timeout is taken from
+   * the default timeout in the Actor.
    * 

-   * It waits on the reply either until it receives it or until the timeout expires 
+   * It waits on the reply either until it receives it or until the timeout expires
    * (which will throw an ActorTimeoutException). E.g. send-and-receive-eventually semantics.
    * 

    * NOTE:
@@ -324,19 +324,19 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * If you are sending messages using sendRequestReply then you have to use getContext().reply(..)
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
-  def sendRequestReply(message: AnyRef): AnyRef = 
+  def sendRequestReply(message: AnyRef): AnyRef =
     actorRef.!!(message)(None).getOrElse(throw new ActorTimeoutException(
-      "Message [" + message + 
-      "]\n\tsent to [" + actorRef.actorClassName + 
-      "]\n\twith timeout [" + actorRef.timeout + 
+      "Message [" + message +
+      "]\n\tsent to [" + actorRef.actorClassName +
+      "]\n\twith timeout [" + actorRef.timeout +
       "]\n\ttimed out."))
     .asInstanceOf[AnyRef]
 
   /**
-   * Sends a message asynchronously and waits on a future for a reply message under the hood. The timeout is taken from 
-   * the default timeout in the Actor. 
+   * Sends a message asynchronously and waits on a future for a reply message under the hood. The timeout is taken from
+   * the default timeout in the Actor.
    * 

-   * It waits on the reply either until it receives it or until the timeout expires 
+   * It waits on the reply either until it receives it or until the timeout expires
    * (which will throw an ActorTimeoutException). E.g. send-and-receive-eventually semantics.
    * 

    * NOTE:
@@ -350,18 +350,18 @@ class UntypedActorRef(val actorRef: ActorRef) {
     val result = if (sender eq null) actorRef.!!(message)(None)
                  else actorRef.!!(message)(Some(sender.actorRef))
     result.getOrElse(throw new ActorTimeoutException(
-      "Message [" + message + 
-      "]\n\tsent to [" + actorRef.actorClassName + 
-      "]\n\tfrom [" + sender.actorRef.actorClassName + 
-      "]\n\twith timeout [" + actorRef.timeout + 
+      "Message [" + message +
+      "]\n\tsent to [" + actorRef.actorClassName +
+      "]\n\tfrom [" + sender.actorRef.actorClassName +
+      "]\n\twith timeout [" + actorRef.timeout +
       "]\n\ttimed out."))
     .asInstanceOf[AnyRef]
   }
-  
+
   /**
    * Sends a message asynchronously and waits on a future for a reply message under the hood.
    * 

-   * It waits on the reply either until it receives it or until the timeout expires 
+   * It waits on the reply either until it receives it or until the timeout expires
    * (which will throw an ActorTimeoutException). E.g. send-and-receive-eventually semantics.
    * 

    * NOTE:
@@ -371,18 +371,18 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * If you are sending messages using sendRequestReply then you have to use getContext().reply(..)
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
-  def sendRequestReply(message: AnyRef, timeout: Long): AnyRef = 
+  def sendRequestReply(message: AnyRef, timeout: Long): AnyRef =
     actorRef.!!(message, timeout)(None).getOrElse(throw new ActorTimeoutException(
-      "Message [" + message + 
-      "]\n\tsent to [" + actorRef.actorClassName + 
-      "]\n\twith timeout [" + timeout + 
-      "]\n\ttimed out.")) 
+      "Message [" + message +
+      "]\n\tsent to [" + actorRef.actorClassName +
+      "]\n\twith timeout [" + timeout +
+      "]\n\ttimed out."))
     .asInstanceOf[AnyRef]
-  
+
   /**
    * Sends a message asynchronously and waits on a future for a reply message under the hood.
    * 

-   * It waits on the reply either until it receives it or until the timeout expires 
+   * It waits on the reply either until it receives it or until the timeout expires
    * (which will throw an ActorTimeoutException). E.g. send-and-receive-eventually semantics.
    * 

    * NOTE:
@@ -396,17 +396,17 @@ class UntypedActorRef(val actorRef: ActorRef) {
     val result = if (sender eq null) actorRef.!!(message, timeout)(None)
                  else actorRef.!!(message)(Some(sender.actorRef))
     result.getOrElse(throw new ActorTimeoutException(
-      "Message [" + message + 
-      "]\n\tsent to [" + actorRef.actorClassName + 
-      "]\n\tfrom [" + sender.actorRef.actorClassName + 
-      "]\n\twith timeout [" + timeout + 
-      "]\n\ttimed out.")) 
+      "Message [" + message +
+      "]\n\tsent to [" + actorRef.actorClassName +
+      "]\n\tfrom [" + sender.actorRef.actorClassName +
+      "]\n\twith timeout [" + timeout +
+      "]\n\ttimed out."))
     .asInstanceOf[AnyRef]
   }
-  
+
   /**
-   * Sends a message asynchronously returns a future holding the eventual reply message. The timeout is taken from 
-   * the default timeout in the Actor. 
+   * Sends a message asynchronously returns a future holding the eventual reply message. The timeout is taken from
+   * the default timeout in the Actor.
    * 

    * NOTE:
    * Use this method with care. In most cases it is better to use 'sendOneWay' together with the 'getContext().getSender()' to
@@ -416,10 +416,10 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
   def sendRequestReplyFuture(message: AnyRef): Future[_] = actorRef.!!!(message)(None)
-  
+
   /**
-   * Sends a message asynchronously returns a future holding the eventual reply message. The timeout is taken from 
-   * the default timeout in the Actor. 
+   * Sends a message asynchronously returns a future holding the eventual reply message. The timeout is taken from
+   * the default timeout in the Actor.
    * 

    * NOTE:
    * Use this method with care. In most cases it is better to use 'sendOneWay' together with the 'getContext().getSender()' to
@@ -428,10 +428,10 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * If you are sending messages using sendRequestReplyFuture then you have to use getContext().reply(..)
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
-  def sendRequestReplyFuture(message: AnyRef, sender: UntypedActorRef): Future[_] = 
+  def sendRequestReplyFuture(message: AnyRef, sender: UntypedActorRef): Future[_] =
     if (sender eq null) actorRef.!!!(message)(None)
     else actorRef.!!!(message)(Some(sender.actorRef))
-  
+
   /**
    * Sends a message asynchronously returns a future holding the eventual reply message.
    * 

@@ -443,7 +443,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
   def sendRequestReplyFuture(message: AnyRef, timeout: Long): Future[_] = actorRef.!!!(message, timeout)(None)
-  
+
   /**
    * Sends a message asynchronously returns a future holding the eventual reply message.
    * 

@@ -454,17 +454,17 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * If you are sending messages using sendRequestReplyFuture then you have to use getContext().reply(..)
    * to send a reply message to the original sender. If not then the sender will block until the timeout expires.
    */
-  def sendRequestReplyFuture(message: AnyRef, timeout: Long, sender: UntypedActorRef): Future[_] = 
+  def sendRequestReplyFuture(message: AnyRef, timeout: Long, sender: UntypedActorRef): Future[_] =
     if (sender eq null) actorRef.!!!(message, timeout)(None)
     else actorRef.!!!(message)(Some(sender.actorRef))
-  
+
   /**
    * Forwards the message and passes the original sender actor as the sender.
    * 

    * Works with 'sendOneWay', 'sendRequestReply' and 'sendRequestReplyFuture'.
    */
-  def forward(message: AnyRef, sender: UntypedActorRef): Unit = 
-    if (sender eq null) throw new IllegalArgumentException("The 'sender' argument to 'forward' can't be null") 
+  def forward(message: AnyRef, sender: UntypedActorRef): Unit =
+    if (sender eq null) throw new IllegalArgumentException("The 'sender' argument to 'forward' can't be null")
     else actorRef.forward(message)(Some(sender.actorRef))
 
   /**
@@ -474,7 +474,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * Throws an IllegalStateException if unable to determine what to reply to.
    */
   def replyUnsafe(message: AnyRef): Unit = actorRef.reply(message)
-  
+
     /**
    * Use getContext().replySafe(..) to reply with a message to the original sender of the message currently
    * being processed.
@@ -492,7 +492,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * Returns the class name for the Actor instance that is managed by the ActorRef.
    */
   def getActorClassName(): String = actorRef.actorClassName
-  
+
   /**
    * Invoking 'makeRemote' means that an actor will be moved to and invoked on a remote host.
    */
@@ -538,7 +538,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
    * Set the home address and port for this actor.
    */
   def setHomeAddress(address: InetSocketAddress): Unit = actorRef.homeAddress = address
-  
+
   /**
    * Links an other actor to this actor. Links are unidirectional and means that a the linking actor will
    * receive a notification if the linked actor has crashed.
@@ -562,7 +562,7 @@ class UntypedActorRef(val actorRef: ActorRef) {
   /**
    * Atomically start, link and make an actor remote.
    */
-  def startLinkRemote(actor: UntypedActorRef, hostname: String, port: Int): Unit = 
+  def startLinkRemote(actor: UntypedActorRef, hostname: String, port: Int): Unit =
     actorRef.startLinkRemote(actor.actorRef, hostname, port)
 
   /**
diff --git a/akka-core/src/main/scala/dispatch/Dispatchers.scala b/akka-core/src/main/scala/dispatch/Dispatchers.scala
index e83d52da8b..0d2da205c6 100644
--- a/akka-core/src/main/scala/dispatch/Dispatchers.scala
+++ b/akka-core/src/main/scala/dispatch/Dispatchers.scala
@@ -43,7 +43,7 @@ object Dispatchers {
   val THROUGHPUT = config.getInt("akka.actor.throughput", 5)
 
   object globalHawtDispatcher extends HawtDispatcher
-  
+
   object globalExecutorBasedEventDrivenDispatcher extends ExecutorBasedEventDrivenDispatcher("global") {
     override def register(actor: ActorRef) = {
       if (isShutdown) init
@@ -52,7 +52,7 @@ object Dispatchers {
   }
 
   object globalReactorBasedSingleThreadEventDrivenDispatcher extends ReactorBasedSingleThreadEventDrivenDispatcher("global")
-  
+
   object globalReactorBasedThreadPoolEventDrivenDispatcher extends ReactorBasedThreadPoolEventDrivenDispatcher("global")
 
   /**
diff --git a/akka-core/src/main/scala/dispatch/ThreadPoolBuilder.scala b/akka-core/src/main/scala/dispatch/ThreadPoolBuilder.scala
index 5abf431ef8..55755250e2 100644
--- a/akka-core/src/main/scala/dispatch/ThreadPoolBuilder.scala
+++ b/akka-core/src/main/scala/dispatch/ThreadPoolBuilder.scala
@@ -234,7 +234,7 @@ trait ThreadPoolBuilder {
       extends Thread(runnable, name + "-" + MonitorableThread.created.incrementAndGet) with Logging {
 
     setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
-      def uncaughtException(thread: Thread, cause: Throwable) = 
+      def uncaughtException(thread: Thread, cause: Throwable) =
         log.error(cause, "UNCAUGHT in thread [%s]", thread.getName)
     })
 
diff --git a/akka-core/src/main/scala/remote/BootableRemoteActorService.scala b/akka-core/src/main/scala/remote/BootableRemoteActorService.scala
index 7d6286f24c..643dbd2f33 100644
--- a/akka-core/src/main/scala/remote/BootableRemoteActorService.scala
+++ b/akka-core/src/main/scala/remote/BootableRemoteActorService.scala
@@ -25,7 +25,7 @@ trait BootableRemoteActorService extends Bootable with Logging {
 
   def startRemoteService = remoteServerThread.start
 
-  abstract override def onLoad = {   
+  abstract override def onLoad = {
     if (config.getBool("akka.remote.server.service", true)) {
       if (config.getBool("akka.remote.cluster.service", true)) Cluster.start(self.applicationLoader)
       log.info("Initializing Remote Actors Service...")
diff --git a/akka-core/src/main/scala/remote/RemoteClient.scala b/akka-core/src/main/scala/remote/RemoteClient.scala
index cc32e96998..724a71a642 100644
--- a/akka-core/src/main/scala/remote/RemoteClient.scala
+++ b/akka-core/src/main/scala/remote/RemoteClient.scala
@@ -255,11 +255,11 @@ class RemoteClientPipelineFactory(name: String,
   def getPipeline: ChannelPipeline = {
 
     def join(ch: ChannelHandler*) = Array[ChannelHandler](ch:_*)
-    
+
     val engine = RemoteServerSslContext.client.createSSLEngine()
     engine.setEnabledCipherSuites(engine.getSupportedCipherSuites) //TODO is this sensible?
     engine.setUseClientMode(true)
-  
+
     val ssl         = if(RemoteServer.SECURE) join(new SslHandler(engine)) else join()
     val timeout     = new ReadTimeoutHandler(timer, RemoteClient.READ_TIMEOUT.toMillis.toInt)
     val lenDec      = new LengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4)
diff --git a/akka-core/src/main/scala/remote/RemoteServer.scala b/akka-core/src/main/scala/remote/RemoteServer.scala
index f8512c5630..3dd9a204ea 100644
--- a/akka-core/src/main/scala/remote/RemoteServer.scala
+++ b/akka-core/src/main/scala/remote/RemoteServer.scala
@@ -311,10 +311,10 @@ object RemoteServerSslContext {
     val protocol  = "TLS"
     //val algorithm = Option(Security.getProperty("ssl.KeyManagerFactory.algorithm")).getOrElse("SunX509")
     //val store = KeyStore.getInstance("JKS")
-    
+
     val s = SSLContext.getInstance(protocol)
     s.init(null,null,null)
-    
+
     val c = SSLContext.getInstance(protocol)
     c.init(null,null,null)
 
@@ -379,11 +379,11 @@ class RemoteServerHandler(
   override def channelOpen(ctx: ChannelHandlerContext, event: ChannelStateEvent) {
     openChannels.add(ctx.getChannel)
   }
-  
+
   override def channelConnected(ctx : ChannelHandlerContext, e : ChannelStateEvent) {
     if(RemoteServer.SECURE) {
       val sslHandler : SslHandler = ctx.getPipeline.get(classOf[SslHandler])
- 
+
       // Begin handshake.
       sslHandler.handshake().addListener( new ChannelFutureListener {
         def operationComplete(future : ChannelFuture) : Unit = {
diff --git a/akka-core/src/test/scala/misc/SchedulerSpec.scala b/akka-core/src/test/scala/misc/SchedulerSpec.scala
index e1219d708a..510b24dedc 100644
--- a/akka-core/src/test/scala/misc/SchedulerSpec.scala
+++ b/akka-core/src/test/scala/misc/SchedulerSpec.scala
@@ -44,7 +44,7 @@ class SchedulerSpec extends JUnitSuite {
     // should still be 1 left
     assert(countDownLatch.getCount == 1)
   }
-  
+
   /**
    * ticket #372
    */
@@ -59,19 +59,19 @@ class SchedulerSpec extends JUnitSuite {
     assert(ticks.await(10,TimeUnit.SECONDS))
     assert(ActorRegistry.actors.length === numActors)
   }
-  
+
   /**
    * ticket #372
    */
   @Test def schedulerShouldBeCancellable = withCleanEndState {
     object Ping
     val ticks = new CountDownLatch(1)
-    
+
     val actor = actorOf(new Actor {
       def receive = { case Ping => ticks.countDown }
     }).start
 
-    (1 to 10).foreach { i => 
+    (1 to 10).foreach { i =>
       val future = Scheduler.scheduleOnce(actor,Ping,1,TimeUnit.SECONDS)
       future.cancel(true)
     }
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index aa65304666..5eb4347986 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -428,7 +428,7 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
   // -------------------------------------------------------------------------------------------------------------------
   // akka-persistence-common subproject
   // -------------------------------------------------------------------------------------------------------------------
-  
+
   class AkkaPersistenceCommonProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
     val commons_pool = Dependencies.commons_pool
     val thrift       = Dependencies.thrift
@@ -747,4 +747,4 @@ trait DeployProject { self: BasicScalaProject =>
 
 trait OSGiProject extends BNDPlugin { self: DefaultProject =>
   override def bndExportPackage = Seq("se.scalablesolutions.akka.*;version=%s".format(projectVersion.value))
-}
\ No newline at end of file
+}