Merge with master

akka-actor-tests/src/test/scala/akka/actor/TypedActorSpec.scala

@@ -4,7 +4,6 @@
 package akka.actor
 
 import language.postfixOps
-
 import org.scalatest.{ BeforeAndAfterAll, BeforeAndAfterEach }
 import akka.util.Timeout
 import scala.concurrent.{ Await, Future, Promise }
@@ -21,6 +20,7 @@ import akka.serialization.JavaSerializer
 import akka.actor.TypedActor._
 import java.lang.IllegalStateException
 import java.util.concurrent.{ TimeoutException, TimeUnit, CountDownLatch }
+import scala.concurrent.util.FiniteDuration
 
 object TypedActorSpec {
 
@@ -203,10 +203,10 @@ class TypedActorSpec extends AkkaSpec(TypedActorSpec.config)
 
   def newFooBar: Foo = newFooBar(Duration(2, "s"))
 
-  def newFooBar(d: Duration): Foo =
+  def newFooBar(d: FiniteDuration): Foo =
     TypedActor(system).typedActorOf(TypedProps[Bar](classOf[Foo], classOf[Bar]).withTimeout(Timeout(d)))
 
-  def newFooBar(dispatcher: String, d: Duration): Foo =
+  def newFooBar(dispatcher: String, d: FiniteDuration): Foo =
     TypedActor(system).typedActorOf(TypedProps[Bar](classOf[Foo], classOf[Bar]).withTimeout(Timeout(d)).withDispatcher(dispatcher))
 
   def newStacked(): Stacked =

akka-actor-tests/src/test/scala/akka/pattern/AskSpec.scala

@@ -68,16 +68,6 @@ class AskSpec extends AkkaSpec {
       }.getMessage must be === expectedMsg
     }
 
-    "return broken promises on infinite timeout" in {
-      implicit val timeout = Timeout.never
-      val echo = system.actorOf(Props(new Actor { def receive = { case x ⇒ sender ! x } }))
-      val f = echo ? "foo"
-      val expectedMsg = "Timeouts to `ask` must be finite. Question not sent to [%s]" format echo
-      intercept[IllegalArgumentException] {
-        Await.result(f, remaining)
-      }.getMessage must be === expectedMsg
-    }
-
   }
 
 }

akka-actor-tests/src/test/scala/akka/routing/ResizerSpec.scala

@@ -4,7 +4,6 @@
 package akka.routing
 
 import language.postfixOps
-
 import akka.actor.Actor
 import akka.testkit._
 import akka.actor.Props
@@ -15,6 +14,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import akka.pattern.ask
 import scala.concurrent.util.Duration
 import java.util.concurrent.TimeoutException
+import scala.concurrent.util.FiniteDuration
 
 object ResizerSpec {
 
@@ -174,8 +174,8 @@ class ResizerSpec extends AkkaSpec(ResizerSpec.config) with DefaultTimeout with
 
       val router = system.actorOf(Props(new Actor {
         def receive = {
-          case d: Duration ⇒ Thread.sleep(d.dilated.toMillis); sender ! "done"
+          case d: FiniteDuration ⇒ Thread.sleep(d.dilated.toMillis); sender ! "done"
-          case "echo"      ⇒ sender ! "reply"
+          case "echo"            ⇒ sender ! "reply"
         }
       }).withRouter(RoundRobinRouter(resizer = Some(resizer))))
 
@@ -190,7 +190,7 @@ class ResizerSpec extends AkkaSpec(ResizerSpec.config) with DefaultTimeout with
 
       routees(router) must be(3)
 
-      def loop(loops: Int, d: Duration) = {
+      def loop(loops: Int, d: FiniteDuration) = {
         for (m ← 0 until loops) router ! d
         for (m ← 0 until loops) expectMsg(d * 3, "done")
       }

akka-actor/src/main/scala/akka/actor/TypedActor.scala

@@ -4,7 +4,6 @@
 package akka.actor
 
 import language.existentials
-
 import akka.japi.{ Creator, Option ⇒ JOption }
 import java.lang.reflect.{ InvocationTargetException, Method, InvocationHandler, Proxy }
 import akka.util.Timeout
@@ -20,6 +19,7 @@ import scala.reflect.ClassTag
 import akka.serialization.{ JavaSerializer, SerializationExtension }
 import java.io.ObjectStreamException
 import scala.util.{ Try, Success, Failure }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * A TypedActorFactory is something that can created TypedActor instances.
@@ -421,7 +421,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
   /**
    * INTERNAL USE ONLY
    */
-  private[akka] case class SerializedTypedActorInvocationHandler(val actor: ActorRef, val timeout: Duration) {
+  private[akka] case class SerializedTypedActorInvocationHandler(val actor: ActorRef, val timeout: FiniteDuration) {
     @throws(classOf[ObjectStreamException]) private def readResolve(): AnyRef = JavaSerializer.currentSystem.value match {
       case null ⇒ throw new IllegalStateException("SerializedTypedActorInvocationHandler.readResolve requires that JavaSerializer.currentSystem.value is set to a non-null value")
       case some ⇒ toTypedActorInvocationHandler(some)

akka-actor/src/main/scala/akka/actor/dsl/Inbox.scala

@@ -169,7 +169,7 @@ trait Inbox { this: ActorDSL.type ⇒
      * this method within an actor!</b>
      */
     def receive(timeout: FiniteDuration = defaultTimeout): Any = {
-      implicit val t = Timeout(timeout + extraTime)
+      implicit val t = Timeout((timeout + extraTime).asInstanceOf[FiniteDuration])
       Await.result(receiver ? Get(Deadline.now + timeout), Duration.Inf)
     }
 
@@ -186,7 +186,7 @@ trait Inbox { this: ActorDSL.type ⇒
      * this method within an actor!</b>
      */
     def select[T](timeout: FiniteDuration = defaultTimeout)(predicate: PartialFunction[Any, T]): T = {
-      implicit val t = Timeout(timeout + extraTime)
+      implicit val t = Timeout((timeout + extraTime).asInstanceOf[FiniteDuration])
       predicate(Await.result(receiver ? Select(Deadline.now + timeout, predicate), Duration.Inf))
     }
 

akka-actor/src/main/scala/akka/pattern/AskSupport.scala

@@ -78,8 +78,7 @@ trait AskSupport {
       actorRef.tell(message)
       Future.failed[Any](new AskTimeoutException("Recipient[%s] had already been terminated." format actorRef))
     case ref: InternalActorRef ⇒
-      if (!timeout.duration.isFinite) Future.failed[Any](new IllegalArgumentException("Timeouts to `ask` must be finite. Question not sent to [%s]" format actorRef))
+      if (timeout.duration.length <= 0) Future.failed[Any](new IllegalArgumentException("Timeout length for an `ask` must be greater or equal to 1.  Question not sent to [%s]" format actorRef))
-      else if (timeout.duration.length <= 0) Future.failed[Any](new IllegalArgumentException("Timeout length for an `ask` must be greater or equal to 1.  Question not sent to [%s]" format actorRef))
       else {
         val provider = ref.provider
         val a = PromiseActorRef(provider, timeout)

akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala

@@ -10,7 +10,7 @@ import akka.util.Unsafe
 import scala.util.control.NoStackTrace
 import java.util.concurrent.{ Callable, CopyOnWriteArrayList }
 import scala.concurrent.{ ExecutionContext, Future, Promise, Await }
-import scala.concurrent.util.{ Duration, Deadline }
+import scala.concurrent.util.{ FiniteDuration, Deadline }
 import scala.concurrent.util.duration._
 import scala.util.control.NonFatal
 import scala.util.Success
@@ -38,8 +38,8 @@ object CircuitBreaker {
    * @param callTimeout [[scala.concurrent.util.Duration]] of time after which to consider a call a failure
    * @param resetTimeout [[scala.concurrent.util.Duration]] of time after which to attempt to close the circuit
    */
-  def apply(scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration): CircuitBreaker =
+  def apply(scheduler: Scheduler, maxFailures: Int, callTimeout: FiniteDuration, resetTimeout: FiniteDuration): CircuitBreaker =
-    new CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration)(syncExecutionContext)
+    new CircuitBreaker(scheduler, maxFailures, callTimeout, resetTimeout)(syncExecutionContext)
 
   /**
    * Callbacks run in caller's thread when using withSyncCircuitBreaker, and in same ExecutionContext as the passed
@@ -52,8 +52,8 @@ object CircuitBreaker {
    * @param callTimeout [[scala.concurrent.util.Duration]] of time after which to consider a call a failure
    * @param resetTimeout [[scala.concurrent.util.Duration]] of time after which to attempt to close the circuit
    */
-  def create(scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration): CircuitBreaker =
+  def create(scheduler: Scheduler, maxFailures: Int, callTimeout: FiniteDuration, resetTimeout: FiniteDuration): CircuitBreaker =
-    apply(scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration)
+    apply(scheduler, maxFailures, callTimeout, resetTimeout)
 }
 
 /**
@@ -76,9 +76,9 @@ object CircuitBreaker {
  * @param resetTimeout [[scala.concurrent.util.Duration]] of time after which to attempt to close the circuit
  * @param executor [[scala.concurrent.ExecutionContext]] used for execution of state transition listeners
  */
-class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration)(implicit executor: ExecutionContext) extends AbstractCircuitBreaker {
+class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: FiniteDuration, resetTimeout: FiniteDuration)(implicit executor: ExecutionContext) extends AbstractCircuitBreaker {
 
-  def this(executor: ExecutionContext, scheduler: Scheduler, maxFailures: Int, callTimeout: Duration, resetTimeout: Duration) = {
+  def this(executor: ExecutionContext, scheduler: Scheduler, maxFailures: Int, callTimeout: FiniteDuration, resetTimeout: FiniteDuration) = {
     this(scheduler, maxFailures, callTimeout, resetTimeout)(executor)
   }
 
@@ -409,7 +409,7 @@ class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Durati
      * @return Future containing result of protected call
      */
     override def invoke[T](body: ⇒ Future[T]): Future[T] =
-      if (compareAndSet(true, false)) callThrough(body) else Promise.failed[T](new CircuitBreakerOpenException(Duration.Zero)).future
+      if (compareAndSet(true, false)) callThrough(body) else Promise.failed[T](new CircuitBreakerOpenException(0.seconds)).future
 
     /**
      * Reset breaker on successful call.
@@ -453,7 +453,7 @@ class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Durati
      * @return Future containing result of protected call
      */
     override def invoke[T](body: ⇒ Future[T]): Future[T] =
-      Promise.failed[T](new CircuitBreakerOpenException(remainingTimeout().timeLeft)).future
+      Promise.failed[T](new CircuitBreakerOpenException(remainingTimeout().timeLeft.asInstanceOf[FiniteDuration])).future
 
     /**
      * Calculate remaining timeout to inform the caller in case a backoff algorithm is useful
@@ -510,6 +510,6 @@ class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Durati
  * @param message Defaults to "Circuit Breaker is open; calls are failing fast"
  */
 class CircuitBreakerOpenException(
-  val remainingDuration: Duration,
+  val remainingDuration: FiniteDuration,
   message: String = "Circuit Breaker is open; calls are failing fast")
   extends AkkaException(message) with NoStackTrace

akka-actor/src/main/scala/akka/pattern/GracefulStopSupport.scala

@@ -10,6 +10,7 @@ import akka.dispatch.{ Unwatch, Watch }
 import scala.concurrent.Future
 import scala.concurrent.util.Duration
 import scala.util.Success
+import scala.concurrent.util.FiniteDuration
 
 trait GracefulStopSupport {
   /**
@@ -36,7 +37,7 @@ trait GracefulStopSupport {
    * If the target actor isn't terminated within the timeout the [[scala.concurrent.Future]]
    * is completed with failure [[akka.pattern.AskTimeoutException]].
    */
-  def gracefulStop(target: ActorRef, timeout: Duration)(implicit system: ActorSystem): Future[Boolean] = {
+  def gracefulStop(target: ActorRef, timeout: FiniteDuration)(implicit system: ActorSystem): Future[Boolean] = {
     if (target.isTerminated) Future successful true
     else system match {
       case e: ExtendedActorSystem ⇒

akka-actor/src/main/scala/akka/pattern/Patterns.scala

@@ -6,6 +6,7 @@ package akka.pattern
 import akka.actor.Scheduler
 import scala.concurrent.ExecutionContext
 import java.util.concurrent.Callable
+import scala.concurrent.util.FiniteDuration
 
 object Patterns {
   import akka.actor.{ ActorRef, ActorSystem }
@@ -103,7 +104,7 @@ object Patterns {
    * If the target actor isn't terminated within the timeout the [[scala.concurrent.Future]]
    * is completed with failure [[akka.pattern.AskTimeoutException]].
    */
-  def gracefulStop(target: ActorRef, timeout: Duration, system: ActorSystem): Future[java.lang.Boolean] =
+  def gracefulStop(target: ActorRef, timeout: FiniteDuration, system: ActorSystem): Future[java.lang.Boolean] =
     scalaGracefulStop(target, timeout)(system).asInstanceOf[Future[java.lang.Boolean]]
 
   /**

akka-actor/src/main/scala/akka/routing/Routing.scala

@@ -5,7 +5,6 @@ package akka.routing
 
 import language.implicitConversions
 import language.postfixOps
-
 import akka.actor._
 import scala.concurrent.util.Duration
 import scala.concurrent.util.duration._
@@ -19,6 +18,7 @@ import scala.concurrent.forkjoin.ThreadLocalRandom
 import akka.dispatch.Dispatchers
 import scala.annotation.tailrec
 import concurrent.ExecutionContext
+import scala.concurrent.util.FiniteDuration
 
 /**
  * A RoutedActorRef is an ActorRef that has a set of connected ActorRef and it uses a Router to
@@ -1098,13 +1098,13 @@ object ScatterGatherFirstCompletedRouter {
   /**
    * Creates a new ScatterGatherFirstCompletedRouter, routing to the specified routees, timing out after the specified Duration
    */
-  def apply(routees: Iterable[ActorRef], within: Duration): ScatterGatherFirstCompletedRouter =
+  def apply(routees: Iterable[ActorRef], within: FiniteDuration): ScatterGatherFirstCompletedRouter =
     new ScatterGatherFirstCompletedRouter(routees = routees map (_.path.toString), within = within)
 
   /**
    * Java API to create router with the supplied 'routees' actors.
    */
-  def create(routees: java.lang.Iterable[ActorRef], within: Duration): ScatterGatherFirstCompletedRouter = {
+  def create(routees: java.lang.Iterable[ActorRef], within: FiniteDuration): ScatterGatherFirstCompletedRouter = {
     import scala.collection.JavaConverters._
     apply(routees.asScala, within)
   }
@@ -1153,7 +1153,7 @@ object ScatterGatherFirstCompletedRouter {
  *   using `actorFor` in [[akka.actor.ActorRefProvider]]
  */
 @SerialVersionUID(1L)
-case class ScatterGatherFirstCompletedRouter(nrOfInstances: Int = 0, routees: Iterable[String] = Nil, within: Duration,
+case class ScatterGatherFirstCompletedRouter(nrOfInstances: Int = 0, routees: Iterable[String] = Nil, within: FiniteDuration,
                                              override val resizer: Option[Resizer] = None,
                                              val routerDispatcher: String = Dispatchers.DefaultDispatcherId,
                                              val supervisorStrategy: SupervisorStrategy = Router.defaultSupervisorStrategy)
@@ -1166,7 +1166,7 @@ case class ScatterGatherFirstCompletedRouter(nrOfInstances: Int = 0, routees: It
    * Constructor that sets nrOfInstances to be created.
    * Java API
    */
-  def this(nr: Int, w: Duration) = this(nrOfInstances = nr, within = w)
+  def this(nr: Int, w: FiniteDuration) = this(nrOfInstances = nr, within = w)
 
   /**
    * Constructor that sets the routees to be used.
@@ -1174,14 +1174,14 @@ case class ScatterGatherFirstCompletedRouter(nrOfInstances: Int = 0, routees: It
    * @param routeePaths string representation of the actor paths of the routees that will be looked up
    *   using `actorFor` in [[akka.actor.ActorRefProvider]]
    */
-  def this(routeePaths: java.lang.Iterable[String], w: Duration) =
+  def this(routeePaths: java.lang.Iterable[String], w: FiniteDuration) =
     this(routees = iterableAsScalaIterable(routeePaths), within = w)
 
   /**
    * Constructor that sets the resizer to be used.
    * Java API
    */
-  def this(resizer: Resizer, w: Duration) = this(resizer = Some(resizer), within = w)
+  def this(resizer: Resizer, w: FiniteDuration) = this(resizer = Some(resizer), within = w)
 
   /**
    * Java API for setting routerDispatcher
@@ -1211,7 +1211,7 @@ trait ScatterGatherFirstCompletedLike { this: RouterConfig ⇒
 
   def routees: Iterable[String]
 
-  def within: Duration
+  def within: FiniteDuration
 
   def createRoute(routeeProvider: RouteeProvider): Route = {
     if (resizer.isEmpty) {

akka-actor/src/main/scala/akka/util/Timeout.scala

@@ -8,10 +8,10 @@ import language.implicitConversions
 
 import java.util.concurrent.TimeUnit
 import java.lang.{ Double ⇒ JDouble }
-import scala.concurrent.util.Duration
+import scala.concurrent.util.{ Duration, FiniteDuration }
 
 @SerialVersionUID(1L)
-case class Timeout(duration: Duration) {
+case class Timeout(duration: FiniteDuration) {
   def this(timeout: Long) = this(Duration(timeout, TimeUnit.MILLISECONDS))
   def this(length: Long, unit: TimeUnit) = this(Duration(length, unit))
 }
@@ -26,17 +26,10 @@ object Timeout {
    */
   val zero: Timeout = new Timeout(Duration.Zero)
 
-  /**
-   * A Timeout with infinite duration. Will never timeout. Use extreme caution with this
-   * as it may cause memory leaks, blocked threads, or may not even be supported by
-   * the receiver, which would result in an exception.
-   */
-  val never: Timeout = new Timeout(Duration.Inf)
-
   def apply(timeout: Long): Timeout = new Timeout(timeout)
   def apply(length: Long, unit: TimeUnit): Timeout = new Timeout(length, unit)
 
-  implicit def durationToTimeout(duration: Duration): Timeout = new Timeout(duration)
+  implicit def durationToTimeout(duration: FiniteDuration): Timeout = new Timeout(duration)
   implicit def intToTimeout(timeout: Int): Timeout = new Timeout(timeout)
   implicit def longToTimeout(timeout: Long): Timeout = new Timeout(timeout)
 }

akka-agent/src/main/scala/akka/agent/Agent.scala

@@ -10,7 +10,7 @@ import akka.pattern.ask
 import akka.util.Timeout
 import scala.concurrent.stm._
 import scala.concurrent.{ ExecutionContext, Future, Promise, Await }
-import scala.concurrent.util.Duration
+import scala.concurrent.util.{ FiniteDuration, Duration }
 
 /**
  * Used internally to send functions.
@@ -240,7 +240,7 @@ class Agent[T](initialValue: T, refFactory: ActorRefFactory, system: ActorSystem
    * Dispatch a function to update the internal state, and return a Future where that new state can be obtained
    * within the given timeout
    */
-  def alter(f: JFunc[T, T], timeout: Duration): Future[T] = alter(x ⇒ f(x))(timeout)
+  def alter(f: JFunc[T, T], timeout: FiniteDuration): Future[T] = alter(x ⇒ f(x))(timeout)
 
   /**
    * Java API:
@@ -259,7 +259,7 @@ class Agent[T](initialValue: T, refFactory: ActorRefFactory, system: ActorSystem
    * or blocking operations. Dispatches using either `alterOff` or `alter` will
    * still be executed in order.
    */
-  def alterOff(f: JFunc[T, T], timeout: Duration, ec: ExecutionContext): Unit = alterOff(x ⇒ f(x))(Timeout(timeout), ec)
+  def alterOff(f: JFunc[T, T], timeout: FiniteDuration, ec: ExecutionContext): Unit = alterOff(x ⇒ f(x))(Timeout(timeout), ec)
 
   /**
    * Java API:

akka-camel/src/main/scala/akka/camel/Activation.scala

@@ -10,6 +10,7 @@ import akka.actor.{ ActorSystem, Props, ActorRef }
 import akka.pattern._
 import scala.concurrent.util.Duration
 import concurrent.{ ExecutionContext, Future }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * Activation trait that can be used to wait on activation or de-activation of Camel endpoints.
@@ -27,7 +28,7 @@ trait Activation {
    * @param endpoint the endpoint to be activated
    * @param timeout the timeout for the Future
    */
-  def activationFutureFor(endpoint: ActorRef)(implicit timeout: Duration, executor: ExecutionContext): Future[ActorRef] =
+  def activationFutureFor(endpoint: ActorRef)(implicit timeout: FiniteDuration, executor: ExecutionContext): Future[ActorRef] =
     (activationTracker.ask(AwaitActivation(endpoint))(Timeout(timeout))).map[ActorRef]({
       case EndpointActivated(`endpoint`)               ⇒ endpoint
       case EndpointFailedToActivate(`endpoint`, cause) ⇒ throw cause
@@ -40,7 +41,7 @@ trait Activation {
    * @param endpoint the endpoint to be deactivated
    * @param timeout the timeout of the Future
    */
-  def deactivationFutureFor(endpoint: ActorRef)(implicit timeout: Duration, executor: ExecutionContext): Future[ActorRef] =
+  def deactivationFutureFor(endpoint: ActorRef)(implicit timeout: FiniteDuration, executor: ExecutionContext): Future[ActorRef] =
     (activationTracker.ask(AwaitDeActivation(endpoint))(Timeout(timeout))).map[ActorRef]({
       case EndpointDeActivated(`endpoint`)               ⇒ endpoint
       case EndpointFailedToDeActivate(`endpoint`, cause) ⇒ throw cause

akka-camel/src/main/scala/akka/camel/Consumer.scala

@@ -5,12 +5,12 @@
 package akka.camel
 
 import language.postfixOps
-
 import internal.component.DurationTypeConverter
 import org.apache.camel.model.{ RouteDefinition, ProcessorDefinition }
 import akka.actor._
 import scala.concurrent.util.Duration
 import scala.concurrent.util.duration._
+import scala.concurrent.util.FiniteDuration
 
 /**
  * Mixed in by Actor implementations that consume message from Camel endpoints.
@@ -41,7 +41,7 @@ trait ConsumerConfig { this: CamelSupport ⇒
   /**
    * How long the actor should wait for activation before it fails.
    */
-  def activationTimeout: Duration = camel.settings.activationTimeout
+  def activationTimeout: FiniteDuration = camel.settings.activationTimeout
 
   /**
    * When endpoint is out-capable (can produce responses) replyTimeout is the maximum time

akka-camel/src/main/scala/akka/camel/internal/ConsumerRegistry.scala

@@ -7,9 +7,7 @@ package akka.camel.internal
 import akka.camel._
 import component.CamelPath
 import java.io.InputStream
-
 import org.apache.camel.builder.RouteBuilder
-
 import akka.actor._
 import collection.mutable
 import org.apache.camel.model.RouteDefinition
@@ -17,6 +15,7 @@ import org.apache.camel.CamelContext
 import scala.concurrent.util.Duration
 import concurrent.Await
 import akka.util.Timeout
+import scala.concurrent.util.FiniteDuration
 
 /**
  * For internal use only.
@@ -38,7 +37,7 @@ private[camel] trait ConsumerRegistry { this: Activation ⇒
    * @param activationTimeout the timeout for activation
    * @return the actorRef to the consumer
    */
-  private[camel] def registerConsumer(endpointUri: String, consumer: Consumer, activationTimeout: Duration) = {
+  private[camel] def registerConsumer(endpointUri: String, consumer: Consumer, activationTimeout: FiniteDuration) = {
     idempotentRegistry ! RegisterConsumer(endpointUri, consumer.self, consumer)
     Await.result(activationFutureFor(consumer.self)(activationTimeout, consumer.context.dispatcher), activationTimeout)
   }

akka-camel/src/main/scala/akka/camel/internal/DefaultCamel.scala

@@ -8,8 +8,8 @@ import akka.event.Logging
 import akka.camel.{ CamelSettings, Camel }
 import scala.util.control.NonFatal
 import scala.concurrent.util.Duration
-
 import org.apache.camel.{ ProducerTemplate, CamelContext }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * For internal use only.
@@ -32,7 +32,7 @@ private[camel] class DefaultCamel(val system: ActorSystem) extends Camel {
     ctx.setName(system.name)
     ctx.setStreamCaching(true)
     ctx.addComponent("akka", new ActorComponent(this, system))
-    ctx.getTypeConverterRegistry.addTypeConverter(classOf[Duration], classOf[String], DurationTypeConverter)
+    ctx.getTypeConverterRegistry.addTypeConverter(classOf[FiniteDuration], classOf[String], DurationTypeConverter)
     ctx
   }
 

akka-camel/src/main/scala/akka/camel/internal/component/ActorComponent.scala

@@ -5,15 +5,11 @@
 package akka.camel.internal.component
 
 import language.postfixOps
-
 import java.util.{ Map ⇒ JMap }
-
 import org.apache.camel._
 import org.apache.camel.impl.{ DefaultProducer, DefaultEndpoint, DefaultComponent }
-
 import akka.actor._
 import akka.pattern._
-
 import scala.reflect.BeanProperty
 import scala.concurrent.util.duration._
 import scala.concurrent.util.Duration
@@ -25,6 +21,7 @@ import akka.camel.internal.CamelExchangeAdapter
 import akka.camel.{ ActorNotRegisteredException, Camel, Ack, FailureResult, CamelMessage }
 import support.TypeConverterSupport
 import scala.util.{ Failure, Success, Try }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * For internal use only.
@@ -98,7 +95,7 @@ private[camel] trait ActorEndpointConfig {
   def path: ActorEndpointPath
   def camel: Camel
 
-  @BeanProperty var replyTimeout: Duration = camel.settings.replyTimeout
+  @BeanProperty var replyTimeout: FiniteDuration = camel.settings.replyTimeout
 
   @BeanProperty var autoAck: Boolean = camel.settings.autoAck
 }

akka-camel/src/test/java/akka/camel/ConsumerJavaTestBase.java

@@ -4,20 +4,22 @@
 
 package akka.camel;
 
-import akka.actor.ActorRef;
+import static org.junit.Assert.assertEquals;
-import akka.actor.ActorSystem;
+
-import akka.actor.Props;
+import java.util.concurrent.TimeUnit;
-import akka.testkit.JavaTestKit;
+
+import org.junit.AfterClass;
+import org.junit.Test;
+
 import scala.concurrent.Await;
 import scala.concurrent.ExecutionContext;
 import scala.concurrent.util.Duration;
-import org.junit.AfterClass;
+import scala.concurrent.util.FiniteDuration;
-import org.junit.Test;
+import akka.actor.ActorRef;
-import java.util.concurrent.TimeUnit;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
 import akka.testkit.AkkaSpec;
-import akka.testkit.JavaTestKit.EventFilter;
+import akka.testkit.JavaTestKit;
-
-import static org.junit.Assert.assertEquals;
 
 
 /**
@@ -37,7 +39,7 @@ public class ConsumerJavaTestBase {
         new JavaTestKit(system) {{
             String result = new EventFilter<String>(Exception.class) {
                 protected String run() {
-                    Duration timeout = Duration.create(1, TimeUnit.SECONDS);
+                    FiniteDuration timeout = Duration.create(1, TimeUnit.SECONDS);
                     Camel camel = CamelExtension.get(system);
                     ExecutionContext executionContext = system.dispatcher();
                     try {

akka-camel/src/test/java/akka/camel/CustomRouteTestBase.java

@@ -7,6 +7,7 @@ import akka.camel.javaapi.UntypedProducerActor;
 import scala.concurrent.Await;
 import scala.concurrent.ExecutionContext;
 import scala.concurrent.util.Duration;
+import scala.concurrent.util.FiniteDuration;
 import org.apache.camel.CamelExecutionException;
 import org.apache.camel.Exchange;
 import org.apache.camel.Predicate;
@@ -59,7 +60,7 @@ public class CustomRouteTestBase {
   @Test
   public void testCustomConsumerRoute() throws Exception {
     MockEndpoint mockEndpoint = camel.context().getEndpoint("mock:mockConsumer", MockEndpoint.class);
-    Duration timeout = Duration.create(10, TimeUnit.SECONDS);
+    FiniteDuration timeout = Duration.create(10, TimeUnit.SECONDS);
     ExecutionContext executionContext = system.dispatcher();
     ActorRef consumer = Await.result(
             camel.activationFutureFor(system.actorOf(new Props(TestConsumer.class), "testConsumer"), timeout, executionContext),
@@ -73,7 +74,7 @@ public class CustomRouteTestBase {
   @Test
   public void testCustomAckConsumerRoute() throws Exception {
     MockEndpoint mockEndpoint = camel.context().getEndpoint("mock:mockAck", MockEndpoint.class);
-    Duration timeout = Duration.create(10, TimeUnit.SECONDS);
+    FiniteDuration timeout = Duration.create(10, TimeUnit.SECONDS);
     ExecutionContext executionContext = system.dispatcher();
     ActorRef consumer = Await.result(
       camel.activationFutureFor(
@@ -91,7 +92,7 @@ public class CustomRouteTestBase {
   public void testCustomAckConsumerRouteFromUri() throws Exception {
     MockEndpoint mockEndpoint = camel.context().getEndpoint("mock:mockAckUri", MockEndpoint.class);
       ExecutionContext executionContext = system.dispatcher();
-    Duration timeout = Duration.create(10, TimeUnit.SECONDS);
+    FiniteDuration timeout = Duration.create(10, TimeUnit.SECONDS);
     ActorRef consumer = Await.result(
         camel.activationFutureFor(system.actorOf(new Props( new UntypedActorFactory(){ public Actor create() { return new TestAckConsumer("direct:testConsumerAckFromUri","mock:mockAckUri"); } }), "testConsumerAckUri"),
       timeout, executionContext),
@@ -104,7 +105,7 @@ public class CustomRouteTestBase {
 
   @Test(expected=CamelExecutionException.class)
   public void testCustomTimeoutConsumerRoute() throws Exception {
-    Duration timeout = Duration.create(10, TimeUnit.SECONDS);
+    FiniteDuration timeout = Duration.create(10, TimeUnit.SECONDS);
     ExecutionContext executionContext = system.dispatcher();
     ActorRef consumer = Await.result(
       camel.activationFutureFor(system.actorOf(new Props( new UntypedActorFactory(){ public Actor create() { return new TestAckConsumer("direct:testConsumerException","mock:mockException"); } }), "testConsumerException"),

akka-camel/src/test/scala/akka/camel/internal/ActivationTrackerTest.scala

@@ -1,7 +1,6 @@
 package akka.camel.internal
 
 import language.postfixOps
-
 import org.scalatest.matchers.MustMatchers
 import scala.concurrent.util.duration._
 import org.scalatest.{ GivenWhenThen, BeforeAndAfterEach, BeforeAndAfterAll, WordSpec }
@@ -9,6 +8,7 @@ import akka.actor.{ Props, ActorSystem }
 import scala.concurrent.util.Duration
 import akka.camel._
 import akka.testkit.{ TimingTest, TestProbe, TestKit }
+import scala.concurrent.util.FiniteDuration
 
 class ActivationTrackerTest extends TestKit(ActorSystem("test")) with WordSpec with MustMatchers with BeforeAndAfterAll with BeforeAndAfterEach with GivenWhenThen {
 
@@ -115,11 +115,11 @@ class ActivationTrackerTest extends TestKit(ActorSystem("test")) with WordSpec w
     val probe = TestProbe()
     def awaitActivation() = at.tell(AwaitActivation(actor.ref), probe.ref)
     def awaitDeActivation() = at.tell(AwaitDeActivation(actor.ref), probe.ref)
-    def verifyActivated(timeout: Duration = 50 millis) = within(timeout) { probe.expectMsg(EndpointActivated(actor.ref)) }
+    def verifyActivated(timeout: FiniteDuration = 50 millis) = within(timeout) { probe.expectMsg(EndpointActivated(actor.ref)) }
-    def verifyDeActivated(timeout: Duration = 50 millis) = within(timeout) { probe.expectMsg(EndpointDeActivated(actor.ref)) }
+    def verifyDeActivated(timeout: FiniteDuration = 50 millis) = within(timeout) { probe.expectMsg(EndpointDeActivated(actor.ref)) }
 
-    def verifyFailedToActivate(timeout: Duration = 50 millis) = within(timeout) { probe.expectMsg(EndpointFailedToActivate(actor.ref, cause)) }
+    def verifyFailedToActivate(timeout: FiniteDuration = 50 millis) = within(timeout) { probe.expectMsg(EndpointFailedToActivate(actor.ref, cause)) }
-    def verifyFailedToDeActivate(timeout: Duration = 50 millis) = within(timeout) { probe.expectMsg(EndpointFailedToDeActivate(actor.ref, cause)) }
+    def verifyFailedToDeActivate(timeout: FiniteDuration = 50 millis) = within(timeout) { probe.expectMsg(EndpointFailedToDeActivate(actor.ref, cause)) }
 
   }
 

akka-camel/src/test/scala/akka/camel/internal/component/ActorProducerTest.scala

@@ -5,7 +5,6 @@
 package akka.camel.internal.component
 
 import language.postfixOps
-
 import org.scalatest.mock.MockitoSugar
 import org.mockito.Matchers.any
 import org.mockito.Mockito._
@@ -27,6 +26,7 @@ import com.typesafe.config.ConfigFactory
 import akka.actor.ActorSystem.Settings
 import akka.event.LoggingAdapter
 import akka.testkit.{ TimingTest, TestKit, TestProbe }
+import scala.concurrent.util.FiniteDuration
 
 class ActorProducerTest extends TestKit(ActorSystem("test")) with WordSpec with MustMatchers with ActorProducerFixture {
 
@@ -303,7 +303,7 @@ trait ActorProducerFixture extends MockitoSugar with BeforeAndAfterAll with Befo
 
   def msg(s: String) = CamelMessage(s, Map.empty)
 
-  def given(actor: ActorRef = probe.ref, outCapable: Boolean = true, autoAck: Boolean = true, replyTimeout: Duration = Int.MaxValue seconds) = {
+  def given(actor: ActorRef = probe.ref, outCapable: Boolean = true, autoAck: Boolean = true, replyTimeout: FiniteDuration = Int.MaxValue seconds) = {
     prepareMocks(actor, outCapable = outCapable)
     new ActorProducer(configure(isAutoAck = autoAck, _replyTimeout = replyTimeout), camel)
   }
@@ -325,16 +325,16 @@ trait ActorProducerFixture extends MockitoSugar with BeforeAndAfterAll with Befo
       callbackReceived.countDown()
     }
 
-    private[this] def valueWithin(implicit timeout: Duration) =
+    private[this] def valueWithin(implicit timeout: FiniteDuration) =
       if (!callbackReceived.await(timeout.toNanos, TimeUnit.NANOSECONDS)) fail("Callback not received!")
       else callbackValue.get
 
-    def expectDoneSyncWithin(implicit timeout: Duration): Unit = if (!valueWithin(timeout)) fail("Expected to be done Synchronously")
+    def expectDoneSyncWithin(implicit timeout: FiniteDuration): Unit = if (!valueWithin(timeout)) fail("Expected to be done Synchronously")
-    def expectDoneAsyncWithin(implicit timeout: Duration): Unit = if (valueWithin(timeout)) fail("Expected to be done Asynchronously")
+    def expectDoneAsyncWithin(implicit timeout: FiniteDuration): Unit = if (valueWithin(timeout)) fail("Expected to be done Asynchronously")
 
   }
 
-  def configure(endpointUri: String = "test-uri", isAutoAck: Boolean = true, _replyTimeout: Duration = Int.MaxValue seconds) = {
+  def configure(endpointUri: String = "test-uri", isAutoAck: Boolean = true, _replyTimeout: FiniteDuration = Int.MaxValue seconds) = {
     val endpoint = new ActorEndpoint(endpointUri, actorComponent, actorEndpointPath, camel)
     endpoint.autoAck = isAutoAck
     endpoint.replyTimeout = _replyTimeout

akka-cluster/src/main/scala/akka/cluster/ClusterActorRefProvider.scala

@@ -15,7 +15,7 @@ import akka.cluster.routing.ClusterRouterConfig
 import akka.event.EventStream
 import akka.remote.RemoteActorRefProvider
 import akka.remote.RemoteDeployer
-import akka.routing.RemoteRouterConfig
+import akka.remote.routing.RemoteRouterConfig
 import akka.cluster.routing.ClusterRouterSettings
 
 class ClusterActorRefProvider(

akka-cluster/src/main/scala/akka/cluster/routing/ClusterRouterConfig.scala

@@ -28,7 +28,7 @@ import akka.routing.Route
 import akka.routing.RouteeProvider
 import akka.routing.Router
 import akka.routing.RouterConfig
-import akka.routing.RemoteRouterConfig
+import akka.remote.routing.RemoteRouterConfig
 import akka.actor.RootActorPath
 import akka.actor.ActorCell
 import akka.actor.RelativeActorPath

akka-docs/common/circuitbreaker.rst

@@ -51,28 +51,7 @@ What do they do?
 	* Callbacks can be provided for every state entry via `onOpen`, `onClose`, and `onHalfOpen`
 	* These are executed in the :class:`ExecutionContext` provided. 
 
-.. graphviz::
+.. image:: ../images/circuit-breaker-states.png
-
-	digraph circuit_breaker {
-		rankdir = "LR";
-		size = "6,5";
-		graph [ bgcolor = "transparent" ]
-		node [ fontname = "Helvetica",
-					 fontsize = 14,
-					 shape = circle, 
-					 color = white, 
-					 style = filled ];
-	  edge [ fontname = "Helvetica", fontsize = 12 ]
-		Closed [ fillcolor = green2 ];
-		"Half-Open" [fillcolor = yellow2 ];
-		Open [ fillcolor = red2 ];
-		Closed -> Closed [ label = "Success" ];
-		"Half-Open" -> Open [ label = "Trip Breaker" ];
-		"Half-Open" -> Closed [ label = "Reset Breaker" ];
-		Closed -> Open [ label = "Trip Breaker" ];
-		Open -> Open [ label = "Calls failing fast" ];
-		Open -> "Half-Open" [ label = "Attempt Reset" ];
-	}
 
 ========
 Examples

akka-docs/common/code/docs/circuitbreaker/DangerousJavaActor.java

@@ -27,7 +27,7 @@ public class DangerousJavaActor extends UntypedActor {
     public DangerousJavaActor() {
         this.breaker = new CircuitBreaker(
                 getContext().dispatcher(), getContext().system().scheduler(),
-                5, Duration.parse("10s"), Duration.parse("1m"))
+                5, Duration.create(10, "s"), Duration.create(1, "m"))
                 .onOpen(new Callable<Object>() {
                     public Object call() throws Exception {
                         notifyMeOnOpen();

akka-docs/conf.py

@@ -8,7 +8,7 @@ import sys, os
 # -- General configuration -----------------------------------------------------
 
 sys.path.append(os.path.abspath('_sphinx/exts'))
-extensions = ['sphinx.ext.todo', 'includecode', 'sphinx.ext.graphviz']
+extensions = ['sphinx.ext.todo', 'includecode']
 
 templates_path = ['_templates']
 source_suffix = '.rst'

akka-docs/dev/multi-jvm-testing.rst

@@ -18,7 +18,7 @@ http://github.com/typesafehub/sbt-multi-jvm
 
 You can add it as a plugin by adding the following to your project/plugins.sbt::
 
-   addSbtPlugin("com.typesafe.sbt" % "sbt-multi-jvm" % "0.2.0")
+   addSbtPlugin("com.typesafe.sbt" % "sbt-multi-jvm" % "0.3.0")
 
 You can then add multi-JVM testing to ``project/Build.scala`` by including the ``MultiJvm``
 settings and config. For example, here is an example of how the akka-remote-tests project adds
@@ -47,7 +47,7 @@ multi-JVM testing (Simplified for clarity):
       )
     ) configs (MultiJvm)
 
-    lazy val buildSettings = Defaults.defaultSettings ++ SbtMultiJvm.settings ++ Seq(
+    lazy val buildSettings = Defaults.defaultSettings ++ SbtMultiJvm.multiJvmSettings ++ Seq(
       organization := "com.typesafe.akka",
       version      := "2.1-SNAPSHOT",
       scalaVersion := "|scalaVersion|",

akka-docs/general/addressing.rst

@@ -210,7 +210,7 @@ Querying the Logical Actor Hierarchy
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Since the actor system forms a file-system like hierarchy, matching on paths is
-possible in the same was as supported by Unix shells: you may replace (parts
+possible in the same way as supported by Unix shells: you may replace (parts
 of) path element names with wildcards (`«*»` and `«?»`) to formulate a
 selection which may match zero or more actual actors. Because the result is not
 a single actor reference, it has a different type :class:`ActorSelection` and

akka-docs/general/jmm.rst

@@ -45,8 +45,8 @@ To prevent visibility and reordering problems on actors, Akka guarantees the fol
 
 .. note::
 
-    In layman's terms this means that changes to internal fields of the actor is visible when the next message
+    In layman's terms this means that changes to internal fields of the actor are visible when the next message
-    is processed by that actor. So fields in your actor does not need to be volatile or equivalent.
+    is processed by that actor. So fields in your actor need not be volatile or equivalent.
 
 
 Both rules only apply for the same actor instance and are not valid if different actors are used.

akka-docs/images/circuit-breaker-states.dot

@@ -0,0 +1,19 @@
+	digraph circuit_breaker {
+		rankdir = "LR";
+		size = "6,5";
+		graph [ bgcolor = "transparent" ]
+		node [ fontname = "Helvetica",
+					 fontsize = 14,
+					 shape = circle, 
+					 color = white, 
+					 style = filled ];
+	  edge [ fontname = "Helvetica", fontsize = 12 ]
+		Closed [ fillcolor = green2 ];
+		"Half-Open" [fillcolor = yellow2 ];
+		Open [ fillcolor = red2 ];
+		Closed -> Closed [ label = "Success" ];
+		"Half-Open" -> Open [ label = "Trip Breaker" ];
+		"Half-Open" -> Closed [ label = "Reset Breaker" ];
+		Closed -> Open [ label = "Trip Breaker" ];
+		Open -> Open [ label = "Calls failing fast" ];
+		Open -> "Half-Open" [ label = "Attempt Reset" ];

akka-docs/java/code/docs/actor/japi/FaultHandlingDocSample.java

@@ -109,7 +109,7 @@ public class FaultHandlingDocSample {
    */
   public static class Worker extends UntypedActor {
     final LoggingAdapter log = Logging.getLogger(getContext().system(), this);
-    final Timeout askTimeout = new Timeout(Duration.parse("5 seconds"));
+    final Timeout askTimeout = new Timeout(Duration.create(5, "seconds"));
 
     // The sender of the initial Start message will continuously be notified about progress
     ActorRef progressListener;

akka-docs/java/code/docs/future/FutureDocTestBase.java

@@ -106,7 +106,7 @@ public class FutureDocTestBase {
     ActorRef actor = system.actorOf(new Props(MyActor.class));
     String msg = "hello";
     //#ask-blocking
-    Timeout timeout = new Timeout(Duration.parse("5 seconds"));
+    Timeout timeout = new Timeout(Duration.create(5, "seconds"));
     Future<Object> future = Patterns.ask(actor, msg, timeout);
     String result = (String) Await.result(future, timeout.duration());
     //#ask-blocking

akka-docs/java/code/docs/jrouting/CustomRouterDocTestBase.java

@@ -72,7 +72,7 @@ public class CustomRouterDocTestBase {
     routedActor.tell(RepublicanVote);
     routedActor.tell(DemocratVote);
     routedActor.tell(RepublicanVote);
-    Timeout timeout = new Timeout(Duration.parse("1 seconds"));
+    Timeout timeout = new Timeout(Duration.create(1, "seconds"));
     Future<Object> democratsResult = ask(routedActor, DemocratCountResult, timeout);
     Future<Object> republicansResult = ask(routedActor, RepublicanCountResult, timeout);
 

akka-docs/java/code/docs/jrouting/ParentActor.java

@@ -53,8 +53,8 @@ public class ParentActor extends UntypedActor {
       //#scatterGatherFirstCompletedRouter
       ActorRef scatterGatherFirstCompletedRouter = getContext().actorOf(
           new Props(FibonacciActor.class).withRouter(new ScatterGatherFirstCompletedRouter(5, Duration
-              .parse("2 seconds"))), "router");
+              .create(2, "seconds"))), "router");
-      Timeout timeout = new Timeout(Duration.parse("5 seconds"));
+      Timeout timeout = new Timeout(Duration.create(5, "seconds"));
       Future<Object> futureResult = akka.pattern.Patterns.ask(scatterGatherFirstCompletedRouter,
           new FibonacciActor.FibonacciNumber(10), timeout);
       int result = (Integer) Await.result(futureResult, timeout.duration());

akka-docs/java/code/docs/jrouting/RouterViaProgramExample.java

@@ -5,7 +5,7 @@ package docs.jrouting;
 
 import akka.routing.RoundRobinRouter;
 import akka.routing.DefaultResizer;
-import akka.routing.RemoteRouterConfig;
+import akka.remote.routing.RemoteRouterConfig;
 import akka.actor.ActorRef;
 import akka.actor.Props;
 import akka.actor.UntypedActor;

akka-docs/java/code/docs/testkit/TestKitDocTest.java

@@ -98,7 +98,7 @@ public class TestKitDocTest {
     //#test-within
     new JavaTestKit(system) {{
       getRef().tell(42);
-      new Within(Duration.Zero(), Duration.parse("1 second")) {
+      new Within(Duration.Zero(), Duration.create(1, "second")) {
         // do not put code outside this method, will run afterwards
         public void run() {
           assertEquals((Integer) 42, expectMsgClass(Integer.class));

akka-docs/modules/code/docs/actor/mailbox/DurableMailboxDocSpec.scala

@@ -25,7 +25,7 @@ object DurableMailboxDocSpec {
   val config = """
     //#dispatcher-config
     my-dispatcher {
-      mailbox-type = akka.actor.mailbox.FileBasedMailboxType
+      mailbox-type = akka.actor.mailbox.filebased.FileBasedMailboxType
     }
     //#dispatcher-config
     """

akka-docs/project/migration-guide-2.0.x-2.1.x.rst

@@ -6,7 +6,8 @@
 
 The 2.1 release contains several structural changes that require some
 simple, mechanical source-level changes in client code. Several things have
-been moved to Scala standard library, such as ``Future``.
+been moved to Scala standard library, such as ``Future``, and some package
+names have been changed in Remoting and Durable Mailboxes.
 
 When migrating from 1.3.x to 2.1.x you should first follow the instructions for
 migrating `1.3.x to 2.0.x <http://doc.akka.io/docs/akka/2.0.3/project/migration-guide-1.3.x-2.0.x.html>`_.
@@ -239,7 +240,7 @@ If the target actor of ``akka.pattern.gracefulStop`` isn't terminated within the
 timeout the ``Future`` is completed with failure ``akka.pattern.AskTimeoutException``.
 In 2.0 it was ``akka.actor.ActorTimeoutException``.
 
-getInstance for singeltons - Java
+getInstance for Singletons - Java
 ====================================
 
 v2.0::
@@ -358,4 +359,62 @@ v2.1::
     else if (requestedCapacity < 0) routeeProvider.removeRoutees(
       -requestedCapacity, stopDelay)
 
+Duration and Timeout
+====================
 
+The Duration class in the scala library is an improved version of the previous
+:class:`akka.util.Duration`. Among others it keeps the static type of
+:class:`FiniteDuration` more consistently, which has been used to tighten APIs.
+The advantage is that instead of runtime exceptions you’ll get compiler errors
+telling you if you try to pass a possibly non-finite duration where it does not
+belong.
+
+The main source incompatibility is that you may have to change the declared
+type of fields from ``Duration`` to ``FiniteDuration`` (factory methods already
+return the more precise type wherever possible).
+
+Another change is that ``Duration.parse`` was not accepted by the scala-library
+maintainers, use ``Duration.create`` instead.
+
+v2.0::
+
+  final Duration d = Duration.parse("1 second");
+  final Timeout t = new Timeout(d);
+
+v2.1::
+
+  final FiniteDuration d = Duration.create("1 second");
+  final Timeout t = new Timeout(d); // always required finite duration, now also in type   
+
+Package Name Changes in Remoting
+================================
+
+The package name of all classes in the ``akka-remote.jar`` artifact now starts with ``akka.remote``.
+This has been done to enable OSGi bundles that don't have conflicting package names.
+
+Change the following import statements. Please note that the serializers are often referenced from configuration.
+
+================================================ =======================================================
+Search                                           Replace with
+================================================ =======================================================
+``akka.routing.RemoteRouterConfig``              ``akka.remote.routing.RemoteRouterConfig``
+``akka.serialization.ProtobufSerializer``        ``akka.remote.serialization.ProtobufSerializer``
+``akka.serialization.DaemonMsgCreateSerializer`` ``akka.remote.serialization.DaemonMsgCreateSerializer``
+================================================ =======================================================
+
+Package Name Changes in Durable Mailboxes
+=========================================
+
+The package name of all classes in the ``akka-file-mailbox.jar`` artifact now starts with ``akka.actor.mailbox.filebased``.
+This has been done to enable OSGi bundles that don't have conflicting package names.
+
+Change the following import statements. Please note that the ``FileBasedMailboxType`` is often referenced from configuration.
+
+================================================ =========================================================
+Search                                           Replace with
+================================================ =========================================================
+``akka.actor.mailbox.FileBasedMailboxType``      ``akka.actor.mailbox.filebased.FileBasedMailboxType``
+``akka.actor.mailbox.FileBasedMailboxSettings``  ``akka.actor.mailbox.filebased.FileBasedMailboxSettings``
+``akka.actor.mailbox.FileBasedMessageQueue``     ``akka.actor.mailbox.filebased.FileBasedMessageQueue``
+``akka.actor.mailbox.filequeue.*``               ``akka.actor.mailbox.filebased.filequeue.*``
+================================================ =========================================================

akka-docs/scala/actors.rst

@@ -51,6 +51,16 @@ be able to handle unknown messages then you need to have a default case as in
 the example above. Otherwise an ``akka.actor.UnhandledMessage(message, sender, recipient)`` will be
 published to the ``ActorSystem``'s ``EventStream``.
 
+The result of the :meth:`receive` method is a partial function object, which is
+stored within the actor as its “initial behavior”, see `Become/Unbecome`_ for
+further information on changing the behavior of an actor after its
+construction. 
+
+.. note::
+   The initial behavior of an Actor is extracted prior to constructor is run,
+   so if you want to base your initial behavior on member state, you should
+   use ``become`` in the constructor.
+
 Creating Actors with default constructor
 ----------------------------------------
 

akka-docs/scala/code/docs/routing/RouterViaProgramExample.scala

@@ -6,7 +6,7 @@ package docs.routing
 import akka.routing.RoundRobinRouter
 import akka.actor.{ ActorRef, Props, Actor, ActorSystem }
 import akka.routing.DefaultResizer
-import akka.routing.RemoteRouterConfig
+import akka.remote.routing.RemoteRouterConfig
 
 case class Message1(nbr: Int)
 

akka-docs/scala/code/docs/serialization/SerializationDocSpec.scala

@@ -104,7 +104,7 @@ package docs.serialization {
         actor {
           serializers {
             java = "akka.serialization.JavaSerializer"
-            proto = "akka.serialization.ProtobufSerializer"
+            proto = "akka.remote.serialization.ProtobufSerializer"
             myown = "docs.serialization.MyOwnSerializer"
           }
         }
@@ -122,7 +122,7 @@ package docs.serialization {
         actor {
           serializers {
             java = "akka.serialization.JavaSerializer"
-            proto = "akka.serialization.ProtobufSerializer"
+            proto = "akka.remote.serialization.ProtobufSerializer"
             myown = "docs.serialization.MyOwnSerializer"
           }
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/FileBasedMailbox.scala

@@ -2,8 +2,9 @@
  *  Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.actor.mailbox
+package akka.actor.mailbox.filebased
 
+import akka.actor.mailbox._
 import akka.actor.{ ActorContext, ActorRef, ActorSystem, ExtendedActorSystem }
 import akka.event.Logging
 import com.typesafe.config.Config

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/FileBasedMailboxSettings.scala

@@ -1,8 +1,9 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.actor.mailbox
+package akka.actor.mailbox.filebased
 
+import akka.actor.mailbox._
 import com.typesafe.config.Config
 import scala.concurrent.util.Duration
 import java.util.concurrent.TimeUnit.MILLISECONDS

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/BrokenItemException.scala

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.io.IOException
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/Counter.scala

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.util.concurrent.atomic.AtomicLong
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/Journal.scala

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.io._
 import java.nio.{ ByteBuffer, ByteOrder }

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/PersistentQueue.scala

@@ -15,14 +15,14 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.io._
 import scala.collection.mutable
 import akka.event.LoggingAdapter
 import scala.concurrent.util.Duration
 import java.util.concurrent.TimeUnit
-import akka.actor.mailbox.FileBasedMailboxSettings
+import akka.actor.mailbox.filebased.FileBasedMailboxSettings
 
 // a config value that's backed by a global setting but may be locally overridden
 class OverlaySetting[T](base: ⇒ T) {

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/QItem.scala

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.nio.{ ByteBuffer, ByteOrder }
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/QueueCollection.scala

@@ -15,13 +15,13 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue
+package akka.actor.mailbox.filebased.filequeue
 
 import java.io.File
 import java.util.concurrent.CountDownLatch
 import scala.collection.mutable
 import akka.event.LoggingAdapter
-import akka.actor.mailbox.FileBasedMailboxSettings
+import akka.actor.mailbox.filebased.FileBasedMailboxSettings
 
 class InaccessibleQueuePath extends Exception("Inaccessible queue path: Must be a directory and writable")
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/tools/QDumper.scala

@@ -15,13 +15,13 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue.tools
+package akka.actor.mailbox.filebased.filequeue.tools
 
 import language.reflectiveCalls
 
 import java.io.{ FileNotFoundException, IOException }
 import scala.collection.mutable
-import akka.actor.mailbox.filequeue._
+import akka.actor.mailbox.filebased.filequeue._
 import akka.event.LoggingAdapter
 import akka.actor.ActorSystem
 

akka-durable-mailboxes/akka-file-mailbox/src/main/scala/akka/actor/mailbox/filebased/filequeue/tools/Util.scala

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package akka.actor.mailbox.filequeue.tools
+package akka.actor.mailbox.filebased.filequeue.tools
 
 object Util {
   val KILOBYTE = 1024L

akka-durable-mailboxes/akka-file-mailbox/src/test/scala/akka/actor/mailbox/filebased/FileBasedMailboxSpec.scala

@@ -1,14 +1,15 @@
-package akka.actor.mailbox
+package akka.actor.mailbox.filebased
 
 import language.postfixOps
 
+import akka.actor.mailbox._
 import org.apache.commons.io.FileUtils
 import akka.dispatch.Mailbox
 
 object FileBasedMailboxSpec {
   val config = """
     File-dispatcher {
-      mailbox-type = akka.actor.mailbox.FileBasedMailboxType
+      mailbox-type = akka.actor.mailbox.filebased.FileBasedMailboxType
       throughput = 1
       file-based.directory-path = "file-based"
       file-based.circuit-breaker.max-failures = 5

akka-remote-tests/src/main/scala/akka/remote/testconductor/Player.scala

@@ -4,7 +4,6 @@
 package akka.remote.testconductor
 
 import language.postfixOps
-
 import akka.actor.{ Actor, ActorRef, ActorSystem, LoggingFSM, Props, PoisonPill, Status, Address, Scheduler }
 import RemoteConnection.getAddrString
 import scala.concurrent.util.{ Duration, Deadline }
@@ -20,6 +19,7 @@ import akka.event.{ LoggingAdapter, Logging }
 import java.net.{ InetSocketAddress, ConnectException }
 import scala.reflect.classTag
 import concurrent.{ ExecutionContext, Await, Future }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * The Player is the client component of the
@@ -81,13 +81,13 @@ trait Player { this: TestConductorExt ⇒
     system.log.debug("entering barriers " + name.mkString("(", ", ", ")"))
     val stop = Deadline.now + timeout.duration
     name foreach { b ⇒
-      val barrierTimeout = stop.timeLeft
+      val barrierTimeout = stop.timeLeft.asInstanceOf[FiniteDuration]
       if (barrierTimeout < Duration.Zero) {
         client ! ToServer(FailBarrier(b))
         throw new TimeoutException("Server timed out while waiting for barrier " + b);
       }
       try {
-        implicit val timeout = Timeout(barrierTimeout + Settings.QueryTimeout.duration)
+        implicit val timeout = Timeout((barrierTimeout + Settings.QueryTimeout.duration).asInstanceOf[FiniteDuration])
         Await.result(client ? ToServer(EnterBarrier(b, Option(barrierTimeout))), Duration.Inf)
       } catch {
         case e: AskTimeoutException ⇒

akka-remote/src/main/resources/reference.conf

@@ -13,8 +13,8 @@ akka {
   actor {
 
     serializers {
-      proto = "akka.serialization.ProtobufSerializer"
+      proto = "akka.remote.serialization.ProtobufSerializer"
-      daemon-create = "akka.serialization.DaemonMsgCreateSerializer"
+      daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
     }
 
 

akka-remote/src/main/scala/akka/remote/RemoteDeployer.scala

@@ -5,6 +5,7 @@ package akka.remote
 
 import akka.actor._
 import akka.routing._
+import akka.remote.routing._
 import com.typesafe.config._
 import akka.ConfigurationException
 

akka-remote/src/main/scala/akka/remote/netty/NettySSLSupport.scala

@@ -9,7 +9,7 @@ import javax.net.ssl.{ KeyManagerFactory, TrustManager, TrustManagerFactory, SSL
 import akka.remote.RemoteTransportException
 import akka.event.LoggingAdapter
 import java.io.{ IOException, FileNotFoundException, FileInputStream }
-import akka.security.provider.AkkaProvider
+import akka.remote.security.provider.AkkaProvider
 import java.security._
 
 /**

akka-remote/src/main/scala/akka/remote/routing/RemoteRouterConfig.scala

@@ -1,8 +1,9 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.routing
+package akka.remote.routing
 
+import akka.routing.{ Route, Router, RouterConfig, RouteeProvider, Resizer }
 import com.typesafe.config.ConfigFactory
 import akka.actor.ActorContext
 import akka.actor.ActorRef

akka-remote/src/main/scala/akka/remote/security/provider/AES128CounterInetRNG.scala

@@ -1,7 +1,7 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.security.provider
+package akka.remote.security.provider
 
 import org.uncommons.maths.random.{ AESCounterRNG }
 import SeedSize.Seed128

akka-remote/src/main/scala/akka/remote/security/provider/AES128CounterSecureRNG.scala

@@ -1,7 +1,7 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.security.provider
+package akka.remote.security.provider
 
 import org.uncommons.maths.random.{ AESCounterRNG, SecureRandomSeedGenerator }
 import SeedSize.Seed128

akka-remote/src/main/scala/akka/remote/security/provider/AES256CounterInetRNG.scala

@@ -1,7 +1,7 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.security.provider
+package akka.remote.security.provider
 
 import org.uncommons.maths.random.{ AESCounterRNG }
 import SeedSize.Seed256

akka-remote/src/main/scala/akka/remote/security/provider/AES256CounterSecureRNG.scala

@@ -1,7 +1,7 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.security.provider
+package akka.remote.security.provider
 
 import org.uncommons.maths.random.{ AESCounterRNG, SecureRandomSeedGenerator }
 import SeedSize.Seed256

akka-remote/src/main/scala/akka/remote/security/provider/AkkaProvider.scala

@@ -1,7 +1,7 @@
 /**
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
-package akka.security.provider
+package akka.remote.security.provider
 
 import java.security.{ PrivilegedAction, AccessController, Provider, Security }
 

akka-remote/src/main/scala/akka/remote/security/provider/InternetSeedGenerator.scala

@@ -13,7 +13,7 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 // ============================================================================
-package akka.security.provider
+package akka.remote.security.provider
 
 import org.uncommons.maths.random.{ SeedGenerator, SeedException, SecureRandomSeedGenerator, RandomDotOrgSeedGenerator, DevRandomSeedGenerator }
 

akka-remote/src/main/scala/akka/remote/security/provider/SeedSize.scala

@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.security.provider
+package akka.remote.security.provider
 
 /**
  * Internal API

akka-remote/src/main/scala/akka/remote/serialization/DaemonMsgCreateSerializer.scala

@@ -2,8 +2,9 @@
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.serialization
+package akka.remote.serialization
 
+import akka.serialization.{ Serializer, SerializationExtension }
 import java.io.Serializable
 import com.google.protobuf.ByteString
 import com.typesafe.config.{ Config, ConfigFactory }

akka-remote/src/main/scala/akka/remote/serialization/ProtobufSerializer.scala

@@ -2,8 +2,9 @@
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.serialization
+package akka.remote.serialization
 
+import akka.serialization.{ Serializer, Serialization }
 import com.google.protobuf.Message
 import akka.actor.DynamicAccess
 import akka.remote.RemoteProtocol.ActorRefProtocol

akka-remote/src/test/java/akka/remote/ProtobufProtocol.java

@@ -1,7 +1,9 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: ProtobufProtocol.proto
 
-package akka.actor;
+package akka.remote;
+
+import com.google.protobuf.AbstractMessage;
 
 public final class ProtobufProtocol {
   private ProtobufProtocol() {}
@@ -43,12 +45,12 @@ public final class ProtobufProtocol {
 
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
-      return akka.actor.ProtobufProtocol.internal_static_akka_actor_MyMessage_descriptor;
+      return ProtobufProtocol.internal_static_akka_actor_MyMessage_descriptor;
     }
 
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
-      return akka.actor.ProtobufProtocol.internal_static_akka_actor_MyMessage_fieldAccessorTable;
+      return ProtobufProtocol.internal_static_akka_actor_MyMessage_fieldAccessorTable;
     }
 
     private int bitField0_;
@@ -175,41 +177,41 @@ public final class ProtobufProtocol {
       return super.writeReplace();
     }
 
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         com.google.protobuf.ByteString data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(byte[] data)
+    public static ProtobufProtocol.MyMessage parseFrom(byte[] data)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data).buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         byte[] data,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws com.google.protobuf.InvalidProtocolBufferException {
       return newBuilder().mergeFrom(data, extensionRegistry)
                .buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(java.io.InputStream input)
+    public static ProtobufProtocol.MyMessage parseFrom(java.io.InputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseDelimitedFrom(java.io.InputStream input)
+    public static ProtobufProtocol.MyMessage parseDelimitedFrom(java.io.InputStream input)
         throws java.io.IOException {
       Builder builder = newBuilder();
       if (builder.mergeDelimitedFrom(input)) {
@@ -218,7 +220,7 @@ public final class ProtobufProtocol {
         return null;
       }
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseDelimitedFrom(
+    public static ProtobufProtocol.MyMessage parseDelimitedFrom(
         java.io.InputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -229,12 +231,12 @@ public final class ProtobufProtocol {
         return null;
       }
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         com.google.protobuf.CodedInputStream input)
         throws java.io.IOException {
       return newBuilder().mergeFrom(input).buildParsed();
     }
-    public static akka.actor.ProtobufProtocol.MyMessage parseFrom(
+    public static ProtobufProtocol.MyMessage parseFrom(
         com.google.protobuf.CodedInputStream input,
         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
         throws java.io.IOException {
@@ -244,7 +246,7 @@ public final class ProtobufProtocol {
 
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder(akka.actor.ProtobufProtocol.MyMessage prototype) {
+    public static Builder newBuilder(ProtobufProtocol.MyMessage prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
@@ -257,15 +259,15 @@ public final class ProtobufProtocol {
     }
     public static final class Builder extends
         com.google.protobuf.GeneratedMessage.Builder<Builder>
-       implements akka.actor.ProtobufProtocol.MyMessageOrBuilder {
+       implements ProtobufProtocol.MyMessageOrBuilder {
       public static final com.google.protobuf.Descriptors.Descriptor
           getDescriptor() {
-        return akka.actor.ProtobufProtocol.internal_static_akka_actor_MyMessage_descriptor;
+        return ProtobufProtocol.internal_static_akka_actor_MyMessage_descriptor;
       }
 
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
-        return akka.actor.ProtobufProtocol.internal_static_akka_actor_MyMessage_fieldAccessorTable;
+        return ProtobufProtocol.internal_static_akka_actor_MyMessage_fieldAccessorTable;
       }
 
       // Construct using akka.actor.ProtobufProtocol.MyMessage.newBuilder()
@@ -302,33 +304,33 @@ public final class ProtobufProtocol {
 
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
-        return akka.actor.ProtobufProtocol.MyMessage.getDescriptor();
+        return ProtobufProtocol.MyMessage.getDescriptor();
       }
 
-      public akka.actor.ProtobufProtocol.MyMessage getDefaultInstanceForType() {
+      public ProtobufProtocol.MyMessage getDefaultInstanceForType() {
-        return akka.actor.ProtobufProtocol.MyMessage.getDefaultInstance();
+        return ProtobufProtocol.MyMessage.getDefaultInstance();
       }
 
-      public akka.actor.ProtobufProtocol.MyMessage build() {
+      public ProtobufProtocol.MyMessage build() {
-        akka.actor.ProtobufProtocol.MyMessage result = buildPartial();
+        ProtobufProtocol.MyMessage result = buildPartial();
         if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
+          throw AbstractMessage.Builder.newUninitializedMessageException(result);
         }
         return result;
       }
 
-      private akka.actor.ProtobufProtocol.MyMessage buildParsed()
+      private ProtobufProtocol.MyMessage buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
-        akka.actor.ProtobufProtocol.MyMessage result = buildPartial();
+        ProtobufProtocol.MyMessage result = buildPartial();
         if (!result.isInitialized()) {
-          throw newUninitializedMessageException(
+          throw AbstractMessage.Builder.newUninitializedMessageException(
-            result).asInvalidProtocolBufferException();
+                  result).asInvalidProtocolBufferException();
         }
         return result;
       }
 
-      public akka.actor.ProtobufProtocol.MyMessage buildPartial() {
+      public ProtobufProtocol.MyMessage buildPartial() {
-        akka.actor.ProtobufProtocol.MyMessage result = new akka.actor.ProtobufProtocol.MyMessage(this);
+        ProtobufProtocol.MyMessage result = new ProtobufProtocol.MyMessage(this);
         int from_bitField0_ = bitField0_;
         int to_bitField0_ = 0;
         if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
@@ -349,16 +351,16 @@ public final class ProtobufProtocol {
       }
 
       public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof akka.actor.ProtobufProtocol.MyMessage) {
+        if (other instanceof ProtobufProtocol.MyMessage) {
-          return mergeFrom((akka.actor.ProtobufProtocol.MyMessage)other);
+          return mergeFrom((ProtobufProtocol.MyMessage)other);
         } else {
           super.mergeFrom(other);
           return this;
         }
       }
 
-      public Builder mergeFrom(akka.actor.ProtobufProtocol.MyMessage other) {
+      public Builder mergeFrom(ProtobufProtocol.MyMessage other) {
-        if (other == akka.actor.ProtobufProtocol.MyMessage.getDefaultInstance()) return this;
+        if (other == ProtobufProtocol.MyMessage.getDefaultInstance()) return this;
         if (other.hasId()) {
           setId(other.getId());
         }
@@ -550,8 +552,8 @@ public final class ProtobufProtocol {
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_akka_actor_MyMessage_descriptor,
               new java.lang.String[] { "Id", "Name", "Status", },
-              akka.actor.ProtobufProtocol.MyMessage.class,
+              ProtobufProtocol.MyMessage.class,
-              akka.actor.ProtobufProtocol.MyMessage.Builder.class);
+              ProtobufProtocol.MyMessage.Builder.class);
           return null;
         }
       };

akka-remote/src/test/scala/akka/remote/RemoteRouterSpec.scala

@@ -6,6 +6,7 @@ package akka.remote
 import akka.testkit._
 import akka.routing._
 import akka.actor._
+import akka.remote.routing._
 import com.typesafe.config._
 
 object RemoteRouterSpec {

akka-remote/src/test/scala/akka/remote/serialization/DaemonMsgCreateSerializerSpec.scala

@@ -2,10 +2,11 @@
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.serialization
+package akka.remote.serialization
 
 import language.postfixOps
 
+import akka.serialization.SerializationExtension
 import com.typesafe.config.ConfigFactory
 import akka.testkit.AkkaSpec
 import akka.actor.{ Actor, Address, Props, Deploy, OneForOneStrategy, SupervisorStrategy, FromClassCreator }

akka-remote/src/test/scala/akka/remote/serialization/ProtobufSerializerSpec.scala

@@ -2,11 +2,12 @@
  * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
  */
 
-package akka.serialization
+package akka.remote.serialization
 
+import akka.serialization.SerializationExtension
 import akka.testkit.AkkaSpec
 import akka.remote.RemoteProtocol.MessageProtocol
-import akka.actor.ProtobufProtocol.MyMessage
+import akka.remote.ProtobufProtocol.MyMessage
 
 @org.junit.runner.RunWith(classOf[org.scalatest.junit.JUnitRunner])
 class ProtobufSerializerSpec extends AkkaSpec {

akka-testkit/src/main/java/akka/testkit/JavaTestKit.java

@@ -11,6 +11,7 @@ import akka.event.Logging.LogEvent;
 import akka.japi.JavaPartialFunction;
 import akka.japi.Util;
 import scala.concurrent.util.Duration;
+import scala.concurrent.util.FiniteDuration;
 
 /**
  * Java API for the TestProbe. Proper JavaDocs to come once JavaDoccing is implemented.
@@ -30,8 +31,10 @@ public class JavaTestKit {
     return p.system();
   }
   
-  static public Duration duration(String s) {
+  static public FiniteDuration duration(String s) {
-    return Duration.parse(s);
+    final Duration ret = Duration.apply(s);
+    if (ret instanceof FiniteDuration) return (FiniteDuration) ret;
+    else throw new IllegalArgumentException("duration() is only for finite durations, use Duration.Inf() and friends");
   }
   
   public Duration dilated(Duration d) {
@@ -58,11 +61,11 @@ public class JavaTestKit {
     p.lastMessage().sender().tell(msg, p.ref());
   }
 
-  public Duration getRemainingTime() {
+  public FiniteDuration getRemainingTime() {
     return p.remaining();
   }
 
-  public Duration getRemainingTimeOr(Duration def) {
+  public FiniteDuration getRemainingTimeOr(FiniteDuration def) {
     return p.remainingOr(def);
   }
 
@@ -97,7 +100,7 @@ public class JavaTestKit {
   public abstract class Within {
     protected abstract void run();
 
-    public Within(Duration max) {
+    public Within(FiniteDuration max) {
       p.within(max, new AbstractFunction0<Object>() {
         public Object apply() {
           run();
@@ -106,7 +109,7 @@ public class JavaTestKit {
       });
     }
 
-    public Within(Duration min, Duration max) {
+    public Within(FiniteDuration min, FiniteDuration max) {
       p.within(min, max, new AbstractFunction0<Object>() {
         public Object apply() {
           run();
@@ -168,7 +171,7 @@ public class JavaTestKit {
     return p.expectMsg(msg);
   }
 
-  public <T> T expectMsgEquals(Duration max, T msg) {
+  public <T> T expectMsgEquals(FiniteDuration max, T msg) {
     return p.expectMsg(max, msg);
   }
 
@@ -176,7 +179,7 @@ public class JavaTestKit {
     return p.expectMsgClass(clazz);
   }
 
-  public <T> T expectMsgClass(Duration max, Class<T> clazz) {
+  public <T> T expectMsgClass(FiniteDuration max, Class<T> clazz) {
     return p.expectMsgClass(max, clazz);
   }
 
@@ -184,7 +187,7 @@ public class JavaTestKit {
     return p.expectMsgAnyOf(Util.arrayToSeq(msgs));
   }
 
-  public Object expectMsgAnyOf(Duration max, Object... msgs) {
+  public Object expectMsgAnyOf(FiniteDuration max, Object... msgs) {
     return p.expectMsgAnyOf(max, Util.arrayToSeq(msgs));
   }
 
@@ -193,7 +196,7 @@ public class JavaTestKit {
         Util.classTag(Object.class));
   }
 
-  public Object[] expectMsgAllOf(Duration max, Object... msgs) {
+  public Object[] expectMsgAllOf(FiniteDuration max, Object... msgs) {
     return (Object[]) p.expectMsgAllOf(max, Util.arrayToSeq(msgs)).toArray(
         Util.classTag(Object.class));
   }
@@ -204,7 +207,7 @@ public class JavaTestKit {
     return (T) result;
   }
 
-  public Object expectMsgAnyClassOf(Duration max, Class<?>... classes) {
+  public Object expectMsgAnyClassOf(FiniteDuration max, Class<?>... classes) {
     return p.expectMsgAnyClassOf(max, Util.arrayToSeq(classes));
   }
 
@@ -212,7 +215,7 @@ public class JavaTestKit {
     p.expectNoMsg();
   }
 
-  public void expectNoMsg(Duration max) {
+  public void expectNoMsg(FiniteDuration max) {
     p.expectNoMsg(max);
   }
 

akka-testkit/src/main/scala/akka/testkit/TestBarrier.scala

@@ -7,6 +7,7 @@ package akka.testkit
 import scala.concurrent.util.Duration
 import java.util.concurrent.{ CyclicBarrier, TimeUnit, TimeoutException }
 import akka.actor.ActorSystem
+import scala.concurrent.util.FiniteDuration
 
 class TestBarrierTimeoutException(message: String) extends RuntimeException(message)
 
@@ -27,7 +28,7 @@ class TestBarrier(count: Int) {
 
   def await()(implicit system: ActorSystem): Unit = await(TestBarrier.DefaultTimeout)
 
-  def await(timeout: Duration)(implicit system: ActorSystem) {
+  def await(timeout: FiniteDuration)(implicit system: ActorSystem) {
     try {
       barrier.await(timeout.dilated.toNanos, TimeUnit.NANOSECONDS)
     } catch {

akka-testkit/src/main/scala/akka/testkit/TestKit.scala

@@ -7,7 +7,7 @@ import language.postfixOps
 
 import akka.actor._
 import akka.actor.Actor._
-import scala.concurrent.util.Duration
+import scala.concurrent.util.{ Duration, FiniteDuration }
 import scala.concurrent.util.duration._
 import java.util.concurrent.{ BlockingDeque, LinkedBlockingDeque, TimeUnit, atomic }
 import atomic.AtomicInteger
@@ -176,20 +176,30 @@ trait TestKitBase {
   /**
    * Obtain current time (`System.nanoTime`) as Duration.
    */
-  def now: Duration = System.nanoTime.nanos
+  def now: FiniteDuration = System.nanoTime.nanos
 
   /**
    * Obtain time remaining for execution of the innermost enclosing `within`
    * block or missing that it returns the properly dilated default for this
    * case from settings (key "akka.test.single-expect-default").
    */
-  def remaining: Duration = remainingOr(testKitSettings.SingleExpectDefaultTimeout.dilated)
+  def remaining: FiniteDuration = remainingOr(testKitSettings.SingleExpectDefaultTimeout.dilated)
 
   /**
    * Obtain time remaining for execution of the innermost enclosing `within`
    * block or missing that it returns the given duration.
    */
-  def remainingOr(duration: Duration): Duration = if (end == Duration.Undefined) duration else end - now
+  def remainingOr(duration: FiniteDuration): FiniteDuration = end match {
+    case x if x eq Duration.Undefined ⇒ duration
+    case x if !x.isFinite             ⇒ throw new IllegalArgumentException("`end` cannot be infinite")
+    case f: FiniteDuration            ⇒ (end - now).asInstanceOf[FiniteDuration] // RK FIXME after next Scala milestone
+  }
+
+  private def remainingOrDilated(max: Duration): FiniteDuration = max match {
+    case x if x eq Duration.Undefined ⇒ remaining
+    case x if !x.isFinite             ⇒ throw new IllegalArgumentException("max duration cannot be infinite")
+    case f: FiniteDuration            ⇒ f.dilated
+  }
 
   /**
    * Query queue status.
@@ -207,7 +217,7 @@ trait TestKitBase {
    * which uses the configuration entry "akka.test.timefactor".
    */
   def awaitCond(p: ⇒ Boolean, max: Duration = Duration.Undefined, interval: Duration = 100.millis) {
-    val _max = if (max eq Duration.Undefined) remaining else max.dilated
+    val _max = remainingOrDilated(max)
     val stop = now + _max
 
     @tailrec
@@ -238,7 +248,7 @@ trait TestKitBase {
    *       }
    * </pre>
    */
-  def within[T](min: Duration, max: Duration)(f: ⇒ T): T = {
+  def within[T](min: FiniteDuration, max: FiniteDuration)(f: ⇒ T): T = {
     val _max = max.dilated
     val start = now
     val rem = if (end == Duration.Undefined) Duration.Inf else end - start
@@ -264,7 +274,7 @@ trait TestKitBase {
   /**
    * Same as calling `within(0 seconds, max)(f)`.
    */
-  def within[T](max: Duration)(f: ⇒ T): T = within(0 seconds, max)(f)
+  def within[T](max: FiniteDuration)(f: ⇒ T): T = within(0 seconds, max)(f)
 
   /**
    * Same as `expectMsg(remaining, obj)`, but correctly treating the timeFactor.
@@ -278,7 +288,7 @@ trait TestKitBase {
    *
    * @return the received object
    */
-  def expectMsg[T](max: Duration, obj: T): T = expectMsg_internal(max.dilated, obj)
+  def expectMsg[T](max: FiniteDuration, obj: T): T = expectMsg_internal(max.dilated, obj)
 
   private def expectMsg_internal[T](max: Duration, obj: T): T = {
     val o = receiveOne(max)
@@ -298,7 +308,7 @@ trait TestKitBase {
    * @return the received object as transformed by the partial function
    */
   def expectMsgPF[T](max: Duration = Duration.Undefined, hint: String = "")(f: PartialFunction[Any, T]): T = {
-    val _max = if (max eq Duration.Undefined) remaining else max.dilated
+    val _max = remainingOrDilated(max)
     val o = receiveOne(_max)
     assert(o ne null, "timeout (" + _max + ") during expectMsg: " + hint)
     assert(f.isDefinedAt(o), "expected: " + hint + " but got unexpected message " + o)
@@ -314,7 +324,7 @@ trait TestKitBase {
    *         partial function returned true
    */
   def fishForMessage(max: Duration = Duration.Undefined, hint: String = "")(f: PartialFunction[Any, Boolean]): Any = {
-    val _max = if (max eq Duration.Undefined) remaining else max.dilated
+    val _max = remainingOrDilated(max)
     val end = now + _max
     @tailrec
     def recv: Any = {
@@ -338,7 +348,7 @@ trait TestKitBase {
    *
    * @return the received object
    */
-  def expectMsgType[T](max: Duration)(implicit t: ClassTag[T]): T = expectMsgClass_internal(max.dilated, t.runtimeClass.asInstanceOf[Class[T]])
+  def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T = expectMsgClass_internal(max.dilated, t.runtimeClass.asInstanceOf[Class[T]])
 
   /**
    * Same as `expectMsgClass(remaining, c)`, but correctly treating the timeFactor.
@@ -352,9 +362,9 @@ trait TestKitBase {
    *
    * @return the received object
    */
-  def expectMsgClass[C](max: Duration, c: Class[C]): C = expectMsgClass_internal(max.dilated, c)
+  def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C = expectMsgClass_internal(max.dilated, c)
 
-  private def expectMsgClass_internal[C](max: Duration, c: Class[C]): C = {
+  private def expectMsgClass_internal[C](max: FiniteDuration, c: Class[C]): C = {
     val o = receiveOne(max)
     assert(o ne null, "timeout (" + max + ") during expectMsgClass waiting for " + c)
     assert(BoxedType(c) isInstance o, "expected " + c + ", found " + o.getClass)
@@ -373,9 +383,9 @@ trait TestKitBase {
    *
    * @return the received object
    */
-  def expectMsgAnyOf[T](max: Duration, obj: T*): T = expectMsgAnyOf_internal(max.dilated, obj: _*)
+  def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T = expectMsgAnyOf_internal(max.dilated, obj: _*)
 
-  private def expectMsgAnyOf_internal[T](max: Duration, obj: T*): T = {
+  private def expectMsgAnyOf_internal[T](max: FiniteDuration, obj: T*): T = {
     val o = receiveOne(max)
     assert(o ne null, "timeout (" + max + ") during expectMsgAnyOf waiting for " + obj.mkString("(", ", ", ")"))
     assert(obj exists (_ == o), "found unexpected " + o)
@@ -394,9 +404,9 @@ trait TestKitBase {
    *
    * @return the received object
    */
-  def expectMsgAnyClassOf[C](max: Duration, obj: Class[_ <: C]*): C = expectMsgAnyClassOf_internal(max.dilated, obj: _*)
+  def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C = expectMsgAnyClassOf_internal(max.dilated, obj: _*)
 
-  private def expectMsgAnyClassOf_internal[C](max: Duration, obj: Class[_ <: C]*): C = {
+  private def expectMsgAnyClassOf_internal[C](max: FiniteDuration, obj: Class[_ <: C]*): C = {
     val o = receiveOne(max)
     assert(o ne null, "timeout (" + max + ") during expectMsgAnyClassOf waiting for " + obj.mkString("(", ", ", ")"))
     assert(obj exists (c ⇒ BoxedType(c) isInstance o), "found unexpected " + o)
@@ -421,9 +431,9 @@ trait TestKitBase {
    *   expectMsgAllOf(1 second, Result1(), Result2())
    * </pre>
    */
-  def expectMsgAllOf[T](max: Duration, obj: T*): Seq[T] = expectMsgAllOf_internal(max.dilated, obj: _*)
+  def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T] = expectMsgAllOf_internal(max.dilated, obj: _*)
 
-  private def expectMsgAllOf_internal[T](max: Duration, obj: T*): Seq[T] = {
+  private def expectMsgAllOf_internal[T](max: FiniteDuration, obj: T*): Seq[T] = {
     val recv = receiveN_internal(obj.size, max)
     obj foreach (x ⇒ assert(recv exists (x == _), "not found " + x))
     recv foreach (x ⇒ assert(obj exists (x == _), "found unexpected " + x))
@@ -443,9 +453,9 @@ trait TestKitBase {
    * Wait time is bounded by the given duration, with an AssertionFailure
    * being thrown in case of timeout.
    */
-  def expectMsgAllClassOf[T](max: Duration, obj: Class[_ <: T]*): Seq[T] = internalExpectMsgAllClassOf(max.dilated, obj: _*)
+  def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T] = internalExpectMsgAllClassOf(max.dilated, obj: _*)
 
-  private def internalExpectMsgAllClassOf[T](max: Duration, obj: Class[_ <: T]*): Seq[T] = {
+  private def internalExpectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T] = {
     val recv = receiveN_internal(obj.size, max)
     obj foreach (x ⇒ assert(recv exists (_.getClass eq BoxedType(x)), "not found " + x))
     recv foreach (x ⇒ assert(obj exists (c ⇒ BoxedType(c) eq x.getClass), "found non-matching object " + x))
@@ -468,9 +478,9 @@ trait TestKitBase {
    * Beware that one object may satisfy all given class constraints, which
    * may be counter-intuitive.
    */
-  def expectMsgAllConformingOf[T](max: Duration, obj: Class[_ <: T]*): Seq[T] = internalExpectMsgAllConformingOf(max.dilated, obj: _*)
+  def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T] = internalExpectMsgAllConformingOf(max.dilated, obj: _*)
 
-  private def internalExpectMsgAllConformingOf[T](max: Duration, obj: Class[_ <: T]*): Seq[T] = {
+  private def internalExpectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T] = {
     val recv = receiveN_internal(obj.size, max)
     obj foreach (x ⇒ assert(recv exists (BoxedType(x) isInstance _), "not found " + x))
     recv foreach (x ⇒ assert(obj exists (c ⇒ BoxedType(c) isInstance x), "found non-matching object " + x))
@@ -485,9 +495,9 @@ trait TestKitBase {
   /**
    * Assert that no message is received for the specified time.
    */
-  def expectNoMsg(max: Duration) { expectNoMsg_internal(max.dilated) }
+  def expectNoMsg(max: FiniteDuration) { expectNoMsg_internal(max.dilated) }
 
-  private def expectNoMsg_internal(max: Duration) {
+  private def expectNoMsg_internal(max: FiniteDuration) {
     val o = receiveOne(max)
     assert(o eq null, "received unexpected message " + o)
     lastWasNoMsg = true
@@ -512,7 +522,7 @@ trait TestKitBase {
    * </pre>
    */
   def receiveWhile[T](max: Duration = Duration.Undefined, idle: Duration = Duration.Inf, messages: Int = Int.MaxValue)(f: PartialFunction[AnyRef, T]): Seq[T] = {
-    val stop = now + (if (max eq Duration.Undefined) remaining else max.dilated)
+    val stop = now + remainingOrDilated(max)
     var msg: Message = NullMessage
 
     @tailrec
@@ -549,7 +559,7 @@ trait TestKitBase {
   /**
    * Receive N messages in a row before the given deadline.
    */
-  def receiveN(n: Int, max: Duration): Seq[AnyRef] = receiveN_internal(n, max.dilated)
+  def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef] = receiveN_internal(n, max.dilated)
 
   private def receiveN_internal(n: Int, max: Duration): Seq[AnyRef] = {
     val stop = max + now

akka-testkit/src/main/scala/akka/testkit/TestLatch.scala

@@ -8,6 +8,7 @@ import scala.concurrent.util.Duration
 import akka.actor.ActorSystem
 import scala.concurrent.{ Await, CanAwait, Awaitable }
 import java.util.concurrent.{ TimeoutException, CountDownLatch, TimeUnit }
+import scala.concurrent.util.FiniteDuration
 
 /**
  * A count down latch wrapper for use in testing.
@@ -32,7 +33,11 @@ class TestLatch(count: Int = 1)(implicit system: ActorSystem) extends Awaitable[
 
   @throws(classOf[TimeoutException])
   def ready(atMost: Duration)(implicit permit: CanAwait) = {
-    val opened = latch.await(atMost.dilated.toNanos, TimeUnit.NANOSECONDS)
+    val waitTime = atMost match {
+      case f: FiniteDuration ⇒ f
+      case _                 ⇒ throw new IllegalArgumentException("TestLatch does not support waiting for " + atMost)
+    }
+    val opened = latch.await(waitTime.dilated.toNanos, TimeUnit.NANOSECONDS)
     if (!opened) throw new TimeoutException(
       "Timeout of %s with time factor of %s" format (atMost.toString, TestKitExtension(system).TestTimeFactor))
     this

akka-testkit/src/main/scala/akka/testkit/package.scala

@@ -3,7 +3,7 @@ package akka
 import language.implicitConversions
 
 import akka.actor.ActorSystem
-import scala.concurrent.util.Duration
+import scala.concurrent.util.{ Duration, FiniteDuration }
 import java.util.concurrent.TimeUnit.MILLISECONDS
 import scala.reflect.ClassTag
 
@@ -41,14 +41,15 @@ package object testkit {
    *
    * Corresponding Java API is available in TestKit.dilated
    */
-  implicit def duration2TestDuration(duration: Duration) = new TestDuration(duration)
+  implicit def duration2TestDuration(duration: FiniteDuration) = new TestDuration(duration)
 
   /**
    * Wrapper for implicit conversion to add dilated function to Duration.
    */
-  class TestDuration(duration: Duration) {
+  class TestDuration(duration: FiniteDuration) {
-    def dilated(implicit system: ActorSystem): Duration = {
+    def dilated(implicit system: ActorSystem): FiniteDuration = {
-      duration * TestKitExtension(system).TestTimeFactor
+      // this cast will succeed unless TestTimeFactor is non-finite (which would be a misconfiguration)
+      (duration * TestKitExtension(system).TestTimeFactor).asInstanceOf[FiniteDuration]
     }
   }
 }

project/AkkaBuild.scala

@@ -36,7 +36,7 @@ object AkkaBuild extends Build {
       parallelExecution in GlobalScope := System.getProperty("akka.parallelExecution", "false").toBoolean,
       Publish.defaultPublishTo in ThisBuild <<= crossTarget / "repository",
       Unidoc.unidocExclude := Seq(samples.id),
-      Dist.distExclude := Seq(actorTests.id, akkaSbtPlugin.id, docs.id),
+      Dist.distExclude := Seq(actorTests.id, akkaSbtPlugin.id, docs.id, samples.id),
       initialCommands in ThisBuild :=
         """|import language.postfixOps
            |import akka.actor._
@@ -69,7 +69,7 @@ object AkkaBuild extends Build {
       sphinxLatex <<= sphinxLatex in LocalProject(docs.id) map identity,
       sphinxPdf <<= sphinxPdf in LocalProject(docs.id) map identity
     ),
-    aggregate = Seq(actor, testkit, actorTests, dataflow, remote, remoteTests, camel, cluster, slf4j, agent, transactor, mailboxes, zeroMQ, kernel, akkaSbtPlugin, samples, osgi, osgiAries, docs)
+    aggregate = Seq(actor, testkit, actorTests, dataflow, remote, remoteTests, camel, cluster, slf4j, agent, transactor, mailboxes, zeroMQ, kernel, akkaSbtPlugin, osgi, osgiAries, docs)
   )
 
   lazy val actor = Project(
@@ -275,12 +275,7 @@ object AkkaBuild extends Build {
     settings = defaultSettings ++ Seq(
       sbtPlugin := true,
       publishMavenStyle := false, // SBT Plugins should be published as Ivy
-      publishTo <<= (version) { version: String =>
+      publishTo <<= Publish.akkaPluginPublishTo,
-        val scalasbt = "http://scalasbt.artifactoryonline.com/scalasbt/"
-        val (name, u) = if (version.contains("-SNAPSHOT")) ("sbt-plugin-snapshots", scalasbt+"sbt-plugin-snapshots")
-        else ("sbt-plugin-releases", scalasbt+"sbt-plugin-releases")
-        Some(Resolver.url(name, url(u))(Resolver.ivyStylePatterns))
-      },
       scalacOptions in Compile := Seq("-encoding", "UTF-8", "-deprecation", "-unchecked"),
       scalaVersion := "2.9.1",
       scalaBinaryVersion <<= scalaVersion
@@ -299,7 +294,8 @@ object AkkaBuild extends Build {
     base = file("akka-samples/akka-sample-camel"),
     dependencies = Seq(actor, camel),
     settings = defaultSettings ++ Seq(
-      libraryDependencies ++= Dependencies.camelSample
+      libraryDependencies ++= Dependencies.camelSample,
+      publishArtifact in Compile := false
     )
   )
 
@@ -307,35 +303,35 @@ object AkkaBuild extends Build {
     id = "akka-sample-fsm",
     base = file("akka-samples/akka-sample-fsm"),
     dependencies = Seq(actor),
-    settings = defaultSettings
+    settings = defaultSettings ++ Seq( publishArtifact in Compile := false )
   )
 
   lazy val helloSample = Project(
     id = "akka-sample-hello",
     base = file("akka-samples/akka-sample-hello"),
     dependencies = Seq(actor),
-    settings = defaultSettings
+    settings = defaultSettings ++ Seq( publishArtifact in Compile := false )
   )
 
   lazy val helloKernelSample = Project(
     id = "akka-sample-hello-kernel",
     base = file("akka-samples/akka-sample-hello-kernel"),
     dependencies = Seq(kernel),
-    settings = defaultSettings
+    settings = defaultSettings ++ Seq( publishArtifact in Compile := false )
   )
 
   lazy val remoteSample = Project(
     id = "akka-sample-remote",
     base = file("akka-samples/akka-sample-remote"),
     dependencies = Seq(actor, remote, kernel),
-    settings = defaultSettings
+    settings = defaultSettings ++ Seq( publishArtifact in Compile := false )
   )
 
   lazy val clusterSample = Project(
     id = "akka-sample-cluster",
     base = file("akka-samples/akka-sample-cluster"),
     dependencies = Seq(cluster),
-    settings = defaultSettings
+    settings = defaultSettings ++ Seq( publishArtifact in Compile := false )
   )
 
   lazy val docs = Project(
@@ -471,7 +467,7 @@ object AkkaBuild extends Build {
     .setPreference(AlignSingleLineCaseStatements, true)
   }
 
-  lazy val multiJvmSettings = SbtMultiJvm.settings ++ inConfig(MultiJvm)(ScalariformPlugin.scalariformSettings) ++ Seq(
+  lazy val multiJvmSettings = SbtMultiJvm.multiJvmSettings ++ inConfig(MultiJvm)(ScalariformPlugin.scalariformSettings) ++ Seq(
     compileInputs in MultiJvm <<= (compileInputs in MultiJvm) dependsOn (ScalariformKeys.format in MultiJvm),
     compile in MultiJvm <<= (compile in MultiJvm) triggeredBy (compile in Test),
     ScalariformKeys.preferences in MultiJvm := formattingPreferences) ++
@@ -514,7 +510,7 @@ object AkkaBuild extends Build {
 
     val cluster = exports(Seq("akka.cluster.*"))
 
-    val fileMailbox = exports(Seq("akka.actor.mailbox.*"))
+    val fileMailbox = exports(Seq("akka.actor.mailbox.filebased.*"))
 
     val mailboxesCommon = exports(Seq("akka.actor.mailbox.*"))
 
@@ -522,7 +518,7 @@ object AkkaBuild extends Build {
 
     val osgiAries = exports() ++ Seq(OsgiKeys.privatePackage := Seq("akka.osgi.aries.*"))
 
-    val remote = exports(Seq("akka.remote.*", "akka.routing.*", "akka.serialization.*"))
+    val remote = exports(Seq("akka.remote.*"))
 
     val slf4j = exports(Seq("akka.event.slf4j.*"))
 
@@ -534,16 +530,13 @@ object AkkaBuild extends Build {
 
     def exports(packages: Seq[String] = Seq()) = osgiSettings ++ Seq(
       OsgiKeys.importPackage := defaultImports,
-      OsgiKeys.exportPackage := packages,
+      OsgiKeys.exportPackage := packages
-      packagedArtifact in (Compile, packageBin) <<= (artifact in (Compile, packageBin), OsgiKeys.bundle).identityMap,
-      artifact in (Compile, packageBin) ~= (_.copy(`type` = "bundle"))
     )
 
     def defaultImports = Seq("!sun.misc", akkaImport(), configImport(), scalaImport(), "*")
     def akkaImport(packageName: String = "akka.*") = "%s;version=\"[2.1,2.2)\"".format(packageName)
     def configImport(packageName: String = "com.typesafe.config.*") = "%s;version=\"[0.4.1,0.5)\"".format(packageName)
     def scalaImport(packageName: String = "scala.*") = "%s;version=\"[2.10,2.11)\"".format(packageName)
-
   }
 }
 

project/Publish.scala

@@ -74,6 +74,15 @@ object Publish {
     }
   }
 
+  def akkaPluginPublishTo: Initialize[Option[Resolver]] = {
+    (version) { version: String =>
+      akkaPublishRepository orElse {
+        val name = if (version.contains("-SNAPSHOT")) "sbt-plugin-snapshots" else "sbt-plugin-releases"
+        Some(Resolver.url(name, url("http://scalasbt.artifactoryonline.com/scalasbt/" + name))(Resolver.ivyStylePatterns))
+      }
+    }
+  }
+
   def sonatypeRepo(version: String): Option[Resolver] = {
     Option(sys.props("publish.maven.central")) filter (_.toLowerCase == "true") map { _ =>
       val nexus = "https://oss.sonatype.org/"
@@ -83,15 +92,11 @@ object Publish {
   }
 
 
-  def akkaPublishRepository: Option[Resolver] = {
+  def akkaPublishRepository: Option[Resolver] =
-      val property = Option(System.getProperty("akka.publish.repository"))
+      Option(System.getProperty("akka.publish.repository", null)) map { "Akka Publish Repository" at _ }
-      property map { "Akka Publish Repository" at _ }
-  }
 
-  def akkaCredentials: Seq[Credentials] = {
+  def akkaCredentials: Seq[Credentials] =
-    val property = Option(System.getProperty("akka.publish.credentials"))
+    Option(System.getProperty("akka.publish.credentials", null)) map (f => Credentials(new File(f))) toSeq
-    property map (f => Credentials(new File(f))) toSeq
-  }
 
   // timestamped versions
 

project/plugins.sbt

@@ -1,11 +1,11 @@
 
 resolvers += Classpaths.typesafeResolver
 
-addSbtPlugin("com.typesafe.sbt" % "sbt-multi-jvm" % "0.2.0")
+addSbtPlugin("com.typesafe.sbt" % "sbt-multi-jvm" % "0.3.0")
 
 addSbtPlugin("com.typesafe.sbtscalariform" % "sbtscalariform" % "0.4.0")
 
-addSbtPlugin("com.typesafe.sbtosgi" % "sbtosgi" % "0.2.0")
+addSbtPlugin("com.typesafe.sbtosgi" % "sbtosgi" % "0.3.0")
 
 addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.3")