diff --git a/.gitignore b/.gitignore
index cb0c517fff..02f7ff993d 100755
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 *#
 *.log
 *.orig
+*.jfr
 *.iml
 *.ipr
 *.iws
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4d41c6a848..795216dc39 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -85,6 +85,8 @@ The TL;DR; of the above very precise workflow version is:
 4. Keep polishing it until received enough LGTM
 5. Profit!
 
+Note that the Akka sbt project is large, so `sbt` needs to be run with lots of heap (1-2 Gb). This can be specified using a command line argument `sbt -mem 2048` or in the environment variable `SBT_OPTS` but then as a regular JVM memory flag, for example `SBT_OPTS=-Xmx2G`, on some platforms you can also edit the global defaults for sbt in `/usr/local/etc/sbtopts`.
+
 ## The `validatePullRequest` task
 
 The Akka build includes a special task called `validatePullRequest` which investigates the changes made as well as dirty
@@ -179,6 +181,19 @@ For more info, or for a starting point for new projects, look at the [Lightbend
 
 For larger projects that have invested a lot of time and resources into their current documentation and samples scheme (like for example Play), it is understandable that it will take some time to migrate to this new model. In these cases someone from the project needs to take the responsibility of manual QA and verifier for the documentation and samples.
 
+### JavaDoc
+
+Akka generates JavaDoc-style API documentation using the [genjavadoc](https://github.com/typesafehub/genjavadoc) sbt plugin, since the sources are written mostly in Scala.
+
+Generating JavaDoc is not enabled by default, as it's not needed on day-to-day development as it's expected to just work.
+If you'd like to check if you links and formatting looks good in JavaDoc (and not only in ScalaDoc), you can generate it by running:
+
+```
+sbt -Dakka.genjavadoc.enabled=true javaunidoc:doc
+```
+
+Which will generate JavaDoc style docs in `./target/javaunidoc/index.html`
+
 ## External Dependencies
 
 All the external runtime dependencies for the project, including transitive dependencies, must have an open source license that is equal to, or compatible with, [Apache 2](http://www.apache.org/licenses/LICENSE-2.0).
@@ -224,7 +239,7 @@ Example:
 Akka uses [Jenkins GitHub pull request builder plugin](https://wiki.jenkins-ci.org/display/JENKINS/GitHub+pull+request+builder+plugin)
 that automatically merges the code, builds it, runs the tests and comments on the Pull Request in GitHub.
 
-Upon a submission of a Pull Request the Github pull request builder plugin will post a following comment:
+Upon a submission of a Pull Request the GitHub pull request builder plugin will post a following comment:
 
     Can one of the repo owners verify this patch?
 
@@ -258,6 +273,21 @@ Thus we ask Java contributions to follow these simple guidelines:
 - `{` on same line as method name
 - in all other aspects, follow the [Oracle Java Style Guide](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
 
+### Preferred ways to use timeouts in tests
+
+Avoid short test timeouts, since Jenkins server may GC heavily causing spurious test failures. GC pause or other hiccup of 2 seconds is common in our CI environment. Please note that usually giving a larger timeout *does not slow down the tests*, as in an `expectMessage` call for example it usually will complete quickly.
+
+There is a number of ways timeouts can be defined in Akka tests. The following ways to use timeouts are recommended (in order of preference): 
+
+* `remaining` is first choice (requires `within` block)
+* `remainingOrDefault` is second choice
+* `3.seconds` is third choice if not using testkit
+* lower timeouts must come with a very good reason (e.g. Awaiting on a known to be "already completed" `Future`)
+
+Special care should be given `expectNoMsg` calls, which indeed will wait the entire timeout before continuing, therefore a shorter timeout should be used in those, for example `200` or `300.millis`.
+
+You can read up on remaining and friends in [TestKit.scala](https://github.com/akka/akka/blob/master/akka-testkit/src/main/scala/akka/testkit/TestKit.scala)
+
 ## Contributing Modules
 
 For external contributions of entire features, the normal way is to establish it
diff --git a/README.md b/README.md
index 339887d464..4b6c42c083 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ Reference Documentation
 -----------------------
 
 The reference documentation is available at [doc.akka.io](http://doc.akka.io), 
-for [Scala](http://doc.akka.io/docs/akka/current/scala.html) and [Java](http://doc.akka.io/docs/akka/current/scala.html).
+for [Scala](http://doc.akka.io/docs/akka/current/scala.html) and [Java](http://doc.akka.io/docs/akka/current/java.html).
 
 
 Community
@@ -31,9 +31,10 @@ You can join these groups and chats to discuss and ask Akka related questions:
 
 In addition to that, you may enjoy following:
 
+- The [news](http://akka.io/news) section of the page, which is updated whenever a new version is released 
 - The [Akka Team Blog](http://blog.akka.io)
 - [@akkateam](https://twitter.com/akkateam) on Twitter
-- Questions tagged [#akka on StackOverflow](stackoverflow.com/questions/tagged/akka)
+- Questions tagged [#akka on StackOverflow](http://stackoverflow.com/questions/tagged/akka)
 
 Contributing
 ------------
@@ -42,7 +43,7 @@ Contributions are *very* welcome!
 If you see an issue that you'd like to see fixed, the best way to make it happen is to help out by submitting a PullRequest implementing it.
 
 Refer to the [CONTRIBUTING.md](https://github.com/akka/akka/blob/master/CONTRIBUTING.md) file for more details about the workflow,
-and general hints how to prepare your pull request. You can also chat ask for clarifications or guidance in github issues directly,
+and general hints how to prepare your pull request. You can also chat ask for clarifications or guidance in GitHub issues directly,
 or in the akka/dev chat if a more real time communication would be of benefit.
 
 A chat room is available for all questions related to *developing and contributing* to Akka:
diff --git a/akka-actor-tests/src/test/java/akka/actor/ActorCreationTest.java b/akka-actor-tests/src/test/java/akka/actor/ActorCreationTest.java
index 0f2b4ed585..35e835aa90 100644
--- a/akka-actor-tests/src/test/java/akka/actor/ActorCreationTest.java
+++ b/akka-actor-tests/src/test/java/akka/actor/ActorCreationTest.java
@@ -11,6 +11,7 @@ import java.util.ArrayList;
 import java.util.stream.IntStream;
 
 import akka.testkit.TestActors;
+import org.junit.Assert;
 import org.junit.Test;
 
 import akka.japi.Creator;
@@ -209,7 +210,7 @@ public class ActorCreationTest extends JUnitSuite {
   public void testWrongAnonymousClassStaticCreator() {
     try {
       Props.create(new C() {}); // has implicit reference to outer class
-      fail("Should have detected this is not a real static class, and thrown");
+      org.junit.Assert.fail("Should have detected this is not a real static class, and thrown");
     } catch (IllegalArgumentException e) {
       assertEquals("cannot use non-static local Creator to create actors; make it static (e.g. local to a static method) or top-level", e.getMessage());
     }
@@ -278,7 +279,7 @@ public class ActorCreationTest extends JUnitSuite {
         // captures enclosing class
       };
       Props.create(anonymousCreatorFromStaticMethod);
-      fail("Should have detected this is not a real static class, and thrown");
+      org.junit.Assert.fail("Should have detected this is not a real static class, and thrown");
     } catch (IllegalArgumentException e) {
       assertEquals("cannot use non-static local Creator to create actors; make it static (e.g. local to a static method) or top-level", e.getMessage());
     }
@@ -296,7 +297,7 @@ public class ActorCreationTest extends JUnitSuite {
     assertEquals(TestActor.class, p.actorClass());
     try {
       TestActor.propsUsingLamdaWithoutClass(17);
-      fail("Should have detected lambda erasure, and thrown");
+      org.junit.Assert.fail("Should have detected lambda erasure, and thrown");
     } catch (IllegalArgumentException e) {
       assertEquals("erased Creator types are unsupported, use Props.create(actorClass, creator) instead",
           e.getMessage());
diff --git a/akka-actor-tests/src/test/java/akka/japi/JavaAPITestBase.java b/akka-actor-tests/src/test/java/akka/japi/JavaAPITestBase.java
index 10c40159f8..d97f4302e5 100644
--- a/akka-actor-tests/src/test/java/akka/japi/JavaAPITestBase.java
+++ b/akka-actor-tests/src/test/java/akka/japi/JavaAPITestBase.java
@@ -41,14 +41,14 @@ public class JavaAPITestBase extends JUnitSuite {
     String s : Option.some("abc")) {
       return;
     }
-    fail("for-loop not entered");
+    org.junit.Assert.fail("for-loop not entered");
   }
 
   @Test
   public void shouldNotEnterForLoop() {
     for (@SuppressWarnings("unused")
     Object o : Option.none()) {
-      fail("for-loop entered");
+      org.junit.Assert.fail("for-loop entered");
     }
   }
 
diff --git a/akka-actor-tests/src/test/java/akka/pattern/CircuitBreakerTest.java b/akka-actor-tests/src/test/java/akka/pattern/CircuitBreakerTest.java
new file mode 100644
index 0000000000..c3e5da1606
--- /dev/null
+++ b/akka-actor-tests/src/test/java/akka/pattern/CircuitBreakerTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.pattern;
+
+import akka.actor.*;
+import akka.testkit.AkkaJUnitActorSystemResource;
+import akka.testkit.AkkaSpec;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.scalatest.junit.JUnitSuite;
+import scala.compat.java8.FutureConverters;
+import scala.concurrent.Await;
+import scala.concurrent.duration.FiniteDuration;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+
+public class CircuitBreakerTest extends JUnitSuite {
+
+  @ClassRule
+  public static AkkaJUnitActorSystemResource actorSystemResource = 
+    new AkkaJUnitActorSystemResource("JavaAPI", AkkaSpec.testConf());
+
+  private final ActorSystem system = actorSystemResource.getSystem();
+
+  @Test
+  public void useCircuitBreakerWithCompletableFuture() throws Exception {
+    final FiniteDuration fiveSeconds = FiniteDuration.create(5, TimeUnit.SECONDS);
+    final FiniteDuration fiveHundredMillis = FiniteDuration.create(500, TimeUnit.MILLISECONDS);
+    final CircuitBreaker breaker = new CircuitBreaker(system.dispatcher(), system.scheduler(), 1, fiveSeconds, fiveHundredMillis);
+
+    final CompletableFuture<String> f = new CompletableFuture<>();
+    f.complete("hello");
+    final CompletionStage<String> res = breaker.callWithCircuitBreakerCS(() -> f);
+    assertEquals("hello", Await.result(FutureConverters.toScala(res), fiveSeconds));
+  }
+
+}
diff --git a/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
index 46cd02589d..d30e02b2fa 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/DeployerSpec.scala
@@ -60,6 +60,12 @@ object DeployerSpec {
         "/*/some" {
           router = scatter-gather-pool
         }
+        "/double/**" {
+          router = random-pool
+        }
+        "/double/more/**" {
+          router = round-robin-pool
+        }
       }
       """, ConfigParseOptions.defaults)
 
@@ -74,7 +80,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
 
     "be able to parse 'akka.actor.deployment._' with all default values" in {
       val service = "/service1"
-      val deployment = system.asInstanceOf[ActorSystemImpl].provider.deployer.lookup(service.split("/").drop(1))
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
 
       deployment should ===(Some(
         Deploy(
@@ -88,13 +94,13 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
 
     "use None deployment for undefined service" in {
       val service = "/undefined"
-      val deployment = system.asInstanceOf[ActorSystemImpl].provider.deployer.lookup(service.split("/").drop(1))
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
       deployment should ===(None)
     }
 
     "be able to parse 'akka.actor.deployment._' with dispatcher config" in {
       val service = "/service3"
-      val deployment = system.asInstanceOf[ActorSystemImpl].provider.deployer.lookup(service.split("/").drop(1))
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
 
       deployment should ===(Some(
         Deploy(
@@ -108,7 +114,7 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
 
     "be able to parse 'akka.actor.deployment._' with mailbox config" in {
       val service = "/service4"
-      val deployment = system.asInstanceOf[ActorSystemImpl].provider.deployer.lookup(service.split("/").drop(1))
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
 
       deployment should ===(Some(
         Deploy(
@@ -186,8 +192,15 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
       assertRouting("/somewildcardmatch/some", ScatterGatherFirstCompletedPool(nrOfInstances = 1, within = 2 seconds), "/*/some")
     }
 
+    "be able to use double wildcards" in {
+      assertRouting("/double/wildcardmatch", RandomPool(1), "/double/**")
+      assertRouting("/double/wildcardmatch/anothermatch", RandomPool(1), "/double/**")
+      assertRouting("/double/more/anothermatch", RoundRobinPool(1), "/double/more/**")
+      assertNoRouting("/double")
+    }
+
     "have correct router mappings" in {
-      val mapping = system.asInstanceOf[ActorSystemImpl].provider.deployer.routerTypeMapping
+      val mapping = system.asInstanceOf[ExtendedActorSystem].provider.deployer.routerTypeMapping
       mapping("from-code") should ===(classOf[akka.routing.NoRouter].getName)
       mapping("round-robin-pool") should ===(classOf[akka.routing.RoundRobinPool].getName)
       mapping("round-robin-group") should ===(classOf[akka.routing.RoundRobinGroup].getName)
@@ -203,8 +216,13 @@ class DeployerSpec extends AkkaSpec(DeployerSpec.deployerConf) {
       mapping("consistent-hashing-group") should ===(classOf[akka.routing.ConsistentHashingGroup].getName)
     }
 
+    def assertNoRouting(service: String): Unit = {
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
+      deployment shouldNot be(defined)
+    }
+
     def assertRouting(service: String, expected: RouterConfig, expectPath: String): Unit = {
-      val deployment = system.asInstanceOf[ActorSystemImpl].provider.deployer.lookup(service.split("/").drop(1))
+      val deployment = system.asInstanceOf[ExtendedActorSystem].provider.deployer.lookup(service.split("/").drop(1))
       deployment.map(_.path).getOrElse("NOT FOUND") should ===(expectPath)
       deployment.get.routerConfig.getClass should ===(expected.getClass)
       deployment.get.scope should ===(NoScopeGiven)
diff --git a/akka-actor-tests/src/test/scala/akka/actor/ReceiveTimeoutSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/ReceiveTimeoutSpec.scala
index 445d52bf67..2ada2abda8 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/ReceiveTimeoutSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/ReceiveTimeoutSpec.scala
@@ -102,7 +102,12 @@ class ReceiveTimeoutSpec extends AkkaSpec {
         }
       }))
 
-      val ticks = system.scheduler.schedule(100.millis, 100.millis, timeoutActor, TransperentTick)(system.dispatcher)
+      val ticks = system.scheduler.schedule(100.millis, 100.millis, new Runnable {
+        override def run() = {
+          timeoutActor ! TransperentTick
+          timeoutActor ! Identify(None)
+        }
+      })(system.dispatcher)
 
       Await.ready(timeoutLatch, TestLatch.DefaultTimeout)
       ticks.cancel()
diff --git a/akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala b/akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala
index 2a4ae83b05..fd520eee22 100644
--- a/akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala
@@ -719,7 +719,14 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
         Await.result(p.future, timeout.duration) should ===(message)
       }
     }
-    "always cast successfully using mapTo" in { f((future, message) ⇒ (evaluating { Await.result(future.mapTo[java.lang.Thread], timeout.duration) } should produce[java.lang.Exception]).getMessage should ===(message)) }
+    "always cast successfully using mapTo" in {
+      f((future, message) ⇒ {
+        val exception = the[java.lang.Exception] thrownBy {
+          Await.result(future.mapTo[java.lang.Thread], timeout.duration)
+        }
+        exception.getMessage should ===(message)
+      })
+    }
   }
 
   implicit def arbFuture: Arbitrary[Future[Int]] = Arbitrary(for (n ← arbitrary[Int]) yield Future(n))
diff --git a/akka-actor-tests/src/test/scala/akka/io/SimpleDnsCacheSpec.scala b/akka-actor-tests/src/test/scala/akka/io/SimpleDnsCacheSpec.scala
index af796c6e0b..b45f547fe0 100644
--- a/akka-actor-tests/src/test/scala/akka/io/SimpleDnsCacheSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/io/SimpleDnsCacheSpec.scala
@@ -3,9 +3,9 @@ package akka.io
 import java.net.InetAddress
 import java.util.concurrent.atomic.AtomicLong
 
-import org.scalatest.{ ShouldMatchers, WordSpec }
+import org.scalatest.{ Matchers, WordSpec }
 
-class SimpleDnsCacheSpec extends WordSpec with ShouldMatchers {
+class SimpleDnsCacheSpec extends WordSpec with Matchers {
   "Cache" should {
     "not reply with expired but not yet swept out entries" in {
       val localClock = new AtomicLong(0)
@@ -15,11 +15,11 @@ class SimpleDnsCacheSpec extends WordSpec with ShouldMatchers {
       val cacheEntry = Dns.Resolved("test.local", Seq(InetAddress.getByName("127.0.0.1")))
       cache.put(cacheEntry, 5000)
 
-      cache.cached("test.local") should equal(Some(cacheEntry))
+      cache.cached("test.local") should ===(Some(cacheEntry))
       localClock.set(4999)
-      cache.cached("test.local") should equal(Some(cacheEntry))
+      cache.cached("test.local") should ===(Some(cacheEntry))
       localClock.set(5000)
-      cache.cached("test.local") should equal(None)
+      cache.cached("test.local") should ===(None)
     }
 
     "sweep out expired entries on cleanup()" in {
@@ -30,16 +30,16 @@ class SimpleDnsCacheSpec extends WordSpec with ShouldMatchers {
       val cacheEntry = Dns.Resolved("test.local", Seq(InetAddress.getByName("127.0.0.1")))
       cache.put(cacheEntry, 5000)
 
-      cache.cached("test.local") should equal(Some(cacheEntry))
+      cache.cached("test.local") should ===(Some(cacheEntry))
       localClock.set(5000)
-      cache.cached("test.local") should equal(None)
+      cache.cached("test.local") should ===(None)
       localClock.set(0)
-      cache.cached("test.local") should equal(Some(cacheEntry))
+      cache.cached("test.local") should ===(Some(cacheEntry))
       localClock.set(5000)
       cache.cleanup()
-      cache.cached("test.local") should equal(None)
+      cache.cached("test.local") should ===(None)
       localClock.set(0)
-      cache.cached("test.local") should equal(None)
+      cache.cached("test.local") should ===(None)
     }
   }
 }
diff --git a/akka-actor-tests/src/test/scala/akka/io/TcpConnectionSpec.scala b/akka-actor-tests/src/test/scala/akka/io/TcpConnectionSpec.scala
index 1dcacf1b0d..5272f0b471 100644
--- a/akka-actor-tests/src/test/scala/akka/io/TcpConnectionSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/io/TcpConnectionSpec.scala
@@ -449,10 +449,10 @@ class TcpConnectionSpec extends AkkaSpec("""
           assertThisConnectionActorTerminated()
 
           val buffer = ByteBuffer.allocate(1)
-          val thrown = evaluating {
+          val thrown = the[IOException] thrownBy {
             windowsWorkaroundToDetectAbort()
             serverSideChannel.read(buffer)
-          } should produce[IOException]
+          }
           thrown.getMessage should ===(ConnectionResetByPeerMessage)
         }
       }
diff --git a/akka-actor-tests/src/test/scala/akka/pattern/CircuitBreakerSpec.scala b/akka-actor-tests/src/test/scala/akka/pattern/CircuitBreakerSpec.scala
index a0df91c16c..35784cf58f 100644
--- a/akka-actor-tests/src/test/scala/akka/pattern/CircuitBreakerSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/pattern/CircuitBreakerSpec.scala
@@ -133,10 +133,10 @@ class CircuitBreakerSpec extends AkkaSpec with BeforeAndAfter {
       val breaker = CircuitBreakerSpec.shortCallTimeoutCb()
       Future {
         breaker().withSyncCircuitBreaker {
-          Thread.sleep(500.millis.dilated.toMillis)
+          Thread.sleep(1.second.dilated.toMillis)
         }
       }
-      within(300.millis) {
+      within(900.millis) {
         awaitCond(breaker().currentFailureCount == 1, 100.millis.dilated)
       }
     }
@@ -219,7 +219,7 @@ class CircuitBreakerSpec extends AkkaSpec with BeforeAndAfter {
       val breaker = CircuitBreakerSpec.shortCallTimeoutCb()
 
       val fut = breaker().withCircuitBreaker(Future {
-        Thread.sleep(150.millis.dilated.toMillis);
+        Thread.sleep(150.millis.dilated.toMillis)
         throwException
       })
       checkLatch(breaker.openLatch)
diff --git a/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala b/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala
index 57dac8c482..1e2fce7b4c 100644
--- a/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala
@@ -10,6 +10,7 @@ import java.lang.Float.floatToRawIntBits
 import java.nio.{ ByteBuffer, ByteOrder }
 import java.nio.ByteOrder.{ BIG_ENDIAN, LITTLE_ENDIAN }
 
+import akka.util.ByteString.{ ByteString1, ByteString1C, ByteStrings }
 import org.apache.commons.codec.binary.Hex.encodeHex
 import org.scalacheck.Arbitrary.arbitrary
 import org.scalacheck.{ Arbitrary, Gen }
@@ -20,6 +21,12 @@ import scala.collection.mutable.Builder
 
 class ByteStringSpec extends WordSpec with Matchers with Checkers {
 
+  //  // uncomment when developing locally to get better coverage
+  //  implicit override val generatorDrivenConfig =
+  //    PropertyCheckConfig(
+  //      minSuccessful = 1000,
+  //      minSize = 0, maxSize = 100)
+
   def genSimpleByteString(min: Int, max: Int) = for {
     n ← Gen.choose(min, max)
     b ← Gen.containerOfN[Array, Byte](n, arbitrary[Byte])
@@ -56,14 +63,21 @@ class ByteStringSpec extends WordSpec with Matchers with Checkers {
     } yield (xs, from, until)
   }
 
-  def testSer(obj: AnyRef) = {
+  def serialize(obj: AnyRef): Array[Byte] = {
     val os = new ByteArrayOutputStream
     val bos = new ObjectOutputStream(os)
     bos.writeObject(obj)
-    val arr = os.toByteArray
-    val is = new ObjectInputStream(new ByteArrayInputStream(arr))
+    os.toByteArray
+  }
 
-    is.readObject == obj
+  def deserialize(bytes: Array[Byte]): AnyRef = {
+    val is = new ObjectInputStream(new ByteArrayInputStream(bytes))
+
+    is.readObject
+  }
+
+  def testSer(obj: AnyRef) = {
+    deserialize(serialize(obj)) == obj
   }
 
   def hexFromSer(obj: AnyRef) = {
@@ -281,10 +295,113 @@ class ByteStringSpec extends WordSpec with Matchers with Checkers {
     reference.toSeq == builder.result
   }
 
+  "ByteString1" must {
+    "drop(0)" in {
+      ByteString1.fromString("").drop(0) should ===(ByteString.empty)
+      ByteString1.fromString("a").drop(0) should ===(ByteString("a"))
+    }
+    "drop(1)" in {
+      ByteString1.fromString("").drop(1) should ===(ByteString(""))
+      ByteString1.fromString("a").drop(1) should ===(ByteString(""))
+      ByteString1.fromString("ab").drop(1) should ===(ByteString("b"))
+      ByteString1.fromString("xaaa").drop(1) should ===(ByteString("aaa"))
+      ByteString1.fromString("xaab").drop(1).take(2) should ===(ByteString("aa"))
+      ByteString1.fromString("0123456789").drop(5).take(4).drop(1).take(2) should ===(ByteString("67"))
+    }
+    "drop(n)" in {
+      ByteString1.fromString("ab").drop(2) should ===(ByteString(""))
+      ByteString1.fromString("ab").drop(3) should ===(ByteString(""))
+    }
+  }
+  "ByteString1C" must {
+    "drop(0)" in {
+      ByteString1C.fromString("").drop(0) should ===(ByteString.empty)
+      ByteString1C.fromString("a").drop(0) should ===(ByteString("a"))
+    }
+    "drop(1)" in {
+      ByteString1C.fromString("").drop(1) should ===(ByteString(""))
+      ByteString1C.fromString("a").drop(1) should ===(ByteString(""))
+      ByteString1C.fromString("ab").drop(1) should ===(ByteString("b"))
+    }
+    "drop(n)" in {
+      ByteString1C.fromString("ab").drop(2) should ===(ByteString(""))
+      ByteString1C.fromString("ab").drop(3) should ===(ByteString(""))
+    }
+    "take" in {
+      ByteString1.fromString("abcdefg").drop(1).take(0) should ===(ByteString(""))
+      ByteString1.fromString("abcdefg").drop(1).take(-1) should ===(ByteString(""))
+      ByteString1.fromString("abcdefg").drop(1).take(-2) should ===(ByteString(""))
+      ByteString1.fromString("abcdefg").drop(2) should ===(ByteString("cdefg"))
+      ByteString1.fromString("abcdefg").drop(2).take(1) should ===(ByteString("c"))
+    }
+  }
+  "ByteStrings" must {
+    "drop(0)" in {
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("")).drop(0) should ===(ByteString.empty)
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("a")).drop(0) should ===(ByteString("a"))
+      (ByteString1C.fromString("") ++ ByteString1.fromString("a")).drop(0) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).drop(0) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("a")).drop(0) should ===(ByteString("aa"))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("")).drop(0) should ===(ByteString(""))
+    }
+    "drop(1)" in {
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("")).drop(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).drop(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("a")).drop(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(1) should ===(ByteString("bcd"))
+      ByteStrings(Vector(ByteString1.fromString("xaaa"))).drop(1) should ===(ByteString("aaa"))
+    }
+    "drop(n)" in {
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).drop(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("a")).drop(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(3) should ===(ByteString("d"))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(4) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(5) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(10) should ===(ByteString(""))
+
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).drop(-2) should ===(ByteString("abcd"))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("")).drop(-2) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("")).drop(Int.MinValue) should ===(ByteString("ab"))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("ab")).dropRight(Int.MinValue) should ===(ByteString("ab"))
+    }
+    "slice" in {
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).slice(0, 1) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString(""), ByteString1.fromString("a")).slice(1, 1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).slice(2, 2) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).slice(2, 3) should ===(ByteString("c"))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).slice(2, 4) should ===(ByteString("cd"))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).slice(3, 4) should ===(ByteString("d"))
+      ByteStrings(ByteString1.fromString("ab"), ByteString1.fromString("cd")).slice(10, 100) should ===(ByteString(""))
+    }
+    "dropRight" in {
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).dropRight(0) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).dropRight(-1) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).dropRight(Int.MinValue) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).dropRight(1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("")).dropRight(Int.MaxValue) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).dropRight(1) should ===(ByteString("ab"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).dropRight(2) should ===(ByteString("a"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).dropRight(3) should ===(ByteString(""))
+    }
+    "take" in {
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).drop(1).take(0) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).drop(1).take(-1) should ===(ByteString(""))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).drop(1).take(-2) should ===(ByteString(""))
+      (ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")) ++ ByteString1.fromString("defg")).drop(2) should ===(ByteString("cdefg"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).drop(2).take(1) should ===(ByteString("c"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).take(100) should ===(ByteString("abc"))
+      ByteStrings(ByteString1.fromString("a"), ByteString1.fromString("bc")).drop(1).take(100) should ===(ByteString("bc"))
+    }
+  }
+
   "A ByteString" must {
     "have correct size" when {
       "concatenating" in { check((a: ByteString, b: ByteString) ⇒ (a ++ b).size == a.size + b.size) }
       "dropping" in { check((a: ByteString, b: ByteString) ⇒ (a ++ b).drop(b.size).size == a.size) }
+      "taking" in { check((a: ByteString, b: ByteString) ⇒ (a ++ b).take(a.size) == a) }
+      "takingRight" in { check((a: ByteString, b: ByteString) ⇒ (a ++ b).takeRight(b.size) == b) }
+      "droppnig then taking" in { check((a: ByteString, b: ByteString) ⇒ (b ++ a ++ b).drop(b.size).take(a.size) == a) }
+      "droppingRight" in { check((a: ByteString, b: ByteString) ⇒ (b ++ a ++ b).drop(b.size).dropRight(b.size) == a) }
     }
 
     "be sequential" when {
@@ -301,6 +418,21 @@ class ByteStringSpec extends WordSpec with Matchers with Checkers {
           (a ++ b ++ c) == xs
         }
       }
+      def excerciseRecombining(xs: ByteString, from: Int, until: Int) = {
+        val (tmp, c) = xs.splitAt(until)
+        val (a, b) = tmp.splitAt(from)
+        (a ++ b ++ c) should ===(xs)
+      }
+      "recombining - edge cases" in {
+        excerciseRecombining(ByteStrings(Vector(ByteString1(Array[Byte](1)), ByteString1(Array[Byte](2)))), -2147483648, 112121212)
+        excerciseRecombining(ByteStrings(Vector(ByteString1(Array[Byte](100)))), 0, 2)
+        excerciseRecombining(ByteStrings(Vector(ByteString1(Array[Byte](100)))), -2147483648, 2)
+        excerciseRecombining(ByteStrings(Vector(ByteString1.fromString("ab"), ByteString1.fromString("cd"))), 0, 1)
+        excerciseRecombining(ByteString1.fromString("abc").drop(1).take(1), -324234, 234232)
+        excerciseRecombining(ByteString("a"), 0, 2147483647)
+        excerciseRecombining(ByteStrings(Vector(ByteString1.fromString("ab"), ByteString1.fromString("cd"))).drop(2), 2147483647, 1)
+        excerciseRecombining(ByteString1.fromString("ab").drop1(1), Int.MaxValue, Int.MaxValue)
+      }
     }
 
     "behave as expected" when {
@@ -322,7 +454,7 @@ class ByteStringSpec extends WordSpec with Matchers with Checkers {
         check { (a: ByteString) ⇒ a.asByteBuffers.foldLeft(ByteString.empty) { (bs, bb) ⇒ bs ++ ByteString(bb) } == a }
         check { (a: ByteString) ⇒ a.asByteBuffers.forall(_.isReadOnly) }
         check { (a: ByteString) ⇒
-          import scala.collection.JavaConverters.iterableAsScalaIterableConverter;
+          import scala.collection.JavaConverters.iterableAsScalaIterableConverter
           a.asByteBuffers.zip(a.getByteBuffers().asScala).forall(x ⇒ x._1 == x._2)
         }
       }
@@ -404,6 +536,13 @@ class ByteStringSpec extends WordSpec with Matchers with Checkers {
           testSer(bs)
         }
       }
+
+      "with a large concatenated bytestring" in {
+        // coverage for #20901
+        val original = ByteString(Array.fill[Byte](1000)(1)) ++ ByteString(Array.fill[Byte](1000)(2))
+
+        deserialize(serialize(original)) shouldEqual original
+      }
     }
   }
 
diff --git a/akka-actor-tests/src/test/scala/akka/util/WildcardIndexSpec.scala b/akka-actor-tests/src/test/scala/akka/util/WildcardIndexSpec.scala
new file mode 100644
index 0000000000..33ff1e8d4a
--- /dev/null
+++ b/akka-actor-tests/src/test/scala/akka/util/WildcardIndexSpec.scala
@@ -0,0 +1,67 @@
+/**
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.util
+
+import org.scalatest.{ Matchers, WordSpec }
+
+class WildcardIndexSpec extends WordSpec with Matchers {
+
+  "wildcard index" must {
+    "allow to insert elements using Arrays of strings" in {
+      emptyIndex.insert(Array("a", "b"), 1) shouldBe a[WildcardIndex[_]]
+      emptyIndex.insert(Array("a"), 1) shouldBe a[WildcardIndex[_]]
+      emptyIndex.insert(Array.empty[String], 1) shouldBe a[WildcardIndex[_]]
+    }
+
+    "allow to find inserted elements" in {
+      val tree = emptyIndex.insert(Array("a"), 1).insert(Array("a", "b"), 2).insert(Array("a", "c"), 3)
+      tree.find(Array("a", "b")).get shouldBe 2
+      tree.find(Array("a")).get shouldBe 1
+      tree.find(Array("x")) shouldBe None
+      tree.find(Array.empty[String]) shouldBe None
+    }
+
+    "match all elements in the subArray when it contains a wildcard" in {
+      val tree1 = emptyIndex.insert(Array("a"), 1).insert(Array("a", "*"), 1)
+      tree1.find(Array("z")) shouldBe None
+      tree1.find(Array("a")).get shouldBe 1
+      tree1.find(Array("a", "b")).get shouldBe 1
+      tree1.find(Array("a", "x")).get shouldBe 1
+
+      val tree2 = emptyIndex.insert(Array("a", "*"), 1).insert(Array("a", "*", "c"), 2)
+      tree2.find(Array("z")) shouldBe None
+      tree2.find(Array("a", "b")).get shouldBe 1
+      tree2.find(Array("a", "x")).get shouldBe 1
+      tree2.find(Array("a", "x", "c")).get shouldBe 2
+      tree2.find(Array("a", "x", "y")) shouldBe None
+    }
+
+    "never find anything when emptyIndex" in {
+      emptyIndex.find(Array("a")) shouldBe None
+      emptyIndex.find(Array("a", "b")) shouldBe None
+      emptyIndex.find(Array.empty[String]) shouldBe None
+    }
+
+    "match all remaining elements when it contains a terminal double wildcard" in {
+      val tree1 = emptyIndex.insert(Array("a", "**"), 1)
+      tree1.find(Array("z")) shouldBe None
+      tree1.find(Array("a", "b")).get shouldBe 1
+      tree1.find(Array("a", "x")).get shouldBe 1
+      tree1.find(Array("a", "x", "y")).get shouldBe 1
+
+      val tree2 = emptyIndex.insert(Array("**"), 1)
+      tree2.find(Array("anything", "I", "want")).get shouldBe 1
+      tree2.find(Array("anything")).get shouldBe 1
+    }
+
+    "ignore non-terminal double wildcards" in {
+      val tree = emptyIndex.insert(Array("a", "**", "c"), 1)
+      tree.find(Array("a", "x", "y", "c")) shouldBe None
+      tree.find(Array("a", "x", "y")) shouldBe None
+    }
+  }
+
+  private val emptyIndex = WildcardIndex[Int]()
+}
diff --git a/akka-actor/src/main/scala/akka/actor/Actor.scala b/akka-actor/src/main/scala/akka/actor/Actor.scala
index 7be9612952..f0e766e410 100644
--- a/akka-actor/src/main/scala/akka/actor/Actor.scala
+++ b/akka-actor/src/main/scala/akka/actor/Actor.scala
@@ -61,7 +61,7 @@ case object Kill extends Kill {
  * is returned in the `ActorIdentity` message as `correlationId`.
  */
 @SerialVersionUID(1L)
-final case class Identify(messageId: Any) extends AutoReceivedMessage
+final case class Identify(messageId: Any) extends AutoReceivedMessage with NotInfluenceReceiveTimeout
 
 /**
  * Reply to [[akka.actor.Identify]]. Contains
diff --git a/akka-actor/src/main/scala/akka/actor/Deployer.scala b/akka-actor/src/main/scala/akka/actor/Deployer.scala
index 9431139801..6b47dd0240 100644
--- a/akka-actor/src/main/scala/akka/actor/Deployer.scala
+++ b/akka-actor/src/main/scala/akka/actor/Deployer.scala
@@ -7,7 +7,7 @@ package akka.actor
 import java.util.concurrent.atomic.AtomicReference
 
 import akka.routing._
-import akka.util.WildcardTree
+import akka.util.WildcardIndex
 import com.typesafe.config._
 
 import scala.annotation.tailrec
@@ -132,7 +132,7 @@ private[akka] class Deployer(val settings: ActorSystem.Settings, val dynamicAcce
   import scala.collection.JavaConverters._
 
   private val resizerEnabled: Config = ConfigFactory.parseString("resizer.enabled=on")
-  private val deployments = new AtomicReference(WildcardTree[Deploy]())
+  private val deployments = new AtomicReference(WildcardIndex[Deploy]())
   private val config = settings.config.getConfig("akka.actor.deployment")
   protected val default = config.getConfig("default")
   val routerTypeMapping: Map[String, String] =
@@ -146,20 +146,18 @@ private[akka] class Deployer(val settings: ActorSystem.Settings, val dynamicAcce
     case _                          ⇒ None
   } foreach deploy
 
-  def lookup(path: ActorPath): Option[Deploy] = lookup(path.elements.drop(1).iterator)
+  def lookup(path: ActorPath): Option[Deploy] = lookup(path.elements.drop(1))
 
-  def lookup(path: Iterable[String]): Option[Deploy] = lookup(path.iterator)
-
-  def lookup(path: Iterator[String]): Option[Deploy] = deployments.get().find(path).data
+  def lookup(path: Iterable[String]): Option[Deploy] = deployments.get().find(path)
 
   def deploy(d: Deploy): Unit = {
-    @tailrec def add(path: Array[String], d: Deploy, w: WildcardTree[Deploy] = deployments.get): Unit = {
-      for (i ← 0 until path.length) path(i) match {
+    @tailrec def add(path: Array[String], d: Deploy, w: WildcardIndex[Deploy] = deployments.get): Unit = {
+      for (i ← path.indices) path(i) match {
         case "" ⇒ throw new InvalidActorNameException(s"Actor name in deployment [${d.path}] must not be empty")
         case el ⇒ ActorPath.validatePathElement(el, fullPath = d.path)
       }
 
-      if (!deployments.compareAndSet(w, w.insert(path.iterator, d))) add(path, d)
+      if (!deployments.compareAndSet(w, w.insert(path, d))) add(path, d)
     }
 
     add(d.path.split("/").drop(1), d)
diff --git a/akka-actor/src/main/scala/akka/actor/FSM.scala b/akka-actor/src/main/scala/akka/actor/FSM.scala
index 242083a730..6d4d0f11d7 100644
--- a/akka-actor/src/main/scala/akka/actor/FSM.scala
+++ b/akka-actor/src/main/scala/akka/actor/FSM.scala
@@ -224,6 +224,7 @@ object FSM {
  * Finite State Machine actor trait. Use as follows:
  *
  * <pre>
+ *   object A {
  *     trait State
  *     case class One extends State
  *     case class Two extends State
@@ -785,7 +786,7 @@ trait LoggingFSM[S, D] extends FSM[S, D] { this: Actor ⇒
         case a: ActorRef          ⇒ a.toString
         case _                    ⇒ "unknown"
       }
-      log.debug("processing " + event + " from " + srcstr)
+      log.debug("processing {} from {} in state {}", event, srcstr, stateName)
     }
 
     if (logDepth > 0) {
diff --git a/akka-actor/src/main/scala/akka/event/ActorClassificationUnsubscriber.scala b/akka-actor/src/main/scala/akka/event/ActorClassificationUnsubscriber.scala
index d9cada0d42..6aa9b13dbc 100644
--- a/akka-actor/src/main/scala/akka/event/ActorClassificationUnsubscriber.scala
+++ b/akka-actor/src/main/scala/akka/event/ActorClassificationUnsubscriber.scala
@@ -12,7 +12,7 @@ import java.util.concurrent.atomic.AtomicInteger
  *
  * Watches all actors which subscribe on the given event stream, and unsubscribes them from it when they are Terminated.
  */
-private[akka] class ActorClassificationUnsubscriber(bus: ManagedActorClassification, debug: Boolean) extends Actor with Stash {
+protected[akka] class ActorClassificationUnsubscriber(bus: ManagedActorClassification, debug: Boolean) extends Actor with Stash {
 
   import ActorClassificationUnsubscriber._
 
diff --git a/akka-actor/src/main/scala/akka/event/EventStreamUnsubscriber.scala b/akka-actor/src/main/scala/akka/event/EventStreamUnsubscriber.scala
index 74158a5853..1c95f3f844 100644
--- a/akka-actor/src/main/scala/akka/event/EventStreamUnsubscriber.scala
+++ b/akka-actor/src/main/scala/akka/event/EventStreamUnsubscriber.scala
@@ -19,7 +19,7 @@ import java.util.concurrent.atomic.AtomicInteger
  * subscribe calls * because of the need of linearizing the history message sequence and the possibility of sometimes
  * watching a few actors too much - we opt for the 2nd choice here.
  */
-private[akka] class EventStreamUnsubscriber(eventStream: EventStream, debug: Boolean = false) extends Actor {
+protected[akka] class EventStreamUnsubscriber(eventStream: EventStream, debug: Boolean = false) extends Actor {
 
   import EventStreamUnsubscriber._
 
diff --git a/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala b/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala
index 5f34ac2e5a..6460ee039c 100644
--- a/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala
+++ b/akka-actor/src/main/scala/akka/pattern/CircuitBreaker.scala
@@ -3,18 +3,24 @@
  */
 package akka.pattern
 
-import java.util.concurrent.atomic.{ AtomicInteger, AtomicLong, AtomicBoolean }
+import java.util.concurrent.atomic.{ AtomicBoolean, AtomicInteger, AtomicLong }
+
 import akka.AkkaException
 import akka.actor.Scheduler
 import akka.util.Unsafe
+
 import scala.util.control.NoStackTrace
-import java.util.concurrent.{ Callable, CopyOnWriteArrayList }
-import scala.concurrent.{ ExecutionContext, Future, Promise, Await }
+import java.util.concurrent.{ Callable, CompletionStage, CopyOnWriteArrayList }
+
+import scala.concurrent.{ Await, ExecutionContext, Future, Promise }
 import scala.concurrent.duration._
 import scala.concurrent.TimeoutException
 import scala.util.control.NonFatal
 import scala.util.Success
 import akka.dispatch.ExecutionContexts.sameThreadExecutionContext
+import akka.japi.function.Creator
+
+import scala.compat.java8.FutureConverters
 
 /**
  * Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
@@ -123,6 +129,18 @@ class CircuitBreaker(scheduler: Scheduler, maxFailures: Int, callTimeout: Finite
    */
   def callWithCircuitBreaker[T](body: Callable[Future[T]]): Future[T] = withCircuitBreaker(body.call)
 
+  /**
+   * Java API (8) for [[#withCircuitBreaker]]
+   *
+   * @param body Call needing protected
+   * @return [[java.util.concurrent.CompletionStage]] containing the call result or a
+   *   `scala.concurrent.TimeoutException` if the call timed out
+   */
+  def callWithCircuitBreakerCS[T](body: Callable[CompletionStage[T]]): CompletionStage[T] =
+    FutureConverters.toJava[T](callWithCircuitBreaker(new Callable[Future[T]] {
+      override def call(): Future[T] = FutureConverters.toScala(body.call())
+    }))
+
   /**
    * Wraps invocations of synchronous calls that need to be protected
    *
diff --git a/akka-actor/src/main/scala/akka/routing/ConsistentHashing.scala b/akka-actor/src/main/scala/akka/routing/ConsistentHashing.scala
index 78dd4ff505..4e3461fb69 100644
--- a/akka-actor/src/main/scala/akka/routing/ConsistentHashing.scala
+++ b/akka-actor/src/main/scala/akka/routing/ConsistentHashing.scala
@@ -91,7 +91,7 @@ object ConsistentHashingRouter {
    * INTERNAL API
    */
   private[akka] def hashMappingAdapter(mapper: ConsistentHashMapper): ConsistentHashMapping = {
-    case message if (mapper.hashKey(message).asInstanceOf[AnyRef] ne null) ⇒
+    case message if mapper.hashKey(message).asInstanceOf[AnyRef] ne null ⇒
       mapper.hashKey(message)
   }
 
diff --git a/akka-actor/src/main/scala/akka/routing/RouterConfig.scala b/akka-actor/src/main/scala/akka/routing/RouterConfig.scala
index 27f4df9085..1385ca9ba5 100644
--- a/akka-actor/src/main/scala/akka/routing/RouterConfig.scala
+++ b/akka-actor/src/main/scala/akka/routing/RouterConfig.scala
@@ -273,7 +273,9 @@ abstract class CustomRouterConfig extends RouterConfig {
 }
 
 /**
- * Router configuration which has no default, i.e. external configuration is required.
+ * Wraps a [[akka.actor.Props]] to mark the actor as externally configurable to be used with a router.
+ * If a [[akka.actor.Props]] is not wrapped with [[FromConfig]] then the actor will ignore the router part of the deployment section
+ * in the configuration.
  */
 case object FromConfig extends FromConfig {
   /**
@@ -290,7 +292,9 @@ case object FromConfig extends FromConfig {
 }
 
 /**
- * Java API: Router configuration which has no default, i.e. external configuration is required.
+ * Java API: Wraps a [[akka.actor.Props]] to mark the actor as externally configurable to be used with a router.
+ * If a [[akka.actor.Props]] is not wrapped with [[FromConfig]] then the actor will ignore the router part of the deployment section
+ * in the configuration.
  *
  * This can be used when the dispatcher to be used for the head Router needs to be configured
  * (defaults to default-dispatcher).
diff --git a/akka-actor/src/main/scala/akka/util/ByteIterator.scala b/akka-actor/src/main/scala/akka/util/ByteIterator.scala
index b763ef93fe..e3a3ffdbab 100644
--- a/akka-actor/src/main/scala/akka/util/ByteIterator.scala
+++ b/akka-actor/src/main/scala/akka/util/ByteIterator.scala
@@ -234,6 +234,7 @@ object ByteIterator {
       new MultiByteArrayIterator(clonedIterators)
     }
 
+    /** For performance sensitive code, call take() directly on ByteString (it's optimised there) */
     final override def take(n: Int): this.type = {
       var rest = n
       val builder = new ListBuffer[ByteArrayIterator]
@@ -249,7 +250,8 @@ object ByteIterator {
       normalize()
     }
 
-    @tailrec final override def drop(n: Int): this.type =
+    /** For performance sensitive code, call drop() directly on ByteString (it's optimised there) */
+    final override def drop(n: Int): this.type =
       if ((n > 0) && !isEmpty) {
         val nCurrent = math.min(n, current.len)
         current.drop(n)
@@ -341,7 +343,9 @@ object ByteIterator {
     def getDoubles(xs: Array[Double], offset: Int, n: Int)(implicit byteOrder: ByteOrder): this.type =
       getToArray(xs, offset, n, 8) { getDouble(byteOrder) } { current.getDoubles(_, _, _)(byteOrder) }
 
-    def copyToBuffer(buffer: ByteBuffer): Int = {
+    /** For performance sensitive code, call copyToBuffer() directly on ByteString (it's optimised there) */
+    override def copyToBuffer(buffer: ByteBuffer): Int = {
+      // the fold here is better than indexing into the LinearSeq
       val n = iterators.foldLeft(0) { _ + _.copyToBuffer(buffer) }
       normalize()
       n
@@ -635,6 +639,7 @@ abstract class ByteIterator extends BufferedIterator[Byte] {
    * @param buffer a ByteBuffer to copy bytes to
    * @return the number of bytes actually copied
    */
+  /** For performance sensitive code, call take() directly on ByteString (it's optimised there) */
   def copyToBuffer(buffer: ByteBuffer): Int
 
   /**
diff --git a/akka-actor/src/main/scala/akka/util/ByteString.scala b/akka-actor/src/main/scala/akka/util/ByteString.scala
index 8ccfa2518b..6438d95c48 100644
--- a/akka-actor/src/main/scala/akka/util/ByteString.scala
+++ b/akka-actor/src/main/scala/akka/util/ByteString.scala
@@ -7,14 +7,15 @@ package akka.util
 import java.io.{ ObjectInputStream, ObjectOutputStream }
 import java.nio.{ ByteBuffer, ByteOrder }
 import java.lang.{ Iterable ⇒ JIterable }
-import scala.annotation.varargs
+
+import scala.annotation.{ tailrec, varargs }
 import scala.collection.IndexedSeqOptimized
 import scala.collection.mutable.{ Builder, WrappedArray }
 import scala.collection.immutable
-import scala.collection.immutable.{ IndexedSeq, VectorBuilder }
+import scala.collection.immutable.{ IndexedSeq, VectorBuilder, VectorIterator }
 import scala.collection.generic.CanBuildFrom
 import scala.reflect.ClassTag
-import java.nio.charset.StandardCharsets
+import java.nio.charset.{ Charset, StandardCharsets }
 
 object ByteString {
 
@@ -103,13 +104,14 @@ object ByteString {
     }
 
   private[akka] object ByteString1C extends Companion {
+    def fromString(s: String): ByteString1C = new ByteString1C(s.getBytes)
     def apply(bytes: Array[Byte]): ByteString1C = new ByteString1C(bytes)
     val SerializationIdentity = 1.toByte
 
     def readFromInputStream(is: ObjectInputStream): ByteString1C = {
       val length = is.readInt()
       val arr = new Array[Byte](length)
-      is.read(arr, 0, length)
+      is.readFully(arr, 0, length)
       ByteString1C(arr)
     }
   }
@@ -123,37 +125,74 @@ object ByteString {
 
     override def length: Int = bytes.length
 
+    // Avoid `iterator` in performance sensitive code, call ops directly on ByteString instead
     override def iterator: ByteIterator.ByteArrayIterator = ByteIterator.ByteArrayIterator(bytes, 0, bytes.length)
 
-    private[akka] def toByteString1: ByteString1 = ByteString1(bytes)
+    /** INTERNAL API */
+    private[akka] def toByteString1: ByteString1 = ByteString1(bytes, 0, bytes.length)
 
+    /** INTERNAL API */
     private[akka] def byteStringCompanion = ByteString1C
 
-    def asByteBuffer: ByteBuffer = toByteString1.asByteBuffer
+    override def asByteBuffer: ByteBuffer = toByteString1.asByteBuffer
 
-    def asByteBuffers: scala.collection.immutable.Iterable[ByteBuffer] = List(asByteBuffer)
+    override def asByteBuffers: scala.collection.immutable.Iterable[ByteBuffer] = List(asByteBuffer)
 
-    def decodeString(charset: String): String =
+    override def decodeString(charset: String): String =
       if (isEmpty) "" else new String(bytes, charset)
 
-    def ++(that: ByteString): ByteString =
+    override def decodeString(charset: Charset): String =
+      if (isEmpty) "" else new String(bytes, charset)
+
+    override def ++(that: ByteString): ByteString = {
       if (that.isEmpty) this
       else if (this.isEmpty) that
       else toByteString1 ++ that
+    }
+
+    override def take(n: Int): ByteString =
+      if (n <= 0) ByteString.empty
+      else toByteString1.take(n)
+
+    override def dropRight(n: Int): ByteString =
+      if (n <= 0) this
+      else toByteString1.dropRight(n)
+
+    override def drop(n: Int): ByteString =
+      if (n <= 0) this
+      else toByteString1.drop(n)
 
     override def slice(from: Int, until: Int): ByteString =
-      if ((from != 0) || (until != length)) toByteString1.slice(from, until)
-      else this
+      if ((from == 0) && (until == length)) this
+      else if (from > length) ByteString.empty
+      else toByteString1.slice(from, until)
 
-    private[akka] def writeToOutputStream(os: ObjectOutputStream): Unit =
+    private[akka] override def writeToOutputStream(os: ObjectOutputStream): Unit =
       toByteString1.writeToOutputStream(os)
+
+    override def copyToBuffer(buffer: ByteBuffer): Int =
+      writeToBuffer(buffer, offset = 0)
+
+    /** INTERNAL API: Specialized for internal use, writing multiple ByteString1C into the same ByteBuffer. */
+    private[akka] def writeToBuffer(buffer: ByteBuffer, offset: Int): Int = {
+      val copyLength = Math.min(buffer.remaining, offset + length)
+      if (copyLength > 0) {
+        buffer.put(bytes, offset, copyLength)
+        drop(copyLength)
+      }
+      copyLength
+    }
+
   }
 
+  /** INTERNAL API: ByteString backed by exactly one array, with start / end markers */
   private[akka] object ByteString1 extends Companion {
     val empty: ByteString1 = new ByteString1(Array.empty[Byte])
-    def apply(bytes: Array[Byte]): ByteString1 = ByteString1(bytes, 0, bytes.length)
+    def fromString(s: String): ByteString1 = apply(s.getBytes)
+    def apply(bytes: Array[Byte]): ByteString1 = apply(bytes, 0, bytes.length)
     def apply(bytes: Array[Byte], startIndex: Int, length: Int): ByteString1 =
-      if (length == 0) empty else new ByteString1(bytes, startIndex, length)
+      if (length == 0) empty
+      else new ByteString1(bytes, Math.max(0, startIndex), Math.max(0, length))
 
     val SerializationIdentity = 0.toByte
 
@@ -170,6 +209,7 @@ object ByteString {
 
     def apply(idx: Int): Byte = bytes(checkRangeConvert(idx))
 
+    // Avoid `iterator` in performance sensitive code, call ops directly on ByteString instead
     override def iterator: ByteIterator.ByteArrayIterator =
       ByteIterator.ByteArrayIterator(bytes, startIndex, startIndex + length)
 
@@ -189,6 +229,48 @@ object ByteString {
 
     private[akka] def byteStringCompanion = ByteString1
 
+    override def dropRight(n: Int): ByteString =
+      dropRight1(n)
+
+    /** INTERNAL API */
+    private[akka] def dropRight1(n: Int): ByteString1 =
+      if (n <= 0) this
+      else if (length - n <= 0) ByteString1.empty
+      else new ByteString1(bytes, startIndex, length - n)
+
+    override def drop(n: Int): ByteString =
+      if (n <= 0) this else drop1(n)
+
+    /** INTERNAL API */
+    private[akka] def drop1(n: Int): ByteString1 = {
+      val nextStartIndex = startIndex + n
+      if (nextStartIndex >= bytes.length) ByteString1.empty
+      else ByteString1(bytes, nextStartIndex, length - n)
+    }
+
+    override def take(n: Int): ByteString =
+      if (n <= 0) ByteString.empty
+      else ByteString1(bytes, startIndex, Math.min(n, length))
+
+    override def slice(from: Int, until: Int): ByteString = {
+      if (from <= 0 && until >= length) this // we can do < / > since we're Compact
+      else if (until <= from) ByteString1.empty
+      else ByteString1(bytes, startIndex + from, until - from)
+    }
+
+    override def copyToBuffer(buffer: ByteBuffer): Int =
+      writeToBuffer(buffer)
+
+    /** INTERNAL API: Specialized for internal use, writing multiple ByteString1C into the same ByteBuffer. */
+    private[akka] def writeToBuffer(buffer: ByteBuffer): Int = {
+      val copyLength = Math.min(buffer.remaining, length)
+      if (copyLength > 0) {
+        buffer.put(bytes, startIndex, copyLength)
+        drop(copyLength)
+      }
+      copyLength
+    }
+
     def compact: CompactByteString =
       if (isCompact) ByteString1C(bytes) else ByteString1C(toArray)
 
@@ -200,7 +282,10 @@ object ByteString {
 
     def asByteBuffers: scala.collection.immutable.Iterable[ByteBuffer] = List(asByteBuffer)
 
-    def decodeString(charset: String): String =
+    override def decodeString(charset: String): String =
+      new String(if (length == bytes.length) bytes else toArray, charset)
+
+    override def decodeString(charset: Charset): String = // avoids Charset.forName lookup in String internals
       new String(if (length == bytes.length) bytes else toArray, charset)
 
     def ++(that: ByteString): ByteString = {
@@ -283,8 +368,9 @@ object ByteString {
    */
   final class ByteStrings private (private[akka] val bytestrings: Vector[ByteString1], val length: Int) extends ByteString with Serializable {
     if (bytestrings.isEmpty) throw new IllegalArgumentException("bytestrings must not be empty")
+    if (bytestrings.head.isEmpty) throw new IllegalArgumentException("bytestrings.head must not be empty")
 
-    def apply(idx: Int): Byte =
+    def apply(idx: Int): Byte = {
       if (0 <= idx && idx < length) {
         var pos = 0
         var seen = 0
@@ -294,7 +380,9 @@ object ByteString {
         }
         bytestrings(pos)(idx - seen)
       } else throw new IndexOutOfBoundsException(idx.toString)
+    }
 
+    /** Avoid `iterator` in performance sensitive code, call ops directly on ByteString instead */
     override def iterator: ByteIterator.MultiByteArrayIterator =
       ByteIterator.MultiByteArrayIterator(bytestrings.toStream map { _.iterator })
 
@@ -312,6 +400,14 @@ object ByteString {
 
     def isCompact: Boolean = if (bytestrings.length == 1) bytestrings.head.isCompact else false
 
+    override def copyToBuffer(buffer: ByteBuffer): Int = {
+      @tailrec def copyItToTheBuffer(buffer: ByteBuffer, i: Int, written: Int): Int =
+        if (i < bytestrings.length) copyItToTheBuffer(buffer, i + 1, written + bytestrings(i).writeToBuffer(buffer))
+        else written
+
+      copyItToTheBuffer(buffer, 0, 0)
+    }
+
     def compact: CompactByteString = {
       if (isCompact) bytestrings.head.compact
       else {
@@ -331,11 +427,83 @@ object ByteString {
 
     def decodeString(charset: String): String = compact.decodeString(charset)
 
+    def decodeString(charset: Charset): String =
+      compact.decodeString(charset)
+
     private[akka] def writeToOutputStream(os: ObjectOutputStream): Unit = {
       os.writeInt(bytestrings.length)
       bytestrings.foreach(_.writeToOutputStream(os))
     }
 
+    override def take(n: Int): ByteString = {
+      @tailrec def take0(n: Int, b: ByteStringBuilder, bs: Vector[ByteString1]): ByteString =
+        if (bs.isEmpty || n <= 0) b.result
+        else {
+          val head = bs.head
+          if (n <= head.length) b.append(head.take(n)).result
+          else take0(n - head.length, b.append(head), bs.tail)
+        }
+
+      if (n <= 0) ByteString.empty
+      else if (n >= length) this
+      else take0(n, ByteString.newBuilder, bytestrings)
+    }
+
+    override def dropRight(n: Int): ByteString =
+      if (n <= 0) this
+      else {
+        val last = bytestrings.last
+        if (n < last.length) new ByteStrings(bytestrings.init :+ last.dropRight1(n), length - n)
+        else {
+          val remaining = bytestrings.init
+          if (remaining.isEmpty) ByteString.empty
+          else {
+            val s = new ByteStrings(remaining, length - last.length)
+            val remainingToBeDropped = n - last.length
+            s.dropRight(remainingToBeDropped)
+          }
+        }
+      }
+
+    override def slice(from: Int, until: Int): ByteString =
+      if ((from == 0) && (until == length)) this
+      else if (from > length || until <= from) ByteString.empty
+      else drop(from).dropRight(length - until)
+
+    override def drop(n: Int): ByteString =
+      if (n <= 0) this
+      else if (n > length) ByteString.empty
+      else drop0(n)
+
+    private def drop0(n: Int): ByteString = {
+      var continue = true
+      var fullDrops = 0
+      var remainingToDrop = n
+      do {
+        // impl note: could be optimised a bit by using VectorIterator instead, 
+        //            however then we're forced to call .toVector which halfs performance
+        //            We can work around that, as there's a Scala private method "remainingVector" which is fast, 
+        //            but let's not go into calling private APIs here just yet.
+        val currentLength = bytestrings(fullDrops).length
+        if (remainingToDrop >= currentLength) {
+          fullDrops += 1
+          remainingToDrop -= currentLength
+        } else continue = false
+      } while (remainingToDrop > 0 && continue)
+
+      val remainingByteStrings = bytestrings.drop(fullDrops)
+      if (remainingByteStrings.isEmpty) ByteString.empty
+      else if (remainingToDrop > 0) {
+        val h: ByteString1 = remainingByteStrings.head.drop1(remainingToDrop)
+        val bs = remainingByteStrings.tail
+
+        if (h.isEmpty)
+          if (bs.isEmpty) ByteString.empty
+          else new ByteStrings(bs, length - n)
+        else new ByteStrings(h +: bs, length - n)
+      } else ByteStrings(remainingByteStrings, length - n)
+    }
+
     protected def writeReplace(): AnyRef = new SerializationProxy(this)
   }
 
@@ -386,6 +554,8 @@ sealed abstract class ByteString extends IndexedSeq[Byte] with IndexedSeqOptimiz
   // *must* be overridden by derived classes. This construction is necessary
   // to specialize the return type, as the method is already implemented in
   // a parent trait.
+  // 
+  // Avoid `iterator` in performance sensitive code, call ops directly on ByteString instead
   override def iterator: ByteIterator = throw new UnsupportedOperationException("Method iterator is not implemented in ByteString")
 
   override def head: Byte = apply(0)
@@ -393,14 +563,19 @@ sealed abstract class ByteString extends IndexedSeq[Byte] with IndexedSeqOptimiz
   override def last: Byte = apply(length - 1)
   override def init: ByteString = dropRight(1)
 
-  override def slice(from: Int, until: Int): ByteString =
-    if ((from == 0) && (until == length)) this
-    else iterator.slice(from, until).toByteString
-
-  override def take(n: Int): ByteString = slice(0, n)
+  // *must* be overridden by derived classes.
+  override def take(n: Int): ByteString = throw new UnsupportedOperationException("Method slice is not implemented in ByteString")
   override def takeRight(n: Int): ByteString = slice(length - n, length)
-  override def drop(n: Int): ByteString = slice(n, length)
-  override def dropRight(n: Int): ByteString = slice(0, length - n)
+
+  // these methods are optimized in derived classes utilising the maximum knowlage about data layout available to them:
+  // *must* be overridden by derived classes.
+  override def slice(from: Int, until: Int): ByteString = throw new UnsupportedOperationException("Method slice is not implemented in ByteString")
+
+  // *must* be overridden by derived classes.
+  override def drop(n: Int): ByteString = throw new UnsupportedOperationException("Method drop is not implemented in ByteString")
+
+  // *must* be overridden by derived classes.
+  override def dropRight(n: Int): ByteString = throw new UnsupportedOperationException("Method dropRight is not implemented in ByteString")
 
   override def takeWhile(p: Byte ⇒ Boolean): ByteString = iterator.takeWhile(p).toByteString
   override def dropWhile(p: Byte ⇒ Boolean): ByteString = iterator.dropWhile(p).toByteString
@@ -425,7 +600,7 @@ sealed abstract class ByteString extends IndexedSeq[Byte] with IndexedSeqOptimiz
    *
    * @return this ByteString copied into a byte array
    */
-  protected[ByteString] def toArray: Array[Byte] = toArray[Byte] // protected[ByteString] == public to Java but hidden to Scala * fnizz *
+  protected[ByteString] def toArray: Array[Byte] = toArray[Byte]
 
   override def toArray[B >: Byte](implicit arg0: ClassTag[B]): Array[B] = iterator.toArray
   override def copyToArray[B >: Byte](xs: Array[B], start: Int, len: Int): Unit =
@@ -452,7 +627,8 @@ sealed abstract class ByteString extends IndexedSeq[Byte] with IndexedSeqOptimiz
    * @param buffer a ByteBuffer to copy bytes to
    * @return the number of bytes actually copied
    */
-  def copyToBuffer(buffer: ByteBuffer): Int = iterator.copyToBuffer(buffer)
+  // *must* be overridden by derived classes. 
+  def copyToBuffer(buffer: ByteBuffer): Int = throw new UnsupportedOperationException("Method copyToBuffer is not implemented in ByteString")
 
   /**
    * Create a new ByteString with all contents compacted into a single,
@@ -504,9 +680,16 @@ sealed abstract class ByteString extends IndexedSeq[Byte] with IndexedSeqOptimiz
 
   /**
    * Decodes this ByteString using a charset to produce a String.
+   * If you have a [[Charset]] instance available, use `decodeString(charset: java.nio.charset.Charset` instead.
    */
   def decodeString(charset: String): String
 
+  /**
+   * Decodes this ByteString using a charset to produce a String.
+   * Avoids Charset.forName lookup in String internals, thus is preferable to `decodeString(charset: String)`.
+   */
+  def decodeString(charset: Charset): String
+
   /**
    * map method that will automatically cast Int back into Byte.
    */
@@ -568,8 +751,8 @@ object CompactByteString {
    * an Array.
    */
   def fromArray(array: Array[Byte], offset: Int, length: Int): CompactByteString = {
-    val copyOffset = math.max(offset, 0)
-    val copyLength = math.max(math.min(array.length - copyOffset, length), 0)
+    val copyOffset = Math.max(offset, 0)
+    val copyLength = Math.max(Math.min(array.length - copyOffset, length), 0)
     if (copyLength == 0) empty
     else {
       val copyArray = new Array[Byte](copyLength)
@@ -666,6 +849,8 @@ final class ByteStringBuilder extends Builder[Byte, ByteString] {
 
   override def ++=(xs: TraversableOnce[Byte]): this.type = {
     xs match {
+      case b: ByteString if b.isEmpty ⇒
+      // do nothing
       case b: ByteString1C ⇒
         clearTemp()
         _builder += b.toByteString1
@@ -708,7 +893,7 @@ final class ByteStringBuilder extends Builder[Byte, ByteString] {
   /**
    * Java API: append a ByteString to this builder.
    */
-  def append(bs: ByteString): this.type = this ++= bs
+  def append(bs: ByteString): this.type = if (bs.isEmpty) this else this ++= bs
 
   /**
    * Add a single Byte to this builder.
@@ -875,7 +1060,7 @@ final class ByteStringBuilder extends Builder[Byte, ByteString] {
     fillByteBuffer(len * 8, byteOrder) { _.asDoubleBuffer.put(array, start, len) }
 
   def clear(): Unit = {
-    _builder.clear
+    _builder.clear()
     _length = 0
     _tempLength = 0
   }
diff --git a/akka-actor/src/main/scala/akka/util/WildcardIndex.scala b/akka-actor/src/main/scala/akka/util/WildcardIndex.scala
new file mode 100644
index 0000000000..1c5cec32f2
--- /dev/null
+++ b/akka-actor/src/main/scala/akka/util/WildcardIndex.scala
@@ -0,0 +1,81 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.util
+
+import scala.annotation.tailrec
+import scala.collection.immutable.HashMap
+
+private[akka] final case class WildcardIndex[T](wildcardTree: WildcardTree[T] = WildcardTree[T](), doubleWildcardTree: WildcardTree[T] = WildcardTree[T]()) {
+
+  val empty = WildcardTree[T]()
+
+  def insert(elems: Array[String], d: T): WildcardIndex[T] = elems.lastOption match {
+    case Some("**") ⇒ copy(doubleWildcardTree = doubleWildcardTree.insert(elems.iterator, d))
+    case Some(_)    ⇒ copy(wildcardTree = wildcardTree.insert(elems.iterator, d))
+    case _          ⇒ this
+  }
+
+  def find(elems: Iterable[String]): Option[T] =
+    (if (wildcardTree.isEmpty) {
+      if (doubleWildcardTree.isEmpty) {
+        empty
+      } else {
+        doubleWildcardTree.findWithTerminalDoubleWildcard(elems.iterator)
+      }
+    } else {
+      val withSingleWildcard = wildcardTree.findWithSingleWildcard(elems.iterator)
+      if (withSingleWildcard.isEmpty) {
+        doubleWildcardTree.findWithTerminalDoubleWildcard(elems.iterator)
+      } else {
+        withSingleWildcard
+      }
+    }).data
+
+}
+
+private[akka] object WildcardTree {
+  private val empty = new WildcardTree[Nothing]()
+  def apply[T](): WildcardTree[T] = empty.asInstanceOf[WildcardTree[T]]
+}
+
+private[akka] final case class WildcardTree[T](data: Option[T] = None, children: Map[String, WildcardTree[T]] = HashMap[String, WildcardTree[T]]()) {
+
+  lazy val isEmpty: Boolean = data.isEmpty && children.isEmpty
+
+  def insert(elems: Iterator[String], d: T): WildcardTree[T] =
+    if (!elems.hasNext) {
+      copy(data = Some(d))
+    } else {
+      val e = elems.next()
+      copy(children = children.updated(e, children.getOrElse(e, WildcardTree[T]()).insert(elems, d)))
+    }
+
+  @tailrec def findWithSingleWildcard(elems: Iterator[String]): WildcardTree[T] =
+    if (!elems.hasNext) this
+    else {
+      children.get(elems.next()) match {
+        case Some(branch) ⇒ branch.findWithSingleWildcard(elems)
+        case None ⇒ children.get("*") match {
+          case Some(branch) ⇒ branch.findWithSingleWildcard(elems)
+          case None         ⇒ WildcardTree[T]()
+        }
+      }
+    }
+
+  @tailrec def findWithTerminalDoubleWildcard(elems: Iterator[String], alt: WildcardTree[T] = WildcardTree[T]()): WildcardTree[T] = {
+    if (!elems.hasNext) this
+    else {
+      val newAlt = children.getOrElse("**", alt)
+      children.get(elems.next()) match {
+        case Some(branch) ⇒ branch.findWithTerminalDoubleWildcard(elems, newAlt)
+        case None ⇒ children.get("*") match {
+          case Some(branch) ⇒ branch.findWithTerminalDoubleWildcard(elems, newAlt)
+          case None         ⇒ newAlt
+        }
+      }
+    }
+  }
+}
+
diff --git a/akka-actor/src/main/scala/akka/util/WildcardTree.scala b/akka-actor/src/main/scala/akka/util/WildcardTree.scala
deleted file mode 100644
index 15f3e6d30c..0000000000
--- a/akka-actor/src/main/scala/akka/util/WildcardTree.scala
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
- */
-
-package akka.util
-
-import annotation.tailrec
-import collection.immutable.HashMap
-
-private[akka] object WildcardTree {
-  private val empty = new WildcardTree[Nothing]()
-  def apply[T](): WildcardTree[T] = empty.asInstanceOf[WildcardTree[T]]
-}
-private[akka] final case class WildcardTree[T](data: Option[T] = None, children: Map[String, WildcardTree[T]] = HashMap[String, WildcardTree[T]]()) {
-
-  def insert(elems: Iterator[String], d: T): WildcardTree[T] =
-    if (!elems.hasNext) {
-      copy(data = Some(d))
-    } else {
-      val e = elems.next()
-      copy(children = children.updated(e, children.get(e).getOrElse(WildcardTree()).insert(elems, d)))
-    }
-
-  @tailrec final def find(elems: Iterator[String]): WildcardTree[T] =
-    if (!elems.hasNext) this
-    else {
-      (children.get(elems.next()) orElse children.get("*")) match {
-        case Some(branch) ⇒ branch.find(elems)
-        case None         ⇒ WildcardTree()
-      }
-    }
-}
diff --git a/akka-bench-jmh/src/main/scala/akka/http/HttpBlueprintBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/http/HttpBlueprintBenchmark.scala
new file mode 100644
index 0000000000..d9925b8a82
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/http/HttpBlueprintBenchmark.scala
@@ -0,0 +1,128 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http
+
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
+
+import akka.NotUsed
+import akka.actor.ActorSystem
+import akka.http.impl.util.ByteStringRendering
+import akka.http.scaladsl.{ Http, HttpExt }
+import akka.http.scaladsl.Http.ServerBinding
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.server.Directives._
+import akka.http.scaladsl.unmarshalling._
+import akka.stream._
+import akka.stream.TLSProtocol.{ SslTlsInbound, SslTlsOutbound }
+import akka.stream.scaladsl._
+import akka.stream.stage.{ GraphStage, GraphStageLogic }
+import akka.util.ByteString
+import com.typesafe.config.ConfigFactory
+import org.openjdk.jmh.annotations._
+import org.openjdk.jmh.infra.Blackhole
+
+import scala.concurrent.{ Await, Future }
+import scala.concurrent.duration._
+import scala.util.Try
+
+/*
+Baseline: 
+ 
+ [info] Benchmark                                      Mode  Cnt       Score       Error  Units
+ [info] HttpBlueprintBenchmark.run_10000_reqs         thrpt   20  197972.659 ± 14512.694  ops/s
+ */
+@State(Scope.Benchmark)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+class HttpBlueprintBenchmark {
+
+  val config = ConfigFactory.parseString(
+    """
+      akka {
+        loglevel = "WARNING"
+        
+        stream.materializer {
+        
+          # default: sync-processing-limit = 1000
+          sync-processing-limit = 1000
+          
+          # default: output-burst-limit = 10000
+          output-burst-limit = 1000
+          
+          # default: initial-input-buffer-size = 4
+          initial-input-buffer-size = 4
+          
+          # default: max-input-buffer-size = 16
+          max-input-buffer-size = 16
+          
+        }
+        
+        http {
+          # default: request-timeout = 20s 
+          request-timeout = infinite # disabled
+          # request-timeout = 20s 
+        }
+      }""".stripMargin
+  ).withFallback(ConfigFactory.load())
+
+  implicit val system: ActorSystem = ActorSystem("HttpBenchmark", config)
+
+  val materializer: ActorMaterializer = ActorMaterializer()
+  val notFusingMaterializer = ActorMaterializer(materializer.settings.withAutoFusing(false))
+
+  val request: HttpRequest = HttpRequest()
+  val requestRendered = ByteString(
+    "GET / HTTP/1.1\r\n" +
+      "Accept: */*\r\n" +
+      "Accept-Encoding: gzip, deflate\r\n" +
+      "Connection: keep-alive\r\n" +
+      "Host: example.com\r\n" +
+      "User-Agent: HTTPie/0.9.3\r\n" +
+      "\r\n"
+  )
+
+  val response: HttpResponse = HttpResponse()
+  val responseRendered: ByteString = ByteString(
+    s"HTTP/1.1 200 OK\r\n" +
+      s"Content-Length: 0\r\n" +
+      s"\r\n"
+  )
+
+  def TCPPlacebo(requests: Int): Flow[ByteString, ByteString, NotUsed] =
+    Flow.fromSinkAndSource(
+      Flow[ByteString].takeWhile(it => !(it.utf8String contains "Connection: close")) to Sink.ignore,
+      Source.repeat(requestRendered).take(requests)
+    )
+
+  def layer: BidiFlow[HttpResponse, SslTlsOutbound, SslTlsInbound, HttpRequest, NotUsed] = Http().serverLayer()(materializer)
+  def server(requests: Int): Flow[HttpResponse, HttpRequest, _] = layer atop TLSPlacebo() join TCPPlacebo(requests)
+
+  val reply = Flow[HttpRequest].map { _ => response }
+
+  @TearDown
+  def shutdown(): Unit = {
+    Await.result(system.terminate(), 5.seconds)
+  }
+
+  val nothingHere: Flow[HttpRequest, HttpResponse, NotUsed] =
+    Flow.fromSinkAndSource(Sink.cancelled, Source.empty)
+
+  @Benchmark
+  @OperationsPerInvocation(100000)
+  def run_10000_reqs() = {
+    val n = 100000
+    val latch = new CountDownLatch(n)
+
+    val replyCountdown = reply map { x =>
+      latch.countDown()
+      x
+    }
+    server(n).joinMat(replyCountdown)(Keep.right).run()(materializer)
+
+    latch.await()
+  }
+
+}
+
diff --git a/akka-bench-jmh/src/main/scala/akka/http/HttpRequestParsingBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/http/HttpRequestParsingBenchmark.scala
new file mode 100644
index 0000000000..4233a5115b
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/http/HttpRequestParsingBenchmark.scala
@@ -0,0 +1,102 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http
+
+import java.util.concurrent.TimeUnit
+import javax.net.ssl.SSLContext
+
+import akka.Done
+import akka.actor.ActorSystem
+import akka.event.NoLogging
+import akka.http.impl.engine.parsing.{ HttpHeaderParser, HttpRequestParser }
+import akka.http.scaladsl.settings.ParserSettings
+import akka.event.NoLogging
+import akka.stream.ActorMaterializer
+import akka.stream.TLSProtocol.SessionBytes
+import akka.stream.scaladsl._
+import akka.util.ByteString
+import org.openjdk.jmh.annotations.{ OperationsPerInvocation, _ }
+import org.openjdk.jmh.infra.Blackhole
+
+import scala.concurrent.duration._
+import scala.concurrent.{ Await, Future }
+
+@State(Scope.Benchmark)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+class HttpRequestParsingBenchmark {
+
+  implicit val system: ActorSystem = ActorSystem("HttpRequestParsingBenchmark")
+  implicit val materializer = ActorMaterializer()(system)
+  val parserSettings = ParserSettings(system)
+  val parser = new HttpRequestParser(parserSettings, false, HttpHeaderParser(parserSettings, NoLogging)())
+  val dummySession = SSLContext.getDefault.createSSLEngine.getSession
+
+  @Param(Array("small", "large"))
+  var req: String = ""
+
+  def request = req match {
+    case "small" => requestBytesSmall
+    case "large" => requestBytesLarge
+  }
+
+  val requestBytesSmall: SessionBytes = SessionBytes(
+    dummySession,
+    ByteString(
+      """|GET / HTTP/1.1
+         |Accept: */*
+         |Accept-Encoding: gzip, deflate
+         |Connection: keep-alive
+         |Host: example.com
+         |User-Agent: HTTPie/0.9.3
+         |
+         |""".stripMargin.replaceAll("\n", "\r\n")
+    )
+  )
+
+  val requestBytesLarge: SessionBytes = SessionBytes(
+    dummySession,
+    ByteString(
+      """|GET /json HTTP/1.1
+         |Host: server
+         |User-Agent: Mozilla/5.0 (X11; Linux x86_64) Gecko/20130501 Firefox/30.0 AppleWebKit/600.00 Chrome/30.0.0000.0 Trident/10.0 Safari/600.00
+         |Cookie: uid=12345678901234567890; __utma=1.1234567890.1234567890.1234567890.1234567890.12; wd=2560x1600
+         |Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+         |Accept-Language: en-US,en;q=0.5
+         |Connection: keep-alive
+         |
+         |""".stripMargin.replaceAll("\n", "\r\n")
+    )
+  )
+
+  /*
+  // before:
+  [info] Benchmark                                                 (req)   Mode  Cnt            Score       Error  Units
+  [info] HttpRequestParsingBenchmark.parse_10000_requests          small  thrpt   20      358 982.157 ± 93745.863  ops/s
+  [info] HttpRequestParsingBenchmark.parse_10000_requests          large  thrpt   20      388 335.666 ± 16990.715  ops/s
+  
+  // after:
+  [info] HttpRequestParsingBenchmark.parse_10000_requests_val      small  thrpt   20      623 975.879 ± 6191.897  ops/s
+  [info] HttpRequestParsingBenchmark.parse_10000_requests_val      large  thrpt   20      507 460.283 ± 4735.843  ops/s
+  */
+
+  val httpMessageParser = Flow.fromGraph(parser)
+
+  def flow(bytes: SessionBytes, n: Int): RunnableGraph[Future[Done]] =
+    Source.repeat(request).take(n)
+      .via(httpMessageParser)
+      .toMat(Sink.ignore)(Keep.right)
+
+  @Benchmark
+  @OperationsPerInvocation(10000)
+  def parse_10000_requests_val(blackhole: Blackhole): Unit = {
+    val done = flow(requestBytesSmall, 10000).run()
+    Await.ready(done, 32.days)
+  }
+
+  @TearDown
+  def shutdown(): Unit = {
+    Await.result(system.terminate(), 5.seconds)
+  }
+}
diff --git a/akka-bench-jmh/src/main/scala/akka/http/HttpResponseRenderingBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/http/HttpResponseRenderingBenchmark.scala
new file mode 100644
index 0000000000..8e5aa5c10a
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/http/HttpResponseRenderingBenchmark.scala
@@ -0,0 +1,250 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http
+
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
+
+import akka.NotUsed
+import akka.actor.ActorSystem
+import akka.event.NoLogging
+import akka.http.impl.engine.rendering.ResponseRenderingOutput.HttpData
+import akka.http.impl.engine.rendering.{ HttpResponseRendererFactory, ResponseRenderingContext, ResponseRenderingOutput }
+import akka.http.scaladsl.Http
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.headers.Server
+import akka.http.scaladsl.unmarshalling.Unmarshal
+import akka.stream._
+import akka.stream.scaladsl._
+import akka.stream.stage.{ GraphStageLogic, GraphStageWithMaterializedValue, InHandler }
+import akka.util.ByteString
+import com.typesafe.config.ConfigFactory
+import org.openjdk.jmh.annotations._
+import org.openjdk.jmh.infra.Blackhole
+
+import scala.concurrent.duration._
+import scala.concurrent.{ Await, Future }
+import scala.util.Try
+
+@State(Scope.Benchmark)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+class HttpResponseRenderingBenchmark extends HttpResponseRendererFactory(
+  serverHeader = Some(Server("Akka HTTP 2.4.x")),
+  responseHeaderSizeHint = 64,
+  log = NoLogging
+) {
+
+  val config = ConfigFactory.parseString(
+    """
+      akka {
+        loglevel = "ERROR"
+      }""".stripMargin
+  ).withFallback(ConfigFactory.load())
+
+  implicit val system = ActorSystem("HttpResponseRenderingBenchmark", config)
+  implicit val materializer = ActorMaterializer()
+
+  import system.dispatcher
+
+  val requestRendered = ByteString(
+    "GET / HTTP/1.1\r\n" +
+      "Accept: */*\r\n" +
+      "Accept-Encoding: gzip, deflate\r\n" +
+      "Connection: keep-alive\r\n" +
+      "Host: example.com\r\n" +
+      "User-Agent: HTTPie/0.9.3\r\n" +
+      "\r\n"
+  )
+
+  def TCPPlacebo(requests: Int): Flow[ByteString, ByteString, NotUsed] =
+    Flow.fromSinkAndSource(
+      Flow[ByteString].takeWhile(it => !(it.utf8String contains "Connection: close")) to Sink.ignore,
+      Source.repeat(requestRendered).take(requests)
+    )
+
+  def TlsPlacebo = TLSPlacebo()
+
+  val requestRendering: Flow[HttpRequest, String, NotUsed] =
+    Http()
+      .clientLayer(headers.Host("blah.com"))
+      .atop(TlsPlacebo)
+      .join {
+        Flow[ByteString].map { x ⇒
+          val response = s"HTTP/1.1 200 OK\r\nContent-Length: ${x.size}\r\n\r\n"
+          ByteString(response) ++ x
+        }
+      }
+      .mapAsync(1)(response => Unmarshal(response).to[String])
+
+  def renderResponse: Future[String] = Source.single(HttpRequest(uri = "/foo"))
+    .via(requestRendering)
+    .runWith(Sink.head)
+
+  var request: HttpRequest = _
+  var pool: Flow[(HttpRequest, Int), (Try[HttpResponse], Int), _] = _
+
+  @TearDown
+  def shutdown(): Unit = {
+    Await.ready(Http().shutdownAllConnectionPools(), 1.second)
+    Await.result(system.terminate(), 5.seconds)
+  }
+
+  /*
+  [info] Benchmark                                               Mode  Cnt              Score              Error  Units
+  [info] HttpResponseRenderingBenchmark.header_date_val         thrpt   20  2 704 169 260 029.906 ± 234456086114.237  ops/s
+  
+  // def, normal time
+  [info] HttpResponseRenderingBenchmark.header_date_def             thrpt   20    178 297 625 609.638 ± 7429280865.659  ops/s
+  [info] HttpResponseRenderingBenchmark.response_ok_simple_val      thrpt   20          1 258 119.673 ± 58399.454  ops/s
+  [info] HttpResponseRenderingBenchmark.response_ok_simple_def      thrpt   20            687 576.928 ± 94813.618  ops/s
+  
+  // clock nanos
+  [info] HttpResponseRenderingBenchmark.response_ok_simple_clock    thrpt   20          1 676 438.649 ± 33976.590  ops/s
+  [info] HttpResponseRenderingBenchmark.response_ok_simple_clock    thrpt   40          1 199 462.263 ± 222226.304  ops/s
+  
+  // ------
+  
+  // before optimisig collectFirst
+  [info] HttpResponseRenderingBenchmark.json_response        thrpt   20  1 782 572.845 ± 16572.625  ops/s
+  [info] HttpResponseRenderingBenchmark.simple_response      thrpt   20  1 611 802.216 ± 19557.151  ops/s
+  
+  // after removing collectFirst and Option from renderHeaders
+  // not much of a difference, but hey, less Option allocs
+  [info] HttpResponseRenderingBenchmark.json_response        thrpt   20  1 785 152.896 ± 15210.299  ops/s
+  [info] HttpResponseRenderingBenchmark.simple_response      thrpt   20  1 783 800.184 ± 14938.415  ops/s
+  
+  // -----
+
+  // baseline for this optimisation is the above results (after collectFirst).
+  
+  // after introducing pre-rendered ContentType headers:
+  
+  normal clock
+  [info] HttpResponseRenderingBenchmark.json_long_raw_response  thrpt   20  1738558.895 ± 159612.661  ops/s
+  [info] HttpResponseRenderingBenchmark.json_response           thrpt   20  1714176.824 ± 100011.642  ops/s
+
+  "fast clock"
+  [info] HttpResponseRenderingBenchmark.json_long_raw_response  thrpt   20  1 528 632.480 ± 44934.827  ops/s
+  [info] HttpResponseRenderingBenchmark.json_response           thrpt   20  1 517 383.792 ± 28256.716  ops/s
+  
+   */
+
+  /**
+   * HTTP/1.1 200 OK
+   * Server: Akka HTTP 2.4.x
+   * Date: Tue, 26 Jul 2016 15:26:53 GMT
+   * Content-Type: text/plain; charset=UTF-8
+   * Content-Length: 6
+   *
+   * ENTITY
+   */
+  val simpleResponse =
+    ResponseRenderingContext(
+      response = HttpResponse(
+        200,
+        headers = Nil,
+        entity = HttpEntity("ENTITY")
+      ),
+      requestMethod = HttpMethods.GET
+    )
+
+  /**
+   * HTTP/1.1 200 OK
+   * Server: Akka HTTP 2.4.x
+   * Date: Tue, 26 Jul 2016 15:26:53 GMT
+   * Content-Type: application/json
+   * Content-Length: 27
+   *
+   * {"message":"Hello, World!"}
+   */
+  val jsonResponse =
+    ResponseRenderingContext(
+      response = HttpResponse(
+        200,
+        headers = Nil,
+        entity = HttpEntity(ContentTypes.`application/json`, """{"message":"Hello, World!"}""")
+      ),
+      requestMethod = HttpMethods.GET
+    )
+
+  /**
+   * HTTP/1.1 200 OK
+   * Server: Akka HTTP 2.4.x
+   * Date: Tue, 26 Jul 2016 15:26:53 GMT
+   * Content-Type: application/json
+   * Content-Length: 315
+   *
+   * [{"id":4174,"randomNumber":331},{"id":51,"randomNumber":6544},{"id":4462,"randomNumber":952},{"id":2221,"randomNumber":532},{"id":9276,"randomNumber":3097},{"id":3056,"randomNumber":7293},{"id":6964,"randomNumber":620},{"id":675,"randomNumber":6601},{"id":8414,"randomNumber":6569},{"id":2753,"randomNumber":4065}]
+   */
+  val jsonLongRawResponse =
+    ResponseRenderingContext(
+      response = HttpResponse(
+        200,
+        headers = Nil,
+        entity = HttpEntity(ContentTypes.`application/json`, """[{"id":4174,"randomNumber":331},{"id":51,"randomNumber":6544},{"id":4462,"randomNumber":952},{"id":2221,"randomNumber":532},{"id":9276,"randomNumber":3097},{"id":3056,"randomNumber":7293},{"id":6964,"randomNumber":620},{"id":675,"randomNumber":6601},{"id":8414,"randomNumber":6569},{"id":2753,"randomNumber":4065}]""")
+      ),
+      requestMethod = HttpMethods.GET
+    )
+
+  @Benchmark
+  @Threads(8)
+  @OperationsPerInvocation(100 * 1000)
+  def simple_response(blackhole: Blackhole): Unit =
+    renderToImpl(simpleResponse, blackhole, n = 100 * 1000).await()
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def json_response(blackhole: Blackhole): Unit =
+    renderToImpl(jsonResponse, blackhole, n = 100 * 1000).await()
+
+  /*
+  Difference between 27 and 315 bytes long JSON is:
+  
+  [info] Benchmark                                                   Mode  Cnt        Score       Error  Units
+  [info] HttpResponseRenderingBenchmark.json_long_raw_response      thrpt   20  1 932 331.049 ± 64125.621  ops/s
+  [info] HttpResponseRenderingBenchmark.json_response               thrpt   20  1 973 232.941 ± 18568.314  ops/s
+   */
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def json_long_raw_response(blackhole: Blackhole): Unit =
+    renderToImpl(jsonLongRawResponse, blackhole, n = 100 * 1000).await()
+
+  class JitSafeLatch[A](blackhole: Blackhole, n: Int) extends GraphStageWithMaterializedValue[SinkShape[A], CountDownLatch] {
+    val in = Inlet[A]("JitSafeLatch.in")
+    override val shape = SinkShape(in)
+
+    override def createLogicAndMaterializedValue(inheritedAttributes: Attributes): (GraphStageLogic, CountDownLatch) = {
+      val latch = new CountDownLatch(n)
+      val logic = new GraphStageLogic(shape) with InHandler {
+
+        override def preStart(): Unit = pull(in)
+        override def onPush(): Unit = {
+          if (blackhole ne null) blackhole.consume(grab(in))
+          latch.countDown()
+          pull(in)
+        }
+
+        setHandler(in, this)
+      }
+
+      (logic, latch)
+    }
+  }
+
+  def renderToImpl(ctx: ResponseRenderingContext, blackhole: Blackhole, n: Int)(implicit mat: Materializer): CountDownLatch = {
+    val latch =
+      (Source.repeat(ctx).take(n) ++ Source.maybe[ResponseRenderingContext]) // never send upstream completion
+        .via(renderer.named("renderer"))
+        .runWith(new JitSafeLatch[ResponseRenderingOutput](blackhole, n))
+
+    latch
+  }
+
+  // TODO benchmark with stable override
+  override def currentTimeMillis(): Long = System.currentTimeMillis()
+  //  override def currentTimeMillis(): Long = System.currentTimeMillis() // DateTime(2011, 8, 25, 9, 10, 29).clicks // provide a stable date for testing
+
+}
+
diff --git a/akka-bench-jmh/src/main/scala/akka/stream/FusedGraphsBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/stream/FusedGraphsBenchmark.scala
new file mode 100644
index 0000000000..f2dea5401f
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/stream/FusedGraphsBenchmark.scala
@@ -0,0 +1,331 @@
+/**
+ * Copyright (C) 2014-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.stream
+
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
+
+import akka.NotUsed
+import akka.actor.ActorSystem
+import akka.stream.impl.fusing.GraphStages
+import akka.stream.scaladsl._
+import akka.stream.stage._
+import org.openjdk.jmh.annotations.{ OperationsPerInvocation, _ }
+
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+object FusedGraphsBenchmark {
+  val ElementCount = 100 * 1000
+
+  @volatile var blackhole: org.openjdk.jmh.infra.Blackhole = _
+}
+
+// Just to avoid allocations and still have a way to do some work in stages. The value itself does not matter
+// so no issues with sharing (the result does not make any sense, but hey)
+class MutableElement(var value: Int)
+
+class TestSource(elems: Array[MutableElement]) extends GraphStage[SourceShape[MutableElement]] {
+  val out = Outlet[MutableElement]("TestSource.out")
+  override val shape = SourceShape(out)
+
+  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with OutHandler {
+    private[this] var left = FusedGraphsBenchmark.ElementCount - 1
+
+    override def onPull(): Unit = {
+      if (left >= 0) {
+        push(out, elems(left))
+        left -= 1
+      } else completeStage()
+    }
+
+    setHandler(out, this)
+  }
+}
+
+class JitSafeCompletionLatch extends GraphStageWithMaterializedValue[SinkShape[MutableElement], CountDownLatch] {
+  val in = Inlet[MutableElement]("JitSafeCompletionLatch.in")
+  override val shape = SinkShape(in)
+
+  override def createLogicAndMaterializedValue(inheritedAttributes: Attributes): (GraphStageLogic, CountDownLatch) = {
+    val latch = new CountDownLatch(1)
+    val logic = new GraphStageLogic(shape) with InHandler {
+      private[this] var sum = 0
+
+      override def preStart(): Unit = pull(in)
+      override def onPush(): Unit = {
+        sum += grab(in).value
+        pull(in)
+      }
+
+      override def onUpstreamFinish(): Unit = {
+        // Do not ignore work along the chain
+        FusedGraphsBenchmark.blackhole.consume(sum)
+        latch.countDown()
+        completeStage()
+      }
+
+      setHandler(in, this)
+    }
+
+    (logic, latch)
+  }
+}
+
+class IdentityStage extends GraphStage[FlowShape[MutableElement, MutableElement]] {
+  val in = Inlet[MutableElement]("Identity.in")
+  val out = Outlet[MutableElement]("Identity.out")
+  override val shape = FlowShape(in, out)
+
+  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with InHandler with OutHandler {
+    override def onPush(): Unit = push(out, grab(in))
+    override def onPull(): Unit = pull(in)
+
+    setHandlers(in, out, this)
+  }
+}
+
+@State(Scope.Benchmark)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+class FusedGraphsBenchmark {
+  import FusedGraphsBenchmark._
+
+  implicit val system = ActorSystem("test")
+  var materializer: ActorMaterializer = _
+  var testElements: Array[MutableElement] = _
+
+  var singleIdentity: RunnableGraph[CountDownLatch] = _
+  var chainOfIdentities: RunnableGraph[CountDownLatch] = _
+  var singleMap: RunnableGraph[CountDownLatch] = _
+  var chainOfMaps: RunnableGraph[CountDownLatch] = _
+  var repeatTakeMapAndFold: RunnableGraph[CountDownLatch] = _
+  var singleBuffer: RunnableGraph[CountDownLatch] = _
+  var chainOfBuffers: RunnableGraph[CountDownLatch] = _
+  var broadcastZip: RunnableGraph[CountDownLatch] = _
+  var balanceMerge: RunnableGraph[CountDownLatch] = _
+  var broadcastZipBalanceMerge: RunnableGraph[CountDownLatch] = _
+
+  @Setup
+  def setup(): Unit = {
+    val settings = ActorMaterializerSettings(system)
+      .withFuzzing(false)
+      .withSyncProcessingLimit(Int.MaxValue)
+      .withAutoFusing(false) // We fuse manually in this test in the setup
+
+    materializer = ActorMaterializer(settings)
+    testElements = Array.fill(ElementCount)(new MutableElement(0))
+    val addFunc = (x: MutableElement) => { x.value += 1; x }
+
+    val testSource = Source.fromGraph(new TestSource(testElements))
+    val testSink = Sink.fromGraph(new JitSafeCompletionLatch)
+
+    def fuse(r: RunnableGraph[CountDownLatch]): RunnableGraph[CountDownLatch] = {
+      RunnableGraph.fromGraph(Fusing.aggressive(r))
+    }
+
+    val identityStage = new IdentityStage
+
+    singleIdentity =
+      fuse(
+        testSource
+          .via(identityStage)
+          .toMat(testSink)(Keep.right)
+      )
+
+    chainOfIdentities =
+      fuse(
+        testSource
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .via(identityStage)
+          .toMat(testSink)(Keep.right)
+      )
+
+    singleMap =
+      fuse(
+        testSource
+          .map(addFunc)
+          .toMat(testSink)(Keep.right)
+      )
+
+    chainOfMaps =
+      fuse(
+        testSource
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .map(addFunc)
+          .toMat(testSink)(Keep.right)
+      )
+
+    repeatTakeMapAndFold =
+      fuse(
+        Source.repeat(new MutableElement(0))
+          .take(ElementCount)
+          .map(addFunc)
+          .map(addFunc)
+          .fold(new MutableElement(0))((acc, x) => { acc.value += x.value; acc })
+          .toMat(testSink)(Keep.right)
+      )
+
+    singleBuffer =
+      fuse(
+        testSource
+          .buffer(10, OverflowStrategy.backpressure)
+          .toMat(testSink)(Keep.right)
+      )
+
+    chainOfBuffers =
+      fuse(
+        testSource
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .buffer(10, OverflowStrategy.backpressure)
+          .toMat(testSink)(Keep.right)
+      )
+
+    val broadcastZipFlow: Flow[MutableElement, MutableElement, NotUsed] = Flow.fromGraph(GraphDSL.create() { implicit b =>
+      import GraphDSL.Implicits._
+
+      val bcast = b.add(Broadcast[MutableElement](2))
+      val zip = b.add(Zip[MutableElement, MutableElement]())
+
+      bcast ~> zip.in0
+      bcast ~> zip.in1
+
+      FlowShape(bcast.in, zip.out.map(_._1).outlet)
+    })
+
+    val balanceMergeFlow: Flow[MutableElement, MutableElement, NotUsed] = Flow.fromGraph(GraphDSL.create() { implicit b =>
+      import GraphDSL.Implicits._
+
+      val balance = b.add(Balance[MutableElement](2))
+      val merge = b.add(Merge[MutableElement](2))
+
+      balance ~> merge
+      balance ~> merge
+
+      FlowShape(balance.in, merge.out)
+    })
+
+    broadcastZip =
+      fuse(
+        testSource
+          .via(broadcastZipFlow)
+          .toMat(testSink)(Keep.right)
+      )
+
+    balanceMerge =
+      fuse(
+        testSource
+          .via(balanceMergeFlow)
+          .toMat(testSink)(Keep.right)
+      )
+
+    broadcastZipBalanceMerge =
+      fuse(
+        testSource
+          .via(broadcastZipFlow)
+          .via(balanceMergeFlow)
+          .toMat(testSink)(Keep.right)
+      )
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def single_identity(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    singleIdentity.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def chain_of_identities(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    chainOfIdentities.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def single_map(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    singleMap.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def chain_of_maps(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    chainOfMaps.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def repeat_take_map_and_fold(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    repeatTakeMapAndFold.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def single_buffer(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    singleBuffer.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def chain_of_buffers(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    chainOfBuffers.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def broadcast_zip(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    broadcastZip.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def balance_merge(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    balanceMerge.run()(materializer).await()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100 * 1000)
+  def boradcast_zip_balance_merge(blackhole: org.openjdk.jmh.infra.Blackhole): Unit = {
+    FusedGraphsBenchmark.blackhole = blackhole
+    broadcastZipBalanceMerge.run()(materializer).await()
+  }
+
+  @TearDown
+  def shutdown(): Unit = {
+    Await.result(system.terminate(), 5.seconds)
+  }
+
+}
diff --git a/akka-bench-jmh/src/main/scala/akka/stream/JsonFramingBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/stream/JsonFramingBenchmark.scala
new file mode 100644
index 0000000000..8e7cfe884e
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/stream/JsonFramingBenchmark.scala
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2009-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.stream
+
+import java.util.concurrent.TimeUnit
+
+import akka.stream.impl.JsonObjectParser
+import akka.util.ByteString
+import org.openjdk.jmh.annotations._
+
+@State(Scope.Benchmark)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+class JsonFramingBenchmark {
+
+  /*
+    Benchmark                                 Mode  Cnt      Score      Error  Units
+    // old
+    JsonFramingBenchmark.collecting_1        thrpt   20     81.476 ±   14.793  ops/s
+    JsonFramingBenchmark.collecting_offer_5  thrpt   20     20.187 ±    2.291  ops/s
+
+    // new
+    JsonFramingBenchmark.counting_1          thrpt   20  10766.738 ± 1278.300  ops/s
+    JsonFramingBenchmark.counting_offer_5    thrpt   20  28798.255 ± 2670.163  ops/s
+   */
+
+  val json =
+    ByteString(
+      """|{"fname":"Frank","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Bob","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Bob","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Bob","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Bob","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Bob","name":"Smith","age":42,"id":1337,"boardMember":false},
+        |{"fname":"Hank","name":"Smith","age":42,"id":1337,"boardMember":false}""".stripMargin
+    )
+
+  val bracket = new JsonObjectParser
+
+  @Setup(Level.Invocation)
+  def init(): Unit = {
+    bracket.offer(json)
+  }
+
+  @Benchmark
+  def counting_1: ByteString =
+    bracket.poll().get
+
+  @Benchmark
+  @OperationsPerInvocation(5)
+  def counting_offer_5: ByteString = {
+    bracket.offer(json)
+    bracket.poll().get
+    bracket.poll().get
+    bracket.poll().get
+    bracket.poll().get
+    bracket.poll().get
+    bracket.poll().get
+  }
+
+}
diff --git a/akka-bench-jmh/src/main/scala/akka/util/ByteString_copyToBuffer_Benchmark.scala b/akka-bench-jmh/src/main/scala/akka/util/ByteString_copyToBuffer_Benchmark.scala
new file mode 100644
index 0000000000..5868897ec7
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/util/ByteString_copyToBuffer_Benchmark.scala
@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2014-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.util
+
+import java.nio.ByteBuffer
+import java.util.concurrent.TimeUnit
+
+import akka.util.ByteString.{ ByteString1, ByteString1C, ByteStrings }
+import org.openjdk.jmh.annotations._
+import org.openjdk.jmh.infra.Blackhole
+
+@State(Scope.Benchmark)
+@Measurement(timeUnit = TimeUnit.MILLISECONDS)
+class ByteString_copyToBuffer_Benchmark {
+
+  val _bs_mini = ByteString(Array.ofDim[Byte](128 * 4))
+  val _bs_small = ByteString(Array.ofDim[Byte](1024 * 1))
+  val _bs_large = ByteString(Array.ofDim[Byte](1024 * 4))
+
+  val bs_mini = ByteString(Array.ofDim[Byte](128 * 4 * 4))
+  val bs_small = ByteString(Array.ofDim[Byte](1024 * 1 * 4))
+  val bs_large = ByteString(Array.ofDim[Byte](1024 * 4 * 4))
+
+  val bss_mini = ByteStrings(Vector.fill(4)(bs_mini.asInstanceOf[ByteString1C].toByteString1), 4 * bs_mini.length)
+  val bss_small = ByteStrings(Vector.fill(4)(bs_small.asInstanceOf[ByteString1C].toByteString1), 4 * bs_small.length)
+  val bss_large = ByteStrings(Vector.fill(4)(bs_large.asInstanceOf[ByteString1C].toByteString1), 4 * bs_large.length)
+  val bss_pc_large = bss_large.compact
+
+  val buf = ByteBuffer.allocate(1024 * 4 * 4)
+
+  /*
+    BEFORE
+
+    [info] Benchmark                                       Mode  Cnt            Score          Error  Units
+    [info] ByteStringBenchmark.bs_large_copyToBuffer      thrpt   40  142 163 289.866 ± 21751578.294  ops/s
+    [info] ByteStringBenchmark.bss_large_copyToBuffer     thrpt   40    1 489 195.631 ±   209165.487  ops/s << that's the interesting case, we needlessly fold and allocate tons of Stream etc
+    [info] ByteStringBenchmark.bss_large_pc_copyToBuffer  thrpt   40  184 466 756.364 ±  9169108.378  ops/s // "can't beat that"
+    
+    
+    [info] ....[Thread state: RUNNABLE]........................................................................
+    [info]  35.9%  35.9% scala.collection.Iterator$class.toStream
+    [info]  20.2%  20.2% scala.collection.immutable.Stream.foldLeft
+    [info]  11.6%  11.6% scala.collection.immutable.Stream$StreamBuilder.<init>
+    [info]  10.9%  10.9% akka.util.ByteIterator.<init>
+    [info]   6.1%   6.1% scala.collection.mutable.ListBuffer.<init>
+    [info]   5.2%   5.2% akka.util.ByteString.copyToBuffer
+    [info]   5.2%   5.2% scala.collection.AbstractTraversable.<init>
+    [info]   2.2%   2.2% scala.collection.immutable.VectorIterator.initFrom
+    [info]   1.2%   1.2% akka.util.generated.ByteStringBenchmark_bss_large_copyToBuffer.bss_large_copyToBuffer_thrpt_jmhStub
+    [info]   0.3%   0.3% akka.util.ByteIterator$MultiByteArrayIterator.copyToBuffer
+    [info]   1.2%   1.2% <other>
+    
+    
+    AFTER specializing impls
+    
+    [info] ....[Thread state: RUNNABLE]........................................................................
+    [info]  99.5%  99.6% akka.util.generated.ByteStringBenchmark_bss_large_copyToBuffer_jmhTest.bss_large_copyToBuffer_thrpt_jmhStub
+    [info]   0.1%   0.1% java.util.concurrent.CountDownLatch.countDown
+    [info]   0.1%   0.1% sun.reflect.NativeMethodAccessorImpl.invoke0
+    [info]   0.1%   0.1% sun.misc.Unsafe.putObject
+    [info]   0.1%   0.1% org.openjdk.jmh.infra.IterationParamsL2.getBatchSize
+    [info]   0.1%   0.1% java.lang.Thread.currentThread
+    [info]   0.1%   0.1% sun.misc.Unsafe.compareAndSwapInt
+    [info]   0.1%   0.1% sun.reflect.AccessorGenerator.internalize
+    
+    [info] Benchmark                                       Mode  Cnt            Score         Error  Units
+    [info] ByteStringBenchmark.bs_large_copyToBuffer      thrpt   40  177 328 585.473 ± 7742067.648  ops/s
+    [info] ByteStringBenchmark.bss_large_copyToBuffer     thrpt   40  113 535 003.488 ± 3899763.124  ops/s // previous bad case now very good (was 2M/s)
+    [info] ByteStringBenchmark.bss_large_pc_copyToBuffer  thrpt   40  203 590 896.493 ± 7582752.024  ops/s // "can't beat that"
+    
+   */
+
+  @Benchmark
+  def bs_large_copyToBuffer(): Int = {
+    buf.flip()
+    bs_large.copyToBuffer(buf)
+  }
+
+  @Benchmark
+  def bss_large_copyToBuffer(): Int = {
+    buf.flip()
+    bss_large.copyToBuffer(buf)
+  }
+
+  /** Pre-compacted */
+  @Benchmark
+  def bss_large_pc_copyToBuffer(): Int = {
+    buf.flip()
+    bss_pc_large.copyToBuffer(buf)
+  }
+}
diff --git a/akka-bench-jmh/src/main/scala/akka/util/ByteString_decode_Benchmark.scala b/akka-bench-jmh/src/main/scala/akka/util/ByteString_decode_Benchmark.scala
new file mode 100644
index 0000000000..b606f251fe
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/util/ByteString_decode_Benchmark.scala
@@ -0,0 +1,64 @@
+/**
+ * Copyright (C) 2014-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.util
+
+import java.nio.charset.Charset
+import java.util.concurrent.TimeUnit
+
+import akka.util.ByteString.{ ByteString1C, ByteStrings }
+import org.openjdk.jmh.annotations._
+
+@State(Scope.Benchmark)
+@Measurement(timeUnit = TimeUnit.MILLISECONDS)
+class ByteString_decode_Benchmark {
+
+  val _bs_large = ByteString(Array.ofDim[Byte](1024 * 4))
+
+  val bs_large = ByteString(Array.ofDim[Byte](1024 * 4 * 4))
+
+  val bss_large = ByteStrings(Vector.fill(4)(bs_large.asInstanceOf[ByteString1C].toByteString1), 4 * bs_large.length)
+  val bc_large = bss_large.compact // compacted
+
+  val utf8String = "utf-8"
+  val utf8 = Charset.forName(utf8String)
+
+  /*
+    Using Charset helps a bit, but nothing impressive:
+  
+    [info] ByteString_decode_Benchmark.bc_large_decodeString_stringCharset_utf8        thrpt   20  21 612.293 ±  825.099  ops/s
+      =>
+    [info] ByteString_decode_Benchmark.bc_large_decodeString_charsetCharset_utf8       thrpt   20  22 473.372 ±  851.597  ops/s
+    
+    
+    [info] ByteString_decode_Benchmark.bs_large_decodeString_stringCharset_utf8        thrpt   20  84 443.674 ± 3723.987  ops/s
+      =>
+    [info] ByteString_decode_Benchmark.bs_large_decodeString_charsetCharset_utf8       thrpt   20  93 865.033 ± 2052.476  ops/s
+    
+    
+    [info] ByteString_decode_Benchmark.bss_large_decodeString_stringCharset_utf8       thrpt   20  14 886.553 ±  326.752  ops/s
+      =>
+    [info] ByteString_decode_Benchmark.bss_large_decodeString_charsetCharset_utf8      thrpt   20  16 031.670 ±  474.565  ops/s
+   */
+
+  @Benchmark
+  def bc_large_decodeString_stringCharset_utf8: String =
+    bc_large.decodeString(utf8String)
+  @Benchmark
+  def bs_large_decodeString_stringCharset_utf8: String =
+    bs_large.decodeString(utf8String)
+  @Benchmark
+  def bss_large_decodeString_stringCharset_utf8: String =
+    bss_large.decodeString(utf8String)
+
+  @Benchmark
+  def bc_large_decodeString_charsetCharset_utf8: String =
+    bc_large.decodeString(utf8)
+  @Benchmark
+  def bs_large_decodeString_charsetCharset_utf8: String =
+    bs_large.decodeString(utf8)
+  @Benchmark
+  def bss_large_decodeString_charsetCharset_utf8: String =
+    bss_large.decodeString(utf8)
+
+}
diff --git a/akka-bench-jmh/src/main/scala/akka/util/ByteString_dropSliceTake_Benchmark.scala b/akka-bench-jmh/src/main/scala/akka/util/ByteString_dropSliceTake_Benchmark.scala
new file mode 100644
index 0000000000..90ff47a807
--- /dev/null
+++ b/akka-bench-jmh/src/main/scala/akka/util/ByteString_dropSliceTake_Benchmark.scala
@@ -0,0 +1,156 @@
+/**
+ * Copyright (C) 2014-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.util
+
+import java.nio.ByteBuffer
+import java.util.concurrent.TimeUnit
+
+import akka.util.ByteString.{ ByteString1C, ByteStrings }
+import org.openjdk.jmh.annotations._
+
+@State(Scope.Benchmark)
+@Measurement(timeUnit = TimeUnit.MILLISECONDS)
+class ByteString_dropSliceTake_Benchmark {
+
+  val _bs_mini = ByteString(Array.ofDim[Byte](128 * 4))
+  val _bs_small = ByteString(Array.ofDim[Byte](1024 * 1))
+  val _bs_large = ByteString(Array.ofDim[Byte](1024 * 4))
+
+  val bs_mini = ByteString(Array.ofDim[Byte](128 * 4 * 4))
+  val bs_small = ByteString(Array.ofDim[Byte](1024 * 1 * 4))
+  val bs_large = ByteString(Array.ofDim[Byte](1024 * 4 * 4))
+
+  val bss_mini = ByteStrings(Vector.fill(4)(bs_mini.asInstanceOf[ByteString1C].toByteString1), 4 * bs_mini.length)
+  val bss_small = ByteStrings(Vector.fill(4)(bs_small.asInstanceOf[ByteString1C].toByteString1), 4 * bs_small.length)
+  val bss_large = ByteStrings(Vector.fill(4)(bs_large.asInstanceOf[ByteString1C].toByteString1), 4 * bs_large.length)
+  val bss_pc_large = bss_large.compact
+
+  /*
+   --------------------------------- BASELINE -------------------------------------------------------------------- 
+   [info] Benchmark                                                         Mode  Cnt            Score         Error  Units
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_100        thrpt   20  111 122 621.983 ± 6172679.160  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_256        thrpt   20  110 238 003.870 ± 4042572.908  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_2000       thrpt   20  106 435 449.123 ± 2972282.531  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_100       thrpt   20    1 155 292.430 ±   23096.219  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_256       thrpt   20    1 191 713.229 ±   15910.426  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_2000      thrpt   20    1 201 342.579 ±   21119.392  ops/s
+
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_100             thrpt   20  108 252 561.824 ± 3841392.346  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_256             thrpt   20  112 515 936.237 ± 5651549.124  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_2000            thrpt   20  110 851 553.706 ± 3327510.108  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_18             thrpt   20      983 544.541 ±   46299.808  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_100            thrpt   20      875 345.433 ±   44760.533  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_256            thrpt   20      864 182.258 ±  111172.303  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_2000           thrpt   20      997 459.151 ±   33627.993  ops/s
+
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_slice_80_80          thrpt   20  112 299 538.691 ± 7259114.294  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_slice_129_129        thrpt   20  105 640 836.625 ± 9112709.942  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_slice_80_80         thrpt   20   10 868 202.262 ±  526537.133  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_slice_129_129       thrpt   20    9 429 199.802 ± 1321542.453  ops/s
+   
+   --------------------------------- AFTER -----------------------------------------------------------------------
+   
+   ------ TODAY –––––––
+   [info] Benchmark                                                         Mode  Cnt            Score         Error  Units
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_100        thrpt   20  126 091 961.654 ± 2813125.268  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_256        thrpt   20  118 393 394.350 ± 2934782.759  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_dropRight_2000       thrpt   20  119 183 386.004 ± 4445324.298  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_100       thrpt   20    8 813 065.392 ±  234570.880  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_256       thrpt   20    9 039 585.934 ±  297168.301  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_dropRight_2000      thrpt   20    9 629 458.168 ±  124846.904  ops/s
+   
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_100             thrpt   20  111 666 137.955 ± 4846727.674  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_256             thrpt   20  114 405 514.622 ± 4985750.805  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_drop_2000            thrpt   20  114 364 716.297 ± 2512280.603  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_18             thrpt   20   10 040 457.962 ±  527850.116  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_100            thrpt   20    9 184 934.769 ±  549140.840  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_256            thrpt   20   10 887 437.121 ±  195606.240  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_drop_2000           thrpt   20   10 725 300.292 ±  403470.413  ops/s
+   
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_slice_80_80          thrpt   20  233 017 314.148 ± 7070246.826  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bs_large_slice_129_129        thrpt   20  275 245 086.247 ± 4969752.048  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_slice_80_80         thrpt   20  264 963 420.976 ± 4259289.143  ops/s
+   [info] ByteString_dropSliceTake_Benchmark.bss_large_slice_129_129       thrpt   20  265 477 577.022 ± 4623974.283  ops/s
+   
+   */
+
+  // 18 == "http://example.com", a typical url length 
+
+  @Benchmark
+  def bs_large_drop_0: ByteString =
+    bs_large.drop(0)
+  @Benchmark
+  def bss_large_drop_0: ByteString =
+    bss_large.drop(0)
+
+  @Benchmark
+  def bs_large_drop_18: ByteString =
+    bs_large.drop(18)
+  @Benchmark
+  def bss_large_drop_18: ByteString =
+    bss_large.drop(18)
+
+  @Benchmark
+  def bs_large_drop_100: ByteString =
+    bs_large.drop(100)
+  @Benchmark
+  def bss_large_drop_100: ByteString =
+    bss_large.drop(100)
+
+  @Benchmark
+  def bs_large_drop_256: ByteString =
+    bs_large.drop(256)
+  @Benchmark
+  def bss_large_drop_256: ByteString =
+    bss_large.drop(256)
+
+  @Benchmark
+  def bs_large_drop_2000: ByteString =
+    bs_large.drop(2000)
+  @Benchmark
+  def bss_large_drop_2000: ByteString =
+    bss_large.drop(2000)
+
+  /* these force 2 array drops, and 1 element drop inside the 2nd to first/last; can be considered as "bad case" */
+
+  @Benchmark
+  def bs_large_slice_129_129: ByteString =
+    bs_large.slice(129, 129)
+  @Benchmark
+  def bss_large_slice_129_129: ByteString =
+    bss_large.slice(129, 129)
+
+  /* these only move the indexes, don't drop any arrays "happy case" */
+
+  @Benchmark
+  def bs_large_slice_80_80: ByteString =
+    bs_large.slice(80, 80)
+  @Benchmark
+  def bss_large_slice_80_80: ByteString =
+    bss_large.slice(80, 80)
+
+  // drop right ---
+
+  @Benchmark
+  def bs_large_dropRight_100: ByteString =
+    bs_large.dropRight(100)
+  @Benchmark
+  def bss_large_dropRight_100: ByteString =
+    bss_large.dropRight(100)
+
+  @Benchmark
+  def bs_large_dropRight_256: ByteString =
+    bs_large.dropRight(256)
+  @Benchmark
+  def bss_large_dropRight_256: ByteString =
+    bss_large.dropRight(256)
+
+  @Benchmark
+  def bs_large_dropRight_2000: ByteString =
+    bs_large.dropRight(2000)
+  @Benchmark
+  def bss_large_dropRight_2000: ByteString =
+    bss_large.dropRight(2000)
+
+}
diff --git a/akka-camel/src/test/scala/akka/camel/ConsumerIntegrationTest.scala b/akka-camel/src/test/scala/akka/camel/ConsumerIntegrationTest.scala
index b673fa9057..1c4f03a16a 100644
--- a/akka-camel/src/test/scala/akka/camel/ConsumerIntegrationTest.scala
+++ b/akka-camel/src/test/scala/akka/camel/ConsumerIntegrationTest.scala
@@ -123,13 +123,13 @@ class ConsumerIntegrationTest extends WordSpec with Matchers with NonSharedCamel
     }
 
     "Error passing consumer supports redelivery through route modification" in {
-      val ref = start(new FailingOnceConsumer("direct:failing-once-concumer") {
+      val ref = start(new FailingOnceConsumer("direct:failing-once-consumer") {
         override def onRouteDefinition = (rd: RouteDefinition) ⇒ {
-          rd.onException(classOf[TestException]).maximumRedeliveries(1).end
+          rd.onException(classOf[TestException]).redeliveryDelay(0L).maximumRedeliveries(1).end
         }
       }, name = "direct-failing-once-consumer")
       filterEvents(EventFilter[TestException](occurrences = 1)) {
-        camel.sendTo("direct:failing-once-concumer", msg = "hello") should ===("accepted: hello")
+        camel.sendTo("direct:failing-once-consumer", msg = "hello") should ===("accepted: hello")
       }
       stop(ref)
     }
diff --git a/akka-cluster-sharding/src/main/resources/reference.conf b/akka-cluster-sharding/src/main/resources/reference.conf
index 8206019d46..c89d0036a5 100644
--- a/akka-cluster-sharding/src/main/resources/reference.conf
+++ b/akka-cluster-sharding/src/main/resources/reference.conf
@@ -94,6 +94,20 @@ akka.cluster.sharding {
   # works only for state-store-mode = "ddata"
   updating-state-timeout = 5 s
 
+  # The shard uses this strategy to determines how to recover the underlying entity actors. The strategy is only used
+  # by the persistent shard when rebalancing or restarting. The value can either be "all" or "constant". The "all"
+  # strategy start all the underlying entity actors at the same time. The constant strategy will start the underlying
+  # entity actors at a fix rate. The default strategy "all".
+  entity-recovery-strategy = "all"
+
+  # Default settings for the constant rate entity recovery strategy
+  entity-recovery-constant-rate-strategy {
+    # Sets the frequency at which a batch of entity actors is started.
+    frequency = 100 ms
+    # Sets the number of entity actors to be restart at a particular interval
+    number-of-entities = 5
+  }
+
   # Settings for the coordinator singleton. Same layout as akka.cluster.singleton.
   # The "role" of the singleton configuration is not used. The singleton role will
   # be the same as "akka.cluster.sharding.role".
diff --git a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterSharding.scala b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterSharding.scala
index 631d064939..f063268ccc 100644
--- a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterSharding.scala
+++ b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterSharding.scala
@@ -258,7 +258,7 @@ class ClusterSharding(system: ExtendedActorSystem) extends Extension {
    * @param entityProps the `Props` of the entity actors that will be created by the `ShardRegion`
    * @param settings configuration settings, see [[ClusterShardingSettings]]
    * @param messageExtractor functions to extract the entity id, shard id, and the message to send to the
-   *   entity from the incoming message
+   *   entity from the incoming message, see [[ShardRegion.MessageExtractor]]
    * @param allocationStrategy possibility to use a custom shard allocation and
    *   rebalancing logic
    * @param handOffStopMessage the message that will be sent to entities when they are to be stopped
diff --git a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterShardingSettings.scala b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterShardingSettings.scala
index b77fb80eb8..230cfc4a5e 100644
--- a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterShardingSettings.scala
+++ b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ClusterShardingSettings.scala
@@ -38,7 +38,10 @@ object ClusterShardingSettings {
       leastShardAllocationMaxSimultaneousRebalance =
         config.getInt("least-shard-allocation-strategy.max-simultaneous-rebalance"),
       waitingForStateTimeout = config.getDuration("waiting-for-state-timeout", MILLISECONDS).millis,
-      updatingStateTimeout = config.getDuration("updating-state-timeout", MILLISECONDS).millis)
+      updatingStateTimeout = config.getDuration("updating-state-timeout", MILLISECONDS).millis,
+      entityRecoveryStrategy = config.getString("entity-recovery-strategy"),
+      entityRecoveryConstantRateStrategyFrequency = config.getDuration("entity-recovery-constant-rate-strategy.frequency", MILLISECONDS).millis,
+      entityRecoveryConstantRateStrategyNumberOfEntities = config.getInt("entity-recovery-constant-rate-strategy.number-of-entities"))
 
     val coordinatorSingletonSettings = ClusterSingletonManagerSettings(config.getConfig("coordinator-singleton"))
 
@@ -71,19 +74,62 @@ object ClusterShardingSettings {
     if (role == "") None else Option(role)
 
   class TuningParameters(
-    val coordinatorFailureBackoff:                    FiniteDuration,
-    val retryInterval:                                FiniteDuration,
-    val bufferSize:                                   Int,
-    val handOffTimeout:                               FiniteDuration,
-    val shardStartTimeout:                            FiniteDuration,
-    val shardFailureBackoff:                          FiniteDuration,
-    val entityRestartBackoff:                         FiniteDuration,
-    val rebalanceInterval:                            FiniteDuration,
-    val snapshotAfter:                                Int,
-    val leastShardAllocationRebalanceThreshold:       Int,
-    val leastShardAllocationMaxSimultaneousRebalance: Int,
-    val waitingForStateTimeout:                       FiniteDuration,
-    val updatingStateTimeout:                         FiniteDuration)
+    val coordinatorFailureBackoff:                          FiniteDuration,
+    val retryInterval:                                      FiniteDuration,
+    val bufferSize:                                         Int,
+    val handOffTimeout:                                     FiniteDuration,
+    val shardStartTimeout:                                  FiniteDuration,
+    val shardFailureBackoff:                                FiniteDuration,
+    val entityRestartBackoff:                               FiniteDuration,
+    val rebalanceInterval:                                  FiniteDuration,
+    val snapshotAfter:                                      Int,
+    val leastShardAllocationRebalanceThreshold:             Int,
+    val leastShardAllocationMaxSimultaneousRebalance:       Int,
+    val waitingForStateTimeout:                             FiniteDuration,
+    val updatingStateTimeout:                               FiniteDuration,
+    val entityRecoveryStrategy:                             String,
+    val entityRecoveryConstantRateStrategyFrequency:        FiniteDuration,
+    val entityRecoveryConstantRateStrategyNumberOfEntities: Int) {
+
+    require(
+      entityRecoveryStrategy == "all" || entityRecoveryStrategy == "constant",
+      s"Unknown 'entity-recovery-strategy' [$entityRecoveryStrategy], valid values are 'all' or 'constant'")
+
+    // included for binary compatibility
+    def this(
+      coordinatorFailureBackoff:                    FiniteDuration,
+      retryInterval:                                FiniteDuration,
+      bufferSize:                                   Int,
+      handOffTimeout:                               FiniteDuration,
+      shardStartTimeout:                            FiniteDuration,
+      shardFailureBackoff:                          FiniteDuration,
+      entityRestartBackoff:                         FiniteDuration,
+      rebalanceInterval:                            FiniteDuration,
+      snapshotAfter:                                Int,
+      leastShardAllocationRebalanceThreshold:       Int,
+      leastShardAllocationMaxSimultaneousRebalance: Int,
+      waitingForStateTimeout:                       FiniteDuration,
+      updatingStateTimeout:                         FiniteDuration) = {
+      this(
+        coordinatorFailureBackoff,
+        retryInterval,
+        bufferSize,
+        handOffTimeout,
+        shardStartTimeout,
+        shardFailureBackoff,
+        entityRestartBackoff,
+        rebalanceInterval,
+        snapshotAfter,
+        leastShardAllocationRebalanceThreshold,
+        leastShardAllocationMaxSimultaneousRebalance,
+        waitingForStateTimeout,
+        updatingStateTimeout,
+        "all",
+        100 milliseconds,
+        5
+      )
+    }
+  }
 }
 
 /**
diff --git a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/Shard.scala b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/Shard.scala
index e8381da165..a1d42d1034 100644
--- a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/Shard.scala
+++ b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/Shard.scala
@@ -6,16 +6,19 @@ package akka.cluster.sharding
 import java.net.URLEncoder
 import akka.actor.ActorLogging
 import akka.actor.ActorRef
+import akka.actor.ActorSystem
 import akka.actor.Deploy
 import akka.actor.Props
 import akka.actor.Terminated
-import akka.cluster.sharding.Shard.{ ShardCommand }
+import akka.cluster.sharding.Shard.ShardCommand
 import akka.persistence.PersistentActor
 import akka.persistence.SnapshotOffer
 import akka.actor.Actor
 import akka.persistence.RecoveryCompleted
 import akka.persistence.SaveSnapshotFailure
 import akka.persistence.SaveSnapshotSuccess
+import scala.concurrent.Future
+import scala.concurrent.duration.FiniteDuration
 
 /**
  * INTERNAL API
@@ -35,6 +38,12 @@ private[akka] object Shard {
    */
   final case class RestartEntity(entity: EntityId) extends ShardCommand
 
+  /**
+   * When initialising a shard with remember entities enabled the following message is used
+   * to restart batches of entity actors at a time.
+   */
+  final case class RestartEntities(entity: Set[EntityId]) extends ShardCommand
+
   /**
    * A case class which represents a state change for the Shard
    */
@@ -116,7 +125,7 @@ private[akka] class Shard(
 
   import ShardRegion.{ handOffStopperProps, EntityId, Msg, Passivate, ShardInitialized }
   import ShardCoordinator.Internal.{ HandOff, ShardStopped }
-  import Shard.{ State, RestartEntity, EntityStopped, EntityStarted }
+  import Shard.{ State, RestartEntity, RestartEntities, EntityStopped, EntityStarted }
   import Shard.{ ShardQuery, GetCurrentShardState, CurrentShardState, GetShardStats, ShardStats }
   import akka.cluster.sharding.ShardCoordinator.Internal.CoordinatorMessage
   import akka.cluster.sharding.ShardRegion.ShardRegionCommand
@@ -151,7 +160,8 @@ private[akka] class Shard(
   }
 
   def receiveShardCommand(msg: ShardCommand): Unit = msg match {
-    case RestartEntity(id) ⇒ getEntity(id)
+    case RestartEntity(id)    ⇒ getEntity(id)
+    case RestartEntities(ids) ⇒ ids foreach getEntity
   }
 
   def receiveShardRegionCommand(msg: ShardRegionCommand): Unit = msg match {
@@ -313,8 +323,19 @@ private[akka] class PersistentShard(
   with PersistentActor with ActorLogging {
 
   import ShardRegion.{ EntityId, Msg }
-  import Shard.{ State, RestartEntity, EntityStopped, EntityStarted }
+  import Shard.{ State, RestartEntity, RestartEntities, EntityStopped, EntityStarted }
   import settings.tuningParameters._
+  import akka.pattern.pipe
+
+  val rememberedEntitiesRecoveryStrategy: EntityRecoveryStrategy =
+    entityRecoveryStrategy match {
+      case "all" ⇒ EntityRecoveryStrategy.allStrategy()
+      case "constant" ⇒ EntityRecoveryStrategy.constantStrategy(
+        context.system,
+        entityRecoveryConstantRateStrategyFrequency,
+        entityRecoveryConstantRateStrategyNumberOfEntities
+      )
+    }
 
   override def persistenceId = s"/sharding/${typeName}Shard/${shardId}"
 
@@ -344,7 +365,7 @@ private[akka] class PersistentShard(
     case EntityStopped(id)                 ⇒ state = state.copy(state.entities - id)
     case SnapshotOffer(_, snapshot: State) ⇒ state = snapshot
     case RecoveryCompleted ⇒
-      state.entities foreach getEntity
+      restartRememberedEntities()
       super.initialized()
       log.debug("Shard recovery completed {}", shardId)
   }
@@ -388,4 +409,45 @@ private[akka] class PersistentShard(
     }
   }
 
+  private def restartRememberedEntities(): Unit = {
+    rememberedEntitiesRecoveryStrategy.recoverEntities(state.entities).foreach { scheduledRecovery ⇒
+      import context.dispatcher
+      scheduledRecovery.filter(_.nonEmpty).map(RestartEntities).pipeTo(self)
+    }
+  }
+}
+
+object EntityRecoveryStrategy {
+  def allStrategy(): EntityRecoveryStrategy = new AllAtOnceEntityRecoveryStrategy()
+
+  def constantStrategy(actorSystem: ActorSystem, frequency: FiniteDuration, numberOfEntities: Int): EntityRecoveryStrategy =
+    new ConstantRateEntityRecoveryStrategy(actorSystem, frequency, numberOfEntities)
+}
+
+trait EntityRecoveryStrategy {
+  import ShardRegion.EntityId
+  import scala.concurrent.Future
+
+  def recoverEntities(entities: Set[EntityId]): Set[Future[Set[EntityId]]]
+}
+
+final class AllAtOnceEntityRecoveryStrategy extends EntityRecoveryStrategy {
+  import ShardRegion.EntityId
+  override def recoverEntities(entities: Set[EntityId]): Set[Future[Set[EntityId]]] =
+    if (entities.isEmpty) Set.empty else Set(Future.successful(entities))
+}
+
+final class ConstantRateEntityRecoveryStrategy(actorSystem: ActorSystem, frequency: FiniteDuration, numberOfEntities: Int) extends EntityRecoveryStrategy {
+  import ShardRegion.EntityId
+  import akka.pattern.after
+  import actorSystem.dispatcher
+
+  override def recoverEntities(entities: Set[EntityId]): Set[Future[Set[EntityId]]] =
+    entities.grouped(numberOfEntities).foldLeft((frequency, Set[Future[Set[EntityId]]]())) {
+      case ((interval, scheduledEntityIds), entityIds) ⇒
+        (interval + frequency, scheduledEntityIds + scheduleEntities(interval, entityIds))
+    }._2
+
+  private def scheduleEntities(interval: FiniteDuration, entityIds: Set[EntityId]) =
+    after(interval, actorSystem.scheduler)(Future.successful[Set[EntityId]](entityIds))
 }
diff --git a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardCoordinator.scala b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardCoordinator.scala
index 370a635f1f..3ba933ee7d 100644
--- a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardCoordinator.scala
+++ b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardCoordinator.scala
@@ -153,7 +153,7 @@ object ShardCoordinator {
           case (_, v) ⇒ v.filterNot(s ⇒ rebalanceInProgress(s))
         }.maxBy(_.size)
         if (mostShards.size - leastShards.size >= rebalanceThreshold)
-          Future.successful(Set(mostShards.head))
+          Future.successful(mostShards.take(maxSimultaneousRebalance - rebalanceInProgress.size).toSet)
         else
           emptyRebalanceResult
       } else emptyRebalanceResult
@@ -367,8 +367,8 @@ object ShardCoordinator {
     }
 
     def stoppingShard: Receive = {
-      case ShardStopped(shard) ⇒ done(ok = true)
-      case ReceiveTimeout      ⇒ done(ok = false)
+      case ShardStopped(`shard`) ⇒ done(ok = true)
+      case ReceiveTimeout        ⇒ done(ok = false)
     }
 
     def done(ok: Boolean): Unit = {
diff --git a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardRegion.scala b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardRegion.scala
index c73eeb8f64..5593191c06 100644
--- a/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardRegion.scala
+++ b/akka-cluster-sharding/src/main/scala/akka/cluster/sharding/ShardRegion.scala
@@ -413,8 +413,8 @@ class ShardRegion(
     case msg: CoordinatorMessage                 ⇒ receiveCoordinatorMessage(msg)
     case cmd: ShardRegionCommand                 ⇒ receiveCommand(cmd)
     case query: ShardRegionQuery                 ⇒ receiveQuery(query)
-    case msg if extractEntityId.isDefinedAt(msg) ⇒ deliverMessage(msg, sender())
     case msg: RestartShard                       ⇒ deliverMessage(msg, sender())
+    case msg if extractEntityId.isDefinedAt(msg) ⇒ deliverMessage(msg, sender())
   }
 
   def receiveClusterState(state: CurrentClusterState): Unit = {
@@ -454,7 +454,7 @@ class ShardRegion(
       regionByShard.get(shard) match {
         case Some(r) if r == self && ref != self ⇒
           // should not happen, inconsistency between ShardRegion and ShardCoordinator
-          throw new IllegalStateException(s"Unexpected change of shard [${shard}] from self to [${ref}]")
+          throw new IllegalStateException(s"Unexpected change of shard [$shard] from self to [$ref]")
         case _ ⇒
       }
       regionByShard = regionByShard.updated(shard, ref)
@@ -546,7 +546,7 @@ class ShardRegion(
   }
 
   def receiveTerminated(ref: ActorRef): Unit = {
-    if (coordinator.exists(_ == ref))
+    if (coordinator.contains(ref))
       coordinator = None
     else if (regions.contains(ref)) {
       val shards = regions(ref)
@@ -711,7 +711,7 @@ class ShardRegion(
           case Some(ref) ⇒
             log.debug("Forwarding request for shard [{}] to [{}]", shardId, ref)
             ref.tell(msg, snd)
-          case None if (shardId == null || shardId == "") ⇒
+          case None if shardId == null || shardId == "" ⇒
             log.warning("Shard must not be empty, dropping message [{}]", msg.getClass.getName)
             context.system.deadLetters ! msg
           case None ⇒
diff --git a/akka-cluster-sharding/src/multi-jvm/scala/akka/cluster/sharding/ClusterShardingSpec.scala b/akka-cluster-sharding/src/multi-jvm/scala/akka/cluster/sharding/ClusterShardingSpec.scala
index cc9e19b88a..36a251628d 100644
--- a/akka-cluster-sharding/src/multi-jvm/scala/akka/cluster/sharding/ClusterShardingSpec.scala
+++ b/akka-cluster-sharding/src/multi-jvm/scala/akka/cluster/sharding/ClusterShardingSpec.scala
@@ -114,7 +114,11 @@ object ClusterShardingSpec {
 
 }
 
-abstract class ClusterShardingSpecConfig(val mode: String) extends MultiNodeConfig {
+abstract class ClusterShardingSpecConfig(
+  val mode:                   String,
+  val entityRecoveryStrategy: String = "all")
+  extends MultiNodeConfig {
+
   val controller = role("controller")
   val first = role("first")
   val second = role("second")
@@ -144,6 +148,11 @@ abstract class ClusterShardingSpecConfig(val mode: String) extends MultiNodeConf
       entity-restart-backoff = 1s
       rebalance-interval = 2 s
       state-store-mode = "$mode"
+      entity-recovery-strategy = "$entityRecoveryStrategy"
+      entity-recovery-constant-rate-strategy {
+        frequency = 1 ms
+        number-of-entities = 1
+      }
       least-shard-allocation-strategy {
         rebalance-threshold = 2
         max-simultaneous-rebalance = 1
@@ -177,9 +186,19 @@ object ClusterShardingDocCode {
 
 object PersistentClusterShardingSpecConfig extends ClusterShardingSpecConfig("persistence")
 object DDataClusterShardingSpecConfig extends ClusterShardingSpecConfig("ddata")
+object PersistentClusterShardingWithEntityRecoverySpecConfig extends ClusterShardingSpecConfig(
+  "persistence",
+  "all"
+)
+object DDataClusterShardingWithEntityRecoverySpecConfig extends ClusterShardingSpecConfig(
+  "ddata",
+  "constant"
+)
 
 class PersistentClusterShardingSpec extends ClusterShardingSpec(PersistentClusterShardingSpecConfig)
 class DDataClusterShardingSpec extends ClusterShardingSpec(DDataClusterShardingSpecConfig)
+class PersistentClusterShardingWithEntityRecoverySpec extends ClusterShardingSpec(PersistentClusterShardingWithEntityRecoverySpecConfig)
+class DDataClusterShardingWithEntityRecoverySpec extends ClusterShardingSpec(DDataClusterShardingWithEntityRecoverySpecConfig)
 
 class PersistentClusterShardingMultiJvmNode1 extends PersistentClusterShardingSpec
 class PersistentClusterShardingMultiJvmNode2 extends PersistentClusterShardingSpec
@@ -197,6 +216,22 @@ class DDataClusterShardingMultiJvmNode5 extends DDataClusterShardingSpec
 class DDataClusterShardingMultiJvmNode6 extends DDataClusterShardingSpec
 class DDataClusterShardingMultiJvmNode7 extends DDataClusterShardingSpec
 
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode1 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode2 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode3 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode4 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode5 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode6 extends PersistentClusterShardingSpec
+class PersistentClusterShardingWithEntityRecoveryMultiJvmNode7 extends PersistentClusterShardingSpec
+
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode1 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode2 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode3 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode4 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode5 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode6 extends DDataClusterShardingSpec
+class DDataClusterShardingWithEntityRecoveryMultiJvmNode7 extends DDataClusterShardingSpec
+
 abstract class ClusterShardingSpec(config: ClusterShardingSpecConfig) extends MultiNodeSpec(config) with STMultiNodeSpec with ImplicitSender {
   import ClusterShardingSpec._
   import config._
diff --git a/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/AllAtOnceEntityRecoveryStrategySpec.scala b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/AllAtOnceEntityRecoveryStrategySpec.scala
new file mode 100644
index 0000000000..b9b7b2b562
--- /dev/null
+++ b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/AllAtOnceEntityRecoveryStrategySpec.scala
@@ -0,0 +1,37 @@
+package akka.cluster.sharding
+
+import akka.cluster.sharding.ShardRegion.EntityId
+import akka.testkit.AkkaSpec
+import scala.concurrent.{ Await, Future }
+import scala.concurrent.duration._
+import scala.language.postfixOps
+
+class AllAtOnceEntityRecoveryStrategySpec extends AkkaSpec {
+  val strategy = EntityRecoveryStrategy.allStrategy()
+
+  import system.dispatcher
+
+  "AllAtOnceEntityRecoveryStrategy" must {
+    "recover entities" in {
+      val entities = Set[EntityId]("1", "2", "3", "4", "5")
+      val startTime = System.currentTimeMillis()
+      val resultWithTimes = strategy.recoverEntities(entities).map(
+        _.map(entityIds ⇒ (entityIds, System.currentTimeMillis() - startTime))
+      )
+
+      val result = Await.result(Future.sequence(resultWithTimes), 4 seconds).toList.sortWith(_._2 < _._2)
+      result.size should ===(1)
+
+      val scheduledEntities = result.map(_._1)
+      scheduledEntities.head should ===(entities)
+
+      val times = result.map(_._2)
+      times.head should ===(0L +- 20L)
+    }
+
+    "not recover when no entities to recover" in {
+      val result = strategy.recoverEntities(Set[EntityId]())
+      result.size should ===(0)
+    }
+  }
+}
\ No newline at end of file
diff --git a/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/ConstantRateEntityRecoveryStrategySpec.scala b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/ConstantRateEntityRecoveryStrategySpec.scala
new file mode 100644
index 0000000000..454218ca0f
--- /dev/null
+++ b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/ConstantRateEntityRecoveryStrategySpec.scala
@@ -0,0 +1,45 @@
+package akka.cluster.sharding
+
+import akka.cluster.sharding.ShardRegion.EntityId
+import akka.testkit.AkkaSpec
+
+import scala.concurrent.{ Await, Future }
+import scala.concurrent.duration._
+import scala.language.postfixOps
+
+class ConstantRateEntityRecoveryStrategySpec extends AkkaSpec {
+
+  import system.dispatcher
+
+  val strategy = EntityRecoveryStrategy.constantStrategy(system, 500 millis, 2)
+
+  "ConstantRateEntityRecoveryStrategy" must {
+    "recover entities" in {
+      val entities = Set[EntityId]("1", "2", "3", "4", "5")
+      val startTime = System.currentTimeMillis()
+      val resultWithTimes = strategy.recoverEntities(entities).map(
+        _.map(entityIds ⇒ (entityIds, System.currentTimeMillis() - startTime))
+      )
+
+      val result = Await.result(Future.sequence(resultWithTimes), 4 seconds).toList.sortWith(_._2 < _._2)
+      result.size should ===(3)
+
+      val scheduledEntities = result.map(_._1)
+      scheduledEntities.head.size should ===(2)
+      scheduledEntities(1).size should ===(2)
+      scheduledEntities(2).size should ===(1)
+      scheduledEntities.foldLeft(Set[EntityId]())(_ ++ _) should ===(entities)
+
+      val times = result.map(_._2)
+
+      times.head should ===(500L +- 30L)
+      times(1) should ===(1000L +- 30L)
+      times(2) should ===(1500L +- 30L)
+    }
+
+    "not recover when no entities to recover" in {
+      val result = strategy.recoverEntities(Set[EntityId]())
+      result.size should ===(0)
+    }
+  }
+}
diff --git a/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/LeastShardAllocationStrategySpec.scala b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/LeastShardAllocationStrategySpec.scala
index 8717e9eb22..54fd1ef339 100644
--- a/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/LeastShardAllocationStrategySpec.scala
+++ b/akka-cluster-sharding/src/test/scala/akka/cluster/sharding/LeastShardAllocationStrategySpec.scala
@@ -31,14 +31,23 @@ class LeastShardAllocationStrategySpec extends AkkaSpec {
       Await.result(allocationStrategy.rebalance(allocations, Set.empty), 3.seconds) should ===(Set.empty[String])
 
       val allocations2 = allocations.updated(regionB, Vector("shard2", "shard3", "shard4"))
-      Await.result(allocationStrategy.rebalance(allocations2, Set.empty), 3.seconds) should ===(Set("shard2"))
+      Await.result(allocationStrategy.rebalance(allocations2, Set.empty), 3.seconds) should ===(Set("shard2", "shard3"))
       Await.result(allocationStrategy.rebalance(allocations2, Set("shard4")), 3.seconds) should ===(Set.empty[String])
 
       val allocations3 = allocations2.updated(regionA, Vector("shard1", "shard5", "shard6"))
       Await.result(allocationStrategy.rebalance(allocations3, Set("shard1")), 3.seconds) should ===(Set("shard2"))
     }
 
-    "must limit number of simultanious rebalance" in {
+    "rebalance multiple shards if max simultaneous rebalances is not exceeded" in {
+      val allocations = Map(
+        regionA → Vector("shard1"),
+        regionB → Vector("shard2", "shard3", "shard4", "shard5", "shard6"),
+        regionC → Vector.empty)
+
+      Await.result(allocationStrategy.rebalance(allocations, Set.empty), 3.seconds) should ===(Set("shard2", "shard3"))
+      Await.result(allocationStrategy.rebalance(allocations, Set("shard2", "shard3")), 3.seconds) should ===(Set.empty[String])
+    }
+    "limit number of simultaneous rebalance" in {
       val allocations = Map(
         regionA → Vector("shard1"),
         regionB → Vector("shard2", "shard3", "shard4", "shard5", "shard6"), regionC → Vector.empty)
diff --git a/akka-cluster-tools/src/main/scala/akka/cluster/singleton/ClusterSingletonManager.scala b/akka-cluster-tools/src/main/scala/akka/cluster/singleton/ClusterSingletonManager.scala
index 0383f294c3..848a91bc92 100644
--- a/akka-cluster-tools/src/main/scala/akka/cluster/singleton/ClusterSingletonManager.scala
+++ b/akka-cluster-tools/src/main/scala/akka/cluster/singleton/ClusterSingletonManager.scala
@@ -23,6 +23,7 @@ import akka.cluster.Member
 import akka.cluster.MemberStatus
 import akka.AkkaException
 import akka.actor.NoSerializationVerificationNeeded
+import akka.cluster.UniqueAddress
 
 object ClusterSingletonManagerSettings {
 
@@ -184,11 +185,11 @@ object ClusterSingletonManager {
     case object End extends State
 
     case object Uninitialized extends Data
-    final case class YoungerData(oldestOption: Option[Address]) extends Data
-    final case class BecomingOldestData(previousOldestOption: Option[Address]) extends Data
+    final case class YoungerData(oldestOption: Option[UniqueAddress]) extends Data
+    final case class BecomingOldestData(previousOldestOption: Option[UniqueAddress]) extends Data
     final case class OldestData(singleton: ActorRef, singletonTerminated: Boolean = false) extends Data
     final case class WasOldestData(singleton: ActorRef, singletonTerminated: Boolean,
-                                   newOldestOption: Option[Address]) extends Data
+                                   newOldestOption: Option[UniqueAddress]) extends Data
     final case class HandingOverData(singleton: ActorRef, handOverTo: Option[ActorRef]) extends Data
     case object EndData extends Data
     final case class DelayedMemberRemoved(member: Member)
@@ -205,9 +206,9 @@ object ClusterSingletonManager {
       /**
        * The first event, corresponding to CurrentClusterState.
        */
-      final case class InitialOldestState(oldest: Option[Address], safeToBeOldest: Boolean)
+      final case class InitialOldestState(oldest: Option[UniqueAddress], safeToBeOldest: Boolean)
 
-      final case class OldestChanged(oldest: Option[Address])
+      final case class OldestChanged(oldest: Option[UniqueAddress])
     }
 
     /**
@@ -245,14 +246,14 @@ object ClusterSingletonManager {
         block()
         val after = membersByAge.headOption
         if (before != after)
-          changes :+= OldestChanged(after.map(_.address))
+          changes :+= OldestChanged(after.map(_.uniqueAddress))
       }
 
       def handleInitial(state: CurrentClusterState): Unit = {
         membersByAge = immutable.SortedSet.empty(ageOrdering) union state.members.filter(m ⇒
           (m.status == MemberStatus.Up || m.status == MemberStatus.Leaving) && matchingRole(m))
         val safeToBeOldest = !state.members.exists { m ⇒ (m.status == MemberStatus.Down || m.status == MemberStatus.Exiting) }
-        val initial = InitialOldestState(membersByAge.headOption.map(_.address), safeToBeOldest)
+        val initial = InitialOldestState(membersByAge.headOption.map(_.uniqueAddress), safeToBeOldest)
         changes :+= initial
       }
 
@@ -376,7 +377,7 @@ class ClusterSingletonManager(
   import FSM.`→`
 
   val cluster = Cluster(context.system)
-  val selfAddressOption = Some(cluster.selfAddress)
+  val selfUniqueAddressOption = Some(cluster.selfUniqueAddress)
   import cluster.settings.LogInfo
 
   require(
@@ -406,13 +407,13 @@ class ClusterSingletonManager(
   var selfExited = false
 
   // keep track of previously removed members
-  var removed = Map.empty[Address, Deadline]
+  var removed = Map.empty[UniqueAddress, Deadline]
 
-  def addRemoved(address: Address): Unit =
-    removed += address → (Deadline.now + 15.minutes)
+  def addRemoved(node: UniqueAddress): Unit =
+    removed += node → (Deadline.now + 15.minutes)
 
   def cleanupOverdueNotMemberAnyMore(): Unit = {
-    removed = removed filter { case (address, deadline) ⇒ deadline.hasTimeLeft }
+    removed = removed filter { case (_, deadline) ⇒ deadline.hasTimeLeft }
   }
 
   def logInfo(message: String): Unit =
@@ -463,10 +464,10 @@ class ClusterSingletonManager(
 
     case Event(InitialOldestState(oldestOption, safeToBeOldest), _) ⇒
       oldestChangedReceived = true
-      if (oldestOption == selfAddressOption && safeToBeOldest)
+      if (oldestOption == selfUniqueAddressOption && safeToBeOldest)
         // oldest immediately
         gotoOldest()
-      else if (oldestOption == selfAddressOption)
+      else if (oldestOption == selfUniqueAddressOption)
         goto(BecomingOldest) using BecomingOldestData(None)
       else
         goto(Younger) using YoungerData(oldestOption)
@@ -475,22 +476,22 @@ class ClusterSingletonManager(
   when(Younger) {
     case Event(OldestChanged(oldestOption), YoungerData(previousOldestOption)) ⇒
       oldestChangedReceived = true
-      if (oldestOption == selfAddressOption) {
-        logInfo("Younger observed OldestChanged: [{} -> myself]", previousOldestOption)
+      if (oldestOption == selfUniqueAddressOption) {
+        logInfo("Younger observed OldestChanged: [{} -> myself]", previousOldestOption.map(_.address))
         previousOldestOption match {
           case None                                 ⇒ gotoOldest()
           case Some(prev) if removed.contains(prev) ⇒ gotoOldest()
           case Some(prev) ⇒
-            peer(prev) ! HandOverToMe
+            peer(prev.address) ! HandOverToMe
             goto(BecomingOldest) using BecomingOldestData(previousOldestOption)
         }
       } else {
-        logInfo("Younger observed OldestChanged: [{} -> {}]", previousOldestOption, oldestOption)
+        logInfo("Younger observed OldestChanged: [{} -> {}]", previousOldestOption.map(_.address), oldestOption.map(_.address))
         getNextOldestChanged()
         stay using YoungerData(oldestOption)
       }
 
-    case Event(MemberRemoved(m, _), _) if m.address == cluster.selfAddress ⇒
+    case Event(MemberRemoved(m, _), _) if m.uniqueAddress == cluster.selfUniqueAddress ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
 
@@ -498,11 +499,17 @@ class ClusterSingletonManager(
       scheduleDelayedMemberRemoved(m)
       stay
 
-    case Event(DelayedMemberRemoved(m), YoungerData(Some(previousOldest))) if m.address == previousOldest ⇒
+    case Event(DelayedMemberRemoved(m), YoungerData(Some(previousOldest))) if m.uniqueAddress == previousOldest ⇒
       logInfo("Previous oldest removed [{}]", m.address)
-      addRemoved(m.address)
+      addRemoved(m.uniqueAddress)
       // transition when OldestChanged
       stay using YoungerData(None)
+
+    case Event(HandOverToMe, _) ⇒
+      // this node was probably quickly restarted with same hostname:port,
+      // confirm that the old singleton instance has been stopped
+      sender() ! HandOverDone
+      stay
   }
 
   when(BecomingOldest) {
@@ -514,16 +521,16 @@ class ClusterSingletonManager(
       stay
 
     case Event(HandOverDone, BecomingOldestData(Some(previousOldest))) ⇒
-      if (sender().path.address == previousOldest)
+      if (sender().path.address == previousOldest.address)
         gotoOldest()
       else {
         logInfo(
           "Ignoring HandOverDone in BecomingOldest from [{}]. Expected previous oldest [{}]",
-          sender().path.address, previousOldest)
+          sender().path.address, previousOldest.address)
         stay
       }
 
-    case Event(MemberRemoved(m, _), _) if m.address == cluster.selfAddress ⇒
+    case Event(MemberRemoved(m, _), _) if m.uniqueAddress == cluster.selfUniqueAddress ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
 
@@ -531,26 +538,39 @@ class ClusterSingletonManager(
       scheduleDelayedMemberRemoved(m)
       stay
 
-    case Event(DelayedMemberRemoved(m), BecomingOldestData(Some(previousOldest))) if m.address == previousOldest ⇒
-      logInfo("Previous oldest [{}] removed", previousOldest)
-      addRemoved(m.address)
+    case Event(DelayedMemberRemoved(m), BecomingOldestData(Some(previousOldest))) if m.uniqueAddress == previousOldest ⇒
+      logInfo("Previous oldest [{}] removed", previousOldest.address)
+      addRemoved(m.uniqueAddress)
       gotoOldest()
 
-    case Event(TakeOverFromMe, BecomingOldestData(None)) ⇒
-      sender() ! HandOverToMe
-      stay using BecomingOldestData(Some(sender().path.address))
-
-    case Event(TakeOverFromMe, BecomingOldestData(Some(previousOldest))) ⇒
-      if (previousOldest == sender().path.address) sender() ! HandOverToMe
-      else logInfo(
-        "Ignoring TakeOver request in BecomingOldest from [{}]. Expected previous oldest [{}]",
-        sender().path.address, previousOldest)
-      stay
+    case Event(TakeOverFromMe, BecomingOldestData(previousOldestOption)) ⇒
+      val senderAddress = sender().path.address
+      // it would have been better to include the UniqueAddress in the TakeOverFromMe message,
+      // but can't change due to backwards compatibility
+      cluster.state.members.collectFirst { case m if m.address == senderAddress ⇒ m.uniqueAddress } match {
+        case None ⇒
+          // from unknown node, ignore
+          logInfo(
+            "Ignoring TakeOver request from unknown node in BecomingOldest from [{}].", senderAddress)
+          stay
+        case Some(senderUniqueAddress) ⇒
+          previousOldestOption match {
+            case Some(previousOldest) ⇒
+              if (previousOldest == senderUniqueAddress) sender() ! HandOverToMe
+              else logInfo(
+                "Ignoring TakeOver request in BecomingOldest from [{}]. Expected previous oldest [{}]",
+                sender().path.address, previousOldest.address)
+              stay
+            case None ⇒
+              sender() ! HandOverToMe
+              stay using BecomingOldestData(Some(senderUniqueAddress))
+          }
+      }
 
     case Event(HandOverRetry(count), BecomingOldestData(previousOldestOption)) ⇒
       if (count <= maxHandOverRetries) {
-        logInfo("Retry [{}], sending HandOverToMe to [{}]", count, previousOldestOption)
-        previousOldestOption foreach { peer(_) ! HandOverToMe }
+        logInfo("Retry [{}], sending HandOverToMe to [{}]", count, previousOldestOption.map(_.address))
+        previousOldestOption.foreach(node ⇒ peer(node.address) ! HandOverToMe)
         setTimer(HandOverRetryTimer, HandOverRetry(count + 1), handOverRetryInterval, repeat = false)
         stay()
       } else if (previousOldestOption forall removed.contains) {
@@ -582,16 +602,19 @@ class ClusterSingletonManager(
   when(Oldest) {
     case Event(OldestChanged(oldestOption), OldestData(singleton, singletonTerminated)) ⇒
       oldestChangedReceived = true
-      logInfo("Oldest observed OldestChanged: [{} -> {}]", cluster.selfAddress, oldestOption)
+      logInfo("Oldest observed OldestChanged: [{} -> {}]", cluster.selfAddress, oldestOption.map(_.address))
       oldestOption match {
-        case Some(a) if a == cluster.selfAddress ⇒
+        case Some(a) if a == cluster.selfUniqueAddress ⇒
           // already oldest
           stay
         case Some(a) if !selfExited && removed.contains(a) ⇒
+          // The member removal was not completed and the old removed node is considered
+          // oldest again. Safest is to terminate the singleton instance and goto Younger.
+          // This node will become oldest again when the other is removed again.
           gotoHandingOver(singleton, singletonTerminated, None)
         case Some(a) ⇒
           // send TakeOver request in case the new oldest doesn't know previous oldest
-          peer(a) ! TakeOverFromMe
+          peer(a.address) ! TakeOverFromMe
           setTimer(TakeOverRetryTimer, TakeOverRetry(1), handOverRetryInterval, repeat = false)
           goto(WasOldest) using WasOldestData(singleton, singletonTerminated, newOldestOption = Some(a))
         case None ⇒
@@ -610,8 +633,8 @@ class ClusterSingletonManager(
   when(WasOldest) {
     case Event(TakeOverRetry(count), WasOldestData(_, _, newOldestOption)) ⇒
       if (count <= maxTakeOverRetries) {
-        logInfo("Retry [{}], sending TakeOverFromMe to [{}]", count, newOldestOption)
-        newOldestOption foreach { peer(_) ! TakeOverFromMe }
+        logInfo("Retry [{}], sending TakeOverFromMe to [{}]", count, newOldestOption.map(_.address))
+        newOldestOption.foreach(node ⇒ peer(node.address) ! TakeOverFromMe)
         setTimer(TakeOverRetryTimer, TakeOverRetry(count + 1), handOverRetryInterval, repeat = false)
         stay
       } else if (cluster.isTerminated)
@@ -622,12 +645,12 @@ class ClusterSingletonManager(
     case Event(HandOverToMe, WasOldestData(singleton, singletonTerminated, _)) ⇒
       gotoHandingOver(singleton, singletonTerminated, Some(sender()))
 
-    case Event(MemberRemoved(m, _), _) if m.address == cluster.selfAddress && !selfExited ⇒
+    case Event(MemberRemoved(m, _), _) if m.uniqueAddress == cluster.selfUniqueAddress && !selfExited ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
 
-    case Event(MemberRemoved(m, _), WasOldestData(singleton, singletonTerminated, Some(newOldest))) if !selfExited && m.address == newOldest ⇒
-      addRemoved(m.address)
+    case Event(MemberRemoved(m, _), WasOldestData(singleton, singletonTerminated, Some(newOldest))) if !selfExited && m.uniqueAddress == newOldest ⇒
+      addRemoved(m.uniqueAddress)
       gotoHandingOver(singleton, singletonTerminated, None)
 
     case Event(Terminated(ref), d @ WasOldestData(singleton, _, _)) if ref == singleton ⇒
@@ -660,17 +683,17 @@ class ClusterSingletonManager(
     val newOldest = handOverTo.map(_.path.address)
     logInfo("Singleton terminated, hand-over done [{} -> {}]", cluster.selfAddress, newOldest)
     handOverTo foreach { _ ! HandOverDone }
-    if (removed.contains(cluster.selfAddress)) {
+    if (removed.contains(cluster.selfUniqueAddress)) {
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
-    } else if (selfExited)
-      goto(End) using EndData
+    } else if (handOverTo.isEmpty)
+      goto(Younger) using YoungerData(None)
     else
-      goto(Younger) using YoungerData(newOldest)
+      goto(End) using EndData
   }
 
   when(End) {
-    case Event(MemberRemoved(m, _), _) if m.address == cluster.selfAddress ⇒
+    case Event(MemberRemoved(m, _), _) if m.uniqueAddress == cluster.selfUniqueAddress ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
   }
@@ -678,21 +701,21 @@ class ClusterSingletonManager(
   whenUnhandled {
     case Event(_: CurrentClusterState, _) ⇒ stay
     case Event(MemberExited(m), _) ⇒
-      if (m.address == cluster.selfAddress) {
+      if (m.uniqueAddress == cluster.selfUniqueAddress) {
         selfExited = true
         logInfo("Exited [{}]", m.address)
       }
       stay
-    case Event(MemberRemoved(m, _), _) if m.address == cluster.selfAddress && !selfExited ⇒
+    case Event(MemberRemoved(m, _), _) if m.uniqueAddress == cluster.selfUniqueAddress && !selfExited ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       stop()
     case Event(MemberRemoved(m, _), _) ⇒
       if (!selfExited) logInfo("Member removed [{}]", m.address)
-      addRemoved(m.address)
+      addRemoved(m.uniqueAddress)
       stay
     case Event(DelayedMemberRemoved(m), _) ⇒
       if (!selfExited) logInfo("Member removed [{}]", m.address)
-      addRemoved(m.address)
+      addRemoved(m.uniqueAddress)
       stay
     case Event(TakeOverFromMe, _) ⇒
       logInfo("Ignoring TakeOver request in [{}] from [{}].", stateName, sender().path.address)
@@ -720,7 +743,7 @@ class ClusterSingletonManager(
   }
 
   onTransition {
-    case _ → (Younger | End) if removed.contains(cluster.selfAddress) ⇒
+    case _ → (Younger | End) if removed.contains(cluster.selfUniqueAddress) ⇒
       logInfo("Self removed, stopping ClusterSingletonManager")
       // note that FSM.stop() can't be used in onTransition
       context.stop(self)
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala
new file mode 100644
index 0000000000..e8c2f6d8b1
--- /dev/null
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala
@@ -0,0 +1,109 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.cluster.singleton
+
+import scala.concurrent.duration._
+
+import akka.actor.ActorSystem
+import akka.actor.PoisonPill
+import akka.cluster.Cluster
+import akka.cluster.MemberStatus
+import akka.testkit.AkkaSpec
+import akka.testkit.TestActors
+import akka.testkit.TestProbe
+import com.typesafe.config.ConfigFactory
+
+class ClusterSingletonRestartSpec extends AkkaSpec("""
+  akka.loglevel = INFO
+  akka.actor.provider = akka.cluster.ClusterActorRefProvider
+  akka.remote {
+    netty.tcp {
+      hostname = "127.0.0.1"
+      port = 0
+    }
+  }
+  """) {
+
+  val sys1 = ActorSystem(system.name, system.settings.config)
+  val sys2 = ActorSystem(system.name, system.settings.config)
+  var sys3: ActorSystem = null
+
+  def join(from: ActorSystem, to: ActorSystem): Unit = {
+    from.actorOf(
+      ClusterSingletonManager.props(
+        singletonProps = TestActors.echoActorProps,
+        terminationMessage = PoisonPill,
+        settings = ClusterSingletonManagerSettings(from)),
+      name = "echo")
+
+    within(10.seconds) {
+      awaitAssert {
+        Cluster(from) join Cluster(to).selfAddress
+        Cluster(from).state.members.map(_.uniqueAddress) should contain(Cluster(from).selfUniqueAddress)
+        Cluster(from).state.members.map(_.status) should ===(Set(MemberStatus.Up))
+      }
+    }
+  }
+
+  "Restarting cluster node with same hostname and port" must {
+    "hand-over to next oldest" in {
+      join(sys1, sys1)
+      join(sys2, sys1)
+
+      val proxy2 = sys2.actorOf(ClusterSingletonProxy.props("user/echo", ClusterSingletonProxySettings(sys2)), "proxy2")
+
+      within(5.seconds) {
+        awaitAssert {
+          val probe = TestProbe()(sys2)
+          proxy2.tell("hello", probe.ref)
+          probe.expectMsg(1.second, "hello")
+        }
+      }
+
+      shutdown(sys1)
+      // it will be downed by the join attempts of the new incarnation
+
+      sys3 = ActorSystem(
+        system.name,
+        ConfigFactory.parseString(s"akka.remote.netty.tcp.port=${Cluster(sys1).selfAddress.port.get}").withFallback(
+          system.settings.config))
+      join(sys3, sys2)
+
+      within(5.seconds) {
+        awaitAssert {
+          val probe = TestProbe()(sys2)
+          proxy2.tell("hello2", probe.ref)
+          probe.expectMsg(1.second, "hello2")
+        }
+      }
+
+      Cluster(sys2).leave(Cluster(sys2).selfAddress)
+
+      within(10.seconds) {
+        awaitAssert {
+          Cluster(sys3).state.members.map(_.uniqueAddress) should ===(Set(Cluster(sys3).selfUniqueAddress))
+        }
+      }
+
+      val proxy3 = sys3.actorOf(ClusterSingletonProxy.props("user/echo", ClusterSingletonProxySettings(sys3)), "proxy3")
+
+      within(5.seconds) {
+        awaitAssert {
+          val probe = TestProbe()(sys3)
+          proxy3.tell("hello3", probe.ref)
+          probe.expectMsg(1.second, "hello3")
+        }
+      }
+
+    }
+  }
+
+  override def afterTermination(): Unit = {
+    shutdown(sys1)
+    shutdown(sys2)
+    if (sys3 != null)
+      shutdown(sys3)
+  }
+}
+
diff --git a/akka-cluster/src/main/scala/akka/cluster/ClusterDaemon.scala b/akka-cluster/src/main/scala/akka/cluster/ClusterDaemon.scala
index d8c613114a..a65ca8cb24 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ClusterDaemon.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ClusterDaemon.scala
@@ -85,25 +85,25 @@ private[cluster] object InternalClusterAction {
    * If a node is uninitialized it will reply to `InitJoin` with
    * `InitJoinNack`.
    */
-  case object JoinSeedNode
+  case object JoinSeedNode extends DeadLetterSuppression
 
   /**
    * see JoinSeedNode
    */
   @SerialVersionUID(1L)
-  case object InitJoin extends ClusterMessage
+  case object InitJoin extends ClusterMessage with DeadLetterSuppression
 
   /**
    * see JoinSeedNode
    */
   @SerialVersionUID(1L)
-  final case class InitJoinAck(address: Address) extends ClusterMessage
+  final case class InitJoinAck(address: Address) extends ClusterMessage with DeadLetterSuppression
 
   /**
    * see JoinSeedNode
    */
   @SerialVersionUID(1L)
-  final case class InitJoinNack(address: Address) extends ClusterMessage
+  final case class InitJoinNack(address: Address) extends ClusterMessage with DeadLetterSuppression
 
   /**
    * Marker interface for periodic tick messages
@@ -508,8 +508,15 @@ private[cluster] class ClusterCoreDaemon(publisher: ActorRef) extends Actor with
           // new node will retry join
           logInfo("New incarnation of existing member [{}] is trying to join. " +
             "Existing will be removed from the cluster and then new member will be allowed to join.", m)
-          if (m.status != Down)
+          if (m.status != Down) {
+            // we can confirm it as terminated/unreachable immediately
+            val newReachability = latestGossip.overview.reachability.terminated(selfUniqueAddress, m.uniqueAddress)
+            val newOverview = latestGossip.overview.copy(reachability = newReachability)
+            val newGossip = latestGossip.copy(overview = newOverview)
+            updateLatestGossip(newGossip)
+
             downing(m.address)
+          }
         case None ⇒
           // remove the node from the failure detector
           failureDetector.remove(node.address)
@@ -609,7 +616,7 @@ private[cluster] class ClusterCoreDaemon(publisher: ActorRef) extends Actor with
         publish(latestGossip)
       case Some(_) ⇒ // already down
       case None ⇒
-        logInfo("Ignoring down of unknown node [{}] as [{}]", address)
+        logInfo("Ignoring down of unknown node [{}]", address)
     }
 
   }
@@ -1259,10 +1266,10 @@ private[cluster] class OnMemberStatusChangedListener(callback: Runnable, status:
   import ClusterEvent._
   private val cluster = Cluster(context.system)
   private val to = status match {
-    case Up ⇒
-      classOf[MemberUp]
-    case Removed ⇒
-      classOf[MemberRemoved]
+    case Up      ⇒ classOf[MemberUp]
+    case Removed ⇒ classOf[MemberRemoved]
+    case other ⇒ throw new IllegalArgumentException(
+      s"Expected Up or Removed in OnMemberStatusChangedListener, got [$other]")
   }
 
   override def preStart(): Unit =
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
index ef56dc19cf..564eb27d29 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
@@ -74,12 +74,15 @@ abstract class NodeChurnSpec
     }
   }
 
-  def awaitRemoved(additionaSystems: Vector[ActorSystem]): Unit = {
+  def awaitRemoved(additionaSystems: Vector[ActorSystem], round: Int): Unit = {
     awaitMembersUp(roles.size, timeout = 40.seconds)
-    within(20.seconds) {
+    enterBarrier("removed-" + round)
+    within(3.seconds) {
       awaitAssert {
         additionaSystems.foreach { s ⇒
-          Cluster(s).isTerminated should be(true)
+          withClue(s"Cluster(s).self:") {
+            Cluster(s).isTerminated should be(true)
+          }
         }
       }
     }
@@ -113,7 +116,7 @@ abstract class NodeChurnSpec
           else
             Cluster(node).leave(Cluster(node).selfAddress)
         }
-        awaitRemoved(systems)
+        awaitRemoved(systems, n)
         enterBarrier("members-removed-" + n)
         systems.foreach(_.terminate().await)
         log.info("end of round-" + n)
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/SurviveNetworkInstabilitySpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/SurviveNetworkInstabilitySpec.scala
index f493be218c..eeeedb7301 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/SurviveNetworkInstabilitySpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/SurviveNetworkInstabilitySpec.scala
@@ -330,9 +330,19 @@ abstract class SurviveNetworkInstabilitySpec
       runOn(side1AfterJoin: _*) {
         // side2 removed
         val expected = (side1AfterJoin map address).toSet
-        awaitAssert(clusterView.members.map(_.address) should ===(expected))
-        awaitAssert(clusterView.members.collectFirst { case m if m.address == address(eighth) ⇒ m.status } should ===(
-          Some(MemberStatus.Up)))
+        awaitAssert {
+          // repeat the downing in case it was not successful, which may
+          // happen if the removal was reverted due to gossip merge, see issue #18767
+          runOn(fourth) {
+            for (role2 ← side2) {
+              cluster.down(role2)
+            }
+          }
+
+          clusterView.members.map(_.address) should ===(expected)
+          clusterView.members.collectFirst { case m if m.address == address(eighth) ⇒ m.status } should ===(
+            Some(MemberStatus.Up))
+        }
       }
 
       enterBarrier("side2-removed")
diff --git a/akka-contrib/src/test/scala/akka/contrib/pattern/ReceivePipelineSpec.scala b/akka-contrib/src/test/scala/akka/contrib/pattern/ReceivePipelineSpec.scala
index 77b2a2ff4c..5a80ee6cb5 100644
--- a/akka-contrib/src/test/scala/akka/contrib/pattern/ReceivePipelineSpec.scala
+++ b/akka-contrib/src/test/scala/akka/contrib/pattern/ReceivePipelineSpec.scala
@@ -326,7 +326,7 @@ class PersistentReceivePipelineSpec(config: Config) extends AkkaSpec(config) wit
       totaller ! 6
       totaller ! "get"
       expectMsg(6)
-      probe.expectMsg(99)
+      probe.expectMsg(99L)
     }
   }
 }
diff --git a/akka-distributed-data/src/main/scala/akka/cluster/ddata/Replicator.scala b/akka-distributed-data/src/main/scala/akka/cluster/ddata/Replicator.scala
index 8ccb288c0e..74a4d43553 100644
--- a/akka-distributed-data/src/main/scala/akka/cluster/ddata/Replicator.scala
+++ b/akka-distributed-data/src/main/scala/akka/cluster/ddata/Replicator.scala
@@ -276,14 +276,14 @@ object Replicator {
   final case class Subscribe[A <: ReplicatedData](key: Key[A], subscriber: ActorRef) extends ReplicatorMessage
   /**
    * Unregister a subscriber.
-    *
-    * @see [[Replicator.Subscribe]]
+   *
+   * @see [[Replicator.Subscribe]]
    */
   final case class Unsubscribe[A <: ReplicatedData](key: Key[A], subscriber: ActorRef) extends ReplicatorMessage
   /**
    * The data value is retrieved with [[#get]] using the typed key.
-    *
-    * @see [[Replicator.Subscribe]]
+   *
+   * @see [[Replicator.Subscribe]]
    */
   final case class Changed[A <: ReplicatedData](key: Key[A])(data: A) extends ReplicatorMessage {
     /**
diff --git a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorPruningSpec.scala b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorPruningSpec.scala
index 10c57cc006..dcc25e9a22 100644
--- a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorPruningSpec.scala
+++ b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorPruningSpec.scala
@@ -42,7 +42,7 @@ class ReplicatorPruningSpec extends MultiNodeSpec(ReplicatorPruningSpec) with ST
   val replicator = system.actorOf(Replicator.props(
     ReplicatorSettings(system).withGossipInterval(1.second)
       .withPruning(pruningInterval = 1.second, maxPruningDissemination)), "replicator")
-  val timeout = 2.seconds.dilated
+  val timeout = 3.seconds.dilated
 
   val KeyA = GCounterKey("A")
   val KeyB = ORSetKey[String]("B")
diff --git a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorSpec.scala b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorSpec.scala
index 78efdb3a46..d4407634d6 100644
--- a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorSpec.scala
+++ b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/ReplicatorSpec.scala
@@ -41,7 +41,7 @@ class ReplicatorSpec extends MultiNodeSpec(ReplicatorSpec) with STMultiNodeSpec
   implicit val cluster = Cluster(system)
   val replicator = system.actorOf(Replicator.props(
     ReplicatorSettings(system).withGossipInterval(1.second).withMaxDeltaElements(10)), "replicator")
-  val timeout = 2.seconds.dilated
+  val timeout = 3.seconds.dilated
   val writeTwo = WriteTo(2, timeout)
   val writeMajority = WriteMajority(timeout)
   val writeAll = WriteAll(timeout)
@@ -112,7 +112,7 @@ class ReplicatorSpec extends MultiNodeSpec(ReplicatorSpec) with STMultiNodeSpec
         val c4 = c3 + 1
         // too strong consistency level
         replicator ! Update(KeyA, GCounter(), writeTwo)(_ + 1)
-        expectMsg(UpdateTimeout(KeyA, None))
+        expectMsg(timeout + 1.second, UpdateTimeout(KeyA, None))
         replicator ! Get(KeyA, ReadLocal)
         expectMsg(GetSuccess(KeyA, None)(c4)).dataValue should be(c4)
         changedProbe.expectMsg(Changed(KeyA)(c4)).dataValue should be(c4)
@@ -347,9 +347,9 @@ class ReplicatorSpec extends MultiNodeSpec(ReplicatorSpec) with STMultiNodeSpec
       val c40 = expectMsgPF() { case g @ GetSuccess(KeyD, _) ⇒ g.get(KeyD) }
       c40.value should be(40)
       replicator ! Update(KeyD, GCounter() + 1, writeTwo)(_ + 1)
-      expectMsg(UpdateTimeout(KeyD, None))
+      expectMsg(timeout + 1.second, UpdateTimeout(KeyD, None))
       replicator ! Update(KeyD, GCounter(), writeTwo)(_ + 1)
-      expectMsg(UpdateTimeout(KeyD, None))
+      expectMsg(timeout + 1.second, UpdateTimeout(KeyD, None))
     }
     runOn(first) {
       for (n ← 1 to 30) {
@@ -466,7 +466,7 @@ class ReplicatorSpec extends MultiNodeSpec(ReplicatorSpec) with STMultiNodeSpec
 
     runOn(first, second) {
       replicator ! Get(KeyE2, readAll, Some(998))
-      expectMsg(GetFailure(KeyE2, Some(998)))
+      expectMsg(timeout + 1.second, GetFailure(KeyE2, Some(998)))
       replicator ! Get(KeyE2, ReadLocal)
       expectMsg(NotFound(KeyE2, None))
     }
diff --git a/akka-docs/_sphinx/themes/akka/layout.html b/akka-docs/_sphinx/themes/akka/layout.html
index 0fdb57b588..22e0dd9c44 100644
--- a/akka-docs/_sphinx/themes/akka/layout.html
+++ b/akka-docs/_sphinx/themes/akka/layout.html
@@ -86,7 +86,7 @@
         </div>
         <ul class="nav">
           <li><a href="http://akka.io/docs">Documentation</a></li>
-          <li><a href="http://akka.io/faq">FAQ</a></li>
+          <li><a href="http://doc.akka.io/docs/akka/current/additional/faq.html">FAQ</a></li>
           <li><a href="http://akka.io/downloads">Download</a></li>
           <li><a href="http://groups.google.com/group/akka-user">Mailing List</a></li>
           <li><a href="http://github.com/akka/akka">Code</a></li>
@@ -158,7 +158,7 @@
     <ul>
       <li><h5>Akka</h5></li>
       <li><a href="http://akka.io/docs">Documentation</a></li>
-      <li><a href="http://akka.io/faq">FAQ</a></li>
+      <li><a href="http://doc.akka.io/docs/akka/current/additional/faq.html">FAQ</a></li>
       <li><a href="http://akka.io/downloads">Downloads</a></li>
       <li><a href="http://akka.io/news">News</a></li>
       <li><a href="http://letitcrash.com">Blog</a></li>
diff --git a/akka-docs/rst/common/code/docs/circuitbreaker/DangerousJavaActor.java b/akka-docs/rst/common/code/docs/circuitbreaker/DangerousJavaActor.java
index f7eba2708f..92cfaba185 100644
--- a/akka-docs/rst/common/code/docs/circuitbreaker/DangerousJavaActor.java
+++ b/akka-docs/rst/common/code/docs/circuitbreaker/DangerousJavaActor.java
@@ -51,27 +51,16 @@ public class DangerousJavaActor extends UntypedActor {
     if (message instanceof String) {
       String m = (String) message;
       if ("is my middle name".equals(m)) {
-        pipe(breaker.callWithCircuitBreaker(
-          new Callable<Future<String>>() {
-            public Future<String> call() throws Exception {
-              return future(
-                      new Callable<String>() {
-                          public String call() {
-                            return dangerousCall();
-                          }
-                        }, getContext().dispatcher());
-            }
-          }), getContext().dispatcher()).to(getSender());
+        pipe(
+          breaker.callWithCircuitBreaker(() -> 
+            future(() -> dangerousCall(), getContext().dispatcher())
+          ), getContext().dispatcher()
+        ).to(getSender());
       }
       if ("block for me".equals(m)) {
         getSender().tell(breaker
           .callWithSyncCircuitBreaker(
-            new Callable<String>() {
-              @Override
-              public String call() throws Exception {
-                return dangerousCall();
-              }
-            }), getSelf());
+            () -> dangerousCall()), getSelf());
       }
     }
   }
diff --git a/akka-docs/rst/general/addressing.rst b/akka-docs/rst/general/addressing.rst
index 0768dc82b4..9edbe6297d 100644
--- a/akka-docs/rst/general/addressing.rst
+++ b/akka-docs/rst/general/addressing.rst
@@ -107,8 +107,8 @@ actors in the hierarchy from the root up. Examples are::
   "akka://my-sys/user/service-a/worker1"                   // purely local
   "akka.tcp://my-sys@host.example.com:5678/user/service-b" // remote
 
-Here, ``akka.tcp`` is the default remote transport for the 2.2 release; other transports
-are pluggable. A remote host using UDP would be accessible by using ``akka.udp``.
+Here, ``akka.tcp`` is the default remote transport for the 2.4 release; other transports
+are pluggable.
 The interpretation of the host and port part (i.e. ``host.example.com:5678`` in the example)
 depends on the transport mechanism used, but it must abide by the URI structural rules.
 
diff --git a/akka-docs/rst/general/code/docs/config/ConfigDocSpec.scala b/akka-docs/rst/general/code/docs/config/ConfigDocSpec.scala
index a7cdac465f..4f9796867d 100644
--- a/akka-docs/rst/general/code/docs/config/ConfigDocSpec.scala
+++ b/akka-docs/rst/general/code/docs/config/ConfigDocSpec.scala
@@ -46,6 +46,12 @@ class ConfigDocSpec extends WordSpec with Matchers {
     "/actorC/*" {
       dispatcher = my-dispatcher
     }
+
+    # all descendants of '/user/actorC' (direct children, and their children recursively)
+    # have a dedicated dispatcher
+    "/actorC/**" {
+      dispatcher = my-dispatcher
+    }
     
     # '/user/actorD/actorE' has a special priority mailbox
     /actorD/actorE {
diff --git a/akka-docs/rst/general/configuration.rst b/akka-docs/rst/general/configuration.rst
index c8df1b3a2e..ffaf9549fc 100644
--- a/akka-docs/rst/general/configuration.rst
+++ b/akka-docs/rst/general/configuration.rst
@@ -413,10 +413,18 @@ topics. An example may look like this:
 
 You can use asterisks as wildcard matches for the actor path sections, so you could specify:
 ``/*/sampleActor`` and that would match all ``sampleActor`` on that level in the hierarchy.
-You can also use wildcard in the last position to match all actors at a certain level:
-``/someParent/*``. Non-wildcard matches always have higher priority to match than wildcards, so:
-``/foo/bar`` is considered **more specific** than ``/foo/*`` and only the highest priority match is used.
-Please note that it **cannot** be used to partially match section, like this: ``/foo*/bar``, ``/f*o/bar`` etc.
+In addition, please note:
+
+ - you can also use wildcards in the last position to match all actors at a certain level: ``/someParent/*``
+ - you can use double-wildcards in the last position to match all child actors and their children
+   recursively: ``/someParent/**``
+ - non-wildcard matches always have higher priority to match than wildcards, and single wildcard matches
+   have higher priority than double-wildcards, so: ``/foo/bar`` is considered **more specific** than
+   ``/foo/*``, which is considered **more specific** than ``/foo/**``. Only the highest priority match is used
+ - wildcards **cannot** be used to partially match section, like this: ``/foo*/bar``, ``/f*o/bar`` etc.
+
+.. note::
+    Double-wildcards can only be placed in the last position.
 
 Listing of the Reference Configuration
 --------------------------------------
diff --git a/akka-docs/rst/intro/getting-started.rst b/akka-docs/rst/intro/getting-started.rst
index 85d34100bd..08191b0006 100644
--- a/akka-docs/rst/intro/getting-started.rst
+++ b/akka-docs/rst/intro/getting-started.rst
@@ -37,7 +37,7 @@ Akka is very modular and consists of several JARs containing different features.
 
 - ``akka-cluster`` – Cluster membership management, elastic routers.
 
-- ``akka-osgi`` – utilities for using Akka in OSGi containers
+- ``akka-osgi`` – Utilities for using Akka in OSGi containers
 
 - ``akka-osgi-aries`` – Aries blueprint for provisioning actor systems
 
@@ -45,6 +45,8 @@ Akka is very modular and consists of several JARs containing different features.
 
 - ``akka-slf4j`` – SLF4J Logger (event bus listener)
 
+- ``akka-stream`` – Reactive stream processing
+
 - ``akka-testkit`` – Toolkit for testing Actor systems
 
 In addition to these stable modules there are several which are on their way
@@ -212,12 +214,12 @@ For snapshot versions, the snapshot repository needs to be added as well:
 Using Akka with Eclipse
 -----------------------
 
-Setup SBT project and then use `sbteclipse <https://github.com/typesafehub/sbteclipse>`_ to generate a Eclipse project.
+Setup SBT project and then use `sbteclipse <https://github.com/typesafehub/sbteclipse>`_ to generate an Eclipse project.
 
 Using Akka with IntelliJ IDEA
 -----------------------------
 
-Setup SBT project and then use `sbt-idea <https://github.com/mpeltonen/sbt-idea>`_ to generate a IntelliJ IDEA project.
+Setup SBT project and then use `sbt-idea <https://github.com/mpeltonen/sbt-idea>`_ to generate an IntelliJ IDEA project.
 
 Using Akka with NetBeans
 ------------------------
diff --git a/akka-docs/rst/intro/what-is-akka.rst b/akka-docs/rst/intro/what-is-akka.rst
index 808b4f1278..2361b06dcf 100644
--- a/akka-docs/rst/intro/what-is-akka.rst
+++ b/akka-docs/rst/intro/what-is-akka.rst
@@ -60,7 +60,7 @@ and :ref:`Scala <cluster_usage_scala>` documentation chapters.
 Persistence
 -----------
 
-State changes experience by an actor can optionally be persisted and replayed when the actor is started or
+State changes experienced by an actor can optionally be persisted and replayed when the actor is started or
 restarted. This allows actors to recover their state, even after JVM crashes or when being migrated
 to another node.
 
diff --git a/akka-docs/rst/intro/why-akka.rst b/akka-docs/rst/intro/why-akka.rst
index f5556bbf1c..c25e982ef2 100644
--- a/akka-docs/rst/intro/why-akka.rst
+++ b/akka-docs/rst/intro/why-akka.rst
@@ -19,7 +19,7 @@ but also in the size of applications it is useful for. The core of Akka, akka-ac
 is very small and easily dropped into an existing project where you need
 asynchronicity and lockless concurrency without hassle.
 
-You can choose to include only the parts of akka you need in your application.
+You can choose to include only the parts of Akka you need in your application.
 With CPUs growing more and more cores every cycle, Akka is the alternative that
 provides outstanding performance even if you're only running it on one machine.
 Akka also supplies a wide array of concurrency-paradigms, allowing users to choose
diff --git a/akka-docs/rst/java/camel.rst b/akka-docs/rst/java/camel.rst
index 96ff9e468c..919fbc133e 100644
--- a/akka-docs/rst/java/camel.rst
+++ b/akka-docs/rst/java/camel.rst
@@ -281,7 +281,7 @@ Actors may also use a Camel `ProducerTemplate`_ for producing messages to endpoi
 
 .. includecode:: code/docs/camel/MyActor.java#ProducerTemplate
 
-For initiating a a two-way message exchange, one of the
+For initiating a two-way message exchange, one of the
 ``ProducerTemplate.request*`` methods must be used.
 
 .. includecode:: code/docs/camel/RequestBodyActor.java#RequestProducerTemplate
diff --git a/akka-docs/rst/java/cluster-metrics.rst b/akka-docs/rst/java/cluster-metrics.rst
index 68e70effbb..3f8dfeaa13 100644
--- a/akka-docs/rst/java/cluster-metrics.rst
+++ b/akka-docs/rst/java/cluster-metrics.rst
@@ -14,7 +14,7 @@ Cluster metrics information is primarily used for load-balancing routers,
 and can also be used to implement advanced metrics-based node life cycles,
 such as "Node Let-it-crash" when CPU steal time becomes excessive.
 
-Cluster Metrics Extension is a separate akka module delivered in ``akka-cluster-metrics`` jar.
+Cluster Metrics Extension is a separate Akka module delivered in ``akka-cluster-metrics`` jar.
 
 To enable usage of the extension you need to add the following dependency to your project:
 ::
diff --git a/akka-docs/rst/java/cluster-sharding.rst b/akka-docs/rst/java/cluster-sharding.rst
index 75edd1145f..aa130ddc8f 100644
--- a/akka-docs/rst/java/cluster-sharding.rst
+++ b/akka-docs/rst/java/cluster-sharding.rst
@@ -270,8 +270,8 @@ Note that stopped entities will be started again when a new message is targeted
 Graceful Shutdown
 -----------------
 
-You can send the message ``ClusterSharding.GracefulShutdown`` message (``ClusterSharding.gracefulShutdownInstance``
-in Java) to the ``ShardRegion`` actor to handoff all shards that are hosted by that ``ShardRegion`` and then the
+You can send the ``ShardRegion.gracefulShutdownInstance`` message
+to the ``ShardRegion`` actor to handoff all shards that are hosted by that ``ShardRegion`` and then the
 ``ShardRegion`` actor will be stopped. You can ``watch`` the ``ShardRegion`` actor to know when it is completed.
 During this period other regions will buffer messages for those shards in the same way as when a rebalance is
 triggered by the coordinator. When the shards have been stopped the coordinator will allocate these shards elsewhere.
diff --git a/akka-docs/rst/java/cluster-usage.rst b/akka-docs/rst/java/cluster-usage.rst
index bcc9ea092c..c7a521af80 100644
--- a/akka-docs/rst/java/cluster-usage.rst
+++ b/akka-docs/rst/java/cluster-usage.rst
@@ -733,3 +733,13 @@ For this purpose you can define a separate dispatcher to be used for the cluster
       parallelism-max = 4
     }
   }
+
+.. note::
+    Normally it should not be necessary to configure a separate dispatcher for the Cluster.
+    The default-dispatcher should be sufficient for performing the Cluster tasks, i.e. ``akka.cluster.use-dispatcher``
+    should not be changed. If you have Cluster related problems when using the default-dispatcher that is typically an
+    indication that you are running blocking or CPU intensive actors/tasks on the default-dispatcher.
+    Use dedicated dispatchers for such actors/tasks instead of running them on the default-dispatcher,
+    because that may starve system internal tasks.
+    Related config properties: ``akka.cluster.use-dispatcher = akka.cluster.cluster-dispatcher``.
+    Corresponding default values: ``akka.cluster.use-dispatcher =``.
\ No newline at end of file
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/FormFieldRequestValsExampleTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/FormFieldRequestValsExampleTest.java
index fc5ae71c28..546579d1ad 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/FormFieldRequestValsExampleTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/FormFieldRequestValsExampleTest.java
@@ -10,9 +10,9 @@ import org.junit.Test;
 import akka.http.javadsl.model.FormData;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.StringUnmarshallers;
-import akka.http.javadsl.server.StringUnmarshaller;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.japi.Pair;
 
@@ -72,4 +72,4 @@ public class FormFieldRequestValsExampleTest extends JUnitRouteTest {
   }
 
 
-}
\ No newline at end of file
+}
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/HttpServerExampleDocTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/HttpServerExampleDocTest.java
index d06236fd5b..1d6e7c9078 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/HttpServerExampleDocTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/HttpServerExampleDocTest.java
@@ -15,7 +15,7 @@ import akka.http.javadsl.marshallers.jackson.Jackson;
 import akka.http.javadsl.model.*;
 import akka.http.javadsl.model.headers.Connection;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.japi.function.Function;
 import akka.stream.ActorMaterializer;
 import akka.stream.IOResult;
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/JsonStreamingExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/JsonStreamingExamplesTest.java
new file mode 100644
index 0000000000..c43d6241e5
--- /dev/null
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/JsonStreamingExamplesTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package docs.http.javadsl.server;
+
+import akka.NotUsed;
+import akka.http.javadsl.common.CsvEntityStreamingSupport;
+import akka.http.javadsl.common.JsonEntityStreamingSupport;
+import akka.http.javadsl.marshallers.jackson.Jackson;
+import akka.http.javadsl.marshalling.Marshaller;
+import akka.http.javadsl.model.*;
+import akka.http.javadsl.model.headers.Accept;
+import akka.http.javadsl.server.*;
+import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.http.javadsl.testkit.TestRoute;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
+import akka.http.javadsl.common.EntityStreamingSupport;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
+import akka.stream.javadsl.Flow;
+import akka.stream.javadsl.Source;
+import akka.util.ByteString;
+import org.junit.Test;
+
+import java.util.concurrent.CompletionStage;
+
+public class JsonStreamingExamplesTest extends JUnitRouteTest {
+
+  //#routes
+  final Route tweets() {
+    //#formats
+    final Unmarshaller<ByteString, JavaTweet> JavaTweets = Jackson.byteStringUnmarshaller(JavaTweet.class);
+    //#formats
+
+    //#response-streaming
+    
+    // Step 1: Enable JSON streaming
+    // we're not using this in the example, but it's the simplest way to start:
+    // The default rendering is a JSON array: `[el, el, el , ...]`
+    final JsonEntityStreamingSupport jsonStreaming = EntityStreamingSupport.json();
+
+    // Step 1.1: Enable and customise how we'll render the JSON, as a compact array:
+    final ByteString start = ByteString.fromString("[");
+    final ByteString between = ByteString.fromString(",");
+    final ByteString end = ByteString.fromString("]");
+    final Flow<ByteString, ByteString, NotUsed> compactArrayRendering = 
+      Flow.of(ByteString.class).intersperse(start, between, end);
+    
+    final JsonEntityStreamingSupport compactJsonSupport = EntityStreamingSupport.json()
+      .withFramingRendererFlow(compactArrayRendering);
+
+
+    // Step 2: implement the route
+    final Route responseStreaming = path("tweets", () ->
+      get(() ->
+        parameter(StringUnmarshallers.INTEGER, "n", n -> {
+          final Source<JavaTweet, NotUsed> tws =
+            Source.repeat(new JavaTweet(12, "Hello World!")).take(n);
+          
+          // Step 3: call complete* with your source, marshaller, and stream rendering mode
+          return completeOKWithSource(tws, Jackson.marshaller(), compactJsonSupport);
+        })
+      )
+    );
+    //#response-streaming
+
+    //#incoming-request-streaming
+    final Route incomingStreaming = path("tweets", () ->
+      post(() ->
+        extractMaterializer(mat -> {
+          final JsonEntityStreamingSupport jsonSupport = EntityStreamingSupport.json();
+
+          return entityAsSourceOf(JavaTweets, jsonSupport, sourceOfTweets -> {
+              final CompletionStage<Integer> tweetsCount = sourceOfTweets.runFold(0, (acc, tweet) -> acc + 1, mat);
+              return onComplete(tweetsCount, c -> complete("Total number of tweets: " + c));
+            });
+          }
+        )
+      )  
+    );
+    //#incoming-request-streaming
+    
+    return responseStreaming.orElse(incomingStreaming);
+  }
+  
+  final Route csvTweets() {
+    //#csv-example
+    final Marshaller<JavaTweet, ByteString> renderAsCsv = 
+      Marshaller.withFixedContentType(ContentTypes.TEXT_CSV_UTF8, t -> 
+        ByteString.fromString(t.getId() + "," + t.getMessage())
+      );
+
+    final CsvEntityStreamingSupport compactJsonSupport = EntityStreamingSupport.csv();
+
+    final Route responseStreaming = path("tweets", () ->
+      get(() ->
+        parameter(StringUnmarshallers.INTEGER, "n", n -> {
+          final Source<JavaTweet, NotUsed> tws =
+            Source.repeat(new JavaTweet(12, "Hello World!")).take(n);
+          return completeWithSource(tws, renderAsCsv, compactJsonSupport);
+        })
+      )
+    );
+    //#csv-example
+    
+    return responseStreaming;
+  }
+  //#routes
+  
+  @Test
+  public void getTweetsTest() {
+    //#response-streaming
+    // tests:
+    final TestRoute routes = testRoute(tweets());
+    
+    // test happy path
+    final Accept acceptApplication = Accept.create(MediaRanges.create(MediaTypes.APPLICATION_JSON));
+    routes.run(HttpRequest.GET("/tweets?n=2").addHeader(acceptApplication))
+      .assertStatusCode(200)
+      .assertEntity("[{\"id\":12,\"message\":\"Hello World!\"},{\"id\":12,\"message\":\"Hello World!\"}]");
+
+    // test responses to potential errors
+    final Accept acceptText = Accept.create(MediaRanges.ALL_TEXT);
+    routes.run(HttpRequest.GET("/tweets?n=3").addHeader(acceptText))
+      .assertStatusCode(StatusCodes.NOT_ACCEPTABLE) // 406
+      .assertEntity("Resource representation is only available with these types:\napplication/json");
+    //#response-streaming
+  }
+  
+  @Test
+  public void csvExampleTweetsTest() {
+    //#response-streaming
+    // tests --------------------------------------------
+    final TestRoute routes = testRoute(csvTweets());
+    
+    // test happy path
+    final Accept acceptCsv = Accept.create(MediaRanges.create(MediaTypes.TEXT_CSV));
+    routes.run(HttpRequest.GET("/tweets?n=2").addHeader(acceptCsv))
+      .assertStatusCode(200)
+      .assertEntity("12,Hello World!\n" +
+        "12,Hello World!");
+
+    // test responses to potential errors
+    final Accept acceptText = Accept.create(MediaRanges.ALL_APPLICATION);
+    routes.run(HttpRequest.GET("/tweets?n=3").addHeader(acceptText))
+      .assertStatusCode(StatusCodes.NOT_ACCEPTABLE) // 406
+      .assertEntity("Resource representation is only available with these types:\ntext/csv; charset=UTF-8");
+    //#response-streaming
+  }
+
+  //#models
+  private static final class JavaTweet {
+    private int id; 
+    private String message;
+
+    public JavaTweet(int id, String message) {
+      this.id = id;
+      this.message = message;
+    }
+
+    public int getId() {
+      return id;
+    }
+
+    public void setId(int id) {
+      this.id = id;
+    }
+
+    public void setMessage(String message) {
+      this.message = message;
+    }
+
+    public String getMessage() {
+      return message;
+    }
+
+  }
+  //#models
+}
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java
index 21d7fcc471..0b93560be3 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java
@@ -3,6 +3,7 @@
  */
 package docs.http.javadsl.server.directives;
 
+import akka.NotUsed;
 import akka.actor.ActorSystem;
 import akka.dispatch.ExecutionContexts;
 import akka.event.Logging;
@@ -31,14 +32,17 @@ import akka.util.ByteString;
 import org.junit.Ignore;
 import org.junit.Test;
 import scala.concurrent.ExecutionContextExecutor;
+import scala.concurrent.duration.FiniteDuration;
 
 import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -785,4 +789,105 @@ public class BasicDirectivesExamplesTest extends JUnitRouteTest {
     //#extractUnmatchedPath
   }
 
+  @Test
+  public void testExtractRequestEntity() {
+    //#extractRequestEntity
+    final Route route = extractRequestEntity(entity ->
+      complete("Request entity content-type is " + entity.getContentType())
+    );
+
+    // tests:
+    testRoute(route).run(
+      HttpRequest.POST("/abc")
+        .withEntity(HttpEntities.create(ContentTypes.TEXT_PLAIN_UTF8, "req"))
+    ).assertEntity("Request entity content-type is text/plain; charset=UTF-8");
+    //#extractRequestEntity
+  }
+
+  @Test
+  public void testExtractDataBytes() {
+    //#extractDataBytes
+    final Route route = extractDataBytes(data -> {
+      final CompletionStage<Integer> sum = data.runFold(0, (acc, i) ->
+        acc + Integer.valueOf(i.utf8String()), materializer());
+      return onSuccess(() -> sum, s ->
+        complete(HttpResponse.create().withEntity(HttpEntities.create(s.toString()))));
+    });
+
+    // tests:
+    final Iterator iterator = Arrays.asList(
+      ByteString.fromString("1"),
+      ByteString.fromString("2"),
+      ByteString.fromString("3")).iterator();
+    final Source<ByteString, NotUsed> dataBytes = Source.fromIterator(() -> iterator);
+
+    testRoute(route).run(
+      HttpRequest.POST("abc")
+        .withEntity(HttpEntities.create(ContentTypes.TEXT_PLAIN_UTF8, dataBytes))
+    ).assertEntity("6");
+    //#extractDataBytes
+  }
+
+  @Test
+  public void testExtractStrictEntity() {
+    //#extractStrictEntity
+    final FiniteDuration timeout = FiniteDuration.create(3, TimeUnit.SECONDS);
+    final Route route = extractStrictEntity(timeout, strict ->
+      complete(strict.getData().utf8String())
+    );
+
+    // tests:
+    final Iterator iterator = Arrays.asList(
+      ByteString.fromString("1"),
+      ByteString.fromString("2"),
+      ByteString.fromString("3")).iterator();
+    final Source<ByteString, NotUsed> dataBytes = Source.fromIterator(() -> iterator);
+    testRoute(route).run(
+      HttpRequest.POST("/")
+        .withEntity(HttpEntities.create(ContentTypes.TEXT_PLAIN_UTF8, dataBytes))
+    ).assertEntity("123");
+    //#extractStrictEntity
+  }
+
+  @Test
+  public void testToStrictEntity() {
+    //#toStrictEntity
+    final FiniteDuration timeout = FiniteDuration.create(3, TimeUnit.SECONDS);
+    final Route route = toStrictEntity(timeout, () ->
+      extractRequest(req -> {
+        if (req.entity() instanceof HttpEntity.Strict) {
+          final HttpEntity.Strict strict = (HttpEntity.Strict)req.entity();
+          return complete("Request entity is strict, data=" + strict.getData().utf8String());
+        } else {
+          return complete("Ooops, request entity is not strict!");
+        }
+      })
+    );
+
+    // tests:
+    final Iterator iterator = Arrays.asList(
+      ByteString.fromString("1"),
+      ByteString.fromString("2"),
+      ByteString.fromString("3")).iterator();
+    final Source<ByteString, NotUsed> dataBytes = Source.fromIterator(() -> iterator);
+    testRoute(route).run(
+      HttpRequest.POST("/")
+        .withEntity(HttpEntities.create(ContentTypes.TEXT_PLAIN_UTF8, dataBytes))
+    ).assertEntity("Request entity is strict, data=123");
+    //#toStrictEntity
+  }
+
+  @Test
+  public void testExtractActorSystem() {
+    //#extractActorSystem
+    final Route route = extractActorSystem(actorSystem ->
+      complete("Actor System extracted, hash=" + actorSystem.hashCode())
+    );
+
+    // tests:
+    testRoute(route).run(HttpRequest.GET("/"))
+      .assertEntity("Actor System extracted, hash=" + system().hashCode());
+    //#extractActorSystem
+  }
+
 }
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CodingDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CodingDirectivesExamplesTest.java
index 0fde3f7599..3ba307ca1f 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CodingDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CodingDirectivesExamplesTest.java
@@ -7,7 +7,7 @@ import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.headers.AcceptEncoding;
 import akka.http.javadsl.model.headers.ContentEncoding;
 import akka.http.javadsl.model.headers.HttpEncodings;
-import akka.http.javadsl.server.Coder;
+import akka.http.javadsl.coding.Coder;
 import akka.http.javadsl.server.Rejections;
 import akka.http.javadsl.server.Route;
 import akka.http.javadsl.testkit.JUnitRouteTest;
@@ -16,7 +16,7 @@ import org.junit.Test;
 
 import java.util.Collections;
 
-import static akka.http.javadsl.server.Unmarshaller.entityToString;
+import static akka.http.javadsl.unmarshalling.Unmarshaller.entityToString;
 
 public class CodingDirectivesExamplesTest extends JUnitRouteTest {
 
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CustomHttpMethodExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CustomHttpMethodExamplesTest.java
new file mode 100644
index 0000000000..c98e4ef675
--- /dev/null
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/CustomHttpMethodExamplesTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package docs.http.javadsl.server.directives;
+
+import akka.NotUsed;
+import akka.actor.ActorSystem;
+import akka.event.LoggingAdapter;
+import akka.event.NoLogging;
+import akka.http.javadsl.ConnectHttp;
+import akka.http.javadsl.Http;
+import akka.http.javadsl.ServerBinding;
+import akka.http.javadsl.model.*;
+import akka.http.javadsl.server.Route;
+import akka.http.javadsl.settings.ParserSettings;
+import akka.http.javadsl.settings.ServerSettings;
+import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.stream.Materializer;
+import akka.stream.javadsl.Flow;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+
+import static akka.http.javadsl.model.HttpProtocols.HTTP_1_0;
+import static akka.http.javadsl.model.RequestEntityAcceptances.Expected;
+
+public class CustomHttpMethodExamplesTest extends JUnitRouteTest {
+
+  @Test
+  public void testComposition() throws InterruptedException, ExecutionException {
+    ActorSystem  system = system();
+    Materializer materializer = materializer();
+    LoggingAdapter loggingAdapter = NoLogging.getInstance();
+
+    int    port = 9090;
+    String host = "127.0.0.1";
+
+    //#customHttpMethod
+    HttpMethod BOLT =
+      HttpMethods.createCustom("BOLT", false, true, Expected);
+    final ParserSettings parserSettings =
+      ParserSettings.create(system).withCustomMethods(BOLT);
+    final ServerSettings serverSettings =
+      ServerSettings.create(system).withParserSettings(parserSettings);
+
+    final Route routes = route(
+      extractMethod( method ->
+        complete( "This is a " + method.name() + " request.")
+      )
+    );
+    final Flow<HttpRequest, HttpResponse, NotUsed> handler = routes.flow(system, materializer);
+    final Http http = Http.get(system);
+    final CompletionStage<ServerBinding> binding =
+      http.bindAndHandle(
+        handler,
+        ConnectHttp.toHost(host, port),
+        serverSettings,
+        loggingAdapter,
+        materializer);
+
+    HttpRequest request = HttpRequest.create()
+      .withUri("http://" + host + ":" + Integer.toString(port))
+      .withMethod(BOLT)
+      .withProtocol(HTTP_1_0);
+
+    CompletionStage<HttpResponse> response = http.singleRequest(request, materializer);
+    //#customHttpMethod
+
+    assertEquals(StatusCodes.OK, response.toCompletableFuture().get().status());
+    assertEquals(
+      "This is a BOLT request.",
+      response.toCompletableFuture().get().entity().toStrict(3000, materializer).toCompletableFuture().get().getData().utf8String()
+    );
+  }
+}
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java
index dee1e78d3d..4011d3b0c5 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java
@@ -16,9 +16,11 @@ import akka.http.javadsl.model.headers.Host;
 import akka.http.javadsl.server.Route;
 import akka.http.javadsl.server.RequestContext;
 import akka.http.javadsl.testkit.JUnitRouteTest;
+
 import java.util.function.Function;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
+
 import akka.http.javadsl.model.Uri;
 import akka.http.javadsl.model.headers.Location;
 import akka.http.javadsl.server.directives.DebuggingDirectives;
@@ -26,10 +28,13 @@ import akka.http.javadsl.server.directives.RouteDirectives;
 import akka.event.Logging;
 import akka.event.Logging.LogLevel;
 import akka.http.javadsl.server.directives.LogEntry;
+
 import java.util.List;
-import akka.http.scaladsl.server.Rejection;
+
+import akka.http.javadsl.server.Rejection;
 
 import static akka.event.Logging.InfoLevel;
+
 import java.util.stream.Collectors;
 import java.util.Optional;
 
@@ -39,18 +44,18 @@ public class DebuggingDirectivesExamplesTest extends JUnitRouteTest {
   public void testLogRequest() {
     //#logRequest
     // logs request with "get-user"
-    final Route routeBasicLogRequest = get(() -> 
+    final Route routeBasicLogRequest = get(() ->
       logRequest("get-user", () -> complete("logged")));
-    
+
     // logs request with "get-user" as Info
-    final Route routeBasicLogRequestAsInfo = get(() -> 
+    final Route routeBasicLogRequestAsInfo = get(() ->
       logRequest("get-user", InfoLevel(), () -> complete("logged")));
 
     // logs just the request method at info level
-    Function<HttpRequest, LogEntry> requestMethodAsInfo = (request) -> 
-      LogEntry.create(request.method().toString(), InfoLevel());
+    Function<HttpRequest, LogEntry> requestMethodAsInfo = (request) ->
+      LogEntry.create(request.method().name(), InfoLevel());
 
-    final Route routeUsingFunction = get(() -> 
+    final Route routeUsingFunction = get(() ->
       logRequest(requestMethodAsInfo, () -> complete("logged")));
 
     // tests:
@@ -63,32 +68,31 @@ public class DebuggingDirectivesExamplesTest extends JUnitRouteTest {
   public void testLogRequestResult() {
     //#logRequestResult
     // using logRequestResult
-
     // handle request to optionally generate a log entry
-    BiFunction<HttpRequest, HttpResponse, Optional<LogEntry>> requestMethodAsInfo = 
+    BiFunction<HttpRequest, HttpResponse, Optional<LogEntry>> requestMethodAsInfo =
       (request, response) ->
-        (response.status().isSuccess())  ? 
-            Optional.of(
-              LogEntry.create(
-                request.method().toString() + ":" + response.status().intValue(), 
-                InfoLevel()))
+        (response.status().isSuccess()) ?
+          Optional.of(
+            LogEntry.create(
+              request.method().name() + ":" + response.status().intValue(),
+              InfoLevel()))
           : Optional.empty(); // not a successful response
 
     // handle rejections to optionally generate a log entry
-    BiFunction<HttpRequest, List<Rejection>, Optional<LogEntry>> rejectionsAsInfo = 
+    BiFunction<HttpRequest, List<Rejection>, Optional<LogEntry>> rejectionsAsInfo =
       (request, rejections) ->
-        (!rejections.isEmpty())  ? 
+        (!rejections.isEmpty()) ?
           Optional.of(
             LogEntry.create(
-                rejections
+              rejections
                 .stream()
                 .map(Rejection::toString)
-                .collect(Collectors.joining(", ")), 
+                .collect(Collectors.joining(", ")),
               InfoLevel()))
           : Optional.empty(); // no rejections
 
     final Route route = get(() -> logRequestResultOptional(
-      requestMethodAsInfo, 
+      requestMethodAsInfo,
       rejectionsAsInfo,
       () -> complete("logged")));
     // tests:
@@ -109,16 +113,16 @@ public class DebuggingDirectivesExamplesTest extends JUnitRouteTest {
 
     // logs the result and the rejections as LogEntry
     Function<HttpResponse, LogEntry> showSuccessAsInfo = (response) ->
-      LogEntry.create(String.format("Response code '%d'", response.status().intValue()), 
+      LogEntry.create(String.format("Response code '%d'", response.status().intValue()),
         InfoLevel());
 
     Function<List<Rejection>, LogEntry> showRejectionAsInfo = (rejections) ->
       LogEntry.create(
         rejections
-        .stream()
-        .map(rejection->rejection.toString())
-        .collect(Collectors.joining(", ")), 
-      InfoLevel());
+          .stream()
+          .map(rejection -> rejection.toString())
+          .collect(Collectors.joining(", ")),
+        InfoLevel());
 
     final Route routeUsingFunction = get(() ->
       logResult(showSuccessAsInfo, showRejectionAsInfo, () -> complete("logged")));
@@ -128,4 +132,50 @@ public class DebuggingDirectivesExamplesTest extends JUnitRouteTest {
     //#logResult
   }
 
-}
\ No newline at end of file
+  @Test
+  public void testLogRequestResultWithResponseTime() {
+    //#logRequestResultWithResponseTime
+    // using logRequestResultOptional for generating Response Time
+    // handle request to optionally generate a log entry
+
+    BiFunction<HttpRequest, HttpResponse, Optional<LogEntry>> requestMethodAsInfo =
+      (request, response) -> {
+        Long requestTime = System.nanoTime();
+        return printResponseTime(request, response, requestTime);
+      };
+
+    // handle rejections to optionally generate a log entry
+    BiFunction<HttpRequest, List<Rejection>, Optional<LogEntry>> rejectionsAsInfo =
+      (request, rejections) ->
+        (!rejections.isEmpty()) ?
+          Optional.of(
+            LogEntry.create(
+              rejections
+                .stream()
+                .map(Rejection::toString)
+                .collect(Collectors.joining(", ")),
+              InfoLevel()))
+          : Optional.empty(); // no rejections
+
+    final Route route = get(() -> logRequestResultOptional(
+      requestMethodAsInfo,
+      rejectionsAsInfo,
+      () -> complete("logged")));
+    // tests:
+    testRoute(route).run(HttpRequest.GET("/")).assertEntity("logged");
+    //#logRequestResult
+  }
+
+  // A function for the logging of Time
+  public static Optional<LogEntry> printResponseTime(HttpRequest request, HttpResponse response, Long requestTime) {
+    if (response.status().isSuccess()) {
+      Long elapsedTime = (requestTime - System.nanoTime()) / 1000000;
+      return Optional.of(
+        LogEntry.create(
+          "Logged Request:" + request.method().name() + ":" + request.getUri() + ":" + response.status() + ":" + elapsedTime,
+          InfoLevel()));
+    } else {
+      return Optional.empty();  //not a successfull response
+    }
+  }
+}
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FileUploadDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FileUploadDirectivesExamplesTest.java
index 61a65f06e9..2af6f8362e 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FileUploadDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FileUploadDirectivesExamplesTest.java
@@ -6,7 +6,7 @@ package docs.http.javadsl.server.directives;
 import akka.http.impl.engine.rendering.BodyPartRenderer;
 import akka.http.javadsl.model.*;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.http.javadsl.server.directives.FileInfo;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.stream.javadsl.Framing;
@@ -14,8 +14,6 @@ import akka.stream.javadsl.Source;
 import akka.util.ByteString;
 import org.junit.Ignore;
 import org.junit.Test;
-import scala.concurrent.duration.Duration;
-import scala.concurrent.duration.FiniteDuration;
 
 import java.io.File;
 import java.nio.charset.Charset;
@@ -24,7 +22,6 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.CompletionStage;
-import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
 
 public class FileUploadDirectivesExamplesTest extends JUnitRouteTest {
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FormFieldDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FormFieldDirectivesExamplesTest.java
index 69c0e11239..bb8b685150 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FormFieldDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FormFieldDirectivesExamplesTest.java
@@ -7,7 +7,7 @@ import akka.http.javadsl.model.FormData;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.StatusCodes;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.japi.Pair;
 import org.junit.Test;
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FutureDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FutureDirectivesExamplesTest.java
index f40753ec13..23a4d58fdf 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FutureDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/FutureDirectivesExamplesTest.java
@@ -8,7 +8,7 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 
 import akka.http.javadsl.model.HttpRequest;
-import akka.http.javadsl.server.Marshaller;
+import akka.http.javadsl.marshalling.Marshaller;
 import akka.http.javadsl.server.Route;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.scaladsl.model.StatusCodes;
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/MiscDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/MiscDirectivesExamplesTest.java
index 0f36352b76..df44b9114b 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/MiscDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/MiscDirectivesExamplesTest.java
@@ -6,7 +6,7 @@ package docs.http.javadsl.server.directives;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.StatusCodes;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import org.junit.Test;
 
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/RangeDirectivesExamplesTest.java b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/RangeDirectivesExamplesTest.java
index 69c1358d9c..5dfe1ed0cb 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/directives/RangeDirectivesExamplesTest.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/directives/RangeDirectivesExamplesTest.java
@@ -11,7 +11,7 @@ import akka.http.javadsl.model.headers.ContentRange;
 import akka.http.javadsl.model.headers.Range;
 import akka.http.javadsl.model.headers.RangeUnits;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRouteResult;
 import akka.stream.ActorMaterializer;
@@ -19,6 +19,7 @@ import akka.util.ByteString;
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import org.junit.Test;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -68,16 +69,16 @@ public class RangeDirectivesExamplesTest extends JUnitRouteTest {
         try {
             final List<Multipart.ByteRanges.BodyPart> bodyParts =
                     completionStage.toCompletableFuture().get(3, TimeUnit.SECONDS);
-            assertResult(2, bodyParts.toArray().length);
+            assertEquals(2, bodyParts.toArray().length);
 
             final Multipart.ByteRanges.BodyPart part1 = bodyParts.get(0);
-            assertResult(bytes028Range, part1.getContentRange());
-            assertResult(ByteString.fromString("ABC"),
+            assertEquals(bytes028Range, part1.getContentRange());
+            assertEquals(ByteString.fromString("ABC"),
                     part1.toStrict(1000, materializer).toCompletableFuture().get().getEntity().getData());
 
             final Multipart.ByteRanges.BodyPart part2 = bodyParts.get(1);
-            assertResult(bytes678Range, part2.getContentRange());
-            assertResult(ByteString.fromString("GH"),
+            assertEquals(bytes678Range, part2.getContentRange());
+            assertEquals(ByteString.fromString("GH"),
                     part2.toStrict(1000, materializer).toCompletableFuture().get().getEntity().getData());
 
         } catch (Exception e) {
diff --git a/akka-docs/rst/java/code/docs/http/javadsl/server/testkit/MyAppService.java b/akka-docs/rst/java/code/docs/http/javadsl/server/testkit/MyAppService.java
index 88a82ee69b..bc9836fac8 100644
--- a/akka-docs/rst/java/code/docs/http/javadsl/server/testkit/MyAppService.java
+++ b/akka-docs/rst/java/code/docs/http/javadsl/server/testkit/MyAppService.java
@@ -11,7 +11,7 @@ import akka.http.javadsl.ConnectHttp;
 import akka.http.javadsl.Http;
 import akka.http.javadsl.server.AllDirectives;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.server.examples.simple.SimpleServerApp;
 import akka.stream.ActorMaterializer;
 
diff --git a/akka-docs/rst/java/code/docs/stream/GraphDSLDocTest.java b/akka-docs/rst/java/code/docs/stream/GraphDSLDocTest.java
index 51fe15ef40..58e3fa4a22 100644
--- a/akka-docs/rst/java/code/docs/stream/GraphDSLDocTest.java
+++ b/akka-docs/rst/java/code/docs/stream/GraphDSLDocTest.java
@@ -98,7 +98,7 @@ public class GraphDSLDocTest extends AbstractJavaTest {
         );
       // unconnected zip.out (!) => "The inlets [] and outlets [] must correspond to the inlets [] and outlets [ZipWith2.out]"
       //#simple-graph
-      fail("expected IllegalArgumentException");
+      org.junit.Assert.fail("expected IllegalArgumentException");
     } catch (IllegalArgumentException e) {
       assertTrue(e != null && e.getMessage() != null && e.getMessage().contains("must correspond to"));
     }
diff --git a/akka-docs/rst/java/code/docs/stream/GraphStageDocTest.java b/akka-docs/rst/java/code/docs/stream/GraphStageDocTest.java
index 1bce706cc9..feb30c8d9d 100644
--- a/akka-docs/rst/java/code/docs/stream/GraphStageDocTest.java
+++ b/akka-docs/rst/java/code/docs/stream/GraphStageDocTest.java
@@ -95,6 +95,40 @@ public class GraphStageDocTest extends AbstractJavaTest {
   }
   //#simple-source
 
+  //#simple-sink
+  public class StdoutSink extends GraphStage<SinkShape<Integer>> {
+    public final Inlet<Integer> in = Inlet.create("StdoutSink.in");
+
+    private final SinkShape<Integer> shape = SinkShape.of(in);
+    @Override
+    public SinkShape<Integer> shape() {
+      return shape;
+    }
+
+    @Override
+    public GraphStageLogic createLogic(Attributes inheritedAttributes) {
+      return new GraphStageLogic(shape()) {
+
+        // This requests one element at the Sink startup.
+        @Override
+        public void preStart() {
+          pull(in);
+        }
+
+        {
+          setHandler(in, new AbstractInHandler() {
+            @Override
+            public void onPush() throws Exception {
+              Integer element = grab(in);
+              System.out.println(element);
+              pull(in);
+            }
+          });
+        }
+      };
+    }
+  }
+  //#simple-sink
 
   @Test
   public void demonstrateCustomSourceUsage() throws Exception {
@@ -116,6 +150,14 @@ public class GraphStageDocTest extends AbstractJavaTest {
     assertEquals(result2.toCompletableFuture().get(3, TimeUnit.SECONDS), (Integer) 5050);
   }
 
+  @Test
+  public void demonstrateCustomSinkUsage() throws Exception {
+    Graph<SinkShape<Integer>, NotUsed> sinkGraph = new StdoutSink();
+
+    Sink<Integer, NotUsed> mySink = Sink.fromGraph(sinkGraph);
+
+    Source.from(Arrays.asList(1, 2, 3)).runWith(mySink, mat);
+  }
 
   //#one-to-one
   public class Map<A, B> extends GraphStage<FlowShape<A, B>> {
diff --git a/akka-docs/rst/java/code/docs/stream/StreamBuffersRateDocTest.java b/akka-docs/rst/java/code/docs/stream/StreamBuffersRateDocTest.java
index a1383e6626..0adc78c863 100644
--- a/akka-docs/rst/java/code/docs/stream/StreamBuffersRateDocTest.java
+++ b/akka-docs/rst/java/code/docs/stream/StreamBuffersRateDocTest.java
@@ -65,7 +65,7 @@ public class StreamBuffersRateDocTest extends AbstractJavaTest {
     final Flow<Integer, Integer, NotUsed> flow1 =
       Flow.of(Integer.class)
       .map(elem -> elem * 2).async()
-      .withAttributes(Attributes.inputBuffer(1, 1)); // the buffer size of this map is 1
+      .addAttributes(Attributes.inputBuffer(1, 1)); // the buffer size of this map is 1
     final Flow<Integer, Integer, NotUsed> flow2 =
       flow1.via(
         Flow.of(Integer.class)
diff --git a/akka-docs/rst/java/code/docs/stream/javadsl/cookbook/RecipeByteStrings.java b/akka-docs/rst/java/code/docs/stream/javadsl/cookbook/RecipeByteStrings.java
index 81ff223327..f9c7255473 100644
--- a/akka-docs/rst/java/code/docs/stream/javadsl/cookbook/RecipeByteStrings.java
+++ b/akka-docs/rst/java/code/docs/stream/javadsl/cookbook/RecipeByteStrings.java
@@ -100,8 +100,15 @@ public class RecipeByteStrings extends RecipeTest {
                 @Override
                 public void onUpstreamFinish() throws Exception {
                   if (buffer.isEmpty()) completeStage();
-                  // elements left in buffer, keep accepting downstream pulls
-                  // and push from buffer until buffer is emitted
+                  else {
+                    // There are elements left in buffer, so
+                    // we keep accepting downstream pulls and push from buffer until emptied.
+                    //
+                    // It might be though, that the upstream finished while it was pulled, in which
+                    // case we will not get an onPull from the downstream, because we already had one.
+                    // In that case we need to emit from the buffer.
+                    if (isAvailable(out)) emitChunk();
+                  }
                 }
               });
             }
diff --git a/akka-docs/rst/java/dispatchers.rst b/akka-docs/rst/java/dispatchers.rst
index 3d0ab07f32..5098048117 100644
--- a/akka-docs/rst/java/dispatchers.rst
+++ b/akka-docs/rst/java/dispatchers.rst
@@ -44,6 +44,10 @@ And here's another example that uses the "thread-pool-executor":
 
 .. includecode:: ../scala/code/docs/dispatcher/DispatcherDocSpec.scala#my-thread-pool-dispatcher-config
 
+.. note::
+  The thread pool executor dispatcher is implemented using by a ``java.util.concurrent.ThreadPoolExecutor``.
+  You can read more about it in the JDK's `ThreadPoolExecutor documentation`_.
+
 For more options, see the default-dispatcher section of the :ref:`configuration`.
 
 Then you create the actor as usual and define the dispatcher in the deployment configuration.
@@ -65,6 +69,7 @@ of programmatically provided parameter.
     where you'd use periods to denote sub-sections, like this: ``"foo.bar.my-dispatcher"``
 
 .. _ForkJoinPool documentation: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ForkJoinPool.html
+.. _ThreadPoolExecutor documentation: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html
 
 Types of dispatchers
 --------------------
diff --git a/akka-docs/rst/java/http/client-side/websocket-support.rst b/akka-docs/rst/java/http/client-side/websocket-support.rst
index 5331ff754c..4f376771c9 100644
--- a/akka-docs/rst/java/http/client-side/websocket-support.rst
+++ b/akka-docs/rst/java/http/client-side/websocket-support.rst
@@ -28,7 +28,7 @@ HTTP result can be found in ``WebSocketUpgradeResponse.response``
 Message
 -------
 Messages sent and received over a WebSocket can be either :class:`TextMessage` s or :class:`BinaryMessage` s and each
-of those can be either strict (all data in one chunk) or streaming. In typical applications messages will be strict as
+of those can be either strict (all data in one chunk) or streamed. In typical applications messages will be strict as
 WebSockets are usually deployed to communicate using small messages not stream data, the protocol does however
 allow this (by not marking the first fragment as final, as described in `rfc 6455 section 5.2`__).
 
@@ -37,7 +37,7 @@ __ https://tools.ietf.org/html/rfc6455#section-5.2
 The strict text is available from ``TextMessage.getStrictText`` and strict binary data from
 ``BinaryMessage.getStrictData``.
 
-For streaming messages ``BinaryMessage.getStreamedData`` and ``TextMessage.getStreamedText`` is used to access the data.
+For streamed messages ``BinaryMessage.getStreamedData`` and ``TextMessage.getStreamedText`` is used to access the data.
 In these cases the data is provided as a ``Source<ByteString, NotUsed>`` for binary and ``Source<String, NotUsed>``
 for text messages.
 
diff --git a/akka-docs/rst/java/http/common/timeouts.rst b/akka-docs/rst/java/http/common/timeouts.rst
index fe38391e6f..69dcade043 100644
--- a/akka-docs/rst/java/http/common/timeouts.rst
+++ b/akka-docs/rst/java/http/common/timeouts.rst
@@ -10,6 +10,8 @@ are left to the streaming APIs and are easily implementable as patterns in user-
 Common timeouts
 ---------------
 
+.. _idle-timeouts-java:
+
 Idle timeouts
 ^^^^^^^^^^^^^
 
@@ -22,8 +24,8 @@ independently for each of those using the following keys::
 
     akka.http.server.idle-timeout
     akka.http.client.idle-timeout
-    akka.http.http-connection-pool.idle-timeout
-    akka.http.http-connection-pool.client.idle-timeout
+    akka.http.host-connection-pool.idle-timeout
+    akka.http.host-connection-pool.client.idle-timeout
 
 .. note::
   For the connection pooled client side the idle period is counted only when the pool has no pending requests waiting.
diff --git a/akka-docs/rst/java/http/implications-of-streaming-http-entity.rst b/akka-docs/rst/java/http/implications-of-streaming-http-entity.rst
index b66f66da53..efa76d8ef6 100644
--- a/akka-docs/rst/java/http/implications-of-streaming-http-entity.rst
+++ b/akka-docs/rst/java/http/implications-of-streaming-http-entity.rst
@@ -23,12 +23,12 @@ Client-Side handling of streaming HTTP Entities
 Consuming the HTTP Response Entity (Client)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The most commong use-case of course is consuming the response entity, which can be done via
+The most common use-case of course is consuming the response entity, which can be done via
 running the underlying ``dataBytes`` Source. This is as simple as running the dataBytes source,
 (or on the server-side using directives such as 
 
 It is encouraged to use various streaming techniques to utilise the underlying infrastructure to its fullest,
-for example by framing the incoming chunks, parsing them line-by-line and the connecting the flow into another 
+for example by framing the incoming chunks, parsing them line-by-line and then connecting the flow into another
 destination Sink, such as a File or other Akka Streams connector:
 
 .. includecode:: ../code/docs/http/javadsl/HttpClientExampleDocTest.java#manual-entity-consume-example-1
@@ -108,7 +108,7 @@ Closing connections is also explained in depth in the :ref:`http-closing-connect
 Pending: Automatic discarding of not used entities
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Under certin conditions is is possible to detect an entity is very unlikely to be used by the user for a given request,
+Under certain conditions it is possible to detect an entity is very unlikely to be used by the user for a given request,
 and issue warnings or discard the entity automatically. This advanced feature has not been implemented yet, see the below
 note and issues for further discussion and ideas.
 
diff --git a/akka-docs/rst/java/http/index.rst b/akka-docs/rst/java/http/index.rst
index 49e63aba62..c0b86256b8 100644
--- a/akka-docs/rst/java/http/index.rst
+++ b/akka-docs/rst/java/http/index.rst
@@ -40,5 +40,6 @@ akka-http-jackson
    implications-of-streaming-http-entity
    configuration
    server-side-https-support
+   ../../scala/http/migration-guide-2.4.x-experimental
 
 .. _jackson: https://github.com/FasterXML/jackson
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractActorSystem.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractActorSystem.rst
new file mode 100644
index 0000000000..2ef2f70af5
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractActorSystem.rst
@@ -0,0 +1,19 @@
+.. _-extractActorSystem-java-:
+
+extractActorSystem
+==================
+
+Description
+-----------
+
+Extracts the ``ActorSystem`` from the ``RequestContext``, which can be useful when the external API
+in your route needs one.
+
+.. warning::
+
+  This is only supported when the available Materializer is an ActorMaterializer.
+
+Example
+-------
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java#extractActorSystem
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractDataBytes.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractDataBytes.rst
new file mode 100644
index 0000000000..a74722579b
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractDataBytes.rst
@@ -0,0 +1,16 @@
+.. _-extractDataBytes-java-:
+
+extractDataBytes
+================
+
+Description
+-----------
+
+Extracts the entities data bytes as ``Source[ByteString, Any]`` from the :class:`RequestContext`.
+
+The directive returns a stream containing the request data bytes.
+
+Example
+-------
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java#extractDataBytes
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractRequestEntity.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractRequestEntity.rst
new file mode 100644
index 0000000000..bdbeea2af7
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractRequestEntity.rst
@@ -0,0 +1,17 @@
+.. _-extractRequestEntity-java-:
+
+extractRequestEntity
+====================
+
+Description
+-----------
+
+Extracts the ``RequestEntity`` from the :class:`RequestContext`.
+
+The directive returns a ``RequestEntity`` without unmarshalling the request. To extract domain entity,
+:ref:`-entity-java-` should be used.
+
+Example
+-------
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java#extractRequestEntity
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst
new file mode 100644
index 0000000000..3b2279c1aa
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst
@@ -0,0 +1,23 @@
+.. _-extractStrictEntity-java-:
+
+extractStrictEntity
+===================
+
+Description
+-----------
+
+Extracts the strict http entity as ``HttpEntity.Strict`` from the :class:`RequestContext`.
+
+A timeout parameter is given and if the stream isn't completed after the timeout, the directive will be failed.
+
+.. warning::
+
+  The directive will read the request entity into memory within the size limit(8M by default) and effectively disable streaming.
+  The size limit can be configured globally with ``akka.http.parsing.max-content-length`` or
+  overridden by wrapping with :ref:`-withSizeLimit-java-` or :ref:`-withoutSizeLimit-java-` directive.
+
+
+Example
+-------
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java#extractStrictEntity
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/index.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/index.rst
index 39238f6d99..5b507d1b8b 100644
--- a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/index.rst
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/index.rst
@@ -17,11 +17,15 @@ on two axes: a) provide a constant value or extract a value from the ``RequestCo
 a single value or a tuple of values.
 
   * :ref:`-extract-java-`
+  * :ref:`-extractActorSystem-java-`
+  * :ref:`-extractDataBytes-java-`
   * :ref:`-extractExecutionContext-java-`
   * :ref:`-extractMaterializer-java-`
+  * :ref:`-extractStrictEntity-java-`
   * :ref:`-extractLog-java-`
   * :ref:`-extractRequest-java-`
   * :ref:`-extractRequestContext-java-`
+  * :ref:`-extractRequestEntity-java-`
   * :ref:`-extractSettings-java-`
   * :ref:`-extractUnmatchedPath-java-`
   * :ref:`-extractUri-java-`
@@ -41,6 +45,7 @@ Transforming the Request(Context)
   * :ref:`-withMaterializer-java-`
   * :ref:`-withLog-java-`
   * :ref:`-withSettings-java-`
+  * :ref:`-toStrictEntity-java-`
 
 
 .. _Response Transforming Directives-java:
@@ -91,11 +96,15 @@ Alphabetically
    cancelRejection
    cancelRejections
    extract
+   extractActorSystem
+   extractDataBytes
    extractExecutionContext
    extractMaterializer
+   extractStrictEntity
    extractLog
    extractRequest
    extractRequestContext
+   extractRequestEntity
    extractSettings
    extractUnmatchedPath
    extractUri
@@ -117,6 +126,7 @@ Alphabetically
    provide
    recoverRejections
    recoverRejectionsWith
+   toStrictEntity
    withExecutionContext
    withMaterializer
    withLog
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/toStrictEntity.rst b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/toStrictEntity.rst
new file mode 100644
index 0000000000..a1950e6b42
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/directives/basic-directives/toStrictEntity.rst
@@ -0,0 +1,23 @@
+.. _-toStrictEntity-java-:
+
+toStrictEntity
+==============
+
+Description
+-----------
+
+Transforms the request entity to strict entity before it is handled by the inner route.
+
+A timeout parameter is given and if the stream isn't completed after the timeout, the directive will be failed.
+
+.. warning::
+
+  The directive will read the request entity into memory within the size limit(8M by default) and effectively disable streaming.
+  The size limit can be configured globally with ``akka.http.parsing.max-content-length`` or
+  overridden by wrapping with :ref:`-withSizeLimit-java-` or :ref:`-withoutSizeLimit-java-` directive.
+
+
+Example
+-------
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/BasicDirectivesExamplesTest.java#toStrictEntity
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/debugging-directives/logRequestResult.rst b/akka-docs/rst/java/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
index 079935e653..a71b4f2a14 100644
--- a/akka-docs/rst/java/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
+++ b/akka-docs/rst/java/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
@@ -14,3 +14,10 @@ See :ref:`-logRequest-java-` for the general description how these directives wo
 Example
 -------
 .. includecode:: ../../../../code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java#logRequestResult
+
+Longer Example
+--------------
+
+This example shows how to log the response time of the request using the Debugging Directive
+
+.. includecode:: ../../../../code/docs/http/javadsl/server/directives/DebuggingDirectivesExamplesTest.java#logRequestResultWithResponseTime
diff --git a/akka-docs/rst/java/http/routing-dsl/directives/method-directives/extractMethod.rst b/akka-docs/rst/java/http/routing-dsl/directives/method-directives/extractMethod.rst
index edcf4a62cf..042f028dd5 100644
--- a/akka-docs/rst/java/http/routing-dsl/directives/method-directives/extractMethod.rst
+++ b/akka-docs/rst/java/http/routing-dsl/directives/method-directives/extractMethod.rst
@@ -17,3 +17,9 @@ print what type of request it was - independent of what actual HttpMethod it was
 
 .. includecode:: ../../../../code/docs/http/javadsl/server/directives/MethodDirectivesExamplesTest.java#extractMethod
 
+Custom Http Method
+------------------
+
+When you define a custom HttpMethod, you can define a route using extractMethod.
+
+ .. includecode:: ../../../../code/docs/http/javadsl/server/directives/CustomHttpMethodExamplesTest.java#customHttpMethod
diff --git a/akka-docs/rst/java/http/routing-dsl/index.rst b/akka-docs/rst/java/http/routing-dsl/index.rst
index f84f20759f..85fff2bcb5 100644
--- a/akka-docs/rst/java/http/routing-dsl/index.rst
+++ b/akka-docs/rst/java/http/routing-dsl/index.rst
@@ -18,6 +18,7 @@ To use the high-level API you need to add a dependency to the ``akka-http-experi
    directives/index
    marshalling
    exception-handling
+   source-streaming-support
    rejections
    testkit
    
@@ -51,7 +52,6 @@ in the :ref:`exception-handling-java` section of the documtnation. You can use t
 
 File uploads
 ^^^^^^^^^^^^
-TODO not possible in Java DSL since there
 
 For high level directives to handle uploads see the :ref:`FileUploadDirectives-java`.
 
diff --git a/akka-docs/rst/java/http/routing-dsl/marshalling.rst b/akka-docs/rst/java/http/routing-dsl/marshalling.rst
index 899fc11abb..d0376b9caa 100644
--- a/akka-docs/rst/java/http/routing-dsl/marshalling.rst
+++ b/akka-docs/rst/java/http/routing-dsl/marshalling.rst
@@ -13,7 +13,7 @@ of an HTTP request or response (depending on whether used on the client or serve
 Marshalling
 -----------
 
-On the server-side marshalling is used to convert a application-domain object to a response (entity). Requests can
+On the server-side marshalling is used to convert an application-domain object to a response (entity). Requests can
 contain an ``Accept`` header that lists acceptable content types for the client. A marshaller contains the logic to
 negotiate the result content types based on the ``Accept`` and the ``AcceptCharset`` headers.
 
@@ -30,7 +30,7 @@ These marshallers are provided by akka-http:
 Unmarshalling
 -------------
 
-On the server-side unmarshalling is used to convert a request (entity) to a application-domain object. This is done
+On the server-side unmarshalling is used to convert a request (entity) to an application-domain object. This is done
 in the ``MarshallingDirectives.request`` or ``MarshallingDirectives.entity`` directive. There are several unmarshallers
 provided by akka-http: 
 
diff --git a/akka-docs/rst/java/http/routing-dsl/source-streaming-support.rst b/akka-docs/rst/java/http/routing-dsl/source-streaming-support.rst
new file mode 100644
index 0000000000..acf46421b6
--- /dev/null
+++ b/akka-docs/rst/java/http/routing-dsl/source-streaming-support.rst
@@ -0,0 +1,91 @@
+.. _json-streaming-java:
+
+Source Streaming
+================
+
+Akka HTTP supports completing a request with an Akka ``Source<T, _>``, which makes it possible to easily build
+and consume streaming end-to-end APIs which apply back-pressure throughout the entire stack. 
+
+It is possible to complete requests with raw ``Source<ByteString, _>``, however often it is more convenient to 
+stream on an element-by-element basis, and allow Akka HTTP to handle the rendering internally - for example as a JSON array,
+or CSV stream (where each element is separated by a new-line).
+
+In the following sections we investigate how to make use of the JSON Streaming infrastructure,
+however the general hints apply to any kind of element-by-element streaming you could imagine.
+
+JSON Streaming
+==============
+
+`JSON Streaming`_ is a term refering to streaming a (possibly infinite) stream of element as independent JSON
+objects as a continuous HTTP request or response. The elements are most often separated using newlines,
+however do not have to be. Concatenating elements side-by-side or emitting "very long" JSON array is also another
+use case.
+
+In the below examples, we'll be refering to the ``Tweet`` and ``Measurement`` case classes as our model, which are defined as:
+
+.. includecode:: ../../code/docs/http/javadsl/server/JsonStreamingExamplesTest.java#models
+
+.. _Json Streaming: https://en.wikipedia.org/wiki/JSON_Streaming
+
+Responding with JSON Streams
+----------------------------
+
+In this example we implement an API representing an infinite stream of tweets, very much like Twitter's `Streaming API`_.
+
+Firstly, we'll need to get some additional marshalling infrastructure set up, that is able to marshal to and from an
+Akka Streams ``Source<T,_>``. Here we'll use the ``Jackson`` helper class from ``akka-http-jackson`` (a separate library
+that you should add as a dependency if you want to use Jackson with Akka HTTP).
+
+First we enable JSON Streaming by making an implicit ``EntityStreamingSupport`` instance available (Step 1).
+
+The default mode of rendering a ``Source`` is to represent it as an JSON Array. If you want to change this representation
+for example to use Twitter style new-line separated JSON objects, you can do so by configuring the support trait accordingly.
+
+In Step 1.1. we demonstrate to configure configude the rendering to be new-line separated, and also how parallel marshalling 
+can be applied. We configure the Support object to render the JSON as series of new-line separated JSON objects,
+simply by providing the ``start``, ``sep`` and ``end`` ByteStrings, which will be emitted at the apropriate
+places in the rendered stream. Although this format is *not* valid JSON, it is pretty popular since parsing it is relatively
+simple - clients need only to find the new-lines and apply JSON unmarshalling for an entire line of JSON.
+
+The final step is simply completing a request using a Source of tweets, as simple as that:
+
+.. includecode:: ../../code/docs/http/javadsl/server/JsonStreamingExamplesTest.java#response-streaming
+
+.. _Streaming API: https://dev.twitter.com/streaming/overview
+
+Consuming JSON Streaming uploads
+--------------------------------
+
+Sometimes the client may be sending a streaming request, for example an embedded device initiated a connection with
+the server and is feeding it with one line of measurement data.
+
+In this example, we want to consume this data in a streaming fashion from the request entity, and also apply
+back-pressure to the underlying TCP connection, if the server can not cope with the rate of incoming data (back-pressure
+will be applied automatically thanks to using Akka HTTP/Streams).
+
+.. includecode:: ../../code/docs/http/javadsl/server/JsonStreamingExamplesTest.java#formats
+
+.. includecode:: ../../code/docs/http/javadsl/server/JsonStreamingExamplesTest.java#incoming-request-streaming
+
+
+Simple CSV streaming example
+----------------------------
+
+Akka HTTP provides another ``EntityStreamingSupport`` out of the box, namely ``csv`` (comma-separated values).
+For completeness, we demonstrate its usage in the below snippet. As you'll notice, switching betweeen streaming
+modes is fairly simple, one only has to make sure that an implicit ``Marshaller`` of the requested type is available,
+and that the streaming support operates on the same ``Content-Type`` as the rendered values. Otherwise you'll see
+an error during runtime that the marshaller did not expose the expected content type and thus we can not render
+the streaming response).
+
+.. includecode:: ../../code/docs/http/javadsl/server/JsonStreamingExamplesTest.java#csv-example
+
+Implementing custom EntityStreamingSupport traits
+-------------------------------------------------
+
+The ``EntityStreamingSupport`` infrastructure is open for extension and not bound to any single format, content type
+or marshalling library. The provided JSON support does not rely on Spray JSON directly, but uses ``Marshaller<T, ByteString>``
+instances, which can be provided using any JSON marshalling library (such as Circe, Jawn or Play JSON).
+
+When implementing a custom support trait, one should simply extend the ``EntityStreamingSupport`` abstract class,
+and implement all of it's methods. It's best to use the existing implementations as a guideline.
diff --git a/akka-docs/rst/java/http/server-side-https-support.rst b/akka-docs/rst/java/http/server-side-https-support.rst
index 331575a867..f72aeaebd2 100644
--- a/akka-docs/rst/java/http/server-side-https-support.rst
+++ b/akka-docs/rst/java/http/server-side-https-support.rst
@@ -21,6 +21,8 @@ For detailed documentation for client-side HTTPS support refer to :ref:`clientSi
 
 .. _akka.http.javadsl.Http: https://github.com/akka/akka/blob/master/akka-http-core/src/main/scala/akka/http/javadsl/Http.scala
 
+.. _ssl-config-java:
+
 SSL-Config
 ----------
 
@@ -57,6 +59,8 @@ keystores using the JDK keytool utility can be found `here <https://docs.oracle.
 SSL-Config provides a more targeted guide on generating certificates, so we recommend you start with the guide
 titled `Generating X.509 Certificates <http://typesafehub.github.io/ssl-config/CertificateGeneration.html>`_.
 
+.. _using-https-java:
+
 Using HTTPS
 -----------
 
@@ -64,11 +68,34 @@ Once you have obtained the server certificate, using it is as simple as preparin
 and either setting it as the default one to be used by all servers started by the given ``Http`` extension
 or passing it in explicitly when binding the server.
 
-The below example shows how setting up HTTPS works when using the ``akka.http.javadsl.server.HttpApp`` convenience class:
+The below example shows how setting up HTTPS works when using the ``akka.http.javadsl.server.HttpApp`` convenience class.
+Firstly you will create and configure an instance of ``akka.http.javadsl.HttpsConnectionContext`` :
+
+.. includecode2:: ../../../../akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
+   :snippet: https-http-config
+
+Then pass it to ``akka.http.javadsl.Http`` class's ``setDefaultServerHttpContext`` method, like in the below ``main`` method.
 
 .. includecode2:: ../../../../akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
    :snippet: https-http-app
 
+Running both HTTP and HTTPS
+---------------------------
+If you want to run HTTP and HTTPS servers in a single application, you can call ``bind...`` methods twice,
+one for HTTPS, and the other for HTTP.
+
+When configuring HTTPS, you can do it up like explained in the above :ref:`using-https-java` section,
+
+.. includecode2:: ../../../../akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
+   :snippet: https-http-config
+
+or via :ref:`ssl-config-java` (not explained here though).
+
+Then, call ``bind...`` methods twice like below.
+The blow ``SimpleServerApp.useHttps(system)`` is calling the above defined HTTP ``public static HttpsConnectionContext useHttps(ActorSystem system)`` method.
+
+.. includecode2:: ../../../../akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerHttpHttpsApp.java
+   :snippet: both-https-and-http
 
 Further reading
 ---------------
diff --git a/akka-docs/rst/java/http/server-side/websocket-support.rst b/akka-docs/rst/java/http/server-side/websocket-support.rst
index d72555dfb6..c4d699431f 100644
--- a/akka-docs/rst/java/http/server-side/websocket-support.rst
+++ b/akka-docs/rst/java/http/server-side/websocket-support.rst
@@ -40,7 +40,7 @@ the notion of a "strict" message to represent cases where a whole message was re
 When receiving data from the network connection the WebSocket implementation tries to create a strict message whenever
 possible, i.e. when the complete data was received in one chunk. However, the actual chunking of messages over a network
 connection and through the various streaming abstraction layers is not deterministic from the perspective of the
-application. Therefore, application code must be able to handle both streaming and strict messages and not expect
+application. Therefore, application code must be able to handle both streamed and strict messages and not expect
 certain messages to be strict. (Particularly, note that tests against ``localhost`` will behave differently than tests
 against remote peers where data is received over a physical network connection.)
 
@@ -104,6 +104,11 @@ and then responds with another text message that contains a greeting:
 .. includecode:: ../../code/docs/http/javadsl/server/WebSocketCoreExample.java
    :include: websocket-handler
 
+.. note::
+  Inactive WebSocket connections will be dropped according to the :ref:`idle-timeout settings <idle-timeouts-java>`.
+  In case you need to keep inactive connections alive, you can either tweak your idle-timeout or inject
+  'keep-alive' messages regularly.
+
 Routing support
 ---------------
 
diff --git a/akka-docs/rst/java/io-tcp.rst b/akka-docs/rst/java/io-tcp.rst
index 5ea30571f5..1ad4b7b51d 100644
--- a/akka-docs/rst/java/io-tcp.rst
+++ b/akka-docs/rst/java/io-tcp.rst
@@ -189,7 +189,7 @@ For back-pressuring writes there are three modes of operation
 
 These write models (with the exception of the second which is rather specialised) are
 demonstrated in complete examples below. The full and contiguous source is
-available `on github <@github@/akka-docs/rst/java/code/docs/io/japi>`_.
+available `on GitHub <@github@/akka-docs/rst/java/code/docs/io/japi>`_.
 
 For back-pressuring reads there are two modes of operation
 
diff --git a/akka-docs/rst/java/lambda-actors.rst b/akka-docs/rst/java/lambda-actors.rst
index bd56087a39..5f3e385676 100644
--- a/akka-docs/rst/java/lambda-actors.rst
+++ b/akka-docs/rst/java/lambda-actors.rst
@@ -211,7 +211,7 @@ The Inbox
 ---------
 
 When writing code outside of actors which shall communicate with actors, the
-``ask`` pattern can be a solution (see below), but there are two thing it
+``ask`` pattern can be a solution (see below), but there are two things it
 cannot do: receiving multiple replies (e.g. by subscribing an :class:`ActorRef`
 to a notification service) and watching other actors’ lifecycle. For these
 purposes there is the :class:`Inbox` class:
diff --git a/akka-docs/rst/java/lambda-fsm.rst b/akka-docs/rst/java/lambda-fsm.rst
index 63b4ef6e9e..18a2dc15f0 100644
--- a/akka-docs/rst/java/lambda-fsm.rst
+++ b/akka-docs/rst/java/lambda-fsm.rst
@@ -9,7 +9,7 @@ Overview
 ========
 
 The FSM (Finite State Machine) is available as an abstract base class that implements
-an akka Actor and is best described in the `Erlang design principles
+an Akka Actor and is best described in the `Erlang design principles
 <http://www.erlang.org/documentation/doc-4.8.2/doc/design_principles/fsm.html>`_
 
 A FSM can be described as a set of relations of the form:
diff --git a/akka-docs/rst/java/persistence-schema-evolution.rst b/akka-docs/rst/java/persistence-schema-evolution.rst
index a3f33f515e..8c0ac8f2ef 100644
--- a/akka-docs/rst/java/persistence-schema-evolution.rst
+++ b/akka-docs/rst/java/persistence-schema-evolution.rst
@@ -33,16 +33,12 @@ and systems design much simpler you may want to read Pat Helland's excellent `Im
 
 Since with `Event Sourcing`_ the **events are immutable** and usually never deleted – the way schema evolution is handled
 differs from how one would go about it in a mutable database setting (e.g. in typical CRUD database applications).
+
 The system needs to be able to continue to work in the presence of "old" events which were stored under the "old" schema.
 We also want to limit complexity in the business logic layer, exposing a consistent view over all of the events of a given
 type to :class:`PersistentActor` s and :ref:`persistence queries <persistence-query-java>`. This allows the business logic layer to focus on solving business problems
 instead of having to explicitly deal with different schemas.
 
-The system needs to be able to continue to work in the presence of "old" events which were stored under the "old" schema,
-and we want to limit the complexity to the data layer, exposing a consistent view over all of the events of a given type
-to :class:`PersistentActor` s and persistence queries, which allows these layers to focus on the business problems instead
-handling the different schemas explicitly in the business logic layers.
-
 
 In summary, schema evolution in event sourced systems exposes the following characteristics:
   - Allow the system to continue operating without large scale migrations to be applied,
diff --git a/akka-docs/rst/java/remoting.rst b/akka-docs/rst/java/remoting.rst
index 02ec42a18e..b1e8390ece 100644
--- a/akka-docs/rst/java/remoting.rst
+++ b/akka-docs/rst/java/remoting.rst
@@ -490,7 +490,7 @@ Akka behind NAT or in a Docker container
 ----------------------------------------
 
 In setups involving Network Address Translation (NAT), Load Balancers or Docker
-containers the hostname and port pair that akka binds to will be different than the "logical"
+containers the hostname and port pair that Akka binds to will be different than the "logical"
 host name and port pair that is used to connect to the system from the outside. This requires
 special configuration that sets both the logical and the bind pairs for remoting.
 
diff --git a/akka-docs/rst/java/routing.rst b/akka-docs/rst/java/routing.rst
index f47fe99d01..665b94847d 100644
--- a/akka-docs/rst/java/routing.rst
+++ b/akka-docs/rst/java/routing.rst
@@ -46,7 +46,9 @@ outside of actors.
 .. note::
 
     In general, any message sent to a router will be sent onwards to its routees, but there is one exception.
-    The special :ref:`broadcast-messages-java` will send to *all* of a router's routees 
+    The special :ref:`broadcast-messages-java` will send to *all* of a router's routees.
+    However, do not use :ref:`broadcast-messages-java` when you use :ref:`balancing-pool-java` for routees
+    as described in :ref:`router-special-messages-java`.
 
 A Router Actor
 ^^^^^^^^^^^^^^
@@ -62,11 +64,11 @@ This type of router actor comes in two distinct flavors:
 * Group - The routee actors are created externally to the router and the router sends
   messages to the specified path using actor selection, without watching for termination.  
 
-The settings for a router actor can be defined in configuration or programmatically. 
-Although router actors can be defined in the configuration file, they must still be created
-programmatically, i.e. you cannot make a router through external configuration alone.
-If you define the router actor in the configuration file then these settings will be used
-instead of any programmatically provided parameters.
+The settings for a router actor can be defined in configuration or programmatically.
+In order to make an actor to make use of an externally configurable router the ``FromConfig`` props wrapper must be used
+to denote that the actor accepts routing settings from configuration.
+This is in contrast with Remote Deployment where such marker props is not necessary.
+If the props of an actor is NOT wrapped in ``FromConfig`` it will ignore the router section of the deployment configuration.
 
 You send messages to the routees via the router actor in the same way as for ordinary actors,
 i.e. via its ``ActorRef``. The router actor forwards messages onto its routees without changing 
@@ -276,6 +278,10 @@ All routees share the same mailbox.
    replying to the original client. The other advantage is that it does not place
    a restriction on the message queue implementation as BalancingPool does.
 
+.. note::
+   Do not use :ref:`broadcast-messages-java` when you use :ref:`balancing-pool-java` for routers,
+   as described in :ref:`router-special-messages-java`.
+
 BalancingPool defined in configuration:
 
 .. includecode:: ../scala/code/docs/routing/RouterDocSpec.scala#config-balancing-pool
@@ -305,6 +311,20 @@ with a ``thread-pool-executor`` hinting the number of allocated threads explicit
 
 .. includecode:: ../scala/code/docs/routing/RouterDocSpec.scala#config-balancing-pool3
 
+It is also possible to change the ``mailbox`` used by the balancing dispatcher for
+scenarios where the default unbounded mailbox is not well suited. An example of such
+a scenario could arise whether there exists the need to manage priority for each message.
+You can then implement a priority mailbox and configure your dispatcher:
+
+.. includecode:: ../scala/code/docs/routing/RouterDocSpec.scala#config-balancing-pool4
+
+.. note::
+
+   Bear in mind that ``BalancingDispatcher`` requires a message queue that must be thread-safe for
+   multiple concurrent consumers. So it is mandatory for the message queue backing a custom mailbox
+   for this kind of dispatcher to implement akka.dispatch.MultipleConsumerSemantics. See details
+   on how to implement your custom mailbox in :ref:`mailboxes-java`.
+
 There is no Group variant of the BalancingPool.
 
 SmallestMailboxPool
@@ -522,6 +542,11 @@ In this example the router receives the ``Broadcast`` message, extracts its payl
 (``"Watch out for Davy Jones' locker"``), and then sends the payload on to all of the router's
 routees. It is up to each routee actor to handle the received payload message.
 
+.. note::
+   Do not use :ref:`broadcast-messages-java` when you use :ref:`balancing-pool-java` for routers.
+   Routees on :ref:`balancing-pool-java` shares the same mailbox instance, thus some routees can
+   possibly get the broadcast message multiple times, while other routees get no broadcast message.
+
 PoisonPill Messages
 -------------------
 
diff --git a/akka-docs/rst/java/serialization.rst b/akka-docs/rst/java/serialization.rst
index 109752bd77..d76de2b513 100644
--- a/akka-docs/rst/java/serialization.rst
+++ b/akka-docs/rst/java/serialization.rst
@@ -35,6 +35,14 @@ one of which all other candidates are superclasses. If this condition cannot be
 met, because e.g. ``java.io.Serializable`` and ``MyOwnSerializable`` both apply
 and neither is a subtype of the other, a warning will be issued.
 
+.. note::
+
+  If you are using Scala for your message protocol and your messages are contained
+  inside of a Scala object, then in order to reference those messages, you will need
+  use the fully qualified Java class name. For a message named ``Message`` contained inside
+  the Scala object named ``Wrapper`` you would need to reference it as
+  ``Wrapper$Message`` instead of ``Wrapper.Message``.
+
 Akka provides serializers for :class:`java.io.Serializable` and `protobuf
 <http://code.google.com/p/protobuf/>`_
 :class:`com.google.protobuf.GeneratedMessage` by default (the latter only if
diff --git a/akka-docs/rst/java/stream/migration-guide-2.0-2.4-java.rst b/akka-docs/rst/java/stream/migration-guide-2.0-2.4-java.rst
index eeabc82333..4d483116c7 100644
--- a/akka-docs/rst/java/stream/migration-guide-2.0-2.4-java.rst
+++ b/akka-docs/rst/java/stream/migration-guide-2.0-2.4-java.rst
@@ -42,7 +42,7 @@ completion but there is no actual value attached to the completion. It is used t
 occurrences of ``Future<BoxedUnit>`` with ``Future<Done>`` in Java and ``Future[Unit]`` with
 ``Future[Done]`` in Scala.
 
-All previous usage of ``Unit`` and ``BoxedUnit`` for these two cases in the akka streams APIs
+All previous usage of ``Unit`` and ``BoxedUnit`` for these two cases in the Akka Streams APIs
 has been updated.
 
 This means that Java code like this::
@@ -136,8 +136,8 @@ IO Sources / Sinks materialize IOResult
 
 Materialized values of the following sources and sinks:
 
-  * ``FileIO.fromFile``
-  * ``FileIO.toFile``
+  * ``FileIO.fromPath``
+  * ``FileIO.toPath``
   * ``StreamConverters.fromInputStream``
   * ``StreamConverters.fromOutputStream``
 
diff --git a/akka-docs/rst/java/stream/stages-overview.rst b/akka-docs/rst/java/stream/stages-overview.rst
index 6373eb8e70..d5b5b50b92 100644
--- a/akka-docs/rst/java/stream/stages-overview.rst
+++ b/akka-docs/rst/java/stream/stages-overview.rst
@@ -323,6 +323,23 @@ Invoke a callback when the stream has completed or failed.
 
 **backpressures** never
 
+lazyInit
+^^^^^^^^
+Invoke sinkFactory function to create a real sink upon receiving the first element. Internal ``Sink`` will not be created if there are no elements,
+because of completion or error. `fallback` will be invoked if there was no elements and completed is received from upstream.
+
+**cancels** never
+
+**backpressures** when initialized and when created sink backpressures
+
+queue
+^^^^^
+Materialize a ``SinkQueue`` that can be pulled to trigger demand through the sink. The queue contains
+a buffer in case stream emitting elements faster than queue pulling them.
+
+**cancels** when  ``SinkQueue.cancel`` is called
+
+**backpressures** when buffer has some space
 
 fold
 ^^^^
@@ -570,6 +587,17 @@ it returns false the element is discarded.
 
 **completes** when upstream completes
 
+filterNot
+^^^^^^^^
+Filter the incoming elements using a predicate. If the predicate returns false the element is passed downstream, if
+it returns true the element is discarded.
+
+**emits** when the given predicate returns false for the element
+
+**backpressures** when the given predicate returns false for the element and downstream backpressures
+
+**completes** when upstream completes
+
 collect
 ^^^^^^^
 Apply a partial function to each incoming element, if the partial function is defined for a value the returned
@@ -630,6 +658,17 @@ complete the current value is emitted downstream.
 
 **completes** when upstream completes
 
+reduce
+^^^^^^
+Start with first element and then apply the current and next value to the given function, when upstream
+complete the current value is emitted downstream. Similar to ``fold``.
+
+**emits** when upstream completes
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
 drop
 ^^^^
 Drop ``n`` elements and then pass any subsequent element downstream.
@@ -713,6 +752,59 @@ a function has to be provided to calculate the individual cost of each element.
 
 **completes** when upstream completes
 
+intersperse
+^^^^^^^^^^^
+Intersperse stream with provided element similar to ``List.mkString``. It can inject start and end marker elements to stream.
+
+**emits** when upstream emits an element or before with the `start` element if provided
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
+limit
+^^^^^
+Limit number of element from upstream to given ``max`` number.
+
+**emits** when upstream emits and the number of emitted elements has not reached max
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes and the number of emitted elements has not reached max
+
+limitWeighted
+^^^^^^^^^^^^^
+Ensure stream boundedness by evaluating the cost of incoming elements using a cost function.
+Evaluated cost of each element defines how many elements will be allowed to travel downstream.
+
+**emits** when upstream emits and the number of emitted elements has not reached max
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes and the number of emitted elements has not reached max
+
+log
+^^^
+Log elements flowing through the stream as well as completion and erroring. By default element and
+completion signals are logged on debug level, and errors are logged on Error level.
+This can be changed by calling ``Attributes.createLogLevels(...)`` on the given Flow.
+
+**emits** when upstream emits
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
+recoverWithRetries
+^^^^^^^^^^^^^^^^^^
+Switch to alternative Source on flow failure. It stays in effect after a failure has been recovered up to ``attempts``
+number of times. Each time a failure is fed into the partial function and a new Source may be materialized.
+
+**emits** when element is available from the upstream or upstream is failed and element is available from alternative Source
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes or upstream failed with exception partial function can handle
 
 
 Asynchronous processing stages
@@ -1217,6 +1309,17 @@ Fan-out the stream to several streams. Each upstream element is emitted to the f
 
 **completes** when upstream completes
 
+partition
+^^^^^^^^^
+Fan-out the stream to several streams. Each upstream element is emitted to one downstream consumer according to the
+partitioner function applied to the element.
+
+**emits** when the chosen output stops backpressuring and there is an input element available
+
+**backpressures** when the chosen output backpressures
+
+**completes** when upstream completes and no output is pending
+
 
 Watching status stages
 ----------------------
diff --git a/akka-docs/rst/java/stream/stream-customize.rst b/akka-docs/rst/java/stream/stream-customize.rst
index e3922b5b0b..ffcc8d7fde 100644
--- a/akka-docs/rst/java/stream/stream-customize.rst
+++ b/akka-docs/rst/java/stream/stream-customize.rst
@@ -58,6 +58,14 @@ source as any other built-in one:
 
 .. includecode:: ../code/docs/stream/GraphStageDocTest.java#simple-source-usage
 
+Similarly, to create a custom :class:`Sink` one can register a subclass :class:`InHandler` with the stage :class:`Inlet`.
+The ``onPush()`` callback is used to signal the handler a new element has been pushed to the stage,
+and can hence be grabbed and used. ``onPush()`` can be overridden to provide custom behaviour.
+Please note, most Sinks would need to request upstream elements as soon as they are created: this can be
+done by calling ``pull(inlet)`` in the ``preStart()`` callback.
+
+.. includecode:: ../code/docs/stream/GraphStageDocTest.java#simple-sink
+
 Port states, AbstractInHandler and AbstractOutHandler
 -----------------------------------------------------
 
@@ -105,7 +113,7 @@ The following operations are available for *input* ports:
 The events corresponding to an *input* port can be received in an :class:`AbstractInHandler` instance registered to the
 input port using ``setHandler(in, handler)``. This handler has three callbacks:
 
-* ``onPush()`` is called when the output port has now a new element. Now it is possible to acquire this element using
+* ``onPush()`` is called when the input port has now a new element. Now it is possible to acquire this element using
   ``grab(in)`` and/or call ``pull(in)`` on the port to request the next element. It is not mandatory to grab the
   element, but if it is pulled while the element has not been grabbed it will drop the buffered element.
 * ``onUpstreamFinish()`` is called once the upstream has completed and no longer can be pulled for new elements.
@@ -138,7 +146,7 @@ Finally, there are two methods available for convenience to complete the stage a
 
 
 In some cases it is inconvenient and error prone to react on the regular state machine events with the
-signal based API described above. For those cases there is a API which allows for a more declarative sequencing
+signal based API described above. For those cases there is an API which allows for a more declarative sequencing
 of actions which will greatly simplify some use cases at the cost of some extra allocations. The difference
 between the two APIs could be described as that the first one is signal driven from the outside, while this API
 is more active and drives its surroundings.
diff --git a/akka-docs/rst/java/stream/stream-dynamic.rst b/akka-docs/rst/java/stream/stream-dynamic.rst
index f90cbdcacb..2e0d37c368 100644
--- a/akka-docs/rst/java/stream/stream-dynamic.rst
+++ b/akka-docs/rst/java/stream/stream-dynamic.rst
@@ -1,10 +1,10 @@
-.. _stream-dynamic-scala:
+.. _stream-dynamic-java:
 
 #######################
 Dynamic stream handling
 #######################
 
-.. _kill-switch-scala:
+.. _kill-switch-java:
 
 Controlling graph completion with KillSwitch
 --------------------------------------------
@@ -24,7 +24,7 @@ Graph completion is performed by both
 
 A ``KillSwitch`` can control the completion of one or multiple streams, and therefore comes in two different flavours.
 
-.. _unique-kill-switch-scala:
+.. _unique-kill-switch-java:
 
 UniqueKillSwitch
 ^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ below for usage examples.
 
 .. includecode:: ../code/docs/stream/KillSwitchDocTest.java#unique-abort
 
-.. _shared-kill-switch-scala:
+.. _shared-kill-switch-java:
 
 SharedKillSwitch
 ^^^^^^^^^^^^^^^^
diff --git a/akka-docs/rst/java/stream/stream-integrations.rst b/akka-docs/rst/java/stream/stream-integrations.rst
index c4225dc15c..6f47436fe1 100644
--- a/akka-docs/rst/java/stream/stream-integrations.rst
+++ b/akka-docs/rst/java/stream/stream-integrations.rst
@@ -15,7 +15,7 @@ For more advanced use cases the :class:`ActorPublisher` and :class:`ActorSubscri
 provided to support implementing Reactive Streams :class:`Publisher` and :class:`Subscriber` with
 an :class:`Actor`.
 
-These can be consumed by other Reactive Stream libraries or used as a
+These can be consumed by other Reactive Stream libraries or used as an
 Akka Streams :class:`Source` or :class:`Sink`.
 
 .. warning::
diff --git a/akka-docs/rst/java/stream/stream-io.rst b/akka-docs/rst/java/stream/stream-io.rst
index 71f2786ae5..598b4ee04f 100644
--- a/akka-docs/rst/java/stream/stream-io.rst
+++ b/akka-docs/rst/java/stream/stream-io.rst
@@ -100,7 +100,7 @@ Akka Streams provide simple Sources and Sinks that can work with :class:`ByteStr
 on files.
 
 
-Streaming data from a file is as easy as creating a `FileIO.fromFile` given a target file, and an optional
+Streaming data from a file is as easy as creating a `FileIO.fromPath` given a target path, and an optional
 ``chunkSize`` which determines the buffer size determined as one "element" in such stream:
 
 .. includecode:: ../code/docs/stream/io/StreamFileDocTest.java#file-source
diff --git a/akka-docs/rst/java/stream/stream-quickstart.rst b/akka-docs/rst/java/stream/stream-quickstart.rst
index 12d9016502..c3c7e73ee9 100644
--- a/akka-docs/rst/java/stream/stream-quickstart.rst
+++ b/akka-docs/rst/java/stream/stream-quickstart.rst
@@ -90,7 +90,7 @@ accepts strings as its input and when materialized it will create auxiliary
 information of type ``CompletionStage<IOResult>`` (when chaining operations on
 a :class:`Source` or :class:`Flow` the type of the auxiliary information—called
 the “materialized value”—is given by the leftmost starting point; since we want
-to retain what the ``FileIO.toFile`` sink has to offer, we need to say
+to retain what the ``FileIO.toPath`` sink has to offer, we need to say
 ``Keep.right()``).
 
 We can use the new and shiny :class:`Sink` we just created by
diff --git a/akka-docs/rst/java/typed-actors.rst b/akka-docs/rst/java/typed-actors.rst
index 11160b69e1..0b6622023c 100644
--- a/akka-docs/rst/java/typed-actors.rst
+++ b/akka-docs/rst/java/typed-actors.rst
@@ -25,7 +25,7 @@ lies in interfacing between private sphere and the public, but you don’t want
 that many doors inside your house, do you? For a longer discussion see `this
 blog post <http://letitcrash.com/post/19074284309/when-to-use-typedactors>`_.
 
-A bit more background: TypedActors can very easily be abused as RPC, and that
+A bit more background: TypedActors can easily be abused as RPC, and that
 is an abstraction which is `well-known
 <http://doc.akka.io/docs/misc/smli_tr-94-29.pdf>`_
 to be leaky. Hence TypedActors are not what we think of first when we talk
diff --git a/akka-docs/rst/java/untyped-actors.rst b/akka-docs/rst/java/untyped-actors.rst
index 335ec55cc7..b9da5bc02f 100644
--- a/akka-docs/rst/java/untyped-actors.rst
+++ b/akka-docs/rst/java/untyped-actors.rst
@@ -165,7 +165,7 @@ The Inbox
 ---------
 
 When writing code outside of actors which shall communicate with actors, the
-``ask`` pattern can be a solution (see below), but there are two thing it
+``ask`` pattern can be a solution (see below), but there are two things it
 cannot do: receiving multiple replies (e.g. by subscribing an :class:`ActorRef`
 to a notification service) and watching other actors’ lifecycle. For these
 purposes there is the :class:`Inbox` class:
diff --git a/akka-docs/rst/project/issue-tracking.rst b/akka-docs/rst/project/issue-tracking.rst
index 7a68465e63..98406eaa68 100644
--- a/akka-docs/rst/project/issue-tracking.rst
+++ b/akka-docs/rst/project/issue-tracking.rst
@@ -19,7 +19,7 @@ have reproducible test cases that you can share.
 Roadmaps
 ^^^^^^^^
 
-Short and long-term plans are published in the [akka/akka-meta](https://github.com/akka/akka-meta/issues) repository.
+Short and long-term plans are published in the `akka/akka-meta <https://github.com/akka/akka-meta/issues>`_ repository.
 
 Creating tickets
 ----------------
@@ -37,7 +37,7 @@ Submitting Pull Requests
 .. note:: *A pull request is worth a thousand +1's.* -- Old Klangian Proverb
 
 Pull Requests fixing issues or adding functionality are very welcome.
-Please read [CONTRIBUTING.md](https://github.com/akka/akka/blob/master/CONTRIBUTING.md) for
+Please read `CONTRIBUTING.md <https://github.com/akka/akka/blob/master/CONTRIBUTING.md>`_ for
 more information about contributing to Akka.
 
 
diff --git a/akka-docs/rst/project/migration-guide-2.3.x-2.4.x.rst b/akka-docs/rst/project/migration-guide-2.3.x-2.4.x.rst
index f3e239b101..c19b5a6854 100644
--- a/akka-docs/rst/project/migration-guide-2.3.x-2.4.x.rst
+++ b/akka-docs/rst/project/migration-guide-2.3.x-2.4.x.rst
@@ -125,10 +125,10 @@ FSM notifies on same state transitions
 When changing states in an Finite-State-Machine Actor (``FSM``), state transition events are emitted and can be handled by the user
 either by registering ``onTransition`` handlers or by subscribing to these events by sending it an ``SubscribeTransitionCallBack`` message.
 
-Previously in ``2.3.x`` when an ``FSM`` was in state ``A`` and performed an ``goto(A)`` transition, no state transition notification would be sent.
+Previously in ``2.3.x`` when an ``FSM`` was in state ``A`` and performed a ``goto(A)`` transition, no state transition notification would be sent.
 This is because it would effectively stay in the same state, and was deemed to be semantically equivalent to calling ``stay()``.
 
-In ``2.4.x`` when an ``FSM`` performs a any ``goto(X)`` transition, it will always trigger state transition events.
+In ``2.4.x`` when an ``FSM`` performs an any ``goto(X)`` transition, it will always trigger state transition events.
 Which turns out to be useful in many systems where same-state transitions actually should have an effect.
 
 In case you do *not* want to trigger a state transition event when effectively performing an ``X->X`` transition, use ``stay()`` instead.
@@ -191,7 +191,7 @@ i.e. if defined it takes precedence over ``max-total-nr-of-instances``.
 
 Logger names use full class name 
 ================================
-Previously, few places in akka used "simple" logger names, such as ``Cluster`` or ``Remoting``.
+Previously, few places in Akka used "simple" logger names, such as ``Cluster`` or ``Remoting``.
 Now they use full class names, such as ``akka.cluster.Cluster`` or ``akka.remote.Remoting``,
 in order to allow package level log level definitions and ease source code lookup. 
 In case you used specific "simple" logger name based rules in your ``logback.xml`` configurations,
@@ -226,7 +226,7 @@ Please see :ref:`deployment-scenarios` for more information.
 New Cluster Metrics Extension 
 =============================
 Previously, cluster metrics functionality was located in the ``akka-cluster`` jar.
-Now it is split out and moved into a separate akka module: ``akka-cluster-metrics`` jar.
+Now it is split out and moved into a separate Akka module: ``akka-cluster-metrics`` jar.
 The module comes with few enhancements, such as use of Kamon sigar-loader 
 for native library provisioning as well as use of statistical averaging of metrics data.
 Note that both old and new metrics configuration entries in the ``reference.conf`` 
diff --git a/akka-docs/rst/project/migration-guide-persistence-experimental-2.3.x-2.4.x.rst b/akka-docs/rst/project/migration-guide-persistence-experimental-2.3.x-2.4.x.rst
index f8060314a1..051f7158d3 100644
--- a/akka-docs/rst/project/migration-guide-persistence-experimental-2.3.x-2.4.x.rst
+++ b/akka-docs/rst/project/migration-guide-persistence-experimental-2.3.x-2.4.x.rst
@@ -201,5 +201,5 @@ Persistence extension uses LevelDB based plugins for own development and keeps r
 However previously LevelDB was a ``compile`` scope dependency, and now it is an ``optional;provided`` dependency.
 To continue using LevelDB based persistence plugins it is now required for related user projects
 to include an additional explicit dependency declaration for the LevelDB artifacts. 
-This change allows production akka deployments to avoid need for the LevelDB provisioning. 
+This change allows production Akka deployments to avoid need for the LevelDB provisioning.
 Please see persistence extension ``reference.conf`` for details. 
diff --git a/akka-docs/rst/scala/camel.rst b/akka-docs/rst/scala/camel.rst
index 7cfeec715a..84cc196554 100644
--- a/akka-docs/rst/scala/camel.rst
+++ b/akka-docs/rst/scala/camel.rst
@@ -277,7 +277,7 @@ messages to endpoints.
 
 .. includecode:: code/docs/camel/Producers.scala#ProducerTemplate
 
-For initiating a a two-way message exchange, one of the
+For initiating a two-way message exchange, one of the
 ``ProducerTemplate.request*`` methods must be used.
 
 .. includecode:: code/docs/camel/Producers.scala#RequestProducerTemplate
@@ -415,7 +415,7 @@ Here's an actor endpoint URI example containing an actor path::
    akka://some-system/user/myconsumer?autoAck=false&replyTimeout=100+millis
 
 In the following example, a custom route to an actor is created, using the
-actor's path. the akka camel package contains an implicit ``toActorRouteDefinition`` that allows for a route to
+actor's path. the Akka camel package contains an implicit ``toActorRouteDefinition`` that allows for a route to
 reference an ``ActorRef`` directly as shown in the below example, The route starts from a `Jetty`_ endpoint and
 ends at the target actor.
 
diff --git a/akka-docs/rst/scala/cluster-metrics.rst b/akka-docs/rst/scala/cluster-metrics.rst
index e0e3d67a3d..e894b5e234 100644
--- a/akka-docs/rst/scala/cluster-metrics.rst
+++ b/akka-docs/rst/scala/cluster-metrics.rst
@@ -14,7 +14,7 @@ Cluster metrics information is primarily used for load-balancing routers,
 and can also be used to implement advanced metrics-based node life cycles,
 such as "Node Let-it-crash" when CPU steal time becomes excessive.
 
-Cluster Metrics Extension is a separate akka module delivered in ``akka-cluster-metrics`` jar.
+Cluster Metrics Extension is a separate Akka module delivered in ``akka-cluster-metrics`` jar.
 
 To enable usage of the extension you need to add the following dependency to your project:
 ::
diff --git a/akka-docs/rst/scala/cluster-sharding.rst b/akka-docs/rst/scala/cluster-sharding.rst
index 9e7ed16598..875c216bdd 100644
--- a/akka-docs/rst/scala/cluster-sharding.rst
+++ b/akka-docs/rst/scala/cluster-sharding.rst
@@ -273,7 +273,7 @@ Note that stopped entities will be started again when a new message is targeted
 Graceful Shutdown
 -----------------
 
-You can send the message ``ClusterSharding.GracefulShutdown`` message to the ``ShardRegion`` actor to handoff all shards that are hosted by that ``ShardRegion`` and then the
+You can send the message ``ShardRegion.GracefulShutdown`` message to the ``ShardRegion`` actor to handoff all shards that are hosted by that ``ShardRegion`` and then the
 ``ShardRegion`` actor will be stopped. You can ``watch`` the ``ShardRegion`` actor to know when it is completed.
 During this period other regions will buffer messages for those shards in the same way as when a rebalance is
 triggered by the coordinator. When the shards have been stopped the coordinator will allocate these shards elsewhere.
diff --git a/akka-docs/rst/scala/cluster-usage.rst b/akka-docs/rst/scala/cluster-usage.rst
index 4eb8177e3c..fc34e35698 100644
--- a/akka-docs/rst/scala/cluster-usage.rst
+++ b/akka-docs/rst/scala/cluster-usage.rst
@@ -785,3 +785,13 @@ For this purpose you can define a separate dispatcher to be used for the cluster
       parallelism-max = 4
     }
   }
+
+.. note::
+    Normally it should not be necessary to configure a separate dispatcher for the Cluster.
+    The default-dispatcher should be sufficient for performing the Cluster tasks, i.e. ``akka.cluster.use-dispatcher``
+    should not be changed. If you have Cluster related problems when using the default-dispatcher that is typically an
+    indication that you are running blocking or CPU intensive actors/tasks on the default-dispatcher.
+    Use dedicated dispatchers for such actors/tasks instead of running them on the default-dispatcher,
+    because that may starve system internal tasks.
+    Related config properties: ``akka.cluster.use-dispatcher = akka.cluster.cluster-dispatcher``.
+    Corresponding default values: ``akka.cluster.use-dispatcher =``.
\ No newline at end of file
diff --git a/akka-docs/rst/scala/code/docs/event/LoggingDocSpec.scala b/akka-docs/rst/scala/code/docs/event/LoggingDocSpec.scala
index d27d04e900..7e93bb2ac1 100644
--- a/akka-docs/rst/scala/code/docs/event/LoggingDocSpec.scala
+++ b/akka-docs/rst/scala/code/docs/event/LoggingDocSpec.scala
@@ -152,12 +152,13 @@ class LoggingDocSpec extends AkkaSpec {
 
   "demonstrate superclass subscriptions on eventStream" in {
     def println(s: String) = ()
-    //#superclass-subscription-eventstream
-    abstract class AllKindsOfMusic { def artist: String }
-    case class Jazz(artist: String) extends AllKindsOfMusic
-    case class Electronic(artist: String) extends AllKindsOfMusic
 
     new AnyRef {
+      //#superclass-subscription-eventstream
+      abstract class AllKindsOfMusic { def artist: String }
+      case class Jazz(artist: String) extends AllKindsOfMusic
+      case class Electronic(artist: String) extends AllKindsOfMusic
+
       class Listener extends Actor {
         def receive = {
           case m: Jazz       => println(s"${self.path.name} is listening to: ${m.artist}")
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/SprayJsonExampleSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/SprayJsonExampleSpec.scala
index 7da0505134..187290eed0 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/SprayJsonExampleSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/SprayJsonExampleSpec.scala
@@ -4,8 +4,6 @@
 
 package docs.http.scaladsl
 
-import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
-import akka.http.scaladsl.server.Directives
 import org.scalatest.{ Matchers, WordSpec }
 
 class SprayJsonExampleSpec extends WordSpec with Matchers {
@@ -13,7 +11,9 @@ class SprayJsonExampleSpec extends WordSpec with Matchers {
   def compileOnlySpec(body: => Unit) = ()
 
   "spray-json example" in compileOnlySpec {
-    //#example
+    //#minimal-spray-json-example
+    import akka.http.scaladsl.server.Directives
+    import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
     import spray.json._
 
     // domain model
@@ -120,4 +120,4 @@ class SprayJsonExampleSpec extends WordSpec with Matchers {
     }
     //#second-spray-json-example
   }
-}
\ No newline at end of file
+}
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/FileUploadExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/FileUploadExamplesSpec.scala
index 1a52983dcf..5bdf363a14 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/FileUploadExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/FileUploadExamplesSpec.scala
@@ -35,7 +35,7 @@ class FileUploadExamplesSpec extends RoutingSpec {
               // stream into a file as the chunks of it arrives and return a future
               // file to where it got stored
               val file = File.createTempFile("upload", "tmp")
-              b.entity.dataBytes.runWith(FileIO.toFile(file)).map(_ =>
+              b.entity.dataBytes.runWith(FileIO.toPath(file.toPath)).map(_ =>
                 (b.name -> file))
 
             case b: BodyPart =>
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
index e3fba4191a..cc15315dda 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
@@ -54,10 +54,13 @@ abstract class HttpsServerExampleSpec extends WordSpec with Matchers
     val sslContext: SSLContext = SSLContext.getInstance("TLS")
     sslContext.init(keyManagerFactory.getKeyManagers, tmf.getTrustManagers, new SecureRandom)
     val https: HttpsConnectionContext = ConnectionContext.https(sslContext)
+    //#
 
-    // sets default context to HTTPS – all Http() bound servers for this ActorSystem will use HTTPS from now on
-    Http().setDefaultServerHttpContext(https)
-
+    //#both-https-and-http
+    // you can run both HTTP and HTTPS in the same application as follows:
+    val commonRoutes: Route = get { complete("Hello world!") }
+    Http().bindAndHandle(commonRoutes, "127.0.0.1", 443, connectionContext = https)
+    Http().bindAndHandle(commonRoutes, "127.0.0.1", 80)
     //#
 
     //#bind-low-level-context
@@ -67,6 +70,14 @@ abstract class HttpsServerExampleSpec extends WordSpec with Matchers
     val routes: Route = get { complete("Hello world!") }
     Http().bindAndHandle(routes, "127.0.0.1", 8080, connectionContext = https)
     //#
+
+    //#set-low-level-context-default
+    // sets default context to HTTPS – all Http() bound servers for this ActorSystem will use HTTPS from now on
+    Http().setDefaultServerHttpContext(https)
+    Http().bindAndHandle(routes, "127.0.0.1", 9090, connectionContext = https)
+    //#
+
+    system.terminate()
   }
 
 }
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
index 0b5ff6247e..c3ec9b4576 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
@@ -805,7 +805,7 @@ class BasicDirectivesExamplesSpec extends RoutingSpec {
     // tests:
     val httpEntity = HttpEntity(ContentTypes.`text/plain(UTF-8)`, "req")
     Post("/abc", httpEntity) ~> route ~> check {
-      responseAs[String] shouldEqual s"Request entity content-type is text/plain; charset=UTF-8"
+      responseAs[String] shouldEqual "Request entity content-type is text/plain; charset=UTF-8"
     }
     //#
   }
@@ -826,5 +826,53 @@ class BasicDirectivesExamplesSpec extends RoutingSpec {
     }
     //#
   }
+  "extractStrictEntity-example" in {
+    //#extractStrictEntity-example
+    import scala.concurrent.duration._
+    val route = extractStrictEntity(3.seconds) { entity =>
+      complete(entity.data.utf8String)
+    }
+
+    // tests:
+    val dataBytes = Source.fromIterator(() ⇒ Iterator.range(1, 10).map(x ⇒ ByteString(x.toString)))
+    Post("/", HttpEntity(ContentTypes.`text/plain(UTF-8)`, data = dataBytes)) ~> route ~> check {
+      responseAs[String] shouldEqual "123456789"
+    }
+    //#
+  }
+  "toStrictEntity-example" in {
+    //#toStrictEntity-example
+    import scala.concurrent.duration._
+    val route = toStrictEntity(3.seconds) {
+      extractRequest { req =>
+        req.entity match {
+          case strict: HttpEntity.Strict =>
+            complete(s"Request entity is strict, data=${strict.data.utf8String}")
+          case _ =>
+            complete("Ooops, request entity is not strict!")
+        }
+      }
+    }
+
+    // tests:
+    val dataBytes = Source.fromIterator(() ⇒ Iterator.range(1, 10).map(x ⇒ ByteString(x.toString)))
+    Post("/", HttpEntity(ContentTypes.`text/plain(UTF-8)`, data = dataBytes)) ~> route ~> check {
+      responseAs[String] shouldEqual "Request entity is strict, data=123456789"
+    }
+    //#
+  }
+
+  "extractActorSystem-example" in {
+    //#extractActorSystem-example
+    val route = extractActorSystem { actorSystem =>
+      complete(s"Actor System extracted, hash=${actorSystem.hashCode()}")
+    }
+
+    // tests:
+    Get("/") ~> route ~> check {
+      responseAs[String] shouldEqual s"Actor System extracted, hash=${system.hashCode()}"
+    }
+    //#
+  }
 
 }
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/CustomHttpMethodSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/CustomHttpMethodSpec.scala
new file mode 100644
index 0000000000..5fe711b713
--- /dev/null
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/CustomHttpMethodSpec.scala
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package docs.http.scaladsl.server.directives
+
+import akka.http.scaladsl.{ Http, TestUtils }
+import akka.http.scaladsl.client.RequestBuilding
+import akka.http.scaladsl.model.HttpProtocols._
+import akka.http.scaladsl.model.RequestEntityAcceptance.Expected
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.server.Directives
+import akka.stream.ActorMaterializer
+import akka.testkit.AkkaSpec
+import akka.util.ByteString
+import org.scalatest.concurrent.ScalaFutures
+
+import scala.concurrent.duration._
+
+class CustomHttpMethodSpec extends AkkaSpec with ScalaFutures
+  with Directives with RequestBuilding {
+
+  implicit val mat = ActorMaterializer()
+
+  "Http" should {
+    "allow registering custom method" in {
+      import system.dispatcher
+      val (_, host, port) = TestUtils.temporaryServerHostnameAndPort()
+
+      //#application-custom
+      import akka.http.scaladsl.settings.{ ParserSettings, ServerSettings }
+
+      // define custom media type:
+      val BOLT = HttpMethod.custom("BOLT", safe = false,
+        idempotent = true, requestEntityAcceptance = Expected)
+
+      // add custom method to parser settings:
+      val parserSettings = ParserSettings(system).withCustomMethods(BOLT)
+      val serverSettings = ServerSettings(system).withParserSettings(parserSettings)
+
+      val routes = extractMethod { method ⇒
+        complete(s"This is a ${method.name} method request.")
+      }
+      val binding = Http().bindAndHandle(routes, host, port, settings = serverSettings)
+      //#application-custom
+
+      val request = HttpRequest(BOLT, s"http://$host:$port/", protocol = `HTTP/1.0`)
+      val response = Http().singleRequest(request).futureValue
+
+      response.status should ===(StatusCodes.OK)
+      val responseBody = response.toStrict(1.second).futureValue.entity.dataBytes.runFold(ByteString.empty)(_ ++ _).futureValue.utf8String
+      responseBody should ===("This is a BOLT method request.")
+    }
+  }
+}
+
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala
index 4ff330a9eb..6c32784c76 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala
@@ -4,8 +4,11 @@
 
 package docs.http.scaladsl.server.directives
 
-import akka.event.Logging
+import akka.event.{ LoggingAdapter, Logging }
+import akka.event.Logging.LogLevel
 import akka.http.scaladsl.model.{ HttpRequest, HttpResponse }
+import akka.http.scaladsl.server.RouteResult
+import akka.http.scaladsl.server.RouteResult.{ Rejected, Complete }
 import akka.http.scaladsl.server.directives.{ DebuggingDirectives, LogEntry, LoggingMagnet }
 import docs.http.scaladsl.server.RoutingSpec
 
@@ -21,15 +24,15 @@ class DebuggingDirectivesExamplesSpec extends RoutingSpec {
     DebuggingDirectives.logRequest(("get-user", Logging.InfoLevel))
 
     // logs just the request method at debug level
-    def requestMethod(req: HttpRequest): String = req.method.toString
+    def requestMethod(req: HttpRequest): String = req.method.name
     DebuggingDirectives.logRequest(requestMethod _)
 
     // logs just the request method at info level
-    def requestMethodAsInfo(req: HttpRequest): LogEntry = LogEntry(req.method.toString, Logging.InfoLevel)
+    def requestMethodAsInfo(req: HttpRequest): LogEntry = LogEntry(req.method.name, Logging.InfoLevel)
     DebuggingDirectives.logRequest(requestMethodAsInfo _)
 
     // This one doesn't use the implicit LoggingContext but uses `println` for logging
-    def printRequestMethod(req: HttpRequest): Unit = println(req.method)
+    def printRequestMethod(req: HttpRequest): Unit = println(req.method.name)
     val logRequestPrintln = DebuggingDirectives.logRequest(LoggingMagnet(_ => printRequestMethod))
 
     // tests:
@@ -48,14 +51,14 @@ class DebuggingDirectivesExamplesSpec extends RoutingSpec {
     DebuggingDirectives.logRequestResult(("get-user", Logging.InfoLevel))
 
     // logs just the request method and response status at info level
-    def requestMethodAndResponseStatusAsInfo(req: HttpRequest): Any => Option[LogEntry] = {
-      case res: HttpResponse => Some(LogEntry(req.method + ":" + res.status, Logging.InfoLevel))
-      case _                 => None // other kind of responses
+    def requestMethodAndResponseStatusAsInfo(req: HttpRequest): RouteResult => Option[LogEntry] = {
+      case RouteResult.Complete(res) => Some(LogEntry(req.method.name + ": " + res.status, Logging.InfoLevel))
+      case _                         => None // no log entries for rejections
     }
     DebuggingDirectives.logRequestResult(requestMethodAndResponseStatusAsInfo _)
 
     // This one doesn't use the implicit LoggingContext but uses `println` for logging
-    def printRequestMethodAndResponseStatus(req: HttpRequest)(res: Any): Unit =
+    def printRequestMethodAndResponseStatus(req: HttpRequest)(res: RouteResult): Unit =
       println(requestMethodAndResponseStatusAsInfo(req)(res).map(_.obj.toString).getOrElse(""))
     val logRequestResultPrintln = DebuggingDirectives.logRequestResult(LoggingMagnet(_ => printRequestMethodAndResponseStatus))
 
@@ -75,18 +78,18 @@ class DebuggingDirectivesExamplesSpec extends RoutingSpec {
     DebuggingDirectives.logResult(("get-user", Logging.InfoLevel))
 
     // logs just the response status at debug level
-    def responseStatus(res: Any): String = res match {
-      case x: HttpResponse => x.status.toString
-      case _               => "unknown response part"
+    def responseStatus(res: RouteResult): String = res match {
+      case RouteResult.Complete(x)          => x.status.toString
+      case RouteResult.Rejected(rejections) => "Rejected: " + rejections.mkString(", ")
     }
     DebuggingDirectives.logResult(responseStatus _)
 
     // logs just the response status at info level
-    def responseStatusAsInfo(res: Any): LogEntry = LogEntry(responseStatus(res), Logging.InfoLevel)
+    def responseStatusAsInfo(res: RouteResult): LogEntry = LogEntry(responseStatus(res), Logging.InfoLevel)
     DebuggingDirectives.logResult(responseStatusAsInfo _)
 
     // This one doesn't use the implicit LoggingContext but uses `println` for logging
-    def printResponseStatus(res: Any): Unit = println(responseStatus(res))
+    def printResponseStatus(res: RouteResult): Unit = println(responseStatus(res))
     val logResultPrintln = DebuggingDirectives.logResult(LoggingMagnet(_ => printResponseStatus))
 
     // tests:
@@ -94,4 +97,32 @@ class DebuggingDirectivesExamplesSpec extends RoutingSpec {
       responseAs[String] shouldEqual "logged"
     }
   }
+  "logRequestResultWithResponseTime" in {
+
+    def akkaResponseTimeLoggingFunction(
+      loggingAdapter:   LoggingAdapter,
+      requestTimestamp: Long,
+      level:            LogLevel       = Logging.InfoLevel)(req: HttpRequest)(res: Any): Unit = {
+      val entry = res match {
+        case Complete(resp) =>
+          val responseTimestamp: Long = System.nanoTime
+          val elapsedTime: Long = (responseTimestamp - requestTimestamp) / 1000000
+          val loggingString = s"""Logged Request:${req.method}:${req.uri}:${resp.status}:${elapsedTime}"""
+          LogEntry(loggingString, level)
+        case Rejected(reason) =>
+          LogEntry(s"Rejected Reason: ${reason.mkString(",")}", level)
+      }
+      entry.logTo(loggingAdapter)
+    }
+    def printResponseTime(log: LoggingAdapter) = {
+      val requestTimestamp = System.nanoTime
+      akkaResponseTimeLoggingFunction(log, requestTimestamp)(_)
+    }
+
+    val logResponseTime = DebuggingDirectives.logRequestResult(LoggingMagnet(printResponseTime(_)))
+
+    Get("/") ~> logResponseTime(complete("logged")) ~> check {
+      responseAs[String] shouldEqual "logged"
+    }
+  }
 }
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/FileUploadDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/FileUploadDirectivesExamplesSpec.scala
index 694581f5ab..1bad238591 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/FileUploadDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/FileUploadDirectivesExamplesSpec.scala
@@ -4,15 +4,21 @@
 package docs.http.scaladsl.server.directives
 
 import akka.http.scaladsl.model._
+import akka.http.scaladsl.testkit.RouteTestTimeout
 import akka.stream.scaladsl.Framing
 import akka.util.ByteString
 import docs.http.scaladsl.server.RoutingSpec
+import akka.testkit.TestDuration
 import scala.concurrent.Future
+import scala.concurrent.duration._
 
 class FileUploadDirectivesExamplesSpec extends RoutingSpec {
 
   override def testConfigSource = "akka.actor.default-mailbox.mailbox-type = \"akka.dispatch.UnboundedMailbox\""
 
+  // test touches disk, so give it some time
+  implicit val routeTimeout = RouteTestTimeout(3.seconds.dilated)
+
   "uploadedFile" in {
 
     val route =
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/HeaderDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/HeaderDirectivesExamplesSpec.scala
index 695f23dcf8..e417ca35a4 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/HeaderDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/HeaderDirectivesExamplesSpec.scala
@@ -209,13 +209,13 @@ class HeaderDirectivesExamplesSpec extends RoutingSpec with Inside {
     val invalidOriginHeader = Origin(invalidHttpOrigin)
     Get("abc") ~> invalidOriginHeader ~> route ~> check {
       inside(rejection) {
-        case InvalidOriginRejection(invalidOrigins) ⇒
-          invalidOrigins shouldEqual Seq(invalidHttpOrigin)
+        case InvalidOriginRejection(allowedOrigins) ⇒
+          allowedOrigins shouldEqual Seq(correctOrigin)
       }
     }
     Get("abc") ~> invalidOriginHeader ~> Route.seal(route) ~> check {
       status shouldEqual StatusCodes.Forbidden
-      responseAs[String] should include(s"${invalidHttpOrigin.value}")
+      responseAs[String] should include(s"${correctOrigin.value}")
     }
   }
 }
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
new file mode 100644
index 0000000000..2f4b2e6766
--- /dev/null
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2009-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package docs.http.scaladsl.server.directives
+
+import akka.NotUsed
+import akka.http.scaladsl.common.{ EntityStreamingSupport, JsonEntityStreamingSupport }
+import akka.http.scaladsl.marshalling._
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.headers.Accept
+import akka.http.scaladsl.server.{ UnacceptedResponseContentTypeRejection, UnsupportedRequestContentTypeRejection }
+import akka.stream.scaladsl.{ Flow, Source }
+import akka.util.ByteString
+import docs.http.scaladsl.server.RoutingSpec
+
+import scala.concurrent.Future
+
+class JsonStreamingExamplesSpec extends RoutingSpec {
+
+  //#models
+  case class Tweet(uid: Int, txt: String)
+  case class Measurement(id: String, value: Int)
+  //#
+
+  val tweets = List(
+    Tweet(1, "#Akka rocks!"),
+    Tweet(2, "Streaming is so hot right now!"),
+    Tweet(3, "You cannot enter the same river twice."))
+  def getTweets = Source(tweets)
+
+  //#formats
+  object MyJsonProtocol
+    extends akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
+    with spray.json.DefaultJsonProtocol {
+
+    implicit val tweetFormat = jsonFormat2(Tweet.apply)
+    implicit val measurementFormat = jsonFormat2(Measurement.apply)
+  }
+  //#
+
+  "spray-json-response-streaming" in {
+    // [1] import "my protocol", for marshalling Tweet objects:
+    import MyJsonProtocol._
+
+    // [2] pick a Source rendering support trait:
+    // Note that the default support renders the Source as JSON Array
+    implicit val jsonStreamingSupport: JsonEntityStreamingSupport = EntityStreamingSupport.json()
+
+    val route =
+      path("tweets") {
+        // [3] simply complete a request with a source of tweets:
+        val tweets: Source[Tweet, NotUsed] = getTweets
+        complete(tweets)
+      }
+
+    // tests ------------------------------------------------------------
+    val AcceptJson = Accept(MediaRange(MediaTypes.`application/json`))
+    val AcceptXml = Accept(MediaRange(MediaTypes.`text/xml`))
+
+    Get("/tweets").withHeaders(AcceptJson) ~> route ~> check {
+      responseAs[String] shouldEqual
+        """[""" +
+        """{"uid":1,"txt":"#Akka rocks!"},""" +
+        """{"uid":2,"txt":"Streaming is so hot right now!"},""" +
+        """{"uid":3,"txt":"You cannot enter the same river twice."}""" +
+        """]"""
+    }
+
+    // endpoint can only marshal Json, so it will *reject* requests for application/xml:
+    Get("/tweets").withHeaders(AcceptXml) ~> route ~> check {
+      handled should ===(false)
+      rejection should ===(UnacceptedResponseContentTypeRejection(Set(ContentTypes.`application/json`)))
+    }
+  }
+
+  "line-by-line-json-response-streaming" in {
+    import MyJsonProtocol._
+
+    // Configure the EntityStreamingSupport to render the elements as:
+    // {"example":42}
+    // {"example":43}
+    // ...
+    // {"example":1000}
+    val start = ByteString.empty
+    val sep = ByteString("\n")
+    val end = ByteString.empty
+
+    implicit val jsonStreamingSupport = EntityStreamingSupport.json()
+      .withFramingRenderer(Flow[ByteString].intersperse(start, sep, end))
+
+    val route =
+      path("tweets") {
+        // [3] simply complete a request with a source of tweets:
+        val tweets: Source[Tweet, NotUsed] = getTweets
+        complete(tweets)
+      }
+
+    // tests ------------------------------------------------------------
+    val AcceptJson = Accept(MediaRange(MediaTypes.`application/json`))
+
+    Get("/tweets").withHeaders(AcceptJson) ~> route ~> check {
+      responseAs[String] shouldEqual
+        """{"uid":1,"txt":"#Akka rocks!"}""" + "\n" +
+        """{"uid":2,"txt":"Streaming is so hot right now!"}""" + "\n" +
+        """{"uid":3,"txt":"You cannot enter the same river twice."}"""
+    }
+  }
+
+  "csv-example" in {
+    // [1] provide a marshaller to ByteString
+    implicit val tweetAsCsv = Marshaller.strict[Tweet, ByteString] { t =>
+      Marshalling.WithFixedContentType(ContentTypes.`text/csv(UTF-8)`, () => {
+        val txt = t.txt.replaceAll(",", ".")
+        val uid = t.uid
+        ByteString(List(uid, txt).mkString(","))
+      })
+    }
+
+    // [2] enable csv streaming:
+    implicit val csvStreaming = EntityStreamingSupport.csv()
+
+    val route =
+      path("tweets") {
+        val tweets: Source[Tweet, NotUsed] = getTweets
+        complete(tweets)
+      }
+
+    // tests ------------------------------------------------------------
+    val AcceptCsv = Accept(MediaRange(MediaTypes.`text/csv`))
+
+    Get("/tweets").withHeaders(AcceptCsv) ~> route ~> check {
+      responseAs[String] shouldEqual
+        "1,#Akka rocks!" + "\n" +
+        "2,Streaming is so hot right now!" + "\n" +
+        "3,You cannot enter the same river twice."
+    }
+  }
+
+  "response-streaming-modes" in {
+
+    {
+      //#async-rendering 
+      import MyJsonProtocol._
+      implicit val jsonStreamingSupport: JsonEntityStreamingSupport =
+        EntityStreamingSupport.json()
+          .withParallelMarshalling(parallelism = 8, unordered = false)
+
+      path("tweets") {
+        val tweets: Source[Tweet, NotUsed] = getTweets
+        complete(tweets)
+      }
+      //#
+    }
+
+    {
+
+      //#async-unordered-rendering
+      import MyJsonProtocol._
+      implicit val jsonStreamingSupport: JsonEntityStreamingSupport =
+        EntityStreamingSupport.json()
+          .withParallelMarshalling(parallelism = 8, unordered = true)
+
+      path("tweets" / "unordered") {
+        val tweets: Source[Tweet, NotUsed] = getTweets
+        complete(tweets)
+      }
+      //#
+    }
+  }
+
+  "spray-json-request-streaming" in {
+    // [1] import "my protocol", for unmarshalling Measurement objects:
+    import MyJsonProtocol._
+
+    // [2] enable Json Streaming
+    implicit val jsonStreamingSupport = EntityStreamingSupport.json()
+
+    // prepare your persisting logic here
+    val persistMetrics = Flow[Measurement]
+
+    val route =
+      path("metrics") {
+        // [3] extract Source[Measurement, _]
+        entity(asSourceOf[Measurement]) { measurements =>
+          // alternative syntax:
+          // entity(as[Source[Measurement, NotUsed]]) { measurements =>
+          val measurementsSubmitted: Future[Int] =
+            measurements
+              .via(persistMetrics)
+              .runFold(0) { (cnt, _) => cnt + 1 }
+
+          complete {
+            measurementsSubmitted.map(n => Map("msg" -> s"""Total metrics received: $n"""))
+          }
+        }
+      }
+
+    // tests ------------------------------------------------------------
+    // uploading an array or newline separated values works out of the box
+    val data = HttpEntity(
+      ContentTypes.`application/json`,
+      """
+        |{"id":"temp","value":32}
+        |{"id":"temp","value":31}
+        |
+      """.stripMargin)
+
+    Post("/metrics", entity = data) ~> route ~> check {
+      status should ===(StatusCodes.OK)
+      responseAs[String] should ===("""{"msg":"Total metrics received: 2"}""")
+    }
+
+    // the FramingWithContentType will reject any content type that it does not understand:
+    val xmlData = HttpEntity(
+      ContentTypes.`text/xml(UTF-8)`,
+      """|<data id="temp" value="32"/>
+         |<data id="temp" value="31"/>""".stripMargin)
+
+    Post("/metrics", entity = xmlData) ~> route ~> check {
+      handled should ===(false)
+      rejection should ===(UnsupportedRequestContentTypeRejection(Set(ContentTypes.`application/json`)))
+    }
+  }
+
+}
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/MarshallingDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/MarshallingDirectivesExamplesSpec.scala
index a0720452cd..8f7c855dc9 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/MarshallingDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/MarshallingDirectivesExamplesSpec.scala
@@ -71,8 +71,8 @@ class MarshallingDirectivesExamplesSpec extends RoutingSpec {
     // tests:
     Get("/") ~> route ~> check {
       mediaType shouldEqual `application/json`
-      responseAs[String] should include(""""name": "Jane"""")
-      responseAs[String] should include(""""favoriteNumber": 42""")
+      responseAs[String] should include(""""name":"Jane"""")
+      responseAs[String] should include(""""favoriteNumber":42""")
     }
   }
 
@@ -95,8 +95,8 @@ class MarshallingDirectivesExamplesSpec extends RoutingSpec {
     Post("/", HttpEntity(`application/json`, """{ "name": "Jane", "favoriteNumber" : 42 }""")) ~>
       route ~> check {
         mediaType shouldEqual `application/json`
-        responseAs[String] should include(""""name": "Jane"""")
-        responseAs[String] should include(""""favoriteNumber": 42""")
+        responseAs[String] should include(""""name":"Jane"""")
+        responseAs[String] should include(""""favoriteNumber":42""")
       }
   }
 }
diff --git a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/SecurityDirectivesExamplesSpec.scala b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/SecurityDirectivesExamplesSpec.scala
index 00981f4f06..4cc8d7ee77 100644
--- a/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/SecurityDirectivesExamplesSpec.scala
+++ b/akka-docs/rst/scala/code/docs/http/scaladsl/server/directives/SecurityDirectivesExamplesSpec.scala
@@ -34,7 +34,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
     Get("/secured") ~> route ~> check {
       status shouldEqual StatusCodes.Unauthorized
       responseAs[String] shouldEqual "The resource requires authentication, which was not supplied with the request"
-      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
     }
 
     val validCredentials = BasicHttpCredentials("John", "p4ssw0rd")
@@ -49,7 +49,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
       route ~> check {
         status shouldEqual StatusCodes.Unauthorized
         responseAs[String] shouldEqual "The supplied authentication is invalid"
-        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
       }
   }
   "authenticateBasicPF-0" in {
@@ -71,7 +71,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
     Get("/secured") ~> route ~> check {
       status shouldEqual StatusCodes.Unauthorized
       responseAs[String] shouldEqual "The resource requires authentication, which was not supplied with the request"
-      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
     }
 
     val validCredentials = BasicHttpCredentials("John", "p4ssw0rd")
@@ -92,7 +92,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
       route ~> check {
         status shouldEqual StatusCodes.Unauthorized
         responseAs[String] shouldEqual "The supplied authentication is invalid"
-        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
       }
   }
   "authenticateBasicPFAsync-0" in {
@@ -120,7 +120,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
     Get("/secured") ~> route ~> check {
       status shouldEqual StatusCodes.Unauthorized
       responseAs[String] shouldEqual "The resource requires authentication, which was not supplied with the request"
-      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
     }
 
     val validCredentials = BasicHttpCredentials("John", "p4ssw0rd")
@@ -135,7 +135,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
       route ~> check {
         status shouldEqual StatusCodes.Unauthorized
         responseAs[String] shouldEqual "The supplied authentication is invalid"
-        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
       }
   }
   "authenticateBasicAsync-0" in {
@@ -163,7 +163,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
     Get("/secured") ~> route ~> check {
       status shouldEqual StatusCodes.Unauthorized
       responseAs[String] shouldEqual "The resource requires authentication, which was not supplied with the request"
-      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
     }
 
     val validCredentials = BasicHttpCredentials("John", "p4ssw0rd")
@@ -178,11 +178,11 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
       route ~> check {
         status shouldEqual StatusCodes.Unauthorized
         responseAs[String] shouldEqual "The supplied authentication is invalid"
-        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", "secure site")
+        header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("Basic", Some("secure site"))
       }
   }
   "authenticateOrRejectWithChallenge-0" in {
-    val challenge = HttpChallenge("MyAuth", "MyRealm")
+    val challenge = HttpChallenge("MyAuth", Some("MyRealm"))
 
     // your custom authentication logic:
     def auth(creds: HttpCredentials): Boolean = true
@@ -208,7 +208,7 @@ class SecurityDirectivesExamplesSpec extends RoutingSpec {
     Get("/secured") ~> route ~> check {
       status shouldEqual StatusCodes.Unauthorized
       responseAs[String] shouldEqual "The resource requires authentication, which was not supplied with the request"
-      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("MyAuth", "MyRealm")
+      header[`WWW-Authenticate`].get.challenges.head shouldEqual HttpChallenge("MyAuth", Some("MyRealm"))
     }
 
     val validCredentials = BasicHttpCredentials("John", "p4ssw0rd")
diff --git a/akka-docs/rst/scala/code/docs/routing/RouterDocSpec.scala b/akka-docs/rst/scala/code/docs/routing/RouterDocSpec.scala
index 29b13a85ba..40de0a8645 100644
--- a/akka-docs/rst/scala/code/docs/routing/RouterDocSpec.scala
+++ b/akka-docs/rst/scala/code/docs/routing/RouterDocSpec.scala
@@ -101,6 +101,18 @@ akka.actor.deployment {
   }
 }
 #//#config-balancing-pool3
+
+#//#config-balancing-pool4
+akka.actor.deployment {
+  /parent/router10c {
+    router = balancing-pool
+    nr-of-instances = 5
+    pool-dispatcher {
+      mailbox = myapp.myprioritymailbox
+    }
+  }
+}
+#//#config-balancing-pool4
     
 #//#config-smallest-mailbox-pool
 akka.actor.deployment {
diff --git a/akka-docs/rst/scala/code/docs/stream/GraphStageDocSpec.scala b/akka-docs/rst/scala/code/docs/stream/GraphStageDocSpec.scala
index 0defd9a17e..efb3437c95 100644
--- a/akka-docs/rst/scala/code/docs/stream/GraphStageDocSpec.scala
+++ b/akka-docs/rst/scala/code/docs/stream/GraphStageDocSpec.scala
@@ -4,15 +4,14 @@
 package docs.stream
 
 import akka.NotUsed
-import akka.stream.scaladsl.{ Keep, Sink, Flow, Source }
+import akka.stream.scaladsl.{ Flow, Keep, Sink, Source }
 import akka.stream.stage._
 import akka.stream._
-
 import akka.stream.testkit.{ TestPublisher, TestSubscriber }
 import akka.testkit.{ AkkaSpec, TestLatch }
 
 import scala.collection.mutable
-import scala.concurrent.{ Promise, Await, Future }
+import scala.concurrent.{ Await, Future, Promise }
 import scala.concurrent.duration._
 import scala.collection.immutable.Iterable
 
@@ -86,6 +85,35 @@ class GraphStageDocSpec extends AkkaSpec {
     Await.result(result2, 3.seconds) should ===(5050)
   }
 
+  "Demonstrate creation of GraphStage Sink" in {
+    //#custom-sink-example
+    import akka.stream.SinkShape
+    import akka.stream.stage.GraphStage
+    import akka.stream.stage.InHandler
+
+    class StdoutSink extends GraphStage[SinkShape[Int]] {
+      val in: Inlet[Int] = Inlet("StdoutSink")
+      override val shape: SinkShape[Int] = SinkShape(in)
+
+      override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+        new GraphStageLogic(shape) {
+
+          // This requests one element at the Sink startup.
+          override def preStart(): Unit = pull(in)
+
+          setHandler(in, new InHandler {
+            override def onPush(): Unit = {
+              println(grab(in))
+              pull(in)
+            }
+          })
+        }
+    }
+    //#custom-sink-example
+
+    Source(List(0, 1, 2)).runWith(Sink.fromGraph(new StdoutSink))
+  }
+
   //#one-to-one
   class Map[A, B](f: A => B) extends GraphStage[FlowShape[A, B]] {
 
diff --git a/akka-docs/rst/scala/code/docs/stream/StreamBuffersRateSpec.scala b/akka-docs/rst/scala/code/docs/stream/StreamBuffersRateSpec.scala
index dc29301e75..eee8237169 100644
--- a/akka-docs/rst/scala/code/docs/stream/StreamBuffersRateSpec.scala
+++ b/akka-docs/rst/scala/code/docs/stream/StreamBuffersRateSpec.scala
@@ -30,7 +30,7 @@ class StreamBuffersRateSpec extends AkkaSpec {
 
     //#section-buffer
     val section = Flow[Int].map(_ * 2).async
-      .withAttributes(Attributes.inputBuffer(initial = 1, max = 1)) // the buffer size of this map is 1
+      .addAttributes(Attributes.inputBuffer(initial = 1, max = 1)) // the buffer size of this map is 1
     val flow = section.via(Flow[Int].map(_ / 2)).async // the buffer size of this map is the default
     //#section-buffer
   }
diff --git a/akka-docs/rst/scala/code/docs/stream/cookbook/RecipeByteStrings.scala b/akka-docs/rst/scala/code/docs/stream/cookbook/RecipeByteStrings.scala
index 4c5f1d356e..8cea3af8d8 100644
--- a/akka-docs/rst/scala/code/docs/stream/cookbook/RecipeByteStrings.scala
+++ b/akka-docs/rst/scala/code/docs/stream/cookbook/RecipeByteStrings.scala
@@ -42,8 +42,15 @@ class RecipeByteStrings extends RecipeSpec {
 
             override def onUpstreamFinish(): Unit = {
               if (buffer.isEmpty) completeStage()
-              // elements left in buffer, keep accepting downstream pulls
-              // and push from buffer until buffer is emitted
+              else {
+                // There are elements left in buffer, so
+                // we keep accepting downstream pulls and push from buffer until emptied.
+                //
+                // It might be though, that the upstream finished while it was pulled, in which
+                // case we will not get an onPull from the downstream, because we already had one.
+                // In that case we need to emit from the buffer.
+                if (isAvailable(out)) emitChunk()
+              }
             }
           })
 
diff --git a/akka-docs/rst/scala/dispatchers.rst b/akka-docs/rst/scala/dispatchers.rst
index ad391b9482..83d53776e8 100644
--- a/akka-docs/rst/scala/dispatchers.rst
+++ b/akka-docs/rst/scala/dispatchers.rst
@@ -44,6 +44,10 @@ And here's another example that uses the "thread-pool-executor":
 
 .. includecode:: ../scala/code/docs/dispatcher/DispatcherDocSpec.scala#my-thread-pool-dispatcher-config
 
+.. note::
+  The thread pool executor dispatcher is implemented using by a ``java.util.concurrent.ThreadPoolExecutor``.
+  You can read more about it in the JDK's `ThreadPoolExecutor documentation`_.
+
 For more options, see the default-dispatcher section of the :ref:`configuration`.
 
 Then you create the actor as usual and define the dispatcher in the deployment configuration.
@@ -65,7 +69,7 @@ of programmatically provided parameter.
     where you'd use periods to denote sub-sections, like this: ``"foo.bar.my-dispatcher"``
 
 .. _ForkJoinPool documentation: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ForkJoinPool.html
-
+.. _ThreadPoolExecutor documentation: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html
 Types of dispatchers
 --------------------
 
diff --git a/akka-docs/rst/scala/fsm.rst b/akka-docs/rst/scala/fsm.rst
index 1b8636eee0..ea20f39540 100644
--- a/akka-docs/rst/scala/fsm.rst
+++ b/akka-docs/rst/scala/fsm.rst
@@ -8,7 +8,7 @@ FSM
 Overview
 ========
 
-The FSM (Finite State Machine) is available as a mixin for the akka Actor and
+The FSM (Finite State Machine) is available as a mixin for the Akka Actor and
 is best described in the `Erlang design principles
 <http://www.erlang.org/documentation/doc-4.8.2/doc/design_principles/fsm.html>`_
 
diff --git a/akka-docs/rst/scala/http/client-side/websocket-support.rst b/akka-docs/rst/scala/http/client-side/websocket-support.rst
index 79f88e4002..f432d40a70 100644
--- a/akka-docs/rst/scala/http/client-side/websocket-support.rst
+++ b/akka-docs/rst/scala/http/client-side/websocket-support.rst
@@ -27,13 +27,13 @@ HTTP result can be found in ``WebSocketUpgradeResponse.response``
 Message
 -------
 Messages sent and received over a WebSocket can be either :class:`TextMessage` s or :class:`BinaryMessage` s and each
-of those has two subtypes :class:`Strict` or :class:`Streaming`. In typical applications messages will be ``Strict`` as
+of those has two subtypes :class:`Strict` or :class:`Streamed`. In typical applications messages will be ``Strict`` as
 WebSockets are usually deployed to communicate using small messages not stream data, the protocol does however
 allow this (by not marking the first fragment as final, as described in `rfc 6455 section 5.2`__).
 
 __ https://tools.ietf.org/html/rfc6455#section-5.2
 
-For such streaming messages :class:`BinaryMessage.Streaming` and :class:`TextMessage.Streaming` will be used. In these cases
+For such streamed messages :class:`BinaryMessage.Streamed` and :class:`TextMessage.Streamed` will be used. In these cases
 the data is provided as a ``Source[ByteString, NotUsed]`` for binary and ``Source[String, NotUsed]`` for text messages.
 
 
diff --git a/akka-docs/rst/scala/http/common/json-support.rst b/akka-docs/rst/scala/http/common/json-support.rst
index 5c3aab6c47..835a26617d 100644
--- a/akka-docs/rst/scala/http/common/json-support.rst
+++ b/akka-docs/rst/scala/http/common/json-support.rst
@@ -33,8 +33,8 @@ This is how you enable automatic support for (un)marshalling from and to JSON wi
 
 Once you have done this (un)marshalling between JSON and your type ``T`` should work nicely and transparently.
 
-.. includecode:: ../../code/docs/http/scaladsl/SprayJsonExampleSpec.scala
-  :include: example
+.. includecode2:: ../../code/docs/http/scaladsl/SprayJsonExampleSpec.scala
+  :snippet: minimal-spray-json-example
 
 4. By default, spray-json marshals your types to pretty printed json by implicit conversion using PrettyPrinter, as defined in
    ``implicit def sprayJsonMarshallerConverter[T](writer: RootJsonWriter[T])(implicit printer: JsonPrinter = PrettyPrinter): ToEntityMarshaller[T]``.
diff --git a/akka-docs/rst/scala/http/common/timeouts.rst b/akka-docs/rst/scala/http/common/timeouts.rst
index b4996bbf78..dea4158a9f 100644
--- a/akka-docs/rst/scala/http/common/timeouts.rst
+++ b/akka-docs/rst/scala/http/common/timeouts.rst
@@ -10,6 +10,8 @@ are left to the streaming APIs and are easily implementable as patterns in user-
 Common timeouts
 ---------------
 
+.. _idle-timeouts-scala:
+
 Idle timeouts
 ^^^^^^^^^^^^^
 
@@ -22,8 +24,8 @@ independently for each of those using the following keys::
 
     akka.http.server.idle-timeout
     akka.http.client.idle-timeout
-    akka.http.http-connection-pool.idle-timeout
-    akka.http.http-connection-pool.client.idle-timeout
+    akka.http.host-connection-pool.idle-timeout
+    akka.http.host-connection-pool.client.idle-timeout
 
 .. note::
   For the connection pooled client side the idle period is counted only when the pool has no pending requests waiting.
diff --git a/akka-docs/rst/scala/http/handling-blocking-operations-in-akka-http-routes.rst b/akka-docs/rst/scala/http/handling-blocking-operations-in-akka-http-routes.rst
index 3dd622e2da..e264edd487 100644
--- a/akka-docs/rst/scala/http/handling-blocking-operations-in-akka-http-routes.rst
+++ b/akka-docs/rst/scala/http/handling-blocking-operations-in-akka-http-routes.rst
@@ -74,7 +74,7 @@ be configured as follows::
   my-blocking-dispatcher {
     type = Dispatcher
     executor = "thread-pool-executor"
-    thread-pool-executer {
+    thread-pool-executor {
       // or in Akka 2.4.2+
       fixed-pool-size = 16
     }
@@ -83,7 +83,7 @@ be configured as follows::
 
 There are many dispatcher options available which can be found in :ref:`dispatchers-scala`.
 
-Here ``thread-pool-executer`` is used, which has a hard limit of threads, it can
+Here ``thread-pool-executor`` is used, which has a hard limit of threads, it can
 keep available for blocking operations. The size settings depend on the app
 functionality and the number of cores the server has.
 
diff --git a/akka-docs/rst/scala/http/implications-of-streaming-http-entity.rst b/akka-docs/rst/scala/http/implications-of-streaming-http-entity.rst
index d6a0403eef..c53d68859e 100644
--- a/akka-docs/rst/scala/http/implications-of-streaming-http-entity.rst
+++ b/akka-docs/rst/scala/http/implications-of-streaming-http-entity.rst
@@ -23,12 +23,12 @@ Client-Side handling of streaming HTTP Entities
 Consuming the HTTP Response Entity (Client)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The most commong use-case of course is consuming the response entity, which can be done via
+The most common use-case of course is consuming the response entity, which can be done via
 running the underlying ``dataBytes`` Source. This is as simple as running the dataBytes source,
 (or on the server-side using directives such as 
 
 It is encouraged to use various streaming techniques to utilise the underlying infrastructure to its fullest,
-for example by framing the incoming chunks, parsing them line-by-line and the connecting the flow into another 
+for example by framing the incoming chunks, parsing them line-by-line and then connecting the flow into another
 destination Sink, such as a File or other Akka Streams connector:
 
 .. includecode:: ../code/docs/http/scaladsl/HttpClientExampleSpec.scala
@@ -116,7 +116,7 @@ Closing connections is also explained in depth in the :ref:`http-closing-connect
 Pending: Automatic discarding of not used entities
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Under certin conditions is is possible to detect an entity is very unlikely to be used by the user for a given request,
+Under certain conditions it is possible to detect an entity is very unlikely to be used by the user for a given request,
 and issue warnings or discard the entity automatically. This advanced feature has not been implemented yet, see the below
 note and issues for further discussion and ideas.
 
diff --git a/akka-docs/rst/scala/http/migration-guide-2.4.x-experimental.rst b/akka-docs/rst/scala/http/migration-guide-2.4.x-experimental.rst
index 23f9e5eeae..fd7d36e05b 100644
--- a/akka-docs/rst/scala/http/migration-guide-2.4.x-experimental.rst
+++ b/akka-docs/rst/scala/http/migration-guide-2.4.x-experimental.rst
@@ -19,8 +19,24 @@ versions of the **experimental** part of Akka HTTP.
 Akka HTTP 2.4.7 -> 2.4.8
 ------------------------
 
-`SecurityDirectives#challengeFor` has moved
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The `challengeFor` directive was actually more like a factory for `HttpChallenge`,
-thus it was moved to become such. It is now available as `akka.http.javadsl.model.headers.HttpChallenge#create[Basic|OAuth2]`
-for JavaDSL and `akka.http.scaladsl.model.headers.HttpChallenges#[basic|oAuth2]` for ScalaDSL.
+``SecurityDirectives#challengeFor`` has moved
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The ``challengeFor`` directive was actually more like a factory for ``HttpChallenge``,
+thus it was moved to become such. It is now available as ``akka.http.javadsl.model.headers.HttpChallenge#create[Basic|OAuth2]``
+for JavaDSL and ``akka.http.scaladsl.model.headers.HttpChallenges#[basic|oAuth2]`` for ScalaDSL.
+
+Akka HTTP 2.4.8 -> 2.4.9
+------------------------
+
+Java DSL Package structure changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We have aligned the package structure of the Java based DSL with the Scala based DSL
+and moved classes that were in the wrong or unexpected places around a bit. This means
+that Java DSL users must update their imports as follows:
+
+Classes dealing with unmarshalling and marshalling used to reside in ``akka.http.javadsl.server``,
+but are now available from the packages ``akka.http.javadsl.unmarshalling`` and ``akka.http.javadsl.marshalling``.
+
+``akka.http.javadsl.server.Coder`` is now ``akka.http.javadsl.coding.Coder``.
+
+``akka.http.javadsl.server.RegexConverters`` is now ``akka.http.javadsl.common.RegexConverters``.
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractActorSystem.rst b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractActorSystem.rst
new file mode 100644
index 0000000000..e3e2340257
--- /dev/null
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractActorSystem.rst
@@ -0,0 +1,26 @@
+.. _-extractActorSystem-:
+
+extractActorSystem
+==================
+
+Signature
+---------
+
+.. includecode2:: /../../akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
+   :snippet: extractActorSystem
+
+Description
+-----------
+
+Extracts the ``ActorSystem`` from the ``RequestContext``, which can be useful when the external API
+in your route needs one.
+
+.. warning::
+
+  This is only supported when the available Materializer is an ActorMaterializer.
+
+Example
+-------
+
+.. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
+   :snippet: extractActorSystem-example
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst
new file mode 100644
index 0000000000..29ca0aa174
--- /dev/null
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/extractStrictEntity.rst
@@ -0,0 +1,30 @@
+.. _-extractStrictEntity-:
+
+extractStrictEntity
+===================
+
+Signature
+---------
+
+.. includecode2:: /../../akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
+   :snippet: extractStrictEntity
+
+Description
+-----------
+
+Extracts the strict http entity as ``HttpEntity.Strict`` from the :class:`RequestContext`.
+
+A timeout parameter is given and if the stream isn't completed after the timeout, the directive will be failed.
+
+.. warning::
+
+  The directive will read the request entity into memory within the size limit(8M by default) and effectively disable streaming.
+  The size limit can be configured globally with ``akka.http.parsing.max-content-length`` or
+  overridden by wrapping with :ref:`-withSizeLimit-` or :ref:`-withoutSizeLimit-` directive.
+
+
+Example
+-------
+
+.. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
+   :snippet: extractStrictEntity-example
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/index.rst b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/index.rst
index 709f7d7b29..4395e8da9f 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/index.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/index.rst
@@ -17,9 +17,11 @@ on two axes: a) provide a constant value or extract a value from the ``RequestCo
 a single value or a tuple of values.
 
   * :ref:`-extract-`
+  * :ref:`-extractActorSystem-`
   * :ref:`-extractDataBytes-`
   * :ref:`-extractExecutionContext-`
   * :ref:`-extractMaterializer-`
+  * :ref:`-extractStrictEntity-`
   * :ref:`-extractLog-`
   * :ref:`-extractRequest-`
   * :ref:`-extractRequestContext-`
@@ -45,6 +47,7 @@ Transforming the Request(Context)
   * :ref:`-withMaterializer-`
   * :ref:`-withLog-`
   * :ref:`-withSettings-`
+  * :ref:`-toStrictEntity-`
 
 
 .. _Response Transforming Directives:
@@ -95,9 +98,11 @@ Alphabetically
    cancelRejection
    cancelRejections
    extract
-   extractExecutionContext
+   extractActorSystem
    extractDataBytes
+   extractExecutionContext
    extractMaterializer
+   extractStrictEntity
    extractLog
    extractRequest
    extractRequestContext
@@ -124,6 +129,7 @@ Alphabetically
    recoverRejections
    recoverRejectionsWith
    textract
+   toStrictEntity
    tprovide
    withExecutionContext
    withMaterializer
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/toStrictEntity.rst b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/toStrictEntity.rst
new file mode 100644
index 0000000000..f45a9ac048
--- /dev/null
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/basic-directives/toStrictEntity.rst
@@ -0,0 +1,30 @@
+.. _-toStrictEntity-:
+
+toStrictEntity
+==============
+
+Signature
+---------
+
+.. includecode2:: /../../akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
+   :snippet: toStrictEntity
+
+Description
+-----------
+
+Transforms the request entity to strict entity before it is handled by the inner route.
+
+A timeout parameter is given and if the stream isn't completed after the timeout, the directive will be failed.
+
+.. warning::
+
+  The directive will read the request entity into memory within the size limit(8M by default) and effectively disable streaming.
+  The size limit can be configured globally with ``akka.http.parsing.max-content-length`` or
+  overridden by wrapping with :ref:`-withSizeLimit-` or :ref:`-withoutSizeLimit-` directive.
+
+
+Example
+-------
+
+.. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/BasicDirectivesExamplesSpec.scala
+   :snippet: toStrictEntity-example
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logRequestResult.rst b/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
index 801bd8fc65..7bc199dc36 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logRequestResult.rst
@@ -10,9 +10,7 @@ Signature
 
     def logRequestResult(marker: String)(implicit log: LoggingContext): Directive0
     def logRequestResult(marker: String, level: LogLevel)(implicit log: LoggingContext): Directive0
-    def logRequestResult(show: HttpRequest => HttpResponsePart => Option[LogEntry])
-                          (implicit log: LoggingContext): Directive0
-    def logRequestResult(show: HttpRequest => Any => Option[LogEntry])(implicit log: LoggingContext): Directive0
+    def logRequestResult(show: HttpRequest => RouteResult => Option[LogEntry])(implicit log: LoggingContext): Directive0
 
 The signature shown is simplified, the real signature uses magnets. [1]_
 
@@ -32,3 +30,13 @@ Example
 
 .. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala
    :snippet: logRequestResult
+
+
+Building Advanced Directives
+----------------------------
+
+This example will showcase the advanced logging using the ``DebuggingDirectives``.
+The built `logResponseTime ` directive will log the request time (or rejection reason):
+
+.. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/DebuggingDirectivesExamplesSpec.scala
+   :snippet: logRequestResultWithResponseTime
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logResult.rst b/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logResult.rst
index bdbbe4e2de..17403bb018 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logResult.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/debugging-directives/logResult.rst
@@ -10,9 +10,9 @@ Signature
 
     def logResult(marker: String)(implicit log: LoggingContext): Directive0
     def logResult(marker: String, level: LogLevel)(implicit log: LoggingContext): Directive0
-    def logResult(show: Any => String)(implicit log: LoggingContext): Directive0
-    def logResult(show: Any => LogEntry)(implicit log: LoggingContext): Directive0
-    def logResult(magnet: LoggingMagnet[Any => Unit])(implicit log: LoggingContext): Directive0
+    def logResult(show: RouteResult => String)(implicit log: LoggingContext): Directive0
+    def logResult(show: RouteResult => LogEntry)(implicit log: LoggingContext): Directive0
+    def logResult(magnet: LoggingMagnet[RouteResult => Unit])(implicit log: LoggingContext): Directive0
 
 The signature shown is simplified, the real signature uses magnets. [1]_
 
@@ -24,7 +24,7 @@ Description
 Logs the response.
 
 See :ref:`-logRequest-` for the general description how these directives work. This directive is different
-as it requires a ``LoggingMagnet[Any => Unit]``. Instead of just logging ``HttpResponses``, ``logResult`` is able to
+as it requires a ``LoggingMagnet[RouteResult => Unit]``. Instead of just logging ``HttpResponses``, ``logResult`` is able to
 log any :ref:`RouteResult` coming back from the inner route.
 
 Use ``logRequest`` for logging the request, or ``logRequestResult`` for logging both.
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/future-directives/completeOrRecoverWith.rst b/akka-docs/rst/scala/http/routing-dsl/directives/future-directives/completeOrRecoverWith.rst
index b616abff09..6ad762b2a4 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/future-directives/completeOrRecoverWith.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/future-directives/completeOrRecoverWith.rst
@@ -14,7 +14,7 @@ Description
 If the ``Future[T]`` succeeds the request is completed using the value's marshaller (this directive therefore
 requires a marshaller for the future's parameter type to be implicitly available). The execution of the inner
 route passed to this directive is only executed if the given future completed with a failure,
-exposing the reason of failure as a extraction of type ``Throwable``.
+exposing the reason of failure as an extraction of type ``Throwable``.
 
 To handle the successful case manually as well, use the :ref:`-onComplete-` directive, instead.
 
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/index.rst b/akka-docs/rst/scala/http/routing-dsl/directives/index.rst
index e0082a338a..4e30d49f50 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/index.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/index.rst
@@ -224,4 +224,4 @@ When you combine directives producing extractions with the ``&`` operator all ex
 
 Directives offer a great way of constructing your web service logic from small building blocks in a plug and play
 fashion while maintaining DRYness and full type-safety. If the large range of :ref:`Predefined Directives` does not
-fully satisfy your needs you can also very easily create :ref:`Custom Directives`.
+fully satisfy your needs you can also easily create :ref:`Custom Directives`.
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/method-directives/extractMethod.rst b/akka-docs/rst/scala/http/routing-dsl/directives/method-directives/extractMethod.rst
index e0ff7743ff..9c25b91741 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/method-directives/extractMethod.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/method-directives/extractMethod.rst
@@ -22,3 +22,13 @@ print what type of request it was - independent of what actual HttpMethod it was
 
 .. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/MethodDirectivesExamplesSpec.scala
    :snippet: extractMethod-example
+
+
+Custom Http Method
+------------------
+
+When you define a custom HttpMethod, you can define a route using extractMethod.
+
+.. includecode:: ../../../../code/docs/http/scaladsl/server/directives/CustomHttpMethodSpec.scala
+   :include: application-custom
+
diff --git a/akka-docs/rst/scala/http/routing-dsl/directives/route-directives/redirect.rst b/akka-docs/rst/scala/http/routing-dsl/directives/route-directives/redirect.rst
index af9364b118..38ce11ae54 100644
--- a/akka-docs/rst/scala/http/routing-dsl/directives/route-directives/redirect.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/directives/route-directives/redirect.rst
@@ -15,9 +15,9 @@ Description
 Completes the request with a redirection response to a given targer URI and of a given redirection type (status code).
 
 ``redirect`` is a convenience helper for completing the request with a redirection response.
-It is equivalent to this snippet relying on the ``complete`` directive:
+It is equivalent to this snippet relying on the ``complete`` method on ``RequestContext`` (a directive is also available):
 
-.. includecode2:: /../../akka-http/src/main/scala/akka/http/scaladsl/server/directives/RouteDirectives.scala
+.. includecode2:: /../../akka-http/src/main/scala/akka/http/scaladsl/server/RequestContextImpl.scala
    :snippet: red-impl
 
 
@@ -25,4 +25,4 @@ Example
 -------
 
 .. includecode2:: ../../../../code/docs/http/scaladsl/server/directives/RouteDirectivesExamplesSpec.scala
-   :snippet: redirect-examples
\ No newline at end of file
+   :snippet: redirect-examples
diff --git a/akka-docs/rst/scala/http/routing-dsl/index.rst b/akka-docs/rst/scala/http/routing-dsl/index.rst
index a4e1ee5121..10942ef517 100644
--- a/akka-docs/rst/scala/http/routing-dsl/index.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/index.rst
@@ -23,6 +23,7 @@ static content serving.
    exception-handling
    path-matchers
    case-class-extraction
+   source-streaming-support
    testkit
    websocket-support
 
diff --git a/akka-docs/rst/scala/http/routing-dsl/source-streaming-support.rst b/akka-docs/rst/scala/http/routing-dsl/source-streaming-support.rst
new file mode 100644
index 0000000000..38baaa6bd5
--- /dev/null
+++ b/akka-docs/rst/scala/http/routing-dsl/source-streaming-support.rst
@@ -0,0 +1,136 @@
+.. _json-streaming-scala:
+
+Source Streaming
+================
+
+Akka HTTP supports completing a request with an Akka ``Source[T, _]``, which makes it possible to easily build
+and consume streaming end-to-end APIs which apply back-pressure throughout the entire stack. 
+
+It is possible to complete requests with raw ``Source[ByteString, _]``, however often it is more convenient to 
+stream on an element-by-element basis, and allow Akka HTTP to handle the rendering internally - for example as a JSON array,
+or CSV stream (where each element is separated by a new-line).
+
+In the following sections we investigate how to make use of the JSON Streaming infrastructure,
+however the general hints apply to any kind of element-by-element streaming you could imagine.
+
+JSON Streaming
+==============
+
+`JSON Streaming`_ is a term refering to streaming a (possibly infinite) stream of element as independent JSON
+objects as a continuous HTTP request or response. The elements are most often separated using newlines,
+however do not have to be. Concatenating elements side-by-side or emitting "very long" JSON array is also another
+use case.
+
+In the below examples, we'll be refering to the ``Tweet`` and ``Measurement`` case classes as our model, which are defined as:
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: models
+
+And as always with spray-json, we provide our (Un)Marshaller instances as implicit values using the ``jsonFormat##``
+method to generate them statically:
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: formats
+
+.. _Json Streaming: https://en.wikipedia.org/wiki/JSON_Streaming
+
+Responding with JSON Streams
+----------------------------
+
+In this example we implement an API representing an infinite stream of tweets, very much like Twitter's `Streaming API`_.
+
+Firstly, we'll need to get some additional marshalling infrastructure set up, that is able to marshal to and from an
+Akka Streams ``Source[T,_]``. One such trait, containing the needed marshallers is ``SprayJsonSupport``, which uses
+spray-json (a high performance json parser library), and is shipped as part of Akka HTTP in the
+``akka-http-spray-json-experimental`` module.
+
+Once the general infrastructure is prepared we import our model's marshallers, generated by spray-json (Step 1),
+and enable JSON Streaming by making an implicit ``EntityStreamingSupport`` instance available (Step 2). 
+Akka HTTP pre-packages JSON and CSV entity streaming support, however it is simple to add your own, in case you'd
+like to stream a different content type (for example plists or protobuf).
+
+The final step is simply completing a request using a Source of tweets, as simple as that:
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: spray-json-response-streaming
+
+The reason the ``EntityStreamingSupport`` has to be enabled explicitly is that one might want to configure how the 
+stream should be rendered. We'll dicuss this in depth in the next section though.
+
+.. _Streaming API: https://dev.twitter.com/streaming/overview
+
+Customising response rendering mode
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Since it is not always possible to directly and confidently answer the question of how a stream of ``T`` should look on 
+the wire, the ``EntityStreamingSupport`` traits come into play and allow fine-tuning the streams rendered representation.
+
+For example, in case of JSON Streaming, there isn't really one standard about rendering the response. Some APIs prefer
+to render multiple JSON objects in a line-by-line fashion (Twitter's streaming APIs for example), while others simply return
+very large arrays, which could be streamed as well. 
+
+Akka defaults to the second one (streaming a JSON Array), as it is correct JSON and clients not expecting
+a streaming API would still be able to consume it in a naive way if they'd want to. 
+
+The line-by-line aproach however is also pretty popular even though it is not valid JSON. It's relatively simplicity for 
+client-side parsing is a strong point in case to pick this format for your Streaming APIs.
+Below we demonstrate how to reconfigure the support trait to render the JSON as 
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: line-by-line-json-response-streaming
+
+Another interesting feature is parallel marshalling. Since marshalling can potentially take much time,
+it is possible to marshal multiple elements of the stream in parallel. This is simply a configuration 
+option on ``EntityStreamingSupport`` and is configurable like this:
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: async-rendering
+
+The above shown mode perserves ordering of the Source's elements, which may sometimes be a required property,
+for example when streaming a strictly ordered dataset. Sometimes the contept of strict-order does not apply to the
+data being streamed though, which allows us to exploit this property and use an ``unordered`` rendering.
+
+This also is a configuration option and is used as shown below. Effectively this will allow Akka's marshalling infrastructure 
+to concurrently marshallup to ``parallelism`` elements and emit the first which is marshalled onto the ``HttpResponse``:
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: async-unordered-rendering
+
+This allows us to _potentially_ render elements faster onto the HttpResponse, since it can avoid "head of line blocking",
+in case one element in front of the stream takes a long time to marshall, yet others after it are very quick to marshall.
+
+Consuming JSON Streaming uploads
+--------------------------------
+
+Sometimes the client may be sending a streaming request, for example an embedded device initiated a connection with
+the server and is feeding it with one line of measurement data.
+
+In this example, we want to consume this data in a streaming fashion from the request entity, and also apply
+back-pressure to the underlying TCP connection, if the server can not cope with the rate of incoming data (back-pressure
+will be applied automatically thanks to using Akka HTTP/Streams).
+
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: spray-json-request-streaming
+
+Simple CSV streaming example
+----------------------------
+
+Akka HTTP provides another ``EntityStreamingSupport`` out of the box, namely ``csv`` (comma-separated values).
+For completeness, we demonstrate its usage in the below snippet. As you'll notice, switching betweeen streaming
+modes is fairly simple, one only has to make sure that an implicit ``Marshaller`` of the requested type is available,
+and that the streaming support operates on the same ``Content-Type`` as the rendered values. Otherwise you'll see
+an error during runtime that the marshaller did not expose the expected content type and thus we can not render
+the streaming response).
+
+.. includecode2:: ../../code/docs/http/scaladsl/server/directives/JsonStreamingExamplesSpec.scala
+   :snippet: csv-example
+
+Implementing custom EntityStreamingSupport traits
+-------------------------------------------------
+
+The ``EntityStreamingSupport`` infrastructure is open for extension and not bound to any single format, content type
+or marshalling library. The provided JSON support does not rely on Spray JSON directly, but uses ``Marshaller[T, ByteString]``
+instances, which can be provided using any JSON marshalling library (such as Circe, Jawn or Play JSON).
+
+When implementing a custom support trait, one should simply extend the ``EntityStreamingSupport`` abstract class,
+and implement all of it's methods. It's best to use the existing implementations as a guideline.
diff --git a/akka-docs/rst/scala/http/routing-dsl/websocket-support.rst b/akka-docs/rst/scala/http/routing-dsl/websocket-support.rst
index 135a1d4009..ff9da67297 100644
--- a/akka-docs/rst/scala/http/routing-dsl/websocket-support.rst
+++ b/akka-docs/rst/scala/http/routing-dsl/websocket-support.rst
@@ -33,13 +33,13 @@ a ``Strict`` subclass for each kind of message which contains data as a strict,
 When receiving data from the network connection the WebSocket implementation tries to create a ``Strict`` message whenever
 possible, i.e. when the complete data was received in one chunk. However, the actual chunking of messages over a network
 connection and through the various streaming abstraction layers is not deterministic from the perspective of the
-application. Therefore, application code must be able to handle both streaming and strict messages and not expect
+application. Therefore, application code must be able to handle both streamed and strict messages and not expect
 certain messages to be strict. (Particularly, note that tests against ``localhost`` will behave differently than tests
 against remote peers where data is received over a physical network connection.)
 
 For sending data, use ``TextMessage.apply(text: String)`` to create a ``Strict`` message which is often the natural
 choice when the complete message has already been assembled. Otherwise, use ``TextMessage.apply(textStream: Source[String, Any])``
-to create a streaming message from an Akka Stream source.
+to create a streamed message from an Akka Stream source.
 
 Server API
 ----------
@@ -95,6 +95,11 @@ and then responds with another text message that contains a greeting:
 .. includecode:: ../../code/docs/http/scaladsl/server/WebSocketExampleSpec.scala
    :include: websocket-handler
 
+.. note::
+  Inactive WebSocket connections will be dropped according to the :ref:`idle-timeout settings <idle-timeouts-scala>`.
+  In case you need to keep inactive connections alive, you can either tweak your idle-timeout or inject
+  'keep-alive' messages regularly.
+
 Routing support
 ---------------
 
diff --git a/akka-docs/rst/scala/http/server-side-https-support.rst b/akka-docs/rst/scala/http/server-side-https-support.rst
index 11cc6e0ee9..7fe02214ae 100644
--- a/akka-docs/rst/scala/http/server-side-https-support.rst
+++ b/akka-docs/rst/scala/http/server-side-https-support.rst
@@ -21,6 +21,9 @@ For detailed documentation for client-side HTTPS support refer to :ref:`clientSi
 
 .. _akka.http.scaladsl.Http: https://github.com/akka/akka/blob/master/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala
 
+
+.. _ssl-config-scala:
+
 SSL-Config
 ----------
 
@@ -57,6 +60,9 @@ keystores using the JDK keytool utility can be found `here <https://docs.oracle.
 SSL-Config provides a more targeted guide on generating certificates, so we recommend you start with the guide
 titled `Generating X.509 Certificates <http://typesafehub.github.io/ssl-config/CertificateGeneration.html>`_.
 
+
+.. _using-https-scala:
+
 Using HTTPS
 -----------
 
@@ -71,13 +77,33 @@ or passing it in explicitly when binding the server:
 .. includecode2:: ../code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
    :snippet: low-level-default
 
+Once you configured the HTTPS context, you can set it as default:
+
+.. includecode2:: ../code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
+   :snippet: set-low-level-context-default
+
 It is also possible to pass in the context to specific ``bind...`` (or client) calls, like displayed below:
 
 .. includecode2:: ../code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
    :snippet: bind-low-level-context
 
 
+Running both HTTP and HTTPS
+---------------------------
+If you want to run HTTP and HTTPS servers in a single application, you can call ``bind...`` methods twice,
+one for HTTPS, and the other for HTTP.
 
+When configuring HTTPS, you can do it up like explained in the above :ref:`using-https-scala` section,
+
+.. includecode2:: ../code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
+   :snippet: low-level-default
+
+or via :ref:`ssl-config-scala` (not explained here though).
+
+Then, call ``bind...`` methods twice like below. The passed ``https`` context is from the above code snippet.
+
+.. includecode2:: ../code/docs/http/scaladsl/server/HttpsServerExampleSpec.scala
+   :snippet: both-https-and-http
 
 Further reading
 ---------------
diff --git a/akka-docs/rst/scala/io-tcp.rst b/akka-docs/rst/scala/io-tcp.rst
index 87acb50dd5..c8772f4bce 100644
--- a/akka-docs/rst/scala/io-tcp.rst
+++ b/akka-docs/rst/scala/io-tcp.rst
@@ -190,7 +190,7 @@ For back-pressuring writes there are three modes of operation
 
 These write back-pressure models (with the exception of the second which is rather specialised) are
 demonstrated in complete examples below. The full and contiguous source is
-available `on github <@github@/akka-docs/rst/scala/code/docs/io/EchoServer.scala>`_.
+available `on GitHub <@github@/akka-docs/rst/scala/code/docs/io/EchoServer.scala>`_.
 
 For back-pressuring reads there are two modes of operation
 
diff --git a/akka-docs/rst/scala/persistence-schema-evolution.rst b/akka-docs/rst/scala/persistence-schema-evolution.rst
index 0d7e73d84e..74cf7ac391 100644
--- a/akka-docs/rst/scala/persistence-schema-evolution.rst
+++ b/akka-docs/rst/scala/persistence-schema-evolution.rst
@@ -33,16 +33,12 @@ and systems design much simpler you may want to read Pat Helland's excellent `Im
 
 Since with `Event Sourcing`_ the **events are immutable** and usually never deleted – the way schema evolution is handled
 differs from how one would go about it in a mutable database setting (e.g. in typical CRUD database applications).
+
 The system needs to be able to continue to work in the presence of "old" events which were stored under the "old" schema.
 We also want to limit complexity in the business logic layer, exposing a consistent view over all of the events of a given
 type to :class:`PersistentActor` s and :ref:`persistence queries <persistence-query-scala>`. This allows the business logic layer to focus on solving business problems
 instead of having to explicitly deal with different schemas.
 
-The system needs to be able to continue to work in the presence of "old" events which were stored under the "old" schema,
-and we want to limit the complexity to the data layer, exposing a consistent view over all of the events of a given type
-to :class:`PersistentActor` s and persistence queries, which allows these layers to focus on the business problems instead
-handling the different schemas explicitly in the business logic layers.
-
 
 In summary, schema evolution in event sourced systems exposes the following characteristics:
   - Allow the system to continue operating without large scale migrations to be applied,
diff --git a/akka-docs/rst/scala/remoting.rst b/akka-docs/rst/scala/remoting.rst
index 7cc6437a08..4dd3e801c8 100644
--- a/akka-docs/rst/scala/remoting.rst
+++ b/akka-docs/rst/scala/remoting.rst
@@ -495,7 +495,7 @@ Akka behind NAT or in a Docker container
 ----------------------------------------
 
 In setups involving Network Address Translation (NAT), Load Balancers or Docker
-containers the hostname and port pair that akka binds to will be different than the "logical"
+containers the hostname and port pair that Akka binds to will be different than the "logical"
 host name and port pair that is used to connect to the system from the outside. This requires
 special configuration that sets both the logical and the bind pairs for remoting.
 
diff --git a/akka-docs/rst/scala/routing.rst b/akka-docs/rst/scala/routing.rst
index bba212da76..5e8b5bb023 100644
--- a/akka-docs/rst/scala/routing.rst
+++ b/akka-docs/rst/scala/routing.rst
@@ -46,7 +46,10 @@ outside of actors.
 .. note::
 
     In general, any message sent to a router will be sent onwards to its routees, but there is one exception.
-    The special :ref:`broadcast-messages-scala` will send to *all* of a router's routees 
+    The special :ref:`broadcast-messages-scala` will send to *all* of a router's routees.
+    However, do not use :ref:`broadcast-messages-scala` when you use :ref:`balancing-pool-scala` for routees
+    as described in :ref:`router-special-messages-scala`.
+
 
 A Router Actor
 ^^^^^^^^^^^^^^
@@ -63,10 +66,10 @@ This type of router actor comes in two distinct flavors:
   messages to the specified path using actor selection, without watching for termination.  
 
 The settings for a router actor can be defined in configuration or programmatically. 
-Although router actors can be defined in the configuration file, they must still be created
-programmatically, i.e. you cannot make a router through external configuration alone.
-If you define the router actor in the configuration file then these settings will be used
-instead of any programmatically provided parameters.
+In order to make an actor to make use of an externally configurable router the ``FromConfig`` props wrapper must be used
+to denote that the actor accepts routing settings from configuration.
+This is in contrast with Remote Deployment where such marker props is not necessary.
+If the props of an actor is NOT wrapped in FromConfig it will ignore the router section of the deployment configuration.
 
 You send messages to the routees via the router actor in the same way as for ordinary actors,
 i.e. via its ``ActorRef``. The router actor forwards messages onto its routees without changing 
@@ -275,6 +278,11 @@ All routees share the same mailbox.
    replying to the original client. The other advantage is that it does not place
    a restriction on the message queue implementation as BalancingPool does.
 
+.. note::
+   Do not use :ref:`broadcast-messages-scala` when you use :ref:`balancing-pool-scala` for routers.
+   as described in :ref:`router-special-messages-scala`,
+
+
 BalancingPool defined in configuration:
 
 .. includecode:: code/docs/routing/RouterDocSpec.scala#config-balancing-pool
@@ -304,6 +312,20 @@ with a ``thread-pool-executor`` hinting the number of allocated threads explicit
 
 .. includecode:: code/docs/routing/RouterDocSpec.scala#config-balancing-pool3
 
+It is also possible to change the ``mailbox`` used by the balancing dispatcher for
+scenarios where the default unbounded mailbox is not well suited. An example of such
+a scenario could arise whether there exists the need to manage priority for each message.
+You can then implement a priority mailbox and configure your dispatcher:
+
+.. includecode:: code/docs/routing/RouterDocSpec.scala#config-balancing-pool4
+
+.. note::
+
+   Bear in mind that ``BalancingDispatcher`` requires a message queue that must be thread-safe for
+   multiple concurrent consumers. So it is mandatory for the message queue backing a custom mailbox
+   for this kind of dispatcher to implement akka.dispatch.MultipleConsumerSemantics. See details
+   on how to implement your custom mailbox in :ref:`mailboxes-scala`.
+
 There is no Group variant of the BalancingPool.
 
 SmallestMailboxPool
@@ -521,6 +543,12 @@ In this example the router receives the ``Broadcast`` message, extracts its payl
 (``"Watch out for Davy Jones' locker"``), and then sends the payload on to all of the router's
 routees. It is up to each routee actor to handle the received payload message.
 
+.. note::
+   Do not use :ref:`broadcast-messages-scala` when you use :ref:`balancing-pool-scala` for routers.
+   Routees on :ref:`balancing-pool-scala` shares the same mailbox instance, thus some routees can
+   possibly get the broadcast message multiple times, while other routees get no broadcast message.
+
+
 PoisonPill Messages
 -------------------
 
diff --git a/akka-docs/rst/scala/serialization.rst b/akka-docs/rst/scala/serialization.rst
index e4ebfecbc8..35f203c06f 100644
--- a/akka-docs/rst/scala/serialization.rst
+++ b/akka-docs/rst/scala/serialization.rst
@@ -35,6 +35,13 @@ one of which all other candidates are superclasses. If this condition cannot be
 met, because e.g. ``java.io.Serializable`` and ``MyOwnSerializable`` both apply
 and neither is a subtype of the other, a warning will be issued
 
+.. note::
+
+  If your messages are contained inside of a Scala object, then in order to
+  reference those messages, you will need use the fully qualified Java class name. For a message
+  named ``Message`` contained inside the object named ``Wrapper``
+  you would need to reference it as ``Wrapper$Message`` instead of ``Wrapper.Message``.
+
 Akka provides serializers for :class:`java.io.Serializable` and `protobuf
 <http://code.google.com/p/protobuf/>`_
 :class:`com.google.protobuf.GeneratedMessage` by default (the latter only if
diff --git a/akka-docs/rst/scala/stream/migration-guide-2.0-2.4-scala.rst b/akka-docs/rst/scala/stream/migration-guide-2.0-2.4-scala.rst
index 4f90f6162f..01bdef1380 100644
--- a/akka-docs/rst/scala/stream/migration-guide-2.0-2.4-scala.rst
+++ b/akka-docs/rst/scala/stream/migration-guide-2.0-2.4-scala.rst
@@ -23,7 +23,7 @@ completion but there is no actual value attached to the completion. It is used t
 occurrences of ``Future<BoxedUnit>`` with ``Future<Done>`` in Java and ``Future[Unit]`` with
 ``Future[Done]`` in Scala.
 
-All previous usage of ``Unit`` and ``BoxedUnit`` for these two cases in the akka streams APIs
+All previous usage of ``Unit`` and ``BoxedUnit`` for these two cases in the Akka Streams APIs
 has been updated.
 
 This means that Scala code like this::
@@ -138,8 +138,8 @@ IO Sources / Sinks materialize IOResult
 
 Materialized values of the following sources and sinks:
 
-  * ``FileIO.fromFile``
-  * ``FileIO.toFile``
+  * ``FileIO.fromPath``
+  * ``FileIO.toPath``
   * ``StreamConverters.fromInputStream``
   * ``StreamConverters.fromOutputStream``
 
diff --git a/akka-docs/rst/scala/stream/stages-overview.rst b/akka-docs/rst/scala/stream/stages-overview.rst
index dcae95bc47..d5a263d64f 100644
--- a/akka-docs/rst/scala/stream/stages-overview.rst
+++ b/akka-docs/rst/scala/stream/stages-overview.rst
@@ -168,7 +168,7 @@ Wrap any resource that can be opened, queried for next element (in a blocking wa
 
 **completes** when read function returns ``None``
 
-unfoldAsyncResource
+unfoldResourceAsync
 ^^^^^^^^^^^^^^^^^^^
 Wrap any resource that can be opened, queried for next element (in a blocking way) and closed using three distinct functions into a source.
 Functions return ``Future`` to achieve asynchronous processing
@@ -312,6 +312,23 @@ Invoke a callback when the stream has completed or failed.
 
 **backpressures** never
 
+lazyInit
+^^^^^^^^
+Invoke sinkFactory function to create a real sink upon receiving the first element. Internal ``Sink`` will not be created if there are no elements,
+because of completion or error. `fallback` will be invoked if there was no elements and completed is received from upstream.
+
+**cancels** never
+
+**backpressures** when initialized and when created sink backpressures
+
+queue
+^^^^^
+Materialize a ``SinkQueue`` that can be pulled to trigger demand through the sink. The queue contains
+a buffer in case stream emitting elements faster than queue pulling them.
+
+**cancels** when  ``SinkQueue.cancel`` is called
+
+**backpressures** when buffer has some space
 
 fold
 ^^^^
@@ -559,6 +576,17 @@ it returns false the element is discarded.
 
 **completes** when upstream completes
 
+filterNot
+^^^^^^^^^
+Filter the incoming elements using a predicate. If the predicate returns false the element is passed downstream, if
+it returns true the element is discarded.
+
+**emits** when the given predicate returns false for the element
+
+**backpressures** when the given predicate returns false for the element and downstream backpressures
+
+**completes** when upstream completes
+
 collect
 ^^^^^^^
 Apply a partial function to each incoming element, if the partial function is defined for a value the returned
@@ -619,6 +647,17 @@ complete the current value is emitted downstream.
 
 **completes** when upstream completes
 
+reduce
+^^^^^^
+Start with first element and then apply the current and next value to the given function, when upstream
+complete the current value is emitted downstream. Similar to ``fold``.
+
+**emits** when upstream completes
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
 drop
 ^^^^
 Drop ``n`` elements and then pass any subsequent element downstream.
@@ -703,6 +742,60 @@ a function has to be provided to calculate the individual cost of each element.
 
 **completes** when upstream completes
 
+intersperse
+^^^^^^^^^^^
+Intersperse stream with provided element similar to ``List.mkString``. It can inject start and end marker elements to stream.
+
+**emits** when upstream emits an element or before with the `start` element if provided
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
+limit
+^^^^^
+Limit number of element from upstream to given ``max`` number.
+
+**emits** when upstream emits and the number of emitted elements has not reached max
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes and the number of emitted elements has not reached max
+
+limitWeighted
+^^^^^^^^^^^^^
+Ensure stream boundedness by evaluating the cost of incoming elements using a cost function.
+Evaluated cost of each element defines how many elements will be allowed to travel downstream.
+
+**emits** when upstream emits and the number of emitted elements has not reached max
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes and the number of emitted elements has not reached max
+
+log
+^^^
+Log elements flowing through the stream as well as completion and erroring. By default element and
+completion signals are logged on debug level, and errors are logged on Error level.
+This can be changed by calling ``Attributes.logLevels(...)`` on the given Flow.
+
+**emits** when upstream emits
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes
+
+recoverWithRetries
+^^^^^^^^^^^^^^^^^^
+Switch to alternative Source on flow failure. It stays in effect after a failure has been recovered up to ``attempts``
+number of times. Each time a failure is fed into the partial function and a new Source may be materialized.
+
+**emits** when element is available from the upstream or upstream is failed and element is available from alternative Source
+
+**backpressures** when downstream backpressures
+
+**completes** when upstream completes or upstream failed with exception provided partial function can handle
+
 
 Asynchronous processing stages
 ------------------------------
@@ -1139,6 +1232,16 @@ After completion of the original upstream the elements of the given source will
 
 **completes** when all upstreams complete
 
+++
+^^
+Just a shorthand for concat
+
+**emits** when the current stream has an element available; if the current input completes, it tries the next one
+
+**backpressures** when downstream backpressures
+
+**completes** when all upstreams complete
+
 prepend
 ^^^^^^^
 Prepends the given source to the flow, consuming it until completion before the original source is consumed.
@@ -1208,6 +1311,17 @@ Fan-out the stream to several streams. Each upstream element is emitted to the f
 
 **completes** when upstream completes
 
+partition
+^^^^^^^^^
+Fan-out the stream to several streams. Each upstream element is emitted to one downstream consumer according to the
+partitioner function applied to the element.
+
+**emits** when the chosen output stops backpressuring and there is an input element available
+
+**backpressures** when the chosen output backpressures
+
+**completes** when upstream completes and no output is pending
+
 
 Watching status stages
 ----------------------
diff --git a/akka-docs/rst/scala/stream/stream-customize.rst b/akka-docs/rst/scala/stream/stream-customize.rst
index b21978c932..dd686cf539 100644
--- a/akka-docs/rst/scala/stream/stream-customize.rst
+++ b/akka-docs/rst/scala/stream/stream-customize.rst
@@ -61,6 +61,14 @@ source as any other built-in one:
 
 .. includecode:: ../code/docs/stream/GraphStageDocSpec.scala#simple-source-usage
 
+Similarly, to create a custom :class:`Sink` one can register a subclass :class:`InHandler` with the stage :class:`Inlet`.
+The ``onPush()`` callback is used to signal the handler a new element has been pushed to the stage,
+and can hence be grabbed and used. ``onPush()`` can be overridden to provide custom behaviour.
+Please note, most Sinks would need to request upstream elements as soon as they are created: this can be
+done by calling ``pull(inlet)`` in the ``preStart()`` callback.
+
+.. includecode:: ../code/docs/stream/GraphStageDocSpec.scala#custom-sink-example
+
 Port states, InHandler and OutHandler
 -------------------------------------
 
@@ -108,7 +116,7 @@ The following operations are available for *input* ports:
 The events corresponding to an *input* port can be received in an :class:`InHandler` instance registered to the
 input port using ``setHandler(in, handler)``. This handler has three callbacks:
 
-* ``onPush()`` is called when the output port has now a new element. Now it is possible to acquire this element using
+* ``onPush()`` is called when the input port has now a new element. Now it is possible to acquire this element using
   ``grab(in)`` and/or call ``pull(in)`` on the port to request the next element. It is not mandatory to grab the
   element, but if it is pulled while the element has not been grabbed it will drop the buffered element.
 * ``onUpstreamFinish()`` is called once the upstream has completed and no longer can be pulled for new elements.
@@ -141,7 +149,7 @@ Finally, there are two methods available for convenience to complete the stage a
 
 
 In some cases it is inconvenient and error prone to react on the regular state machine events with the
-signal based API described above. For those cases there is a API which allows for a more declarative sequencing
+signal based API described above. For those cases there is an API which allows for a more declarative sequencing
 of actions which will greatly simplify some use cases at the cost of some extra allocations. The difference
 between the two APIs could be described as that the first one is signal driven from the outside, while this API
 is more active and drives its surroundings.
@@ -481,4 +489,3 @@ that he gave up).
 
 It is interesting to note that a simplified form of this problem has found its way into the `dotty test suite <https://github.com/lampepfl/dotty/pull/1186/files>`_.
 Dotty is the development version of Scala on its way to Scala 3.
-
diff --git a/akka-docs/rst/scala/stream/stream-integrations.rst b/akka-docs/rst/scala/stream/stream-integrations.rst
index 18e552da6a..8669460c05 100644
--- a/akka-docs/rst/scala/stream/stream-integrations.rst
+++ b/akka-docs/rst/scala/stream/stream-integrations.rst
@@ -15,7 +15,7 @@ For more advanced use cases the :class:`ActorPublisher` and :class:`ActorSubscri
 provided to support implementing Reactive Streams :class:`Publisher` and :class:`Subscriber` with
 an :class:`Actor`.
 
-These can be consumed by other Reactive Stream libraries or used as a
+These can be consumed by other Reactive Stream libraries or used as an
 Akka Streams :class:`Source` or :class:`Sink`.
 
 .. warning::
diff --git a/akka-docs/rst/scala/stream/stream-io.rst b/akka-docs/rst/scala/stream/stream-io.rst
index 760bff8725..178b861b11 100644
--- a/akka-docs/rst/scala/stream/stream-io.rst
+++ b/akka-docs/rst/scala/stream/stream-io.rst
@@ -100,7 +100,7 @@ Akka Streams provide simple Sources and Sinks that can work with :class:`ByteStr
 on files.
 
 
-Streaming data from a file is as easy as creating a `FileIO.fromFile` given a target file, and an optional
+Streaming data from a file is as easy as creating a `FileIO.fromPath` given a target path, and an optional
 ``chunkSize`` which determines the buffer size determined as one "element" in such stream:
 
 .. includecode:: ../code/docs/stream/io/StreamFileDocSpec.scala#file-source
diff --git a/akka-docs/rst/scala/stream/stream-quickstart.rst b/akka-docs/rst/scala/stream/stream-quickstart.rst
index cdc37c1da2..cc599e73f7 100644
--- a/akka-docs/rst/scala/stream/stream-quickstart.rst
+++ b/akka-docs/rst/scala/stream/stream-quickstart.rst
@@ -91,7 +91,7 @@ accepts strings as its input and when materialized it will create auxiliary
 information of type ``Future[IOResult]`` (when chaining operations on
 a :class:`Source` or :class:`Flow` the type of the auxiliary information—called
 the “materialized value”—is given by the leftmost starting point; since we want
-to retain what the ``FileIO.toFile`` sink has to offer, we need to say
+to retain what the ``FileIO.toPath`` sink has to offer, we need to say
 ``Keep.right``).
 
 We can use the new and shiny :class:`Sink` we just created by
diff --git a/akka-docs/rst/scala/typed-actors.rst b/akka-docs/rst/scala/typed-actors.rst
index f9f5ab8fd5..75c72637f3 100644
--- a/akka-docs/rst/scala/typed-actors.rst
+++ b/akka-docs/rst/scala/typed-actors.rst
@@ -35,7 +35,7 @@ lies in interfacing between private sphere and the public, but you don’t want
 that many doors inside your house, do you? For a longer discussion see `this
 blog post <http://letitcrash.com/post/19074284309/when-to-use-typedactors>`_.
 
-A bit more background: TypedActors can very easily be abused as RPC, and that
+A bit more background: TypedActors can easily be abused as RPC, and that
 is an abstraction which is `well-known
 <http://doc.akka.io/docs/misc/smli_tr-94-29.pdf>`_
 to be leaky. Hence TypedActors are not what we think of first when we talk
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/ContentTypes.java b/akka-http-core/src/main/java/akka/http/javadsl/model/ContentTypes.java
index 61b3a1c728..25c403ee63 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/ContentTypes.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/ContentTypes.java
@@ -25,6 +25,9 @@ public final class ContentTypes {
   public static final ContentType.WithCharset TEXT_XML_UTF8 =
           akka.http.scaladsl.model.ContentTypes.text$divxml$u0028UTF$minus8$u0029();
 
+  public static final ContentType.WithCharset TEXT_CSV_UTF8 =
+          akka.http.scaladsl.model.ContentTypes.text$divcsv$u0028UTF$minus8$u0029();
+
   public static ContentType.Binary create(MediaType.Binary mediaType) {
     return ContentType$.MODULE$.apply((akka.http.scaladsl.model.MediaType.Binary) mediaType);
   }
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpEntity.java b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpEntity.java
index b58068c86b..0582d29b74 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpEntity.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpEntity.java
@@ -4,12 +4,12 @@
 
 package akka.http.javadsl.model;
 
+import akka.Done;
 import akka.http.impl.util.Util;
-import akka.http.javadsl.model.headers.EntityTagRanges;
-import akka.http.scaladsl.model.HttpEntity$;
 import akka.stream.Materializer;
 import akka.stream.javadsl.Source;
 import akka.util.ByteString;
+import scala.concurrent.Future;
 
 import java.util.OptionalLong;
 import java.util.concurrent.CompletionStage;
@@ -142,6 +142,43 @@ public interface HttpEntity {
      */
     CompletionStage<HttpEntity.Strict> toStrict(long timeoutMillis, Materializer materializer);
 
+    /**
+     * Discards the entities data bytes by running the {@code dataBytes} Source contained in this entity.
+     *
+     * Note: It is crucial that entities are either discarded, or consumed by running the underlying [[Source]]
+     * as otherwise the lack of consuming of the data will trigger back-pressure to the underlying TCP connection
+     * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of
+     * just having ignored the data.
+     *
+     * Warning: It is not allowed to discard and/or consume the {@code dataBytes} more than once
+     * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
+     * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
+     * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
+     * "stream can cannot be materialized more than once" exception.
+     *
+     * In future versions, more automatic ways to warn or resolve these situations may be introduced, see issue #18716.
+     */
+    HttpMessage.DiscardedEntity discardBytes(Materializer materializer);
+
+
+    /**
+     * Represents the currently being-drained HTTP Entity which triggers completion of the contained
+     * Future once the entity has been drained for the given HttpMessage completely.
+     */
+    interface DiscardedEntity {
+        /**
+         * This future completes successfully once the underlying entity stream has been
+         * successfully drained (and fails otherwise).
+         */
+        Future<Done> future();
+
+        /**
+         * This future completes successfully once the underlying entity stream has been
+         * successfully drained (and fails otherwise).
+         */
+        CompletionStage<Done> completionStage();
+    }
+
     /**
      * The entity type which consists of a predefined fixed ByteString of data.
      */
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMessage.java b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMessage.java
index 5f1f1ae812..c78808b99e 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMessage.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMessage.java
@@ -4,16 +4,13 @@
 
 package akka.http.javadsl.model;
 
-import akka.Done;
 import akka.stream.Materializer;
 import akka.http.javadsl.model.headers.HttpCredentials;
 import akka.util.ByteString;
-import scala.concurrent.Future;
 
 import java.io.File;
 import java.nio.file.Path;
 import java.util.Optional;
-import java.util.concurrent.CompletionStage;
 
 /**
  * The base type for an Http message (request or response).
@@ -70,7 +67,7 @@ public interface HttpMessage {
      * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of 
      * just having ignored the data.
      *  
-     * Warning: It is not allowed to discard and/or consume the the {@code entity.dataBytes} more than once
+     * Warning: It is not allowed to discard and/or consume the {@code entity.dataBytes} more than once
      * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
      * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
      * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
@@ -81,21 +78,10 @@ public interface HttpMessage {
     DiscardedEntity discardEntityBytes(Materializer materializer);
 
     /**
-     * Represents the the currently being-drained HTTP Entity which triggers completion of the contained
+     * Represents the currently being-drained HTTP Entity which triggers completion of the contained
      * Future once the entity has been drained for the given HttpMessage completely.
      */
-    interface DiscardedEntity {
-        /**
-         * This future completes successfully once the underlying entity stream has been
-         * successfully drained (and fails otherwise).
-         */
-        Future<Done> future();
-
-        /**
-         * This future completes successfully once the underlying entity stream has been
-         * successfully drained (and fails otherwise).
-         */
-        CompletionStage<Done> completionStage();
+    interface DiscardedEntity extends HttpEntity.DiscardedEntity {
     }
 
     interface MessageTransformations<Self> {
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethod.java b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethod.java
index f554bd438e..69f95a050f 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethod.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethod.java
@@ -42,6 +42,14 @@ public abstract class HttpMethod {
 
     /**
      * Returns the entity acceptance level for this method.
+     * @deprecated Use {@link #getRequestEntityAcceptance} instead, which returns {@link akka.http.javadsl.model.RequestEntityAcceptance}.
      */
+    @Deprecated
     public abstract akka.http.scaladsl.model.RequestEntityAcceptance requestEntityAcceptance();
+
+    /**
+     * Java API: Returns the entity acceptance level for this method.
+     */
+    // TODO: Rename it to requestEntityAcceptance() in Akka 3.0
+    public abstract akka.http.javadsl.model.RequestEntityAcceptance getRequestEntityAcceptance();
 }
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethods.java b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethods.java
index 70835f1266..0085398a83 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethods.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethods.java
@@ -27,11 +27,24 @@ public final class HttpMethods {
 
     /**
      * Create a custom method type.
+     * @deprecated Use {@link  #createCustom} instead.
      */
+    @Deprecated
     public static HttpMethod custom(String value, boolean safe, boolean idempotent, akka.http.scaladsl.model.RequestEntityAcceptance requestEntityAcceptance) {
         return akka.http.scaladsl.model.HttpMethod.custom(value, safe, idempotent, requestEntityAcceptance);
     }
 
+    /**
+     * Create a custom method type.
+     */
+    // TODO: Rename it to custom() in Akka 3.0
+    public static HttpMethod createCustom(String value, boolean safe, boolean idempotent, akka.http.javadsl.model.RequestEntityAcceptance requestEntityAcceptance) {
+        //This cast is safe as implementation of RequestEntityAcceptance only exists in Scala
+        akka.http.scaladsl.model.RequestEntityAcceptance scalaRequestEntityAcceptance
+          = (akka.http.scaladsl.model.RequestEntityAcceptance) requestEntityAcceptance;
+        return akka.http.scaladsl.model.HttpMethod.custom(value, safe, idempotent, scalaRequestEntityAcceptance);
+    }
+
     /**
      * Looks up a predefined HTTP method with the given name.
      */
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptance.java b/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptance.java
new file mode 100644
index 0000000000..f2c8c69d63
--- /dev/null
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptance.java
@@ -0,0 +1,14 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.javadsl.model;
+
+/**
+ * @see RequestEntityAcceptances for convenience access to often used values.
+ * Do not extend this to a concrete Java class,
+ * as implementation of RequestEntityAcceptation should only exist in Scala
+ */
+public abstract class RequestEntityAcceptance {
+  public abstract boolean isEntityAccepted();
+}
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptances.java b/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptances.java
new file mode 100644
index 0000000000..9063b17961
--- /dev/null
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/RequestEntityAcceptances.java
@@ -0,0 +1,14 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+
+package akka.http.javadsl.model;
+
+public final class RequestEntityAcceptances {
+  private RequestEntityAcceptances() {}
+
+  public static final RequestEntityAcceptance Expected   = akka.http.scaladsl.model.RequestEntityAcceptance.Expected$.MODULE$;
+  public static final RequestEntityAcceptance Tolerated  = akka.http.scaladsl.model.RequestEntityAcceptance.Tolerated$.MODULE$;
+  public static final RequestEntityAcceptance Disallowed = akka.http.scaladsl.model.RequestEntityAcceptance.Disallowed$.MODULE$;
+}
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/headers/ContentLength.java b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/ContentLength.java
new file mode 100644
index 0000000000..959f007cfa
--- /dev/null
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/ContentLength.java
@@ -0,0 +1,13 @@
+/**
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.javadsl.model.headers;
+
+/**
+ *  Model for the `Content-Length` header.
+ *  Specification: https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-26#section-3.3.2
+ */
+public abstract class ContentLength extends akka.http.scaladsl.model.HttpHeader {
+    public abstract long length();
+}
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpChallenge.java b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpChallenge.java
index c018313d53..2d7b15d52b 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpChallenge.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpChallenge.java
@@ -5,6 +5,8 @@
 package akka.http.javadsl.model.headers;
 
 import akka.http.impl.util.Util;
+import akka.japi.Option;
+
 
 import java.util.Map;
 
@@ -14,11 +16,28 @@ public abstract class HttpChallenge {
 
     public abstract Map<String, String> getParams();
 
+    /**
+     * @deprecated Use constructor with optional realm parameter instead.
+     */
+    @Deprecated
     public static HttpChallenge create(String scheme, String realm) {
-        return new akka.http.scaladsl.model.headers.HttpChallenge(scheme, realm, Util.emptyMap);
+        return akka.http.scaladsl.model.headers.HttpChallenge.apply(scheme, scala.Option.apply(realm), Util.emptyMap);
     }
+
+    /**
+     * @deprecated Use constructor with optional realm parameter instead.
+     */
+    @Deprecated
     public static HttpChallenge create(String scheme, String realm, Map<String, String> params) {
-        return new akka.http.scaladsl.model.headers.HttpChallenge(scheme, realm, Util.convertMapToScala(params));
+        return akka.http.scaladsl.model.headers.HttpChallenge.apply(scheme, scala.Option.apply(realm), Util.convertMapToScala(params));
+    }
+
+    public static HttpChallenge create(String scheme, Option<String> realm) {
+        return akka.http.scaladsl.model.headers.HttpChallenge.apply(scheme, realm.asScala(), Util.emptyMap);
+    }
+
+    public static HttpChallenge create(String scheme, Option<String> realm, Map<String, String> params) {
+        return akka.http.scaladsl.model.headers.HttpChallenge.apply(scheme, realm.asScala(), Util.convertMapToScala(params));
     }
 
     public static HttpChallenge createBasic(String realm) {
diff --git a/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpOriginRange.java b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpOriginRange.java
index 0c0ae05863..70a949883f 100644
--- a/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpOriginRange.java
+++ b/akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpOriginRange.java
@@ -11,18 +11,18 @@ import akka.http.impl.util.Util;
  * @see HttpOriginRanges for convenience access to often used values.
  */
 public abstract class HttpOriginRange {
-    public abstract boolean matches(HttpOrigin origin);
+  public abstract boolean matches(HttpOrigin origin);
 
-    public static HttpOriginRange create(HttpOrigin... origins) {
-        return HttpOriginRange$.MODULE$.apply(Util.<HttpOrigin, akka.http.scaladsl.model.headers.HttpOrigin>convertArray(origins));
-    }
+  public static HttpOriginRange create(HttpOrigin... origins) {
+    return HttpOriginRange$.MODULE$.apply(Util.<HttpOrigin, akka.http.scaladsl.model.headers.HttpOrigin>convertArray(origins));
+  }
 
-    /**
-     * @deprecated because of troublesome initialisation order (with regards to scaladsl class implementing this class).
-     *             In some edge cases this field could end up containing a null value.
-     *             Will be removed in Akka 3.x, use {@link HttpEncodingRanges#ALL} instead.
-     */
-    @Deprecated
-    // FIXME: Remove in Akka 3.0
-    public static final HttpOriginRange ALL = HttpOriginRanges.ALL;
+  /**
+   * @deprecated because of troublesome initialisation order (with regards to scaladsl class implementing this class).
+   * In some edge cases this field could end up containing a null value.
+   * Will be removed in Akka 3.x, use {@link HttpEncodingRanges#ALL} instead.
+   */
+  @Deprecated
+  // FIXME: Remove in Akka 3.0
+  public static final HttpOriginRange ALL = HttpOriginRanges.ALL;
 }
diff --git a/akka-http-core/src/main/resources/reference.conf b/akka-http-core/src/main/resources/reference.conf
index 28012b6ba1..bdbf9b6b92 100644
--- a/akka-http-core/src/main/resources/reference.conf
+++ b/akka-http-core/src/main/resources/reference.conf
@@ -286,7 +286,7 @@ akka.http {
   #
   # IMPORTANT:
   # Please note that this sections settings can be overriden by the corresponding settings in:
-  # `akka.http.server.parsing`, `akka.http.client.parsing` or `akka.http.http-connection-pool.client.parsing`.
+  # `akka.http.server.parsing`, `akka.http.client.parsing` or `akka.http.host-connection-pool.client.parsing`.
   parsing {
     # The limits for the various parts of the HTTP message parser.
     max-uri-length             = 2k
@@ -352,6 +352,15 @@ akka.http {
     # `full`  : the full error details (potentially spanning several lines) are logged
     error-logging-verbosity = full
 
+    # Configures the processing mode when encountering illegal characters in
+    # header value of response.
+    #
+    # Supported mode:
+    # `error`  : default mode, throw an ParsingException and terminate the processing
+    # `warn`   : ignore the illegal characters in response header value and log a warning message
+    # `ignore` : just ignore the illegal characters in response header value
+    illegal-response-header-value-processing-mode = error
+
     # limits for the number of different values per header type that the
     # header cache will hold
     header-cache {
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/client/OutgoingConnectionBlueprint.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/client/OutgoingConnectionBlueprint.scala
index 3b61836874..a49a6e191b 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/client/OutgoingConnectionBlueprint.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/client/OutgoingConnectionBlueprint.scala
@@ -83,7 +83,7 @@ private[http] object OutgoingConnectionBlueprint {
       val responseParsingMerge = b.add {
         // the initial header parser we initially use for every connection,
         // will not be mutated, all "shared copy" parsers copy on first-write into the header cache
-        val rootParser = new HttpResponseParser(parserSettings, HttpHeaderParser(parserSettings) { info ⇒
+        val rootParser = new HttpResponseParser(parserSettings, HttpHeaderParser(parserSettings, log) { info ⇒
           if (parserSettings.illegalHeaderWarnings)
             logParsingError(info withSummaryPrepended "Illegal response header", log, parserSettings.errorLoggingVerbosity)
         })
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/BodyPartParser.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/BodyPartParser.scala
index 19ac33da07..56eeb9ea98 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/BodyPartParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/BodyPartParser.scala
@@ -58,7 +58,7 @@ private[http] final class BodyPartParser(
   private[this] val boyerMoore = new BoyerMoore(needle)
 
   // TODO: prevent re-priming header parser from scratch
-  private[this] val headerParser = HttpHeaderParser(settings) { errorInfo ⇒
+  private[this] val headerParser = HttpHeaderParser(settings, log) { errorInfo ⇒
     if (illegalHeaderWarnings) log.warning(errorInfo.withSummaryPrepended("Illegal multipart header").formatPretty)
   }
 
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpHeaderParser.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpHeaderParser.scala
index fa4b23637a..867e39680b 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpHeaderParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpHeaderParser.scala
@@ -7,6 +7,10 @@ package akka.http.impl.engine.parsing
 import java.nio.{ CharBuffer, ByteBuffer }
 import java.util.Arrays.copyOf
 import java.lang.{ StringBuilder ⇒ JStringBuilder }
+import akka.event.LoggingAdapter
+import akka.http.scaladsl.settings.ParserSettings.IllegalResponseHeaderValueProcessingMode
+import akka.http.scaladsl.settings.ParserSettings
+
 import scala.annotation.tailrec
 import akka.parboiled2.CharUtils
 import akka.util.ByteString
@@ -60,6 +64,7 @@ import akka.http.impl.model.parser.CharacterClasses._
  */
 private[engine] final class HttpHeaderParser private (
   val settings:                      HttpHeaderParser.Settings,
+  val log:                           LoggingAdapter,
   onIllegalHeader:                   ErrorInfo ⇒ Unit,
   private[this] var nodes:           Array[Char]               = new Array(512), // initial size, can grow as needed
   private[this] var nodeCount:       Int                       = 0,
@@ -85,7 +90,7 @@ private[engine] final class HttpHeaderParser private (
    * Returns a copy of this parser that shares the trie data with this instance.
    */
   def createShallowCopy(): HttpHeaderParser =
-    new HttpHeaderParser(settings, onIllegalHeader, nodes, nodeCount, branchData, branchDataCount, values, valueCount)
+    new HttpHeaderParser(settings, log, onIllegalHeader, nodes, nodeCount, branchData, branchDataCount, values, valueCount)
 
   /**
    * Parses a header line and returns the line start index of the subsequent line.
@@ -145,12 +150,14 @@ private[engine] final class HttpHeaderParser private (
     val colonIx = scanHeaderNameAndReturnIndexOfColon(input, lineStart, lineStart + 1 + maxHeaderNameLength)(cursor)
     val headerName = asciiString(input, lineStart, colonIx)
     try {
-      val valueParser = new RawHeaderValueParser(headerName, maxHeaderValueLength, headerValueCacheLimit(headerName))
+      val valueParser = new RawHeaderValueParser(headerName, maxHeaderValueLength,
+        headerValueCacheLimit(headerName), log, illegalResponseHeaderValueProcessingMode)
       insert(input, valueParser)(cursor, colonIx + 1, nodeIx, colonIx)
       parseHeaderLine(input, lineStart)(cursor, nodeIx)
     } catch {
       case OutOfTrieSpaceException ⇒ // if we cannot insert we drop back to simply creating new header instances
-        val (headerValue, endIx) = scanHeaderValue(this, input, colonIx + 1, colonIx + maxHeaderValueLength + 3)()
+        val (headerValue, endIx) = scanHeaderValue(this, input, colonIx + 1, colonIx + maxHeaderValueLength + 3,
+          log, settings.illegalResponseHeaderValueProcessingMode)()
         resultHeader = RawHeader(headerName, headerValue.trim)
         endIx
     }
@@ -413,6 +420,7 @@ private[http] object HttpHeaderParser {
     def maxHeaderValueLength: Int
     def headerValueCacheLimit(headerName: String): Int
     def customMediaTypes: MediaTypes.FindCustom
+    def illegalResponseHeaderValueProcessingMode: IllegalResponseHeaderValueProcessingMode
   }
 
   private def predefinedHeaders = Seq(
@@ -426,16 +434,16 @@ private[http] object HttpHeaderParser {
     "Cache-Control: no-cache",
     "Expect: 100-continue")
 
-  def apply(settings: HttpHeaderParser.Settings)(onIllegalHeader: ErrorInfo ⇒ Unit = info ⇒ throw IllegalHeaderException(info)) =
-    prime(unprimed(settings, onIllegalHeader))
+  def apply(settings: HttpHeaderParser.Settings, log: LoggingAdapter)(onIllegalHeader: ErrorInfo ⇒ Unit = info ⇒ throw IllegalHeaderException(info)) =
+    prime(unprimed(settings, log, onIllegalHeader))
 
-  def unprimed(settings: HttpHeaderParser.Settings, warnOnIllegalHeader: ErrorInfo ⇒ Unit) =
-    new HttpHeaderParser(settings, warnOnIllegalHeader)
+  def unprimed(settings: HttpHeaderParser.Settings, log: LoggingAdapter, warnOnIllegalHeader: ErrorInfo ⇒ Unit) =
+    new HttpHeaderParser(settings, log, warnOnIllegalHeader)
 
   def prime(parser: HttpHeaderParser): HttpHeaderParser = {
     val valueParsers: Seq[HeaderValueParser] =
       HeaderParser.ruleNames.map { name ⇒
-        new ModeledHeaderValueParser(name, parser.settings.maxHeaderValueLength, parser.settings.headerValueCacheLimit(name), parser.settings)
+        new ModeledHeaderValueParser(name, parser.settings.maxHeaderValueLength, parser.settings.headerValueCacheLimit(name), parser.log, parser.settings)
       }(collection.breakOut)
     def insertInGoodOrder(items: Seq[Any])(startIx: Int = 0, endIx: Int = items.size): Unit =
       if (endIx - startIx > 0) {
@@ -470,11 +478,11 @@ private[http] object HttpHeaderParser {
     def cachingEnabled = maxValueCount > 0
   }
 
-  private[parsing] class ModeledHeaderValueParser(headerName: String, maxHeaderValueLength: Int, maxValueCount: Int, settings: HeaderParser.Settings)
+  private[parsing] class ModeledHeaderValueParser(headerName: String, maxHeaderValueLength: Int, maxValueCount: Int, log: LoggingAdapter, settings: HeaderParser.Settings)
     extends HeaderValueParser(headerName, maxValueCount) {
     def apply(hhp: HttpHeaderParser, input: ByteString, valueStart: Int, onIllegalHeader: ErrorInfo ⇒ Unit): (HttpHeader, Int) = {
-      // TODO: optimize by running the header value parser directly on the input ByteString (rather than an extracted String)
-      val (headerValue, endIx) = scanHeaderValue(hhp, input, valueStart, valueStart + maxHeaderValueLength + 2)()
+      // TODO: optimize by running the header value parser directly on the input ByteString (rather than an extracted String); seems done?
+      val (headerValue, endIx) = scanHeaderValue(hhp, input, valueStart, valueStart + maxHeaderValueLength + 2, log, settings.illegalResponseHeaderValueProcessingMode)()
       val trimmedHeaderValue = headerValue.trim
       val header = HeaderParser.parseFull(headerName, trimmedHeaderValue, settings) match {
         case Right(h) ⇒ h
@@ -486,10 +494,10 @@ private[http] object HttpHeaderParser {
     }
   }
 
-  private[parsing] class RawHeaderValueParser(headerName: String, maxHeaderValueLength: Int, maxValueCount: Int)
-    extends HeaderValueParser(headerName, maxValueCount) {
+  private[parsing] class RawHeaderValueParser(headerName: String, maxHeaderValueLength: Int, maxValueCount: Int,
+                                              log: LoggingAdapter, mode: IllegalResponseHeaderValueProcessingMode) extends HeaderValueParser(headerName, maxValueCount) {
     def apply(hhp: HttpHeaderParser, input: ByteString, valueStart: Int, onIllegalHeader: ErrorInfo ⇒ Unit): (HttpHeader, Int) = {
-      val (headerValue, endIx) = scanHeaderValue(hhp, input, valueStart, valueStart + maxHeaderValueLength + 2)()
+      val (headerValue, endIx) = scanHeaderValue(hhp, input, valueStart, valueStart + maxHeaderValueLength + 2, log, mode)()
       RawHeader(headerName, headerValue.trim) → endIx
     }
   }
@@ -503,15 +511,16 @@ private[http] object HttpHeaderParser {
       }
     else fail(s"HTTP header name exceeds the configured limit of ${limit - start - 1} characters")
 
-  @tailrec private def scanHeaderValue(hhp: HttpHeaderParser, input: ByteString, start: Int,
-                                       limit: Int)(sb: JStringBuilder = null, ix: Int = start): (String, Int) = {
+  @tailrec private def scanHeaderValue(hhp: HttpHeaderParser, input: ByteString, start: Int, limit: Int, log: LoggingAdapter,
+                                       mode: IllegalResponseHeaderValueProcessingMode)(sb: JStringBuilder = null, ix: Int = start): (String, Int) = {
+
     def appended(c: Char) = (if (sb != null) sb else new JStringBuilder(asciiString(input, start, ix))).append(c)
     def appended2(c: Int) = if ((c >> 16) != 0) appended(c.toChar).append((c >> 16).toChar) else appended(c.toChar)
     if (ix < limit)
       byteChar(input, ix) match {
-        case '\t' ⇒ scanHeaderValue(hhp, input, start, limit)(appended(' '), ix + 1)
+        case '\t' ⇒ scanHeaderValue(hhp, input, start, limit, log, mode)(appended(' '), ix + 1)
         case '\r' if byteChar(input, ix + 1) == '\n' ⇒
-          if (WSP(byteChar(input, ix + 2))) scanHeaderValue(hhp, input, start, limit)(appended(' '), ix + 3)
+          if (WSP(byteChar(input, ix + 2))) scanHeaderValue(hhp, input, start, limit, log, mode)(appended(' '), ix + 3)
           else (if (sb != null) sb.toString else asciiString(input, start, ix), ix + 2)
         case c ⇒
           var nix = ix + 1
@@ -544,8 +553,21 @@ private[http] object HttpHeaderParser {
                 case -1 ⇒ if (sb != null) sb.append(c).append(byteChar(input, ix + 1)).append(byteChar(input, ix + 2)).append(byteChar(input, ix + 3)) else null
                 case cc ⇒ appended2(cc)
               }
-            } else fail(s"Illegal character '${escape(c)}' in header value")
-          scanHeaderValue(hhp, input, start, limit)(nsb, nix)
+            } else {
+              mode match {
+                case ParserSettings.IllegalResponseHeaderValueProcessingMode.Error ⇒
+                  fail(s"Illegal character '${escape(c)}' in header value")
+                case ParserSettings.IllegalResponseHeaderValueProcessingMode.Warn ⇒
+                  // ignore the illegal character and log a warning message
+                  log.warning(s"Illegal character '${escape(c)}' in header value")
+                  sb
+                case ParserSettings.IllegalResponseHeaderValueProcessingMode.Ignore ⇒
+                  // just ignore the illegal character
+                  sb
+              }
+
+            }
+          scanHeaderValue(hhp, input, start, limit, log, mode)(nsb, nix)
       }
     else fail(s"HTTP header value exceeds the configured limit of ${limit - start - 2} characters")
   }
@@ -569,4 +591,4 @@ private[http] object HttpHeaderParser {
     def withValueCountIncreased = copy(valueCount = valueCount + 1)
     def spaceLeft = valueCount < parser.maxValueCount
   }
-}
\ No newline at end of file
+}
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpMessageParser.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpMessageParser.scala
index 46c997d238..bb6cd112ef 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpMessageParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpMessageParser.scala
@@ -23,52 +23,35 @@ import akka.stream.{ Attributes, FlowShape, Inlet, Outlet }
 
 /**
  * INTERNAL API
+ *
+ * Common logic for http request and response message parsing
  */
-private[http] abstract class HttpMessageParser[Output >: MessageOutput <: ParserOutput](
-  val settings:     ParserSettings,
-  val headerParser: HttpHeaderParser) { self ⇒
-  import HttpMessageParser._
-  import settings._
+private[http] trait HttpMessageParser[Output >: MessageOutput <: ParserOutput] {
 
-  private[this] val result = new ListBuffer[Output]
+  import HttpMessageParser._
+
+  protected final val result = new ListBuffer[Output]
   private[this] var state: ByteString ⇒ StateResult = startNewMessage(_, 0)
   private[this] var protocol: HttpProtocol = `HTTP/1.1`
-  private[this] var completionHandling: CompletionHandling = CompletionOk
-  private[this] var terminated = false
+  protected var completionHandling: CompletionHandling = CompletionOk
+  protected var terminated = false
 
   private[this] var lastSession: SSLSession = null // used to prevent having to recreate header on each message
   private[this] var tlsSessionInfoHeader: `Tls-Session-Info` = null
-  def initialHeaderBuffer: ListBuffer[HttpHeader] =
+
+  protected def settings: ParserSettings
+  protected def headerParser: HttpHeaderParser
+  /** invoked if the specified protocol is unknown */
+  protected def onBadProtocol(): Nothing
+  protected def parseMessage(input: ByteString, offset: Int): HttpMessageParser.StateResult
+  protected def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
+                            clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
+                            expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): HttpMessageParser.StateResult
+
+  protected final def initialHeaderBuffer: ListBuffer[HttpHeader] =
     if (settings.includeTlsSessionInfoHeader && tlsSessionInfoHeader != null) ListBuffer(tlsSessionInfoHeader)
     else ListBuffer()
 
-  // Note that this GraphStage mutates the HttpMessageParser instance, use with caution.
-  val stage = new GraphStage[FlowShape[SessionBytes, Output]] {
-    val in: Inlet[SessionBytes] = Inlet("HttpMessageParser.in")
-    val out: Outlet[Output] = Outlet("HttpMessageParser.out")
-    override val shape: FlowShape[SessionBytes, Output] = FlowShape(in, out)
-
-    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
-      new GraphStageLogic(shape) with InHandler with OutHandler {
-        override def onPush(): Unit = handleParserOutput(self.parseSessionBytes(grab(in)))
-        override def onPull(): Unit = handleParserOutput(self.onPull())
-
-        override def onUpstreamFinish(): Unit =
-          if (self.onUpstreamFinish()) completeStage()
-          else if (isAvailable(out)) handleParserOutput(self.onPull())
-
-        private def handleParserOutput(output: Output): Unit = {
-          output match {
-            case StreamEnd    ⇒ completeStage()
-            case NeedMoreData ⇒ pull(in)
-            case x            ⇒ push(out, x)
-          }
-        }
-
-        setHandlers(in, out, this)
-      }
-  }
-
   final def parseSessionBytes(input: SessionBytes): Output = {
     if (input.session ne lastSession) {
       lastSession = input.session
@@ -93,17 +76,17 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
 
     if (result.nonEmpty) throw new IllegalStateException("Unexpected `onPush`")
     run(state)
-    onPull()
+    doPull()
   }
 
-  final def onPull(): Output =
+  protected final def doPull(): Output =
     if (result.nonEmpty) {
       val head = result.head
       result.remove(0) // faster than `ListBuffer::drop`
       head
     } else if (terminated) StreamEnd else NeedMoreData
 
-  final def onUpstreamFinish(): Boolean = {
+  protected final def shouldComplete(): Boolean = {
     completionHandling() match {
       case Some(x) ⇒ emit(x)
       case None    ⇒ // nothing to do
@@ -118,28 +101,24 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
     catch { case NotEnoughDataException ⇒ continue(input, offset)(startNewMessage) }
   }
 
-  protected def parseMessage(input: ByteString, offset: Int): StateResult
-
-  def parseProtocol(input: ByteString, cursor: Int): Int = {
+  protected final def parseProtocol(input: ByteString, cursor: Int): Int = {
     def c(ix: Int) = byteChar(input, cursor + ix)
     if (c(0) == 'H' && c(1) == 'T' && c(2) == 'T' && c(3) == 'P' && c(4) == '/' && c(5) == '1' && c(6) == '.') {
       protocol = c(7) match {
         case '0' ⇒ `HTTP/1.0`
         case '1' ⇒ `HTTP/1.1`
-        case _   ⇒ badProtocol
+        case _   ⇒ onBadProtocol
       }
       cursor + 8
-    } else badProtocol
+    } else onBadProtocol
   }
 
-  def badProtocol: Nothing
-
-  @tailrec final def parseHeaderLines(input: ByteString, lineStart: Int, headers: ListBuffer[HttpHeader] = initialHeaderBuffer,
-                                      headerCount: Int = 0, ch: Option[Connection] = None,
-                                      clh: Option[`Content-Length`] = None, cth: Option[`Content-Type`] = None,
-                                      teh: Option[`Transfer-Encoding`] = None, e100c: Boolean = false,
-                                      hh: Boolean = false): StateResult =
-    if (headerCount < maxHeaderCount) {
+  @tailrec protected final def parseHeaderLines(input: ByteString, lineStart: Int, headers: ListBuffer[HttpHeader] = initialHeaderBuffer,
+                                                headerCount: Int = 0, ch: Option[Connection] = None,
+                                                clh: Option[`Content-Length`] = None, cth: Option[`Content-Type`] = None,
+                                                teh: Option[`Transfer-Encoding`] = None, e100c: Boolean = false,
+                                                hh: Boolean = false): StateResult =
+    if (headerCount < settings.maxHeaderCount) {
       var lineEnd = 0
       val resultHeader =
         try {
@@ -182,19 +161,15 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
 
         case h         ⇒ parseHeaderLines(input, lineEnd, headers += h, headerCount + 1, ch, clh, cth, teh, e100c, hh)
       }
-    } else failMessageStart(s"HTTP message contains more than the configured limit of $maxHeaderCount headers")
+    } else failMessageStart(s"HTTP message contains more than the configured limit of ${settings.maxHeaderCount} headers")
 
   // work-around for compiler complaining about non-tail-recursion if we inline this method
-  def parseHeaderLinesAux(headers: ListBuffer[HttpHeader], headerCount: Int, ch: Option[Connection],
-                          clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
-                          e100c: Boolean, hh: Boolean)(input: ByteString, lineStart: Int): StateResult =
+  private def parseHeaderLinesAux(headers: ListBuffer[HttpHeader], headerCount: Int, ch: Option[Connection],
+                                  clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
+                                  e100c: Boolean, hh: Boolean)(input: ByteString, lineStart: Int): StateResult =
     parseHeaderLines(input, lineStart, headers, headerCount, ch, clh, cth, teh, e100c, hh)
 
-  def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
-                  clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
-                  expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): StateResult
-
-  def parseFixedLengthBody(
+  protected final def parseFixedLengthBody(
     remainingBodyBytes: Long,
     isLastMessage:      Boolean)(input: ByteString, bodyStart: Int): StateResult = {
     val remainingInputBytes = input.length - bodyStart
@@ -213,7 +188,7 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
     } else continue(input, bodyStart)(parseFixedLengthBody(remainingBodyBytes, isLastMessage))
   }
 
-  def parseChunk(input: ByteString, offset: Int, isLastMessage: Boolean, totalBytesRead: Long): StateResult = {
+  protected final def parseChunk(input: ByteString, offset: Int, isLastMessage: Boolean, totalBytesRead: Long): StateResult = {
     @tailrec def parseTrailer(extension: String, lineStart: Int, headers: List[HttpHeader] = Nil,
                               headerCount: Int = 0): StateResult = {
       var errorInfo: ErrorInfo = null
@@ -230,9 +205,9 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
             setCompletionHandling(CompletionOk)
             if (isLastMessage) terminate()
             else startNewMessage(input, lineEnd)
-          case header if headerCount < maxHeaderCount ⇒
+          case header if headerCount < settings.maxHeaderCount ⇒
             parseTrailer(extension, lineEnd, header :: headers, headerCount + 1)
-          case _ ⇒ failEntityStream(s"Chunk trailer contains more than the configured limit of $maxHeaderCount headers")
+          case _ ⇒ failEntityStream(s"Chunk trailer contains more than the configured limit of ${settings.maxHeaderCount} headers")
         }
       } else failEntityStream(errorInfo)
     }
@@ -252,24 +227,24 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
       } else parseTrailer(extension, cursor)
 
     @tailrec def parseChunkExtensions(chunkSize: Int, cursor: Int)(startIx: Int = cursor): StateResult =
-      if (cursor - startIx <= maxChunkExtLength) {
+      if (cursor - startIx <= settings.maxChunkExtLength) {
         def extension = asciiString(input, startIx, cursor)
         byteChar(input, cursor) match {
           case '\r' if byteChar(input, cursor + 1) == '\n' ⇒ parseChunkBody(chunkSize, extension, cursor + 2)
           case '\n' ⇒ parseChunkBody(chunkSize, extension, cursor + 1)
           case _ ⇒ parseChunkExtensions(chunkSize, cursor + 1)(startIx)
         }
-      } else failEntityStream(s"HTTP chunk extension length exceeds configured limit of $maxChunkExtLength characters")
+      } else failEntityStream(s"HTTP chunk extension length exceeds configured limit of ${settings.maxChunkExtLength} characters")
 
     @tailrec def parseSize(cursor: Int, size: Long): StateResult =
-      if (size <= maxChunkSize) {
+      if (size <= settings.maxChunkSize) {
         byteChar(input, cursor) match {
           case c if CharacterClasses.HEXDIG(c) ⇒ parseSize(cursor + 1, size * 16 + CharUtils.hexValue(c))
           case ';' if cursor > offset ⇒ parseChunkExtensions(size.toInt, cursor + 1)()
           case '\r' if cursor > offset && byteChar(input, cursor + 1) == '\n' ⇒ parseChunkBody(size.toInt, "", cursor + 2)
           case c ⇒ failEntityStream(s"Illegal character '${escape(c)}' in chunk start")
         }
-      } else failEntityStream(s"HTTP chunk size exceeds the configured limit of $maxChunkSize bytes")
+      } else failEntityStream(s"HTTP chunk size exceeds the configured limit of ${settings.maxChunkSize} bytes")
 
     try parseSize(offset, 0)
     catch {
@@ -277,9 +252,9 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
     }
   }
 
-  def emit(output: Output): Unit = result += output
+  protected def emit(output: Output): Unit = result += output
 
-  def continue(input: ByteString, offset: Int)(next: (ByteString, Int) ⇒ StateResult): StateResult = {
+  protected final def continue(input: ByteString, offset: Int)(next: (ByteString, Int) ⇒ StateResult): StateResult = {
     state =
       math.signum(offset - input.length) match {
         case -1 ⇒
@@ -291,30 +266,30 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
     done()
   }
 
-  def continue(next: (ByteString, Int) ⇒ StateResult): StateResult = {
+  protected final def continue(next: (ByteString, Int) ⇒ StateResult): StateResult = {
     state = next(_, 0)
     done()
   }
 
-  def failMessageStart(summary: String): StateResult = failMessageStart(summary, "")
-  def failMessageStart(summary: String, detail: String): StateResult = failMessageStart(StatusCodes.BadRequest, summary, detail)
-  def failMessageStart(status: StatusCode): StateResult = failMessageStart(status, status.defaultMessage)
-  def failMessageStart(status: StatusCode, summary: String, detail: String = ""): StateResult = failMessageStart(status, ErrorInfo(summary, detail))
-  def failMessageStart(status: StatusCode, info: ErrorInfo): StateResult = {
+  protected final def failMessageStart(summary: String): StateResult = failMessageStart(summary, "")
+  protected final def failMessageStart(summary: String, detail: String): StateResult = failMessageStart(StatusCodes.BadRequest, summary, detail)
+  protected final def failMessageStart(status: StatusCode): StateResult = failMessageStart(status, status.defaultMessage)
+  protected final def failMessageStart(status: StatusCode, summary: String, detail: String = ""): StateResult = failMessageStart(status, ErrorInfo(summary, detail))
+  protected final def failMessageStart(status: StatusCode, info: ErrorInfo): StateResult = {
     emit(MessageStartError(status, info))
     setCompletionHandling(CompletionOk)
     terminate()
   }
 
-  def failEntityStream(summary: String): StateResult = failEntityStream(summary, "")
-  def failEntityStream(summary: String, detail: String): StateResult = failEntityStream(ErrorInfo(summary, detail))
-  def failEntityStream(info: ErrorInfo): StateResult = {
+  protected final def failEntityStream(summary: String): StateResult = failEntityStream(summary, "")
+  protected final def failEntityStream(summary: String, detail: String): StateResult = failEntityStream(ErrorInfo(summary, detail))
+  protected final def failEntityStream(info: ErrorInfo): StateResult = {
     emit(EntityStreamError(info))
     setCompletionHandling(CompletionOk)
     terminate()
   }
 
-  def terminate(): StateResult = {
+  protected final def terminate(): StateResult = {
     terminated = true
     done()
   }
@@ -325,19 +300,19 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
    */
   private def done(): StateResult = null // StateResult is a phantom type
 
-  def contentType(cth: Option[`Content-Type`]) = cth match {
+  protected final def contentType(cth: Option[`Content-Type`]) = cth match {
     case Some(x) ⇒ x.contentType
     case None    ⇒ ContentTypes.`application/octet-stream`
   }
 
-  def emptyEntity(cth: Option[`Content-Type`]) =
+  protected final def emptyEntity(cth: Option[`Content-Type`]) =
     StrictEntityCreator(if (cth.isDefined) HttpEntity.empty(cth.get.contentType) else HttpEntity.Empty)
 
-  def strictEntity(cth: Option[`Content-Type`], input: ByteString, bodyStart: Int,
-                   contentLength: Int) =
+  protected final def strictEntity(cth: Option[`Content-Type`], input: ByteString, bodyStart: Int,
+                                   contentLength: Int) =
     StrictEntityCreator(HttpEntity.Strict(contentType(cth), input.slice(bodyStart, bodyStart + contentLength)))
 
-  def defaultEntity[A <: ParserOutput](cth: Option[`Content-Type`], contentLength: Long) =
+  protected final def defaultEntity[A <: ParserOutput](cth: Option[`Content-Type`], contentLength: Long) =
     StreamedEntityCreator[A, UniversalEntity] { entityParts ⇒
       val data = entityParts.collect {
         case EntityPart(bytes)       ⇒ bytes
@@ -346,7 +321,7 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
       HttpEntity.Default(contentType(cth), contentLength, HttpEntity.limitableByteSource(data))
     }
 
-  def chunkedEntity[A <: ParserOutput](cth: Option[`Content-Type`]) =
+  protected final def chunkedEntity[A <: ParserOutput](cth: Option[`Content-Type`]) =
     StreamedEntityCreator[A, RequestEntity] { entityChunks ⇒
       val chunks = entityChunks.collect {
         case EntityChunk(chunk)      ⇒ chunk
@@ -355,16 +330,20 @@ private[http] abstract class HttpMessageParser[Output >: MessageOutput <: Parser
       HttpEntity.Chunked(contentType(cth), HttpEntity.limitableChunkSource(chunks))
     }
 
-  def addTransferEncodingWithChunkedPeeled(headers: List[HttpHeader], teh: `Transfer-Encoding`): List[HttpHeader] =
+  protected final def addTransferEncodingWithChunkedPeeled(headers: List[HttpHeader], teh: `Transfer-Encoding`): List[HttpHeader] =
     teh.withChunkedPeeled match {
       case Some(x) ⇒ x :: headers
       case None    ⇒ headers
     }
 
-  def setCompletionHandling(completionHandling: CompletionHandling): Unit =
+  protected final def setCompletionHandling(completionHandling: CompletionHandling): Unit =
     this.completionHandling = completionHandling
+
 }
 
+/**
+ * INTERNAL API
+ */
 private[http] object HttpMessageParser {
   sealed trait StateResult // phantom type for ensuring soundness of our parsing method setup
   final case class Trampoline(f: ByteString ⇒ StateResult) extends StateResult
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpRequestParser.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpRequestParser.scala
index 3fe26250ac..c41fe5db1e 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpRequestParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpRequestParser.scala
@@ -5,169 +5,207 @@
 package akka.http.impl.engine.parsing
 
 import java.lang.{ StringBuilder ⇒ JStringBuilder }
-import scala.annotation.tailrec
+
+import scala.annotation.{ switch, tailrec }
 import akka.http.scaladsl.settings.ParserSettings
-import akka.util.ByteString
+import akka.util.{ ByteString, OptionVal }
 import akka.http.impl.engine.ws.Handshake
 import akka.http.impl.model.parser.CharacterClasses
 import akka.http.scaladsl.model._
 import headers._
 import StatusCodes._
 import ParserOutput._
+import akka.http.impl.util.ByteStringParserInput
+import akka.stream.{ Attributes, FlowShape, Inlet, Outlet }
+import akka.stream.TLSProtocol.SessionBytes
+import akka.stream.stage.{ GraphStage, GraphStageLogic, InHandler, OutHandler }
 
 /**
  * INTERNAL API
  */
-private[http] class HttpRequestParser(
-  _settings:           ParserSettings,
+private[http] final class HttpRequestParser(
+  settings:            ParserSettings,
   rawRequestUriHeader: Boolean,
-  _headerParser:       HttpHeaderParser)
-  extends HttpMessageParser[RequestOutput](_settings, _headerParser) {
+  headerParser:        HttpHeaderParser)
+  extends GraphStage[FlowShape[SessionBytes, RequestOutput]] { self ⇒
+
   import HttpMessageParser._
   import settings._
 
-  private[this] var method: HttpMethod = _
-  private[this] var uri: Uri = _
-  private[this] var uriBytes: Array[Byte] = _
+  val in = Inlet[SessionBytes]("HttpRequestParser.in")
+  val out = Outlet[RequestOutput]("HttpRequestParser.out")
 
-  def createShallowCopy(): HttpRequestParser =
-    new HttpRequestParser(settings, rawRequestUriHeader, headerParser.createShallowCopy())
+  val shape = FlowShape.of(in, out)
 
-  def parseMessage(input: ByteString, offset: Int): StateResult = {
-    var cursor = parseMethod(input, offset)
-    cursor = parseRequestTarget(input, cursor)
-    cursor = parseProtocol(input, cursor)
-    if (byteChar(input, cursor) == '\r' && byteChar(input, cursor + 1) == '\n')
-      parseHeaderLines(input, cursor + 2)
-    else badProtocol
-  }
+  override protected def initialAttributes: Attributes = Attributes.name("HttpRequestParser")
 
-  def parseMethod(input: ByteString, cursor: Int): Int = {
-    @tailrec def parseCustomMethod(ix: Int = 0, sb: JStringBuilder = new JStringBuilder(16)): Int =
-      if (ix < maxMethodLength) {
-        byteChar(input, cursor + ix) match {
-          case ' ' ⇒
-            customMethods(sb.toString) match {
-              case Some(m) ⇒
-                method = m
-                cursor + ix + 1
-              case None ⇒ throw new ParsingException(NotImplemented, ErrorInfo("Unsupported HTTP method", sb.toString))
-            }
-          case c ⇒ parseCustomMethod(ix + 1, sb.append(c))
+  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with HttpMessageParser[RequestOutput] with InHandler with OutHandler {
+
+    import HttpMessageParser._
+
+    override val settings = self.settings
+    override val headerParser = self.headerParser.createShallowCopy()
+
+    private[this] var method: HttpMethod = _
+    private[this] var uri: Uri = _
+    private[this] var uriBytes: ByteString = _
+
+    override def onPush(): Unit = handleParserOutput(parseSessionBytes(grab(in)))
+    override def onPull(): Unit = handleParserOutput(doPull())
+
+    override def onUpstreamFinish(): Unit =
+      if (super.shouldComplete()) completeStage()
+      else if (isAvailable(out)) handleParserOutput(doPull())
+
+    setHandlers(in, out, this)
+
+    private def handleParserOutput(output: RequestOutput): Unit = {
+      output match {
+        case StreamEnd    ⇒ completeStage()
+        case NeedMoreData ⇒ pull(in)
+        case x            ⇒ push(out, x)
+      }
+    }
+
+    override def parseMessage(input: ByteString, offset: Int): StateResult = {
+      var cursor = parseMethod(input, offset)
+      cursor = parseRequestTarget(input, cursor)
+      cursor = parseProtocol(input, cursor)
+      if (byteChar(input, cursor) == '\r' && byteChar(input, cursor + 1) == '\n')
+        parseHeaderLines(input, cursor + 2)
+      else onBadProtocol
+    }
+
+    def parseMethod(input: ByteString, cursor: Int): Int = {
+      @tailrec def parseCustomMethod(ix: Int = 0, sb: JStringBuilder = new JStringBuilder(16)): Int =
+        if (ix < maxMethodLength) {
+          byteChar(input, cursor + ix) match {
+            case ' ' ⇒
+              customMethods(sb.toString) match {
+                case Some(m) ⇒
+                  method = m
+                  cursor + ix + 1
+                case None ⇒ throw new ParsingException(NotImplemented, ErrorInfo("Unsupported HTTP method", sb.toString))
+              }
+            case c ⇒ parseCustomMethod(ix + 1, sb.append(c))
+          }
+        } else throw new ParsingException(
+          BadRequest,
+          ErrorInfo("Unsupported HTTP method", s"HTTP method too long (started with '${sb.toString}'). " +
+            "Increase `akka.http.server.parsing.max-method-length` to support HTTP methods with more characters."))
+
+      @tailrec def parseMethod(meth: HttpMethod, ix: Int = 1): Int =
+        if (ix == meth.value.length)
+          if (byteChar(input, cursor + ix) == ' ') {
+            method = meth
+            cursor + ix + 1
+          } else parseCustomMethod()
+        else if (byteChar(input, cursor + ix) == meth.value.charAt(ix)) parseMethod(meth, ix + 1)
+        else parseCustomMethod()
+
+      import HttpMethods._
+      (byteChar(input, cursor): @switch) match {
+        case 'G' ⇒ parseMethod(GET)
+        case 'P' ⇒ byteChar(input, cursor + 1) match {
+          case 'O' ⇒ parseMethod(POST, 2)
+          case 'U' ⇒ parseMethod(PUT, 2)
+          case 'A' ⇒ parseMethod(PATCH, 2)
+          case _   ⇒ parseCustomMethod()
         }
-      } else throw new ParsingException(
-        BadRequest,
-        ErrorInfo("Unsupported HTTP method", s"HTTP method too long (started with '${sb.toString}'). " +
-          "Increase `akka.http.server.parsing.max-method-length` to support HTTP methods with more characters."))
-
-    @tailrec def parseMethod(meth: HttpMethod, ix: Int = 1): Int =
-      if (ix == meth.value.length)
-        if (byteChar(input, cursor + ix) == ' ') {
-          method = meth
-          cursor + ix + 1
-        } else parseCustomMethod()
-      else if (byteChar(input, cursor + ix) == meth.value.charAt(ix)) parseMethod(meth, ix + 1)
-      else parseCustomMethod()
-
-    import HttpMethods._
-    byteChar(input, cursor) match {
-      case 'G' ⇒ parseMethod(GET)
-      case 'P' ⇒ byteChar(input, cursor + 1) match {
-        case 'O' ⇒ parseMethod(POST, 2)
-        case 'U' ⇒ parseMethod(PUT, 2)
-        case 'A' ⇒ parseMethod(PATCH, 2)
+        case 'D' ⇒ parseMethod(DELETE)
+        case 'H' ⇒ parseMethod(HEAD)
+        case 'O' ⇒ parseMethod(OPTIONS)
+        case 'T' ⇒ parseMethod(TRACE)
+        case 'C' ⇒ parseMethod(CONNECT)
         case _   ⇒ parseCustomMethod()
       }
-      case 'D' ⇒ parseMethod(DELETE)
-      case 'H' ⇒ parseMethod(HEAD)
-      case 'O' ⇒ parseMethod(OPTIONS)
-      case 'T' ⇒ parseMethod(TRACE)
-      case 'C' ⇒ parseMethod(CONNECT)
-      case _   ⇒ parseCustomMethod()
     }
-  }
 
-  def parseRequestTarget(input: ByteString, cursor: Int): Int = {
-    val uriStart = cursor
-    val uriEndLimit = cursor + maxUriLength
+    def parseRequestTarget(input: ByteString, cursor: Int): Int = {
+      val uriStart = cursor
+      val uriEndLimit = cursor + maxUriLength
 
-    @tailrec def findUriEnd(ix: Int = cursor): Int =
-      if (ix == input.length) throw NotEnoughDataException
-      else if (CharacterClasses.WSPCRLF(input(ix).toChar)) ix
-      else if (ix < uriEndLimit) findUriEnd(ix + 1)
-      else throw new ParsingException(
-        RequestUriTooLong,
-        s"URI length exceeds the configured limit of $maxUriLength characters")
+      @tailrec def findUriEnd(ix: Int = cursor): Int =
+        if (ix == input.length) throw NotEnoughDataException
+        else if (CharacterClasses.WSPCRLF(input(ix).toChar)) ix
+        else if (ix < uriEndLimit) findUriEnd(ix + 1)
+        else throw new ParsingException(
+          RequestUriTooLong,
+          s"URI length exceeds the configured limit of $maxUriLength characters")
 
-    val uriEnd = findUriEnd()
-    try {
-      uriBytes = input.iterator.slice(uriStart, uriEnd).toArray[Byte] // TODO: can we reduce allocations here?
-      uri = Uri.parseHttpRequestTarget(uriBytes, mode = uriParsingMode)
-    } catch {
-      case IllegalUriException(info) ⇒ throw new ParsingException(BadRequest, info)
+      val uriEnd = findUriEnd()
+      try {
+        uriBytes = input.slice(uriStart, uriEnd)
+        uri = Uri.parseHttpRequestTarget(new ByteStringParserInput(uriBytes), mode = uriParsingMode)
+      } catch {
+        case IllegalUriException(info) ⇒ throw new ParsingException(BadRequest, info)
+      }
+      uriEnd + 1
     }
-    uriEnd + 1
-  }
 
-  def badProtocol = throw new ParsingException(HTTPVersionNotSupported)
+    override def onBadProtocol() = throw new ParsingException(HTTPVersionNotSupported)
 
-  // http://tools.ietf.org/html/rfc7230#section-3.3
-  def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
-                  clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
-                  expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): StateResult =
-    if (hostHeaderPresent || protocol == HttpProtocols.`HTTP/1.0`) {
-      def emitRequestStart(
-        createEntity: EntityCreator[RequestOutput, RequestEntity],
-        headers:      List[HttpHeader]                            = headers) = {
-        val allHeaders0 =
-          if (rawRequestUriHeader) `Raw-Request-URI`(new String(uriBytes, HttpCharsets.`US-ASCII`.nioCharset)) :: headers
-          else headers
+    // http://tools.ietf.org/html/rfc7230#section-3.3
+    override def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
+                             clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
+                             expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): StateResult =
+      if (hostHeaderPresent || protocol == HttpProtocols.`HTTP/1.0`) {
+        def emitRequestStart(
+          createEntity: EntityCreator[RequestOutput, RequestEntity],
+          headers:      List[HttpHeader]                            = headers) = {
+          val allHeaders0 =
+            if (rawRequestUriHeader) `Raw-Request-URI`(uriBytes.decodeString(HttpCharsets.`US-ASCII`.nioCharset)) :: headers
+            else headers
 
-        val allHeaders =
-          if (method == HttpMethods.GET) {
-            Handshake.Server.websocketUpgrade(headers, hostHeaderPresent) match {
-              case Some(upgrade) ⇒ upgrade :: allHeaders0
-              case None          ⇒ allHeaders0
+          val allHeaders =
+            if (method == HttpMethods.GET) {
+              Handshake.Server.websocketUpgrade(headers, hostHeaderPresent) match {
+                case OptionVal.Some(upgrade) ⇒ upgrade :: allHeaders0
+                case OptionVal.None          ⇒ allHeaders0
+              }
+            } else allHeaders0
+
+          emit(RequestStart(method, uri, protocol, allHeaders, createEntity, expect100continue, closeAfterResponseCompletion))
+        }
+
+        teh match {
+          case None ⇒
+            val contentLength = clh match {
+              case Some(`Content-Length`(len)) ⇒ len
+              case None                        ⇒ 0
+            }
+            if (contentLength == 0) {
+              emitRequestStart(emptyEntity(cth))
+              setCompletionHandling(HttpMessageParser.CompletionOk)
+              startNewMessage(input, bodyStart)
+            } else if (!method.isEntityAccepted) {
+              failMessageStart(UnprocessableEntity, s"${method.name} requests must not have an entity")
+            } else if (contentLength <= input.size - bodyStart) {
+              val cl = contentLength.toInt
+              emitRequestStart(strictEntity(cth, input, bodyStart, cl))
+              setCompletionHandling(HttpMessageParser.CompletionOk)
+              startNewMessage(input, bodyStart + cl)
+            } else {
+              emitRequestStart(defaultEntity(cth, contentLength))
+              parseFixedLengthBody(contentLength, closeAfterResponseCompletion)(input, bodyStart)
             }
-          } else allHeaders0
 
-        emit(RequestStart(method, uri, protocol, allHeaders, createEntity, expect100continue, closeAfterResponseCompletion))
-      }
-
-      teh match {
-        case None ⇒
-          val contentLength = clh match {
-            case Some(`Content-Length`(len)) ⇒ len
-            case None                        ⇒ 0
-          }
-          if (contentLength == 0) {
-            emitRequestStart(emptyEntity(cth))
-            setCompletionHandling(HttpMessageParser.CompletionOk)
-            startNewMessage(input, bodyStart)
-          } else if (!method.isEntityAccepted) {
+          case Some(_) if !method.isEntityAccepted ⇒
             failMessageStart(UnprocessableEntity, s"${method.name} requests must not have an entity")
-          } else if (contentLength <= input.size - bodyStart) {
-            val cl = contentLength.toInt
-            emitRequestStart(strictEntity(cth, input, bodyStart, cl))
-            setCompletionHandling(HttpMessageParser.CompletionOk)
-            startNewMessage(input, bodyStart + cl)
-          } else {
-            emitRequestStart(defaultEntity(cth, contentLength))
-            parseFixedLengthBody(contentLength, closeAfterResponseCompletion)(input, bodyStart)
-          }
 
-        case Some(_) if !method.isEntityAccepted ⇒
-          failMessageStart(UnprocessableEntity, s"${method.name} requests must not have an entity")
+          case Some(te) ⇒
+            val completedHeaders = addTransferEncodingWithChunkedPeeled(headers, te)
+            if (te.isChunked) {
+              if (clh.isEmpty) {
+                emitRequestStart(chunkedEntity(cth), completedHeaders)
+                parseChunk(input, bodyStart, closeAfterResponseCompletion, totalBytesRead = 0L)
+              } else failMessageStart("A chunked request must not contain a Content-Length header.")
+            } else parseEntity(completedHeaders, protocol, input, bodyStart, clh, cth, teh = None,
+              expect100continue, hostHeaderPresent, closeAfterResponseCompletion)
+        }
+      } else failMessageStart("Request is missing required `Host` header")
 
-        case Some(te) ⇒
-          val completedHeaders = addTransferEncodingWithChunkedPeeled(headers, te)
-          if (te.isChunked) {
-            if (clh.isEmpty) {
-              emitRequestStart(chunkedEntity(cth), completedHeaders)
-              parseChunk(input, bodyStart, closeAfterResponseCompletion, totalBytesRead = 0L)
-            } else failMessageStart("A chunked request must not contain a Content-Length header.")
-          } else parseEntity(completedHeaders, protocol, input, bodyStart, clh, cth, teh = None,
-            expect100continue, hostHeaderPresent, closeAfterResponseCompletion)
-      }
-    } else failMessageStart("Request is missing required `Host` header")
+  }
+
+  override def toString: String = "HttpRequestParser"
 }
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpResponseParser.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpResponseParser.scala
index 2d65fe6c2d..ca8683f2b2 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpResponseParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpResponseParser.scala
@@ -13,12 +13,15 @@ import akka.util.ByteString
 import akka.http.scaladsl.model._
 import headers._
 import ParserOutput._
+import akka.stream.{ Attributes, FlowShape, Inlet, Outlet }
+import akka.stream.TLSProtocol.SessionBytes
+import akka.stream.stage.{ GraphStage, GraphStageLogic, InHandler, OutHandler }
 
 /**
  * INTERNAL API
  */
-private[http] class HttpResponseParser(_settings: ParserSettings, _headerParser: HttpHeaderParser)
-  extends HttpMessageParser[ResponseOutput](_settings, _headerParser) {
+private[http] class HttpResponseParser(protected val settings: ParserSettings, protected val headerParser: HttpHeaderParser)
+  extends HttpMessageParser[ResponseOutput] { self ⇒
   import HttpResponseParser._
   import HttpMessageParser._
   import settings._
@@ -26,31 +29,74 @@ private[http] class HttpResponseParser(_settings: ParserSettings, _headerParser:
   private[this] var contextForCurrentResponse: Option[ResponseContext] = None
   private[this] var statusCode: StatusCode = StatusCodes.OK
 
-  def createShallowCopy(): HttpResponseParser = new HttpResponseParser(settings, headerParser.createShallowCopy())
+  // Note that this GraphStage mutates the HttpMessageParser instance, use with caution.
+  final val stage = new GraphStage[FlowShape[SessionBytes, ResponseOutput]] {
+    val in: Inlet[SessionBytes] = Inlet("HttpResponseParser.in")
+    val out: Outlet[ResponseOutput] = Outlet("HttpResponseParser.out")
+    override val shape: FlowShape[SessionBytes, ResponseOutput] = FlowShape(in, out)
 
-  def setContextForNextResponse(responseContext: ResponseContext): Unit =
+    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+      new GraphStageLogic(shape) with InHandler with OutHandler {
+        override def onPush(): Unit = handleParserOutput(self.parseSessionBytes(grab(in)))
+        override def onPull(): Unit = handleParserOutput(self.onPull())
+
+        override def onUpstreamFinish(): Unit =
+          if (self.onUpstreamFinish()) completeStage()
+          else if (isAvailable(out)) handleParserOutput(self.onPull())
+
+        private def handleParserOutput(output: ResponseOutput): Unit = {
+          output match {
+            case StreamEnd    ⇒ completeStage()
+            case NeedMoreData ⇒ pull(in)
+            case x            ⇒ push(out, x)
+          }
+        }
+
+        setHandlers(in, out, this)
+      }
+  }
+
+  final def createShallowCopy(): HttpResponseParser = new HttpResponseParser(settings, headerParser.createShallowCopy())
+
+  final def setContextForNextResponse(responseContext: ResponseContext): Unit =
     if (contextForCurrentResponse.isEmpty) contextForCurrentResponse = Some(responseContext)
 
-  protected def parseMessage(input: ByteString, offset: Int): StateResult =
+  final def onPull(): ResponseOutput =
+    if (result.nonEmpty) {
+      val head = result.head
+      result.remove(0) // faster than `ListBuffer::drop`
+      head
+    } else if (terminated) StreamEnd else NeedMoreData
+
+  final def onUpstreamFinish(): Boolean = {
+    completionHandling() match {
+      case Some(x) ⇒ emit(x)
+      case None    ⇒ // nothing to do
+    }
+    terminated = true
+    result.isEmpty
+  }
+
+  override final def emit(output: ResponseOutput): Unit = {
+    if (output == MessageEnd) contextForCurrentResponse = None
+    super.emit(output)
+  }
+
+  override protected def parseMessage(input: ByteString, offset: Int): StateResult =
     if (contextForCurrentResponse.isDefined) {
       var cursor = parseProtocol(input, offset)
       if (byteChar(input, cursor) == ' ') {
         cursor = parseStatus(input, cursor + 1)
         parseHeaderLines(input, cursor)
-      } else badProtocol
+      } else onBadProtocol()
     } else {
       emit(NeedNextRequestMethod)
       continue(input, offset)(startNewMessage)
     }
 
-  override def emit(output: ResponseOutput): Unit = {
-    if (output == MessageEnd) contextForCurrentResponse = None
-    super.emit(output)
-  }
+  override final def onBadProtocol() = throw new ParsingException("The server-side HTTP version is not supported")
 
-  def badProtocol = throw new ParsingException("The server-side HTTP version is not supported")
-
-  def parseStatus(input: ByteString, cursor: Int): Int = {
+  private def parseStatus(input: ByteString, cursor: Int): Int = {
     def badStatusCode = throw new ParsingException("Illegal response status code")
     def parseStatusCode() = {
       def intValue(offset: Int): Int = {
@@ -84,9 +130,9 @@ private[http] class HttpResponseParser(_settings: ParserSettings, _headerParser:
   def handleInformationalResponses: Boolean = true
 
   // http://tools.ietf.org/html/rfc7230#section-3.3
-  def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
-                  clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
-                  expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): StateResult = {
+  protected final def parseEntity(headers: List[HttpHeader], protocol: HttpProtocol, input: ByteString, bodyStart: Int,
+                                  clh: Option[`Content-Length`], cth: Option[`Content-Type`], teh: Option[`Transfer-Encoding`],
+                                  expect100continue: Boolean, hostHeaderPresent: Boolean, closeAfterResponseCompletion: Boolean): StateResult = {
 
     def emitResponseStart(
       createEntity: EntityCreator[ResponseOutput, ResponseEntity],
@@ -161,7 +207,7 @@ private[http] class HttpResponseParser(_settings: ParserSettings, _headerParser:
     } else finishEmptyResponse()
   }
 
-  def parseToCloseBody(input: ByteString, bodyStart: Int, totalBytesRead: Long): StateResult = {
+  private def parseToCloseBody(input: ByteString, bodyStart: Int, totalBytesRead: Long): StateResult = {
     val newTotalBytes = totalBytesRead + math.max(0, input.length - bodyStart)
     if (input.length > bodyStart)
       emit(EntityPart(input.drop(bodyStart).compact))
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/HttpResponseRendererFactory.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/HttpResponseRendererFactory.scala
index 8a7ca48e72..3967ac5597 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/HttpResponseRendererFactory.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/HttpResponseRendererFactory.scala
@@ -7,11 +7,11 @@ package akka.http.impl.engine.rendering
 import akka.NotUsed
 import akka.http.impl.engine.ws.{ FrameEvent, UpgradeToWebSocketResponseHeader }
 import akka.http.scaladsl.model.ws.Message
-import akka.stream.{ Outlet, Inlet, Attributes, FlowShape, Graph }
+import akka.stream.{ Attributes, FlowShape, Graph, Inlet, Outlet }
 
 import scala.annotation.tailrec
 import akka.event.LoggingAdapter
-import akka.util.ByteString
+import akka.util.{ ByteString, OptionVal }
 import akka.stream.scaladsl.{ Flow, Source }
 import akka.stream.stage._
 import akka.http.scaladsl.model._
@@ -20,6 +20,8 @@ import RenderSupport._
 import HttpProtocols._
 import headers._
 
+import scala.concurrent.duration._
+
 /**
  * INTERNAL API
  */
@@ -129,9 +131,17 @@ private[http] class HttpResponseRendererFactory(
 
           @tailrec def renderHeaders(remaining: List[HttpHeader], alwaysClose: Boolean = false,
                                      connHeader: Connection = null, serverSeen: Boolean = false,
-                                     transferEncodingSeen: Boolean = false, dateSeen: Boolean = false): Unit =
+                                     transferEncodingSeen: Boolean = false, dateSeen: Boolean = false): Unit = {
             remaining match {
               case head :: tail ⇒ head match {
+                case x: Server ⇒
+                  render(x)
+                  renderHeaders(tail, alwaysClose, connHeader, serverSeen = true, transferEncodingSeen, dateSeen)
+
+                case x: Date ⇒
+                  render(x)
+                  renderHeaders(tail, alwaysClose, connHeader, serverSeen, transferEncodingSeen, dateSeen = true)
+
                 case x: `Content-Length` ⇒
                   suppressionWarning(log, x, "explicit `Content-Length` header is not allowed. Use the appropriate HttpEntity subtype.")
                   renderHeaders(tail, alwaysClose, connHeader, serverSeen, transferEncodingSeen, dateSeen)
@@ -140,10 +150,6 @@ private[http] class HttpResponseRendererFactory(
                   suppressionWarning(log, x, "explicit `Content-Type` header is not allowed. Set `HttpResponse.entity.contentType` instead.")
                   renderHeaders(tail, alwaysClose, connHeader, serverSeen, transferEncodingSeen, dateSeen)
 
-                case x: Date ⇒
-                  render(x)
-                  renderHeaders(tail, alwaysClose, connHeader, serverSeen, transferEncodingSeen, dateSeen = true)
-
                 case x: `Transfer-Encoding` ⇒
                   x.withChunkedPeeled match {
                     case None ⇒
@@ -159,10 +165,6 @@ private[http] class HttpResponseRendererFactory(
                   val connectionHeader = if (connHeader eq null) x else Connection(x.tokens ++ connHeader.tokens)
                   renderHeaders(tail, alwaysClose, connectionHeader, serverSeen, transferEncodingSeen, dateSeen)
 
-                case x: Server ⇒
-                  render(x)
-                  renderHeaders(tail, alwaysClose, connHeader, serverSeen = true, transferEncodingSeen, dateSeen)
-
                 case x: CustomHeader ⇒
                   if (x.renderInResponses) render(x)
                   renderHeaders(tail, alwaysClose, connHeader, serverSeen, transferEncodingSeen, dateSeen)
@@ -205,13 +207,15 @@ private[http] class HttpResponseRendererFactory(
                   r ~~ Connection ~~ (if (close) CloseBytes else KeepAliveBytes) ~~ CrLf
                 else if (connHeader != null && connHeader.hasUpgrade) {
                   r ~~ connHeader ~~ CrLf
-                  headers
-                    .collectFirst { case u: UpgradeToWebSocketResponseHeader ⇒ u }
-                    .foreach { header ⇒ closeMode = SwitchToWebSocket(header.handler) }
+                  HttpHeader.fastFind(classOf[UpgradeToWebSocketResponseHeader], headers) match {
+                    case OptionVal.Some(header) ⇒ closeMode = SwitchToWebSocket(header.handler)
+                    case _                      ⇒ // nothing to do here...
+                  }
                 }
                 if (mustRenderTransferEncodingChunkedHeader && !transferEncodingSeen)
                   r ~~ `Transfer-Encoding` ~~ ChunkedBytes ~~ CrLf
             }
+          }
 
           def renderContentLengthHeader(contentLength: Long) =
             if (status.allowsEntity) r ~~ `Content-Length` ~~ contentLength ~~ CrLf else r
@@ -219,7 +223,7 @@ private[http] class HttpResponseRendererFactory(
           def byteStrings(entityBytes: ⇒ Source[ByteString, Any]): Source[ResponseRenderingOutput, Any] =
             renderByteStrings(r, entityBytes, skipEntity = noEntity).map(ResponseRenderingOutput.HttpData(_))
 
-          def completeResponseRendering(entity: ResponseEntity): StrictOrStreamed =
+          @tailrec def completeResponseRendering(entity: ResponseEntity): StrictOrStreamed =
             entity match {
               case HttpEntity.Strict(_, data) ⇒
                 renderHeaders(headers.toList)
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/RenderSupport.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/RenderSupport.scala
index ca4a3ef0a2..0c2ddc5643 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/RenderSupport.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/rendering/RenderSupport.scala
@@ -28,6 +28,20 @@ private object RenderSupport {
   val KeepAliveBytes = "Keep-Alive".asciiBytes
   val CloseBytes = "close".asciiBytes
 
+  private[this] final val PreRenderedContentTypes = {
+    val m = new java.util.HashMap[ContentType, Array[Byte]](16)
+    def preRenderContentType(ct: ContentType) =
+      m.put(ct, (new ByteArrayRendering(32) ~~ headers.`Content-Type` ~~ ct ~~ CrLf).get)
+
+    import ContentTypes._
+    preRenderContentType(`application/json`)
+    preRenderContentType(`text/plain(UTF-8)`)
+    preRenderContentType(`text/xml(UTF-8)`)
+    preRenderContentType(`text/html(UTF-8)`)
+    preRenderContentType(`text/csv(UTF-8)`)
+    m
+  }
+
   def CrLf = Rendering.CrLf
 
   implicit val trailerRenderer = Renderer.genericSeqRenderer[Renderable, HttpHeader](CrLf, Rendering.Empty)
@@ -42,9 +56,14 @@ private object RenderSupport {
     })
   }
 
-  def renderEntityContentType(r: Rendering, entity: HttpEntity) =
-    if (entity.contentType != ContentTypes.NoContentType) r ~~ headers.`Content-Type` ~~ entity.contentType ~~ CrLf
-    else r
+  def renderEntityContentType(r: Rendering, entity: HttpEntity) = {
+    val ct = entity.contentType
+    if (ct != ContentTypes.NoContentType) {
+      val preRendered = PreRenderedContentTypes.get(ct)
+      if (preRendered ne null) r ~~ preRendered // re-use pre-rendered
+      else r ~~ headers.`Content-Type` ~~ ct ~~ CrLf // render ad-hoc
+    } else r // don't render
+  }
 
   def renderByteStrings(r: ByteStringRendering, entityBytes: ⇒ Source[ByteString, Any],
                         skipEntity: Boolean = false): Source[ByteString, Any] = {
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/server/HttpServerBluePrint.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/server/HttpServerBluePrint.scala
index 9e6f78fd4a..38d6a8b688 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/server/HttpServerBluePrint.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/server/HttpServerBluePrint.scala
@@ -65,7 +65,8 @@ private[http] object HttpServerBluePrint {
         websocketSupport(settings, log) atop
         tlsSupport
 
-    theStack.withAttributes(HttpAttributes.remoteAddress(remoteAddress))
+    if (settings.remoteAddressHeader && remoteAddress.isDefined) theStack.withAttributes(HttpAttributes.remoteAddress(remoteAddress))
+    else theStack
   }
 
   val tlsSupport: BidiFlow[ByteString, SslTlsOutbound, SslTlsInbound, SessionBytes, NotUsed] =
@@ -211,7 +212,7 @@ private[http] object HttpServerBluePrint {
     // the initial header parser we initially use for every connection,
     // will not be mutated, all "shared copy" parsers copy on first-write into the header cache
     val rootParser = new HttpRequestParser(parserSettings, rawRequestUriHeader,
-      HttpHeaderParser(parserSettings) { info ⇒
+      HttpHeaderParser(parserSettings, log) { info ⇒
         if (parserSettings.illegalHeaderWarnings)
           logParsingError(info withSummaryPrepended "Illegal request header", log, parserSettings.errorLoggingVerbosity)
       })
@@ -228,11 +229,7 @@ private[http] object HttpServerBluePrint {
       case x ⇒ x
     }
 
-    Flow[SessionBytes].via(
-      // each connection uses a single (private) request parser instance for all its requests
-      // which builds a cache of all header instances seen on that connection
-      rootParser.createShallowCopy().stage).named("rootParser")
-      .map(establishAbsoluteUri)
+    Flow[SessionBytes].via(rootParser).map(establishAbsoluteUri)
   }
 
   def rendering(settings: ServerSettings, log: LoggingAdapter): Flow[ResponseRenderingContext, ResponseRenderingOutput, NotUsed] = {
@@ -425,7 +422,7 @@ private[http] object HttpServerBluePrint {
 
           emit(responseCtxOut, ResponseRenderingContext(response, requestStart.method, requestStart.protocol, close),
             pullHttpResponseIn)
-          if (close && requestStart.expect100Continue) pull(requestParsingIn)
+          if (!isClosed(requestParsingIn) && close && requestStart.expect100Continue) pull(requestParsingIn)
         }
         override def onUpstreamFinish() =
           if (openRequests.isEmpty && isClosed(requestParsingIn)) completeStage()
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Handshake.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Handshake.scala
index c207b7c27e..dd704f7d2c 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Handshake.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Handshake.scala
@@ -5,6 +5,7 @@
 package akka.http.impl.engine.ws
 
 import java.util.Random
+
 import scala.collection.immutable
 import scala.collection.immutable.Seq
 import scala.reflect.ClassTag
@@ -12,7 +13,8 @@ import akka.http.impl.util._
 import akka.http.scaladsl.model.headers._
 import akka.http.scaladsl.model.ws.{ Message, UpgradeToWebSocket }
 import akka.http.scaladsl.model._
-import akka.stream.{ Graph, FlowShape }
+import akka.stream.{ FlowShape, Graph }
+import akka.util.OptionVal
 
 /**
  * Server-side implementation of the WebSocket handshake
@@ -62,50 +64,63 @@ private[http] object Handshake {
      *        to speak.  The interpretation of this header field is discussed
      *        in Section 9.1.
      */
-    def websocketUpgrade(headers: List[HttpHeader], hostHeaderPresent: Boolean): Option[UpgradeToWebSocket] = {
-      def find[T <: HttpHeader: ClassTag]: Option[T] =
-        headers.collectFirst {
-          case t: T ⇒ t
+    def websocketUpgrade(headers: List[HttpHeader], hostHeaderPresent: Boolean): OptionVal[UpgradeToWebSocket] = {
+
+      // notes on Headers that re REQUIRE to be present here:
+      // - Host header is validated in general HTTP logic
+      // - Origin header is optional and, if required, should be validated
+      //   on higher levels (routing, application logic)
+      // 
+      // TODO See #18709 Extension support is optional in WS and currently unsupported.
+      // 
+      // these are not needed directly, we verify their presence and correctness only:
+      // - Upgrade
+      // - Connection
+      // - `Sec-WebSocket-Version`
+      def hasAllRequiredWebsocketUpgradeHeaders: Boolean = {
+        // single-pass through the headers list while collecting all needed requirements
+        // this way we avoid scanning the requirements list 3 times (as we would with collect/find)
+        val it = headers.iterator
+        var requirementsMet = 0
+        val targetRequirements = 3
+        while (it.hasNext && (requirementsMet != targetRequirements)) it.next() match {
+          case u: Upgrade                 ⇒ if (u.hasWebSocket) requirementsMet += 1
+          case c: Connection              ⇒ if (c.hasUpgrade) requirementsMet += 1
+          case v: `Sec-WebSocket-Version` ⇒ if (v.hasVersion(CurrentWebSocketVersion)) requirementsMet += 1
+          case _                          ⇒ // continue...
         }
+        requirementsMet == targetRequirements
+      }
 
-      // Host header is validated in general HTTP logic
-      // val host = find[Host]
-      val upgrade = find[Upgrade]
-      val connection = find[Connection]
-      val key = find[`Sec-WebSocket-Key`]
-      val version = find[`Sec-WebSocket-Version`]
-      // Origin header is optional and, if required, should be validated
-      // on higher levels (routing, application logic)
-      // val origin = find[Origin]
-      val protocol = find[`Sec-WebSocket-Protocol`]
-      val clientSupportedSubprotocols = protocol.toList.flatMap(_.protocols)
-      // Extension support is optional in WS and currently unsupported.
-      // TODO See #18709
-      // val extensions = find[`Sec-WebSocket-Extensions`]
+      if (hasAllRequiredWebsocketUpgradeHeaders) {
+        val key = HttpHeader.fastFind(classOf[`Sec-WebSocket-Key`], headers)
+        if (key.isDefined && key.get.isValid) {
+          val protocol = HttpHeader.fastFind(classOf[`Sec-WebSocket-Protocol`], headers)
 
-      if (upgrade.exists(_.hasWebSocket) &&
-        connection.exists(_.hasUpgrade) &&
-        version.exists(_.hasVersion(CurrentWebSocketVersion)) &&
-        key.exists(k ⇒ k.isValid)) {
-
-        val header = new UpgradeToWebSocketLowLevel {
-          def requestedProtocols: Seq[String] = clientSupportedSubprotocols
-
-          def handle(handler: Either[Graph[FlowShape[FrameEvent, FrameEvent], Any], Graph[FlowShape[Message, Message], Any]], subprotocol: Option[String]): HttpResponse = {
-            require(
-              subprotocol.forall(chosen ⇒ clientSupportedSubprotocols.contains(chosen)),
-              s"Tried to choose invalid subprotocol '$subprotocol' which wasn't offered by the client: [${requestedProtocols.mkString(", ")}]")
-            buildResponse(key.get, handler, subprotocol)
+          val clientSupportedSubprotocols = protocol match {
+            case OptionVal.Some(p) ⇒ p.protocols
+            case _                 ⇒ Nil
           }
 
-          def handleFrames(handlerFlow: Graph[FlowShape[FrameEvent, FrameEvent], Any], subprotocol: Option[String]): HttpResponse =
-            handle(Left(handlerFlow), subprotocol)
+          val header = new UpgradeToWebSocketLowLevel {
+            def requestedProtocols: Seq[String] = clientSupportedSubprotocols
 
-          override def handleMessages(handlerFlow: Graph[FlowShape[Message, Message], Any], subprotocol: Option[String] = None): HttpResponse =
-            handle(Right(handlerFlow), subprotocol)
-        }
-        Some(header)
-      } else None
+            def handle(handler: Either[Graph[FlowShape[FrameEvent, FrameEvent], Any], Graph[FlowShape[Message, Message], Any]], subprotocol: Option[String]): HttpResponse = {
+              require(
+                subprotocol.forall(chosen ⇒ clientSupportedSubprotocols.contains(chosen)),
+                s"Tried to choose invalid subprotocol '$subprotocol' which wasn't offered by the client: [${requestedProtocols.mkString(", ")}]")
+              buildResponse(key.get, handler, subprotocol)
+            }
+
+            def handleFrames(handlerFlow: Graph[FlowShape[FrameEvent, FrameEvent], Any], subprotocol: Option[String]): HttpResponse =
+              handle(Left(handlerFlow), subprotocol)
+
+            override def handleMessages(handlerFlow: Graph[FlowShape[Message, Message], Any], subprotocol: Option[String] = None): HttpResponse =
+              handle(Right(handlerFlow), subprotocol)
+          }
+          OptionVal.Some(header)
+        } else OptionVal.None
+      } else OptionVal.None
     }
 
     /*
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Masking.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Masking.scala
index e69945b82a..095b6f14e1 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Masking.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/Masking.scala
@@ -7,8 +7,9 @@ package akka.http.impl.engine.ws
 import java.util.Random
 
 import akka.NotUsed
+import akka.stream.{ Attributes, Outlet, Inlet, FlowShape }
 import akka.stream.scaladsl.{ Keep, BidiFlow, Flow }
-import akka.stream.stage.{ SyncDirective, Context, StatefulStage }
+import akka.stream.stage._
 
 /**
  * Implements WebSocket Frame masking.
@@ -20,19 +21,20 @@ private[http] object Masking {
     BidiFlow.fromFlowsMat(unmaskIf(serverSide), maskIf(!serverSide, maskRandom))(Keep.none)
 
   def maskIf(condition: Boolean, maskRandom: () ⇒ Random): Flow[FrameEvent, FrameEvent, NotUsed] =
-    if (condition)
+    if (condition) {
       Flow[FrameEvent]
-        .transform(() ⇒ new Masking(maskRandom())) // new random per materialization
+        .via(new Masking(maskRandom())) // new random per materialization
         .map {
           case f: FrameEvent  ⇒ f
           case FrameError(ex) ⇒ throw ex
         }
-    else Flow[FrameEvent]
+    } else Flow[FrameEvent]
+
   def unmaskIf(condition: Boolean): Flow[FrameEvent, FrameEventOrError, NotUsed] =
-    if (condition) Flow[FrameEvent].transform(() ⇒ new Unmasking())
+    if (condition) Flow[FrameEvent].via(Unmasking)
     else Flow[FrameEvent]
 
-  private class Masking(random: Random) extends Masker {
+  private final class Masking(random: Random) extends Masker {
     def extractMask(header: FrameHeader): Int = random.nextInt()
     def setNewMask(header: FrameHeader, mask: Int): FrameHeader = {
       if (header.mask.isDefined) throw new ProtocolException("Frame mustn't already be masked")
@@ -40,7 +42,8 @@ private[http] object Masking {
     }
     override def toString: String = s"Masking($random)"
   }
-  private class Unmasking extends Masker {
+
+  private object Unmasking extends Masker {
     def extractMask(header: FrameHeader): Int = header.mask match {
       case Some(mask) ⇒ mask
       case None       ⇒ throw new ProtocolException("Frame wasn't masked")
@@ -50,42 +53,59 @@ private[http] object Masking {
   }
 
   /** Implements both masking and unmasking which is mostly symmetric (because of XOR) */
-  private abstract class Masker extends StatefulStage[FrameEvent, FrameEventOrError] {
+  private abstract class Masker extends GraphStage[FlowShape[FrameEvent, FrameEventOrError]] {
     def extractMask(header: FrameHeader): Int
     def setNewMask(header: FrameHeader, mask: Int): FrameHeader
 
-    def initial: State = Idle
+    val in = Inlet[FrameEvent](s"${toString}-in")
+    val out = Outlet[FrameEventOrError](s"${toString}-out")
+    override val shape: FlowShape[FrameEvent, FrameEventOrError] = FlowShape(in, out)
 
-    private object Idle extends State {
-      def onPush(part: FrameEvent, ctx: Context[FrameEventOrError]): SyncDirective =
-        part match {
-          case start @ FrameStart(header, data) ⇒
-            try {
-              val mask = extractMask(header)
-              become(new Running(mask))
-              current.onPush(start.copy(header = setNewMask(header, mask)), ctx)
-            } catch {
-              case p: ProtocolException ⇒
-                become(Done)
-                ctx.push(FrameError(p))
+    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with OutHandler with InHandler {
+
+      def onPush(): Unit = grab(in) match {
+        case start @ FrameStart(header, data) ⇒
+          try {
+            val mask = extractMask(header)
+
+            val (masked, newMask) = FrameEventParser.mask(data, mask)
+            if (!start.lastPart) {
+              setHandler(in, runningHandler(newMask, this))
             }
-          case _: FrameData ⇒
-            ctx.fail(new IllegalStateException("unexpected FrameData (need FrameStart first)"))
-        }
-    }
-    private class Running(initialMask: Int) extends State {
-      var mask = initialMask
-
-      def onPush(part: FrameEvent, ctx: Context[FrameEventOrError]): SyncDirective = {
-        if (part.lastPart) become(Idle)
-
-        val (masked, newMask) = FrameEventParser.mask(part.data, mask)
-        mask = newMask
-        ctx.push(part.withData(data = masked))
+            push(out, start.copy(header = setNewMask(header, mask), data = masked))
+          } catch {
+            case p: ProtocolException ⇒ {
+              setHandler(in, doneHandler)
+              push(out, FrameError(p))
+            }
+          }
+        case _: FrameData ⇒ fail(out, new IllegalStateException("unexpected FrameData (need FrameStart first)"))
       }
-    }
-    private object Done extends State {
-      def onPush(part: FrameEvent, ctx: Context[FrameEventOrError]): SyncDirective = ctx.pull()
+
+      private def doneHandler = new InHandler {
+        override def onPush(): Unit = pull(in)
+      }
+
+      private def runningHandler(initialMask: Int, nextState: InHandler): InHandler = new InHandler {
+        var mask = initialMask
+
+        override def onPush(): Unit = {
+          val part = grab(in)
+          if (part.lastPart) {
+            setHandler(in, nextState)
+          }
+
+          val (masked, newMask) = FrameEventParser.mask(part.data, mask)
+          mask = newMask
+          push(out, part.withData(data = masked))
+        }
+      }
+
+      def onPull(): Unit = pull(in)
+
+      setHandler(in, this)
+      setHandler(out, this)
+
     }
   }
 }
diff --git a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/WebSocketClientBlueprint.scala b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/WebSocketClientBlueprint.scala
index e193877496..7cdfda7fc1 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/engine/ws/WebSocketClientBlueprint.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/engine/ws/WebSocketClientBlueprint.scala
@@ -62,7 +62,7 @@ object WebSocketClientBlueprint {
         new GraphStageLogic(shape) with InHandler with OutHandler {
           // a special version of the parser which only parses one message and then reports the remaining data
           // if some is available
-          val parser = new HttpResponseParser(settings.parserSettings, HttpHeaderParser(settings.parserSettings)()) {
+          val parser = new HttpResponseParser(settings.parserSettings, HttpHeaderParser(settings.parserSettings, log)()) {
             var first = true
             override def handleInformationalResponses = false
             override protected def parseMessage(input: ByteString, offset: Int): StateResult = {
@@ -111,6 +111,11 @@ object WebSocketClientBlueprint {
           override def onPull(): Unit = pull(in)
 
           setHandlers(in, out, this)
+
+          override def onUpstreamFailure(ex: Throwable): Unit = {
+            result.tryFailure(new RuntimeException("Connection failed.", ex))
+            super.onUpstreamFailure(ex)
+          }
         }
 
       override def toString = "UpgradeStage"
diff --git a/akka-http-core/src/main/scala/akka/http/impl/model/parser/CommonRules.scala b/akka-http-core/src/main/scala/akka/http/impl/model/parser/CommonRules.scala
index 1176c33133..e3b8c95f4a 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/model/parser/CommonRules.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/model/parser/CommonRules.scala
@@ -174,7 +174,7 @@ private[parser] trait CommonRules { this: Parser with StringBuilding ⇒
   def challenge = rule {
     `challenge-or-credentials` ~> { (scheme, params) ⇒
       val (realms, otherParams) = params.partition(_._1 equalsIgnoreCase "realm")
-      HttpChallenge(scheme, realms.headOption.map(_._2).getOrElse(""), otherParams.toMap)
+      HttpChallenge(scheme, realms.headOption.map(_._2), otherParams.toMap)
     }
   }
 
diff --git a/akka-http-core/src/main/scala/akka/http/impl/model/parser/HeaderParser.scala b/akka-http-core/src/main/scala/akka/http/impl/model/parser/HeaderParser.scala
index 1d95e2f0b6..04c6e3a157 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/model/parser/HeaderParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/model/parser/HeaderParser.scala
@@ -6,6 +6,7 @@ package akka.http.impl.model.parser
 
 import akka.http.scaladsl.settings.ParserSettings
 import akka.http.scaladsl.settings.ParserSettings.CookieParsingMode
+import akka.http.scaladsl.settings.ParserSettings.IllegalResponseHeaderValueProcessingMode
 import akka.http.scaladsl.model.headers.HttpCookiePair
 import akka.stream.impl.ConstantFun
 import scala.util.control.NonFatal
@@ -169,20 +170,26 @@ private[http] object HeaderParser {
     def uriParsingMode: Uri.ParsingMode
     def cookieParsingMode: ParserSettings.CookieParsingMode
     def customMediaTypes: MediaTypes.FindCustom
+    def illegalResponseHeaderValueProcessingMode: IllegalResponseHeaderValueProcessingMode
   }
   def Settings(
-    uriParsingMode:    Uri.ParsingMode                  = Uri.ParsingMode.Relaxed,
-    cookieParsingMode: ParserSettings.CookieParsingMode = ParserSettings.CookieParsingMode.RFC6265,
-    customMediaTypes:  MediaTypes.FindCustom            = ConstantFun.scalaAnyTwoToNone): Settings = {
+    uriParsingMode:    Uri.ParsingMode                          = Uri.ParsingMode.Relaxed,
+    cookieParsingMode: ParserSettings.CookieParsingMode         = ParserSettings.CookieParsingMode.RFC6265,
+    customMediaTypes:  MediaTypes.FindCustom                    = ConstantFun.scalaAnyTwoToNone,
+    mode:              IllegalResponseHeaderValueProcessingMode = ParserSettings.IllegalResponseHeaderValueProcessingMode.Error): Settings = {
+
     val _uriParsingMode = uriParsingMode
     val _cookieParsingMode = cookieParsingMode
     val _customMediaTypes = customMediaTypes
+    val _illegalResponseHeaderValueProcessingMode = mode
 
     new Settings {
       def uriParsingMode: Uri.ParsingMode = _uriParsingMode
       def cookieParsingMode: CookieParsingMode = _cookieParsingMode
       def customMediaTypes: MediaTypes.FindCustom = _customMediaTypes
+      def illegalResponseHeaderValueProcessingMode: IllegalResponseHeaderValueProcessingMode =
+        _illegalResponseHeaderValueProcessingMode
     }
   }
   val DefaultSettings: Settings = Settings()
-}
\ No newline at end of file
+}
diff --git a/akka-http-core/src/main/scala/akka/http/impl/model/parser/UriParser.scala b/akka-http-core/src/main/scala/akka/http/impl/model/parser/UriParser.scala
index 687292a8a2..64a32d8cd5 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/model/parser/UriParser.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/model/parser/UriParser.scala
@@ -13,9 +13,12 @@ import Parser.DeliveryScheme.Either
 import Uri._
 
 // format: OFF
-
-// http://tools.ietf.org/html/rfc3986
-private[http] class UriParser(val input: ParserInput,
+/**
+ * INTERNAL API
+ *
+ * http://tools.ietf.org/html/rfc3986
+ */
+private[http] final class UriParser(val input: ParserInput,
                               val uriParsingCharset: Charset,
                               val uriParsingMode: Uri.ParsingMode,
                               val maxValueStackSize: Int) extends Parser(maxValueStackSize)
diff --git a/akka-http-core/src/main/scala/akka/http/impl/settings/ParserSettingsImpl.scala b/akka-http-core/src/main/scala/akka/http/impl/settings/ParserSettingsImpl.scala
index 4214065af4..09362ba630 100644
--- a/akka-http-core/src/main/scala/akka/http/impl/settings/ParserSettingsImpl.scala
+++ b/akka-http-core/src/main/scala/akka/http/impl/settings/ParserSettingsImpl.scala
@@ -5,7 +5,7 @@
 package akka.http.impl.settings
 
 import akka.http.scaladsl.settings.ParserSettings
-import akka.http.scaladsl.settings.ParserSettings.{ ErrorLoggingVerbosity, CookieParsingMode }
+import akka.http.scaladsl.settings.ParserSettings.{ IllegalResponseHeaderValueProcessingMode, ErrorLoggingVerbosity, CookieParsingMode }
 import akka.stream.impl.ConstantFun
 import com.typesafe.config.Config
 import scala.collection.JavaConverters._
@@ -14,24 +14,25 @@ import akka.http.impl.util._
 
 /** INTERNAL API */
 private[akka] final case class ParserSettingsImpl(
-  maxUriLength:                Int,
-  maxMethodLength:             Int,
-  maxResponseReasonLength:     Int,
-  maxHeaderNameLength:         Int,
-  maxHeaderValueLength:        Int,
-  maxHeaderCount:              Int,
-  maxContentLength:            Long,
-  maxChunkExtLength:           Int,
-  maxChunkSize:                Int,
-  uriParsingMode:              Uri.ParsingMode,
-  cookieParsingMode:           CookieParsingMode,
-  illegalHeaderWarnings:       Boolean,
-  errorLoggingVerbosity:       ParserSettings.ErrorLoggingVerbosity,
-  headerValueCacheLimits:      Map[String, Int],
-  includeTlsSessionInfoHeader: Boolean,
-  customMethods:               String ⇒ Option[HttpMethod],
-  customStatusCodes:           Int ⇒ Option[StatusCode],
-  customMediaTypes:            MediaTypes.FindCustom)
+  maxUriLength:                             Int,
+  maxMethodLength:                          Int,
+  maxResponseReasonLength:                  Int,
+  maxHeaderNameLength:                      Int,
+  maxHeaderValueLength:                     Int,
+  maxHeaderCount:                           Int,
+  maxContentLength:                         Long,
+  maxChunkExtLength:                        Int,
+  maxChunkSize:                             Int,
+  uriParsingMode:                           Uri.ParsingMode,
+  cookieParsingMode:                        CookieParsingMode,
+  illegalHeaderWarnings:                    Boolean,
+  errorLoggingVerbosity:                    ErrorLoggingVerbosity,
+  illegalResponseHeaderValueProcessingMode: IllegalResponseHeaderValueProcessingMode,
+  headerValueCacheLimits:                   Map[String, Int],
+  includeTlsSessionInfoHeader:              Boolean,
+  customMethods:                            String ⇒ Option[HttpMethod],
+  customStatusCodes:                        Int ⇒ Option[StatusCode],
+  customMediaTypes:                         MediaTypes.FindCustom)
   extends akka.http.scaladsl.settings.ParserSettings {
 
   require(maxUriLength > 0, "max-uri-length must be > 0")
@@ -76,6 +77,7 @@ object ParserSettingsImpl extends SettingsCompanion[ParserSettingsImpl]("akka.ht
       CookieParsingMode(c getString "cookie-parsing-mode"),
       c getBoolean "illegal-header-warnings",
       ErrorLoggingVerbosity(c getString "error-logging-verbosity"),
+      IllegalResponseHeaderValueProcessingMode(c getString "illegal-response-header-value-processing-mode"),
       cacheConfig.entrySet.asScala.map(kvp ⇒ kvp.getKey → cacheConfig.getInt(kvp.getKey))(collection.breakOut),
       c getBoolean "tls-session-info-header",
       noCustomMethods,
diff --git a/akka-http-core/src/main/scala/akka/http/impl/util/ByteStringParserInput.scala b/akka-http-core/src/main/scala/akka/http/impl/util/ByteStringParserInput.scala
new file mode 100644
index 0000000000..bd7b88ddfe
--- /dev/null
+++ b/akka-http-core/src/main/scala/akka/http/impl/util/ByteStringParserInput.scala
@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http.impl.util
+
+import java.nio.charset.StandardCharsets
+
+import akka.parboiled2.ParserInput.DefaultParserInput
+import akka.util.ByteString
+
+/**
+ * ParserInput reading directly off a ByteString. (Based on the ByteArrayBasedParserInput)
+ * This avoids a separate decoding step but assumes that each byte represents exactly one character,
+ * which is encoded by ISO-8859-1!
+ * You can therefore use this ParserInput type only if you know that all input will be `ISO-8859-1`-encoded,
+ * or only contains 7-bit ASCII characters (which is a subset of ISO-8859-1)!
+ *
+ * Note that this ParserInput type will NOT work with general `UTF-8`-encoded input as this can contain
+ * character representations spanning multiple bytes. However, if you know that your input will only ever contain
+ * 7-bit ASCII characters (0x00-0x7F) then UTF-8 is fine, since the first 127 UTF-8 characters are
+ * encoded with only one byte that is identical to 7-bit ASCII and ISO-8859-1.
+ */
+final class ByteStringParserInput(bytes: ByteString) extends DefaultParserInput {
+  override def charAt(ix: Int): Char = (bytes(ix) & 0xFF).toChar
+  override def length: Int = bytes.size
+  override def sliceString(start: Int, end: Int): String = bytes.slice(start, end).decodeString(StandardCharsets.ISO_8859_1)
+  override def sliceCharArray(start: Int, end: Int): Array[Char] =
+    StandardCharsets.ISO_8859_1.decode(bytes.slice(start, end).asByteBuffer).array()
+}
diff --git a/akka-http-core/src/main/scala/akka/http/javadsl/settings/ParserSettings.scala b/akka-http-core/src/main/scala/akka/http/javadsl/settings/ParserSettings.scala
index c977b4ead7..21279b3bfb 100644
--- a/akka-http-core/src/main/scala/akka/http/javadsl/settings/ParserSettings.scala
+++ b/akka-http-core/src/main/scala/akka/http/javadsl/settings/ParserSettings.scala
@@ -33,6 +33,7 @@ abstract class ParserSettings private[akka] () extends BodyPartParser.Settings {
   def getCookieParsingMode: ParserSettings.CookieParsingMode
   def getIllegalHeaderWarnings: Boolean
   def getErrorLoggingVerbosity: ParserSettings.ErrorLoggingVerbosity
+  def getIllegalResponseHeaderValueProcessingMode: ParserSettings.IllegalResponseHeaderValueProcessingMode
   def getHeaderValueCacheLimits: ju.Map[String, Int]
   def getIncludeTlsSessionInfoHeader: Boolean
   def headerValueCacheLimits: Map[String, Int]
@@ -81,6 +82,7 @@ abstract class ParserSettings private[akka] () extends BodyPartParser.Settings {
 object ParserSettings extends SettingsCompanion[ParserSettings] {
   trait CookieParsingMode
   trait ErrorLoggingVerbosity
+  trait IllegalResponseHeaderValueProcessingMode
 
   override def create(config: Config): ParserSettings = ParserSettingsImpl(config)
   override def create(configOverrides: String): ParserSettings = ParserSettingsImpl(configOverrides)
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala
index 248f70eb2d..63c3cc6dff 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala
@@ -9,6 +9,7 @@ import java.util.concurrent.CompletionStage
 import javax.net.ssl._
 
 import akka.actor._
+import akka.dispatch.ExecutionContexts
 import akka.event.{ Logging, LoggingAdapter }
 import akka.http.impl.engine.HttpConnectionTimeoutException
 import akka.http.impl.engine.client.PoolMasterActor.{ PoolSize, ShutdownAll }
@@ -26,6 +27,7 @@ import akka.{ Done, NotUsed }
 import akka.stream._
 import akka.stream.TLSProtocol._
 import akka.stream.scaladsl._
+import akka.util.ByteString
 import com.typesafe.config.Config
 import com.typesafe.sslconfig.akka._
 import com.typesafe.sslconfig.akka.util.AkkaLoggerFactory
@@ -55,6 +57,27 @@ class HttpExt(private val config: Config)(implicit val system: ActorSystem) exte
 
   private[this] final val DefaultPortForProtocol = -1 // any negative value
 
+  private def fuseServerLayer(settings: ServerSettings, connectionContext: ConnectionContext, log: LoggingAdapter)(implicit mat: Materializer): BidiFlow[HttpResponse, ByteString, ByteString, HttpRequest, NotUsed] = {
+    val httpLayer = serverLayer(settings, None, log)
+    val tlsStage = sslTlsStage(connectionContext, Server)
+    BidiFlow.fromGraph(Fusing.aggressive(GraphDSL.create() { implicit b ⇒
+      import GraphDSL.Implicits._
+      val http = b.add(httpLayer)
+      val tls = b.add(tlsStage)
+
+      val timeouts = b.add(Flow[ByteString].recover {
+        case t: TimeoutException ⇒ throw new HttpConnectionTimeoutException(t.getMessage)
+      })
+
+      tls.out2 ~> http.in2
+      tls.in1 <~ http.out1
+
+      tls.out1 ~> timeouts.in
+
+      BidiShape(http.in1, timeouts.out, tls.in2, http.out2)
+    }))
+  }
+
   /**
    * Creates a [[akka.stream.scaladsl.Source]] of [[akka.http.scaladsl.Http.IncomingConnection]] instances which represents a prospective HTTP server binding
    * on the given `endpoint`.
@@ -81,14 +104,14 @@ class HttpExt(private val config: Config)(implicit val system: ActorSystem) exte
            settings:          ServerSettings    = ServerSettings(system),
            log:               LoggingAdapter    = system.log)(implicit fm: Materializer): Source[IncomingConnection, Future[ServerBinding]] = {
     val effectivePort = if (port >= 0) port else connectionContext.defaultPort
-    val tlsStage = sslTlsStage(connectionContext, Server)
+
+    val fullLayer = fuseServerLayer(settings, connectionContext, log)
+
     val connections: Source[Tcp.IncomingConnection, Future[Tcp.ServerBinding]] =
       Tcp().bind(interface, effectivePort, settings.backlog, settings.socketOptions, halfClose = false, settings.timeouts.idleTimeout)
     connections.map {
       case Tcp.IncomingConnection(localAddress, remoteAddress, flow) ⇒
-        val layer = serverLayer(settings, Some(remoteAddress), log)
-        val flowWithTimeoutRecovered = flow.via(MapError { case t: TimeoutException ⇒ new HttpConnectionTimeoutException(t.getMessage) })
-        IncomingConnection(localAddress, remoteAddress, layer atop tlsStage join flowWithTimeoutRecovered)
+        IncomingConnection(localAddress, remoteAddress, fullLayer join flow)
     }.mapMaterializedValue {
       _.map(tcpBinding ⇒ ServerBinding(tcpBinding.localAddress)(() ⇒ tcpBinding.unbind()))(fm.executionContext)
     }
@@ -110,30 +133,42 @@ class HttpExt(private val config: Config)(implicit val system: ActorSystem) exte
     connectionContext: ConnectionContext = defaultServerHttpContext,
     settings:          ServerSettings    = ServerSettings(system),
     log:               LoggingAdapter    = system.log)(implicit fm: Materializer): Future[ServerBinding] = {
-    def handleOneConnection(incomingConnection: IncomingConnection): Future[Done] =
-      try
-        incomingConnection.flow
-          .watchTermination()(Keep.right)
-          .joinMat(handler)(Keep.left)
-          .run()
-      catch {
-        case NonFatal(e) ⇒
-          log.error(e, "Could not materialize handling flow for {}", incomingConnection)
-          throw e
-      }
+    val effectivePort = if (port >= 0) port else connectionContext.defaultPort
+
+    val fullLayer: Flow[ByteString, ByteString, Future[Done]] = Flow.fromGraph(Fusing.aggressive(
+      Flow[HttpRequest]
+        .watchTermination()(Keep.right)
+        .viaMat(handler)(Keep.left)
+        .joinMat(fuseServerLayer(settings, connectionContext, log))(Keep.left)))
+
+    val connections: Source[Tcp.IncomingConnection, Future[Tcp.ServerBinding]] =
+      Tcp().bind(interface, effectivePort, settings.backlog, settings.socketOptions, halfClose = false, settings.timeouts.idleTimeout)
+
+    connections.mapAsyncUnordered(settings.maxConnections) {
+      case incoming: Tcp.IncomingConnection ⇒
+        try {
+          val layer =
+            if (settings.remoteAddressHeader) fullLayer.addAttributes(HttpAttributes.remoteAddress(Some(incoming.remoteAddress)))
+            else fullLayer
+
+          layer.joinMat(incoming.flow)(Keep.left)
+            .run().recover {
+              // Ignore incoming errors from the connection as they will cancel the binding.
+              // As far as it is known currently, these errors can only happen if a TCP error bubbles up
+              // from the TCP layer through the HTTP layer to the Http.IncomingConnection.flow.
+              // See https://github.com/akka/akka/issues/17992
+              case NonFatal(ex) ⇒
+                Done
+            }(ExecutionContexts.sameThreadExecutionContext)
+        } catch {
+          case NonFatal(e) ⇒
+            log.error(e, "Could not materialize handling flow for {}", incoming)
+            throw e
+        }
+    }.mapMaterializedValue {
+      _.map(tcpBinding ⇒ ServerBinding(tcpBinding.localAddress)(() ⇒ tcpBinding.unbind()))(fm.executionContext)
+    }.to(Sink.ignore).run()
 
-    bind(interface, port, connectionContext, settings, log)
-      .mapAsyncUnordered(settings.maxConnections) { connection ⇒
-        handleOneConnection(connection).recoverWith {
-          // Ignore incoming errors from the connection as they will cancel the binding.
-          // As far as it is known currently, these errors can only happen if a TCP error bubbles up
-          // from the TCP layer through the HTTP layer to the Http.IncomingConnection.flow.
-          // See https://github.com/akka/akka/issues/17992
-          case NonFatal(_) ⇒ Future.successful(())
-        }(fm.executionContext)
-      }
-      .to(Sink.ignore)
-      .run()
   }
 
   /**
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpEntity.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpEntity.scala
index c07ccd8db5..6c2815356c 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpEntity.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpEntity.scala
@@ -10,8 +10,9 @@ import akka.http.impl.model.JavaInitialization
 
 import language.implicitConversions
 import java.io.File
-import java.nio.file.{ Path, Files }
+import java.nio.file.{ Files, Path }
 import java.lang.{ Iterable ⇒ JIterable }
+
 import scala.util.control.NonFatal
 import scala.concurrent.Future
 import scala.concurrent.duration._
@@ -20,8 +21,8 @@ import akka.util.ByteString
 import akka.stream.scaladsl._
 import akka.stream.stage._
 import akka.stream._
-import akka.{ NotUsed, stream }
-import akka.http.scaladsl.model.ContentType.{ NonBinary, Binary }
+import akka.{ Done, NotUsed, stream }
+import akka.http.scaladsl.model.ContentType.{ Binary, NonBinary }
 import akka.http.scaladsl.util.FastFuture
 import akka.http.javadsl.{ model ⇒ jm }
 import akka.http.impl.util.{ JavaMapping, StreamUtils }
@@ -31,6 +32,8 @@ import scala.compat.java8.OptionConverters._
 import scala.compat.java8.FutureConverters._
 import java.util.concurrent.CompletionStage
 
+import scala.compat.java8.FutureConverters
+
 /**
  * Models the entity (aka "body" or "content) of an HTTP message.
  */
@@ -72,6 +75,25 @@ sealed trait HttpEntity extends jm.HttpEntity {
       .via(new akka.http.impl.util.ToStrict(timeout, contentType))
       .runWith(Sink.head)
 
+  /**
+   * Discards the entities data bytes by running the `dataBytes` Source contained in this `entity`.
+   *
+   * Note: It is crucial that entities are either discarded, or consumed by running the underlying [[akka.stream.scaladsl.Source]]
+   * as otherwise the lack of consuming of the data will trigger back-pressure to the underlying TCP connection
+   * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of
+   * just having ignored the data.
+   *
+   * Warning: It is not allowed to discard and/or consume the `entity.dataBytes` more than once
+   * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
+   * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
+   * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
+   * "stream can cannot be materialized more than once" exception.
+   *
+   * In future versions, more automatic ways to warn or resolve these situations may be introduced, see issue #18716.
+   */
+  override def discardBytes(mat: Materializer): HttpMessage.DiscardedEntity =
+    new HttpMessage.DiscardedEntity(dataBytes.runWith(Sink.ignore)(mat))
+
   /**
    * Returns a copy of the given entity with the ByteString chunks of this entity transformed by the given transformer.
    * For a `Chunked` entity, the chunks will be transformed one by one keeping the chunk metadata (but may introduce an
@@ -145,6 +167,7 @@ sealed trait HttpEntity extends jm.HttpEntity {
   /** Java API */
   override def toStrict(timeoutMillis: Long, materializer: Materializer): CompletionStage[jm.HttpEntity.Strict] =
     toStrict(timeoutMillis.millis)(materializer).toJava
+
 }
 
 /* An entity that can be used for body parts */
@@ -369,6 +392,10 @@ object HttpEntity {
 
     override def productPrefix = "HttpEntity.Default"
 
+    override def toString: String = {
+      s"$productPrefix($contentType,$contentLength bytes total)"
+    }
+
     /** Java API */
     override def getContentLength = contentLength
   }
@@ -414,6 +441,10 @@ object HttpEntity {
     override def withData(data: Source[ByteString, Any]): HttpEntity.CloseDelimited = copy(data = data)
 
     override def productPrefix = "HttpEntity.CloseDelimited"
+
+    override def toString: String = {
+      s"$productPrefix($contentType)"
+    }
   }
 
   /**
@@ -431,6 +462,10 @@ object HttpEntity {
     override def withData(data: Source[ByteString, Any]): HttpEntity.IndefiniteLength = copy(data = data)
 
     override def productPrefix = "HttpEntity.IndefiniteLength"
+
+    override def toString: String = {
+      s"$productPrefix($contentType)"
+    }
   }
 
   /**
@@ -469,6 +504,10 @@ object HttpEntity {
 
     override def productPrefix = "HttpEntity.Chunked"
 
+    override def toString: String = {
+      s"$productPrefix($contentType)"
+    }
+
     /** Java API */
     def getChunks: stream.javadsl.Source[jm.HttpEntity.ChunkStreamPart, AnyRef] =
       stream.javadsl.Source.fromGraph(chunks.asInstanceOf[Source[jm.HttpEntity.ChunkStreamPart, AnyRef]])
@@ -533,14 +572,14 @@ object HttpEntity {
    * to entity constructors.
    */
   def limitableByteSource[Mat](source: Source[ByteString, Mat]): Source[ByteString, Mat] =
-    limitable(source, sizeOfByteString)
+    source.via(new Limitable(sizeOfByteString))
 
   /**
    * Turns the given source into one that respects the `withSizeLimit` calls when used as a parameter
    * to entity constructors.
    */
   def limitableChunkSource[Mat](source: Source[ChunkStreamPart, Mat]): Source[ChunkStreamPart, Mat] =
-    limitable(source, sizeOfChunkStreamPart)
+    source.via(new Limitable(sizeOfChunkStreamPart))
 
   /**
    * INTERNAL API
@@ -548,35 +587,46 @@ object HttpEntity {
   private val sizeOfByteString: ByteString ⇒ Int = _.size
   private val sizeOfChunkStreamPart: ChunkStreamPart ⇒ Int = _.data.size
 
-  /**
-   * INTERNAL API
-   */
-  private def limitable[Out, Mat](source: Source[Out, Mat], sizeOf: Out ⇒ Int): Source[Out, Mat] =
-    source.via(Flow[Out].transform { () ⇒
-      new PushStage[Out, Out] {
-        var maxBytes = -1L
-        var bytesLeft = Long.MaxValue
+  private val limitableDefaults = Attributes.name("limitable")
 
-        override def preStart(ctx: LifecycleContext) =
-          ctx.attributes.getFirst[SizeLimit] match {
-            case Some(limit: SizeLimit) if limit.isDisabled ⇒
-            // "no limit"
-            case Some(SizeLimit(bytes, cl @ Some(contentLength))) ⇒
-              if (contentLength > bytes) throw EntityStreamSizeException(bytes, cl)
-            // else we still count but never throw an error
-            case Some(SizeLimit(bytes, None)) ⇒
-              maxBytes = bytes
-              bytesLeft = bytes
-            case None ⇒
-          }
+  private final class Limitable[T](sizeOf: T ⇒ Int) extends GraphStage[FlowShape[T, T]] {
+    val in = Inlet[T]("Limitable.in")
+    val out = Outlet[T]("Limitable.out")
+    override val shape = FlowShape.of(in, out)
+    override protected val initialAttributes: Attributes = limitableDefaults
 
-        def onPush(elem: Out, ctx: stage.Context[Out]): stage.SyncDirective = {
-          bytesLeft -= sizeOf(elem)
-          if (bytesLeft >= 0) ctx.push(elem)
-          else ctx.fail(EntityStreamSizeException(maxBytes))
+    override def createLogic(attributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with InHandler with OutHandler {
+      private var maxBytes = -1L
+      private var bytesLeft = Long.MaxValue
+
+      override def preStart(): Unit = {
+        attributes.getFirst[SizeLimit] match {
+          case Some(limit: SizeLimit) if limit.isDisabled ⇒
+          // "no limit"
+          case Some(SizeLimit(bytes, cl @ Some(contentLength))) ⇒
+            if (contentLength > bytes) throw EntityStreamSizeException(bytes, cl)
+          // else we still count but never throw an error
+          case Some(SizeLimit(bytes, None)) ⇒
+            maxBytes = bytes
+            bytesLeft = bytes
+          case None ⇒
         }
       }
-    }.named("limitable"))
+
+      override def onPush(): Unit = {
+        val elem = grab(in)
+        bytesLeft -= sizeOf(elem)
+        if (bytesLeft >= 0) push(out, elem)
+        else failStage(EntityStreamSizeException(maxBytes))
+      }
+
+      override def onPull(): Unit = {
+        pull(in)
+      }
+
+      setHandlers(in, out, this)
+    }
+  }
 
   /**
    * INTERNAL API
@@ -607,4 +657,44 @@ object HttpEntity {
         val (newData, whenCompleted) = StreamUtils.captureTermination(x.data)
         x.copy(data = newData).asInstanceOf[T] → whenCompleted
     }
+
+  /**
+   * Represents the currently being-drained HTTP Entity which triggers completion of the contained
+   * Future once the entity has been drained for the given HttpMessage completely.
+   */
+  final class DiscardedEntity(f: Future[Done]) extends akka.http.javadsl.model.HttpMessage.DiscardedEntity {
+    /**
+     * This future completes successfully once the underlying entity stream has been
+     * successfully drained (and fails otherwise).
+     */
+    def future: Future[Done] = f
+
+    /**
+     * This future completes successfully once the underlying entity stream has been
+     * successfully drained (and fails otherwise).
+     */
+    def completionStage: CompletionStage[Done] = FutureConverters.toJava(f)
+  }
+
+  /** Adds Scala DSL idiomatic methods to [[HttpEntity]], e.g. versions of methods with an implicit [[Materializer]]. */
+  implicit final class HttpEntityScalaDSLSugar(val httpEntity: HttpEntity) extends AnyVal {
+    /**
+     * Discards the entities data bytes by running the `dataBytes` Source contained in this `entity`.
+     *
+     * Note: It is crucial that entities are either discarded, or consumed by running the underlying [[akka.stream.scaladsl.Source]]
+     * as otherwise the lack of consuming of the data will trigger back-pressure to the underlying TCP connection
+     * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of
+     * just having ignored the data.
+     *
+     * Warning: It is not allowed to discard and/or consume the `entity.dataBytes` more than once
+     * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
+     * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
+     * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
+     * "stream can cannot be materialized more than once" exception.
+     *
+     * In future versions, more automatic ways to warn or resolve these situations may be introduced, see issue #18716.
+     */
+    def discardBytes()(implicit mat: Materializer): HttpMessage.DiscardedEntity =
+      httpEntity.discardBytes(mat)
+  }
 }
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpHeader.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpHeader.scala
index 0896fec5c2..ecd3c5341a 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpHeader.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpHeader.scala
@@ -4,14 +4,19 @@
 
 package akka.http.scaladsl.model
 
-import akka.http.scaladsl.settings.ParserSettings
+import java.nio.charset.StandardCharsets
 
-import scala.util.{ Success, Failure }
-import akka.parboiled2.ParseError
+import scala.util.{ Failure, Success }
+import akka.parboiled2.{ ParseError, ParserInput }
 import akka.http.impl.util.ToStringRenderable
 import akka.http.impl.model.parser.{ CharacterClasses, HeaderParser }
 import akka.http.javadsl.{ model ⇒ jm }
 import akka.http.scaladsl.model.headers._
+import akka.parboiled2.ParserInput.DefaultParserInput
+import akka.util.{ ByteString, OptionVal }
+
+import scala.annotation.tailrec
+import scala.collection.immutable
 
 /**
  * The model of an HTTP header. In its most basic form headers are simple name-value pairs. Header names
@@ -80,6 +85,16 @@ object HttpHeader {
       }
     } else ParsingResult.Error(ErrorInfo(s"Illegal HTTP header name", name))
 
+  /** INTERNAL API */
+  private[akka] def fastFind[T >: Null <: jm.HttpHeader](clazz: Class[T], headers: immutable.Seq[HttpHeader]): OptionVal[T] = {
+    val it = headers.iterator
+    while (it.hasNext) it.next() match {
+      case h if clazz.isInstance(h) ⇒ return OptionVal.Some[T](h.asInstanceOf[T])
+      case _                        ⇒ // continue ...
+    }
+    OptionVal.None.asInstanceOf[OptionVal[T]]
+  }
+
   sealed trait ParsingResult {
     def errors: List[ErrorInfo]
   }
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMessage.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMessage.scala
index 9cf985f448..7805ac204f 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMessage.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMessage.scala
@@ -19,13 +19,11 @@ import scala.reflect.{ ClassTag, classTag }
 import akka.Done
 import akka.parboiled2.CharUtils
 import akka.stream.Materializer
-import akka.util.{ ByteString, HashCode }
+import akka.util.{ ByteString, HashCode, OptionVal }
 import akka.http.impl.util._
 import akka.http.javadsl.{ model ⇒ jm }
 import akka.http.scaladsl.util.FastFuture._
-import akka.stream.scaladsl.Sink
 import headers._
-import akka.http.impl.util.JavaMapping.Implicits._
 
 /**
  * Common base class of HttpRequest and HttpResponse.
@@ -41,9 +39,23 @@ sealed trait HttpMessage extends jm.HttpMessage {
   def entity: ResponseEntity
   def protocol: HttpProtocol
 
-  /** Drains entity stream */
-  def discardEntityBytes(mat: Materializer): HttpMessage.DiscardedEntity =
-    new HttpMessage.DiscardedEntity(entity.dataBytes.runWith(Sink.ignore)(mat))
+  /**
+   * Discards the entities data bytes by running the `dataBytes` Source contained in this HttpMessage.
+   *
+   * Note: It is crucial that entities are either discarded, or consumed by running the underlying [[akka.stream.scaladsl.Source]]
+   * as otherwise the lack of consuming of the data will trigger back-pressure to the underlying TCP connection
+   * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of
+   * just having ignored the data.
+   *
+   * Warning: It is not allowed to discard and/or consume the `entity.dataBytes` more than once
+   * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
+   * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
+   * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
+   * "stream can cannot be materialized more than once" exception.
+   *
+   * In future versions, more automatic ways to warn or resolve these situations may be introduced, see issue #18716.
+   */
+  def discardEntityBytes(mat: Materializer): HttpMessage.DiscardedEntity = entity.discardBytes()(mat)
 
   /** Returns a copy of this message with the list of headers set to the given ones. */
   def withHeaders(headers: HttpHeader*): Self = withHeaders(headers.toList)
@@ -90,14 +102,13 @@ sealed trait HttpMessage extends jm.HttpMessage {
   }
 
   /** Returns the first header of the given type if there is one */
-  def header[T <: jm.HttpHeader: ClassTag]: Option[T] = {
-    val erasure = classTag[T].runtimeClass
-    headers.find(erasure.isInstance).asInstanceOf[Option[T]] match {
-      case header: Some[T]                         ⇒ header
-      case _ if erasure == classOf[`Content-Type`] ⇒ Some(entity.contentType).asInstanceOf[Option[T]]
-      case _                                       ⇒ None
+  def header[T >: Null <: jm.HttpHeader: ClassTag]: Option[T] = {
+    val clazz = classTag[T].runtimeClass.asInstanceOf[Class[T]]
+    HttpHeader.fastFind[T](clazz, headers) match {
+      case OptionVal.Some(h)                     ⇒ Some(h)
+      case _ if clazz == classOf[`Content-Type`] ⇒ Some(`Content-Type`(entity.contentType)).asInstanceOf[Option[T]]
+      case _                                     ⇒ None
     }
-
   }
 
   /**
@@ -133,7 +144,11 @@ sealed trait HttpMessage extends jm.HttpMessage {
   /** Java API */
   def getHeaders: JIterable[jm.HttpHeader] = (headers: immutable.Seq[jm.HttpHeader]).asJava
   /** Java API */
-  def getHeader[T <: jm.HttpHeader](headerClass: Class[T]): Optional[T] = header(ClassTag(headerClass)).asJava
+  def getHeader[T <: jm.HttpHeader](headerClass: Class[T]): Optional[T] =
+    HttpHeader.fastFind[jm.HttpHeader](headerClass.asInstanceOf[Class[jm.HttpHeader]], headers) match {
+      case OptionVal.Some(h) ⇒ Optional.of(h.asInstanceOf[T])
+      case _                 ⇒ Optional.empty()
+    }
   /** Java API */
   def getHeader(headerName: String): Optional[jm.HttpHeader] = {
     val lowerCased = headerName.toRootLowerCase
@@ -151,7 +166,7 @@ object HttpMessage {
     }
 
   /**
-   * Represents the the currently being-drained HTTP Entity which triggers completion of the contained
+   * Represents the currently being-drained HTTP Entity which triggers completion of the contained
    * Future once the entity has been drained for the given HttpMessage completely.
    */
   final class DiscardedEntity(f: Future[Done]) extends akka.http.javadsl.model.HttpMessage.DiscardedEntity {
@@ -178,7 +193,7 @@ object HttpMessage {
      * (as designed), however possibly leading to an idle-timeout that will close the connection, instead of
      * just having ignored the data.
      *
-     * Warning: It is not allowed to discard and/or consume the the `entity.dataBytes` more than once
+     * Warning: It is not allowed to discard and/or consume the `entity.dataBytes` more than once
      * as the stream is directly attached to the "live" incoming data source from the underlying TCP connection.
      * Allowing it to be consumable twice would require buffering the incoming data, thus defeating the purpose
      * of its streaming nature. If the dataBytes source is materialized a second time, it will fail with an
@@ -310,14 +325,22 @@ object HttpRequest {
    * include a valid [[akka.http.scaladsl.model.headers.Host]] header or if URI authority and [[akka.http.scaladsl.model.headers.Host]] header don't match.
    */
   def effectiveUri(uri: Uri, headers: immutable.Seq[HttpHeader], securedConnection: Boolean, defaultHostHeader: Host): Uri = {
-    val hostHeader = headers.collectFirst { case x: Host ⇒ x }
+    def findHost(headers: immutable.Seq[HttpHeader]): OptionVal[Host] = {
+      val it = headers.iterator
+      while (it.hasNext) it.next() match {
+        case h: Host ⇒ return OptionVal.Some(h)
+        case _       ⇒ // continue ...
+      }
+      OptionVal.None
+    }
+    val hostHeader: OptionVal[Host] = findHost(headers)
     if (uri.isRelative) {
       def fail(detail: String) =
         throw IllegalUriException(s"Cannot establish effective URI of request to `$uri`, request has a relative URI and $detail")
       val Host(host, port) = hostHeader match {
-        case None                 ⇒ if (defaultHostHeader.isEmpty) fail("is missing a `Host` header") else defaultHostHeader
-        case Some(x) if x.isEmpty ⇒ if (defaultHostHeader.isEmpty) fail("an empty `Host` header") else defaultHostHeader
-        case Some(x)              ⇒ x
+        case OptionVal.None                 ⇒ if (defaultHostHeader.isEmpty) fail("is missing a `Host` header") else defaultHostHeader
+        case OptionVal.Some(x) if x.isEmpty ⇒ if (defaultHostHeader.isEmpty) fail("an empty `Host` header") else defaultHostHeader
+        case OptionVal.Some(x)              ⇒ x
       }
       uri.toEffectiveHttpRequestUri(host, port, securedConnection)
     } else // http://tools.ietf.org/html/rfc7230#section-5.4
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMethod.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMethod.scala
index 7ee304c81f..820678bc09 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMethod.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMethod.scala
@@ -8,7 +8,7 @@ import akka.http.impl.util._
 import akka.http.javadsl.{ model ⇒ jm }
 import akka.http.scaladsl.model.RequestEntityAcceptance._
 
-sealed trait RequestEntityAcceptance {
+sealed trait RequestEntityAcceptance extends jm.RequestEntityAcceptance {
   def isEntityAccepted: Boolean
 }
 object RequestEntityAcceptance {
@@ -36,6 +36,7 @@ final case class HttpMethod private[http] (
   requestEntityAcceptance: RequestEntityAcceptance) extends jm.HttpMethod with SingletonValueRenderable {
   override def isEntityAccepted: Boolean = requestEntityAcceptance.isEntityAccepted
   override def toString: String = s"HttpMethod($value)"
+  override def getRequestEntityAcceptance: jm.RequestEntityAcceptance = requestEntityAcceptance
 }
 
 object HttpMethod {
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpChallenge.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpChallenge.scala
index 633d0d221f..f4692f1339 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpChallenge.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpChallenge.scala
@@ -13,7 +13,8 @@ final case class HttpChallenge(scheme: String, realm: String,
                                params: Map[String, String] = Map.empty) extends jm.headers.HttpChallenge with ValueRenderable {
 
   def render[R <: Rendering](r: R): r.type = {
-    r ~~ scheme ~~ " realm=" ~~#! realm
+    r ~~ scheme
+    if (realm != null) r ~~ " realm=" ~~#! realm
     if (params.nonEmpty) params.foreach { case (k, v) ⇒ r ~~ ',' ~~ k ~~ '=' ~~# v }
     r
   }
@@ -22,6 +23,16 @@ final case class HttpChallenge(scheme: String, realm: String,
   def getParams: util.Map[String, String] = params.asJava
 }
 
+// FIXME: AbstractFunction3 required for bin compat. remove in Akka 3.0 and change realm in case class to option #20786
+object HttpChallenge extends scala.runtime.AbstractFunction3[String, String, Map[String, String], HttpChallenge] {
+
+  def apply(scheme: String, realm: Option[String]): HttpChallenge =
+    HttpChallenge(scheme, realm.orNull, Map.empty[String, String])
+
+  def apply(scheme: String, realm: Option[String], params: Map[String, String]): HttpChallenge =
+    HttpChallenge(scheme, realm.orNull, params)
+}
+
 object HttpChallenges {
 
   def basic(realm: String): HttpChallenge = HttpChallenge("Basic", realm)
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpOrigin.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpOrigin.scala
index 27545e3848..bd32d48471 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpOrigin.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpOrigin.scala
@@ -5,7 +5,6 @@
 package akka.http.scaladsl.model.headers
 
 import akka.http.impl.model.JavaInitialization
-import akka.util.Unsafe
 
 import language.implicitConversions
 import scala.collection.immutable
@@ -22,6 +21,7 @@ abstract class HttpOriginRange extends jm.headers.HttpOriginRange with ValueRend
   /** Java API */
   def matches(origin: jm.headers.HttpOrigin): Boolean = matches(origin.asScala)
 }
+
 object HttpOriginRange {
   case object `*` extends HttpOriginRange {
     def matches(origin: HttpOrigin) = true
@@ -43,6 +43,7 @@ object HttpOriginRange {
 final case class HttpOrigin(scheme: String, host: Host) extends jm.headers.HttpOrigin with ValueRenderable {
   def render[R <: Rendering](r: R): r.type = host.renderValue(r ~~ scheme ~~ "://")
 }
+
 object HttpOrigin {
   implicit val originsRenderer: Renderer[immutable.Seq[HttpOrigin]] = Renderer.seqRenderer(" ", "null")
 
@@ -50,4 +51,4 @@ object HttpOrigin {
     val parser = new UriParser(str, UTF8, Uri.ParsingMode.Relaxed)
     parser.parseOrigin()
   }
-}
\ No newline at end of file
+}
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/headers.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/headers.scala
index bf13d2a98e..917243c58c 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/headers.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/headers.scala
@@ -16,12 +16,13 @@ import scala.util.{ Failure, Success, Try }
 import scala.annotation.tailrec
 import scala.collection.immutable
 import akka.parboiled2.util.Base64
+import akka.event.Logging
 import akka.http.impl.util._
 import akka.http.javadsl.{ model ⇒ jm }
 import akka.http.scaladsl.model._
 
 sealed abstract class ModeledCompanion[T: ClassTag] extends Renderable {
-  val name = getClass.getSimpleName.replace("$minus", "-").dropRight(1) // trailing $
+  val name = ModeledCompanion.nameFromClass(getClass)
   val lowercaseName = name.toRootLowerCase
   private[this] val nameBytes = name.asciiBytes
   final def render[R <: Rendering](r: R): r.type = r ~~ nameBytes ~~ ':' ~~ ' '
@@ -36,6 +37,20 @@ sealed abstract class ModeledCompanion[T: ClassTag] extends Renderable {
       case res                                         ⇒ Left(res.errors)
     }
 }
+/** INTERNAL API */
+private[akka] object ModeledCompanion {
+  def nameFromClass[T](clazz: Class[T]): String = {
+    val name = {
+      val n = Logging.simpleName(clazz).replace("$minus", "-")
+      if (n.last == '$') n.dropRight(1) // drop trailing $
+      else n
+    }
+
+    val dollarIndex = name.indexOf('$')
+    if (dollarIndex != -1) name.drop(dollarIndex + 1)
+    else name
+  }
+}
 
 sealed trait ModeledHeader extends HttpHeader with Serializable {
   def renderInRequests: Boolean = false // default implementation
@@ -362,7 +377,8 @@ object `Content-Length` extends ModeledCompanion[`Content-Length`]
  * Instances of this class will only be created transiently during header parsing and will never appear
  * in HttpMessage.header. To access the Content-Length, see subclasses of HttpEntity.
  */
-final case class `Content-Length` private[http] (length: Long) extends RequestResponseHeader {
+final case class `Content-Length` private[http] (length: Long) extends jm.headers.ContentLength
+  with RequestResponseHeader {
   def renderValue[R <: Rendering](r: R): r.type = r ~~ length
   protected def companion = `Content-Length`
 }
diff --git a/akka-http-core/src/main/scala/akka/http/scaladsl/settings/ParserSettings.scala b/akka-http-core/src/main/scala/akka/http/scaladsl/settings/ParserSettings.scala
index fa4ae90d73..97dd767d49 100644
--- a/akka-http-core/src/main/scala/akka/http/scaladsl/settings/ParserSettings.scala
+++ b/akka-http-core/src/main/scala/akka/http/scaladsl/settings/ParserSettings.scala
@@ -34,6 +34,7 @@ abstract class ParserSettings private[akka] () extends akka.http.javadsl.setting
   def cookieParsingMode: ParserSettings.CookieParsingMode
   def illegalHeaderWarnings: Boolean
   def errorLoggingVerbosity: ParserSettings.ErrorLoggingVerbosity
+  def illegalResponseHeaderValueProcessingMode: ParserSettings.IllegalResponseHeaderValueProcessingMode
   def headerValueCacheLimits: Map[String, Int]
   def includeTlsSessionInfoHeader: Boolean
   def customMethods: String ⇒ Option[HttpMethod]
@@ -56,6 +57,7 @@ abstract class ParserSettings private[akka] () extends akka.http.javadsl.setting
   override def getMaxUriLength = maxUriLength
   override def getMaxMethodLength = maxMethodLength
   override def getErrorLoggingVerbosity: js.ParserSettings.ErrorLoggingVerbosity = errorLoggingVerbosity
+  override def getIllegalResponseHeaderValueProcessingMode = illegalResponseHeaderValueProcessingMode
 
   override def getCustomMethods = new Function[String, Optional[akka.http.javadsl.model.HttpMethod]] {
     override def apply(t: String) = OptionConverters.toJava(customMethods(t))
@@ -100,10 +102,12 @@ abstract class ParserSettings private[akka] () extends akka.http.javadsl.setting
     val map = types.map(c ⇒ (c.mainType, c.subType) → c).toMap
     self.copy(customMediaTypes = (main, sub) ⇒ map.get((main, sub)))
   }
+  def withIllegalResponseHeaderValueProcessingMode(newValue: ParserSettings.IllegalResponseHeaderValueProcessingMode): ParserSettings =
+    self.copy(illegalResponseHeaderValueProcessingMode = newValue)
 }
 
 object ParserSettings extends SettingsCompanion[ParserSettings] {
-  trait CookieParsingMode extends akka.http.javadsl.settings.ParserSettings.CookieParsingMode
+  sealed trait CookieParsingMode extends akka.http.javadsl.settings.ParserSettings.CookieParsingMode
   object CookieParsingMode {
     case object RFC6265 extends CookieParsingMode
     case object Raw extends CookieParsingMode
@@ -114,7 +118,7 @@ object ParserSettings extends SettingsCompanion[ParserSettings] {
     }
   }
 
-  trait ErrorLoggingVerbosity extends akka.http.javadsl.settings.ParserSettings.ErrorLoggingVerbosity
+  sealed trait ErrorLoggingVerbosity extends akka.http.javadsl.settings.ParserSettings.ErrorLoggingVerbosity
   object ErrorLoggingVerbosity {
     case object Off extends ErrorLoggingVerbosity
     case object Simple extends ErrorLoggingVerbosity
@@ -129,6 +133,21 @@ object ParserSettings extends SettingsCompanion[ParserSettings] {
       }
   }
 
+  sealed trait IllegalResponseHeaderValueProcessingMode extends akka.http.javadsl.settings.ParserSettings.IllegalResponseHeaderValueProcessingMode
+  object IllegalResponseHeaderValueProcessingMode {
+    case object Error extends IllegalResponseHeaderValueProcessingMode
+    case object Warn extends IllegalResponseHeaderValueProcessingMode
+    case object Ignore extends IllegalResponseHeaderValueProcessingMode
+
+    def apply(string: String): IllegalResponseHeaderValueProcessingMode =
+      string.toRootLowerCase match {
+        case "error"  ⇒ Error
+        case "warn"   ⇒ Warn
+        case "ignore" ⇒ Ignore
+        case x        ⇒ throw new IllegalArgumentException(s"[$x] is not a legal `illegal-response-header-value-processing-mode` setting")
+      }
+  }
+
   override def apply(config: Config): ParserSettings = ParserSettingsImpl(config)
   override def apply(configOverrides: String): ParserSettings = ParserSettingsImpl(configOverrides)
 }
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/HighLevelOutgoingConnectionSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/HighLevelOutgoingConnectionSpec.scala
index 4e37f69027..da2ad966f9 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/client/HighLevelOutgoingConnectionSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/client/HighLevelOutgoingConnectionSpec.scala
@@ -16,7 +16,7 @@ import akka.testkit.AkkaSpec
 import akka.http.scaladsl.{ Http, TestUtils }
 import akka.http.scaladsl.model._
 import akka.stream.testkit.Utils
-import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.concurrent.PatienceConfiguration.Timeout
 
 class HighLevelOutgoingConnectionSpec extends AkkaSpec {
   implicit val materializer = ActorMaterializer(ActorMaterializerSettings(system).withFuzzing(true))
@@ -38,8 +38,7 @@ class HighLevelOutgoingConnectionSpec extends AkkaSpec {
         .mapAsync(4)(_.entity.toStrict(1.second))
         .map { r ⇒ val s = r.data.utf8String; log.debug(s); s.toInt }
         .runFold(0)(_ + _)
-
-      result.futureValue(PatienceConfig(10.seconds)) shouldEqual N * (N + 1) / 2
+      result.futureValue(Timeout(10.seconds)) should ===(N * (N + 1) / 2)
       binding.futureValue.unbind()
     }
 
@@ -73,7 +72,7 @@ class HighLevelOutgoingConnectionSpec extends AkkaSpec {
         .map { r ⇒ val s = r.data.utf8String; log.debug(s); s.toInt }
         .runFold(0)(_ + _)
 
-      result.futureValue(PatienceConfig(10.seconds)) shouldEqual C * N * (N + 1) / 2
+      result.futureValue(Timeout(10.seconds)) should ===(C * N * (N + 1) / 2)
       binding.futureValue.unbind()
     }
 
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/client/LowLevelOutgoingConnectionSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/client/LowLevelOutgoingConnectionSpec.scala
index e2cea50f60..14a359351d 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/client/LowLevelOutgoingConnectionSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/client/LowLevelOutgoingConnectionSpec.scala
@@ -4,6 +4,8 @@
 
 package akka.http.impl.engine.client
 
+import com.typesafe.config.ConfigFactory
+
 import scala.concurrent.duration._
 import scala.reflect.ClassTag
 import org.scalatest.Inside
@@ -326,6 +328,65 @@ class LowLevelOutgoingConnectionSpec extends AkkaSpec("akka.loggers = []\n akka.
       }
     }
 
+    "process the illegal response header value properly" which {
+
+      val illegalChar = '\u0001'
+      val escapeChar = "\\u%04x" format illegalChar.toInt
+
+      "catch illegal response header value by default" in new TestSetup {
+        sendStandardRequest()
+        sendWireData(
+          s"""HTTP/1.1 200 OK
+              |Some-Header: value1$illegalChar
+              |Other-Header: value2
+              |
+              |""")
+
+        responsesSub.request(1)
+        val error @ IllegalResponseException(info) = responses.expectError()
+        info.summary shouldEqual s"""Illegal character '$escapeChar' in header value"""
+        netOut.expectError(error)
+        requestsSub.expectCancellation()
+        netInSub.expectCancellation()
+      }
+
+      val ignoreConfig =
+        """
+          akka.http.parsing.illegal-response-header-value-processing-mode = ignore
+        """
+      "ignore illegal response header value if setting the config to ignore" in new TestSetup(config = ignoreConfig) {
+        sendStandardRequest()
+        sendWireData(
+          s"""HTTP/1.1 200 OK
+              |Some-Header: value1$illegalChar
+              |Other-Header: value2
+              |
+              |""")
+
+        val HttpResponse(_, headers, _, _) = expectResponse()
+        val headerStr = headers.map(h ⇒ s"${h.name}: ${h.value}").mkString(",")
+        headerStr shouldEqual "Some-Header: value1,Other-Header: value2"
+      }
+
+      val warnConfig =
+        """
+          akka.http.parsing.illegal-response-header-value-processing-mode = warn
+        """
+      "ignore illegal response header value and log a warning message if setting the config to warn" in new TestSetup(config = warnConfig) {
+        sendStandardRequest()
+        sendWireData(
+          s"""HTTP/1.1 200 OK
+              |Some-Header: value1$illegalChar
+              |Other-Header: value2
+              |
+              |""")
+
+        val HttpResponse(_, headers, _, _) = expectResponse()
+        val headerStr = headers.map(h ⇒ s"${h.name}: ${h.value}").mkString(",")
+        headerStr shouldEqual "Some-Header: value1,Other-Header: value2"
+      }
+    }
+
     "produce proper errors" which {
 
       "catch the request entity stream being shorter than the Content-Length" in new TestSetup {
@@ -808,13 +869,14 @@ class LowLevelOutgoingConnectionSpec extends AkkaSpec("akka.loggers = []\n akka.
     }
   }
 
-  class TestSetup(maxResponseContentLength: Int = -1) {
+  class TestSetup(maxResponseContentLength: Int = -1, config: String = "") {
     val requests = TestPublisher.manualProbe[HttpRequest]()
     val responses = TestSubscriber.manualProbe[HttpResponse]()
 
     def settings = {
-      val s = ClientConnectionSettings(system)
-        .withUserAgentHeader(Some(`User-Agent`(List(ProductVersion("akka-http", "test")))))
+      val s = ClientConnectionSettings(
+        ConfigFactory.parseString(config).withFallback(system.settings.config)
+      ).withUserAgentHeader(Some(`User-Agent`(List(ProductVersion("akka-http", "test")))))
       if (maxResponseContentLength < 0) s
       else s.withParserSettings(s.parserSettings.withMaxContentLength(maxResponseContentLength))
     }
@@ -873,5 +935,6 @@ class LowLevelOutgoingConnectionSpec extends AkkaSpec("akka.loggers = []\n akka.
       responsesSub.request(1)
       responses.expectNext()
     }
+
   }
 }
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserSpec.scala
index 4282538f0b..c632c74f3c 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserSpec.scala
@@ -246,6 +246,7 @@ class HttpHeaderParserSpec extends WordSpec with Matchers with BeforeAndAfterAll
     val parser = {
       val p = HttpHeaderParser.unprimed(
         settings = ParserSettings(system),
+        system.log,
         warnOnIllegalHeader = info ⇒ system.log.warning(info.formatPretty))
       if (primed) HttpHeaderParser.prime(p) else p
     }
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserTestBed.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserTestBed.scala
index b8dcb95b9a..89c554d2fb 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserTestBed.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/HttpHeaderParserTestBed.scala
@@ -15,7 +15,7 @@ object HttpHeaderParserTestBed extends App {
   val system = ActorSystem("HttpHeaderParserTestBed", testConf)
 
   val parser = HttpHeaderParser.prime {
-    HttpHeaderParser.unprimed(ParserSettings(system), warnOnIllegalHeader = info ⇒ system.log.warning(info.formatPretty))
+    HttpHeaderParser.unprimed(ParserSettings(system), system.log, warnOnIllegalHeader = info ⇒ system.log.warning(info.formatPretty))
   }
 
   println {
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/RequestParserSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/RequestParserSpec.scala
index 17dc6ae6bc..5dfe4a6ace 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/RequestParserSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/RequestParserSpec.scala
@@ -42,7 +42,7 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
     akka.event-handlers = ["akka.testkit.TestEventListener"]
     akka.loglevel = WARNING
     akka.http.parsing.max-header-value-length = 32
-    akka.http.parsing.max-uri-length = 20
+    akka.http.parsing.max-uri-length = 40
     akka.http.parsing.max-content-length = 4000000000""")
   implicit val system = ActorSystem(getClass.getSimpleName, testConf)
   import system.dispatcher
@@ -79,6 +79,14 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
         closeAfterResponseCompletion shouldEqual Seq(false)
       }
 
+      "with absolute uri in request-target" in new Test {
+        """GET http://127.0.0.1:8080/hello HTTP/1.1
+          |Host: 127.0.0.1:8080
+          |
+          |""" should parseTo(HttpRequest(uri = "http://127.0.0.1:8080/hello", headers = List(Host("127.0.0.1", 8080))))
+        closeAfterResponseCompletion shouldEqual Seq(false)
+      }
+
       "with 3 headers and a body" in new Test {
         """POST /resource/yes HTTP/1.0
           |User-Agent: curl/7.19.7 xyz
@@ -300,7 +308,7 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
 
     "support `rawRequestUriHeader` setting" in new Test {
       override protected def newParser: HttpRequestParser =
-        new HttpRequestParser(parserSettings, rawRequestUriHeader = true, _headerParser = HttpHeaderParser(parserSettings)())
+        new HttpRequestParser(parserSettings, rawRequestUriHeader = true, headerParser = HttpHeaderParser(parserSettings, system.log)())
 
       """GET /f%6f%6fbar?q=b%61z HTTP/1.1
         |Host: ping
@@ -408,9 +416,9 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
       }
 
       "a too-long URI" in new Test {
-        "GET /23456789012345678901 HTTP/1.1" should parseToError(
+        "GET /2345678901234567890123456789012345678901 HTTP/1.1" should parseToError(
           RequestUriTooLong,
-          ErrorInfo("URI length exceeds the configured limit of 20 characters"))
+          ErrorInfo("URI length exceeds the configured limit of 40 characters"))
       }
 
       "HTTP version 1.2" in new Test {
@@ -557,7 +565,7 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
     def multiParse(parser: HttpRequestParser)(input: Seq[String]): Seq[Either[RequestOutput, StrictEqualHttpRequest]] =
       Source(input.toList)
         .map(bytes ⇒ SessionBytes(TLSPlacebo.dummySession, ByteString(bytes)))
-        .via(parser.stage).named("parser")
+        .via(parser).named("parser")
         .splitWhen(x ⇒ x.isInstanceOf[MessageStart] || x.isInstanceOf[EntityStreamError])
         .prefixAndTail(1)
         .collect {
@@ -582,7 +590,7 @@ class RequestParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
         .awaitResult(awaitAtMost)
 
     protected def parserSettings: ParserSettings = ParserSettings(system)
-    protected def newParser = new HttpRequestParser(parserSettings, false, HttpHeaderParser(parserSettings)())
+    protected def newParser = new HttpRequestParser(parserSettings, false, HttpHeaderParser(parserSettings, system.log)())
 
     private def compactEntity(entity: RequestEntity): Future[RequestEntity] =
       entity match {
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/ResponseParserSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/ResponseParserSpec.scala
index 5ad34b5d38..470d03c3e4 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/ResponseParserSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/parsing/ResponseParserSpec.scala
@@ -320,7 +320,7 @@ class ResponseParserSpec extends FreeSpec with Matchers with BeforeAndAfterAll {
     protected def parserSettings: ParserSettings = ParserSettings(system)
 
     def newParserStage(requestMethod: HttpMethod = GET) = {
-      val parser = new HttpResponseParser(parserSettings, HttpHeaderParser(parserSettings)())
+      val parser = new HttpResponseParser(parserSettings, HttpHeaderParser(parserSettings, system.log)())
       parser.setContextForNextResponse(HttpResponseParser.ResponseContext(requestMethod, None))
       parser.stage
     }
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerBug2108Spec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerBug2108Spec.scala
new file mode 100644
index 0000000000..9428ae00f7
--- /dev/null
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerBug2108Spec.scala
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http.impl.engine.server
+
+import akka.http.scaladsl.model.HttpEntity.Chunked
+import akka.http.scaladsl.model.HttpMethods._
+import akka.http.scaladsl.model.{ ContentType, HttpRequest, HttpResponse }
+import akka.http.scaladsl.model.MediaTypes._
+import akka.stream.{ ActorMaterializer, Materializer }
+import akka.stream.testkit.Utils.{ TE, _ }
+import akka.testkit.{ AkkaSpec, EventFilter }
+import org.scalatest.Inside
+
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+class HttpServerBug2108Spec extends AkkaSpec(
+  """
+   akka.loglevel = WARNING
+   akka.loggers = ["akka.testkit.TestEventListener", "akka.event.Logging$DefaultLogger"]
+   akka.http.server.request-timeout = infinite
+   akka.test.filter-leeway=300ms""") with Inside { spec ⇒
+  implicit val materializer = ActorMaterializer()
+
+  "The HttpServer" should {
+
+    "not cause internal graph failures when consuming a `100 Continue` entity triggers a failure" in assertAllStagesStopped(new HttpServerTestSetupBase {
+      override implicit def system = HttpServerBug2108Spec.this.system
+      override implicit def materializer: Materializer = HttpServerBug2108Spec.this.materializer
+
+      send("""POST / HTTP/1.1
+             |Host: example.com
+             |Expect: 100-continue
+             |Transfer-Encoding: chunked
+             |
+             |""")
+      inside(expectRequest()) {
+        case HttpRequest(POST, _, _, Chunked(ContentType(`application/octet-stream`, None), data), _) ⇒
+          val done = data.runForeach(_ ⇒ throw TE("failed on first chunk"))
+
+          expectResponseWithWipedDate(
+            """HTTP/1.1 100 Continue
+              |Server: akka-http/test
+              |Date: XXXX
+              |
+              |""")
+          send("""10
+                 |0123456789ABCDEF
+                 |0
+                 |
+                 |""")
+
+          // Bug #21008 does not actually ever make the request fail instead it logs the exception and behaves
+          // nicely so we need to check that the exception didn't get logged
+          var sawException = false
+          try {
+            EventFilter[IllegalArgumentException](occurrences = 1) intercept {
+              // make sure the failure has happened
+              Await.ready(done, 10.seconds)
+              // and then when the failure has happened/future completes, we push a reply
+              responses.sendNext(HttpResponse(entity = "Yeah"))
+
+            }
+            // got such an error, that is bad,
+            sawException = true
+          } catch {
+            case _: AssertionError ⇒ sawException = false
+          }
+          if (sawException) fail("HttpServerBluePrint.ControllerStage: requirement failed: Cannot pull closed port (requestParsingIn)")
+
+          // and the client should still get that ok
+          expectResponseWithWipedDate(
+            """HTTP/1.1 200 OK
+              |Server: akka-http/test
+              |Date: XXXX
+              |Connection: close
+              |Content-Type: text/plain; charset=UTF-8
+              |Content-Length: 4
+              |
+              |Yeah""")
+
+      }
+
+      netIn.sendComplete()
+      netOut.expectComplete()
+
+    })
+
+  }
+}
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerSpec.scala
index 8a09968155..b83f6be39e 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerSpec.scala
@@ -5,25 +5,27 @@
 package akka.http.impl.engine.server
 
 import java.net.{ InetAddress, InetSocketAddress }
+
+import akka.http.impl.util._
+import akka.http.scaladsl.Http.ServerLayer
+import akka.http.scaladsl.model.HttpEntity._
+import akka.http.scaladsl.model.HttpMethods._
+import akka.http.scaladsl.model.MediaTypes._
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.headers._
 import akka.http.scaladsl.settings.ServerSettings
-import scala.reflect.ClassTag
-import scala.util.Random
+import akka.stream.scaladsl._
+import akka.stream.testkit.Utils.assertAllStagesStopped
+import akka.stream.testkit._
+import akka.stream.{ ActorMaterializer, Fusing }
+import akka.testkit.AkkaSpec
+import akka.util.ByteString
+import org.scalatest.Inside
+
 import scala.annotation.tailrec
 import scala.concurrent.duration._
-import org.scalatest.Inside
-import org.scalatest.concurrent.ScalaFutures
-import akka.util.ByteString
-import akka.stream.scaladsl._
-import akka.stream.ActorMaterializer
-import akka.stream.testkit._
-import akka.http.scaladsl.model._
-import akka.http.impl.util._
-import headers._
-import HttpEntity._
-import MediaTypes._
-import HttpMethods._
-import Utils.assertAllStagesStopped
-import akka.testkit.AkkaSpec
+import scala.reflect.ClassTag
+import scala.util.Random
 
 class HttpServerSpec extends AkkaSpec(
   """akka.loggers = []
@@ -813,6 +815,32 @@ class HttpServerSpec extends AkkaSpec(
       shutdownBlueprint()
     })
 
+    "support remote-address-header when blueprint not constructed with it" in assertAllStagesStopped(new TestSetup {
+      // coverage for #21130
+      lazy val theAddress = InetAddress.getByName("127.5.2.1")
+
+      override def settings: ServerSettings =
+        super.settings.withRemoteAddressHeader(true)
+
+      // this is the normal behavior for bindAndHandle(flow), it will set an attribute
+      // with remote ip before flow is materialized, rather than from the blueprint apply method
+      override def modifyServer(server: ServerLayer): ServerLayer = {
+        BidiFlow.fromGraph(Fusing.aggressive(server).withAttributes(
+          HttpAttributes.remoteAddress(Some(new InetSocketAddress(theAddress, 8080)))
+        ))
+      }
+
+      send("""GET / HTTP/1.1
+             |Host: example.com
+             |
+             |""".stripMarginWithNewline("\r\n"))
+
+      val request = expectRequest()
+      request.headers should contain(`Remote-Address`(RemoteAddress(theAddress, Some(8080))))
+
+      shutdownBlueprint()
+    })
+
     "support request timeouts" which {
 
       "are defined via the config" in assertAllStagesStopped(new RequestTimeoutTestSetup(10.millis) {
@@ -832,10 +860,10 @@ class HttpServerSpec extends AkkaSpec(
         netOut.expectComplete()
       })
 
-      "are programmatically increased (not expiring)" in assertAllStagesStopped(new RequestTimeoutTestSetup(10.millis) {
+      "are programmatically increased (not expiring)" in assertAllStagesStopped(new RequestTimeoutTestSetup(50.millis) {
         send("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
-        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(50.millis))
-        netOut.expectNoBytes(30.millis)
+        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(250.millis))
+        netOut.expectNoBytes(150.millis)
         responses.sendNext(HttpResponse())
         expectResponseWithWipedDate(
           """HTTP/1.1 200 OK
@@ -849,10 +877,10 @@ class HttpServerSpec extends AkkaSpec(
         netOut.expectComplete()
       })
 
-      "are programmatically increased (expiring)" in assertAllStagesStopped(new RequestTimeoutTestSetup(10.millis) {
+      "are programmatically increased (expiring)" in assertAllStagesStopped(new RequestTimeoutTestSetup(50.millis) {
         send("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
-        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(50.millis))
-        netOut.expectNoBytes(30.millis)
+        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(250.millis))
+        netOut.expectNoBytes(150.millis)
         expectResponseWithWipedDate(
           """HTTP/1.1 503 Service Unavailable
             |Server: akka-http/test
@@ -867,9 +895,9 @@ class HttpServerSpec extends AkkaSpec(
         netOut.expectComplete()
       })
 
-      "are programmatically decreased" in assertAllStagesStopped(new RequestTimeoutTestSetup(50.millis) {
+      "are programmatically decreased" in assertAllStagesStopped(new RequestTimeoutTestSetup(250.millis) {
         send("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
-        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(10.millis))
+        expectRequest().header[`Timeout-Access`].foreach(_.timeoutAccess.updateTimeout(50.millis))
         val mark = System.nanoTime()
         expectResponseWithWipedDate(
           """HTTP/1.1 503 Service Unavailable
@@ -880,7 +908,7 @@ class HttpServerSpec extends AkkaSpec(
             |
             |The server was not able to produce a timely response to your request.
             |Please try again in a short while!""")
-        (System.nanoTime() - mark) should be < (40 * 1000000L)
+        (System.nanoTime() - mark) should be < (200 * 1000000L)
 
         netIn.sendComplete()
         netOut.expectComplete()
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerTestSetupBase.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerTestSetupBase.scala
index 8758a9e2ab..0a01e3a281 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerTestSetupBase.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/server/HttpServerTestSetupBase.scala
@@ -5,9 +5,11 @@
 package akka.http.impl.engine.server
 
 import java.net.InetSocketAddress
+
 import akka.http.impl.engine.ws.ByteStringSinkProbe
 import akka.http.scaladsl.settings.ServerSettings
 import akka.stream.TLSProtocol._
+
 import scala.concurrent.duration.FiniteDuration
 import akka.actor.ActorSystem
 import akka.event.NoLogging
@@ -16,8 +18,9 @@ import akka.stream._
 import akka.stream.scaladsl._
 import akka.stream.testkit.{ TestPublisher, TestSubscriber }
 import akka.http.impl.util._
+import akka.http.scaladsl.Http
 import akka.http.scaladsl.model.headers.{ ProductVersion, Server }
-import akka.http.scaladsl.model.{ HttpResponse, HttpRequest }
+import akka.http.scaladsl.model.{ HttpRequest, HttpResponse }
 
 abstract class HttpServerTestSetupBase {
   implicit def system: ActorSystem
@@ -30,11 +33,14 @@ abstract class HttpServerTestSetupBase {
     .withServerHeader(Some(Server(List(ProductVersion("akka-http", "test")))))
   def remoteAddress: Option[InetSocketAddress] = None
 
+  // hook to modify server, for example add attributes
+  def modifyServer(server: Http.ServerLayer): Http.ServerLayer = server
+
   val (netIn, netOut) = {
     val netIn = TestPublisher.probe[ByteString]()
     val netOut = ByteStringSinkProbe()
 
-    RunnableGraph.fromGraph(GraphDSL.create(HttpServerBluePrint(settings, remoteAddress = remoteAddress, log = NoLogging)) { implicit b ⇒ server ⇒
+    RunnableGraph.fromGraph(GraphDSL.create(modifyServer(HttpServerBluePrint(settings, remoteAddress = remoteAddress, log = NoLogging))) { implicit b ⇒ server ⇒
       import GraphDSL.Implicits._
       Source.fromPublisher(netIn) ~> Flow[ByteString].map(SessionBytes(null, _)) ~> server.in2
       server.out1 ~> Flow[SslTlsOutbound].collect { case SendBytes(x) ⇒ x }.buffer(1, OverflowStrategy.backpressure) ~> netOut.sink
diff --git a/akka-http-core/src/test/scala/akka/http/impl/engine/ws/WebSocketIntegrationSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/engine/ws/WebSocketIntegrationSpec.scala
index 5fcecd8f2f..10241c6a11 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/engine/ws/WebSocketIntegrationSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/engine/ws/WebSocketIntegrationSpec.scala
@@ -3,7 +3,7 @@
  */
 package akka.http.impl.engine.ws
 
-import scala.concurrent.{ Await, Promise }
+import scala.concurrent.{ Await, Future, Promise }
 import scala.concurrent.duration.DurationInt
 import org.scalactic.ConversionCheckedTripleEquals
 import org.scalatest.concurrent.ScalaFutures
@@ -20,12 +20,15 @@ import org.scalatest.concurrent.Eventually
 import java.net.InetSocketAddress
 
 import akka.Done
+import akka.http.scaladsl.settings.ClientConnectionSettings
 import akka.stream.impl.fusing.GraphStages
 import akka.stream.stage.{ GraphStageLogic, GraphStageWithMaterializedValue, InHandler, OutHandler }
 import akka.util.ByteString
 import akka.stream.testkit.scaladsl.TestSink
 import akka.testkit.{ AkkaSpec, EventFilter }
 
+import scala.util.{ Failure, Success }
+
 class WebSocketIntegrationSpec extends AkkaSpec("akka.stream.materializer.debug.fuzzing-mode=off")
   with Eventually {
 
@@ -196,4 +199,19 @@ class WebSocketIntegrationSpec extends AkkaSpec("akka.stream.materializer.debug.
 
   }
 
+  "A websocket client" should {
+    "fail the materialized future if the request fails" in {
+      val flow = Http().webSocketClientFlow(
+        WebSocketRequest("ws://127.0.0.1:65535/no/server/here"),
+        settings = ClientConnectionSettings(system).withConnectingTimeout(250.millis))
+
+      val future = Source.maybe[Message].viaMat(flow)(Keep.right).toMat(Sink.ignore)(Keep.left).run()
+      import system.dispatcher
+      whenReady(future.map(r ⇒ Success(r)).recover { case ex ⇒ Failure(ex) }) { resTry ⇒
+        resTry.isFailure should ===(true)
+        resTry.failed.get.getMessage should ===("Connection failed.")
+      }
+    }
+  }
+
 }
diff --git a/akka-http-core/src/test/scala/akka/http/impl/model/parser/HttpHeaderSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/model/parser/HttpHeaderSpec.scala
index f7e02d5534..0e16cfb210 100644
--- a/akka-http-core/src/test/scala/akka/http/impl/model/parser/HttpHeaderSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/impl/model/parser/HttpHeaderSpec.scala
@@ -293,6 +293,8 @@ class HttpHeaderSpec extends FreeSpec with Matchers {
       "Host: [2001:db8::1]" =!= Host("[2001:db8::1]")
       "Host: [::FFFF:129.144.52.38]" =!= Host("[::FFFF:129.144.52.38]")
       "Host: spray.io:80000" =!= ErrorInfo("Illegal HTTP header 'Host': requirement failed", "Illegal port: 80000")
+      "Host: 127.0.0.1:9000" =!= Host("127.0.0.1", 9000)
+      "Host: 127.0.0.1" =!= Host("127.0.0.1")
     }
 
     "If-Match" in {
@@ -373,7 +375,7 @@ class HttpHeaderSpec extends FreeSpec with Matchers {
 
     "Proxy-Authenticate" in {
       "Proxy-Authenticate: Basic realm=\"WallyWorld\",attr=\"val>ue\", Fancy realm=\"yeah\"" =!=
-        `Proxy-Authenticate`(HttpChallenge("Basic", "WallyWorld", Map("attr" → "val>ue")), HttpChallenge("Fancy", "yeah"))
+        `Proxy-Authenticate`(HttpChallenge("Basic", Some("WallyWorld"), Map("attr" → "val>ue")), HttpChallenge("Fancy", Some("yeah")))
     }
 
     "Proxy-Authorization" in {
@@ -544,11 +546,13 @@ class HttpHeaderSpec extends FreeSpec with Matchers {
     }
 
     "WWW-Authenticate" in {
+      "WWW-Authenticate: Basic" =!=
+        `WWW-Authenticate`(HttpChallenge("Basic", None))
       "WWW-Authenticate: Basic realm=\"WallyWorld\"" =!=
-        `WWW-Authenticate`(HttpChallenge("Basic", "WallyWorld"))
+        `WWW-Authenticate`(HttpChallenge("Basic", Some("WallyWorld")))
       "WWW-Authenticate: BaSiC rEaLm=WallyWorld" =!=
         `WWW-Authenticate`(HttpChallenge("BaSiC", "WallyWorld")).renderedTo("BaSiC realm=\"WallyWorld\"")
-      "WWW-Authenticate: Basic realm=\"foo<bar\"" =!= `WWW-Authenticate`(HttpChallenge("Basic", "foo<bar"))
+      "WWW-Authenticate: Basic realm=\"foo<bar\"" =!= `WWW-Authenticate`(HttpChallenge("Basic", Some("foo<bar")))
       """WWW-Authenticate: Digest
                            realm="testrealm@host.com",
                            qop="auth,auth-int",
@@ -559,9 +563,9 @@ class HttpHeaderSpec extends FreeSpec with Matchers {
           "nonce" → "dcd98b7102dd2f0e8b11d0f600bfb0c093", "opaque" → "5ccc069c403ebaf9f0171e9517f40e41"))).renderedTo(
           "Digest realm=\"testrealm@host.com\",qop=\"auth,auth-int\",nonce=dcd98b7102dd2f0e8b11d0f600bfb0c093,opaque=5ccc069c403ebaf9f0171e9517f40e41")
       "WWW-Authenticate: Basic realm=\"WallyWorld\",attr=\"val>ue\", Fancy realm=\"yeah\"" =!=
-        `WWW-Authenticate`(HttpChallenge("Basic", "WallyWorld", Map("attr" → "val>ue")), HttpChallenge("Fancy", "yeah"))
+        `WWW-Authenticate`(HttpChallenge("Basic", Some("WallyWorld"), Map("attr" → "val>ue")), HttpChallenge("Fancy", Some("yeah")))
       """WWW-Authenticate: Fancy realm="Secure Area",nonce=42""" =!=
-        `WWW-Authenticate`(HttpChallenge("Fancy", "Secure Area", Map("nonce" → "42")))
+        `WWW-Authenticate`(HttpChallenge("Fancy", Some("Secure Area"), Map("nonce" → "42")))
     }
 
     "X-Forwarded-For" in {
diff --git a/akka-http-core/src/test/scala/akka/http/impl/util/ByteStringParserInputSpec.scala b/akka-http-core/src/test/scala/akka/http/impl/util/ByteStringParserInputSpec.scala
new file mode 100644
index 0000000000..cc3229e6f5
--- /dev/null
+++ b/akka-http-core/src/test/scala/akka/http/impl/util/ByteStringParserInputSpec.scala
@@ -0,0 +1,34 @@
+package akka.http.impl.util
+
+import akka.util.ByteString
+import org.scalatest.{ Matchers, WordSpec }
+
+class ByteStringParserInputSpec extends WordSpec with Matchers {
+
+  "The ByteStringParserInput" should {
+    val parser = new ByteStringParserInput(ByteString("abcde", "ISO-8859-1"))
+    "return the correct character for index" in {
+      parser.charAt(0) should ===('a')
+      parser.charAt(4) should ===('e')
+    }
+
+    "return the correct length" in {
+      parser.length should ===(5)
+    }
+
+    "slice the bytes correctly into a string" in {
+      parser.sliceString(0, 3) should ===("abc")
+      parser.sliceString(3, 5) should ===("de")
+    }
+
+    "slice the bytes correctly into a char array" in {
+      val array = parser.sliceCharArray(0, 3)
+      array(0) should ===('a')
+      array(1) should ===('b')
+      array(2) should ===('c')
+      array.length should ===(3)
+    }
+
+  }
+
+}
diff --git a/akka-http-core/src/test/scala/akka/http/scaladsl/TestClient.scala b/akka-http-core/src/test/scala/akka/http/scaladsl/TestClient.scala
index 771280ae72..7f593ef718 100644
--- a/akka-http-core/src/test/scala/akka/http/scaladsl/TestClient.scala
+++ b/akka-http-core/src/test/scala/akka/http/scaladsl/TestClient.scala
@@ -4,13 +4,22 @@
 
 package akka.http.scaladsl
 
+import java.io.File
+import java.nio.file.spi.FileSystemProvider
+import java.nio.file.{ FileSystem, Path }
+
 import com.typesafe.config.{ Config, ConfigFactory }
+
 import scala.util.{ Failure, Success }
-import akka.actor.{ UnhandledMessage, ActorSystem }
-import akka.stream.ActorMaterializer
-import akka.stream.scaladsl.{ Sink, Source }
+import akka.actor.{ ActorSystem, UnhandledMessage }
+import akka.stream.{ ActorMaterializer, IOResult }
+import akka.stream.scaladsl.{ FileIO, Sink, Source }
 import akka.http.scaladsl.model._
 import akka.http.impl.util._
+import akka.util.ByteString
+
+import scala.concurrent.{ Await, Future }
+import scala.concurrent.duration._
 
 object TestClient extends App {
   val testConf: Config = ConfigFactory.parseString("""
@@ -62,5 +71,47 @@ object TestClient extends App {
     }
   }
 
+  // for gathering dumps of entity and headers from akka http client
+  // and curl in parallel to compare
+  def fetchAndStoreABunchOfUrlsWithHttpAndCurl(urls: Seq[String]): Unit = {
+    assert(urls.nonEmpty)
+    assert(new File("/tmp/client-dumps/").exists(), "you need to create /tmp/client-dumps/ before running")
+
+    val testConf: Config = ConfigFactory.parseString("""
+    akka.loglevel = DEBUG
+    akka.log-dead-letters = off
+    akka.io.tcp.trace-logging = off""")
+    implicit val system = ActorSystem("ServerTest", testConf)
+    implicit val fm = ActorMaterializer()
+    import system.dispatcher
+
+    try {
+      val done = Future.traverse(urls.zipWithIndex) {
+        case (url, index) ⇒
+          Http().singleRequest(HttpRequest(uri = url)).map { response ⇒
+
+            val path = new File(s"/tmp/client-dumps/akka-body-$index.dump").toPath
+            val headersPath = new File(s"/tmp/client-dumps/akka-headers-$index.dump").toPath
+
+            import scala.sys.process._
+            (s"""curl -D /tmp/client-dumps/curl-headers-$index.dump $url""" #> new File(s"/tmp/client-dumps/curl-body-$index.dump")).!
+
+            val headers = Source(response.headers).map(header ⇒ ByteString(header.name + ": " + header.value + "\n"))
+              .runWith(FileIO.toPath(headersPath))
+
+            val body = response.entity.dataBytes
+              .runWith(FileIO.toPath(path))
+              .map(res ⇒ (url, path, res)): Future[(String, Path, IOResult)]
+
+            headers.flatMap(_ ⇒ body)
+          }
+      }
+
+      println("Fetched urls: " + Await.result(done, 10.minutes))
+    } finally {
+      Http().shutdownAllConnectionPools().flatMap(_ ⇒ system.terminate())
+    }
+  }
+
   def shutdown(): Unit = system.terminate()
 }
\ No newline at end of file
diff --git a/akka-http-core/src/test/scala/akka/http/scaladsl/TestServer.scala b/akka-http-core/src/test/scala/akka/http/scaladsl/TestServer.scala
index 0176913e0d..071b46cd5b 100644
--- a/akka-http-core/src/test/scala/akka/http/scaladsl/TestServer.scala
+++ b/akka-http-core/src/test/scala/akka/http/scaladsl/TestServer.scala
@@ -13,7 +13,7 @@ import scala.concurrent.Await
 import akka.actor.ActorSystem
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.model.ws._
-import akka.stream.ActorMaterializer
+import akka.stream._
 import akka.stream.scaladsl.{ Source, Flow }
 import com.typesafe.config.{ ConfigFactory, Config }
 import HttpMethods._
@@ -23,10 +23,17 @@ object TestServer extends App {
     akka.loglevel = INFO
     akka.log-dead-letters = off
     akka.stream.materializer.debug.fuzzing-mode = off
+    akka.actor.serialize-creators = off
+    akka.actor.serialize-messages = off
+    akka.actor.default-dispatcher.throughput = 1000
     """)
   implicit val system = ActorSystem("ServerTest", testConf)
-  implicit val fm = ActorMaterializer()
 
+  val settings = ActorMaterializerSettings(system)
+    .withFuzzing(false)
+    //    .withSyncProcessingLimit(Int.MaxValue)
+    .withInputBuffer(128, 128)
+  implicit val fm = ActorMaterializer(settings)
   try {
     val binding = Http().bindAndHandleSync({
       case req @ HttpRequest(GET, Uri.Path("/"), _, _, _) if req.header[UpgradeToWebSocket].isDefined ⇒
diff --git a/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpEntitySpec.scala b/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpEntitySpec.scala
index 7a533830a7..ddef91fa85 100755
--- a/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpEntitySpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpEntitySpec.scala
@@ -141,14 +141,23 @@ class HttpEntitySpec extends FreeSpec with MustMatchers with BeforeAndAfterAll {
       "Default" in {
         val entity = Default(tpe, 11, source(abc, de, fgh, ijk))
         entity.toString must include(entity.productPrefix)
+        entity.toString must include("11")
+        entity.toString mustNot include("Source")
       }
       "CloseDelimited" in {
         val entity = CloseDelimited(tpe, source(abc, de, fgh, ijk))
         entity.toString must include(entity.productPrefix)
+        entity.toString mustNot include("Source")
       }
       "Chunked" in {
         val entity = Chunked(tpe, source(Chunk(abc)))
         entity.toString must include(entity.productPrefix)
+        entity.toString mustNot include("Source")
+      }
+      "IndefiniteLength" in {
+        val entity = IndefiniteLength(tpe, source(abc, de, fgh, ijk))
+        entity.toString must include(entity.productPrefix)
+        entity.toString mustNot include("Source")
       }
     }
     "support withoutSizeLimit" - {
diff --git a/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpMessageSpec.scala b/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpMessageSpec.scala
index 28c2c5a2f6..4b67f4ecd6 100644
--- a/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpMessageSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/scaladsl/model/HttpMessageSpec.scala
@@ -4,7 +4,9 @@
 
 package akka.http.scaladsl.model
 
+import akka.util.ByteString
 import headers.Host
+import headers.`Content-Type`
 import org.scalatest.{ Matchers, WordSpec }
 
 class HttpMessageSpec extends WordSpec with Matchers {
@@ -29,4 +31,12 @@ class HttpMessageSpec extends WordSpec with Matchers {
       fail("http://example.com/", Host("example.com", 8080))
     }
   }
+
+  "HttpMessage" should {
+    "not throw a ClassCastException on header[`Content-Type`]" in {
+      val entity = HttpEntity.Strict(ContentTypes.`text/plain(UTF-8)`, ByteString.fromString("hello akka"))
+      HttpResponse(entity = entity).header[`Content-Type`] shouldBe Some(`Content-Type`(ContentTypes.`text/plain(UTF-8)`))
+    }
+  }
+
 }
diff --git a/akka-http-core/src/test/scala/akka/http/scaladsl/model/headers/HeaderSpec.scala b/akka-http-core/src/test/scala/akka/http/scaladsl/model/headers/HeaderSpec.scala
index b84d0d104b..c8dd27e196 100644
--- a/akka-http-core/src/test/scala/akka/http/scaladsl/model/headers/HeaderSpec.scala
+++ b/akka-http-core/src/test/scala/akka/http/scaladsl/model/headers/HeaderSpec.scala
@@ -153,7 +153,7 @@ class HeaderSpec extends FreeSpec with Matchers {
         `Last-Modified`(DateTime(2016, 2, 4, 9, 9, 0)),
         Link(Uri("http://example.com"), LinkParams.`title*`("example")),
         Location(Uri("http://example.com")),
-        `Proxy-Authenticate`(HttpChallenge("Basic", "example.com")),
+        `Proxy-Authenticate`(HttpChallenge("Basic", Some("example.com"))),
         `Sec-WebSocket-Accept`("dGhlIHNhbXBsZSBub25jZQ"),
         `Sec-WebSocket-Extensions`(Vector(WebSocketExtension("foo"))),
         `Sec-WebSocket-Version`(Vector(13)),
@@ -161,7 +161,7 @@ class HeaderSpec extends FreeSpec with Matchers {
         `Set-Cookie`(HttpCookie("sessionId", "b0eb8b8b3ad246")),
         `Transfer-Encoding`(TransferEncodings.chunked),
         Upgrade(Vector(UpgradeProtocol("HTTP", Some("2.0")))),
-        `WWW-Authenticate`(HttpChallenge("Basic", "example.com")))
+        `WWW-Authenticate`(HttpChallenge("Basic", Some("example.com"))))
 
       responseHeaders.foreach { header ⇒
         header shouldBe 'renderInResponses
diff --git a/akka-http-marshallers-java/akka-http-jackson/src/main/java/akka/http/javadsl/marshallers/jackson/Jackson.java b/akka-http-marshallers-java/akka-http-jackson/src/main/java/akka/http/javadsl/marshallers/jackson/Jackson.java
index eb1bb70cea..92cd6b9bb6 100644
--- a/akka-http-marshallers-java/akka-http-jackson/src/main/java/akka/http/javadsl/marshallers/jackson/Jackson.java
+++ b/akka-http-marshallers-java/akka-http-jackson/src/main/java/akka/http/javadsl/marshallers/jackson/Jackson.java
@@ -8,9 +8,10 @@ import java.io.IOException;
 import akka.http.javadsl.model.HttpEntity;
 import akka.http.javadsl.model.MediaTypes;
 import akka.http.javadsl.model.RequestEntity;
-import akka.http.javadsl.server.Marshaller;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.marshalling.Marshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 
+import akka.util.ByteString;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -31,6 +32,10 @@ public class Jackson {
     );
   }
 
+  public static <T> Unmarshaller<ByteString, T> byteStringUnmarshaller(Class<T> expectedType) {
+    return byteStringUnmarshaller(defaultObjectMapper, expectedType);
+  }
+  
   public static <T> Unmarshaller<HttpEntity, T> unmarshaller(Class<T> expectedType) {
     return unmarshaller(defaultObjectMapper, expectedType);
   }
@@ -39,6 +44,10 @@ public class Jackson {
     return Unmarshaller.forMediaType(MediaTypes.APPLICATION_JSON, Unmarshaller.entityToString())
                        .thenApply(s -> fromJSON(mapper, s, expectedType));
   }
+  
+  public static <T> Unmarshaller<ByteString, T> byteStringUnmarshaller(ObjectMapper mapper, Class<T> expectedType) {
+    return Unmarshaller.sync(s -> fromJSON(mapper, s.utf8String(), expectedType));
+  }
 
   private static String toJSON(ObjectMapper mapper, Object object) {
     try {
diff --git a/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonByteStringParserInput.scala b/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonByteStringParserInput.scala
new file mode 100644
index 0000000000..6e921267af
--- /dev/null
+++ b/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonByteStringParserInput.scala
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.scaladsl.marshallers.sprayjson
+
+import java.nio.{ ByteBuffer, CharBuffer }
+import java.nio.charset.{ Charset, StandardCharsets }
+
+import akka.util.ByteString
+import spray.json.ParserInput.DefaultParserInput
+import scala.annotation.tailrec
+
+/**
+ * ParserInput reading directly off a ByteString. (Based on the ByteArrayBasedParserInput)
+ * that avoids a separate decoding step.
+ */
+final class SprayJsonByteStringParserInput(bytes: ByteString) extends DefaultParserInput {
+
+  import SprayJsonByteStringParserInput._
+
+  private[this] val byteBuffer = ByteBuffer.allocate(4)
+  private[this] val charBuffer = CharBuffer.allocate(1)
+
+  private[this] val decoder = Charset.forName("UTF-8").newDecoder()
+
+  override def nextChar() = {
+    _cursor += 1
+    if (_cursor < bytes.length) (bytes(_cursor) & 0xFF).toChar else EOI
+  }
+
+  override def nextUtf8Char() = {
+    @tailrec def decode(byte: Byte, remainingBytes: Int): Char = {
+      byteBuffer.put(byte)
+      if (remainingBytes > 0) {
+        _cursor += 1
+        if (_cursor < bytes.length) decode(bytes(_cursor), remainingBytes - 1) else ErrorChar
+      } else {
+        byteBuffer.flip()
+        val coderResult = decoder.decode(byteBuffer, charBuffer, false)
+        charBuffer.flip()
+        val result = if (coderResult.isUnderflow & charBuffer.hasRemaining) charBuffer.get() else ErrorChar
+        byteBuffer.clear()
+        charBuffer.clear()
+        result
+      }
+    }
+
+    _cursor += 1
+    if (_cursor < bytes.length) {
+      val byte = bytes(_cursor)
+      if (byte >= 0) byte.toChar // 7-Bit ASCII
+      else if ((byte & 0xE0) == 0xC0) decode(byte, 1) // 2-byte UTF-8 sequence
+      else if ((byte & 0xF0) == 0xE0) decode(byte, 2) // 3-byte UTF-8 sequence
+      else if ((byte & 0xF8) == 0xF0) decode(byte, 3) // 4-byte UTF-8 sequence, will probably produce an (unsupported) surrogate pair
+      else ErrorChar
+    } else EOI
+  }
+
+  override def length: Int = bytes.size
+  override def sliceString(start: Int, end: Int): String =
+    bytes.slice(start, end - start).decodeString(StandardCharsets.UTF_8)
+  override def sliceCharArray(start: Int, end: Int): Array[Char] =
+    StandardCharsets.UTF_8.decode(bytes.slice(start, end).asByteBuffer).array()
+}
+
+object SprayJsonByteStringParserInput {
+  private final val EOI = '\uFFFF'
+  // compile-time constant
+  private final val ErrorChar = '\uFFFD' // compile-time constant, universal UTF-8 replacement character '�'
+}
diff --git a/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonSupport.scala b/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonSupport.scala
index 99bbb2c2fc..7f91733aa4 100644
--- a/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonSupport.scala
+++ b/akka-http-marshallers-scala/akka-http-spray-json/src/main/scala/akka/http/scaladsl/marshallers/sprayjson/SprayJsonSupport.scala
@@ -4,13 +4,19 @@
 
 package akka.http.scaladsl.marshallers.sprayjson
 
-import scala.language.implicitConversions
-import akka.http.scaladsl.marshalling.{ ToEntityMarshaller, Marshaller }
-import akka.http.scaladsl.unmarshalling.{ FromEntityUnmarshaller, Unmarshaller }
-import akka.http.scaladsl.model.{ MediaTypes, HttpCharsets }
+import akka.NotUsed
+import akka.http.scaladsl.common.EntityStreamingSupport
+import akka.http.scaladsl.marshalling._
 import akka.http.scaladsl.model.MediaTypes.`application/json`
+import akka.http.scaladsl.model.{ HttpCharsets, MediaTypes }
+import akka.http.scaladsl.unmarshalling.{ FromByteStringUnmarshaller, FromEntityUnmarshaller, Unmarshaller }
+import akka.http.scaladsl.util.FastFuture
+import akka.stream.scaladsl.{ Flow, Keep, Source }
+import akka.util.ByteString
 import spray.json._
 
+import scala.language.implicitConversions
+
 /**
  * A trait providing automatic to and from JSON marshalling/unmarshalling using an in-scope *spray-json* protocol.
  */
@@ -19,19 +25,40 @@ trait SprayJsonSupport {
     sprayJsonUnmarshaller(reader)
   implicit def sprayJsonUnmarshaller[T](implicit reader: RootJsonReader[T]): FromEntityUnmarshaller[T] =
     sprayJsValueUnmarshaller.map(jsonReader[T].read)
+  implicit def sprayJsonByteStringUnmarshaller[T](implicit reader: RootJsonReader[T]): FromByteStringUnmarshaller[T] =
+    Unmarshaller.withMaterializer[ByteString, JsValue](_ ⇒ implicit mat ⇒ { bs ⇒
+      // .compact so addressing into any address is very fast (also for large chunks)
+      // TODO we could optimise ByteStrings to better handle linear access like this (or provide ByteStrings.linearAccessOptimised)
+      // TODO IF it's worth it. 
+      val parserInput = new SprayJsonByteStringParserInput(bs.compact)
+      FastFuture.successful(JsonParser(parserInput))
+    }).map(jsonReader[T].read)
   implicit def sprayJsValueUnmarshaller: FromEntityUnmarshaller[JsValue] =
     Unmarshaller.byteStringUnmarshaller.forContentTypes(`application/json`).mapWithCharset { (data, charset) ⇒
       val input =
         if (charset == HttpCharsets.`UTF-8`) ParserInput(data.toArray)
-        else ParserInput(data.decodeString(charset.nioCharset.name)) // FIXME: identify charset by instance, not by name!
+        else ParserInput(data.decodeString(charset.nioCharset))
       JsonParser(input)
     }
+  // support for as[Source[T, NotUsed]]
+  implicit def sprayJsonSourceReader[T](implicit reader: RootJsonReader[T], support: EntityStreamingSupport): FromEntityUnmarshaller[Source[T, NotUsed]] =
+    Unmarshaller.withMaterializer { implicit ec ⇒ implicit mat ⇒ e ⇒
+      if (support.supported.matches(e.contentType)) {
+        val frames = e.dataBytes.via(support.framingDecoder)
+        val unmarshal = sprayJsonByteStringUnmarshaller(reader)(_)
+        val unmarshallingFlow =
+          if (support.unordered) Flow[ByteString].mapAsyncUnordered(support.parallelism)(unmarshal)
+          else Flow[ByteString].mapAsync(support.parallelism)(unmarshal)
+        val elements = frames.viaMat(unmarshallingFlow)(Keep.right)
+        FastFuture.successful(elements)
+      } else FastFuture.failed(Unmarshaller.UnsupportedContentTypeException(support.supported))
+    }
 
-  implicit def sprayJsonMarshallerConverter[T](writer: RootJsonWriter[T])(implicit printer: JsonPrinter = PrettyPrinter): ToEntityMarshaller[T] =
+  implicit def sprayJsonMarshallerConverter[T](writer: RootJsonWriter[T])(implicit printer: JsonPrinter = CompactPrinter): ToEntityMarshaller[T] =
     sprayJsonMarshaller[T](writer, printer)
-  implicit def sprayJsonMarshaller[T](implicit writer: RootJsonWriter[T], printer: JsonPrinter = PrettyPrinter): ToEntityMarshaller[T] =
+  implicit def sprayJsonMarshaller[T](implicit writer: RootJsonWriter[T], printer: JsonPrinter = CompactPrinter): ToEntityMarshaller[T] =
     sprayJsValueMarshaller compose writer.write
-  implicit def sprayJsValueMarshaller(implicit printer: JsonPrinter = PrettyPrinter): ToEntityMarshaller[JsValue] =
+  implicit def sprayJsValueMarshaller(implicit printer: JsonPrinter = CompactPrinter): ToEntityMarshaller[JsValue] =
     Marshaller.StringMarshaller.wrap(MediaTypes.`application/json`)(printer)
 }
-object SprayJsonSupport extends SprayJsonSupport
\ No newline at end of file
+object SprayJsonSupport extends SprayJsonSupport
diff --git a/akka-http-testkit/src/main/scala/akka/http/javadsl/testkit/TestRouteResult.scala b/akka-http-testkit/src/main/scala/akka/http/javadsl/testkit/TestRouteResult.scala
index 91edde58ac..54859d3de7 100644
--- a/akka-http-testkit/src/main/scala/akka/http/javadsl/testkit/TestRouteResult.scala
+++ b/akka-http-testkit/src/main/scala/akka/http/javadsl/testkit/TestRouteResult.scala
@@ -5,10 +5,10 @@
 package akka.http.javadsl.testkit
 
 import akka.http.javadsl.server.RouteResult
+import akka.http.javadsl.unmarshalling.Unmarshaller
 
 import scala.reflect.ClassTag
 import scala.concurrent.ExecutionContext
-import scala.concurrent.Await
 import scala.concurrent.duration.FiniteDuration
 import akka.util.ByteString
 import akka.stream.Materializer
@@ -17,7 +17,7 @@ import akka.http.scaladsl.unmarshalling.Unmarshal
 import akka.http.scaladsl.model.HttpResponse
 import akka.http.impl.util._
 import akka.http.impl.util.JavaMapping.Implicits._
-import akka.http.javadsl.server.{ Rejection, RoutingJavaMapping, Unmarshaller }
+import akka.http.javadsl.server.{ Rejection, RoutingJavaMapping }
 import RoutingJavaMapping._
 import akka.http.javadsl.model._
 
@@ -103,7 +103,7 @@ abstract class TestRouteResult(_result: RouteResult, awaitAtMost: FiniteDuration
   /**
    * Returns the first header of the response which is of the given class.
    */
-  def header[T <: HttpHeader](clazz: Class[T]): T =
+  def header[T >: Null <: HttpHeader](clazz: Class[T]): T =
     response.header(ClassTag(clazz))
       .getOrElse(doFail(s"Expected header of type ${clazz.getSimpleName} but wasn't found."))
 
@@ -172,7 +172,7 @@ abstract class TestRouteResult(_result: RouteResult, awaitAtMost: FiniteDuration
     assertEqualsKind(expected, entityBytes, "entity")
 
   /**
-   * Assert on the response entity to equal the given object after applying an [[akka.http.javadsl.server.Unmarshaller]].
+   * Assert on the response entity to equal the given object after applying an [[akka.http.javadsl.unmarshalling.Unmarshaller]].
    */
   def assertEntityAs[T <: AnyRef](unmarshaller: Unmarshaller[HttpEntity, T], expected: T): TestRouteResult =
     assertEqualsKind(expected, entity(unmarshaller), "entity")
diff --git a/akka-http-testkit/src/main/scala/akka/http/scaladsl/testkit/RouteTest.scala b/akka-http-testkit/src/main/scala/akka/http/scaladsl/testkit/RouteTest.scala
index 2c71fc3538..b7e1c15a36 100644
--- a/akka-http-testkit/src/main/scala/akka/http/scaladsl/testkit/RouteTest.scala
+++ b/akka-http-testkit/src/main/scala/akka/http/scaladsl/testkit/RouteTest.scala
@@ -75,7 +75,7 @@ trait RouteTest extends RequestBuilding with WSTestRequestBuilding with RouteTes
   def charsetOption: Option[HttpCharset] = contentType.charsetOption
   def charset: HttpCharset = charsetOption getOrElse sys.error("Binary entity does not have charset")
   def headers: immutable.Seq[HttpHeader] = response.headers
-  def header[T <: HttpHeader: ClassTag]: Option[T] = response.header[T]
+  def header[T >: Null <: HttpHeader: ClassTag]: Option[T] = response.header[T](implicitly[ClassTag[T]])
   def header(name: String): Option[HttpHeader] = response.headers.find(_.is(name.toLowerCase))
   def status: StatusCode = response.status
 
diff --git a/akka-http-tests/build.sbt b/akka-http-tests/build.sbt
index 489f69bc8e..cf5b82307f 100644
--- a/akka-http-tests/build.sbt
+++ b/akka-http-tests/build.sbt
@@ -1,4 +1,5 @@
 import akka._
+import com.typesafe.sbt.SbtMultiJvm.MultiJvmKeys._
 
 AkkaBuild.defaultSettings
 AkkaBuild.dontPublishSettings
@@ -12,4 +13,6 @@ scalacOptions in Compile  += "-language:_"
 mainClass in run in Test := Some("akka.http.javadsl.SimpleServerApp")
 
 enablePlugins(ScaladocNoVerificationOfDiagrams)
+enablePlugins(MultiNodeScalaTest)
+
 disablePlugins(MimaPlugin)
diff --git a/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/petstore/PetStoreExample.java b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/petstore/PetStoreExample.java
index 58a10527b1..05877a8f91 100644
--- a/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/petstore/PetStoreExample.java
+++ b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/petstore/PetStoreExample.java
@@ -19,7 +19,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 import static akka.http.javadsl.server.Directives.*;
-import static akka.http.javadsl.server.StringUnmarshallers.INTEGER;
+import static akka.http.javadsl.unmarshalling.StringUnmarshallers.INTEGER;
 
 public class PetStoreExample {
 
diff --git a/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
index dd5a60aa9c..f72846c71e 100644
--- a/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
+++ b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerApp.java
@@ -4,7 +4,6 @@
 
 package akka.http.javadsl.server.examples.simple;
 
-//#https-http-app
 
 import akka.NotUsed;
 import static akka.http.javadsl.server.PathMatchers.segment;
@@ -17,6 +16,7 @@ import akka.http.javadsl.HttpsConnectionContext;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.HttpResponse;
 import akka.http.javadsl.server.*;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.stream.ActorMaterializer;
 import akka.stream.javadsl.Flow;
 
@@ -34,10 +34,12 @@ import java.util.function.BiFunction;
 import java.util.function.Function;
 
 import static akka.http.javadsl.server.PathMatchers.integerSegment;
-import static akka.http.javadsl.server.Unmarshaller.entityToString;
+import static akka.http.javadsl.unmarshalling.Unmarshaller.entityToString;
 
 public class SimpleServerApp extends AllDirectives { // or import Directives.*
 
+
+  //#https-http-app
   public Route multiply(int x, int y) {
     int result = x * y;
     return complete(String.format("%d * %d = %d", x, y, result));
@@ -102,7 +104,10 @@ public class SimpleServerApp extends AllDirectives { // or import Directives.*
     final Http http = Http.get(system);
 
     boolean useHttps = false; // pick value from anywhere
-    useHttps(system, http, useHttps);
+    if ( useHttps ) {
+      HttpsConnectionContext https = useHttps(system);
+      http.setDefaultServerHttpContext(https);
+    }
 
     final SimpleServerApp app = new SimpleServerApp();
     final Flow<HttpRequest, HttpResponse, NotUsed> flow = app.createRoute().flow(system, materializer);
@@ -113,12 +118,12 @@ public class SimpleServerApp extends AllDirectives { // or import Directives.*
     System.in.read();
     system.terminate();
   }
+  //#
 
+  //#https-http-config
   // ** CONFIGURING ADDITIONAL SETTINGS ** //
 
-  public static void useHttps(ActorSystem system, Http http, boolean useHttps) {
-    if (useHttps) {
-
+  public static HttpsConnectionContext useHttps(ActorSystem system) {
       HttpsConnectionContext https = null;
       try {
         // initialise the keystore
@@ -149,9 +154,7 @@ public class SimpleServerApp extends AllDirectives { // or import Directives.*
         system.log().error("Exception while ", e);
       }
 
-      http.setDefaultServerHttpContext(https);
-    }
+      return https;
   }
-
+  //#
 }
-//#
diff --git a/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerHttpHttpsApp.java b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerHttpHttpsApp.java
new file mode 100644
index 0000000000..22badc1d3b
--- /dev/null
+++ b/akka-http-tests/src/main/java/akka/http/javadsl/server/examples/simple/SimpleServerHttpHttpsApp.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.javadsl.server.examples.simple;
+
+import akka.NotUsed;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.ConnectHttp;
+import akka.http.javadsl.Http;
+import akka.http.javadsl.HttpsConnectionContext;
+import akka.http.javadsl.model.HttpRequest;
+import akka.http.javadsl.model.HttpResponse;
+import akka.http.javadsl.server.AllDirectives;
+import akka.http.javadsl.server.Route;
+import akka.stream.ActorMaterializer;
+import akka.stream.javadsl.Flow;
+
+import java.io.IOException;
+
+public class SimpleServerHttpHttpsApp extends AllDirectives { // or import Directives.*
+
+  public Route createRoute() {
+    return get( () -> complete("Hello World!") );
+  }
+
+  // ** STARTING THE SERVER ** //
+
+  public static void main(String[] args) throws IOException {
+    final ActorSystem system = ActorSystem.create("SimpleServerHttpHttpsApp");
+    final ActorMaterializer materializer = ActorMaterializer.create(system);
+
+    final SimpleServerApp app = new SimpleServerApp();
+    final Flow<HttpRequest, HttpResponse, NotUsed> flow = app.createRoute().flow(system, materializer);
+
+    //#both-https-and-http
+    final Http http = Http.get(system);
+    //Run HTTP server firstly
+    http.bindAndHandle(flow, ConnectHttp.toHost("localhost", 80), materializer);
+
+    //get configured HTTPS context
+    HttpsConnectionContext https = SimpleServerApp.useHttps(system);
+
+    // sets default context to HTTPS – all Http() bound servers for this ActorSystem will use HTTPS from now on
+    http.setDefaultServerHttpContext(https);
+
+    //Then run HTTPS server
+    http.bindAndHandle(flow, ConnectHttp.toHost("localhost", 443), materializer);
+    //#
+
+    System.out.println("Type RETURN to exit");
+    System.in.read();
+    system.terminate();
+  }
+}
diff --git a/akka-http-tests/src/multi-jvm/scala/akka/http/AkkaHttpServerLatencyMultiNodeSpec.scala b/akka-http-tests/src/multi-jvm/scala/akka/http/AkkaHttpServerLatencyMultiNodeSpec.scala
new file mode 100644
index 0000000000..0e480f80b2
--- /dev/null
+++ b/akka-http-tests/src/multi-jvm/scala/akka/http/AkkaHttpServerLatencyMultiNodeSpec.scala
@@ -0,0 +1,391 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http
+
+import java.io.{ BufferedWriter, FileWriter }
+import java.util.concurrent.TimeUnit
+
+import akka.NotUsed
+import akka.actor.{ Actor, ActorIdentity, ActorRef, Identify, Props }
+import akka.http.scaladsl.Http.ServerBinding
+import akka.http.scaladsl.model.{ ContentTypes, HttpEntity }
+import akka.http.scaladsl.server.{ Directives, Route }
+import akka.http.scaladsl.{ Http, TestUtils }
+import akka.remote.testkit.{ MultiNodeConfig, MultiNodeSpec }
+import akka.stream.ActorMaterializer
+import akka.stream.scaladsl.Source
+import akka.testkit.{ ImplicitSender, LongRunningTest }
+import akka.util.{ ByteString, Timeout }
+import com.typesafe.config.ConfigFactory
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.exceptions.TestPendingException
+
+import scala.annotation.tailrec
+import scala.concurrent.duration._
+import scala.concurrent.{ Await, Promise }
+import scala.util.Try
+
+object AkkaHttpServerLatencyMultiNodeSpec extends MultiNodeConfig {
+
+  commonConfig(ConfigFactory.parseString(
+    """
+      akka {
+        actor.default-mailbox.mailbox-type = "akka.dispatch.UnboundedMailbox"
+        actor.provider = "akka.remote.RemoteActorRefProvider"
+        stream.materializer.debug.fuzzing-mode = off
+
+        testconductor.barrier-timeout = 30m
+        
+        test.AkkaHttpServerLatencySpec {
+          enable = off
+          
+          rate = 10000
+          duration = 30s
+          
+          totalRequestsFactor = 1.0
+        }
+      }
+    """))
+
+  val server = role("server")
+  val loadGenerator = role("loadGenerator")
+
+  private var _ifWrk2Available: Option[Boolean] = None
+  final def ifWrk2Available(test: ⇒ Unit): Unit =
+    if (isWrk2Available) test else throw new TestPendingException()
+  final def isWrk2Available: Boolean =
+    _ifWrk2Available getOrElse {
+      import scala.sys.process._
+      val wrkExitCode = Try("""wrk""".!).getOrElse(-1)
+
+      _ifWrk2Available = Some(wrkExitCode == 1) // app found, help displayed
+      isWrk2Available
+    }
+
+  private var _abAvailable: Option[Boolean] = None
+  final def ifAbAvailable(test: ⇒ Unit): Unit =
+    if (isAbAvailable) test else throw new TestPendingException()
+
+  final def isAbAvailable: Boolean =
+    _abAvailable getOrElse {
+      import scala.sys.process._
+      val abExitCode = Try("""ab -h""".!).getOrElse(-1)
+      _abAvailable = Some(abExitCode == 22) // app found, help displayed (22 return code is when -h runs in ab, weird but true)
+      isAbAvailable
+    }
+
+  final case class LoadGenCommand(cmd: String)
+  final case class LoadGenResults(results: String) {
+    def lines = results.split("\n")
+  }
+  final case class SetServerPort(port: Int)
+  class HttpLoadGeneratorActor(serverPort: Promise[Int]) extends Actor {
+    override def receive: Receive = {
+      case SetServerPort(port) ⇒
+        serverPort.success(port)
+        context become ready(port)
+      case other ⇒
+        throw new RuntimeException("No server port known! Initialize with SetServerPort() first! Got: " + other)
+    }
+
+    import scala.sys.process._
+    def ready(port: Int): Receive = {
+      case LoadGenCommand(cmd) if cmd startsWith "wrk" ⇒
+        val res =
+          if (isWrk2Available) cmd.!! // blocking. DON'T DO THIS AT HOME, KIDS!
+          else "=== WRK NOT AVAILABLE ==="
+        sender() ! LoadGenResults(res)
+
+      case LoadGenCommand(cmd) if cmd startsWith "ab" ⇒
+        val res =
+          if (isAbAvailable) cmd.!! // blocking. DON'T DO THIS AT HOME, KIDS!
+          else "=== AB NOT AVAILABLE ==="
+        sender() ! LoadGenResults(res)
+    }
+  }
+}
+
+class AkkaHttpServerLatencyMultiNodeSpecMultiJvmNode1 extends AkkaHttpServerLatencyMultiNodeSpec
+class AkkaHttpServerLatencyMultiNodeSpecMultiJvmNode2 extends AkkaHttpServerLatencyMultiNodeSpec
+
+class AkkaHttpServerLatencyMultiNodeSpec extends MultiNodeSpec(AkkaHttpServerLatencyMultiNodeSpec) with STMultiNodeSpec
+  with ScalaFutures with ImplicitSender {
+
+  import AkkaHttpServerLatencyMultiNodeSpec._
+
+  override implicit def patienceConfig: PatienceConfig = PatienceConfig(10.seconds, interval = 300.millis)
+
+  def initialParticipants = 2
+
+  val MediumByteString = ByteString(Vector.fill(1024)(0.toByte): _*)
+
+  val array_10x: Array[Byte] = Array(Vector.fill(10)(MediumByteString).flatten: _*)
+  val array_100x: Array[Byte] = Array(Vector.fill(100)(MediumByteString).flatten: _*)
+  val source_10x: Source[ByteString, NotUsed] = Source.repeat(MediumByteString).take(10)
+  val source_100x: Source[ByteString, NotUsed] = Source.repeat(MediumByteString).take(100)
+  val tenXResponseLength = array_10x.length
+  val hundredXResponseLength = array_100x.length
+  
+  // format: OFF
+  val routes: Route = {
+    import Directives._
+    
+    path("ping") {
+      complete("PONG!")
+    } ~
+    path("long-response-array" / IntNumber) { n =>
+      if (n == 10) complete(HttpEntity(ContentTypes.`text/plain(UTF-8)`, array_10x))
+      else if (n == 100) complete(HttpEntity(ContentTypes.`text/plain(UTF-8)`, array_10x))
+      else throw new RuntimeException(s"Not implemented for ${n}")
+    } ~
+    path("long-response-stream" / IntNumber) { n =>
+      if (n == 10) complete(HttpEntity(ContentTypes.`text/plain(UTF-8)`, source_100x))
+      else if (n == 100) complete(HttpEntity(ContentTypes.`text/plain(UTF-8)`, source_100x))
+      else throw new RuntimeException(s"Not implemented for ${n}")
+    }
+  }
+  // format: ON
+
+  val enableSpec = system.settings.config.getBoolean("akka.test.AkkaHttpServerLatencySpec.enable")
+  val totalRequestsFactor = system.settings.config.getDouble("akka.test.AkkaHttpServerLatencySpec.totalRequestsFactor")
+  val requests = Math.round(10000 * totalRequestsFactor)
+  val rate = system.settings.config.getInt("akka.test.AkkaHttpServerLatencySpec.rate")
+  val testDuration = system.settings.config.getDuration("akka.test.AkkaHttpServerLatencySpec.duration", TimeUnit.SECONDS)
+  val connections: Long = 10
+
+  override def binding = _binding
+  var _binding: Option[ServerBinding] = None
+
+  val serverPortPromise: Promise[Int] = Promise()
+  def serverPort: Int = serverPortPromise.future.futureValue
+  def serverHost: String = node(server).address.host.get
+
+  // --- urls
+  def url_ping = s"http://$serverHost:$serverPort/ping"
+  def url_longResponseStream(int: Int) = s"http://$serverHost:$serverPort/long-response-stream/$int"
+  def url_longResponseArray(int: Int) = s"http://$serverHost:$serverPort/long-response-array/$int"
+  // ---
+
+  if (enableSpec) {
+    "Akka HTTP" must {
+      implicit val dispatcher = system.dispatcher
+      implicit val mat = ActorMaterializer()
+
+      "start Akka HTTP" taggedAs LongRunningTest in {
+        enterBarrier("startup")
+
+        runOn(loadGenerator) {
+          system.actorOf(Props(classOf[HttpLoadGeneratorActor], serverPortPromise), "load-gen")
+        }
+        enterBarrier("load-gen-ready")
+
+        runOn(server) {
+          val (_, _, port) = TestUtils.temporaryServerHostnameAndPort()
+          info(s"Binding Akka HTTP Server to port: $port @ ${myself}")
+          val futureBinding = Http().bindAndHandle(routes, "0.0.0.0", port)
+
+          _binding = Some(futureBinding.futureValue)
+          setServerPort(port)
+        }
+
+        enterBarrier("http-server-running")
+      }
+
+      "warmup" taggedAs LongRunningTest in ifWrk2Available {
+        val id = "warmup"
+
+        val wrkOptions = s"""-d 30s -R $rate -c $connections -t $connections"""
+        runLoadTest(id)(s"""wrk $wrkOptions $url_ping""")
+      }
+
+      "have good Latency on PONG response (keep-alive)" taggedAs LongRunningTest in ifWrk2Available {
+        val id = s"Latency_pong_R:${rate}_C:${connections}_p:"
+
+        val wrkOptions = s"""-d ${testDuration}s -R $rate -c $connections -t $connections --u_latency"""
+        runLoadTest(id)(s"""wrk $wrkOptions $url_ping""")
+      }
+
+      "have good Latency (ab) (short-lived connections)" taggedAs LongRunningTest in ifAbAvailable {
+        val id = s"Latency_AB-short-lived_pong_R:${rate}_C:${connections}_p:"
+
+        val abOptions = s"-c $connections -n $requests"
+        runLoadTest(id)(s"""ab $abOptions $url_ping""")
+      }
+
+      "have good Latency (ab) (long-lived connections)" taggedAs LongRunningTest in ifAbAvailable {
+        val id = s"Latency_AB_pong_long-lived_R:${rate}_C:${connections}_p:"
+
+        val abOptions = s"-c $connections -n $requests -k"
+        runLoadTest(id)(s"""ab $abOptions $url_ping""")
+      }
+
+      List(
+        10 → tenXResponseLength,
+        100 → hundredXResponseLength
+      ) foreach {
+          case (n, lenght) ⇒
+            s"have good Latency (streaming-response($lenght), keep-alive)" taggedAs LongRunningTest in {
+              val id = s"Latency_stream($lenght)_R:${rate}_C:${connections}_p:"
+
+              val wrkOptions = s"""-d ${testDuration}s -R $rate -c $connections -t $connections --u_latency"""
+              runLoadTest(id)(s"""wrk $wrkOptions ${url_longResponseStream(n)}""")
+            }
+            s"have good Latency (array-response($lenght), keep-alive)" taggedAs LongRunningTest in {
+              val id = s"Latency_array($lenght)_R:${rate}_C:${connections}_p:"
+
+              val wrkOptions = s"""-d ${testDuration}s -R $rate -c $connections -t $connections --u_latency"""
+              runLoadTest(id)(s"""wrk $wrkOptions ${url_longResponseArray(n)}""")
+            }
+        }
+    }
+  } else {
+    "Akka HTTP" must {
+      "enable these performance tests by running with -Dakka.test.AkkaHttpServerLatencySpec.enable=on" in pending
+    }
+  }
+
+  def runLoadTest(id: String)(cmd: String) = {
+    runOn(loadGenerator) {
+      info(s"${id} => running: $cmd")
+      import akka.pattern.ask
+      implicit val timeout = Timeout(30.minutes) // we don't want to timeout here
+
+      val res = (loadGeneratorActor ? LoadGenCommand(cmd)).mapTo[LoadGenResults]
+      val results = Await.result(res, timeout.duration)
+
+      if (id contains "warmup") ()
+      else if (cmd startsWith "wrk") printWrkPercentiles(id, results.lines)
+      else if (cmd startsWith "ab") printAbPercentiles(id, results.lines)
+      else throw new NotImplementedError(s"Unable to handle [$cmd] results!")
+    }
+
+    enterBarrier(s"load-test-complete-id:${id}")
+  }
+
+  def setServerPort(p: Int): Unit = {
+    serverPortPromise.success(p)
+    loadGeneratorActor ! SetServerPort(p)
+  }
+
+  lazy val loadGeneratorActor: ActorRef = {
+    if (isNode(loadGenerator)) {
+      system.actorSelection("/user/load-gen") ! Identify(None)
+      expectMsgType[ActorIdentity].ref.get
+    } else {
+      system.actorSelection(node(loadGenerator) / "user" / "load-gen") ! Identify(None)
+      expectMsgType[ActorIdentity].ref.get
+    }
+  }
+
+  private def renderResults(prefix: String, titles: Seq[String], values: Seq[String]): Unit = {
+    println("====:" + titles.reverse.map(it ⇒ "\"" + it + "\"").mkString(",") + "\n")
+    println("====:" + values.reverse.map(it ⇒ "\"" + it + "\"").mkString(",") + "\n")
+  }
+
+  private def durationAsMs(d: String): Long = {
+    val dd = d.replace("us", "µs") // Scala Duration does not parse "us"
+    val ddd = if (dd endsWith "m") dd.replace("m", " minutes") else dd
+    Duration(ddd).toMillis
+  }
+
+  private def printWrkPercentiles(prefix: String, lines: Array[String]): Unit = {
+    val percentilesToPrint = 8
+
+    var i = 0
+    val linesWithIndex = lines.zipWithIndex
+    val correctedDistributionStartsHere = linesWithIndex.find(p ⇒ p._1 contains "Latency Distribution").map(_._2).get
+
+    var titles = List.empty[String]
+    var metrics = List.empty[String]
+    i = correctedDistributionStartsHere + 1 // skip header
+    while (i < correctedDistributionStartsHere + 1 + percentilesToPrint) {
+      val line = lines(i).trim
+      val percentile = line.takeWhile(_ != '%')
+
+      val title = prefix + percentile + "_corrected"
+      val duration = durationAsMs(line.drop(percentile.length + 1).trim)
+
+      titles ::= title
+      metrics ::= duration.toString
+      println(title + "," + duration)
+
+      i += 1
+    }
+    renderResults(prefix + "_corrected", titles, metrics)
+
+    val uncorrectedDistributionStartsHere = linesWithIndex.find(p ⇒ p._1 contains "Uncorrected Latency").map(_._2).get
+
+    titles = List.empty
+    metrics = List.empty
+    i = uncorrectedDistributionStartsHere + 1 // skip header
+    while (i < uncorrectedDistributionStartsHere + 1 + percentilesToPrint) {
+      val line = lines(i).trim
+      val percentile = line.takeWhile(_ != '%')
+
+      val title = prefix + percentile + "_uncorrected"
+      val duration = durationAsMs(line.drop(percentile.length + 1).trim)
+
+      titles ::= title
+      metrics ::= duration.toString
+      println(title + "," + duration)
+
+      i += 1
+    }
+    renderResults(prefix + "_uncorrected", titles, metrics)
+
+    titles = List.empty
+    metrics = List.empty
+    val rpsLineNumber = linesWithIndex.find(p ⇒ p._1 contains "Requests/sec:").map(_._2).get
+
+    i = rpsLineNumber
+    val rps = lines(i).replace("Requests/sec:", "").trim
+
+    val rpsTitle = prefix + "requests-per-second"
+    titles ::= rpsTitle
+    metrics ::= rps.toDouble.toInt.toString
+    println(rpsTitle + "," + rps)
+    renderResults(prefix + "_RPS", titles, metrics)
+
+    def transferAsBytes(s: String): Long =
+      ConfigFactory.parseString(s"it=${s}").getMemorySize("it").toBytes
+
+    titles = List.empty
+    metrics = List.empty
+    val transferLineNumber = linesWithIndex.find(p ⇒ p._1 contains "Transfer/sec:").map(_._2).get
+    i = transferLineNumber
+
+    val tps = lines(i).replace("Transfer/sec:", "").trim
+
+    val tpsTitle = prefix + "transfer-per-second"
+    titles ::= tpsTitle
+    metrics ::= transferAsBytes(tps).toString
+    println(tpsTitle + "," + tps)
+    renderResults(prefix + "_TPS", titles, metrics)
+  }
+
+  private def printAbPercentiles(prefix: String, lines: Array[String]): Unit = {
+    val percentilesToPrint = 9
+
+    var i = 0
+    val correctedDistributionStartsHere = lines.zipWithIndex.find(p ⇒ p._1 contains "Percentage of the requests").map(_._2).get
+
+    var titles = List.empty[String]
+    var metrics = List.empty[String]
+    i = correctedDistributionStartsHere + 1 // skip header
+    while (i < correctedDistributionStartsHere + 1 + percentilesToPrint) {
+      val line = lines(i).trim
+      val percentile = line.takeWhile(_ != '%')
+      val title = prefix + percentile
+      val duration = durationAsMs(line.drop(percentile.length + 1).replace("(longest request)", "").trim + "ms")
+
+      titles ::= title
+      metrics ::= duration.toString
+      println(title + "," + duration)
+
+      i += 1
+    }
+    renderResults(prefix, titles, metrics)
+  }
+
+}
diff --git a/akka-http-tests/src/multi-jvm/scala/akka/http/STMultiNodeSpec.scala b/akka-http-tests/src/multi-jvm/scala/akka/http/STMultiNodeSpec.scala
new file mode 100644
index 0000000000..86d04fac6b
--- /dev/null
+++ b/akka-http-tests/src/multi-jvm/scala/akka/http/STMultiNodeSpec.scala
@@ -0,0 +1,24 @@
+/**
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http
+
+import akka.http.scaladsl.Http.ServerBinding
+import akka.remote.testkit.MultiNodeSpecCallbacks
+import org.scalatest.concurrent.ScalaFutures
+import org.scalatest.{ BeforeAndAfterAll, Matchers, WordSpecLike }
+
+trait STMultiNodeSpec extends MultiNodeSpecCallbacks with WordSpecLike with Matchers with BeforeAndAfterAll
+  with ScalaFutures {
+
+  def binding: Option[ServerBinding]
+
+  override def beforeAll() =
+    multiNodeSpecBeforeAll()
+
+  override def afterAll() = {
+    binding foreach { _.unbind().futureValue }
+    multiNodeSpecAfterAll()
+  }
+
+}
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/CompleteTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/CompleteTest.java
index 4e6b873cdc..fb16b3cf64 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/CompleteTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/CompleteTest.java
@@ -4,7 +4,7 @@
 
 package akka.http.javadsl.server;
 
-import static akka.http.javadsl.server.StringUnmarshallers.INTEGER;
+import static akka.http.javadsl.unmarshalling.StringUnmarshallers.INTEGER;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/HandlerBindingTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/HandlerBindingTest.java
index 3c8c60eef2..d6dc7abeeb 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/HandlerBindingTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/HandlerBindingTest.java
@@ -4,7 +4,7 @@
 
 package akka.http.javadsl.server;
 
-import static akka.http.javadsl.server.StringUnmarshallers.INTEGER;
+import static akka.http.javadsl.unmarshalling.StringUnmarshallers.INTEGER;
 
 import org.junit.Test;
 
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaRouteTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaRouteTest.java
index 74473124c3..e447f90eb5 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaRouteTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaRouteTest.java
@@ -14,9 +14,12 @@ import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import akka.http.javadsl.marshalling.Marshaller;
 import akka.http.javadsl.model.*;
 import akka.http.javadsl.model.headers.Accept;
 import akka.http.javadsl.model.headers.RawHeader;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import org.junit.Test;
 
 import akka.http.javadsl.testkit.JUnitRouteTest;
@@ -332,4 +335,4 @@ public class JavaRouteTest extends JUnitRouteTest {
       )
     );
   }
-}
\ No newline at end of file
+}
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaTestServer.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaTestServer.java
index 33f2e98664..761a8e2ba9 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaTestServer.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/JavaTestServer.java
@@ -3,15 +3,22 @@
  */
 package akka.http.javadsl.server;
 
+import akka.NotUsed;
 import akka.actor.ActorSystem;
 import akka.http.javadsl.ConnectHttp;
 import akka.http.javadsl.Http;
 import akka.http.javadsl.ServerBinding;
+import akka.http.javadsl.common.EntityStreamingSupport;
+import akka.http.javadsl.marshallers.jackson.Jackson;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.HttpResponse;
 import akka.http.javadsl.model.StatusCodes;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.stream.ActorMaterializer;
 import akka.stream.javadsl.Flow;
+import akka.stream.javadsl.Source;
+import akka.util.ByteString;
 import scala.concurrent.duration.Duration;
 import scala.runtime.BoxedUnit;
 
@@ -55,18 +62,41 @@ public class JavaTestServer extends AllDirectives { // or import static Directiv
       );
 
     final Route crash = path("crash", () ->
-      path("scala", () -> completeOKWithFutureString(akka.dispatch.Futures.<String>failed(new Exception("Boom!")))).orElse(
-      path("java", () -> completeOKWithFutureString(CompletableFuture.<String>supplyAsync(() -> { throw new RuntimeException("Boom!"); }))))
+      path("scala", () -> completeOKWithFutureString(akka.dispatch.Futures.failed(new Exception("Boom!")))).orElse(
+      path("java", () -> completeOKWithFutureString(CompletableFuture.supplyAsync(() -> { throw new RuntimeException("Boom!"); }))))
     );
 
+    final Unmarshaller<ByteString, JavaTweet> JavaTweets = Jackson.byteStringUnmarshaller(JavaTweet.class);
+    final Route tweets = path("tweets", () ->
+      get(() -> 
+        parameter(StringUnmarshallers.INTEGER, "n", n -> {
+          final Source<JavaTweet, NotUsed> tws = Source.repeat(new JavaTweet("Hello World!")).take(n);
+          return completeOKWithSource(tws, Jackson.marshaller(), EntityStreamingSupport.json());
+        })
+      ).orElse(
+      post(() ->
+        extractMaterializer(mat -> 
+          entityAsSourceOf(JavaTweets, null, sourceOfTweets -> {
+            final CompletionStage<Integer> tweetsCount = sourceOfTweets.runFold(0, (acc, tweet) -> acc + 1, mat);
+            return onComplete(tweetsCount, c -> complete("Total number of tweets: " + c));
+          })
+        )
+      ))
+    );
+    
     final Route inner = path("inner", () ->
       getFromResourceDirectory("someDir")
     );
 
 
-    return get(() ->
-      index.orElse(secure).orElse(ping).orElse(crash).orElse(inner).orElse(requestTimeout)
-    );
+    return index
+      .orElse(secure)
+      .orElse(ping)
+      .orElse(crash)
+      .orElse(inner)
+      .orElse(requestTimeout)
+      .orElse(tweets)
+    ;
   }
 
   private void silentSleep(int millis) {
@@ -113,7 +143,7 @@ public class JavaTestServer extends AllDirectives { // or import static Directiv
 
     final Flow<HttpRequest, HttpResponse, ?> flow = createRoute().flow(system, mat);
     final CompletionStage<ServerBinding> binding =
-      Http.get(system).bindAndHandle(flow, ConnectHttp.toHost("127.0.0.1"), mat);
+      Http.get(system).bindAndHandle(flow, ConnectHttp.toHost("127.0.0.1", 8080), mat);
 
     System.console().readLine("Press [ENTER] to quit...");
     shutdown(binding);
@@ -131,4 +161,21 @@ public class JavaTestServer extends AllDirectives { // or import static Directiv
       }
     });
   }
+  
+  private static final class JavaTweet {
+    private String message;
+
+    public JavaTweet(String message) {
+      this.message = message;
+    }
+
+    public void setMessage(String message) {
+      this.message = message;
+    }
+
+    public String getMessage() {
+      return message;
+    }
+    
+  }
 }
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/MarshallerTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/MarshallerTest.java
index 6cdbd522bc..cdfcbab480 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/MarshallerTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/MarshallerTest.java
@@ -7,8 +7,10 @@ package akka.http.javadsl.server;
 
 import java.util.function.Function;
 
+import akka.http.javadsl.marshalling.Marshaller;
 import akka.http.javadsl.model.*;
 import akka.http.javadsl.model.headers.*;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import org.junit.Test;
 
 import akka.http.javadsl.testkit.JUnitRouteTest;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/UnmarshallerTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/UnmarshallerTest.java
index 7b23e53cf0..d7692cdee5 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/UnmarshallerTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/UnmarshallerTest.java
@@ -5,6 +5,7 @@ package akka.http.javadsl.server;
 
 import akka.http.javadsl.model.*;
 import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import org.junit.Test;
 
 import java.util.Arrays;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/CodingDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/CodingDirectivesTest.java
index 73c13b7dfe..dacee6cc78 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/CodingDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/CodingDirectivesTest.java
@@ -4,23 +4,18 @@
 
 package akka.http.javadsl.server.directives;
 
-import akka.actor.ActorSystem;
+import akka.http.javadsl.coding.Coder;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.headers.AcceptEncoding;
 import akka.http.javadsl.model.headers.ContentEncoding;
 import akka.http.javadsl.model.headers.HttpEncodings;
-import akka.stream.ActorMaterializer;
-import akka.http.javadsl.server.*;
 import akka.util.ByteString;
 
 import org.junit.*;
 
-import scala.concurrent.Await;
-import scala.concurrent.duration.Duration;
 import akka.http.javadsl.testkit.*;
 
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.concurrent.TimeUnit;
 
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ExecutionDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ExecutionDirectivesTest.java
index 2eeee3ad95..2bc1c7dcc9 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ExecutionDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ExecutionDirectivesTest.java
@@ -11,7 +11,7 @@ import akka.http.javadsl.model.StatusCodes;
 import akka.http.javadsl.server.ExceptionHandler;
 import akka.http.javadsl.server.RejectionHandler;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 import akka.http.scaladsl.server.MethodRejection;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/HeaderDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/HeaderDirectivesTest.java
index 8fe7fac43f..fe9ecad53f 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/HeaderDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/HeaderDirectivesTest.java
@@ -205,5 +205,32 @@ public class HeaderDirectivesTest extends JUnitRouteTest {
       .run(HttpRequest.create().addHeader(Origin.create(invalidOriginHeader)))
       .assertStatusCode(StatusCodes.FORBIDDEN);
   }
+  
+  @Test
+  public void testCheckSameOriginGivenALL() {
+    final HttpOrigin validOriginHeader = HttpOrigin.create("http://localhost", Host.create("8080"));
+
+    // not very interesting case, however here we check that the directive simply avoids performing the check
+    final HttpOriginRange everythingGoes = HttpOriginRanges.ALL;
+
+    final TestRoute route = testRoute(checkSameOrigin(everythingGoes, () -> complete("Result")));
+
+    route
+      .run(HttpRequest.create().addHeader(Origin.create(validOriginHeader)))
+      .assertStatusCode(StatusCodes.OK)
+      .assertEntity("Result");
+
+    route
+      .run(HttpRequest.create())
+      .assertStatusCode(StatusCodes.OK)
+      .assertEntity("Result");
+
+    final HttpOrigin otherOriginHeader = HttpOrigin.create("http://invalid.com", Host.create("8080"));
+
+    route
+      .run(HttpRequest.create().addHeader(Origin.create(otherOriginHeader)))
+      .assertStatusCode(StatusCodes.OK)
+      .assertEntity("Result");
+  }
 
 }
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MarshallingDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MarshallingDirectivesTest.java
index 9c291439a6..e1475aa402 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MarshallingDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MarshallingDirectivesTest.java
@@ -14,7 +14,7 @@ import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 
 import org.junit.Test;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MiscDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MiscDirectivesTest.java
index 12002d791c..91dd5a8399 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MiscDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/MiscDirectivesTest.java
@@ -11,7 +11,7 @@ import akka.http.javadsl.model.Uri;
 import akka.http.javadsl.model.headers.RawHeader;
 import akka.http.javadsl.model.headers.XForwardedFor;
 import akka.http.javadsl.model.headers.XRealIp;
-import akka.http.javadsl.server.Unmarshaller;
+import akka.http.javadsl.unmarshalling.Unmarshaller;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 import org.junit.Test;
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ParameterDirectivesTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ParameterDirectivesTest.java
index 7fa8a7f7f4..1084bee84e 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ParameterDirectivesTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/directives/ParameterDirectivesTest.java
@@ -12,7 +12,7 @@ import java.util.Map;
 import org.junit.Test;
 
 import akka.http.javadsl.model.HttpRequest;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 
diff --git a/akka-http-tests/src/test/java/akka/http/javadsl/server/values/FormFieldsTest.java b/akka-http-tests/src/test/java/akka/http/javadsl/server/values/FormFieldsTest.java
index a13eb5cc61..df296552f2 100644
--- a/akka-http-tests/src/test/java/akka/http/javadsl/server/values/FormFieldsTest.java
+++ b/akka-http-tests/src/test/java/akka/http/javadsl/server/values/FormFieldsTest.java
@@ -9,7 +9,7 @@ import org.junit.Test;
 import akka.http.javadsl.model.HttpCharsets;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.MediaTypes;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 import akka.japi.Pair;
diff --git a/akka-http-tests/src/test/java/docs/http/javadsl/server/HandlerExampleDocTest.java b/akka-http-tests/src/test/java/docs/http/javadsl/server/HandlerExampleDocTest.java
index cf6fea705d..219c33007b 100644
--- a/akka-http-tests/src/test/java/docs/http/javadsl/server/HandlerExampleDocTest.java
+++ b/akka-http-tests/src/test/java/docs/http/javadsl/server/HandlerExampleDocTest.java
@@ -18,7 +18,7 @@ import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.model.HttpResponse;
 import akka.http.javadsl.model.StatusCodes;
 import akka.http.javadsl.server.Route;
-import akka.http.javadsl.server.StringUnmarshallers;
+import akka.http.javadsl.unmarshalling.StringUnmarshallers;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
 
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/coding/CoderSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/coding/CoderSpec.scala
index 8142d69f7d..1663f081e1 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/coding/CoderSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/coding/CoderSpec.scala
@@ -14,7 +14,6 @@ import scala.concurrent.duration._
 import scala.concurrent.Await
 import scala.concurrent.ExecutionContext.Implicits.global
 import java.util.concurrent.ThreadLocalRandom
-import scala.util.Random
 import scala.util.control.NoStackTrace
 import org.scalatest.{ Inspectors, WordSpec }
 import akka.util.ByteString
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/IntegrationRoutingSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/IntegrationRoutingSpec.scala
index a931209d7f..223b6b2d9b 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/IntegrationRoutingSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/IntegrationRoutingSpec.scala
@@ -18,6 +18,7 @@ import scala.concurrent.Await
 private[akka] trait IntegrationRoutingSpec extends WordSpecLike with Matchers with BeforeAndAfterAll
   with Directives with RequestBuilding
   with ScalaFutures with IntegrationPatience {
+  import IntegrationRoutingSpec._
 
   implicit val system = ActorSystem(AkkaSpec.getCallerName(getClass))
   implicit val mat = ActorMaterializer()
@@ -31,8 +32,6 @@ private[akka] trait IntegrationRoutingSpec extends WordSpecLike with Matchers wi
     def ~!>(route: Route) = new Prepped(request, route)
   }
 
-  final case class Prepped(request: HttpRequest, route: Route)
-
   implicit class Checking(p: Prepped) {
     def ~!>(checking: HttpResponse ⇒ Unit) = {
       val (_, host, port) = TestUtils.temporaryServerHostnameAndPort()
@@ -47,3 +46,7 @@ private[akka] trait IntegrationRoutingSpec extends WordSpecLike with Matchers wi
   }
 
 }
+
+object IntegrationRoutingSpec {
+  final case class Prepped(request: HttpRequest, route: Route)
+}
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/TestServer.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/TestServer.scala
index ecca3305dc..25fec791f3 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/TestServer.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/TestServer.scala
@@ -4,14 +4,17 @@
 
 package akka.http.scaladsl.server
 
+import akka.NotUsed
 import akka.http.scaladsl.marshallers.xml.ScalaXmlSupport
-import akka.http.scaladsl.model.{ StatusCodes, HttpResponse }
+import akka.http.scaladsl.model.{ HttpResponse, StatusCodes }
 import akka.http.scaladsl.server.directives.Credentials
-import com.typesafe.config.{ ConfigFactory, Config }
+import com.typesafe.config.{ Config, ConfigFactory }
 import akka.actor.ActorSystem
 import akka.stream._
 import akka.stream.scaladsl._
 import akka.http.scaladsl.Http
+import akka.http.scaladsl.common.EntityStreamingSupport
+
 import scala.concurrent.duration._
 import scala.io.StdIn
 
@@ -21,10 +24,18 @@ object TestServer extends App {
     akka.log-dead-letters = off
     akka.stream.materializer.debug.fuzzing-mode = off
     """)
+
   implicit val system = ActorSystem("ServerTest", testConf)
   import system.dispatcher
   implicit val materializer = ActorMaterializer()
 
+  import spray.json.DefaultJsonProtocol._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  final case class Tweet(message: String)
+  implicit val tweetFormat = jsonFormat1(Tweet)
+
+  implicit val jsonStreaming = EntityStreamingSupport.json()
+
   import ScalaXmlSupport._
   import Directives._
 
@@ -32,7 +43,8 @@ object TestServer extends App {
     case p @ Credentials.Provided(name) if p.verify(name + "-password") ⇒ name
   }
 
-  val bindingFuture = Http().bindAndHandle({
+  // format: OFF
+  val routes = {
     get {
       path("") {
         withRequestTimeout(1.milli, _ ⇒ HttpResponse(
@@ -42,21 +54,49 @@ object TestServer extends App {
           complete(index)
         }
       } ~
-        path("secure") {
-          authenticateBasicPF("My very secure site", auth) { user ⇒
-            complete(<html><body>Hello <b>{ user }</b>. Access has been granted!</body></html>)
+      path("secure") {
+        authenticateBasicPF("My very secure site", auth) { user ⇒
+          complete(<html> <body> Hello <b>{user}</b>. Access has been granted! </body> </html>)
+        }
+      } ~
+      path("ping") {
+        complete("PONG!")
+      } ~
+      path("crash") {
+        complete(sys.error("BOOM!"))
+      } ~
+      path("tweet") {
+        complete(Tweet("Hello, world!"))
+      } ~
+      (path("tweets") & parameter('n.as[Int])) { n => 
+        get {
+          val tweets = Source.repeat(Tweet("Hello, world!")).take(n)
+          complete(tweets)
+        } ~
+        post {
+          entity(asSourceOf[Tweet]) { tweets ⇒
+            onComplete(tweets.runFold(0)({ case (acc, t) => acc + 1 })) { count => 
+              complete(s"Total tweets received: " + count)
+            }
           }
         } ~
-        path("ping") {
-          complete("PONG!")
-        } ~
-        path("crash") {
-          complete(sys.error("BOOM!"))
+        put {
+          // checking the alternative syntax also works:
+          entity(as[Source[Tweet, NotUsed]]) { tweets ⇒
+            onComplete(tweets.runFold(0)({ case (acc, t) => acc + 1 })) { count => 
+              complete(s"Total tweets received: " + count)
+            }
+          }
         }
-    } ~ pathPrefix("inner")(getFromResourceDirectory("someDir"))
-  }, interface = "localhost", port = 8080)
+      }
+    } ~ 
+    pathPrefix("inner")(getFromResourceDirectory("someDir"))
+  }
+  // format: ON
 
-  println(s"Server online at http://localhost:8080/\nPress RETURN to stop...")
+  val bindingFuture = Http().bindAndHandle(routes, interface = "0.0.0.0", port = 8080)
+
+  println(s"Server online at http://0.0.0.0:8080/\nPress RETURN to stop...")
   StdIn.readLine()
 
   bindingFuture.flatMap(_.unbind()).onComplete(_ ⇒ system.terminate())
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/HeaderDirectivesSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/HeaderDirectivesSpec.scala
index 4fe55462cc..6b636192d8 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/HeaderDirectivesSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/HeaderDirectivesSpec.scala
@@ -34,7 +34,7 @@ class HeaderDirectivesSpec extends RoutingSpec with Inside {
   }
 
   "The headerValueByType directive" should {
-    lazy val route =
+    val route =
       headerValueByType[Origin]() { origin ⇒
         complete(s"The first origin was ${origin.origins.head}")
       }
@@ -51,6 +51,16 @@ class HeaderDirectivesSpec extends RoutingSpec with Inside {
         }
       }
     }
+    "reject a request for missing header, and format it properly when header included special characters (e.g. `-`)" in {
+      val route = headerValueByType[`User-Agent`]() { agent ⇒
+        complete(s"Agent: ${agent}")
+      }
+      Get("abc") ~> route ~> check {
+        inside(rejection) {
+          case MissingHeaderRejection("User-Agent") ⇒
+        }
+      }
+    }
   }
 
   "The headerValueByName directive" should {
@@ -183,12 +193,12 @@ class HeaderDirectivesSpec extends RoutingSpec with Inside {
       val invalidOriginHeader = Origin(invalidHttpOrigin)
       Get("abc") ~> invalidOriginHeader ~> route ~> check {
         inside(rejection) {
-          case InvalidOriginRejection(invalidOrigins) ⇒ invalidOrigins shouldEqual Seq(invalidHttpOrigin)
+          case InvalidOriginRejection(allowedOrigins) ⇒ allowedOrigins shouldEqual Seq(correctOrigin)
         }
       }
       Get("abc") ~> invalidOriginHeader ~> Route.seal(route) ~> check {
         status shouldEqual StatusCodes.Forbidden
-        responseAs[String] should include(s"${invalidHttpOrigin.value}")
+        responseAs[String] should include(s"${correctOrigin.value}")
       }
     }
   }
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/MarshallingDirectivesSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/MarshallingDirectivesSpec.scala
index 50be2b4c58..fc04936353 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/MarshallingDirectivesSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/MarshallingDirectivesSpec.scala
@@ -184,7 +184,7 @@ class MarshallingDirectivesSpec extends RoutingSpec with Inside {
 
     "render JSON with UTF-8 encoding if no `Accept-Charset` request header is present" in {
       Get() ~> complete(foo) ~> check {
-        responseEntity shouldEqual HttpEntity(`application/json`, foo.toJson.prettyPrint)
+        responseEntity shouldEqual HttpEntity(`application/json`, foo.toJson.compactPrint)
       }
     }
     "reject JSON rendering if an `Accept-Charset` request header requests a non-UTF-8 encoding" in {
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/PathDirectivesSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/PathDirectivesSpec.scala
index 608f8bf37a..4f173e18e7 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/PathDirectivesSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/PathDirectivesSpec.scala
@@ -6,6 +6,7 @@ package akka.http.scaladsl.server.directives
 
 import akka.http.scaladsl.model.StatusCodes
 import akka.http.scaladsl.server._
+import org.scalactic.source.Position
 import org.scalatest.Inside
 
 class PathDirectivesSpec extends RoutingSpec with Inside {
@@ -15,83 +16,83 @@ class PathDirectivesSpec extends RoutingSpec with Inside {
 
   """path("foo")""" should {
     val test = testFor(path("foo") { echoUnmatchedPath })
-    "reject [/bar]" in test()
-    "reject [/foobar]" in test()
-    "reject [/foo/bar]" in test()
-    "accept [/foo] and clear the unmatchedPath" in test("")
-    "reject [/foo/]" in test()
+    "reject [/bar]" inThe test()
+    "reject [/foobar]" inThe test()
+    "reject [/foo/bar]" inThe test()
+    "accept [/foo] and clear the unmatchedPath" inThe test("")
+    "reject [/foo/]" inThe test()
   }
 
   """pathPrefix("")""" should {
     val test = testFor(pathPrefix("") { echoUnmatchedPath })
 
     // Should match everything because pathPrefix is used and "" is a neutral element.
-    "accept [/] and clear the unmatchedPath=" in test("")
-    "accept [/foo] and clear the unmatchedPath" in test("foo")
-    "accept [/foo/] and clear the unmatchedPath" in test("foo/")
-    "accept [/bar/] and clear the unmatchedPath" in test("bar/")
+    "accept [/] and clear the unmatchedPath=" inThe test("")
+    "accept [/foo] and clear the unmatchedPath" inThe test("foo")
+    "accept [/foo/] and clear the unmatchedPath" inThe test("foo/")
+    "accept [/bar/] and clear the unmatchedPath" inThe test("bar/")
   }
 
   """path("" | "foo")""" should {
     val test = testFor(path("" | "foo") { echoUnmatchedPath })
 
     // Should not match anything apart of "/", because path requires whole path being matched.
-    "accept [/] and clear the unmatchedPath=" in test("")
-    "reject [/foo]" in test()
-    "reject [/foo/]" in test()
-    "reject [/bar/]" in test()
+    "accept [/] and clear the unmatchedPath=" inThe test("")
+    "reject [/foo]" inThe test()
+    "reject [/foo/]" inThe test()
+    "reject [/bar/]" inThe test()
   }
 
   """path("") ~ path("foo")""" should {
     val test = testFor(path("")(echoUnmatchedPath) ~ path("foo")(echoUnmatchedPath))
 
     // Should match both because ~ operator is used for two exclusive routes.
-    "accept [/] and clear the unmatchedPath=" in test("")
-    "accept [/foo] and clear the unmatchedPath=" in test("")
+    "accept [/] and clear the unmatchedPath=" inThe test("")
+    "accept [/foo] and clear the unmatchedPath=" inThe test("")
   }
 
   """path("foo" /)""" should {
     val test = testFor(path("foo" /) { echoUnmatchedPath })
-    "reject [/foo]" in test()
-    "accept [/foo/] and clear the unmatchedPath" in test("")
+    "reject [/foo]" inThe test()
+    "accept [/foo/] and clear the unmatchedPath" inThe test("")
   }
 
   """path("")""" should {
     val test = testFor(path("") { echoUnmatchedPath })
-    "reject [/foo]" in test()
+    "reject [/foo]" inThe test()
     "accept [/] and clear the unmatchedPath" in test("")
   }
 
   """pathPrefix("foo")""" should {
     val test = testFor(pathPrefix("foo") { echoUnmatchedPath })
-    "reject [/bar]" in test()
-    "accept [/foobar]" in test("bar")
-    "accept [/foo/bar]" in test("/bar")
-    "accept [/foo] and clear the unmatchedPath" in test("")
-    "accept [/foo/] and clear the unmatchedPath" in test("/")
+    "reject [/bar]" inThe test()
+    "accept [/foobar]" inThe test("bar")
+    "accept [/foo/bar]" inThe test("/bar")
+    "accept [/foo] and clear the unmatchedPath" inThe test("")
+    "accept [/foo/] and clear the unmatchedPath" inThe test("/")
   }
 
   """pathPrefix("foo" / "bar")""" should {
     val test = testFor(pathPrefix("foo" / "bar") { echoUnmatchedPath })
-    "reject [/bar]" in test()
-    "accept [/foo/bar]" in test("")
-    "accept [/foo/bar/baz]" in test("/baz")
+    "reject [/bar]" inThe test()
+    "accept [/foo/bar]" inThe test("")
+    "accept [/foo/bar/baz]" inThe test("/baz")
   }
 
   """pathPrefix("ab[cd]+".r)""" should {
     val test = testFor(pathPrefix("ab[cd]+".r) { echoCaptureAndUnmatchedPath })
-    "reject [/bar]" in test()
-    "reject [/ab/cd]" in test()
-    "accept [/abcdef]" in test("abcd:ef")
-    "accept [/abcdd/ef]" in test("abcdd:/ef")
+    "reject [/bar]" inThe test()
+    "reject [/ab/cd]" inThe test()
+    "accept [/abcdef]" inThe test("abcd:ef")
+    "accept [/abcdd/ef]" inThe test("abcdd:/ef")
   }
 
   """pathPrefix("ab(cd)".r)""" should {
     val test = testFor(pathPrefix("ab(cd)+".r) { echoCaptureAndUnmatchedPath })
-    "reject [/bar]" in test()
-    "reject [/ab/cd]" in test()
-    "accept [/abcdef]" in test("cd:ef")
-    "accept [/abcde/fg]" in test("cd:e/fg")
+    "reject [/bar]" inThe test()
+    "reject [/ab/cd]" inThe test()
+    "accept [/abcdef]" inThe test("cd:ef")
+    "accept [/abcde/fg]" inThe test("cd:e/fg")
   }
 
   "pathPrefix(regex)" should {
@@ -102,11 +103,11 @@ class PathDirectivesSpec extends RoutingSpec with Inside {
 
   "pathPrefix(IntNumber)" should {
     val test = testFor(pathPrefix(IntNumber) { echoCaptureAndUnmatchedPath })
-    "accept [/23]" in test("23:")
-    "accept [/12345yes]" in test("12345:yes")
-    "reject [/]" in test()
-    "reject [/abc]" in test()
-    "reject [/2147483648]" in test() // > Int.MaxValue
+    "accept [/23]" inThe test("23:")
+    "accept [/12345yes]" inThe test("12345:yes")
+    "reject [/]" inThe test()
+    "reject [/abc]" inThe test()
+    "reject [/2147483648]" inThe test() // > Int.MaxValue
   }
 
   "pathPrefix(CustomShortNumber)" should {
@@ -115,200 +116,200 @@ class PathDirectivesSpec extends RoutingSpec with Inside {
     }
 
     val test = testFor(pathPrefix(CustomShortNumber) { echoCaptureAndUnmatchedPath })
-    "accept [/23]" in test("23:")
-    "accept [/12345yes]" in test("12345:yes")
-    "reject [/]" in test()
-    "reject [/abc]" in test()
-    "reject [/33000]" in test() // > Short.MaxValue
+    "accept [/23]" inThe test("23:")
+    "accept [/12345yes]" inThe test("12345:yes")
+    "reject [/]" inThe test()
+    "reject [/abc]" inThe test()
+    "reject [/33000]" inThe test() // > Short.MaxValue
   }
 
   "pathPrefix(JavaUUID)" should {
     val test = testFor(pathPrefix(JavaUUID) { echoCaptureAndUnmatchedPath })
-    "accept [/bdea8652-f26c-40ca-8157-0b96a2a8389d]" in test("bdea8652-f26c-40ca-8157-0b96a2a8389d:")
-    "accept [/bdea8652-f26c-40ca-8157-0b96a2a8389dyes]" in test("bdea8652-f26c-40ca-8157-0b96a2a8389d:yes")
-    "reject [/]" in test()
-    "reject [/abc]" in test()
+    "accept [/bdea8652-f26c-40ca-8157-0b96a2a8389d]" inThe test("bdea8652-f26c-40ca-8157-0b96a2a8389d:")
+    "accept [/bdea8652-f26c-40ca-8157-0b96a2a8389dyes]" inThe test("bdea8652-f26c-40ca-8157-0b96a2a8389d:yes")
+    "reject [/]" inThe test()
+    "reject [/abc]" inThe test()
   }
 
   "pathPrefix(Map(\"red\" -> 1, \"green\" -> 2, \"blue\" -> 3))" should {
     val test = testFor(pathPrefix(Map("red" → 1, "green" → 2, "blue" → 3)) { echoCaptureAndUnmatchedPath })
-    "accept [/green]" in test("2:")
-    "accept [/redsea]" in test("1:sea")
-    "reject [/black]" in test()
+    "accept [/green]" inThe test("2:")
+    "accept [/redsea]" inThe test("1:sea")
+    "reject [/black]" inThe test()
   }
 
   "pathPrefix(Map.empty)" should {
     val test = testFor(pathPrefix(Map[String, Int]()) { echoCaptureAndUnmatchedPath })
-    "reject [/black]" in test()
+    "reject [/black]" inThe test()
   }
 
   "pathPrefix(Segment)" should {
     val test = testFor(pathPrefix(Segment) { echoCaptureAndUnmatchedPath })
-    "accept [/abc]" in test("abc:")
-    "accept [/abc/]" in test("abc:/")
-    "accept [/abc/def]" in test("abc:/def")
-    "reject [/]" in test()
+    "accept [/abc]" inThe test("abc:")
+    "accept [/abc/]" inThe test("abc:/")
+    "accept [/abc/def]" inThe test("abc:/def")
+    "reject [/]" inThe test()
   }
 
   "pathPrefix(Segments)" should {
     val test = testFor(pathPrefix(Segments) { echoCaptureAndUnmatchedPath })
-    "accept [/]" in test("List():")
-    "accept [/a/b/c]" in test("List(a, b, c):")
-    "accept [/a/b/c/]" in test("List(a, b, c):/")
+    "accept [/]" inThe test("List():")
+    "accept [/a/b/c]" inThe test("List(a, b, c):")
+    "accept [/a/b/c/]" inThe test("List(a, b, c):/")
   }
 
   """pathPrefix(separateOnSlashes("a/b"))""" should {
     val test = testFor(pathPrefix(separateOnSlashes("a/b")) { echoUnmatchedPath })
-    "accept [/a/b]" in test("")
-    "accept [/a/b/]" in test("/")
-    "reject [/a/c]" in test()
+    "accept [/a/b]" inThe test("")
+    "accept [/a/b/]" inThe test("/")
+    "reject [/a/c]" inThe test()
   }
   """pathPrefix(separateOnSlashes("abc"))""" should {
     val test = testFor(pathPrefix(separateOnSlashes("abc")) { echoUnmatchedPath })
-    "accept [/abc]" in test("")
-    "accept [/abcdef]" in test("def")
-    "reject [/ab]" in test()
+    "accept [/abc]" inThe test("")
+    "accept [/abcdef]" inThe test("def")
+    "reject [/ab]" inThe test()
   }
 
   """pathPrefixTest("a" / Segment ~ Slash)""" should {
     val test = testFor(pathPrefixTest("a" / Segment ~ Slash) { echoCaptureAndUnmatchedPath })
-    "accept [/a/bc/]" in test("bc:/a/bc/")
-    "reject [/a/bc]" in test()
-    "reject [/a/]" in test()
+    "accept [/a/bc/]" inThe test("bc:/a/bc/")
+    "reject [/a/bc]" inThe test()
+    "reject [/a/]" inThe test()
   }
 
   """pathSuffix("edit" / Segment)""" should {
     val test = testFor(pathSuffix("edit" / Segment) { echoCaptureAndUnmatchedPath })
-    "accept [/orders/123/edit]" in test("123:/orders/")
-    "reject [/orders/123/ed]" in test()
-    "reject [/edit]" in test()
+    "accept [/orders/123/edit]" inThe test("123:/orders/")
+    "reject [/orders/123/ed]" inThe test()
+    "reject [/edit]" inThe test()
   }
 
   """pathSuffix("foo" / "bar" ~ "baz")""" should {
     val test = testFor(pathSuffix("foo" / "bar" ~ "baz") { echoUnmatchedPath })
-    "accept [/orders/barbaz/foo]" in test("/orders/")
-    "reject [/orders/bazbar/foo]" in test()
+    "accept [/orders/barbaz/foo]" inThe test("/orders/")
+    "reject [/orders/bazbar/foo]" inThe test()
   }
 
   "pathSuffixTest(Slash)" should {
     val test = testFor(pathSuffixTest(Slash) { echoUnmatchedPath })
-    "accept [/]" in test("/")
-    "accept [/foo/]" in test("/foo/")
-    "reject [/foo]" in test()
+    "accept [/]" inThe test("/")
+    "accept [/foo/]" inThe test("/foo/")
+    "reject [/foo]" inThe test()
   }
 
   """pathPrefix("foo" | "bar")""" should {
     val test = testFor(pathPrefix("foo" | "bar") { echoUnmatchedPath })
-    "accept [/foo]" in test("")
-    "accept [/foops]" in test("ps")
-    "accept [/bar]" in test("")
-    "reject [/baz]" in test()
+    "accept [/foo]" inThe test("")
+    "accept [/foops]" inThe test("ps")
+    "accept [/bar]" inThe test("")
+    "reject [/baz]" inThe test()
   }
 
   """pathSuffix(!"foo")""" should {
     val test = testFor(pathSuffix(!"foo") { echoUnmatchedPath })
-    "accept [/bar]" in test("/bar")
-    "reject [/foo]" in test()
+    "accept [/bar]" inThe test("/bar")
+    "reject [/foo]" inThe test()
   }
 
   "pathPrefix(IntNumber?)" should {
     val test = testFor(pathPrefix(IntNumber?) { echoCaptureAndUnmatchedPath })
-    "accept [/12]" in test("Some(12):")
-    "accept [/12a]" in test("Some(12):a")
-    "accept [/foo]" in test("None:foo")
+    "accept [/12]" inThe test("Some(12):")
+    "accept [/12a]" inThe test("Some(12):a")
+    "accept [/foo]" inThe test("None:foo")
   }
 
   """pathPrefix("foo"?)""" should {
     val test = testFor(pathPrefix("foo"?) { echoUnmatchedPath })
-    "accept [/foo]" in test("")
-    "accept [/fool]" in test("l")
-    "accept [/bar]" in test("bar")
+    "accept [/foo]" inThe test("")
+    "accept [/fool]" inThe test("l")
+    "accept [/bar]" inThe test("bar")
   }
 
   """pathPrefix("foo") & pathEnd""" should {
     val test = testFor((pathPrefix("foo") & pathEnd) { echoUnmatchedPath })
-    "reject [/foobar]" in test()
-    "reject [/foo/bar]" in test()
-    "accept [/foo] and clear the unmatchedPath" in test("")
-    "reject [/foo/]" in test()
+    "reject [/foobar]" inThe test()
+    "reject [/foo/bar]" inThe test()
+    "accept [/foo] and clear the unmatchedPath" inThe test("")
+    "reject [/foo/]" inThe test()
   }
 
   """pathPrefix("foo") & pathEndOrSingleSlash""" should {
     val test = testFor((pathPrefix("foo") & pathEndOrSingleSlash) { echoUnmatchedPath })
-    "reject [/foobar]" in test()
-    "reject [/foo/bar]" in test()
-    "accept [/foo] and clear the unmatchedPath" in test("")
-    "accept [/foo/] and clear the unmatchedPath" in test("")
+    "reject [/foobar]" inThe test()
+    "reject [/foo/bar]" inThe test()
+    "accept [/foo] and clear the unmatchedPath" inThe test("")
+    "accept [/foo/] and clear the unmatchedPath" inThe test("")
   }
 
   """pathPrefix(IntNumber.repeat(separator = "."))""" should {
     {
       val test = testFor(pathPrefix(IntNumber.repeat(min = 2, max = 5, separator = ".")) { echoCaptureAndUnmatchedPath })
-      "reject [/foo]" in test()
-      "reject [/1foo]" in test()
-      "reject [/1.foo]" in test()
-      "accept [/1.2foo]" in test("List(1, 2):foo")
-      "accept [/1.2.foo]" in test("List(1, 2):.foo")
-      "accept [/1.2.3foo]" in test("List(1, 2, 3):foo")
-      "accept [/1.2.3.foo]" in test("List(1, 2, 3):.foo")
-      "accept [/1.2.3.4foo]" in test("List(1, 2, 3, 4):foo")
-      "accept [/1.2.3.4.foo]" in test("List(1, 2, 3, 4):.foo")
-      "accept [/1.2.3.4.5foo]" in test("List(1, 2, 3, 4, 5):foo")
-      "accept [/1.2.3.4.5.foo]" in test("List(1, 2, 3, 4, 5):.foo")
-      "accept [/1.2.3.4.5.6foo]" in test("List(1, 2, 3, 4, 5):.6foo")
-      "accept [/1.2.3.]" in test("List(1, 2, 3):.")
-      "accept [/1.2.3/]" in test("List(1, 2, 3):/")
-      "accept [/1.2.3./]" in test("List(1, 2, 3):./")
+      "reject [/foo]" inThe test()
+      "reject [/1foo]" inThe test()
+      "reject [/1.foo]" inThe test()
+      "accept [/1.2foo]" inThe test("List(1, 2):foo")
+      "accept [/1.2.foo]" inThe test("List(1, 2):.foo")
+      "accept [/1.2.3foo]" inThe test("List(1, 2, 3):foo")
+      "accept [/1.2.3.foo]" inThe test("List(1, 2, 3):.foo")
+      "accept [/1.2.3.4foo]" inThe test("List(1, 2, 3, 4):foo")
+      "accept [/1.2.3.4.foo]" inThe test("List(1, 2, 3, 4):.foo")
+      "accept [/1.2.3.4.5foo]" inThe test("List(1, 2, 3, 4, 5):foo")
+      "accept [/1.2.3.4.5.foo]" inThe test("List(1, 2, 3, 4, 5):.foo")
+      "accept [/1.2.3.4.5.6foo]" inThe test("List(1, 2, 3, 4, 5):.6foo")
+      "accept [/1.2.3.]" inThe test("List(1, 2, 3):.")
+      "accept [/1.2.3/]" inThe test("List(1, 2, 3):/")
+      "accept [/1.2.3./]" inThe test("List(1, 2, 3):./")
     }
     {
       val test = testFor(pathPrefix(IntNumber.repeat(2, ".")) { echoCaptureAndUnmatchedPath })
-      "reject [/bar]" in test()
-      "reject [/1bar]" in test()
-      "reject [/1.bar]" in test()
-      "accept [/1.2bar]" in test("List(1, 2):bar")
-      "accept [/1.2.bar]" in test("List(1, 2):.bar")
-      "accept [/1.2.3bar]" in test("List(1, 2):.3bar")
+      "reject [/bar]" inThe test()
+      "reject [/1bar]" inThe test()
+      "reject [/1.bar]" inThe test()
+      "accept [/1.2bar]" inThe test("List(1, 2):bar")
+      "accept [/1.2.bar]" inThe test("List(1, 2):.bar")
+      "accept [/1.2.3bar]" inThe test("List(1, 2):.3bar")
     }
   }
 
   """rawPathPrefix(Slash ~ "a" / Segment ~ Slash)""" should {
     val test = testFor(rawPathPrefix(Slash ~ "a" / Segment ~ Slash) { echoCaptureAndUnmatchedPath })
-    "accept [/a/bc/]" in test("bc:")
-    "reject [/a/bc]" in test()
-    "reject [/ab/]" in test()
+    "accept [/a/bc/]" inThe test("bc:")
+    "reject [/a/bc]" inThe test()
+    "reject [/ab/]" inThe test()
   }
 
   """rawPathPrefixTest(Slash ~ "a" / Segment ~ Slash)""" should {
     val test = testFor(rawPathPrefixTest(Slash ~ "a" / Segment ~ Slash) { echoCaptureAndUnmatchedPath })
-    "accept [/a/bc/]" in test("bc:/a/bc/")
-    "reject [/a/bc]" in test()
-    "reject [/ab/]" in test()
+    "accept [/a/bc/]" inThe test("bc:/a/bc/")
+    "reject [/a/bc]" inThe test()
+    "reject [/ab/]" inThe test()
   }
 
   "PathMatchers" should {
     {
       val test = testFor(path(Remaining.tmap { case Tuple1(s) ⇒ Tuple1(s.split('-').toList) }) { echoComplete })
-      "support the hmap modifier in accept [/yes-no]" in test("List(yes, no)")
+      "support the hmap modifier in accept [/yes-no]" inThe test("List(yes, no)")
     }
     {
       val test = testFor(path(Remaining.map(_.split('-').toList)) { echoComplete })
-      "support the map modifier in accept [/yes-no]" in test("List(yes, no)")
+      "support the map modifier in accept [/yes-no]" inThe test("List(yes, no)")
     }
     {
       val test = testFor(path(Remaining.tflatMap { case Tuple1(s) ⇒ Some(s).filter("yes" ==).map(x ⇒ Tuple1(x)) }) { echoComplete })
-      "support the hflatMap modifier in accept [/yes]" in test("yes")
-      "support the hflatMap modifier in reject [/blub]" in test()
+      "support the hflatMap modifier in accept [/yes]" inThe test("yes")
+      "support the hflatMap modifier in reject [/blub]" inThe test()
     }
     {
       val test = testFor(path(Remaining.flatMap(s ⇒ Some(s).filter("yes" ==))) { echoComplete })
-      "support the flatMap modifier in accept [/yes]" in test("yes")
-      "support the flatMap modifier reject [/blub]" in test()
+      "support the flatMap modifier in accept [/yes]" inThe test("yes")
+      "support the flatMap modifier reject [/blub]" inThe test()
     }
   }
 
   implicit class WithIn(str: String) {
-    def in(f: String ⇒ Unit) = convertToWordSpecStringWrapper(str) in f(str)
-    def in(body: ⇒ Unit) = convertToWordSpecStringWrapper(str) in body
+    def inThe(f: String ⇒ Unit) = convertToWordSpecStringWrapper(str) in f(str)
+    def inThe(body: ⇒ Unit) = convertToWordSpecStringWrapper(str) in body
   }
 
   case class testFor(route: Route) {
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/RouteDirectivesSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/RouteDirectivesSpec.scala
index 26e9f65b29..df9ee7c2b5 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/RouteDirectivesSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/RouteDirectivesSpec.scala
@@ -98,10 +98,7 @@ class RouteDirectivesSpec extends FreeSpec with GenericRoutingSpec {
       import akka.http.scaladsl.model.headers.Accept
       Get().withHeaders(Accept(MediaTypes.`application/json`)) ~> route ~> check {
         responseAs[String] shouldEqual
-          """{
-            |  "name": "Ida",
-            |  "age": 83
-            |}""".stripMarginWithNewline("\n")
+          """{"name":"Ida","age":83}"""
       }
       Get().withHeaders(Accept(MediaTypes.`text/xml`)) ~> route ~> check {
         responseAs[xml.NodeSeq] shouldEqual <data><name>Ida</name><age>83</age></data>
diff --git a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/SecurityDirectivesSpec.scala b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/SecurityDirectivesSpec.scala
index 9cb6b52811..82b61d1f63 100644
--- a/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/SecurityDirectivesSpec.scala
+++ b/akka-http-tests/src/test/scala/akka/http/scaladsl/server/directives/SecurityDirectivesSpec.scala
@@ -123,7 +123,7 @@ class SecurityDirectivesSpec extends RoutingSpec {
   }
   "authentication directives" should {
     "properly stack" in {
-      val otherChallenge = HttpChallenge("MyAuth", "MyRealm2")
+      val otherChallenge = HttpChallenge("MyAuth", Some("MyRealm2"))
       val otherAuth: Directive1[String] = authenticateOrRejectWithChallenge { (cred: Option[HttpCredentials]) ⇒
         Future.successful(Left(otherChallenge))
       }
diff --git a/akka-http/src/main/java/akka/http/javadsl/server/Coder.java b/akka-http/src/main/java/akka/http/javadsl/coding/Coder.java
similarity index 96%
rename from akka-http/src/main/java/akka/http/javadsl/server/Coder.java
rename to akka-http/src/main/java/akka/http/javadsl/coding/Coder.java
index f3f45e32aa..7d2196a305 100644
--- a/akka-http/src/main/java/akka/http/javadsl/server/Coder.java
+++ b/akka-http/src/main/java/akka/http/javadsl/coding/Coder.java
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
  */
 
-package akka.http.javadsl.server;
+package akka.http.javadsl.coding;
 
 import java.util.concurrent.CompletionStage;
 
diff --git a/akka-http/src/main/java/akka/http/javadsl/server/RegexConverters.java b/akka-http/src/main/java/akka/http/javadsl/common/RegexConverters.java
similarity index 74%
rename from akka-http/src/main/java/akka/http/javadsl/server/RegexConverters.java
rename to akka-http/src/main/java/akka/http/javadsl/common/RegexConverters.java
index 6d0ff6c5b2..51bd2a24e5 100644
--- a/akka-http/src/main/java/akka/http/javadsl/server/RegexConverters.java
+++ b/akka-http/src/main/java/akka/http/javadsl/common/RegexConverters.java
@@ -1,4 +1,7 @@
-package akka.http.javadsl.server;
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http.javadsl.common;
 
 import java.util.regex.Pattern;
 
@@ -6,7 +9,7 @@ import scala.collection.Seq;
 import scala.collection.immutable.VectorBuilder;
 import scala.util.matching.Regex;
 
-public class RegexConverters {
+public final class RegexConverters {
     private static final Seq<String> empty = new VectorBuilder<String>().result();
     
     /**
diff --git a/akka-http/src/main/java/akka/http/javadsl/server/StringUnmarshallers.java b/akka-http/src/main/java/akka/http/javadsl/unmarshalling/StringUnmarshallers.java
similarity index 95%
rename from akka-http/src/main/java/akka/http/javadsl/server/StringUnmarshallers.java
rename to akka-http/src/main/java/akka/http/javadsl/unmarshalling/StringUnmarshallers.java
index af9f905cc6..4cd74b89d8 100644
--- a/akka-http/src/main/java/akka/http/javadsl/server/StringUnmarshallers.java
+++ b/akka-http/src/main/java/akka/http/javadsl/unmarshalling/StringUnmarshallers.java
@@ -1,8 +1,11 @@
-package akka.http.javadsl.server;
+/*
+ * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http.javadsl.unmarshalling;
 
 import java.util.function.Function;
 
-public class StringUnmarshallers {
+public final class StringUnmarshallers {
   /**
    * An unmarshaller that returns the input String unchanged.
    */
diff --git a/akka-http/src/main/scala/akka/http/javadsl/common/EntityStreamingSupport.scala b/akka-http/src/main/scala/akka/http/javadsl/common/EntityStreamingSupport.scala
new file mode 100644
index 0000000000..b2c461f4c8
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/javadsl/common/EntityStreamingSupport.scala
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.javadsl.common
+
+import akka.NotUsed
+import akka.http.javadsl.model.{ ContentType, ContentTypeRange }
+import akka.http.scaladsl.common
+import akka.stream.javadsl.Flow
+import akka.util.ByteString
+
+/**
+ * Entity streaming support trait allowing rendering and receiving incoming ``Source[T, _]`` from HTTP entities.
+ *
+ * See [[JsonEntityStreamingSupport]] or [[CsvEntityStreamingSupport]] for default implementations.
+ */
+abstract class EntityStreamingSupport {
+
+  /** Read-side, what content types it is able to frame and unmarshall. */
+  def supported: ContentTypeRange
+  /** Write-side, defines what Content-Type the Marshaller should offer and the final Content-Type of the response. */
+  def contentType: ContentType
+
+  /**
+   * Read-side, decode incoming framed entity.
+   * For example with an incoming JSON array, chunk it up into JSON objects contained within that array.
+   */
+  def getFramingDecoder: Flow[ByteString, ByteString, NotUsed]
+  /**
+   * Write-side, apply framing to outgoing entity stream.
+   *
+   * Most typical usage will be a variant of `Flow[ByteString].intersperse`.
+   *
+   * For example for rendering a JSON array one would return
+   * `Flow[ByteString].intersperse(ByteString("["), ByteString(","), ByteString("]"))`
+   * and for rendering a new-line separated CSV simply `Flow[ByteString].intersperse(ByteString("\n"))`.
+   */
+  def getFramingRenderer: Flow[ByteString, ByteString, NotUsed]
+
+  /**
+   * Read-side, allows changing what content types are accepted by this framing.
+   *
+   * EntityStreamingSupport traits MUST support re-configuring the accepted [[ContentTypeRange]].
+   *
+   * This is in order to support a-typical APIs which users still want to communicate with using
+   * the provided support trait. Typical examples include APIs which return valid `application/json`
+   * however advertise the content type as being `application/javascript` or vendor specific content types,
+   * which still parse correctly as JSON, CSV or something else that a provided support trait is built for.
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  def withSupported(range: ContentTypeRange): EntityStreamingSupport
+
+  /**
+   * Write-side, defines what Content-Type the Marshaller should offer and the final Content-Type of the response.
+   *
+   * EntityStreamingSupport traits MUST support re-configuring the offered [[ContentType]].
+   * This is due to the need integrating with existing systems which sometimes excpect custom Content-Types,
+   * however really are just plain JSON or something else internally (perhaps with slight extensions).
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  def withContentType(range: ContentType): EntityStreamingSupport
+
+  /**
+   * Write-side / read-side, defines if (un)marshalling should be done in parallel.
+   *
+   * This may be beneficial marshalling the bottleneck in the pipeline.
+   *
+   * See also [[parallelism]] and [[withParallelMarshalling]].
+   */
+  def parallelism: Int
+
+  /**
+   * Write-side / read-side, defines if (un)marshalling of incoming stream elements should be perserved or not.
+   *
+   * Allowing for parallel and unordered (un)marshalling often yields higher throughput and also allows avoiding
+   * head-of-line blocking if some elements are much larger than others.
+   *
+   * See also [[parallelism]] and [[withParallelMarshalling]].
+   */
+  def unordered: Boolean
+
+  /**
+   * Write-side / read-side, defines parallelism and if ordering should be preserved or not of Source element marshalling.
+   *
+   * Sometimes marshalling multiple elements at once (esp. when elements are not evenly sized, and ordering is not enforced)
+   * may yield in higher throughput.
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  def withParallelMarshalling(parallelism: Int, unordered: Boolean): EntityStreamingSupport
+
+}
+
+/**
+ * Entity streaming support, independent of used Json parsing library etc.
+ */
+object EntityStreamingSupport {
+
+  /**
+   * Default `application/json` entity streaming support.
+   *
+   * Provides framing (based on scanning the incoming dataBytes for valid JSON objects, so for example uploads using arrays or
+   * new-line separated JSON objects are all parsed correctly) and rendering of Sources as JSON Arrays.
+   * A different very popular style of returning streaming JSON is to separate JSON objects on a line-by-line basis,
+   * you can configure the support trait to do so by calling `withFramingRendererFlow`.
+   *
+   * Limits the maximum JSON object length to 8KB, if you want to increase this limit provide a value explicitly.
+   *
+   * See also <a href="https://en.wikipedia.org/wiki/JSON_Streaming">https://en.wikipedia.org/wiki/JSON_Streaming</a>
+   */
+  def json(): JsonEntityStreamingSupport = json(8 * 1024)
+  /**
+   * Default `application/json` entity streaming support.
+   *
+   * Provides framing (based on scanning the incoming dataBytes for valid JSON objects, so for example uploads using arrays or
+   * new-line separated JSON objects are all parsed correctly) and rendering of Sources as JSON Arrays.
+   * A different very popular style of returning streaming JSON is to separate JSON objects on a line-by-line basis,
+   * you can configure the support trait to do so by calling `withFramingRendererFlow`.
+   *
+   * See also <a href="https://en.wikipedia.org/wiki/JSON_Streaming">https://en.wikipedia.org/wiki/JSON_Streaming</a>
+   */
+  def json(maxObjectLength: Int): JsonEntityStreamingSupport = common.EntityStreamingSupport.json(maxObjectLength)
+
+  /**
+   * Default `text/csv(UTF-8)` entity streaming support.
+   * Provides framing and rendering of `\n` separated lines and marshalling Sources into such values.
+   *
+   * Limits the maximum line-length to 8KB, if you want to increase this limit provide a value explicitly.
+   */
+  def csv(): CsvEntityStreamingSupport = csv(8 * 1024)
+  /**
+   * Default `text/csv(UTF-8)` entity streaming support.
+   * Provides framing and rendering of `\n` separated lines and marshalling Sources into such values.
+   */
+  def csv(maxLineLength: Int): CsvEntityStreamingSupport = common.EntityStreamingSupport.csv(maxLineLength)
+}
+
+// extends Scala base, in order to get linearization right and (as we can't go into traits here, because companion object needed)
+abstract class JsonEntityStreamingSupport extends common.EntityStreamingSupport {
+  def withFramingRendererFlow(flow: Flow[ByteString, ByteString, NotUsed]): JsonEntityStreamingSupport
+}
+
+// extends Scala base, in order to get linearization right and (as we can't go into traits here, because companion object needed)
+abstract class CsvEntityStreamingSupport extends common.EntityStreamingSupport {
+  def withFramingRendererFlow(flow: Flow[ByteString, ByteString, NotUsed]): CsvEntityStreamingSupport
+}
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/Marshaller.scala b/akka-http/src/main/scala/akka/http/javadsl/marshalling/Marshaller.scala
similarity index 84%
rename from akka-http/src/main/scala/akka/http/javadsl/server/Marshaller.scala
rename to akka-http/src/main/scala/akka/http/javadsl/marshalling/Marshaller.scala
index ee53d5890d..dfd7388652 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/Marshaller.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/marshalling/Marshaller.scala
@@ -2,31 +2,21 @@
  * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
  */
 
-package akka.http.javadsl.server
+package akka.http.javadsl.marshalling
 
 import java.util.function
 
 import akka.http.impl.util.JavaMapping
+import akka.http.javadsl.model.{ ContentType, HttpHeader, HttpResponse, MediaType, RequestEntity, StatusCode }
+import akka.http.scaladsl
 import akka.http.scaladsl.marshalling
+import akka.http.scaladsl.marshalling._
+import akka.http.scaladsl.model.{ FormData, HttpCharset }
 import akka.japi.Util
+import akka.util.ByteString
 
 import scala.concurrent.ExecutionContext
-import akka.http.javadsl.model.ContentType
-import akka.http.javadsl.model.MediaType
-import akka.http.scaladsl
-import akka.http.javadsl.model.HttpEntity
-import akka.http.scaladsl.marshalling._
-import akka.http.javadsl.model.HttpResponse
-import akka.http.javadsl.model.HttpRequest
-import akka.http.javadsl.model.RequestEntity
-import akka.util.ByteString
-import akka.http.scaladsl.model.{ FormData, HttpCharset }
-import akka.http.javadsl.model.StatusCode
-import akka.http.javadsl.model.HttpHeader
-
-import scala.collection.JavaConverters._
-import akka.http.impl.util.JavaMapping.Implicits._
-
+import scala.annotation.unchecked.uncheckedVariance
 import scala.language.implicitConversions
 
 object Marshaller {
@@ -67,29 +57,29 @@ object Marshaller {
   // TODO make sure these are actually usable in a sane way
 
   def wrapEntity[A, C](f: function.BiFunction[ExecutionContext, C, A], m: Marshaller[A, RequestEntity], mediaType: MediaType): Marshaller[C, RequestEntity] = {
-    val scalaMarshaller = m.asScalaToEntityMarshaller
+    val scalaMarshaller = m.asScalaCastOutput
     fromScala(scalaMarshaller.wrapWithEC(mediaType.asScala) { ctx ⇒ c: C ⇒ f(ctx, c) }(ContentTypeOverrider.forEntity))
   }
 
   def wrapEntity[A, C, E <: RequestEntity](f: function.Function[C, A], m: Marshaller[A, E], mediaType: MediaType): Marshaller[C, RequestEntity] = {
-    val scalaMarshaller = m.asScalaToEntityMarshaller
+    val scalaMarshaller = m.asScalaCastOutput
     fromScala(scalaMarshaller.wrap(mediaType.asScala)((in: C) ⇒ f.apply(in))(ContentTypeOverrider.forEntity))
   }
 
   def entityToOKResponse[A](m: Marshaller[A, _ <: RequestEntity]): Marshaller[A, HttpResponse] = {
-    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A]()(m.asScalaToEntityMarshaller))
+    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A]()(m.asScalaCastOutput))
   }
 
   def entityToResponse[A, R <: RequestEntity](status: StatusCode, m: Marshaller[A, R]): Marshaller[A, HttpResponse] = {
-    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](status.asScala)(m.asScalaToEntityMarshaller))
+    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](status.asScala)(m.asScalaCastOutput))
   }
 
   def entityToResponse[A](status: StatusCode, headers: java.lang.Iterable[HttpHeader], m: Marshaller[A, _ <: RequestEntity]): Marshaller[A, HttpResponse] = {
-    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](status.asScala, Util.immutableSeq(headers).map(_.asScala))(m.asScalaToEntityMarshaller)) // TODO can we avoid the map() ?
+    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](status.asScala, Util.immutableSeq(headers).map(_.asScala))(m.asScalaCastOutput)) // TODO can we avoid the map() ?
   }
 
   def entityToOKResponse[A](headers: java.lang.Iterable[HttpHeader], m: Marshaller[A, _ <: RequestEntity]): Marshaller[A, HttpResponse] = {
-    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](headers = Util.immutableSeq(headers).map(_.asScala))(m.asScalaToEntityMarshaller)) // TODO avoid the map()
+    fromScala(marshalling.Marshaller.fromToEntityMarshaller[A](headers = Util.immutableSeq(headers).map(_.asScala))(m.asScalaCastOutput)) // TODO avoid the map()
   }
 
   // these are methods not varargs to avoid call site warning about unchecked type params
@@ -151,13 +141,14 @@ object Marshaller {
     m.asScala.map(_.asScala)
 }
 
-class Marshaller[A, B] private (implicit val asScala: marshalling.Marshaller[A, B]) {
+class Marshaller[-A, +B] private (implicit val asScala: marshalling.Marshaller[A, B]) {
   import Marshaller.fromScala
 
+  /** INTERNAL API: involves unsafe cast (however is very fast) */
   // TODO would be nice to not need this special case
-  def asScalaToEntityMarshaller[C]: marshalling.Marshaller[A, C] = asScala.asInstanceOf[marshalling.Marshaller[A, C]]
+  private[akka] def asScalaCastOutput[C]: marshalling.Marshaller[A, C] = asScala.asInstanceOf[marshalling.Marshaller[A, C]]
 
-  def map[C](f: function.Function[B, C]): Marshaller[A, C] = fromScala(asScala.map(f.apply))
+  def map[C](f: function.Function[B @uncheckedVariance, C]): Marshaller[A, C] = fromScala(asScala.map(f.apply))
 
-  def compose[C](f: function.Function[C, A]): Marshaller[C, B] = fromScala(asScala.compose(f.apply))
+  def compose[C](f: function.Function[C, A @uncheckedVariance]): Marshaller[C, B] = fromScala(asScala.compose(f.apply))
 }
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/Directives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/Directives.scala
index 7bc2100a2d..2f966a1a7e 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/Directives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/Directives.scala
@@ -5,11 +5,11 @@
 package akka.http.javadsl.server
 
 import akka.http.impl.util.JavaMapping
-import akka.http.javadsl.server.directives.TimeoutDirectives
+import akka.http.javadsl.server.directives.{ FramedEntityStreamingDirectives, TimeoutDirectives }
 
 import scala.annotation.varargs
 
-abstract class AllDirectives extends TimeoutDirectives
+abstract class AllDirectives extends FramedEntityStreamingDirectives
 
 /**
  * INTERNAL API
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/PathMatchers.scala b/akka-http/src/main/scala/akka/http/javadsl/server/PathMatchers.scala
index de29561079..ec3d933799 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/PathMatchers.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/PathMatchers.scala
@@ -12,7 +12,7 @@ import scala.collection.JavaConverters._
 
 import akka.http.scaladsl.server.{ PathMatcher ⇒ SPathMatcher }
 import akka.http.scaladsl.server.{ PathMatchers ⇒ SPathMatchers }
-import akka.http.javadsl.server.RegexConverters.toScala
+import akka.http.javadsl.common.RegexConverters.toScala
 
 final class PathMatchers
 
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/Rejections.scala b/akka-http/src/main/scala/akka/http/javadsl/server/Rejections.scala
index 95d2e3b011..089aa25a31 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/Rejections.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/Rejections.scala
@@ -4,9 +4,6 @@
 package akka.http.javadsl.server
 
 import akka.http.impl.util.JavaMapping
-import akka.http.javadsl.server.RoutingJavaMapping
-import akka.http.javadsl.model.ContentTypeRange
-import akka.http.scaladsl.model
 import akka.http.scaladsl.server.ContentNegotiator.Alternative
 import akka.http.scaladsl.server._
 import akka.http.javadsl.model._
@@ -110,7 +107,7 @@ trait MalformedHeaderRejection extends Rejection {
  * Signals that the request was rejected because `Origin` header value is invalid.
  */
 trait InvalidOriginRejection extends Rejection {
-  def getInvalidOrigins: java.util.List[akka.http.javadsl.model.headers.HttpOrigin]
+  def getAllowedOrigins: java.util.List[akka.http.javadsl.model.headers.HttpOrigin]
 }
 
 /**
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/RequestContext.scala b/akka-http/src/main/scala/akka/http/javadsl/server/RequestContext.scala
index 26c474f11b..9484b922e4 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/RequestContext.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/RequestContext.scala
@@ -4,23 +4,32 @@
 
 package akka.http.javadsl.server
 
+import akka.http.javadsl.marshalling.Marshaller
 import akka.http.javadsl.model.HttpRequest
 import akka.http.scaladsl.util.FastFuture._
+
 import scala.concurrent.ExecutionContextExecutor
 import akka.stream.Materializer
 import akka.event.LoggingAdapter
 import akka.http.javadsl.settings.RoutingSettings
 import akka.http.javadsl.settings.ParserSettings
 import akka.http.javadsl.model.HttpResponse
+import akka.http.javadsl.model.StatusCode
+import akka.http.javadsl.model.Uri
+import akka.http.javadsl.model.headers.Location
 import java.util.concurrent.CompletionStage
 import java.util.function.{ Function ⇒ JFunction }
+
 import akka.http.scaladsl
 import akka.http.impl.util.JavaMapping.Implicits._
 import akka.http.scaladsl.marshalling.ToResponseMarshallable
+
 import scala.compat.java8.FutureConverters._
 import scala.annotation.varargs
 import akka.http.scaladsl.model.Uri.Path
 
+import akka.http.scaladsl.marshalling.PredefinedToResponseMarshallers
+
 class RequestContext private (val delegate: scaladsl.server.RequestContext) {
   import RequestContext._
   import RoutingJavaMapping._
@@ -44,10 +53,19 @@ class RequestContext private (val delegate: scaladsl.server.RequestContext) {
       .fast.map(r ⇒ r: RouteResult)(akka.dispatch.ExecutionContexts.sameThreadExecutionContext).toJava
   }
 
+  def completeWith(response: HttpResponse): CompletionStage[RouteResult] = {
+    delegate.complete(response.asScala)
+      .fast.map(r ⇒ r: RouteResult)(akka.dispatch.ExecutionContexts.sameThreadExecutionContext).toJava
+  }
+
   @varargs def reject(rejections: Rejection*): CompletionStage[RouteResult] = {
     val scalaRejections = rejections.map(_.asScala)
     delegate.reject(scalaRejections: _*)
-      .fast.map(r ⇒ r.asJava: RouteResult)(akka.dispatch.ExecutionContexts.sameThreadExecutionContext).toJava
+      .fast.map(r ⇒ r: RouteResult)(akka.dispatch.ExecutionContexts.sameThreadExecutionContext).toJava
+  }
+
+  def redirect(uri: Uri, redirectionType: StatusCode): CompletionStage[RouteResult] = {
+    completeWith(HttpResponse.create().withStatus(redirectionType).addHeader(Location.create(uri)))
   }
 
   def fail(error: Throwable): CompletionStage[RouteResult] =
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/RoutingJavaMapping.scala b/akka-http/src/main/scala/akka/http/javadsl/server/RoutingJavaMapping.scala
index 1cb892cfd8..ebb6eeb313 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/RoutingJavaMapping.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/RoutingJavaMapping.scala
@@ -8,9 +8,13 @@ import java.util.concurrent.CompletionStage
 
 import akka.http.impl.util.JavaMapping._
 import akka.http.impl.util._
+import akka.http.javadsl.common.EntityStreamingSupport
 import akka.http.{ javadsl, scaladsl }
 import akka.http.scaladsl.server.{ directives ⇒ sdirectives }
+import akka.http.scaladsl.{ common ⇒ scommon }
 import akka.http.javadsl.server.{ directives ⇒ jdirectives }
+import akka.http.javadsl.{ common ⇒ jcommon }
+
 import scala.collection.immutable
 
 /**
@@ -43,6 +47,8 @@ private[http] object RoutingJavaMapping {
   }
   implicit object convertRouteResult extends Inherited[javadsl.server.RouteResult, scaladsl.server.RouteResult]
 
+  implicit object convertEntityStreamingSupport extends Inherited[EntityStreamingSupport, scommon.EntityStreamingSupport]
+
   implicit object convertDirectoryRenderer extends Inherited[jdirectives.DirectoryRenderer, sdirectives.FileAndResourceDirectives.DirectoryRenderer]
   implicit object convertContentTypeResolver extends Inherited[jdirectives.ContentTypeResolver, sdirectives.ContentTypeResolver]
   implicit object convertDirectoryListing extends Inherited[jdirectives.DirectoryListing, sdirectives.DirectoryListing]
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/BasicDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/BasicDirectives.scala
index 886223d662..8b61671039 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/BasicDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/BasicDirectives.scala
@@ -6,6 +6,7 @@ package akka.http.javadsl.server.directives
 
 import java.util.function.{ Function ⇒ JFunction }
 
+import akka.actor.ActorSystem
 import akka.http.impl.util.JavaMapping
 import akka.http.javadsl.settings.ParserSettings
 import akka.http.javadsl.settings.RoutingSettings
@@ -16,6 +17,7 @@ import akka.util.ByteString
 import scala.concurrent.ExecutionContextExecutor
 import akka.http.impl.model.JavaUri
 import akka.http.javadsl.model.HttpRequest
+import akka.http.javadsl.model.HttpEntity
 import akka.http.javadsl.model.RequestEntity
 import akka.http.javadsl.model.Uri
 import akka.http.javadsl.server._
@@ -38,6 +40,7 @@ import akka.event.LoggingAdapter
 import akka.http.javadsl.server
 
 import scala.compat.java8.FutureConverters._
+import scala.concurrent.duration.FiniteDuration
 
 abstract class BasicDirectives {
   import akka.http.impl.util.JavaMapping.Implicits._
@@ -198,6 +201,13 @@ abstract class BasicDirectives {
   def extractMaterializer(inner: JFunction[Materializer, Route]): Route = RouteAdapter(
     D.extractMaterializer { m ⇒ inner.apply(m).delegate })
 
+  /**
+   * Extracts the [[akka.actor.ActorSystem]] if the available Materializer is an [[akka.stream.ActorMaterializer]].
+   * Otherwise throws an exception as it won't be able to extract the system from arbitrary materializers.
+   */
+  def extractActorSystem(inner: JFunction[ActorSystem, Route]): Route = RouteAdapter(
+    D.extractActorSystem { system ⇒ inner.apply(system).delegate })
+
   /**
    * Extracts the [[ExecutionContextExecutor]] from the [[RequestContext]].
    */
@@ -283,4 +293,29 @@ abstract class BasicDirectives {
    */
   def extractRequestEntity(inner: JFunction[RequestEntity, Route]): Route = extractEntity(inner)
 
+  /**
+   * WARNING: This will read the entire request entity into memory regardless of size and effectively disable streaming.
+   *
+   * Converts the HttpEntity from the [[akka.http.javadsl.server.RequestContext]] into an
+   * [[akka.http.javadsl.model.HttpEntity.Strict]] and extracts it, or fails the route if unable to drain the
+   * entire request body within the timeout.
+   *
+   * @param timeout The directive is failed if the stream isn't completed after the given timeout.
+   */
+  def extractStrictEntity(timeout: FiniteDuration, inner: JFunction[HttpEntity.Strict, Route]): Route = RouteAdapter {
+    D.extractStrictEntity(timeout) { strict ⇒ inner.apply(strict).delegate }
+  }
+
+  /**
+   * WARNING: This will read the entire request entity into memory regardless of size and effectively disable streaming.
+   *
+   * Extracts the [[akka.http.javadsl.server.RequestContext]] itself with the strict HTTP entity,
+   * or fails the route if unable to drain the entire request body within the timeout.
+   *
+   * @param timeout The directive is failed if the stream isn't completed after the given timeout.
+   */
+  def toStrictEntity(timeout: FiniteDuration, inner: Supplier[Route]): Route = RouteAdapter {
+    D.toStrictEntity(timeout) { inner.get.delegate }
+  }
+
 }
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/CodingDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/CodingDirectives.scala
index 3765e22233..86236c7647 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/CodingDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/CodingDirectives.scala
@@ -10,6 +10,7 @@ import java.util.function.Supplier
 import scala.collection.JavaConverters._
 import akka.http.impl.util.JavaMapping.Implicits._
 import RoutingJavaMapping._
+import akka.http.javadsl.coding.Coder
 import akka.http.javadsl.model.headers.HttpEncoding
 import akka.http.javadsl.server.Route
 import akka.http.scaladsl.server.{ Directives ⇒ D }
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/DebuggingDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/DebuggingDirectives.scala
index 32865014e0..00fce2b0bf 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/DebuggingDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/DebuggingDirectives.scala
@@ -3,17 +3,16 @@
  */
 package akka.http.javadsl.server.directives
 
-import java.lang.{ Iterable ⇒ JIterable }
 import java.util.function.{ BiFunction, Supplier, Function ⇒ JFunction }
 import java.util.{ Optional, List ⇒ JList }
 
 import akka.event.Logging
 import akka.event.Logging.LogLevel
 import akka.http.javadsl.model.{ HttpRequest, HttpResponse }
-import akka.http.javadsl.server.{ Route, RoutingJavaMapping }
+import akka.http.javadsl.server.{ Rejection, Route, RoutingJavaMapping }
 import akka.http.scaladsl
 import akka.http.scaladsl.server.directives.LoggingMagnet
-import akka.http.scaladsl.server.{ Rejection, RouteResult, Directives ⇒ D }
+import akka.http.scaladsl.server.{ RouteResult, Directives ⇒ D }
 
 import scala.collection.JavaConverters._
 
@@ -72,7 +71,7 @@ abstract class DebuggingDirectives extends CookieDirectives {
     inner:         Supplier[Route]) = RouteAdapter {
     D.logResult(LoggingMagnet.forMessageFromFullShow {
       case RouteResult.Complete(response)   ⇒ showSuccess.apply(response).asScala
-      case RouteResult.Rejected(rejections) ⇒ showRejection.apply(rejections.asJava).asScala
+      case RouteResult.Rejected(rejections) ⇒ showRejection.apply(rejections.map(_.asJava).asJava).asScala
     }) {
       inner.get.delegate
     }
@@ -90,7 +89,7 @@ abstract class DebuggingDirectives extends CookieDirectives {
     inner:         Supplier[Route]) = RouteAdapter {
     D.logRequestResult(LoggingMagnet.forRequestResponseFromFullShow(request ⇒ {
       case RouteResult.Complete(response)   ⇒ Some(showSuccess.apply(request, response).asScala)
-      case RouteResult.Rejected(rejections) ⇒ Some(showRejection.apply(request, rejections.asJava).asScala)
+      case RouteResult.Rejected(rejections) ⇒ Some(showRejection.apply(request, rejections.map(_.asJava).asJava).asScala)
     })) {
       inner.get.delegate
     }
@@ -109,7 +108,7 @@ abstract class DebuggingDirectives extends CookieDirectives {
     inner:         Supplier[Route]) = RouteAdapter {
     D.logRequestResult(LoggingMagnet.forRequestResponseFromFullShow(request ⇒ {
       case RouteResult.Complete(response)   ⇒ showSuccess.apply(request, response).asScala
-      case RouteResult.Rejected(rejections) ⇒ showRejection.apply(request, rejections.asJava).asScala
+      case RouteResult.Rejected(rejections) ⇒ showRejection.apply(request, rejections.map(_.asJava).asJava).asScala
     })) {
       inner.get.delegate
     }
@@ -127,4 +126,4 @@ object LogEntry {
   def info(obj: Any): LogEntry = scaladsl.server.directives.LogEntry(obj, Logging.InfoLevel)
   def warning(obj: Any): LogEntry = scaladsl.server.directives.LogEntry(obj, Logging.WarningLevel)
   def error(obj: Any): LogEntry = scaladsl.server.directives.LogEntry(obj, Logging.ErrorLevel)
-}
\ No newline at end of file
+}
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FileAndResourceDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FileAndResourceDirectives.scala
index c2a4c8d548..4427da1db7 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FileAndResourceDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FileAndResourceDirectives.scala
@@ -6,6 +6,8 @@ package akka.http.javadsl.server.directives
 
 import java.io.File
 
+import akka.http.javadsl.marshalling.Marshaller
+
 import scala.annotation.varargs
 import scala.collection.JavaConverters._
 import akka.http.javadsl.model.ContentType
@@ -27,7 +29,7 @@ abstract class DirectoryListing {
 }
 
 trait DirectoryRenderer {
-  def directoryMarshaller(renderVanityFooter: Boolean): akka.http.javadsl.server.Marshaller[DirectoryListing, RequestEntity]
+  def directoryMarshaller(renderVanityFooter: Boolean): Marshaller[DirectoryListing, RequestEntity]
 }
 
 /**
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FormFieldDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FormFieldDirectives.scala
index 214f191c58..9fa0506950 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FormFieldDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FormFieldDirectives.scala
@@ -8,10 +8,12 @@ import java.util.AbstractMap.SimpleImmutableEntry
 import java.util.Optional
 import java.util.function.{ Function ⇒ JFunction }
 
+import akka.http.javadsl.unmarshalling.Unmarshaller
+
 import scala.collection.JavaConverters._
 import akka.http.impl.util.JavaMapping.Implicits._
 
-import akka.http.javadsl.server.{ Route, Unmarshaller }
+import akka.http.javadsl.server.Route
 
 import akka.http.scaladsl.server.{ Directives ⇒ D }
 import akka.http.scaladsl.server.directives.ParameterDirectives._
@@ -88,4 +90,4 @@ abstract class FormFieldDirectives extends FileUploadDirectives {
     }
   }
 
-}
\ No newline at end of file
+}
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FramedEntityStreamingDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FramedEntityStreamingDirectives.scala
new file mode 100644
index 0000000000..eef4a3d1f9
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FramedEntityStreamingDirectives.scala
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2009-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.http.javadsl.server.directives
+
+import java.util.function.{ Function ⇒ JFunction }
+import java.util.{ List ⇒ JList, Map ⇒ JMap }
+
+import akka.NotUsed
+import akka.http.javadsl.common.EntityStreamingSupport
+import akka.http.javadsl.marshalling.Marshaller
+import akka.http.javadsl.model.{ HttpEntity, _ }
+import akka.http.javadsl.server.Route
+import akka.http.javadsl.unmarshalling.Unmarshaller
+import akka.http.scaladsl.marshalling.{ Marshalling, ToByteStringMarshaller, ToResponseMarshallable }
+import akka.http.scaladsl.server.{ Directives ⇒ D }
+import akka.stream.javadsl.Source
+import akka.util.ByteString
+
+/** EXPERIMENTAL API */
+abstract class FramedEntityStreamingDirectives extends TimeoutDirectives {
+
+  import akka.http.javadsl.server.RoutingJavaMapping._
+  import akka.http.javadsl.server.RoutingJavaMapping.Implicits._
+
+  @CorrespondsTo("asSourceOf")
+  def entityAsSourceOf[T](um: Unmarshaller[ByteString, T], support: EntityStreamingSupport,
+                          inner: java.util.function.Function[Source[T, NotUsed], Route]): Route = RouteAdapter {
+    val umm = D.asSourceOf(um.asScala, support.asScala)
+    D.entity(umm) { s: akka.stream.scaladsl.Source[T, NotUsed] ⇒
+      inner(s.asJava).delegate
+    }
+  }
+
+  // implicits and multiple parameter lists used internally, Java caller does not benefit or use it
+  @CorrespondsTo("complete")
+  def completeWithSource[T, M](source: Source[T, M])(implicit m: Marshaller[T, ByteString], support: EntityStreamingSupport): Route = RouteAdapter {
+    import akka.http.scaladsl.marshalling.PredefinedToResponseMarshallers._
+    val mm = m.map(ByteStringAsEntityFn).asScalaCastOutput[akka.http.scaladsl.model.RequestEntity]
+    val mmm = fromEntityStreamingSupportAndEntityMarshaller[T, M](support.asScala, mm)
+    val response = ToResponseMarshallable(source.asScala)(mmm)
+    D.complete(response)
+  }
+
+  // implicits and multiple parameter lists used internally, Java caller does not benefit or use it
+  @CorrespondsTo("complete")
+  def completeOKWithSource[T, M](source: Source[T, M])(implicit m: Marshaller[T, RequestEntity], support: EntityStreamingSupport): Route = RouteAdapter {
+    import akka.http.scaladsl.marshalling.PredefinedToResponseMarshallers._
+    // don't try this at home:
+    val mm = m.asScalaCastOutput[akka.http.scaladsl.model.RequestEntity].map(_.httpEntity.asInstanceOf[akka.http.scaladsl.model.RequestEntity])
+    implicit val mmm = fromEntityStreamingSupportAndEntityMarshaller[T, M](support.asScala, mm)
+    val response = ToResponseMarshallable(source.asScala)
+    D.complete(response)
+  }
+
+  private[this] val ByteStringAsEntityFn = new java.util.function.Function[ByteString, HttpEntity]() {
+    override def apply(bs: ByteString): HttpEntity = HttpEntities.create(bs)
+  }
+}
+
+object FramedEntityStreamingDirectives extends FramedEntityStreamingDirectives
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FutureDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FutureDirectives.scala
index 8b10bba0af..f89ac51563 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/FutureDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/FutureDirectives.scala
@@ -8,12 +8,13 @@ import java.util.concurrent.CompletionStage
 import java.util.function.{ Function ⇒ JFunction }
 import java.util.function.Supplier
 
+import akka.http.javadsl.marshalling.Marshaller
 import akka.http.javadsl.model.RequestEntity
 
 import scala.compat.java8.FutureConverters._
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.util.Try
-import akka.http.javadsl.server.{ Marshaller, Route }
+import akka.http.javadsl.server.Route
 import akka.http.scaladsl.server.directives.{ CompleteOrRecoverWithMagnet, FutureDirectives ⇒ D }
 import akka.pattern.CircuitBreaker
 
@@ -22,6 +23,8 @@ abstract class FutureDirectives extends FormFieldDirectives {
   /**
    * "Unwraps" a `CompletionStage<T>` and runs the inner route after future
    * completion with the future's value as an extraction of type `Try<T>`.
+   *
+   * @group future
    */
   def onComplete[T](f: Supplier[CompletionStage[T]], inner: JFunction[Try[T], Route]) = RouteAdapter {
     D.onComplete(f.get.toScala.recover(unwrapCompletionException)) { value ⇒
@@ -29,6 +32,18 @@ abstract class FutureDirectives extends FormFieldDirectives {
     }
   }
 
+  /**
+   * "Unwraps" a `CompletionStage<T>` and runs the inner route after future
+   * completion with the future's value as an extraction of type `Try<T>`.
+   *
+   * @group future
+   */
+  def onComplete[T](cs: CompletionStage[T], inner: JFunction[Try[T], Route]) = RouteAdapter {
+    D.onComplete(cs.toScala.recover(unwrapCompletionException)) { value ⇒
+      inner(value).delegate
+    }
+  }
+
   /**
    * "Unwraps" a `CompletionStage[T]` and runs the inner route after future
    * completion with the future's value as an extraction of type `T` if
@@ -50,6 +65,8 @@ abstract class FutureDirectives extends FormFieldDirectives {
    * completion with the stage's value as an extraction of type `T`.
    * If the stage fails its failure Throwable is bubbled up to the nearest
    * ExceptionHandler.
+   *
+   * @group future
    */
   def onSuccess[T](f: Supplier[CompletionStage[T]], inner: JFunction[T, Route]) = RouteAdapter {
     D.onSuccess(f.get.toScala.recover(unwrapCompletionException)) { value ⇒
@@ -63,6 +80,8 @@ abstract class FutureDirectives extends FormFieldDirectives {
    * If the completion stage succeeds the request is completed using the values marshaller
    * (This directive therefore requires a marshaller for the completion stage value type to be
    * provided.)
+   *
+   * @group future
    */
   def completeOrRecoverWith[T](f: Supplier[CompletionStage[T]], marshaller: Marshaller[T, RequestEntity], inner: JFunction[Throwable, Route]): Route = RouteAdapter {
     val magnet = CompleteOrRecoverWithMagnet(f.get.toScala)(Marshaller.asScalaEntityMarshaller(marshaller))
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/HeaderDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/HeaderDirectives.scala
index ebc94285bb..5324b77a5e 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/HeaderDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/HeaderDirectives.scala
@@ -11,12 +11,12 @@ import akka.actor.ReflectiveDynamicAccess
 import scala.compat.java8.OptionConverters
 import scala.compat.java8.OptionConverters._
 import akka.http.impl.util.JavaMapping.Implicits._
+import akka.http.javadsl.model.headers.{ HttpOriginRange, HttpOriginRanges }
 import akka.http.javadsl.model.{ HttpHeader, StatusCodes }
-import akka.http.javadsl.model.headers.HttpOriginRange
 import akka.http.javadsl.server.{ InvalidOriginRejection, MissingHeaderRejection, Route }
+import akka.http.scaladsl.model.headers.HttpOriginRange.Default
 import akka.http.scaladsl.model.headers.{ ModeledCustomHeader, ModeledCustomHeaderCompanion, Origin }
-import akka.http.scaladsl.server.directives.{ HeaderMagnet, BasicDirectives ⇒ B, HeaderDirectives ⇒ D }
-import akka.stream.ActorMaterializer
+import akka.http.scaladsl.server.directives.{ HeaderMagnet, HeaderDirectives ⇒ D }
 
 import scala.reflect.ClassTag
 import scala.util.{ Failure, Success }
@@ -33,9 +33,16 @@ abstract class HeaderDirectives extends FutureDirectives {
    *
    * @group header
    */
-  def checkSameOrigin(allowed: HttpOriginRange, inner: jf.Supplier[Route]): Route = RouteAdapter {
-    D.checkSameOrigin(allowed.asScala) { inner.get().delegate }
-  }
+  // TODO When breaking binary compatibility this should become HttpOriginRange.Default, see https://github.com/akka/akka/pull/20776/files#r70049845
+  def checkSameOrigin(allowed: HttpOriginRange, inner: jf.Supplier[Route]): Route =
+    allowed match {
+      case HttpOriginRanges.ALL | HttpOriginRange.ALL | akka.http.scaladsl.model.headers.HttpOriginRange.`*` ⇒ pass(inner)
+      case _ ⇒ RouteAdapter {
+        // safe, we know it's not the `*` header
+        val default = allowed.asInstanceOf[akka.http.scaladsl.model.headers.HttpOriginRange.Default]
+        D.checkSameOrigin(default) { inner.get().delegate }
+      }
+    }
 
   /**
    * Extracts an HTTP header value using the given function. If the function result is undefined for all headers the
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/HostDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/HostDirectives.scala
index 6ae18a6d57..f8671551ac 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/HostDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/HostDirectives.scala
@@ -13,7 +13,7 @@ import java.util.regex.Pattern
 
 import scala.collection.JavaConverters._
 
-import akka.http.javadsl.server.RegexConverters.toScala
+import akka.http.javadsl.common.RegexConverters.toScala
 import akka.http.scaladsl.server.{ Directives ⇒ D }
 
 abstract class HostDirectives extends HeaderDirectives {
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/MarshallingDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/MarshallingDirectives.scala
index 8bad98b2d3..9abbf3c8e4 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/MarshallingDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/MarshallingDirectives.scala
@@ -6,7 +6,7 @@ package akka.http.javadsl.server.directives
 import akka.http.javadsl.model.HttpRequest
 import akka.http.javadsl.model.HttpEntity
 import akka.http.javadsl.server.Route
-import akka.http.javadsl.server.Unmarshaller
+import akka.http.javadsl.unmarshalling.Unmarshaller
 
 import akka.http.scaladsl.server.directives.{ MarshallingDirectives ⇒ D }
 
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/ParameterDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/ParameterDirectives.scala
index 25e16859c2..0833c14034 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/ParameterDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/ParameterDirectives.scala
@@ -8,10 +8,12 @@ import java.util.AbstractMap.SimpleImmutableEntry
 import java.util.Optional
 import java.util.function.{ Function ⇒ JFunction }
 
+import akka.http.javadsl.unmarshalling.Unmarshaller
+
 import scala.collection.JavaConverters._
 import scala.compat.java8.OptionConverters._
 
-import akka.http.javadsl.server.{ Route, Unmarshaller }
+import akka.http.javadsl.server.Route
 import akka.http.scaladsl.server.directives.{ ParameterDirectives ⇒ D }
 import akka.http.scaladsl.server.directives.ParameterDirectives._
 import akka.http.scaladsl.unmarshalling.PredefinedFromStringUnmarshallers._
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/PathDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/PathDirectives.scala
index 695833a593..c391148815 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/PathDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/PathDirectives.scala
@@ -7,6 +7,8 @@ import java.util.function.BiFunction
 import java.util.function.{ Function ⇒ JFunction }
 import java.util.function.Supplier
 
+import akka.http.javadsl.unmarshalling.Unmarshaller
+
 import scala.util.Failure
 import scala.util.Success
 
@@ -15,7 +17,6 @@ import akka.http.javadsl.server.PathMatcher0
 import akka.http.javadsl.server.PathMatcher1
 import akka.http.javadsl.server.PathMatcher2
 import akka.http.javadsl.server.Route
-import akka.http.javadsl.server.Unmarshaller
 import akka.http.scaladsl.model.StatusCodes.Redirection
 import akka.http.scaladsl.server.{ Directives ⇒ D }
 
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/directives/RouteDirectives.scala b/akka-http/src/main/scala/akka/http/javadsl/server/directives/RouteDirectives.scala
index 91f4a8b4dc..68eef49db8 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/directives/RouteDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/server/directives/RouteDirectives.scala
@@ -6,6 +6,7 @@ package akka.http.javadsl.server.directives
 import java.util.concurrent.CompletionStage
 
 import akka.dispatch.ExecutionContexts
+import akka.http.javadsl.marshalling.Marshaller
 import akka.http.scaladsl.server._
 import akka.japi.Util
 
@@ -18,7 +19,7 @@ import akka.http.javadsl.model.HttpResponse
 import akka.http.javadsl.model.RequestEntity
 import akka.http.javadsl.model.StatusCode
 import akka.http.javadsl.model.Uri
-import akka.http.javadsl.server.{ RoutingJavaMapping, Rejection, Marshaller, Route }
+import akka.http.javadsl.server.{ RoutingJavaMapping, Rejection, Route }
 import akka.http.scaladsl
 import akka.http.scaladsl.marshalling.Marshaller._
 import akka.http.scaladsl.marshalling.ToResponseMarshallable
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/StringUnmarshaller.scala b/akka-http/src/main/scala/akka/http/javadsl/unmarshalling/StringUnmarshaller.scala
similarity index 77%
rename from akka-http/src/main/scala/akka/http/javadsl/server/StringUnmarshaller.scala
rename to akka-http/src/main/scala/akka/http/javadsl/unmarshalling/StringUnmarshaller.scala
index c64fef0b6f..1a85b25697 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/StringUnmarshaller.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/unmarshalling/StringUnmarshaller.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
  */
 
-package akka.http.javadsl.server
+package akka.http.javadsl.unmarshalling
 
 import java.util.concurrent.CompletionStage
 
@@ -21,7 +21,7 @@ object StringUnmarshaller {
 /**
  * INTERNAL API
  */
-private[server] object StringUnmarshallerPredef extends akka.http.scaladsl.unmarshalling.PredefinedFromStringUnmarshallers {
+private[unmarshalling] object StringUnmarshallerPredef extends akka.http.scaladsl.unmarshalling.PredefinedFromStringUnmarshallers {
 
 }
 
diff --git a/akka-http/src/main/scala/akka/http/javadsl/server/Unmarshaller.scala b/akka-http/src/main/scala/akka/http/javadsl/unmarshalling/Unmarshaller.scala
similarity index 88%
rename from akka-http/src/main/scala/akka/http/javadsl/server/Unmarshaller.scala
rename to akka-http/src/main/scala/akka/http/javadsl/unmarshalling/Unmarshaller.scala
index 82dcc5ab7b..368ebe68c3 100644
--- a/akka-http/src/main/scala/akka/http/javadsl/server/Unmarshaller.scala
+++ b/akka-http/src/main/scala/akka/http/javadsl/unmarshalling/Unmarshaller.scala
@@ -2,36 +2,24 @@
  * Copyright (C) 2009-2016 Lightbend Inc. <http://www.lightbend.com>
  */
 
-package akka.http.javadsl.server
+package akka.http.javadsl.unmarshalling
 
-import akka.http.impl.util.JavaMapping
-import akka.http.javadsl.server.RoutingJavaMapping
-import akka.http.scaladsl.marshalling._
-import akka.http.scaladsl.unmarshalling.{ FromEntityUnmarshaller, FromRequestUnmarshaller }
-import akka.http.scaladsl.unmarshalling.Unmarshaller.{ EnhancedFromEntityUnmarshaller, EnhancedUnmarshaller, UnsupportedContentTypeException }
-import akka.http.scaladsl.{ marshalling, model, unmarshalling }
-import akka.util.ByteString
-import akka.http.scaladsl.util.FastFuture
-import akka.http.scaladsl.util.FastFuture._
-
-import scala.concurrent.ExecutionContext
-import scala.annotation.varargs
-import akka.http.javadsl.model.HttpEntity
-import akka.http.scaladsl.model.{ ContentTypeRange, ContentTypes, FormData, Multipart }
-import akka.http.scaladsl
-import akka.http.javadsl.model.ContentType
-import akka.http.javadsl.model.HttpRequest
-import akka.http.javadsl.model.RequestEntity
-import akka.http.javadsl.model.MediaType
 import java.util.concurrent.CompletionStage
 
-import scala.compat.java8.FutureConverters._
-import scala.collection.JavaConverters._
+import akka.http.impl.util.JavaMapping
 import akka.http.impl.util.JavaMapping.Implicits._
-import RoutingJavaMapping._
+import akka.http.javadsl.model.{ HttpEntity, HttpRequest, MediaType, RequestEntity }
+import akka.http.scaladsl.model.{ ContentTypeRange, ContentTypes, FormData, Multipart }
+import akka.http.scaladsl.unmarshalling
+import akka.http.scaladsl.unmarshalling.FromEntityUnmarshaller
+import akka.http.scaladsl.unmarshalling.Unmarshaller.{ EnhancedFromEntityUnmarshaller, UnsupportedContentTypeException }
 import akka.http.scaladsl.util.FastFuture
 import akka.stream.Materializer
+import akka.util.ByteString
 
+import scala.collection.JavaConverters._
+import scala.compat.java8.FutureConverters._
+import scala.concurrent.ExecutionContext
 import scala.language.implicitConversions
 
 object Unmarshaller {
@@ -113,6 +101,9 @@ abstract class Unmarshaller[-A, B] extends UnmarshallerBase[A, B] {
 
   implicit def asScala: akka.http.scaladsl.unmarshalling.Unmarshaller[A, B]
 
+  /** INTERNAL API */
+  private[akka] def asScalaCastInput[I]: unmarshalling.Unmarshaller[I, B] = asScala.asInstanceOf[unmarshalling.Unmarshaller[I, B]]
+
   def unmarshall(a: A, ec: ExecutionContext, mat: Materializer): CompletionStage[B] = asScala.apply(a)(ec, mat).toJava
 
   /**
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/common/CsvEntityStreamingSupport.scala b/akka-http/src/main/scala/akka/http/scaladsl/common/CsvEntityStreamingSupport.scala
new file mode 100644
index 0000000000..536a86f003
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/scaladsl/common/CsvEntityStreamingSupport.scala
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.scaladsl.common
+
+import akka.NotUsed
+import akka.event.Logging
+import akka.http.javadsl.{ common, model ⇒ jm }
+import akka.http.scaladsl.model.{ ContentType, ContentTypeRange, ContentTypes }
+import akka.stream.scaladsl.{ Flow, Framing }
+import akka.util.ByteString
+
+final class CsvEntityStreamingSupport private[akka] (
+  maxLineLength:       Int,
+  val supported:       ContentTypeRange,
+  val contentType:     ContentType,
+  val framingRenderer: Flow[ByteString, ByteString, NotUsed],
+  val parallelism:     Int,
+  val unordered:       Boolean
+) extends common.CsvEntityStreamingSupport {
+  import akka.http.impl.util.JavaMapping.Implicits._
+
+  def this(maxObjectSize: Int) =
+    this(
+      maxObjectSize,
+      ContentTypeRange(ContentTypes.`text/csv(UTF-8)`),
+      ContentTypes.`text/csv(UTF-8)`,
+      Flow[ByteString].intersperse(ByteString("\n")),
+      1, false)
+
+  override val framingDecoder: Flow[ByteString, ByteString, NotUsed] =
+    Framing.delimiter(ByteString("\n"), maxLineLength)
+
+  override def withFramingRendererFlow(framingRendererFlow: akka.stream.javadsl.Flow[ByteString, ByteString, NotUsed]): CsvEntityStreamingSupport =
+    withFramingRenderer(framingRendererFlow.asScala)
+  def withFramingRenderer(framingRendererFlow: Flow[ByteString, ByteString, NotUsed]): CsvEntityStreamingSupport =
+    new CsvEntityStreamingSupport(maxLineLength, supported, contentType, framingRendererFlow, parallelism, unordered)
+
+  override def withContentType(ct: jm.ContentType): CsvEntityStreamingSupport =
+    new CsvEntityStreamingSupport(maxLineLength, supported, ct.asScala, framingRenderer, parallelism, unordered)
+  override def withSupported(range: jm.ContentTypeRange): CsvEntityStreamingSupport =
+    new CsvEntityStreamingSupport(maxLineLength, range.asScala, contentType, framingRenderer, parallelism, unordered)
+  override def withParallelMarshalling(parallelism: Int, unordered: Boolean): CsvEntityStreamingSupport =
+    new CsvEntityStreamingSupport(maxLineLength, supported, contentType, framingRenderer, parallelism, unordered)
+
+  override def toString = s"""${Logging.simpleName(getClass)}($maxLineLength, $supported, $contentType)"""
+}
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/common/EntityStreamingSupport.scala b/akka-http/src/main/scala/akka/http/scaladsl/common/EntityStreamingSupport.scala
new file mode 100644
index 0000000000..aea219666f
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/scaladsl/common/EntityStreamingSupport.scala
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.http.scaladsl.common
+
+import akka.NotUsed
+import akka.http.javadsl.{ common, model ⇒ jm }
+import akka.http.scaladsl.model._
+import akka.stream.scaladsl.Flow
+import akka.util.ByteString
+
+/**
+ * Entity streaming support trait allowing rendering and receiving incoming ``Source[T, _]`` from HTTP entities.
+ *
+ * See [[JsonEntityStreamingSupport]] or [[CsvEntityStreamingSupport]] for default implementations.
+ */
+abstract class EntityStreamingSupport extends common.EntityStreamingSupport {
+  /** Read-side, what content types it is able to frame and unmarshall. */
+  def supported: ContentTypeRange
+  /** Write-side, defines what Content-Type the Marshaller should offer and the final Content-Type of the response. */
+  def contentType: ContentType
+
+  /**
+   * Read-side, decode incoming framed entity.
+   * For example with an incoming JSON array, chunk it up into JSON objects contained within that array.
+   */
+  def framingDecoder: Flow[ByteString, ByteString, NotUsed]
+  override final def getFramingDecoder = framingDecoder.asJava
+
+  /**
+   * Write-side, apply framing to outgoing entity stream.
+   *
+   * Most typical usage will be a variant of `Flow[ByteString].intersperse`.
+   *
+   * For example for rendering a JSON array one would return
+   * `Flow[ByteString].intersperse(ByteString("["), ByteString(","), ByteString("]"))`
+   * and for rendering a new-line separated CSV simply `Flow[ByteString].intersperse(ByteString("\n"))`.
+   */
+  def framingRenderer: Flow[ByteString, ByteString, NotUsed]
+  override final def getFramingRenderer = framingRenderer.asJava
+
+  /**
+   * Read-side, allows changing what content types are accepted by this framing.
+   *
+   * EntityStreamingSupport traits MUST support re-configuring the accepted [[ContentTypeRange]].
+   *
+   * This is in order to support a-typical APIs which users still want to communicate with using
+   * the provided support trait. Typical examples include APIs which return valid `application/json`
+   * however advertise the content type as being `application/javascript` or vendor specific content types,
+   * which still parse correctly as JSON, CSV or something else that a provided support trait is built for.
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  override def withSupported(range: jm.ContentTypeRange): EntityStreamingSupport
+
+  /**
+   * Write-side, defines what Content-Type the Marshaller should offer and the final Content-Type of the response.
+   *
+   * EntityStreamingSupport traits MUST support re-configuring the offered [[ContentType]].
+   * This is due to the need integrating with existing systems which sometimes excpect custom Content-Types,
+   * however really are just plain JSON or something else internally (perhaps with slight extensions).
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  override def withContentType(range: jm.ContentType): EntityStreamingSupport
+
+  /**
+   * Write-side / read-side, defines if (un)marshalling should be done in parallel.
+   *
+   * This may be beneficial marshalling the bottleneck in the pipeline.
+   *
+   * See also [[parallelism]] and [[withParallelMarshalling]].
+   */
+  def parallelism: Int
+
+  /**
+   * Write-side / read-side, defines if (un)marshalling of incoming stream elements should be perserved or not.
+   *
+   * Allowing for parallel and unordered (un)marshalling often yields higher throughput and also allows avoiding
+   * head-of-line blocking if some elements are much larger than others.
+   *
+   * See also [[parallelism]] and [[withParallelMarshalling]].
+   */
+  def unordered: Boolean
+
+  /**
+   * Write-side / read-side, defines parallelism and if ordering should be preserved or not of Source element marshalling.
+   *
+   * Sometimes marshalling multiple elements at once (esp. when elements are not evenly sized, and ordering is not enforced)
+   * may yield in higher throughput.
+   *
+   * NOTE: Implementations should specialize the return type to their own Type!
+   */
+  def withParallelMarshalling(parallelism: Int, unordered: Boolean): EntityStreamingSupport
+
+}
+
+/**
+ * Entity streaming support, independent of used Json parsing library etc.
+ */
+object EntityStreamingSupport {
+
+  /**
+   * Default `application/json` entity streaming support.
+   *
+   * Provides framing (based on scanning the incoming dataBytes for valid JSON objects, so for example uploads using arrays or
+   * new-line separated JSON objects are all parsed correctly) and rendering of Sources as JSON Arrays.
+   * A different very popular style of returning streaming JSON is to separate JSON objects on a line-by-line basis,
+   * you can configure the support trait to do so by calling `withFramingRendererFlow`.
+   *
+   * Limits the maximum JSON object length to 8KB, if you want to increase this limit provide a value explicitly.
+   *
+   * See also <a href="https://en.wikipedia.org/wiki/JSON_Streaming">https://en.wikipedia.org/wiki/JSON_Streaming</a>
+   */
+  def json(): JsonEntityStreamingSupport = json(8 * 1024)
+  /**
+   * Default `application/json` entity streaming support.
+   *
+   * Provides framing (based on scanning the incoming dataBytes for valid JSON objects, so for example uploads using arrays or
+   * new-line separated JSON objects are all parsed correctly) and rendering of Sources as JSON Arrays.
+   * A different very popular style of returning streaming JSON is to separate JSON objects on a line-by-line basis,
+   * you can configure the support trait to do so by calling `withFramingRendererFlow`.
+   *
+   * See also <a href="https://en.wikipedia.org/wiki/JSON_Streaming">https://en.wikipedia.org/wiki/JSON_Streaming</a>
+   */
+  def json(maxObjectLength: Int): JsonEntityStreamingSupport = new JsonEntityStreamingSupport(maxObjectLength)
+
+  /**
+   * Default `text/csv(UTF-8)` entity streaming support.
+   * Provides framing and rendering of `\n` separated lines and marshalling Sources into such values.
+   *
+   * Limits the maximum line-length to 8KB, if you want to increase this limit provide a value explicitly.
+   */
+  def csv(): CsvEntityStreamingSupport = csv(8 * 1024)
+  /**
+   * Default `text/csv(UTF-8)` entity streaming support.
+   * Provides framing and rendering of `\n` separated lines and marshalling Sources into such values.
+   */
+  def csv(maxLineLength: Int): CsvEntityStreamingSupport = new CsvEntityStreamingSupport(maxLineLength)
+}
+
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/common/JsonEntityStreamingSupport.scala b/akka-http/src/main/scala/akka/http/scaladsl/common/JsonEntityStreamingSupport.scala
new file mode 100644
index 0000000000..743f5fd8aa
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/scaladsl/common/JsonEntityStreamingSupport.scala
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package akka.http.scaladsl.common
+
+import akka.NotUsed
+import akka.event.Logging
+import akka.http.javadsl.{ common, model ⇒ jm }
+import akka.http.scaladsl.model.{ ContentType, ContentTypeRange, ContentTypes }
+import akka.stream.scaladsl.Flow
+import akka.util.ByteString
+
+final class JsonEntityStreamingSupport private[akka] (
+  maxObjectSize:       Int,
+  val supported:       ContentTypeRange,
+  val contentType:     ContentType,
+  val framingRenderer: Flow[ByteString, ByteString, NotUsed],
+  val parallelism:     Int,
+  val unordered:       Boolean
+) extends common.JsonEntityStreamingSupport {
+  import akka.http.impl.util.JavaMapping.Implicits._
+
+  def this(maxObjectSize: Int) =
+    this(
+      maxObjectSize,
+      ContentTypeRange(ContentTypes.`application/json`),
+      ContentTypes.`application/json`,
+      Flow[ByteString].intersperse(ByteString("["), ByteString(","), ByteString("]")),
+      1, false)
+
+  override val framingDecoder: Flow[ByteString, ByteString, NotUsed] =
+    akka.stream.scaladsl.JsonFraming.objectScanner(maxObjectSize)
+
+  override def withFramingRendererFlow(framingRendererFlow: akka.stream.javadsl.Flow[ByteString, ByteString, NotUsed]): JsonEntityStreamingSupport =
+    withFramingRenderer(framingRendererFlow.asScala)
+  def withFramingRenderer(framingRendererFlow: Flow[ByteString, ByteString, NotUsed]): JsonEntityStreamingSupport =
+    new JsonEntityStreamingSupport(maxObjectSize, supported, contentType, framingRendererFlow, parallelism, unordered)
+
+  override def withContentType(ct: jm.ContentType): JsonEntityStreamingSupport =
+    new JsonEntityStreamingSupport(maxObjectSize, supported, ct.asScala, framingRenderer, parallelism, unordered)
+  override def withSupported(range: jm.ContentTypeRange): JsonEntityStreamingSupport =
+    new JsonEntityStreamingSupport(maxObjectSize, range.asScala, contentType, framingRenderer, parallelism, unordered)
+  override def withParallelMarshalling(parallelism: Int, unordered: Boolean): JsonEntityStreamingSupport =
+    new JsonEntityStreamingSupport(maxObjectSize, supported, contentType, framingRenderer, parallelism, unordered)
+
+  override def toString = s"""${Logging.simpleName(getClass)}($maxObjectSize, $supported, $contentType)"""
+
+}
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/common/StrictForm.scala b/akka-http/src/main/scala/akka/http/scaladsl/common/StrictForm.scala
index 124746ccd5..f6a5d35206 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/common/StrictForm.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/common/StrictForm.scala
@@ -61,8 +61,9 @@ object StrictForm {
           fsu(value.entity.data.decodeString(charsetName))
       })
 
-    @implicitNotFound("In order to unmarshal a `StrictForm.Field` to type `${T}` you need to supply a " +
-      "`FromStringUnmarshaller[${T}]` and/or a `FromEntityUnmarshaller[${T}]`")
+    @implicitNotFound(msg =
+      s"In order to unmarshal a `StrictForm.Field` to type `$${T}` you need to supply a " +
+        s"`FromStringUnmarshaller[$${T}]` and/or a `FromEntityUnmarshaller[$${T}]`")
     sealed trait FieldUnmarshaller[T] {
       def unmarshalString(value: String)(implicit ec: ExecutionContext, mat: Materializer): Future[T]
       def unmarshalPart(value: Multipart.FormData.BodyPart.Strict)(implicit ec: ExecutionContext, mat: Materializer): Future[T]
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/Marshaller.scala b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/Marshaller.scala
index 81c0290448..6606ff9f37 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/Marshaller.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/Marshaller.scala
@@ -4,7 +4,9 @@
 
 package akka.http.scaladsl.marshalling
 
-import scala.concurrent.{ Future, ExecutionContext }
+import akka.http.scaladsl.marshalling.Marshalling.Opaque
+
+import scala.concurrent.{ ExecutionContext, Future }
 import scala.util.control.NonFatal
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.util.FastFuture
@@ -174,4 +176,4 @@ object Marshalling {
     def map[B](f: A ⇒ B): Opaque[B] = copy(marshal = () ⇒ f(marshal()))
   }
 }
-//#
\ No newline at end of file
+//#
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/PredefinedToResponseMarshallers.scala b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/PredefinedToResponseMarshallers.scala
index 62777103a2..35bc19f3d0 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/PredefinedToResponseMarshallers.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/PredefinedToResponseMarshallers.scala
@@ -4,12 +4,19 @@
 
 package akka.http.scaladsl.marshalling
 
+import akka.http.scaladsl.common.EntityStreamingSupport
 import akka.stream.impl.ConstantFun
 
 import scala.collection.immutable
 import akka.http.scaladsl.util.FastFuture._
 import akka.http.scaladsl.model.MediaTypes._
 import akka.http.scaladsl.model._
+import akka.http.scaladsl.server.ContentNegotiator
+import akka.http.scaladsl.util.FastFuture
+import akka.stream.scaladsl.Source
+import akka.util.ByteString
+
+import scala.language.higherKinds
 
 trait PredefinedToResponseMarshallers extends LowPriorityToResponseMarshallerImplicits {
 
@@ -41,6 +48,37 @@ trait PredefinedToResponseMarshallers extends LowPriorityToResponseMarshallerImp
     Marshaller(implicit ec ⇒ {
       case (status, headers, value) ⇒ mt(value).fast map (_ map (_ map (HttpResponse(status, headers, _))))
     })
+
+  implicit def fromEntityStreamingSupportAndByteStringMarshaller[T, M](implicit s: EntityStreamingSupport, m: ToByteStringMarshaller[T]): ToResponseMarshaller[Source[T, M]] = {
+    Marshaller[Source[T, M], HttpResponse] { implicit ec ⇒ source ⇒
+      FastFuture successful {
+        Marshalling.WithFixedContentType(s.contentType, () ⇒ {
+          val availableMarshallingsPerElement = source.mapAsync(1) { t ⇒ m(t)(ec) }
+
+          // TODO optimise such that we pick the optimal marshalling only once (headAndTail needed?)
+          // TODO, NOTE: this is somewhat duplicated from Marshal.scala it could be made DRYer
+          val bestMarshallingPerElement = availableMarshallingsPerElement mapConcat { marshallings ⇒
+            // pick the Marshalling that matches our EntityStreamingSupport
+            (s.contentType match {
+              case best @ (_: ContentType.Binary | _: ContentType.WithFixedCharset) ⇒
+                marshallings collectFirst { case Marshalling.WithFixedContentType(`best`, marshal) ⇒ marshal }
+
+              case best @ ContentType.WithCharset(bestMT, bestCS) ⇒
+                marshallings collectFirst {
+                  case Marshalling.WithFixedContentType(`best`, marshal) ⇒ marshal
+                  case Marshalling.WithOpenCharset(`bestMT`, marshal)    ⇒ () ⇒ marshal(bestCS)
+                }
+            }).toList
+          }
+          val marshalledElements: Source[ByteString, M] =
+            bestMarshallingPerElement.map(_.apply()) // marshal!
+              .via(s.framingRenderer)
+
+          HttpResponse(entity = HttpEntity(s.contentType, marshalledElements))
+        }) :: Nil
+      }
+    }
+  }
 }
 
 trait LowPriorityToResponseMarshallerImplicits {
@@ -48,6 +86,40 @@ trait LowPriorityToResponseMarshallerImplicits {
     liftMarshaller(m)
   implicit def liftMarshaller[T](implicit m: ToEntityMarshaller[T]): ToResponseMarshaller[T] =
     PredefinedToResponseMarshallers.fromToEntityMarshaller()
+
+  // FIXME deduplicate this!!!
+  implicit def fromEntityStreamingSupportAndEntityMarshaller[T, M](implicit s: EntityStreamingSupport, m: ToEntityMarshaller[T]): ToResponseMarshaller[Source[T, M]] = {
+    Marshaller[Source[T, M], HttpResponse] { implicit ec ⇒ source ⇒
+      FastFuture successful {
+        Marshalling.WithFixedContentType(s.contentType, () ⇒ {
+          val availableMarshallingsPerElement = source.mapAsync(1) { t ⇒ m(t)(ec) }
+
+          // TODO optimise such that we pick the optimal marshalling only once (headAndTail needed?)
+          // TODO, NOTE: this is somewhat duplicated from Marshal.scala it could be made DRYer
+          val bestMarshallingPerElement = availableMarshallingsPerElement mapConcat { marshallings ⇒
+            // pick the Marshalling that matches our EntityStreamingSupport
+            (s.contentType match {
+              case best @ (_: ContentType.Binary | _: ContentType.WithFixedCharset) ⇒
+                marshallings collectFirst { case Marshalling.WithFixedContentType(`best`, marshal) ⇒ marshal }
+
+              case best @ ContentType.WithCharset(bestMT, bestCS) ⇒
+                marshallings collectFirst {
+                  case Marshalling.WithFixedContentType(`best`, marshal) ⇒ marshal
+                  case Marshalling.WithOpenCharset(`bestMT`, marshal)    ⇒ () ⇒ marshal(bestCS)
+                }
+            }).toList
+          }
+          val marshalledElements: Source[ByteString, M] =
+            bestMarshallingPerElement.map(_.apply()) // marshal!
+              .flatMapConcat(_.dataBytes) // extract raw dataBytes
+              .via(s.framingRenderer)
+
+          HttpResponse(entity = HttpEntity(s.contentType, marshalledElements))
+        }) :: Nil
+      }
+    }
+  }
+
 }
 
 object PredefinedToResponseMarshallers extends PredefinedToResponseMarshallers
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/package.scala b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/package.scala
index a6a8748e97..c1935887e0 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/marshalling/package.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/marshalling/package.scala
@@ -6,10 +6,12 @@ package akka.http.scaladsl
 
 import scala.collection.immutable
 import akka.http.scaladsl.model._
+import akka.util.ByteString
 
 package object marshalling {
   //# marshaller-aliases
   type ToEntityMarshaller[T] = Marshaller[T, MessageEntity]
+  type ToByteStringMarshaller[T] = Marshaller[T, ByteString]
   type ToHeadersAndEntityMarshaller[T] = Marshaller[T, (immutable.Seq[HttpHeader], MessageEntity)]
   type ToResponseMarshaller[T] = Marshaller[T, HttpResponse]
   type ToRequestMarshaller[T] = Marshaller[T, HttpRequest]
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/Directives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/Directives.scala
index b92bb8d97a..489ea7375a 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/Directives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/Directives.scala
@@ -36,5 +36,6 @@ trait Directives extends RouteConcatenation
   with SchemeDirectives
   with SecurityDirectives
   with WebSocketDirectives
+  with FramedEntityStreamingDirectives
 
 object Directives extends Directives
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/Rejection.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/Rejection.scala
index 7a2a266dca..eb912fc931 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/Rejection.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/Rejection.scala
@@ -98,9 +98,9 @@ final case class MalformedHeaderRejection(headerName: String, errorMsg: String,
  * Rejection created by [[akka.http.scaladsl.server.directives.HeaderDirectives.checkSameOrigin]].
  * Signals that the request was rejected because `Origin` header value is invalid.
  */
-final case class InvalidOriginRejection(invalidOrigins: immutable.Seq[SHttpOrigin])
+final case class InvalidOriginRejection(allowedOrigins: immutable.Seq[SHttpOrigin])
   extends jserver.InvalidOriginRejection with Rejection {
-  override def getInvalidOrigins: java.util.List[JHttpOrigin] = invalidOrigins.map(_.asJava).asJava
+  override def getAllowedOrigins: java.util.List[JHttpOrigin] = allowedOrigins.map(_.asJava).asJava
 }
 
 /**
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/RejectionHandler.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/RejectionHandler.scala
index acdb5715af..bc6c6a451f 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/RejectionHandler.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/RejectionHandler.scala
@@ -122,9 +122,9 @@ object RejectionHandler {
   import Directives._
 
   /**
-   * Creates a new default [[RejectionHandler]] instance.
+   * Default [[RejectionHandler]] instance.
    */
-  def default =
+  final val default =
     newBuilder()
       .handleAll[SchemeRejection] { rejections ⇒
         val schemes = rejections.map(_.supported).mkString(", ")
@@ -167,8 +167,8 @@ object RejectionHandler {
           complete((BadRequest, "Request is missing required HTTP header '" + headerName + '\''))
       }
       .handle {
-        case InvalidOriginRejection(invalidOrigin) ⇒
-          complete((Forbidden, s"Invalid `Origin` header values: ${invalidOrigin.mkString(", ")}"))
+        case InvalidOriginRejection(allowedOrigins) ⇒
+          complete((Forbidden, s"Allowed `Origin` header values: ${allowedOrigins.mkString(", ")}"))
       }
       .handle {
         case MissingQueryParamRejection(paramName) ⇒
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContext.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContext.scala
index 37e3855cbf..587175c5c3 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContext.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContext.scala
@@ -8,7 +8,9 @@ import scala.concurrent.{ Future, ExecutionContextExecutor }
 import akka.stream.Materializer
 import akka.event.LoggingAdapter
 import akka.http.scaladsl.marshalling.ToResponseMarshallable
+
 import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.StatusCodes._
 import akka.http.scaladsl.settings.{ RoutingSettings, ParserSettings }
 
 /**
@@ -67,6 +69,12 @@ trait RequestContext {
    */
   def reject(rejections: Rejection*): Future[RouteResult]
 
+  /**
+   * Completes the request with redirection response of the given type to the given URI.
+   *
+   */
+  def redirect(uri: Uri, redirectionType: Redirection): Future[RouteResult]
+
   /**
    * Bubbles the given error up the response chain where it is dealt with by the closest `handleExceptions`
    * directive and its `ExceptionHandler`, unless the error is a `RejectionError`. In this case the
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContextImpl.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContextImpl.scala
index c1c008647f..2c31625dbf 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContextImpl.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/RequestContextImpl.scala
@@ -10,6 +10,7 @@ import akka.event.LoggingAdapter
 import akka.http.scaladsl.settings.{ ParserSettings, RoutingSettings }
 import akka.http.scaladsl.marshalling.{ Marshal, ToResponseMarshallable }
 import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.StatusCodes._
 import akka.http.scaladsl.util.FastFuture
 import akka.http.scaladsl.util.FastFuture._
 
@@ -47,6 +48,18 @@ private[http] class RequestContextImpl(
   override def reject(rejections: Rejection*): Future[RouteResult] =
     FastFuture.successful(RouteResult.Rejected(rejections.toList))
 
+  override def redirect(uri: Uri, redirectionType: Redirection): Future[RouteResult] = {
+    //# red-impl
+    complete(HttpResponse(
+      status = redirectionType,
+      headers = headers.Location(uri) :: Nil,
+      entity = redirectionType.htmlTemplate match {
+        case ""       ⇒ HttpEntity.Empty
+        case template ⇒ HttpEntity(ContentTypes.`text/html(UTF-8)`, template format uri)
+      }))
+    //#
+  }
+
   override def fail(error: Throwable): Future[RouteResult] =
     FastFuture.failed(error)
 
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
index 1b5d4fcecc..bb077365d3 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/BasicDirectives.scala
@@ -5,19 +5,24 @@
 package akka.http.scaladsl.server
 package directives
 
+import akka.actor.ActorSystem
 import akka.stream.scaladsl.Source
 import akka.util.ByteString
 
+import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ Future, ExecutionContextExecutor }
 import scala.collection.immutable
 import akka.event.LoggingAdapter
-import akka.stream.Materializer
+import akka.stream.impl.ConstantFun.scalaIdentityFunction
+import akka.stream.{ ActorMaterializerHelper, Materializer }
 import akka.http.scaladsl.settings.{ RoutingSettings, ParserSettings }
 import akka.http.scaladsl.server.util.Tuple
 import akka.http.scaladsl.util.FastFuture
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.util.FastFuture._
 
+import scala.util.{ Failure, Success }
+
 /**
  * @groupname basic Basic directives
  * @groupprio basic 10
@@ -233,6 +238,16 @@ trait BasicDirectives {
    */
   def extractMaterializer: Directive1[Materializer] = BasicDirectives._extractMaterializer
 
+  /**
+   * Extracts the [[akka.actor.ActorSystem]] if the available Materializer is an [[akka.stream.ActorMaterializer]].
+   * Otherwise throws an exception as it won't be able to extract the system from arbitrary materializers.
+   *
+   * @group basic
+   */
+  def extractActorSystem: Directive1[ActorSystem] = extract { ctx ⇒
+    ActorMaterializerHelper.downcast(ctx.materializer).system
+  }
+
   /**
    * Runs its inner route with the given alternative [[akka.event.LoggingAdapter]].
    *
@@ -301,6 +316,51 @@ trait BasicDirectives {
    * @group basic
    */
   def extractDataBytes: Directive1[Source[ByteString, Any]] = BasicDirectives._extractDataBytes
+
+  /**
+   * WARNING: This will read the entire request entity into memory regardless of size and effectively disable streaming.
+   *
+   * Converts the HttpEntity from the [[akka.http.scaladsl.server.RequestContext]] into an
+   * [[akka.http.scaladsl.model.HttpEntity.Strict]] and extracts it, or fails the route if unable to drain the
+   * entire request body within the timeout.
+   *
+   * @param timeout The directive is failed if the stream isn't completed after the given timeout.
+   * @group basic
+   */
+  def extractStrictEntity(timeout: FiniteDuration): Directive1[HttpEntity.Strict] =
+    extract { ctx ⇒
+      import ctx.materializer
+
+      ctx.request.entity.toStrict(timeout)
+
+    }.flatMap { entity ⇒
+      import FutureDirectives._
+
+      onComplete(entity).flatMap {
+        case Success(x) ⇒ provide(x)
+        case Failure(t) ⇒ StandardRoute(_.fail(t))
+      }
+    }
+
+  /**
+   * WARNING: This will read the entire request entity into memory regardless of size and effectively disable streaming.
+   *
+   * Extracts the [[akka.http.scaladsl.server.RequestContext]] itself with the strict HTTP entity,
+   * or fails the route if unable to drain the entire request body within the timeout.
+   *
+   * @param timeout The directive is failed if the stream isn't completed after the given timeout.
+   * @group basic
+   */
+  def toStrictEntity(timeout: FiniteDuration): Directive0 =
+    Directive { inner ⇒ ctx ⇒
+      import ctx.{ executionContext, materializer }
+
+      ctx.request.entity.toStrict(timeout).flatMap { strictEntity ⇒
+        val newCtx = ctx.mapRequest(_.copy(entity = strictEntity))
+        inner(())(newCtx)
+      }
+    }
+
 }
 
 object BasicDirectives extends BasicDirectives {
@@ -312,7 +372,7 @@ object BasicDirectives extends BasicDirectives {
   private val _extractLog: Directive1[LoggingAdapter] = extract(_.log)
   private val _extractSettings: Directive1[RoutingSettings] = extract(_.settings)
   private val _extractParserSettings: Directive1[ParserSettings] = extract(_.parserSettings)
-  private val _extractRequestContext: Directive1[RequestContext] = extract(conforms)
+  private val _extractRequestContext: Directive1[RequestContext] = extract(scalaIdentityFunction)
   private val _extractRequestEntity: Directive1[RequestEntity] = extract(_.request.entity)
   private val _extractDataBytes: Directive1[Source[ByteString, Any]] = extract(_.request.entity.dataBytes)
 }
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileAndResourceDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileAndResourceDirectives.scala
index c8edaa8bc0..e5f4fe4655 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileAndResourceDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileAndResourceDirectives.scala
@@ -8,15 +8,14 @@ package directives
 import java.io.File
 import java.net.{ URI, URL }
 
-import akka.http.javadsl.model
-import akka.http.javadsl.model.RequestEntity
+import akka.http.javadsl.{ marshalling, model }
 import akka.stream.ActorAttributes
 import akka.stream.scaladsl.{ FileIO, StreamConverters }
 
 import scala.annotation.tailrec
 import akka.actor.ActorSystem
 import akka.event.LoggingAdapter
-import akka.http.scaladsl.marshalling.{ Marshaller, Marshalling, ToEntityMarshaller }
+import akka.http.scaladsl.marshalling.{ Marshaller, ToEntityMarshaller }
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.model.headers._
 import akka.http.impl.util._
@@ -70,7 +69,7 @@ trait FileAndResourceDirectives {
             withRangeSupportAndPrecompressedMediaTypeSupportAndExtractSettings { settings ⇒
               complete {
                 HttpEntity.Default(contentType, file.length,
-                  FileIO.fromFile(file).withAttributes(ActorAttributes.dispatcher(settings.fileIODispatcher)))
+                  FileIO.fromPath(file.toPath).withAttributes(ActorAttributes.dispatcher(settings.fileIODispatcher)))
               }
             }
           } else complete(HttpEntity.Empty)
@@ -273,10 +272,10 @@ object FileAndResourceDirectives extends FileAndResourceDirectives {
 
     def marshaller(renderVanityFooter: Boolean): ToEntityMarshaller[DirectoryListing]
 
-    final override def directoryMarshaller(renderVanityFooter: Boolean): akka.http.javadsl.server.Marshaller[JDL, JRE] = {
+    final override def directoryMarshaller(renderVanityFooter: Boolean): marshalling.Marshaller[JDL, JRE] = {
       val combined = Marshaller.combined[JDL, SDL, SRE](x ⇒ JavaMapping.toScala(x)(RoutingJavaMapping.convertDirectoryListing))(marshaller(renderVanityFooter))
         .map(_.asJava)
-      akka.http.javadsl.server.Marshaller.fromScala(combined)
+      marshalling.Marshaller.fromScala(combined)
     }
 
   }
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileUploadDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileUploadDirectives.scala
index 36045a88f7..3f497c4f8e 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileUploadDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FileUploadDirectives.scala
@@ -4,10 +4,10 @@
 package akka.http.scaladsl.server.directives
 
 import java.io.File
-
-import akka.http.scaladsl.server.{ MissingFormFieldRejection, Directive1 }
+import akka.http.scaladsl.server.{ Directive1, MissingFormFieldRejection }
 import akka.http.scaladsl.model.{ ContentType, Multipart }
 import akka.util.ByteString
+
 import scala.concurrent.Future
 import scala.util.{ Failure, Success }
 import akka.stream.scaladsl._
@@ -41,7 +41,7 @@ trait FileUploadDirectives {
         case (fileInfo, bytes) ⇒
 
           val destination = File.createTempFile("akka-http-upload", ".tmp")
-          val uploadedF: Future[(FileInfo, File)] = bytes.runWith(FileIO.toFile(destination))
+          val uploadedF: Future[(FileInfo, File)] = bytes.runWith(FileIO.toPath(destination.toPath))
             .map(_ ⇒ (fileInfo, destination))
 
           onComplete[(FileInfo, File)](uploadedF).flatMap {
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FramedEntityStreamingDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FramedEntityStreamingDirectives.scala
new file mode 100644
index 0000000000..dc4a5ab001
--- /dev/null
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/FramedEntityStreamingDirectives.scala
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2009-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.http.scaladsl.server.directives
+
+import akka.NotUsed
+import akka.http.scaladsl.common
+import akka.http.scaladsl.common.EntityStreamingSupport
+import akka.http.scaladsl.marshalling._
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.unmarshalling.{ Unmarshaller, _ }
+import akka.http.scaladsl.util.FastFuture
+import akka.stream.scaladsl.{ Flow, Keep, Source }
+import akka.util.ByteString
+
+import scala.language.implicitConversions
+
+/**
+ * Allows the [[MarshallingDirectives.entity]] directive to extract a [[Source]] of elements.
+ *
+ * See [[common.EntityStreamingSupport]] for useful default framing `Flow` instances and
+ * support traits such as `SprayJsonSupport` (or your other favourite JSON library) to provide the needed [[Marshaller]] s.
+ */
+trait FramedEntityStreamingDirectives extends MarshallingDirectives {
+
+  type RequestToSourceUnmarshaller[T] = FromRequestUnmarshaller[Source[T, NotUsed]]
+
+  /**
+   * Extracts entity as [[Source]] of elements of type `T`.
+   * This is achieved by applying the implicitly provided (in the following order):
+   *
+   * - 1st: chunk-up the incoming [[ByteString]]s by applying the `Content-Type`-aware framing
+   * - 2nd: apply the [[Unmarshaller]] (from [[ByteString]] to `T`) for each of the respective "chunks" (e.g. for each JSON element contained within an array).
+   *
+   * The request will be rejected with an [[akka.http.scaladsl.server.UnsupportedRequestContentTypeRejection]] if
+   * its [[ContentType]] is not supported by the used `framing` or `unmarshaller`.
+   *
+   * Cancelling extracted [[Source]] closes the connection abruptly (same as cancelling the `entity.dataBytes`).
+   *
+   * See also [[MiscDirectives.withoutSizeLimit]] as you may want to allow streaming infinite streams of data in this route.
+   * By default the uploaded data is limited by the `akka.http.parsing.max-content-length`.
+   */
+  final def asSourceOf[T](implicit um: FromByteStringUnmarshaller[T], support: EntityStreamingSupport): RequestToSourceUnmarshaller[T] =
+    asSourceOfInternal(um, support)
+
+  /**
+   * Extracts entity as [[Source]] of elements of type `T`.
+   * This is achieved by applying the implicitly provided (in the following order):
+   *
+   * - 1st: chunk-up the incoming [[ByteString]]s by applying the `Content-Type`-aware framing
+   * - 2nd: apply the [[Unmarshaller]] (from [[ByteString]] to `T`) for each of the respective "chunks" (e.g. for each JSON element contained within an array).
+   *
+   * The request will be rejected with an [[akka.http.scaladsl.server.UnsupportedRequestContentTypeRejection]] if
+   * its [[ContentType]] is not supported by the used `framing` or `unmarshaller`.
+   *
+   * Cancelling extracted [[Source]] closes the connection abruptly (same as cancelling the `entity.dataBytes`).
+   *
+   * See also [[MiscDirectives.withoutSizeLimit]] as you may want to allow streaming infinite streams of data in this route.
+   * By default the uploaded data is limited by the `akka.http.parsing.max-content-length`.
+   */
+  final def asSourceOf[T](support: EntityStreamingSupport)(implicit um: FromByteStringUnmarshaller[T]): RequestToSourceUnmarshaller[T] =
+    asSourceOfInternal(um, support)
+
+  // format: OFF
+  private final def asSourceOfInternal[T](um: Unmarshaller[ByteString, T], support: EntityStreamingSupport): RequestToSourceUnmarshaller[T] =
+    Unmarshaller.withMaterializer[HttpRequest, Source[T, NotUsed]] { implicit ec ⇒ implicit mat ⇒ req ⇒
+      val entity = req.entity
+      if (support.supported.matches(entity.contentType)) {
+        val bytes = entity.dataBytes
+        val frames = bytes.via(support.framingDecoder)
+        val marshalling = 
+          if (support.unordered) Flow[ByteString].mapAsyncUnordered(support.parallelism)(bs => um(bs)(ec, mat))
+          else Flow[ByteString].mapAsync(support.parallelism)(bs => um(bs)(ec, mat))
+        
+        val elements = frames.viaMat(marshalling)(Keep.right)
+        FastFuture.successful(elements)
+
+      } else FastFuture.failed(Unmarshaller.UnsupportedContentTypeException(support.supported))
+    }
+  // format: ON
+
+}
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/HeaderDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/HeaderDirectives.scala
index 87ae5a1910..1fa50f54bd 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/HeaderDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/HeaderDirectives.scala
@@ -7,7 +7,7 @@ package directives
 
 import akka.http.impl.util._
 import akka.http.scaladsl.model._
-import akka.http.scaladsl.model.headers.{ HttpOriginRange, ModeledCustomHeader, ModeledCustomHeaderCompanion, Origin }
+import akka.http.scaladsl.model.headers._
 
 import scala.reflect.ClassTag
 import scala.util.control.NonFatal
@@ -28,10 +28,10 @@ trait HeaderDirectives {
    *
    * @group header
    */
-  def checkSameOrigin(allowed: HttpOriginRange): Directive0 = {
+  def checkSameOrigin(allowed: HttpOriginRange.Default): Directive0 = {
     headerValueByType[Origin]().flatMap { origin ⇒
       if (origin.origins.exists(allowed.matches)) pass
-      else reject(InvalidOriginRejection(origin.origins))
+      else reject(InvalidOriginRejection(allowed.origins))
     }
   }
 
@@ -91,7 +91,7 @@ trait HeaderDirectives {
    * @group header
    */
   def headerValueByType[T](magnet: HeaderMagnet[T]): Directive1[T] =
-    headerValuePF(magnet.extractPF) | reject(MissingHeaderRejection(magnet.runtimeClass.getSimpleName))
+    headerValuePF(magnet.extractPF) | reject(MissingHeaderRejection(magnet.headerName))
 
   //#optional-header
   /**
@@ -159,6 +159,7 @@ object HeaderDirectives extends HeaderDirectives
 trait HeaderMagnet[T] {
   def classTag: ClassTag[T]
   def runtimeClass: Class[T]
+  def headerName = ModeledCompanion.nameFromClass(runtimeClass)
 
   /**
    * Returns a partial function that checks if the input value is of runtime type
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/RouteDirectives.scala b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/RouteDirectives.scala
index c1c7cf612e..4a6e2e0f7f 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/server/directives/RouteDirectives.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/server/directives/RouteDirectives.scala
@@ -36,19 +36,7 @@ trait RouteDirectives {
    * @group route
    */
   def redirect(uri: Uri, redirectionType: Redirection): StandardRoute =
-    StandardRoute {
-      _. //# red-impl
-        complete {
-          HttpResponse(
-            status = redirectionType,
-            headers = headers.Location(uri) :: Nil,
-            entity = redirectionType.htmlTemplate match {
-              case ""       ⇒ HttpEntity.Empty
-              case template ⇒ HttpEntity(ContentTypes.`text/html(UTF-8)`, template format uri)
-            })
-        }
-      //#
-    }
+    StandardRoute(_.redirect(uri, redirectionType))
 
   /**
    * Completes the request using the given arguments.
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromEntityUnmarshallers.scala b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromEntityUnmarshallers.scala
index 21f629c050..43f4cbd420 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromEntityUnmarshallers.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromEntityUnmarshallers.scala
@@ -35,7 +35,7 @@ trait PredefinedFromEntityUnmarshallers extends MultipartUnmarshallers {
   implicit def stringUnmarshaller: FromEntityUnmarshaller[String] =
     byteStringUnmarshaller mapWithInput { (entity, bytes) ⇒
       if (entity.isKnownEmpty) ""
-      else bytes.decodeString(Unmarshaller.bestUnmarshallingCharsetFor(entity).nioCharset.name)
+      else bytes.decodeString(Unmarshaller.bestUnmarshallingCharsetFor(entity).nioCharset)
     }
 
   implicit def defaultUrlEncodedFormDataUnmarshaller: FromEntityUnmarshaller[FormData] =
@@ -53,4 +53,4 @@ trait PredefinedFromEntityUnmarshallers extends MultipartUnmarshallers {
     }
 }
 
-object PredefinedFromEntityUnmarshallers extends PredefinedFromEntityUnmarshallers
\ No newline at end of file
+object PredefinedFromEntityUnmarshallers extends PredefinedFromEntityUnmarshallers
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromStringUnmarshallers.scala b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromStringUnmarshallers.scala
index 6b6ac6b96a..9f44f67762 100755
--- a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromStringUnmarshallers.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/PredefinedFromStringUnmarshallers.scala
@@ -6,9 +6,15 @@ package akka.http.scaladsl.unmarshalling
 
 import scala.collection.immutable
 import akka.http.scaladsl.util.FastFuture
+import akka.util.ByteString
 
 trait PredefinedFromStringUnmarshallers {
 
+  implicit def _fromStringUnmarshallerFromByteStringUnmarshaller[T](implicit bsum: FromByteStringUnmarshaller[T]): Unmarshaller[String, T] = {
+    val bs = Unmarshaller.strict[String, ByteString](s ⇒ ByteString(s))
+    bs.flatMap(implicit ec ⇒ implicit mat ⇒ bsum(_))
+  }
+
   implicit val byteFromStringUnmarshaller: Unmarshaller[String, Byte] =
     numberUnmarshaller(_.toByte, "8-bit signed integer")
 
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/Unmarshaller.scala b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/Unmarshaller.scala
index d295b4bb38..ae372b3162 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/Unmarshaller.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/Unmarshaller.scala
@@ -13,7 +13,7 @@ import akka.http.scaladsl.util.FastFuture
 import akka.http.scaladsl.util.FastFuture._
 import akka.http.scaladsl.model._
 
-trait Unmarshaller[-A, B] extends akka.http.javadsl.server.Unmarshaller[A, B] {
+trait Unmarshaller[-A, B] extends akka.http.javadsl.unmarshalling.Unmarshaller[A, B] {
 
   implicit final def asScala: Unmarshaller[A, B] = this
 
diff --git a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/package.scala b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/package.scala
index 3870019cbd..46dbbce95a 100644
--- a/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/package.scala
+++ b/akka-http/src/main/scala/akka/http/scaladsl/unmarshalling/package.scala
@@ -6,6 +6,7 @@ package akka.http.scaladsl
 
 import akka.http.scaladsl.common.StrictForm
 import akka.http.scaladsl.model._
+import akka.util.ByteString
 
 package object unmarshalling {
   //# unmarshaller-aliases
@@ -13,6 +14,7 @@ package object unmarshalling {
   type FromMessageUnmarshaller[T] = Unmarshaller[HttpMessage, T]
   type FromResponseUnmarshaller[T] = Unmarshaller[HttpResponse, T]
   type FromRequestUnmarshaller[T] = Unmarshaller[HttpRequest, T]
+  type FromByteStringUnmarshaller[T] = Unmarshaller[ByteString, T]
   type FromStringUnmarshaller[T] = Unmarshaller[String, T]
   type FromStrictFormFieldUnmarshaller[T] = Unmarshaller[StrictForm.Field, T]
   //#
diff --git a/akka-parsing/src/main/scala/akka/parboiled2/ParserInput.scala b/akka-parsing/src/main/scala/akka/parboiled2/ParserInput.scala
index 82f2b73250..445f5c0f67 100644
--- a/akka-parsing/src/main/scala/akka/parboiled2/ParserInput.scala
+++ b/akka-parsing/src/main/scala/akka/parboiled2/ParserInput.scala
@@ -18,6 +18,9 @@ package akka.parboiled2
 
 import scala.annotation.tailrec
 import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+
+import akka.parboiled2.ParserInput.DefaultParserInput
 
 trait ParserInput {
   /**
@@ -109,4 +112,4 @@ object ParserInput {
     def sliceString(start: Int, end: Int) = new String(chars, start, end - start)
     def sliceCharArray(start: Int, end: Int) = java.util.Arrays.copyOfRange(chars, start, end)
   }
-}
\ No newline at end of file
+}
diff --git a/akka-persistence-tck/src/main/scala/akka/persistence/CapabilityFlags.scala b/akka-persistence-tck/src/main/scala/akka/persistence/CapabilityFlags.scala
index f87899b2e3..b8a93b50fe 100644
--- a/akka-persistence-tck/src/main/scala/akka/persistence/CapabilityFlags.scala
+++ b/akka-persistence-tck/src/main/scala/akka/persistence/CapabilityFlags.scala
@@ -21,7 +21,7 @@ object CapabilityFlag {
   def on(): CapabilityFlag =
     new CapabilityFlag { override def value = true }
   def off(): CapabilityFlag =
-    new CapabilityFlag { override def value = true }
+    new CapabilityFlag { override def value = false }
 
   /** Java DSL */
   def create(`val`: Boolean): CapabilityFlag =
diff --git a/akka-persistence-tck/src/main/scala/akka/persistence/japi/journal/JavaJournalPerfSpec.scala b/akka-persistence-tck/src/main/scala/akka/persistence/japi/journal/JavaJournalPerfSpec.scala
index fb0d63d59f..b5ef3b2dbe 100644
--- a/akka-persistence-tck/src/main/scala/akka/persistence/japi/journal/JavaJournalPerfSpec.scala
+++ b/akka-persistence-tck/src/main/scala/akka/persistence/japi/journal/JavaJournalPerfSpec.scala
@@ -6,6 +6,7 @@ package akka.persistence.japi.journal
 import akka.persistence.CapabilityFlag
 import akka.persistence.journal.JournalPerfSpec
 import com.typesafe.config.Config
+import org.scalactic.source.Position
 import org.scalatest.Informer
 
 /**
@@ -43,7 +44,8 @@ import org.scalatest.Informer
  */
 class JavaJournalPerfSpec(config: Config) extends JournalPerfSpec(config) {
   override protected def info: Informer = new Informer {
-    override def apply(message: String, payload: Option[Any]): Unit = System.out.println(message)
+    override def apply(message: String, payload: Option[Any])(implicit pos: Position): Unit =
+      System.out.println(message)
   }
 
   override protected def supportsRejectingNonSerializableObjects: CapabilityFlag = CapabilityFlag.on
diff --git a/akka-persistence-tck/src/main/scala/akka/persistence/scalatest/MayVerb.scala b/akka-persistence-tck/src/main/scala/akka/persistence/scalatest/MayVerb.scala
index 66e2282833..7102f8bccd 100644
--- a/akka-persistence-tck/src/main/scala/akka/persistence/scalatest/MayVerb.scala
+++ b/akka-persistence-tck/src/main/scala/akka/persistence/scalatest/MayVerb.scala
@@ -3,6 +3,7 @@
  */
 package akka.persistence.scalatest
 
+import org.scalactic.source.Position
 import org.scalatest.exceptions.TestCanceledException
 import org.scalatest.words.StringVerbBlockRegistration
 
@@ -37,8 +38,8 @@ trait MayVerb {
      *
      * @see <a href="https://www.rfc-editor.org/rfc/rfc2119.txt">RFC 2119</a>
      */
-    def may(right: ⇒ Unit)(implicit fun: StringVerbBlockRegistration) {
-      fun(leftSideString, "may", right _)
+    def may(right: ⇒ Unit)(implicit fun: StringVerbBlockRegistration, pos: Position) {
+      fun(leftSideString, "may", pos, right _)
     }
   }
 
diff --git a/akka-persistence/src/main/scala/akka/persistence/Eventsourced.scala b/akka-persistence/src/main/scala/akka/persistence/Eventsourced.scala
index 4f01d2739c..15931ff706 100644
--- a/akka-persistence/src/main/scala/akka/persistence/Eventsourced.scala
+++ b/akka-persistence/src/main/scala/akka/persistence/Eventsourced.scala
@@ -258,7 +258,7 @@ private[persistence] trait Eventsourced extends Snapshotter with PersistenceStas
   }
 
   private def flushJournalBatch(): Unit =
-    if (!writeInProgress) {
+    if (!writeInProgress && journalBatch.nonEmpty) {
       journal ! WriteMessages(journalBatch, self, instanceId)
       journalBatch = Vector.empty
       writeInProgress = true
@@ -580,7 +580,7 @@ private[persistence] trait Eventsourced extends Snapshotter with PersistenceStas
       eventBatch = Nil
     }
 
-    if (journalBatch.nonEmpty) flushJournalBatch()
+    flushJournalBatch()
   }
 
   private def peekApplyHandler(payload: Any): Unit =
@@ -630,7 +630,7 @@ private[persistence] trait Eventsourced extends Snapshotter with PersistenceStas
         }
       case WriteMessagesSuccessful ⇒
         writeInProgress = false
-        if (journalBatch.nonEmpty) flushJournalBatch()
+        flushJournalBatch()
 
       case WriteMessagesFailed(_) ⇒
         writeInProgress = false
diff --git a/akka-persistence/src/main/scala/akka/persistence/fsm/PersistentFSMBase.scala b/akka-persistence/src/main/scala/akka/persistence/fsm/PersistentFSMBase.scala
index 9994e95154..787c9f8171 100644
--- a/akka-persistence/src/main/scala/akka/persistence/fsm/PersistentFSMBase.scala
+++ b/akka-persistence/src/main/scala/akka/persistence/fsm/PersistentFSMBase.scala
@@ -575,7 +575,7 @@ trait LoggingPersistentFSM[S, D, E] extends PersistentFSMBase[S, D, E] { this: A
         case a: ActorRef          ⇒ a.toString
         case _                    ⇒ "unknown"
       }
-      log.debug("processing " + event + " from " + srcstr)
+      log.debug("processing {} from {} in state {}", event, srcstr, stateName)
     }
 
     if (logDepth > 0) {
diff --git a/akka-persistence/src/test/scala/akka/persistence/PersistentActorStashingSpec.scala b/akka-persistence/src/test/scala/akka/persistence/PersistentActorStashingSpec.scala
index d99191744b..e08fe61250 100644
--- a/akka-persistence/src/test/scala/akka/persistence/PersistentActorStashingSpec.scala
+++ b/akka-persistence/src/test/scala/akka/persistence/PersistentActorStashingSpec.scala
@@ -166,7 +166,7 @@ abstract class PersistentActorStashingSpec(config: Config) extends PersistenceSp
 
       cmds foreach (persistentActor ! _)
       persistentActor ! GetState
-      expectMsg(evts)
+      expectMsg(evts.toList)
     }
   }
 
diff --git a/akka-remote-tests/src/test/scala/akka/remote/QuietReporter.scala b/akka-remote-tests/src/test/scala/org/scalatest/extra/QuietReporter.scala
similarity index 81%
rename from akka-remote-tests/src/test/scala/akka/remote/QuietReporter.scala
rename to akka-remote-tests/src/test/scala/org/scalatest/extra/QuietReporter.scala
index bc21e5edf8..ef9978d8dd 100644
--- a/akka-remote-tests/src/test/scala/akka/remote/QuietReporter.scala
+++ b/akka-remote-tests/src/test/scala/org/scalatest/extra/QuietReporter.scala
@@ -8,7 +8,8 @@ import org.scalatest.tools.StandardOutReporter
 import org.scalatest.events._
 import java.lang.Boolean.getBoolean
 
-class QuietReporter(inColor: Boolean, withDurations: Boolean = false) extends StandardOutReporter(withDurations, inColor, false, true, false, false, false, false, false) {
+class QuietReporter(inColor: Boolean, withDurations: Boolean = false)
+  extends StandardOutReporter(withDurations, inColor, false, true, false, false, false, false, false, false) {
 
   def this() = this(!getBoolean("akka.test.nocolor"), !getBoolean("akka.test.nodurations"))
 
diff --git a/akka-remote/src/main/scala/akka/remote/transport/netty/NettySSLSupport.scala b/akka-remote/src/main/scala/akka/remote/transport/netty/NettySSLSupport.scala
index 281db760a3..49846cb6da 100644
--- a/akka-remote/src/main/scala/akka/remote/transport/netty/NettySSLSupport.scala
+++ b/akka-remote/src/main/scala/akka/remote/transport/netty/NettySSLSupport.scala
@@ -127,6 +127,7 @@ private[akka] object NettySSLSupport {
           val sslEngine = context.createSSLEngine
           sslEngine.setUseClientMode(true)
           sslEngine.setEnabledCipherSuites(settings.SSLEnabledAlgorithms.toArray)
+          sslEngine.setEnabledProtocols(settings.SSLProtocol.toArray)
           sslEngine
         })
       case None ⇒
diff --git a/akka-remote/src/test/scala/akka/remote/AccrualFailureDetectorSpec.scala b/akka-remote/src/test/scala/akka/remote/AccrualFailureDetectorSpec.scala
index 2da9207c72..b5b0a7a480 100644
--- a/akka-remote/src/test/scala/akka/remote/AccrualFailureDetectorSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/AccrualFailureDetectorSpec.scala
@@ -188,7 +188,7 @@ class AccrualFailureDetectorSpec extends AkkaSpec("akka.loglevel = INFO") {
       fd.heartbeat() //2000
       fd.heartbeat() //2500
       val phi2 = fd.phi //3000
-      phi2 should ===(phi1.plusOrMinus(0.001))
+      phi2 should ===(phi1 +- (0.001))
     }
 
   }
diff --git a/akka-remote/src/test/scala/akka/remote/RemotingSpec.scala b/akka-remote/src/test/scala/akka/remote/RemotingSpec.scala
index 67769be238..e08a1a0267 100644
--- a/akka-remote/src/test/scala/akka/remote/RemotingSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/RemotingSpec.scala
@@ -458,8 +458,7 @@ class RemotingSpec extends AkkaSpec(RemotingSpec.cfg) with ImplicitSender with D
 
     "be able to use multiple transports and use the appropriate one (TCP)" in {
       val r = system.actorOf(Props[Echo1], "gonk")
-      r.path.toString should be ===
-        s"akka.tcp://remote-sys@localhost:${port(remoteSystem, "tcp")}/remote/akka.tcp/RemotingSpec@localhost:${port(system, "tcp")}/user/gonk"
+      r.path.toString should ===(s"akka.tcp://remote-sys@localhost:${port(remoteSystem, "tcp")}/remote/akka.tcp/RemotingSpec@localhost:${port(system, "tcp")}/user/gonk")
       r ! 42
       expectMsg(42)
       EventFilter[Exception]("crash", occurrences = 1).intercept {
@@ -474,8 +473,7 @@ class RemotingSpec extends AkkaSpec(RemotingSpec.cfg) with ImplicitSender with D
 
     "be able to use multiple transports and use the appropriate one (UDP)" in {
       val r = system.actorOf(Props[Echo1], "zagzag")
-      r.path.toString should be ===
-        s"akka.udp://remote-sys@localhost:${port(remoteSystem, "udp")}/remote/akka.udp/RemotingSpec@localhost:${port(system, "udp")}/user/zagzag"
+      r.path.toString should ===(s"akka.udp://remote-sys@localhost:${port(remoteSystem, "udp")}/remote/akka.udp/RemotingSpec@localhost:${port(system, "udp")}/user/zagzag")
       r ! 42
       expectMsg(10.seconds, 42)
       EventFilter[Exception]("crash", occurrences = 1).intercept {
@@ -490,8 +488,7 @@ class RemotingSpec extends AkkaSpec(RemotingSpec.cfg) with ImplicitSender with D
 
     "be able to use multiple transports and use the appropriate one (SSL)" in {
       val r = system.actorOf(Props[Echo1], "roghtaar")
-      r.path.toString should be ===
-        s"akka.ssl.tcp://remote-sys@localhost:${port(remoteSystem, "ssl.tcp")}/remote/akka.ssl.tcp/RemotingSpec@localhost:${port(system, "ssl.tcp")}/user/roghtaar"
+      r.path.toString should ===(s"akka.ssl.tcp://remote-sys@localhost:${port(remoteSystem, "ssl.tcp")}/remote/akka.ssl.tcp/RemotingSpec@localhost:${port(system, "ssl.tcp")}/user/roghtaar")
       r ! 42
       expectMsg(10.seconds, 42)
       EventFilter[Exception]("crash", occurrences = 1).intercept {
diff --git a/akka-stream-testkit/src/test/scala/akka/stream/testkit/StreamSpec.scala b/akka-stream-testkit/src/test/scala/akka/stream/testkit/StreamSpec.scala
new file mode 100644
index 0000000000..7ab2d0fd80
--- /dev/null
+++ b/akka-stream-testkit/src/test/scala/akka/stream/testkit/StreamSpec.scala
@@ -0,0 +1,43 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.stream.testkit
+
+import akka.actor.{ ActorSystem, ActorRef }
+import akka.stream.impl.StreamSupervisor
+import akka.testkit.{ AkkaSpec, TestProbe }
+import com.typesafe.config.{ ConfigFactory, Config }
+import org.scalatest.Failed
+import scala.concurrent.duration._
+
+class StreamSpec(_system: ActorSystem) extends AkkaSpec(_system) {
+  def this(config: Config) =
+    this(ActorSystem(
+      AkkaSpec.getCallerName(getClass),
+      ConfigFactory.load(config.withFallback(AkkaSpec.testConf))))
+
+  def this(s: String) = this(ConfigFactory.parseString(s))
+
+  def this(configMap: Map[String, _]) = this(AkkaSpec.mapToConfig(configMap))
+
+  def this() = this(ActorSystem(AkkaSpec.getCallerName(getClass), AkkaSpec.testConf))
+
+  override def withFixture(test: NoArgTest) = {
+    super.withFixture(test) match {
+      case failed: Failed ⇒
+        val probe = TestProbe()(system)
+        system.actorSelection("/user/" + StreamSupervisor.baseName + "*").tell(StreamSupervisor.GetChildren, probe.ref)
+        val children: Seq[ActorRef] = probe.receiveWhile(2.seconds) {
+          case StreamSupervisor.Children(children) ⇒ children
+        }.flatten
+        println("--- Stream actors debug dump ---")
+        if (children.isEmpty) println("Stream is completed. No debug information is available")
+        else {
+          println("Stream actors alive: " + children)
+          children.foreach(_ ! StreamSupervisor.PrintDebugDump)
+        }
+        failed
+      case other ⇒ other
+    }
+  }
+}
diff --git a/akka-stream-tests/src/test/java/akka/stream/javadsl/FlowTest.java b/akka-stream-tests/src/test/java/akka/stream/javadsl/FlowTest.java
index 55589e9b1d..e8c8f54641 100644
--- a/akka-stream-tests/src/test/java/akka/stream/javadsl/FlowTest.java
+++ b/akka-stream-tests/src/test/java/akka/stream/javadsl/FlowTest.java
@@ -804,7 +804,7 @@ public class FlowTest extends StreamTest {
       try {
         Source.<Integer> maybe().via(Flow.of(Integer.class).initialTimeout(Duration.create(1, "second")))
             .runWith(Sink.<Integer> head(), materializer).toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
@@ -820,7 +820,7 @@ public class FlowTest extends StreamTest {
       try {
         Source.<Integer> maybe().via(Flow.of(Integer.class).completionTimeout(Duration.create(1, "second")))
             .runWith(Sink.<Integer> head(), materializer).toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
@@ -835,7 +835,7 @@ public class FlowTest extends StreamTest {
       try {
         Source.<Integer> maybe().via(Flow.of(Integer.class).idleTimeout(Duration.create(1, "second")))
             .runWith(Sink.<Integer> head(), materializer).toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
diff --git a/akka-stream-tests/src/test/java/akka/stream/javadsl/SourceTest.java b/akka-stream-tests/src/test/java/akka/stream/javadsl/SourceTest.java
index 390344b512..b3fd3bc457 100644
--- a/akka-stream-tests/src/test/java/akka/stream/javadsl/SourceTest.java
+++ b/akka-stream-tests/src/test/java/akka/stream/javadsl/SourceTest.java
@@ -767,7 +767,7 @@ public class SourceTest extends StreamTest {
       try {
         Source.maybe().initialTimeout(Duration.create(1, "second")).runWith(Sink.head(), materializer)
             .toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
@@ -782,7 +782,7 @@ public class SourceTest extends StreamTest {
       try {
         Source.maybe().completionTimeout(Duration.create(1, "second")).runWith(Sink.head(), materializer)
             .toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
@@ -797,7 +797,7 @@ public class SourceTest extends StreamTest {
       try {
         Source.maybe().idleTimeout(Duration.create(1, "second")).runWith(Sink.head(), materializer)
             .toCompletableFuture().get(3, TimeUnit.SECONDS);
-        fail("A TimeoutException was expected");
+        org.junit.Assert.fail("A TimeoutException was expected");
       } catch (ExecutionException e) {
         throw e.getCause();
       }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/ActorMaterializerSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/ActorMaterializerSpec.scala
index 97a0479b80..1e3f7e879f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/ActorMaterializerSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/ActorMaterializerSpec.scala
@@ -3,12 +3,13 @@ package akka.stream
 import akka.actor.{ ActorSystem, Props }
 import akka.stream.impl.{ StreamSupervisor, ActorMaterializerImpl }
 import akka.stream.scaladsl.{ Sink, Source }
-import akka.testkit.{ AkkaSpec, TestActor, ImplicitSender }
+import akka.stream.testkit.StreamSpec
+import akka.testkit.{ TestActor, ImplicitSender }
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
 
-class ActorMaterializerSpec extends AkkaSpec with ImplicitSender {
+class ActorMaterializerSpec extends StreamSpec with ImplicitSender {
 
   "ActorMaterializer" must {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/FusingSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/FusingSpec.scala
index 39fc26a45d..f5bb5f1bd1 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/FusingSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/FusingSpec.scala
@@ -4,18 +4,15 @@
 package akka.stream
 
 import akka.stream.scaladsl._
-import akka.testkit.AkkaSpec
-import org.scalactic.ConversionCheckedTripleEquals
+import akka.stream.testkit.StreamSpec
 import akka.stream.Attributes._
 import akka.stream.Fusing.FusedGraph
 import scala.annotation.tailrec
 import akka.stream.impl.StreamLayout.{ CopiedModule, Module }
-import org.scalatest.concurrent.ScalaFutures
-import scala.concurrent.duration._
 import akka.stream.impl.fusing.GraphInterpreter
 import akka.event.BusLogging
 
-class FusingSpec extends AkkaSpec {
+class FusingSpec extends StreamSpec {
 
   final val Debug = false
   implicit val materializer = ActorMaterializer()
diff --git a/akka-stream-tests/src/test/scala/akka/stream/actor/ActorPublisherSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/actor/ActorPublisherSpec.scala
index f357fcd0ee..34bbf18f6a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/actor/ActorPublisherSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/actor/ActorPublisherSpec.scala
@@ -10,7 +10,7 @@ import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.stream.impl.ReactiveStreamsCompliance
 import akka.testkit.TestEvent.Mute
-import akka.testkit.{ AkkaSpec, EventFilter, ImplicitSender, TestProbe }
+import akka.testkit.{ EventFilter, ImplicitSender, TestProbe }
 import scala.annotation.tailrec
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
@@ -145,7 +145,7 @@ object ActorPublisherSpec {
 
 }
 
-class ActorPublisherSpec extends AkkaSpec(ActorPublisherSpec.config) with ImplicitSender {
+class ActorPublisherSpec extends StreamSpec(ActorPublisherSpec.config) with ImplicitSender {
 
   import akka.stream.actor.ActorPublisherSpec._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/actor/ActorSubscriberSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/actor/ActorSubscriberSpec.scala
index 76578d24bf..e808b6fb11 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/actor/ActorSubscriberSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/actor/ActorSubscriberSpec.scala
@@ -7,7 +7,7 @@ import akka.actor.{ Actor, ActorRef, Props }
 import akka.routing.{ ActorRefRoutee, RoundRobinRoutingLogic, Router }
 import akka.stream.ActorMaterializer
 import akka.stream.scaladsl.{ Sink, Source }
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.testkit.ImplicitSender
 import org.reactivestreams.Subscription
 
@@ -103,7 +103,7 @@ object ActorSubscriberSpec {
   }
 }
 
-class ActorSubscriberSpec extends AkkaSpec with ImplicitSender {
+class ActorSubscriberSpec extends StreamSpec with ImplicitSender {
   import ActorSubscriberMessage._
   import ActorSubscriberSpec._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/extra/FlowTimedSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/extra/FlowTimedSpec.scala
index 51dbef0805..e3ff64e459 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/extra/FlowTimedSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/extra/FlowTimedSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.testkit.TestProbe
 import org.reactivestreams.{ Publisher, Subscriber }
-import akka.testkit.AkkaSpec
 
-class FlowTimedSpec extends AkkaSpec with ScriptedTest {
+class FlowTimedSpec extends StreamSpec with ScriptedTest {
 
   import scala.concurrent.duration._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/FixedBufferSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/FixedBufferSpec.scala
index b340e8bdd9..ec356abf2e 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/FixedBufferSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/FixedBufferSpec.scala
@@ -3,10 +3,10 @@
  */
 package akka.stream.impl
 
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream.ActorMaterializerSettings
 
-class FixedBufferSpec extends AkkaSpec {
+class FixedBufferSpec extends StreamSpec {
 
   for (size ← List(1, 3, 4)) {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/GraphStageLogicSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/GraphStageLogicSpec.scala
index 193c6887d7..aa8d51913f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/GraphStageLogicSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/GraphStageLogicSpec.scala
@@ -4,7 +4,7 @@
 package akka.stream.impl
 
 import akka.stream.stage.GraphStageLogic.{ EagerTerminateOutput, EagerTerminateInput }
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream._
 import akka.stream.Fusing.aggressive
 import akka.stream.scaladsl._
@@ -14,7 +14,7 @@ import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.impl.fusing._
 import scala.concurrent.duration.Duration
 
-class GraphStageLogicSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class GraphStageLogicSpec extends StreamSpec with GraphInterpreterSpecKit {
 
   implicit val materializer = ActorMaterializer()
 
@@ -206,8 +206,8 @@ class GraphStageLogicSpec extends AkkaSpec with GraphInterpreterSpecKit {
         .connect(passThrough.out, Downstream)
         .init()
 
-      interpreter.complete(0)
-      interpreter.cancel(1)
+      interpreter.complete(interpreter.connections(0))
+      interpreter.cancel(interpreter.connections(1))
       interpreter.execute(2)
 
       expectMsg("postStop2")
@@ -219,6 +219,32 @@ class GraphStageLogicSpec extends AkkaSpec with GraphInterpreterSpecKit {
       interpreter.isStageCompleted(interpreter.logics(1)) should ===(false)
     }
 
+    "not allow push from constructor" in {
+      object source extends GraphStage[SourceShape[Int]] {
+        val out = Outlet[Int]("out")
+        override val shape = SourceShape(out)
+        override def createLogic(attr: Attributes) = new GraphStageLogic(shape) {
+          push(out, 1)
+        }
+      }
+
+      val ex = intercept[IllegalStateException] { Source.fromGraph(source).runWith(Sink.ignore) }
+      ex.getMessage should startWith("not yet initialized: only setHandler is allowed in GraphStageLogic constructor")
+    }
+
+    "not allow pull from constructor" in {
+      object sink extends GraphStage[SinkShape[Int]] {
+        val in = Inlet[Int]("in")
+        override val shape = SinkShape(in)
+        override def createLogic(attr: Attributes) = new GraphStageLogic(shape) {
+          pull(in)
+        }
+      }
+
+      val ex = intercept[IllegalStateException] { Source.single(1).runWith(sink) }
+      ex.getMessage should startWith("not yet initialized: only setHandler is allowed in GraphStageLogic constructor")
+    }
+
   }
 
 }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/ResizableMultiReaderRingBufferSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/ResizableMultiReaderRingBufferSpec.scala
index a52845fdbb..abb0ec52fe 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/ResizableMultiReaderRingBufferSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/ResizableMultiReaderRingBufferSpec.scala
@@ -4,10 +4,10 @@
 package akka.stream.impl
 
 import scala.util.Random
-import org.scalatest.{ ShouldMatchers, WordSpec }
+import org.scalatest.{ Matchers, WordSpec }
 import akka.stream.impl.ResizableMultiReaderRingBuffer._
 
-class ResizableMultiReaderRingBufferSpec extends WordSpec with ShouldMatchers {
+class ResizableMultiReaderRingBufferSpec extends WordSpec with Matchers {
 
   "A ResizableMultiReaderRingBuffer" should {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/StreamLayoutSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/StreamLayoutSpec.scala
index 7f829cc215..bf76240782 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/StreamLayoutSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/StreamLayoutSpec.scala
@@ -5,12 +5,13 @@ package akka.stream.impl
 
 import akka.stream._
 import akka.stream.scaladsl._
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import org.reactivestreams.{ Publisher, Subscriber, Subscription }
+import org.scalatest.concurrent.PatienceConfiguration.Timeout
 
 import scala.concurrent.duration._
 
-class StreamLayoutSpec extends AkkaSpec {
+class StreamLayoutSpec extends StreamSpec {
   import StreamLayout._
 
   def testAtomic(inPortCount: Int, outPortCount: Int): Module = new AtomicModule {
@@ -126,7 +127,7 @@ class StreamLayoutSpec extends AkkaSpec {
     }
 
     // Seen tests run in 9-10 seconds, these test cases are heavy on the GC
-    val veryPatient = PatienceConfig(20.seconds)
+    val veryPatient = Timeout(20.seconds)
 
     "not fail materialization when building a large graph with simple computation" when {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/TimeoutsSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/TimeoutsSpec.scala
index 32272fed9a..8ece655856 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/TimeoutsSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/TimeoutsSpec.scala
@@ -8,13 +8,12 @@ import java.util.concurrent.TimeoutException
 import akka.Done
 import akka.stream.scaladsl._
 import akka.stream.testkit.Utils._
-import akka.stream.testkit.{ TestPublisher, TestSubscriber }
+import akka.stream.testkit.{ StreamSpec, TestPublisher, TestSubscriber }
 import akka.stream._
 import scala.concurrent.duration._
 import scala.concurrent.{ Await, Future }
-import akka.testkit.AkkaSpec
 
-class TimeoutsSpec extends AkkaSpec {
+class TimeoutsSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
 
   "InitialTimeout" must {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/ActorGraphInterpreterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/ActorGraphInterpreterSpec.scala
index 7a48799576..b45e937c52 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/ActorGraphInterpreterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/ActorGraphInterpreterSpec.scala
@@ -10,15 +10,14 @@ import akka.stream.impl.ReactiveStreamsCompliance.SpecViolation
 import akka.stream.scaladsl._
 import akka.stream.stage.{ GraphStage, GraphStageLogic, InHandler, OutHandler }
 import akka.stream.testkit.Utils._
-import akka.stream.testkit.{ TestPublisher, TestSubscriber }
+import akka.stream.testkit.{ StreamSpec, TestPublisher, TestSubscriber }
 import akka.testkit.EventFilter
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 import org.reactivestreams.{ Publisher, Subscriber, Subscription }
 
-class ActorGraphInterpreterSpec extends AkkaSpec {
+class ActorGraphInterpreterSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
 
   "ActorGraphInterpreter" must {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterFailureModesSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterFailureModesSpec.scala
index 897aa96499..dafad02bd4 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterFailureModesSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterFailureModesSpec.scala
@@ -1,10 +1,10 @@
 package akka.stream.impl.fusing
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils.TE
 import akka.testkit.EventFilter
-import akka.testkit.AkkaSpec
 
-class GraphInterpreterFailureModesSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class GraphInterpreterFailureModesSpec extends StreamSpec with GraphInterpreterSpecKit {
 
   "GraphInterpreter" must {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterPortsSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterPortsSpec.scala
index c4b561025c..0bc6b81c37 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterPortsSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterPortsSpec.scala
@@ -3,10 +3,10 @@
  */
 package akka.stream.impl.fusing
 
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils._
 
-class GraphInterpreterPortsSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class GraphInterpreterPortsSpec extends StreamSpec with GraphInterpreterSpecKit {
 
   "Port states" must {
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpec.scala
index e795e75374..07327b37d3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpec.scala
@@ -4,13 +4,13 @@
 package akka.stream.impl.fusing
 
 import akka.NotUsed
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ OverflowStrategy, Attributes }
 import akka.stream.stage.AbstractStage.PushPullGraphStage
-import akka.testkit.AkkaSpec
 import akka.stream.scaladsl.{ Merge, Broadcast, Balance, Zip }
 import GraphInterpreter._
 
-class GraphInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class GraphInterpreterSpec extends StreamSpec with GraphInterpreterSpecKit {
   import GraphStages._
 
   "GraphInterpreter" must {
@@ -368,11 +368,8 @@ class GraphInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
       sink.requestOne(eventLimit = 0)
       source.onComplete(eventLimit = 3)
-      lastEvents() should ===(Set(OnNext(sink, "C")))
-
-      sink.requestOne()
-      lastEvents() should ===(Set(OnComplete(sink)))
-
+      // OnComplete arrives early due to push chasing
+      lastEvents() should ===(Set(OnNext(sink, "C"), OnComplete(sink)))
     }
   }
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpecKit.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpecKit.scala
index 0cae67e5bc..c0bd29dd10 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpecKit.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/GraphInterpreterSpecKit.scala
@@ -8,11 +8,11 @@ import akka.stream._
 import akka.stream.impl.fusing.GraphInterpreter.{ DownstreamBoundaryStageLogic, Failed, GraphAssembly, UpstreamBoundaryStageLogic }
 import akka.stream.stage.AbstractStage.PushPullGraphStage
 import akka.stream.stage.{ GraphStage, GraphStageLogic, InHandler, OutHandler, _ }
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils.TE
 import akka.stream.impl.fusing.GraphInterpreter.GraphAssembly
 
-trait GraphInterpreterSpecKit extends AkkaSpec {
+trait GraphInterpreterSpecKit extends StreamSpec {
 
   val logger = Logging(system, "InterpreterSpecKit")
 
@@ -71,17 +71,17 @@ trait GraphInterpreterSpecKit extends AkkaSpec {
       def init(): Unit = {
         val assembly = buildAssembly()
 
-        val (inHandlers, outHandlers, logics) =
+        val (conns, logics) =
           assembly.materialize(Attributes.none, assembly.stages.map(_.module), new java.util.HashMap, _ ⇒ ())
-        _interpreter = new GraphInterpreter(assembly, NoMaterializer, logger, inHandlers, outHandlers, logics,
+        _interpreter = new GraphInterpreter(assembly, NoMaterializer, logger, logics, conns,
           (_, _, _) ⇒ (), fuzzingMode = false, null)
 
         for ((upstream, i) ← upstreams.zipWithIndex) {
-          _interpreter.attachUpstreamBoundary(i, upstream._1)
+          _interpreter.attachUpstreamBoundary(conns(i), upstream._1)
         }
 
         for ((downstream, i) ← downstreams.zipWithIndex) {
-          _interpreter.attachDownstreamBoundary(i + upstreams.size + connections.size, downstream._2)
+          _interpreter.attachDownstreamBoundary(conns(i + upstreams.size + connections.size), downstream._2)
         }
 
         _interpreter.init(null)
@@ -89,9 +89,9 @@ trait GraphInterpreterSpecKit extends AkkaSpec {
     }
 
     def manualInit(assembly: GraphAssembly): Unit = {
-      val (inHandlers, outHandlers, logics) =
+      val (connections, logics) =
         assembly.materialize(Attributes.none, assembly.stages.map(_.module), new java.util.HashMap, _ ⇒ ())
-      _interpreter = new GraphInterpreter(assembly, NoMaterializer, logger, inHandlers, outHandlers, logics,
+      _interpreter = new GraphInterpreter(assembly, NoMaterializer, logger, logics, connections,
         (_, _, _) ⇒ (), fuzzingMode = false, null)
     }
 
@@ -202,7 +202,7 @@ trait GraphInterpreterSpecKit extends AkkaSpec {
 
         // Modified onPush that does not grab() automatically the element. This accesses some internals.
         override def onPush(): Unit = {
-          val internalEvent = interpreter.connectionSlots(portToConn(in.id))
+          val internalEvent = portToConn(in.id).slot
 
           internalEvent match {
             case Failed(_, elem) ⇒ lastEvent += OnNext(DownstreamPortProbe.this, elem)
@@ -224,8 +224,8 @@ trait GraphInterpreterSpecKit extends AkkaSpec {
       outOwners = Array(-1))
 
     manualInit(assembly)
-    interpreter.attachDownstreamBoundary(0, in)
-    interpreter.attachUpstreamBoundary(0, out)
+    interpreter.attachDownstreamBoundary(interpreter.connections(0), in)
+    interpreter.attachUpstreamBoundary(interpreter.connections(0), out)
     interpreter.init(null)
   }
 
@@ -310,8 +310,6 @@ trait GraphInterpreterSpecKit extends AkkaSpec {
   abstract class OneBoundedSetup[T](_ops: GraphStageWithMaterializedValue[Shape, Any]*) extends Builder {
     val ops = _ops.toArray
 
-    def this(op: Seq[Stage[_, _]], dummy: Int = 42) = this(op.map(_.toGS): _*)
-
     val upstream = new UpstreamOneBoundedProbe[T]
     val downstream = new DownstreamOneBoundedPortProbe[T]
     var lastEvent = Set.empty[TestEvent]
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSpec.scala
index d4f8afec9e..61d982801d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSpec.scala
@@ -5,12 +5,12 @@ package akka.stream.impl.fusing
 
 import akka.stream.impl.ConstantFun
 import akka.stream.stage._
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.testkit.EventFilter
-
 import akka.stream._
+import akka.stream.impl.fusing.GraphStages.SimpleLinearGraphStage
 
-class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class InterpreterSpec extends StreamSpec with GraphInterpreterSpecKit {
   import Supervision.stoppingDecider
 
   /*
@@ -24,7 +24,7 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
   "Interpreter" must {
 
-    "implement map correctly" in new OneBoundedSetup[Int](Seq(Map((x: Int) ⇒ x + 1, stoppingDecider))) {
+    "implement map correctly" in new OneBoundedSetup[Int](Map((x: Int) ⇒ x + 1)) {
       lastEvents() should be(Set.empty)
 
       downstream.requestOne()
@@ -43,10 +43,10 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(OnComplete))
     }
 
-    "implement chain of maps correctly" in new OneBoundedSetup[Int](Seq(
-      Map((x: Int) ⇒ x + 1, stoppingDecider),
-      Map((x: Int) ⇒ x * 2, stoppingDecider),
-      Map((x: Int) ⇒ x + 1, stoppingDecider))) {
+    "implement chain of maps correctly" in new OneBoundedSetup[Int](
+      Map((x: Int) ⇒ x + 1),
+      Map((x: Int) ⇒ x * 2),
+      Map((x: Int) ⇒ x + 1)) {
 
       lastEvents() should be(Set.empty)
 
@@ -66,7 +66,7 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(Cancel))
     }
 
-    "work with only boundary ops" in new OneBoundedSetup[Int](Seq.empty) {
+    "work with only boundary ops" in new OneBoundedSetup[Int]() {
       lastEvents() should be(Set.empty)
 
       downstream.requestOne()
@@ -149,7 +149,7 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
     "implement take inside a chain" in new OneBoundedSetup[Int](
       Filter((x: Int) ⇒ x != 0),
       takeTwo,
-      Map((x: Int) ⇒ x + 1, stoppingDecider).toGS) {
+      Map((x: Int) ⇒ x + 1)) {
 
       lastEvents() should be(Set.empty)
 
@@ -433,11 +433,11 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
     // Note, the new interpreter has no jumpback table, still did not want to remove the test
     "work with jumpback table and completed elements" in new OneBoundedSetup[Int](
-      Map((x: Int) ⇒ x, stoppingDecider).toGS,
-      Map((x: Int) ⇒ x, stoppingDecider).toGS,
+      Map((x: Int) ⇒ x),
+      Map((x: Int) ⇒ x),
       KeepGoing(),
-      Map((x: Int) ⇒ x, stoppingDecider).toGS,
-      Map((x: Int) ⇒ x, stoppingDecider).toGS) {
+      Map((x: Int) ⇒ x),
+      Map((x: Int) ⇒ x)) {
 
       lastEvents() should be(Set.empty)
 
@@ -464,8 +464,7 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
     }
 
-    "work with pushAndFinish if upstream completes with pushAndFinish" in new OneBoundedSetup[Int](Seq(
-      new PushFinishStage)) {
+    "work with pushAndFinish if upstream completes with pushAndFinish" in new OneBoundedSetup[Int](new PushFinishStage) {
 
       lastEvents() should be(Set.empty)
 
@@ -476,10 +475,10 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(OnNext(0), OnComplete))
     }
 
-    "work with pushAndFinish if indirect upstream completes with pushAndFinish" in new OneBoundedSetup[Int](Seq(
-      Map((x: Any) ⇒ x, stoppingDecider),
+    "work with pushAndFinish if indirect upstream completes with pushAndFinish" in new OneBoundedSetup[Int](
+      Map((x: Any) ⇒ x),
       new PushFinishStage,
-      Map((x: Any) ⇒ x, stoppingDecider))) {
+      Map((x: Any) ⇒ x)) {
 
       lastEvents() should be(Set.empty)
 
@@ -491,7 +490,7 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
     }
 
     "work with pushAndFinish if upstream completes with pushAndFinish and downstream immediately pulls" in new OneBoundedSetup[Int](
-      (new PushFinishStage).toGS,
+      new PushFinishStage,
       Fold(0, (x: Int, y: Int) ⇒ x + y)) {
 
       lastEvents() should be(Set.empty)
@@ -503,11 +502,18 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(OnNext(1), OnComplete))
     }
 
-    "report error if pull is called while op is terminating" in new OneBoundedSetup[Int](Seq(new PushPullStage[Any, Any] {
-      override def onPull(ctx: Context[Any]): SyncDirective = ctx.pull()
-      override def onPush(elem: Any, ctx: Context[Any]): SyncDirective = ctx.pull()
-      override def onUpstreamFinish(ctx: Context[Any]): TerminationDirective = ctx.absorbTermination()
-    })) {
+    "report error if pull is called while op is terminating" in new OneBoundedSetup[Int](
+      new SimpleLinearGraphStage[Any] {
+        override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+          new GraphStageLogic(shape) with InHandler with OutHandler {
+            override def onPush(): Unit = pull(in)
+            override def onPull(): Unit = pull(in)
+            override def onUpstreamFinish(): Unit = if (!hasBeenPulled(in)) pull(in)
+
+            setHandlers(in, out, this)
+          }
+      }
+    ) {
       lastEvents() should be(Set.empty)
 
       downstream.requestOne()
@@ -558,8 +564,8 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
       override def onDownstreamFinish(ctx: Context[Int]): TerminationDirective = ctx.absorbTermination()
     }
 
-    "not allow absorbTermination from onDownstreamFinish()" in new OneBoundedSetup[Int](Seq(
-      new InvalidAbsorbTermination)) {
+    // This test must be kept since it tests the compatibility layer, which while is deprecated it is still here.
+    "not allow absorbTermination from onDownstreamFinish()" in new OneBoundedSetup[Int]((new InvalidAbsorbTermination).toGS) {
       lastEvents() should be(Set.empty)
 
       EventFilter[UnsupportedOperationException]("It is not allowed to call absorbTermination() from onDownstreamFinish.", occurrences = 1).intercept {
@@ -635,16 +641,19 @@ class InterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
     override val shape: FlowShape[T, T] = FlowShape(in, out)
   }
 
-  // This test is related to issue #17351
-  private[akka] class PushFinishStage(onPostStop: () ⇒ Unit = () ⇒ ()) extends PushStage[Any, Any] {
-    override def onPush(elem: Any, ctx: Context[Any]): SyncDirective =
-      ctx.pushAndFinish(elem)
+  private[akka] class PushFinishStage(onPostStop: () ⇒ Unit = () ⇒ ()) extends SimpleLinearGraphStage[Any] {
+    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+      new GraphStageLogic(shape) with InHandler with OutHandler {
+        override def onPush(): Unit = {
+          push(out, grab(in))
+          completeStage()
+        }
+        override def onPull(): Unit = pull(in)
+        override def onUpstreamFinish(): Unit = failStage(akka.stream.testkit.Utils.TE("Cannot happen"))
+        override def postStop(): Unit = onPostStop()
 
-    override def onUpstreamFinish(ctx: Context[Any]): TerminationDirective =
-      ctx.fail(akka.stream.testkit.Utils.TE("Cannot happen"))
-
-    override def postStop(): Unit =
-      onPostStop()
+        setHandlers(in, out, this)
+      }
   }
 
 }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterStressSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterStressSpec.scala
index 93bd741b05..ff7895fe71 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterStressSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterStressSpec.scala
@@ -5,16 +5,16 @@ package akka.stream.impl.fusing
 
 import akka.stream.impl.ConstantFun
 import akka.stream.Supervision
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 
-class InterpreterStressSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class InterpreterStressSpec extends StreamSpec with GraphInterpreterSpecKit {
   import Supervision.stoppingDecider
 
   val chainLength = 1000 * 1000
   val halfLength = chainLength / 2
   val repetition = 100
 
-  val map = Map((x: Int) ⇒ x + 1, stoppingDecider).toGS
+  val map = Map((x: Int) ⇒ x + 1)
 
   // GraphStages can be reused
   val dropOne = Drop(1)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSupervisionSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSupervisionSpec.scala
index c4233ca47d..355c6453b7 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSupervisionSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/InterpreterSupervisionSpec.scala
@@ -3,15 +3,14 @@
  */
 package akka.stream.impl.fusing
 
+import akka.stream.testkit.StreamSpec
+
 import scala.util.control.NoStackTrace
-import akka.stream.Supervision
-import akka.stream.stage.Context
-import akka.stream.stage.PushPullStage
-import akka.stream.stage.Stage
-import akka.stream.stage.SyncDirective
+import akka.stream.{ ActorAttributes, Attributes, Supervision }
+import akka.stream.stage._
 import akka.testkit.AkkaSpec
 
-class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class InterpreterSupervisionSpec extends StreamSpec with GraphInterpreterSpecKit {
   import Supervision.stoppingDecider
   import Supervision.resumingDecider
   import Supervision.restartingDecider
@@ -20,16 +19,22 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
     override def toString = "TE"
   }
 
+  class ResumingMap[In, Out](_f: In ⇒ Out) extends Map(_f) {
+
+    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+      super.createLogic(inheritedAttributes.and(ActorAttributes.supervisionStrategy(resumingDecider)))
+  }
+
   "Interpreter error handling" must {
 
-    "handle external failure" in new OneBoundedSetup[Int](Seq(Map((x: Int) ⇒ x + 1, stoppingDecider))) {
+    "handle external failure" in new OneBoundedSetup[Int](Map((x: Int) ⇒ x + 1)) {
       lastEvents() should be(Set.empty)
 
       upstream.onError(TE)
       lastEvents() should be(Set(OnError(TE)))
     }
 
-    "emit failure when op throws" in new OneBoundedSetup[Int](Seq(Map((x: Int) ⇒ if (x == 0) throw TE else x, stoppingDecider))) {
+    "emit failure when op throws" in new OneBoundedSetup[Int](Map((x: Int) ⇒ if (x == 0) throw TE else x)) {
       downstream.requestOne()
       lastEvents() should be(Set(RequestOne))
       upstream.onNext(2)
@@ -41,10 +46,10 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(Cancel, OnError(TE)))
     }
 
-    "emit failure when op throws in middle of the chain" in new OneBoundedSetup[Int](Seq(
-      Map((x: Int) ⇒ x + 1, stoppingDecider),
-      Map((x: Int) ⇒ if (x == 0) throw TE else x + 10, stoppingDecider),
-      Map((x: Int) ⇒ x + 100, stoppingDecider))) {
+    "emit failure when op throws in middle of the chain" in new OneBoundedSetup[Int](
+      Map((x: Int) ⇒ x + 1),
+      Map((x: Int) ⇒ if (x == 0) throw TE else x + 10),
+      Map((x: Int) ⇒ x + 100)) {
 
       downstream.requestOne()
       lastEvents() should be(Set(RequestOne))
@@ -57,7 +62,9 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(Cancel, OnError(TE)))
     }
 
-    "resume when Map throws" in new OneBoundedSetup[Int](Seq(Map((x: Int) ⇒ if (x == 0) throw TE else x, resumingDecider))) {
+    "resume when Map throws" in new OneBoundedSetup[Int](
+      new ResumingMap((x: Int) ⇒ if (x == 0) throw TE else x)
+    ) {
       downstream.requestOne()
       lastEvents() should be(Set(RequestOne))
       upstream.onNext(2)
@@ -81,10 +88,11 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
       lastEvents() should be(Set(OnNext(4)))
     }
 
-    "resume when Map throws in middle of the chain" in new OneBoundedSetup[Int](Seq(
-      Map((x: Int) ⇒ x + 1, resumingDecider),
-      Map((x: Int) ⇒ if (x == 0) throw TE else x + 10, resumingDecider),
-      Map((x: Int) ⇒ x + 100, resumingDecider))) {
+    "resume when Map throws in middle of the chain" in new OneBoundedSetup[Int](
+      new ResumingMap((x: Int) ⇒ x + 1),
+      new ResumingMap((x: Int) ⇒ if (x == 0) throw TE else x + 10),
+      new ResumingMap((x: Int) ⇒ x + 100)
+    ) {
 
       downstream.requestOne()
       lastEvents() should be(Set(RequestOne))
@@ -101,8 +109,8 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
     }
 
     "resume when Map throws before Grouped" in new OneBoundedSetup[Int](
-      Map((x: Int) ⇒ x + 1, resumingDecider).toGS,
-      Map((x: Int) ⇒ if (x <= 0) throw TE else x + 10, resumingDecider).toGS,
+      new ResumingMap((x: Int) ⇒ x + 1),
+      new ResumingMap((x: Int) ⇒ if (x <= 0) throw TE else x + 10),
       Grouped(3)) {
 
       downstream.requestOne()
@@ -121,8 +129,8 @@ class InterpreterSupervisionSpec extends AkkaSpec with GraphInterpreterSpecKit {
     }
 
     "complete after resume when Map throws before Grouped" in new OneBoundedSetup[Int](
-      Map((x: Int) ⇒ x + 1, resumingDecider).toGS,
-      Map((x: Int) ⇒ if (x <= 0) throw TE else x + 10, resumingDecider).toGS,
+      new ResumingMap((x: Int) ⇒ x + 1),
+      new ResumingMap((x: Int) ⇒ if (x <= 0) throw TE else x + 10),
       Grouped(1000)) {
 
       downstream.requestOne()
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/IteratorInterpreterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/IteratorInterpreterSpec.scala
index 275a5d907a..c5e1906a2e 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/IteratorInterpreterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/IteratorInterpreterSpec.scala
@@ -3,27 +3,27 @@
  */
 package akka.stream.impl.fusing
 
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.util.ByteString
 import akka.stream.stage._
 import akka.stream.{ Attributes, Supervision }
 import akka.stream.impl.fusing.GraphStages.SimpleLinearGraphStage
 
-class IteratorInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class IteratorInterpreterSpec extends StreamSpec with GraphInterpreterSpecKit {
   import Supervision.stoppingDecider
 
   "IteratorInterpreter" must {
 
     "work in the happy case" in {
       val itr = new IteratorInterpreter[Int, Int]((1 to 10).iterator, Seq(
-        Map((x: Int) ⇒ x + 1, stoppingDecider).toGS)).iterator
+        Map((x: Int) ⇒ x + 1))).iterator
 
       itr.toSeq should be(2 to 11)
     }
 
     "hasNext should not affect elements" in {
       val itr = new IteratorInterpreter[Int, Int]((1 to 10).iterator, Seq(
-        Map((x: Int) ⇒ x, stoppingDecider).toGS)).iterator
+        Map((x: Int) ⇒ x))).iterator
 
       itr.hasNext should be(true)
       itr.hasNext should be(true)
@@ -42,7 +42,7 @@ class IteratorInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
     "throw exceptions on empty iterator" in {
       val itr = new IteratorInterpreter[Int, Int](List(1).iterator, Seq(
-        Map((x: Int) ⇒ x, stoppingDecider).toGS)).iterator
+        Map((x: Int) ⇒ x))).iterator
 
       itr.next() should be(1)
       a[NoSuchElementException] should be thrownBy { itr.next() }
@@ -50,7 +50,7 @@ class IteratorInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
     "throw exceptions when op in chain throws" in {
       val itr = new IteratorInterpreter[Int, Int](List(1, 2, 3).iterator, Seq(
-        Map((n: Int) ⇒ if (n == 2) throw new ArithmeticException() else n, stoppingDecider).toGS)).iterator
+        Map((n: Int) ⇒ if (n == 2) throw new ArithmeticException() else n))).iterator
 
       itr.next() should be(1)
       itr.hasNext should be(true)
@@ -60,7 +60,7 @@ class IteratorInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
 
     "work with an empty iterator" in {
       val itr = new IteratorInterpreter[Int, Int](Iterator.empty, Seq(
-        Map((x: Int) ⇒ x + 1, stoppingDecider).toGS)).iterator
+        Map((x: Int) ⇒ x + 1))).iterator
 
       itr.hasNext should be(false)
       a[NoSuchElementException] should be thrownBy { itr.next() }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/KeepGoingStageSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/KeepGoingStageSpec.scala
index 6fb69c67b8..4db3bf1fcf 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/KeepGoingStageSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/KeepGoingStageSpec.scala
@@ -5,15 +5,15 @@ package akka.stream.impl.fusing
 
 import akka.actor.{ NoSerializationVerificationNeeded, ActorRef }
 import akka.stream.scaladsl.{ Keep, Source }
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ Attributes, Inlet, SinkShape, ActorMaterializer }
 import akka.stream.stage.{ InHandler, AsyncCallback, GraphStageLogic, GraphStageWithMaterializedValue }
-import akka.testkit.AkkaSpec
 import akka.stream.testkit.Utils._
 
 import scala.concurrent.{ Await, Promise, Future }
 import scala.concurrent.duration._
 
-class KeepGoingStageSpec extends AkkaSpec {
+class KeepGoingStageSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/LifecycleInterpreterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/LifecycleInterpreterSpec.scala
index be7225a3da..7faf0e68c9 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/LifecycleInterpreterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/impl/fusing/LifecycleInterpreterSpec.scala
@@ -6,12 +6,12 @@ package akka.stream.impl.fusing
 import akka.stream.Attributes
 import akka.stream.impl.fusing.GraphStages.SimpleLinearGraphStage
 import akka.stream.stage._
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils.TE
 
 import scala.concurrent.duration._
 
-class LifecycleInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
+class LifecycleInterpreterSpec extends StreamSpec with GraphInterpreterSpecKit {
   import akka.stream.Supervision._
 
   "Interpreter" must {
@@ -84,9 +84,9 @@ class LifecycleInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
     }
 
     "onError when preStart fails with stages after" in new OneBoundedSetup[String](
-      Map((x: Int) ⇒ x, stoppingDecider).toGS,
+      Map((x: Int) ⇒ x),
       PreStartFailer(() ⇒ throw TE("Boom!")),
-      Map((x: Int) ⇒ x, stoppingDecider).toGS) {
+      Map((x: Int) ⇒ x)) {
       lastEvents() should ===(Set(Cancel, OnError(TE("Boom!"))))
     }
 
@@ -112,9 +112,9 @@ class LifecycleInterpreterSpec extends AkkaSpec with GraphInterpreterSpecKit {
     }
 
     "postStop when pushAndFinish called with pushAndFinish if indirect upstream completes with pushAndFinish" in new OneBoundedSetup[String](
-      Map((x: Any) ⇒ x, stoppingDecider).toGS,
+      Map((x: Any) ⇒ x),
       new PushFinishStage(onPostStop = () ⇒ testActor ! "stop"),
-      Map((x: Any) ⇒ x, stoppingDecider).toGS) {
+      Map((x: Any) ⇒ x)) {
 
       lastEvents() should be(Set.empty)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
index 86c7e14ea5..ebcdbbcef7 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
@@ -18,9 +18,8 @@ import akka.util.{ ByteString, Timeout }
 import scala.collection.mutable.ListBuffer
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FileSinkSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class FileSinkSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/FileSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/FileSourceSpec.scala
index 857e3d6427..4456889e9f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/FileSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/FileSourceSpec.scala
@@ -24,13 +24,12 @@ import akka.util.ByteString
 import akka.util.Timeout
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
 object FileSourceSpec {
   final case class Settings(chunkSize: Int, readAhead: Int)
 }
 
-class FileSourceSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class FileSourceSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSinkSpec.scala
index 2792b83611..86cf63c7c2 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSinkSpec.scala
@@ -14,16 +14,15 @@ import akka.stream.impl.{ ActorMaterializerImpl, StreamSupervisor }
 import akka.stream.scaladsl.{ Keep, Source, StreamConverters }
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSource
-import akka.stream.testkit.{ GraphStageMessages, TestSinkStage }
+import akka.stream.testkit.{ StreamSpec, GraphStageMessages, TestSinkStage }
 import akka.testkit.TestProbe
 import akka.util.ByteString
 import scala.concurrent.duration._
 import java.util.concurrent.ThreadLocalRandom
 import scala.concurrent.{ Await, Future }
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class InputStreamSinkSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class InputStreamSinkSpec extends StreamSpec(UnboundedMailboxConfig) {
   import system.dispatcher
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSourceSpec.scala
index 6049a69fbe..d424668327 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/InputStreamSourceSpec.scala
@@ -3,7 +3,7 @@
  */
 package akka.stream.io
 
-import java.io.{ InputStream }
+import java.io.InputStream
 import java.util.concurrent.CountDownLatch
 
 import akka.stream.scaladsl.{ Sink, StreamConverters }
@@ -12,12 +12,10 @@ import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.util.ByteString
-import akka.testkit.AkkaSpec
-import org.scalatest.concurrent.ScalaFutures
 import scala.concurrent.Await
 import scala.concurrent.duration._
 
-class InputStreamSourceSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class InputStreamSourceSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSinkSpec.scala
index 9b202e63dc..6266d40239 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSinkSpec.scala
@@ -9,13 +9,13 @@ import akka.stream.scaladsl.{ Source, StreamConverters }
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.{ AkkaSpec, TestProbe }
+import akka.testkit.TestProbe
 import akka.util.ByteString
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
 
-class OutputStreamSinkSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class OutputStreamSinkSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSourceSpec.scala
index f127ba2266..806f31be51 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/OutputStreamSourceSpec.scala
@@ -12,20 +12,18 @@ import akka.stream.Attributes.inputBuffer
 import akka.stream.impl.StreamSupervisor.Children
 import akka.stream.impl.io.OutputStreamSourceStage
 import akka.stream.impl.{ ActorMaterializerImpl, StreamSupervisor }
-import akka.stream.scaladsl.{ Source, Keep, StreamConverters, Sink }
+import akka.stream.scaladsl.{ Keep, StreamConverters, Sink }
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.TestSink
 import akka.testkit.TestProbe
 import akka.util.ByteString
-import com.typesafe.config.ConfigFactory
 import scala.concurrent.duration.Duration.Zero
 import scala.concurrent.duration._
 import scala.concurrent.{ Await, Future }
 import scala.util.Random
-import akka.testkit.AkkaSpec
 
-class OutputStreamSourceSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class OutputStreamSourceSpec extends StreamSpec(UnboundedMailboxConfig) {
   import system.dispatcher
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/TcpSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/TcpSpec.scala
index 16dd3c4350..dda95ce477 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/TcpSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/TcpSpec.scala
@@ -4,24 +4,26 @@
 package akka.stream.io
 
 import akka.NotUsed
-import akka.actor.{ ActorSystem, Kill }
+import akka.actor.{ ActorSystem, Address, Kill }
 import akka.io.Tcp._
 import akka.stream.scaladsl.Tcp.IncomingConnection
 import akka.stream.scaladsl.{ Flow, _ }
 import akka.stream.testkit.TestUtils.temporaryServerAddress
+
 import scala.util.control.NonFatal
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
 import akka.stream.{ ActorMaterializer, BindFailedException, StreamTcpException }
 import akka.util.{ ByteString, Helpers }
-import scala.collection.immutable
-import scala.concurrent.{ Promise, Await }
-import scala.concurrent.duration._
-import java.net.BindException
-import akka.testkit.EventFilter
-import akka.testkit.AkkaSpec
 
-class TcpSpec extends AkkaSpec("akka.stream.materializer.subscription-timeout.timeout = 2s") with TcpHelper {
+import scala.collection.immutable
+import scala.concurrent.{ Await, Promise }
+import scala.concurrent.duration._
+import java.net.{ BindException, InetSocketAddress }
+
+import akka.testkit.EventFilter
+
+class TcpSpec extends StreamSpec("akka.stream.materializer.subscription-timeout.timeout = 2s") with TcpHelper {
 
   "Outgoing TCP stream" must {
 
@@ -76,6 +78,18 @@ class TcpSpec extends AkkaSpec("akka.stream.materializer.subscription-timeout.ti
 
     }
 
+    "fail the materialized future when the connection fails" in assertAllStagesStopped {
+      val tcpWriteProbe = new TcpWriteProbe()
+      val future = Source.fromPublisher(tcpWriteProbe.publisherProbe)
+        .viaMat(Tcp().outgoingConnection(InetSocketAddress.createUnresolved("example.com", 666), connectTimeout = 1.second))(Keep.right)
+        .toMat(Sink.ignore)(Keep.left)
+        .run()
+
+      whenReady(future.failed) { ex ⇒
+        ex.getMessage should ===("Connection failed.")
+      }
+    }
+
     "work when client closes write, then remote closes write" in assertAllStagesStopped {
       val testData = ByteString(1, 2, 3, 4, 5)
       val server = new Server()
@@ -416,7 +430,7 @@ class TcpSpec extends AkkaSpec("akka.stream.materializer.subscription-timeout.ti
           .run()
 
       // make sure that the server has bound to the socket
-      val binding = Await.result(bindingFuture, 100.millis)
+      val binding = Await.result(bindingFuture, remainingOrDefault)
 
       val testInput = (0 to 255).map(ByteString(_))
       val expectedOutput = ByteString(Array.tabulate(256)(_.asInstanceOf[Byte]))
@@ -437,7 +451,7 @@ class TcpSpec extends AkkaSpec("akka.stream.materializer.subscription-timeout.ti
           .run()
 
       // make sure that the server has bound to the socket
-      val binding = Await.result(bindingFuture, 100.millis)
+      val binding = Await.result(bindingFuture, remainingOrDefault)
 
       val echoConnection = Tcp().outgoingConnection(serverAddress)
 
@@ -541,7 +555,7 @@ class TcpSpec extends AkkaSpec("akka.stream.materializer.subscription-timeout.ti
         val bindingFuture = Tcp().bindAndHandle(Flow[ByteString], address.getHostName, address.getPort)(mat2)
 
         // Ensure server is running
-        Await.ready(bindingFuture, 3.seconds)
+        Await.ready(bindingFuture, remainingOrDefault)
         // and is possible to communicate with
         Await.result(
           Source.single(ByteString(0)).via(Tcp().outgoingConnection(address)).runWith(Sink.ignore),
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/TlsSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/TlsSpec.scala
index 2aa6617849..c5efd95488 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/TlsSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/TlsSpec.scala
@@ -21,7 +21,7 @@ import akka.stream.scaladsl._
 import akka.stream.stage._
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.{ AkkaSpec, EventFilter }
+import akka.testkit.EventFilter
 import akka.util.ByteString
 import javax.net.ssl._
 
@@ -83,7 +83,7 @@ object TlsSpec {
 
 }
 
-class TlsSpec extends AkkaSpec("akka.loglevel=INFO\nakka.actor.debug.receive=off") {
+class TlsSpec extends StreamSpec("akka.loglevel=INFO\nakka.actor.debug.receive=off") {
   import TlsSpec._
 
   import system.dispatcher
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefBackpressureSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefBackpressureSinkSpec.scala
index eb94cc6f2d..6fe562b201 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefBackpressureSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefBackpressureSinkSpec.scala
@@ -9,10 +9,6 @@ import akka.stream.Attributes.inputBuffer
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl._
-import org.scalatest.concurrent.ScalaFutures
-import org.scalactic.ConversionCheckedTripleEquals
-import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
 object ActorRefBackpressureSinkSpec {
   val initMessage = "start"
@@ -48,7 +44,7 @@ object ActorRefBackpressureSinkSpec {
 
 }
 
-class ActorRefBackpressureSinkSpec extends AkkaSpec {
+class ActorRefBackpressureSinkSpec extends StreamSpec {
   import ActorRefBackpressureSinkSpec._
   implicit val mat = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSinkSpec.scala
index 759e1b758a..504263d34e 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSinkSpec.scala
@@ -10,7 +10,6 @@ import akka.stream.testkit.scaladsl._
 import akka.actor.Actor
 import akka.actor.ActorRef
 import akka.actor.Props
-import akka.testkit.AkkaSpec
 
 object ActorRefSinkSpec {
   case class Fw(ref: ActorRef) extends Actor {
@@ -20,7 +19,7 @@ object ActorRefSinkSpec {
   }
 }
 
-class ActorRefSinkSpec extends AkkaSpec {
+class ActorRefSinkSpec extends StreamSpec {
   import ActorRefSinkSpec._
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSourceSpec.scala
index 91572838a8..eeaf0776ee 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ActorRefSourceSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.testkit.scaladsl._
 import akka.stream.testkit.Utils._
 import akka.actor.PoisonPill
 import akka.actor.Status
-import akka.testkit.AkkaSpec
 
-class ActorRefSourceSpec extends AkkaSpec {
+class ActorRefSourceSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
 
   "A ActorRefSource" must {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/AttributesSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/AttributesSpec.scala
index 262fa5825d..0b7377e7a0 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/AttributesSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/AttributesSpec.scala
@@ -14,9 +14,7 @@ import scala.concurrent.Future
 import scala.concurrent.Promise
 import akka.stream.impl.SinkModule
 import akka.stream.impl.StreamLayout.Module
-import org.scalatest.concurrent.ScalaFutures
 import akka.stream.impl.SinkholeSubscriber
-import akka.testkit.AkkaSpec
 
 object AttributesSpec {
 
@@ -38,7 +36,7 @@ object AttributesSpec {
 
 }
 
-class AttributesSpec extends AkkaSpec {
+class AttributesSpec extends StreamSpec {
   import AttributesSpec._
 
   val settings = ActorMaterializerSettings(system)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
index 85b8ff4212..050e207270 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
@@ -4,16 +4,15 @@
 package akka.stream.scaladsl
 
 import akka.NotUsed
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils._
-import org.scalactic.ConversionCheckedTripleEquals
 import akka.util.ByteString
 import akka.stream._
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.collection.immutable
-import akka.testkit.AkkaSpec
 
-class BidiFlowSpec extends AkkaSpec {
+class BidiFlowSpec extends StreamSpec {
   import Attributes._
   import GraphDSL.Implicits._
 
@@ -109,7 +108,10 @@ class BidiFlowSpec extends AkkaSpec {
 
     "suitably override attribute handling methods" in {
       import Attributes._
-      val b: BidiFlow[Int, Long, ByteString, String, NotUsed] = bidi.withAttributes(name("")).async.named("")
+      val b: BidiFlow[Int, Long, ByteString, String, NotUsed] = bidi.async.addAttributes(none).named("name")
+
+      b.module.attributes.getFirst[Name] shouldEqual Some(Name("name"))
+      b.module.attributes.getFirst[AsyncBoundary.type] shouldEqual Some(AsyncBoundary)
     }
 
   }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowAppendSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowAppendSpec.scala
index 1efb8aad4e..4187930024 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowAppendSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowAppendSpec.scala
@@ -6,12 +6,11 @@ package akka.stream.scaladsl
 import akka.actor.ActorSystem
 import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
-import akka.stream.testkit.TestSubscriber
+import akka.stream.testkit.{ StreamSpec, TestSubscriber }
 import org.reactivestreams.Subscriber
 import org.scalatest.Matchers
-import akka.testkit.AkkaSpec
 
-class FlowAppendSpec extends AkkaSpec with River {
+class FlowAppendSpec extends StreamSpec with River {
 
   val settings = ActorMaterializerSettings(system)
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchSpec.scala
index 1ed0a381c0..346ab5e0e3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchSpec.scala
@@ -8,9 +8,8 @@ import scala.concurrent.duration._
 import java.util.concurrent.ThreadLocalRandom
 import akka.stream.{ OverflowStrategy, ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowBatchSpec extends AkkaSpec {
+class FlowBatchSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchWeightedSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchWeightedSpec.scala
index 0b59748945..119612bcd9 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchWeightedSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBatchWeightedSpec.scala
@@ -6,9 +6,8 @@ package akka.stream.scaladsl
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit._
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowBatchWeightedSpec extends AkkaSpec {
+class FlowBatchWeightedSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBufferSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBufferSpec.scala
index a0d616adea..10167b32a5 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBufferSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowBufferSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.{ BufferOverflowException, ActorMaterializer, ActorMaterializ
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class FlowBufferSpec extends AkkaSpec {
+class FlowBufferSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 1, maxSize = 1)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCollectSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCollectSpec.scala
index e7764ca0b4..a852020117 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCollectSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCollectSpec.scala
@@ -5,19 +5,15 @@ package akka.stream.scaladsl
 
 import akka.stream.ActorAttributes._
 import akka.stream.Supervision._
-import akka.stream.impl.ConstantFun
 import akka.stream.testkit.Utils.TE
 import akka.stream.testkit.scaladsl.TestSink
 
 import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
 
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.AkkaSpec
-import akka.stream.testkit.{ TestSubscriber, ScriptedTest }
+import akka.stream.testkit.{ StreamSpec, ScriptedTest }
 
-import scala.util.control.NoStackTrace
-
-class FlowCollectSpec extends AkkaSpec with ScriptedTest {
+class FlowCollectSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCompileSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCompileSpec.scala
index d4c14c950d..7129edfaf0 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCompileSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowCompileSpec.scala
@@ -4,6 +4,7 @@
 package akka.stream.scaladsl
 
 import akka.NotUsed
+import akka.stream.testkit.StreamSpec
 import org.reactivestreams.Publisher
 
 import scala.collection.immutable.Seq
@@ -11,9 +12,8 @@ import scala.concurrent.Future
 
 import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
-import akka.testkit.AkkaSpec
 
-class FlowCompileSpec extends AkkaSpec {
+class FlowCompileSpec extends StreamSpec {
 
   val intSeq = Source(Seq(1, 2, 3))
   val strSeq = Source(Seq("a", "b", "c"))
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConcatAllSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConcatAllSpec.scala
index e16cd4b8d3..cfe28517a4 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConcatAllSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConcatAllSpec.scala
@@ -11,9 +11,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class FlowConcatAllSpec extends AkkaSpec {
+class FlowConcatAllSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConflateSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConflateSpec.scala
index ef9c09146f..b0946645cd 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConflateSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowConflateSpec.scala
@@ -13,9 +13,8 @@ import scala.concurrent.duration._
 import java.util.concurrent.ThreadLocalRandom
 import akka.stream._
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowConflateSpec extends AkkaSpec {
+class FlowConflateSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDelaySpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDelaySpec.scala
index f14c67ac86..e094929011 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDelaySpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDelaySpec.scala
@@ -7,15 +7,14 @@ import akka.Done
 import akka.stream.Attributes._
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSink
-import akka.stream.testkit.{ TestPublisher, TestSubscriber }
+import akka.stream.testkit.{ StreamSpec, TestPublisher, TestSubscriber }
 import akka.stream.{ ActorMaterializer, Attributes, BufferOverflowException, DelayOverflowStrategy }
 
 import scala.concurrent.{ Await, Future }
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowDelaySpec extends AkkaSpec {
+class FlowDelaySpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDetacherSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDetacherSpec.scala
index 7f8c671de7..411ad5c12f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDetacherSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDetacherSpec.scala
@@ -3,16 +3,13 @@
  */
 package akka.stream.scaladsl
 
-import org.scalactic.ConversionCheckedTripleEquals
-import org.scalatest.concurrent.ScalaFutures
-import akka.testkit.AkkaSpec
 import akka.stream._
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import akka.stream.testkit.scaladsl.TestSink
-import akka.stream.testkit.Utils
+import akka.stream.testkit.{ StreamSpec, Utils }
 
-class FlowDetacherSpec extends AkkaSpec {
+class FlowDetacherSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDispatcherSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDispatcherSpec.scala
index dffe5f87d6..872424c0d8 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDispatcherSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDispatcherSpec.scala
@@ -3,12 +3,12 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.testkit.TestProbe
-import akka.testkit.AkkaSpec
 import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 
-class FlowDispatcherSpec extends AkkaSpec(s"my-dispatcher = $${akka.test.stream-dispatcher}") {
+class FlowDispatcherSpec extends StreamSpec(s"my-dispatcher = $${akka.test.stream-dispatcher}") {
 
   val defaultSettings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropSpec.scala
index ecdff62a09..6ed8a67e8f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropSpec.scala
@@ -7,9 +7,8 @@ import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
 import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowDropSpec extends AkkaSpec with ScriptedTest {
+class FlowDropSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWhileSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWhileSpec.scala
index d6ffbe1486..f4944de77a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWhileSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWhileSpec.scala
@@ -10,10 +10,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.TestSink
-import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowDropWhileSpec extends AkkaSpec {
+class FlowDropWhileSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWithinSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWithinSpec.scala
index f335ef1c10..02a59c687d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWithinSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowDropWithinSpec.scala
@@ -6,9 +6,8 @@ package akka.stream.scaladsl
 import scala.concurrent.duration._
 import akka.stream.ActorMaterializer
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowDropWithinSpec extends AkkaSpec {
+class FlowDropWithinSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowExpandSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowExpandSpec.scala
index fa5888fb3d..3dcb516255 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowExpandSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowExpandSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.TestSource
 import akka.stream.testkit.scaladsl.TestSink
-import akka.testkit.AkkaSpec
 
-class FlowExpandSpec extends AkkaSpec {
+class FlowExpandSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFilterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFilterSpec.scala
index bd916bb3bd..799ae43b12 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFilterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFilterSpec.scala
@@ -12,11 +12,10 @@ import akka.stream.testkit.Utils._
 import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
 import scala.util.control.NoStackTrace
 
-class FlowFilterSpec extends AkkaSpec with ScriptedTest {
+class FlowFilterSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFlattenMergeSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFlattenMergeSpec.scala
index 3b428ee79a..52b016075a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFlattenMergeSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFlattenMergeSpec.scala
@@ -4,18 +4,16 @@
 package akka.stream.scaladsl
 
 import akka.NotUsed
-import akka.testkit.AkkaSpec
 import akka.stream.{ ActorMaterializerSettings, ActorMaterializer }
+import akka.stream.testkit.Utils.assertAllStagesStopped
 import scala.concurrent._
 import scala.concurrent.duration._
-import org.scalatest.concurrent.ScalaFutures
-import org.scalactic.ConversionCheckedTripleEquals
-import akka.stream.testkit.TestPublisher
+import akka.stream.testkit.{ StreamSpec, TestPublisher }
 import org.scalatest.exceptions.TestFailedException
 import akka.stream.testkit.scaladsl.TestSink
 import akka.testkit.TestLatch
 
-class FlowFlattenMergeSpec extends AkkaSpec {
+class FlowFlattenMergeSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
   import system.dispatcher
 
@@ -27,14 +25,14 @@ class FlowFlattenMergeSpec extends AkkaSpec {
 
   "A FattenMerge" must {
 
-    "work in the nominal case" in {
+    "work in the nominal case" in assertAllStagesStopped {
       Source(List(src10(0), src10(10), src10(20), src10(30)))
         .flatMapMerge(4, identity)
         .runWith(toSet)
         .futureValue should ===((0 until 40).toSet)
     }
 
-    "not be held back by one slow stream" in {
+    "not be held back by one slow stream" in assertAllStagesStopped {
       Source(List(src10(0), src10(10), blocked, src10(20), src10(30)))
         .flatMapMerge(3, identity)
         .take(40)
@@ -42,7 +40,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
         .futureValue should ===((0 until 40).toSet)
     }
 
-    "respect breadth" in {
+    "respect breadth" in assertAllStagesStopped {
       val seq = Source(List(src10(0), src10(10), src10(20), blocked, blocked, src10(30)))
         .flatMapMerge(3, identity)
         .take(40)
@@ -53,7 +51,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       seq.drop(30).toSet should ===((30 until 40).toSet)
     }
 
-    "propagate early failure from main stream" in {
+    "propagate early failure from main stream" in assertAllStagesStopped {
       val ex = new Exception("buh")
       intercept[TestFailedException] {
         Source.failed(ex)
@@ -63,7 +61,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       }.cause.get should ===(ex)
     }
 
-    "propagate late failure from main stream" in {
+    "propagate late failure from main stream" in assertAllStagesStopped {
       val ex = new Exception("buh")
       intercept[TestFailedException] {
         (Source(List(blocked, blocked)) ++ Source.failed(ex))
@@ -73,7 +71,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       }.cause.get should ===(ex)
     }
 
-    "propagate failure from map function" in {
+    "propagate failure from map function" in assertAllStagesStopped {
       val ex = new Exception("buh")
       intercept[TestFailedException] {
         Source(1 to 3)
@@ -83,7 +81,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       }.cause.get should ===(ex)
     }
 
-    "bubble up substream exceptions" in {
+    "bubble up substream exceptions" in assertAllStagesStopped {
       val ex = new Exception("buh")
       val result = intercept[TestFailedException] {
         Source(List(blocked, blocked, Source.failed(ex)))
@@ -93,7 +91,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       }.cause.get should ===(ex)
     }
 
-    "cancel substreams when failing from main stream" in {
+    "cancel substreams when failing from main stream" in assertAllStagesStopped {
       val p1, p2 = TestPublisher.probe[Int]()
       val ex = new Exception("buh")
       val p = Promise[Source[Int, NotUsed]]
@@ -107,7 +105,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       p2.expectCancellation()
     }
 
-    "cancel substreams when failing from substream" in {
+    "cancel substreams when failing from substream" in assertAllStagesStopped {
       val p1, p2 = TestPublisher.probe[Int]()
       val ex = new Exception("buh")
       val p = Promise[Int]
@@ -121,7 +119,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       p2.expectCancellation()
     }
 
-    "cancel substreams when failing map function" in {
+    "cancel substreams when failing map function" in assertAllStagesStopped {
       val settings = ActorMaterializerSettings(system).withSyncProcessingLimit(1).withInputBuffer(1, 1)
       val mat = ActorMaterializer(settings)
       val p = TestPublisher.probe[Int]()
@@ -140,7 +138,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       p.expectCancellation()
     }
 
-    "cancel substreams when being cancelled" in {
+    "cancel substreams when being cancelled" in assertAllStagesStopped {
       val p1, p2 = TestPublisher.probe[Int]()
       val ex = new Exception("buh")
       val sink = Source(List(Source.fromPublisher(p1), Source.fromPublisher(p2)))
@@ -154,7 +152,7 @@ class FlowFlattenMergeSpec extends AkkaSpec {
       p2.expectCancellation()
     }
 
-    "work with many concurrently queued events" in {
+    "work with many concurrently queued events" in assertAllStagesStopped {
       val p = Source((0 until 100).map(i ⇒ src10(10 * i)))
         .flatMapMerge(Int.MaxValue, identity)
         .runWith(TestSink.probe)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFoldSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFoldSpec.scala
index 5004a8f02f..542822a161 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFoldSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFoldSpec.scala
@@ -4,16 +4,16 @@
 package akka.stream.scaladsl
 
 import akka.NotUsed
+import akka.stream.testkit.StreamSpec
 
 import scala.concurrent.Await
 import scala.util.control.NoStackTrace
 
 import akka.stream.ActorMaterializer
-import akka.testkit.AkkaSpec
 import akka.stream.testkit.Utils._
 import scala.concurrent.duration._
 
-class FlowFoldSpec extends AkkaSpec {
+class FlowFoldSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
 
   "A Fold" must {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowForeachSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowForeachSpec.scala
index 13dcba517d..ede0e08265 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowForeachSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowForeachSpec.scala
@@ -9,9 +9,8 @@ import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowForeachSpec extends AkkaSpec {
+class FlowForeachSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
   import system.dispatcher
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFromFutureSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFromFutureSpec.scala
index 74b3ebf387..f129eb0e89 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFromFutureSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowFromFutureSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class FlowFromFutureSpec extends AkkaSpec {
+class FlowFromFutureSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupBySpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupBySpec.scala
index fc2d636731..a1e455d347 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupBySpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupBySpec.scala
@@ -26,7 +26,6 @@ import org.scalactic.ConversionCheckedTripleEquals
 import org.scalatest.concurrent.PatienceConfiguration.Timeout
 import akka.stream.testkit.scaladsl.TestSource
 import akka.stream.testkit.scaladsl.TestSink
-import akka.testkit.AkkaSpec
 
 import java.util.concurrent.ThreadLocalRandom
 
@@ -38,7 +37,7 @@ object FlowGroupBySpec {
 
 }
 
-class FlowGroupBySpec extends AkkaSpec {
+class FlowGroupBySpec extends StreamSpec {
   import FlowGroupBySpec._
 
   val settings = ActorMaterializerSettings(system)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedSpec.scala
index fa57436c3c..62fdd059ba 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedSpec.scala
@@ -7,10 +7,9 @@ import scala.collection.immutable
 import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
 
 import akka.stream.ActorMaterializerSettings
-import akka.testkit.AkkaSpec
-import akka.stream.testkit.ScriptedTest
+import akka.stream.testkit.{ StreamSpec, ScriptedTest }
 
-class FlowGroupedSpec extends AkkaSpec with ScriptedTest {
+class FlowGroupedSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedWithinSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedWithinSpec.scala
index 00dd3078f3..52bb3549d7 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedWithinSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowGroupedWithinSpec.scala
@@ -9,11 +9,10 @@ import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings, ThrottleMode }
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
 import scala.concurrent.Await
 
-class FlowGroupedWithinSpec extends AkkaSpec with ScriptedTest {
+class FlowGroupedWithinSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIdleInjectSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIdleInjectSpec.scala
index 45482e49f7..363ed54afc 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIdleInjectSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIdleInjectSpec.scala
@@ -1,12 +1,11 @@
 package akka.stream.scaladsl
 
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.stream.testkit.{ TestSubscriber, TestPublisher, Utils }
+import akka.stream.testkit.{ StreamSpec, TestSubscriber, TestPublisher, Utils }
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowIdleInjectSpec extends AkkaSpec {
+class FlowIdleInjectSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowInitialDelaySpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowInitialDelaySpec.scala
index fe97126e64..094130ad4c 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowInitialDelaySpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowInitialDelaySpec.scala
@@ -2,12 +2,11 @@ package akka.stream.scaladsl
 
 import java.util.concurrent.TimeoutException
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.stream.testkit.{ Utils, TestSubscriber }
+import akka.stream.testkit.{ StreamSpec, Utils, TestSubscriber }
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowInitialDelaySpec extends AkkaSpec {
+class FlowInitialDelaySpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIntersperseSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIntersperseSpec.scala
index c95d0168e4..33f9509cea 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIntersperseSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIntersperseSpec.scala
@@ -6,11 +6,9 @@ package akka.stream.scaladsl
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.{ TestSource, TestSink }
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import org.scalatest.concurrent.ScalaFutures
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowIntersperseSpec extends AkkaSpec {
+class FlowIntersperseSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIteratorSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIteratorSpec.scala
index 2a60b26fe7..eebf807d9b 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIteratorSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowIteratorSpec.scala
@@ -11,7 +11,6 @@ import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.testkit.EventFilter
-import akka.testkit.AkkaSpec
 
 class FlowIteratorSpec extends AbstractFlowIteratorSpec {
   override def testName = "A Flow based on an iterator producing function"
@@ -72,7 +71,7 @@ class FlowIterableSpec extends AbstractFlowIteratorSpec {
   }
 }
 
-abstract class AbstractFlowIteratorSpec extends AkkaSpec {
+abstract class AbstractFlowIteratorSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowJoinSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowJoinSpec.scala
index 6c98f623b1..39842564f4 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowJoinSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowJoinSpec.scala
@@ -7,14 +7,13 @@ import akka.stream.{ FlowShape, ActorMaterializer, ActorMaterializerSettings, Ov
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl._
-import akka.testkit.AkkaSpec
 import com.typesafe.config.ConfigFactory
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.time._
 
 import scala.collection.immutable
 
-class FlowJoinSpec extends AkkaSpec(ConfigFactory.parseString("akka.loglevel=INFO")) {
+class FlowJoinSpec extends StreamSpec(ConfigFactory.parseString("akka.loglevel=INFO")) {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowKillSwitchSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowKillSwitchSpec.scala
index 8d00c85623..e01b58139a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowKillSwitchSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowKillSwitchSpec.scala
@@ -4,14 +4,14 @@
 package akka.stream.scaladsl
 
 import akka.Done
-import akka.stream.{ ActorMaterializer, ClosedShape, KillSwitch, KillSwitches }
+import akka.stream.testkit.StreamSpec
+import akka.stream.{ ActorMaterializer, ClosedShape, KillSwitches }
 import akka.stream.testkit.scaladsl.{ TestSink, TestSource }
 import akka.stream.testkit.Utils.{ TE, assertAllStagesStopped }
-import akka.testkit.{ AkkaSpec, EventFilter }
 
 import scala.concurrent.duration._
 
-class FlowKillSwitchSpec extends AkkaSpec {
+class FlowKillSwitchSpec extends StreamSpec {
 
   implicit val mat = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitSpec.scala
index fd410574c5..705aafc016 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitSpec.scala
@@ -3,12 +3,11 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ StreamLimitReachedException, ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.AkkaSpec
 import scala.concurrent.Await
-import scala.concurrent.duration._
 
-class FlowLimitSpec extends AkkaSpec {
+class FlowLimitSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitWeightedSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitWeightedSpec.scala
index 367ff1a217..37e39290c3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitWeightedSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLimitWeightedSpec.scala
@@ -3,12 +3,11 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ StreamLimitReachedException, ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.AkkaSpec
 import scala.concurrent.Await
-import scala.concurrent.duration._
 
-class FlowLimitWeightedSpec extends AkkaSpec {
+class FlowLimitWeightedSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLogSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLogSpec.scala
index 3f8521f030..165f3af30b 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLogSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowLogSpec.scala
@@ -8,16 +8,15 @@ import akka.event.{ DummyClassForStringSources, Logging }
 import akka.stream.ActorAttributes._
 import akka.stream.Attributes.LogLevels
 import akka.stream.Supervision._
-import akka.stream.testkit.ScriptedTest
+import akka.stream.testkit.{ StreamSpec, ScriptedTest }
 import akka.stream._
-import akka.testkit.TestProbe
+import akka.testkit.{ AkkaSpec, TestProbe }
 
 import scala.concurrent.duration._
 import scala.concurrent.Await
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowLogSpec extends AkkaSpec("akka.loglevel = DEBUG") with ScriptedTest {
+class FlowLogSpec extends StreamSpec("akka.loglevel = DEBUG") with ScriptedTest {
 
   implicit val mat: Materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncSpec.scala
index 2bf6fc708d..ac16f2d693 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncSpec.scala
@@ -7,6 +7,7 @@ import scala.concurrent.Await
 import scala.concurrent.Future
 import scala.concurrent.duration._
 import java.util.concurrent.ThreadLocalRandom
+
 import scala.util.control.NoStackTrace
 import akka.stream.ActorMaterializer
 import akka.stream.testkit._
@@ -16,14 +17,15 @@ import akka.testkit.TestProbe
 import akka.stream.ActorAttributes.supervisionStrategy
 import akka.stream.Supervision.resumingDecider
 import akka.stream.impl.ReactiveStreamsCompliance
+
 import scala.annotation.tailrec
 import scala.concurrent.Promise
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.LinkedBlockingQueue
-import org.scalatest.concurrent.ScalaFutures
-import akka.testkit.AkkaSpec
 
-class FlowMapAsyncSpec extends AkkaSpec {
+import org.scalatest.concurrent.PatienceConfiguration.Timeout
+
+class FlowMapAsyncSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
@@ -247,7 +249,7 @@ class FlowMapAsyncSpec extends AkkaSpec {
         Source(1 to N)
           .mapAsync(parallelism)(i ⇒ deferred())
           .runFold(0)((c, _) ⇒ c + 1)
-          .futureValue(PatienceConfig(3.seconds)) should ===(N)
+          .futureValue(Timeout(3.seconds)) should ===(N)
       } finally {
         timer.interrupt()
       }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncUnorderedSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncUnorderedSpec.scala
index ef741d59bd..558ec85495 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncUnorderedSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapAsyncUnorderedSpec.scala
@@ -7,7 +7,7 @@ import scala.concurrent.Await
 import scala.concurrent.Future
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
-import akka.stream.{ ActorMaterializer }
+import akka.stream.ActorMaterializer
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl._
 import akka.stream.testkit.Utils._
@@ -17,14 +17,14 @@ import akka.stream.ActorAttributes.supervisionStrategy
 import akka.stream.Supervision.resumingDecider
 import akka.stream.impl.ReactiveStreamsCompliance
 import java.util.concurrent.atomic.AtomicInteger
+
 import scala.concurrent.Promise
 import java.util.concurrent.LinkedBlockingQueue
-import scala.annotation.tailrec
-import org.scalatest.concurrent.ScalaFutures
-import org.scalactic.ConversionCheckedTripleEquals
-import akka.testkit.AkkaSpec
+import org.scalatest.concurrent.PatienceConfiguration.Timeout
 
-class FlowMapAsyncUnorderedSpec extends AkkaSpec {
+import scala.annotation.tailrec
+
+class FlowMapAsyncUnorderedSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
@@ -239,7 +239,7 @@ class FlowMapAsyncUnorderedSpec extends AkkaSpec {
         Source(1 to N)
           .mapAsyncUnordered(parallelism)(i ⇒ deferred())
           .runFold(0)((c, _) ⇒ c + 1)
-          .futureValue(PatienceConfig(3.seconds)) should ===(N)
+          .futureValue(Timeout(3.seconds)) should ===(N)
       } finally {
         timer.interrupt()
       }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapConcatSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapConcatSpec.scala
index 5a7523a0c2..e05b651132 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapConcatSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapConcatSpec.scala
@@ -8,9 +8,8 @@ import akka.stream.{ Supervision, ActorAttributes, ActorMaterializer, ActorMater
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowMapConcatSpec extends AkkaSpec with ScriptedTest {
+class FlowMapConcatSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapSpec.scala
index 0f2ab8f7f3..c9e6e908e3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMapSpec.scala
@@ -4,12 +4,11 @@
 package akka.stream.scaladsl
 
 import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
-import akka.stream.ActorMaterializer
-import akka.stream.ActorMaterializerSettings
-import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowMapSpec extends AkkaSpec with ScriptedTest {
+import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
+import akka.stream.testkit._
+
+class FlowMapSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMergeSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMergeSpec.scala
index f67112f444..1c56a192ba 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMergeSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMergeSpec.scala
@@ -96,5 +96,32 @@ class FlowMergeSpec extends BaseTwoStreamsSetup {
       up1.expectSubscription().expectCancellation()
       up2.expectSubscription().expectCancellation()
     }
+
+    "not try to grab from a closed input previously enqueued" in assertAllStagesStopped {
+      // Coverage for #21138
+      val up1 = TestPublisher.probe[Int]()
+      val up2 = TestPublisher.probe[Int]()
+      val down = TestSubscriber.probe[Int]()
+
+      Source.fromPublisher(up1)
+        .merge(Source.fromPublisher(up2), eagerComplete = true)
+        .to(Sink.fromSubscriber(down))
+        .run
+
+      up1.ensureSubscription()
+      up2.ensureSubscription()
+      down.ensureSubscription()
+
+      up1.expectRequest()
+      up2.expectRequest()
+      up1.sendNext(7)
+      up2.sendNext(8)
+      // there is a race here, the 8 needs to be queued before the
+      // source completes (it failed consistently on my machine, before bugfix)
+      up2.sendComplete()
+      down.request(1)
+      down.expectNext()
+
+    }
   }
 }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMonitorSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMonitorSpec.scala
index 313fd6d208..93a53c11f3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMonitorSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowMonitorSpec.scala
@@ -3,14 +3,14 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.scaladsl.{ TestSource, TestSink }
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.AkkaSpec
 import akka.stream.FlowMonitorState._
 
 import scala.concurrent.duration._
 
-class FlowMonitorSpec extends AkkaSpec {
+class FlowMonitorSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowOnCompleteSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowOnCompleteSpec.scala
index cd0517c177..c6602adb27 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowOnCompleteSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowOnCompleteSpec.scala
@@ -12,9 +12,8 @@ import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
 import akka.testkit.TestProbe
-import akka.testkit.AkkaSpec
 
-class FlowOnCompleteSpec extends AkkaSpec with ScriptedTest {
+class FlowOnCompleteSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowPrefixAndTailSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowPrefixAndTailSpec.scala
index 91cecffb9f..404e9e6598 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowPrefixAndTailSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowPrefixAndTailSpec.scala
@@ -4,15 +4,14 @@
 package akka.stream.scaladsl
 
 import scala.collection.immutable
-import scala.concurrent.{ Await }
+import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
 import akka.stream._
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class FlowPrefixAndTailSpec extends AkkaSpec {
+class FlowPrefixAndTailSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverSpec.scala
index d08a1ecf58..e91f092fb9 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverSpec.scala
@@ -3,14 +3,14 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
 import scala.util.control.NoStackTrace
 
-class FlowRecoverSpec extends AkkaSpec {
+class FlowRecoverSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system).withInputBuffer(initialSize = 1, maxSize = 1)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverWithSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverWithSpec.scala
index ccdd739a8a..636a45cdb8 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverWithSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowRecoverWithSpec.scala
@@ -3,14 +3,14 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
 import scala.util.control.NoStackTrace
 
-class FlowRecoverWithSpec extends AkkaSpec {
+class FlowRecoverWithSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system).withInputBuffer(initialSize = 1, maxSize = 1)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowReduceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowReduceSpec.scala
index 75ae640ac5..ea163ab68e 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowReduceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowReduceSpec.scala
@@ -3,15 +3,16 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
+
 import scala.concurrent.Await
 import scala.util.control.NoStackTrace
 
 import akka.stream.ActorMaterializer
-import akka.testkit.AkkaSpec
 import akka.stream.testkit.Utils._
 import scala.concurrent.duration._
 
-class FlowReduceSpec extends AkkaSpec {
+class FlowReduceSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
 
   "A Reduce" must {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowScanSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowScanSpec.scala
index 04e377d9f8..bbe177b695 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowScanSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowScanSpec.scala
@@ -4,9 +4,9 @@
 package akka.stream.scaladsl
 
 import akka.NotUsed
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.{ ActorAttributes, ActorMaterializer, ActorMaterializerSettings, Supervision }
-import akka.testkit.AkkaSpec
 import akka.stream.testkit.Utils._
 
 import scala.collection.immutable
@@ -14,7 +14,7 @@ import scala.concurrent.Await
 import scala.concurrent.duration._
 import java.util.concurrent.ThreadLocalRandom.{ current ⇒ random }
 
-class FlowScanSpec extends AkkaSpec {
+class FlowScanSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSectionSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSectionSpec.scala
index ec27772f6c..7d4f648658 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSectionSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSectionSpec.scala
@@ -6,7 +6,7 @@ package akka.stream.scaladsl
 import akka.stream.Attributes._
 import akka.stream.ActorAttributes._
 import akka.stream.ActorMaterializer
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.actor.ActorRef
 import akka.testkit.TestProbe
 
@@ -18,7 +18,7 @@ object FlowSectionSpec {
     """
 }
 
-class FlowSectionSpec extends AkkaSpec(FlowSectionSpec.config) {
+class FlowSectionSpec extends StreamSpec(FlowSectionSpec.config) {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSlidingSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSlidingSpec.scala
index d7b207b24a..41e2ee50ce 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSlidingSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSlidingSpec.scala
@@ -7,12 +7,10 @@ import akka.stream.testkit.Utils._
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.testkit._
 import org.scalacheck.Gen
-import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.prop.GeneratorDrivenPropertyChecks
 import akka.pattern.pipe
-import akka.testkit.AkkaSpec
 
-class FlowSlidingSpec extends AkkaSpec with GeneratorDrivenPropertyChecks {
+class FlowSlidingSpec extends StreamSpec with GeneratorDrivenPropertyChecks {
   import system.dispatcher
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSpec.scala
index 8e139ba23c..2080dc1f2a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSpec.scala
@@ -7,7 +7,7 @@ import akka.NotUsed
 import akka.actor._
 import akka.stream.Supervision._
 import akka.stream.impl._
-import akka.stream.impl.fusing.{ ActorGraphInterpreter }
+import akka.stream.impl.fusing.ActorGraphInterpreter
 import akka.stream.impl.fusing.GraphInterpreter.GraphAssembly
 import akka.stream.stage.AbstractStage.PushPullGraphStage
 import akka.stream.testkit.Utils._
@@ -23,7 +23,6 @@ import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
 import akka.stream.impl.fusing.GraphInterpreterShell
-import akka.testkit.AkkaSpec
 
 object FlowSpec {
   class Fruit
@@ -32,7 +31,7 @@ object FlowSpec {
 
 }
 
-class FlowSpec extends AkkaSpec(ConfigFactory.parseString("akka.actor.debug.receive=off\nakka.loglevel=INFO")) {
+class FlowSpec extends StreamSpec(ConfigFactory.parseString("akka.actor.debug.receive=off\nakka.loglevel=INFO")) {
   import FlowSpec._
 
   val settings = ActorMaterializerSettings(system)
@@ -56,7 +55,7 @@ class FlowSpec extends AkkaSpec(ConfigFactory.parseString("akka.actor.debug.rece
   }
 
   val faultyFlow: Flow[Any, Any, NotUsed] ⇒ Flow[Any, Any, NotUsed] = in ⇒ in.via({
-    val stage = new PushPullGraphStage((_) ⇒ fusing.Map({ x: Any ⇒ x }, stoppingDecider), Attributes.none)
+    val stage = fusing.Map({ x: Any ⇒ x })
 
     val assembly = new GraphAssembly(
       Array(stage),
@@ -66,10 +65,10 @@ class FlowSpec extends AkkaSpec(ConfigFactory.parseString("akka.actor.debug.rece
       Array(null, stage.shape.out),
       Array(-1, 0))
 
-    val (inHandlers, outHandlers, logics) =
+    val (connections, logics) =
       assembly.materialize(Attributes.none, assembly.stages.map(_.module), new java.util.HashMap, _ ⇒ ())
 
-    val shell = new GraphInterpreterShell(assembly, inHandlers, outHandlers, logics, stage.shape, settings,
+    val shell = new GraphInterpreterShell(assembly, connections, logics, stage.shape, settings,
       materializer.asInstanceOf[ActorMaterializerImpl])
 
     val props = Props(new BrokenActorInterpreter(shell, "a3"))
@@ -592,7 +591,10 @@ class FlowSpec extends AkkaSpec(ConfigFactory.parseString("akka.actor.debug.rece
 
     "suitably override attribute handling methods" in {
       import Attributes._
-      val f: Flow[Int, Int, NotUsed] = Flow[Int].async.addAttributes(none).named("")
+      val f: Flow[Int, Int, NotUsed] = Flow[Int].map(_ + 1).async.addAttributes(none).named("name")
+
+      f.module.attributes.getFirst[Name] shouldEqual Some(Name("name"))
+      f.module.attributes.getFirst[Attributes.AsyncBoundary.type] shouldEqual Some(AsyncBoundary)
     }
   }
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitAfterSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitAfterSpec.scala
index 94b3d34331..0c05dbbfb1 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitAfterSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitAfterSpec.scala
@@ -6,9 +6,7 @@ package akka.stream.scaladsl
 import akka.NotUsed
 import akka.stream._
 import akka.stream.Supervision.resumingDecider
-import akka.testkit.AkkaSpec
-import akka.stream.testkit.TestPublisher
-import akka.stream.testkit.TestSubscriber
+import akka.stream.testkit.{ StreamSpec, TestPublisher, TestSubscriber }
 import akka.stream.testkit.Utils._
 import org.reactivestreams.Publisher
 import scala.concurrent.Await
@@ -24,7 +22,7 @@ object FlowSplitAfterSpec {
 
 }
 
-class FlowSplitAfterSpec extends AkkaSpec {
+class FlowSplitAfterSpec extends StreamSpec {
   import FlowSplitAfterSpec._
 
   val settings = ActorMaterializerSettings(system)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitWhenSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitWhenSpec.scala
index c1aa286526..cd0de06fc3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitWhenSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSplitWhenSpec.scala
@@ -12,9 +12,8 @@ import akka.stream.testkit._
 import org.reactivestreams.Publisher
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class FlowSplitWhenSpec extends AkkaSpec {
+class FlowSplitWhenSpec extends StreamSpec {
   import FlowSplitAfterSpec._
 
   val settings = ActorMaterializerSettings(system)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStageSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStageSpec.scala
index ecba234df3..6c75b4e088 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStageSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStageSpec.scala
@@ -17,9 +17,8 @@ import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
 import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.testkit.scaladsl.TestSource
-import akka.testkit.AkkaSpec
 
-class FlowStageSpec extends AkkaSpec(ConfigFactory.parseString("akka.actor.debug.receive=off\nakka.loglevel=INFO")) {
+class FlowStageSpec extends StreamSpec(ConfigFactory.parseString("akka.actor.debug.receive=off\nakka.loglevel=INFO")) {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 2)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStatefulMapConcatSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStatefulMapConcatSpec.scala
index 76d24bf192..47ad25d496 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStatefulMapConcatSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowStatefulMapConcatSpec.scala
@@ -7,9 +7,8 @@ import akka.stream.testkit.scaladsl.TestSink
 import akka.stream.{ ActorMaterializer, ActorAttributes, Supervision, ActorMaterializerSettings }
 import akka.stream.testkit._
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowStatefulMapConcatSpec extends AkkaSpec with ScriptedTest {
+class FlowStatefulMapConcatSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSupervisionSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSupervisionSpec.scala
index fc7e18c845..6b0094491c 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSupervisionSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowSupervisionSpec.scala
@@ -13,9 +13,8 @@ import akka.stream.Supervision
 import akka.stream.impl.ReactiveStreamsCompliance
 import akka.stream.ActorAttributes
 import akka.NotUsed
-import akka.testkit.AkkaSpec
 
-class FlowSupervisionSpec extends AkkaSpec {
+class FlowSupervisionSpec extends StreamSpec {
   import ActorAttributes.supervisionStrategy
 
   implicit val materializer = ActorMaterializer()(system)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeSpec.scala
index e564f53c7f..b6a3d5ef50 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeSpec.scala
@@ -12,9 +12,8 @@ import akka.stream.actor.ActorSubscriberMessage.OnComplete
 import akka.stream.actor.ActorSubscriberMessage.OnNext
 import akka.stream.impl.RequestMore
 import akka.stream.testkit._
-import akka.testkit.AkkaSpec
 
-class FlowTakeSpec extends AkkaSpec with ScriptedTest {
+class FlowTakeSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWhileSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWhileSpec.scala
index 34f6782667..915b89455d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWhileSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWhileSpec.scala
@@ -11,9 +11,8 @@ import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.TestSink
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowTakeWhileSpec extends AkkaSpec {
+class FlowTakeWhileSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWithinSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWithinSpec.scala
index 839380b6d1..2d1c547c0d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWithinSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowTakeWithinSpec.scala
@@ -7,9 +7,8 @@ import scala.concurrent.duration._
 import akka.stream.ActorMaterializer
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class FlowTakeWithinSpec extends AkkaSpec {
+class FlowTakeWithinSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowThrottleSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowThrottleSpec.scala
index a930e68536..255b1fbd88 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowThrottleSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowThrottleSpec.scala
@@ -12,9 +12,8 @@ import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.util.Random
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class FlowThrottleSpec extends AkkaSpec {
+class FlowThrottleSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer(ActorMaterializerSettings(system).withInputBuffer(1, 1))
 
   def genByteString(length: Int) =
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowWatchTerminationSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowWatchTerminationSpec.scala
index 40ef1adced..053471183a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowWatchTerminationSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FlowWatchTerminationSpec.scala
@@ -6,16 +6,14 @@ package akka.stream.scaladsl
 import akka.Done
 import akka.pattern.pipe
 import akka.stream._
-import akka.testkit.AkkaSpec
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.{ TestSink, TestSource }
-import org.scalactic.ConversionCheckedTripleEquals
-import org.scalatest.concurrent.ScalaFutures
 
 import scala.util.control.NoStackTrace
 import scala.concurrent.duration._
 
-class FlowWatchTerminationSpec extends AkkaSpec {
+class FlowWatchTerminationSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FramingSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FramingSpec.scala
index f85575f06e..3a8ecd2b84 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FramingSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/FramingSpec.scala
@@ -4,57 +4,72 @@
 package akka.stream.scaladsl
 
 import java.nio.ByteOrder
+import java.util.concurrent.ThreadLocalRandom
+import java.util.concurrent.atomic.AtomicLong
 
 import akka.stream.scaladsl.Framing.FramingException
-import akka.stream.stage.{ Context, PushPullStage, SyncDirective, TerminationDirective }
-import akka.stream.testkit.{ TestSubscriber, TestPublisher }
-import akka.testkit.AkkaSpec
-import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
+import akka.stream.stage.{ GraphStage, _ }
+import akka.stream.testkit.{ StreamSpec, TestPublisher, TestSubscriber }
+import akka.stream._
 import akka.util.{ ByteString, ByteStringBuilder }
 
 import scala.collection.immutable
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import java.util.concurrent.ThreadLocalRandom
 import scala.util.Random
 
-class FramingSpec extends AkkaSpec {
+class FramingSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
   implicit val materializer = ActorMaterializer(settings)
 
-  class Rechunker extends PushPullStage[ByteString, ByteString] {
-    private var rechunkBuffer = ByteString.empty
+  class Rechunker extends GraphStage[FlowShape[ByteString, ByteString]] {
 
-    override def onPush(chunk: ByteString, ctx: Context[ByteString]): SyncDirective = {
-      rechunkBuffer ++= chunk
-      rechunk(ctx)
-    }
+    val out: Outlet[ByteString] = Outlet("Rechunker.out")
+    val in: Inlet[ByteString] = Inlet("Rechunker.in")
 
-    override def onPull(ctx: Context[ByteString]): SyncDirective = {
-      rechunk(ctx)
-    }
+    override val shape: FlowShape[ByteString, ByteString] = FlowShape(in, out)
 
-    override def onUpstreamFinish(ctx: Context[ByteString]): TerminationDirective = {
-      if (rechunkBuffer.isEmpty) ctx.finish()
-      else ctx.absorbTermination()
-    }
+    override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+      new GraphStageLogic(shape) with InHandler with OutHandler {
 
-    private def rechunk(ctx: Context[ByteString]): SyncDirective = {
-      if (!ctx.isFinishing && ThreadLocalRandom.current().nextBoolean()) ctx.pull()
-      else {
-        val nextChunkSize =
-          if (rechunkBuffer.isEmpty) 0
-          else ThreadLocalRandom.current().nextInt(0, rechunkBuffer.size + 1)
-        val newChunk = rechunkBuffer.take(nextChunkSize)
-        rechunkBuffer = rechunkBuffer.drop(nextChunkSize)
-        if (ctx.isFinishing && rechunkBuffer.isEmpty) ctx.pushAndFinish(newChunk)
-        else ctx.push(newChunk)
+        private var rechunkBuffer = ByteString.empty
+
+        private def rechunk() = {
+          if (!isClosed(in) && ThreadLocalRandom.current().nextBoolean()) pull(in)
+          else {
+            val nextChunkSize =
+              if (rechunkBuffer.isEmpty) 0
+              else ThreadLocalRandom.current().nextInt(0, rechunkBuffer.size + 1)
+            val newChunk = rechunkBuffer.take(nextChunkSize).compact
+            rechunkBuffer = rechunkBuffer.drop(nextChunkSize).compact
+            if (isClosed(in) && rechunkBuffer.isEmpty) {
+              push(out, newChunk)
+              completeStage()
+            } else push(out, newChunk)
+          }
+        }
+
+        override def onPush(): Unit = {
+          rechunkBuffer ++= grab(in)
+          rechunk()
+        }
+
+        override def onPull(): Unit = {
+          rechunk()
+        }
+
+        override def onUpstreamFinish(): Unit = {
+          if (rechunkBuffer.isEmpty) completeStage()
+          else if (isAvailable(out))
+            onPull()
+        }
+
+        setHandlers(in, out, this)
       }
-    }
   }
 
-  val rechunk = Flow[ByteString].transform(() ⇒ new Rechunker).named("rechunker")
+  val rechunk = Flow[ByteString].via(new Rechunker).named("rechunker")
 
   "Delimiter bytes based framing" must {
 
@@ -72,14 +87,14 @@ class FramingSpec extends AkkaSpec {
 
     "work with various delimiters and test sequences" in {
       for (delimiter ← delimiterBytes; _ ← 1 to 100) {
-        val f = Source(completeTestSequences(delimiter))
+        val testSequence = completeTestSequences(delimiter)
+        val f = Source(testSequence)
           .map(_ ++ delimiter)
           .via(rechunk)
           .via(Framing.delimiter(delimiter, 256))
-          .grouped(1000)
-          .runWith(Sink.head)
+          .runWith(Sink.seq)
 
-        Await.result(f, 3.seconds) should be(completeTestSequences(delimiter))
+        Await.result(f, 3.seconds) should ===(testSequence)
       }
     }
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBackedFlowSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBackedFlowSpec.scala
index 67bb7f1f1f..c188f47478 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBackedFlowSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBackedFlowSpec.scala
@@ -8,7 +8,6 @@ import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream._
 import org.reactivestreams.Subscriber
-import akka.testkit.AkkaSpec
 
 object GraphFlowSpec {
   val source1 = Source(0 to 3)
@@ -36,7 +35,7 @@ object GraphFlowSpec {
   val stdResult = Set(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 }
 
-class GraphFlowSpec extends AkkaSpec {
+class GraphFlowSpec extends StreamSpec {
 
   import GraphFlowSpec._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBalanceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBalanceSpec.scala
index 25737fdf65..0bffe24625 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBalanceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBalanceSpec.scala
@@ -3,13 +3,13 @@ package akka.stream.scaladsl
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.concurrent.Future
-import akka.stream.{ SourceShape, ClosedShape, ActorMaterializer, ActorMaterializerSettings }
+import akka.stream._
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
+import akka.util.ByteString
 
-class GraphBalanceSpec extends AkkaSpec {
+class GraphBalanceSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
@@ -257,6 +257,36 @@ class GraphBalanceSpec extends AkkaSpec {
       bsub.expectCancellation()
     }
 
+    // Bug #20943
+    "not push output twice" in assertAllStagesStopped {
+      val p1 = TestPublisher.manualProbe[Int]()
+      val c1 = TestSubscriber.manualProbe[Int]()
+      val c2 = TestSubscriber.manualProbe[Int]()
+
+      RunnableGraph.fromGraph(GraphDSL.create() { implicit b ⇒
+        val balance = b.add(Balance[Int](2))
+        Source.fromPublisher(p1.getPublisher) ~> balance.in
+        balance.out(0) ~> Sink.fromSubscriber(c1)
+        balance.out(1) ~> Sink.fromSubscriber(c2)
+        ClosedShape
+      }).run()
+
+      val bsub = p1.expectSubscription()
+      val sub1 = c1.expectSubscription()
+      val sub2 = c2.expectSubscription()
+
+      sub1.request(1)
+      p1.expectRequest(bsub, 16)
+      bsub.sendNext(1)
+      c1.expectNext(1)
+
+      sub2.request(1)
+      sub2.cancel()
+      bsub.sendNext(2)
+
+      sub1.cancel()
+      bsub.expectCancellation()
+    }
   }
 
 }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBroadcastSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBroadcastSpec.scala
index 6de5b1a1a8..e525f18107 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBroadcastSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphBroadcastSpec.scala
@@ -6,9 +6,8 @@ import scala.concurrent.duration._
 import akka.stream._
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class GraphBroadcastSpec extends AkkaSpec {
+class GraphBroadcastSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphDSLCompileSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphDSLCompileSpec.scala
index aed95477e2..36592d5b86 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphDSLCompileSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphDSLCompileSpec.scala
@@ -3,17 +3,18 @@
  */
 package akka.stream.scaladsl
 
-import akka.stream.{ ClosedShape, ActorMaterializer, OverflowStrategy }
+import akka.NotUsed
+import akka.stream.impl.fusing.GraphStages
+import akka.stream.{ ActorMaterializer, ClosedShape, FlowShape, OverflowStrategy }
 import akka.stream.testkit._
 import akka.stream.stage._
-import akka.testkit.AkkaSpec
 
 object GraphDSLCompileSpec {
   class Fruit
   class Apple extends Fruit
 }
 
-class GraphDSLCompileSpec extends AkkaSpec {
+class GraphDSLCompileSpec extends StreamSpec {
   import GraphDSLCompileSpec._
 
   implicit val materializer = ActorMaterializer()
@@ -340,5 +341,18 @@ class GraphDSLCompileSpec extends AkkaSpec {
         ClosedShape
       }).run()
     }
+
+    "suitably override attribute handling methods" in {
+      import akka.stream.Attributes._
+      val ga = GraphDSL.create() { implicit b ⇒
+        import GraphDSL.Implicits._
+        val id = b.add(GraphStages.Identity)
+
+        FlowShape(id.in, id.out)
+      }.async.addAttributes(none).named("useless")
+
+      ga.module.attributes.getFirst[Name] shouldEqual Some(Name("useless"))
+      ga.module.attributes.getFirst[AsyncBoundary.type] shouldEqual (Some(AsyncBoundary))
+    }
   }
 }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphMatValueSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphMatValueSpec.scala
index 631dcc5a54..cb524e0a16 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphMatValueSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphMatValueSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.testkit._
 import scala.concurrent.Await
 import scala.concurrent.Future
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class GraphMatValueSpec extends AkkaSpec {
+class GraphMatValueSpec extends StreamSpec {
 
   import GraphDSL.Implicits._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphOpsIntegrationSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphOpsIntegrationSpec.scala
index cad98ad609..07d837f67a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphOpsIntegrationSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphOpsIntegrationSpec.scala
@@ -6,8 +6,6 @@ import scala.concurrent.{ Future, Await }
 import scala.concurrent.duration._
 import akka.stream._
 import akka.stream.testkit._
-import org.scalactic.ConversionCheckedTripleEquals
-import akka.testkit.AkkaSpec
 
 object GraphOpsIntegrationSpec {
   import GraphDSL.Implicits._
@@ -43,7 +41,7 @@ object GraphOpsIntegrationSpec {
 
 }
 
-class GraphOpsIntegrationSpec extends AkkaSpec {
+class GraphOpsIntegrationSpec extends StreamSpec {
   import akka.stream.scaladsl.GraphOpsIntegrationSpec._
   import GraphDSL.Implicits._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartialSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartialSpec.scala
index cb4ffdf612..07c0189974 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartialSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartialSpec.scala
@@ -1,12 +1,12 @@
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ ClosedShape, ActorMaterializer, ActorMaterializerSettings, FlowShape }
-import akka.testkit.AkkaSpec
 
-import scala.concurrent.{ Await }
+import scala.concurrent.Await
 import scala.concurrent.duration._
 
-class GraphPartialSpec extends AkkaSpec {
+class GraphPartialSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartitionSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartitionSpec.scala
index a30c3a31f3..8cc1926ae6 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartitionSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphPartitionSpec.scala
@@ -9,9 +9,8 @@ import akka.stream.testkit.Utils._
 import org.scalatest.concurrent.ScalaFutures
 import scala.concurrent.Await
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class GraphPartitionSpec extends AkkaSpec {
+class GraphPartitionSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphStageTimersSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphStageTimersSpec.scala
index 261b6c082c..2540b1e580 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphStageTimersSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphStageTimersSpec.scala
@@ -7,7 +7,6 @@ import akka.actor.ActorRef
 import akka.stream.{ Attributes, ActorMaterializer }
 import akka.stream.impl.fusing.GraphStages.SimpleLinearGraphStage
 import akka.stream.stage.{ TimerGraphStageLogic, OutHandler, AsyncCallback, InHandler }
-import akka.testkit.AkkaSpec
 import akka.testkit.TestDuration
 
 import scala.concurrent.Promise
@@ -36,7 +35,7 @@ object GraphStageTimersSpec {
 
 }
 
-class GraphStageTimersSpec extends AkkaSpec {
+class GraphStageTimersSpec extends StreamSpec {
   import GraphStageTimersSpec._
 
   implicit val materializer = ActorMaterializer()
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipSpec.scala
index d0f9be0c78..c74e40d36f 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipSpec.scala
@@ -7,9 +7,8 @@ import scala.concurrent.duration._
 import akka.stream.{ ClosedShape, OverflowStrategy, ActorMaterializerSettings, ActorMaterializer }
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class GraphUnzipSpec extends AkkaSpec {
+class GraphUnzipSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipWithSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipWithSpec.scala
index 903c7a3c75..d9ee1aa358 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipWithSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/GraphUnzipWithSpec.scala
@@ -11,9 +11,8 @@ import org.reactivestreams.Publisher
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
 import akka.testkit.EventFilter
-import akka.testkit.AkkaSpec
 
-class GraphUnzipWithSpec extends AkkaSpec {
+class GraphUnzipWithSpec extends StreamSpec {
 
   import GraphDSL.Implicits._
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/HeadSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/HeadSinkSpec.scala
index e9a73c30e3..60d16b36e4 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/HeadSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/HeadSinkSpec.scala
@@ -11,9 +11,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class HeadSinkSpec extends AkkaSpec with ScriptedTest {
+class HeadSinkSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/JsonFramingSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/JsonFramingSpec.scala
new file mode 100644
index 0000000000..562789ebba
--- /dev/null
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/JsonFramingSpec.scala
@@ -0,0 +1,475 @@
+/*
+ * Copyright (C) 2009-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.stream.scaladsl
+
+import akka.stream.ActorMaterializer
+import akka.stream.impl.JsonObjectParser
+import akka.stream.scaladsl.Framing.FramingException
+import akka.stream.testkit.{ TestPublisher, TestSubscriber }
+import akka.stream.testkit.scaladsl.TestSink
+import akka.testkit.AkkaSpec
+import akka.util.ByteString
+
+import scala.collection.immutable.Seq
+import scala.concurrent.Await
+import scala.concurrent.duration._
+
+class JsonFramingSpec extends AkkaSpec {
+
+  implicit val mat = ActorMaterializer()
+
+  "collecting multiple json" should {
+    "parse json array" in {
+      val input =
+        """
+          |[
+          | { "name" : "john" },
+          | { "name" : "Ég get etið gler án þess að meiða mig" },
+          | { "name" : "jack" },
+          |]
+          |""".stripMargin // also should complete once notices end of array
+
+      val result = Source.single(ByteString(input))
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry.utf8String)
+        }
+
+      result.futureValue shouldBe Seq(
+        """{ "name" : "john" }""",
+        """{ "name" : "Ég get etið gler án þess að meiða mig" }""",
+        """{ "name" : "jack" }"""
+      )
+    }
+
+    "emit single json element from string" in {
+      val input =
+        """| { "name": "john" }
+           | { "name": "jack" }
+        """.stripMargin
+
+      val result = Source.single(ByteString(input))
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .take(1)
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry.utf8String)
+        }
+
+      Await.result(result, 3.seconds) shouldBe Seq("""{ "name": "john" }""")
+    }
+
+    "parse line delimited" in {
+      val input =
+        """| { "name": "john" }
+           | { "name": "jack" }
+           | { "name": "katie" }
+        """.stripMargin
+
+      val result = Source.single(ByteString(input))
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry.utf8String)
+        }
+
+      Await.result(result, 3.seconds) shouldBe Seq(
+        """{ "name": "john" }""",
+        """{ "name": "jack" }""",
+        """{ "name": "katie" }""")
+    }
+
+    "parse comma delimited" in {
+      val input =
+        """  { "name": "john" }, { "name": "jack" }, { "name": "katie" }  """
+
+      val result = Source.single(ByteString(input))
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry.utf8String)
+        }
+
+      result.futureValue shouldBe Seq(
+        """{ "name": "john" }""",
+        """{ "name": "jack" }""",
+        """{ "name": "katie" }""")
+    }
+
+    "parse chunks successfully" in {
+      val input: Seq[ByteString] = Seq(
+        """
+          |[
+          |  { "name": "john"""".stripMargin,
+        """
+          |},
+        """.stripMargin,
+        """{ "na""",
+        """me": "jack""",
+        """"}]"""").map(ByteString(_))
+
+      val result = Source.apply(input)
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry.utf8String)
+        }
+
+      result.futureValue shouldBe Seq(
+        """{ "name": "john"
+          |}""".stripMargin,
+        """{ "name": "jack"}""")
+    }
+
+    "emit all elements after input completes" in {
+      // coverage for #21150
+      val input = TestPublisher.probe[ByteString]()
+      val output = TestSubscriber.probe[String]()
+
+      val result = Source.fromPublisher(input)
+        .via(JsonFraming.objectScanner(Int.MaxValue))
+        .map(_.utf8String)
+        .runWith(Sink.fromSubscriber(output))
+
+      output.request(1)
+      input.expectRequest()
+      input.sendNext(ByteString("""[{"a":0}, {"b":1}, {"c":2}, {"d":3}, {"e":4}]"""))
+      input.sendComplete()
+      Thread.sleep(10) // another of those races, we don't know the order of next and complete
+      output.expectNext("""{"a":0}""")
+      output.request(1)
+      output.expectNext("""{"b":1}""")
+      output.request(1)
+      output.expectNext("""{"c":2}""")
+      output.request(1)
+      output.expectNext("""{"d":3}""")
+      output.request(1)
+      output.expectNext("""{"e":4}""")
+      output.request(1)
+      output.expectComplete()
+    }
+  }
+
+  "collecting json buffer" when {
+    "nothing is supplied" should {
+      "return nothing" in {
+        val buffer = new JsonObjectParser()
+        buffer.poll() should ===(None)
+      }
+    }
+
+    "valid json is supplied" which {
+      "has one object" should {
+        "successfully parse empty object" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{}"""))
+          buffer.poll().get.utf8String shouldBe """{}"""
+        }
+
+        "successfully parse single field having string value" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "name": "john"}"""))
+          buffer.poll().get.utf8String shouldBe """{ "name": "john"}"""
+        }
+
+        "successfully parse single field having string value containing space" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "name": "john doe"}"""))
+          buffer.poll().get.utf8String shouldBe """{ "name": "john doe"}"""
+        }
+
+        "successfully parse single field having string value containing single quote" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "name": "john o'doe"}"""))
+          buffer.poll().get.utf8String shouldBe """{ "name": "john o'doe"}"""
+        }
+
+        "successfully parse single field having string value containing curly brace" in {
+          val buffer = new JsonObjectParser()
+
+          buffer.offer(ByteString("""{ "name": "john{"""))
+          buffer.offer(ByteString("}"))
+          buffer.offer(ByteString("\""))
+          buffer.offer(ByteString("}"))
+
+          buffer.poll().get.utf8String shouldBe """{ "name": "john{}"}"""
+        }
+
+        "successfully parse single field having string value containing curly brace and escape character" in {
+          val buffer = new JsonObjectParser()
+
+          buffer.offer(ByteString("""{ "name": "john"""))
+          buffer.offer(ByteString("\\\""))
+          buffer.offer(ByteString("{"))
+          buffer.offer(ByteString("}"))
+          buffer.offer(ByteString("\\\""))
+          buffer.offer(ByteString(" "))
+          buffer.offer(ByteString("hey"))
+          buffer.offer(ByteString("\""))
+
+          buffer.offer(ByteString("}"))
+          buffer.poll().get.utf8String shouldBe """{ "name": "john\"{}\" hey"}"""
+        }
+
+        "successfully parse single field having integer value" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "age": 101}"""))
+          buffer.poll().get.utf8String shouldBe """{ "age": 101}"""
+        }
+
+        "successfully parse single field having decimal value" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "age": 101}"""))
+          buffer.poll().get.utf8String shouldBe """{ "age": 101}"""
+        }
+
+        "successfully parse single field having nested object" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(
+            """
+              |{  "name": "john",
+              |   "age": 101,
+              |   "address": {
+              |     "street": "Straight Street",
+              |     "postcode": 1234
+              |   }
+              |}
+              | """.stripMargin))
+          buffer.poll().get.utf8String shouldBe """{  "name": "john",
+                                                      |   "age": 101,
+                                                      |   "address": {
+                                                      |     "street": "Straight Street",
+                                                      |     "postcode": 1234
+                                                      |   }
+                                                      |}""".stripMargin
+        }
+
+        "successfully parse single field having multiple level of nested object" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(
+            """
+              |{  "name": "john",
+              |   "age": 101,
+              |   "address": {
+              |     "street": {
+              |       "name": "Straight",
+              |       "type": "Avenue"
+              |     },
+              |     "postcode": 1234
+              |   }
+              |}
+              | """.stripMargin))
+          buffer.poll().get.utf8String shouldBe """{  "name": "john",
+                                                      |   "age": 101,
+                                                      |   "address": {
+                                                      |     "street": {
+                                                      |       "name": "Straight",
+                                                      |       "type": "Avenue"
+                                                      |     },
+                                                      |     "postcode": 1234
+                                                      |   }
+                                                      |}""".stripMargin
+        }
+      }
+
+      "has nested array" should {
+        "successfully parse" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(
+            """
+              |{  "name": "john",
+              |   "things": [
+              |     1,
+              |     "hey",
+              |     3,
+              |     "there"
+              |   ]
+              |}
+              | """.stripMargin))
+          buffer.poll().get.utf8String shouldBe """{  "name": "john",
+                                                      |   "things": [
+                                                      |     1,
+                                                      |     "hey",
+                                                      |     3,
+                                                      |     "there"
+                                                      |   ]
+                                                      |}""".stripMargin
+        }
+      }
+
+      "has complex object graph" should {
+        "successfully parse" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(
+            """
+              |{
+              |  "name": "john",
+              |  "addresses": [
+              |    {
+              |      "street": "3 Hopson Street",
+              |      "postcode": "ABC-123",
+              |      "tags": ["work", "office"],
+              |      "contactTime": [
+              |        {"time": "0900-1800", "timezone", "UTC"}
+              |      ]
+              |    },
+              |    {
+              |      "street": "12 Adielie Road",
+              |      "postcode": "ZZY-888",
+              |      "tags": ["home"],
+              |      "contactTime": [
+              |        {"time": "0800-0830", "timezone", "UTC"},
+              |        {"time": "1800-2000", "timezone", "UTC"}
+              |      ]
+              |    }
+              |  ]
+              |}
+              | """.stripMargin))
+
+          buffer.poll().get.utf8String shouldBe """{
+                                                      |  "name": "john",
+                                                      |  "addresses": [
+                                                      |    {
+                                                      |      "street": "3 Hopson Street",
+                                                      |      "postcode": "ABC-123",
+                                                      |      "tags": ["work", "office"],
+                                                      |      "contactTime": [
+                                                      |        {"time": "0900-1800", "timezone", "UTC"}
+                                                      |      ]
+                                                      |    },
+                                                      |    {
+                                                      |      "street": "12 Adielie Road",
+                                                      |      "postcode": "ZZY-888",
+                                                      |      "tags": ["home"],
+                                                      |      "contactTime": [
+                                                      |        {"time": "0800-0830", "timezone", "UTC"},
+                                                      |        {"time": "1800-2000", "timezone", "UTC"}
+                                                      |      ]
+                                                      |    }
+                                                      |  ]
+                                                      |}""".stripMargin
+        }
+      }
+
+      "has multiple fields" should {
+        "parse successfully" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "name": "john", "age": 101}"""))
+          buffer.poll().get.utf8String shouldBe """{ "name": "john", "age": 101}"""
+        }
+
+        "parse successfully despite valid whitespaces around json" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(
+            """
+              |
+              |
+              |{"name":   "john"
+              |, "age": 101}""".stripMargin))
+          buffer.poll().get.utf8String shouldBe
+            """{"name":   "john"
+              |, "age": 101}""".stripMargin
+        }
+      }
+
+      "has multiple objects" should {
+        "pops the right object as buffer is filled" in {
+          val input =
+            """
+              |  {
+              |    "name": "john",
+              |    "age": 32
+              |  },
+              |  {
+              |    "name": "katie",
+              |    "age": 25
+              |  }
+            """.stripMargin
+
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString(input))
+
+          buffer.poll().get.utf8String shouldBe
+            """{
+              |    "name": "john",
+              |    "age": 32
+              |  }""".stripMargin
+          buffer.poll().get.utf8String shouldBe
+            """{
+              |    "name": "katie",
+              |    "age": 25
+              |  }""".stripMargin
+          buffer.poll() should ===(None)
+
+          buffer.offer(ByteString("""{"name":"jenkins","age": """))
+          buffer.poll() should ===(None)
+
+          buffer.offer(ByteString("65 }"))
+          buffer.poll().get.utf8String shouldBe """{"name":"jenkins","age": 65 }"""
+        }
+      }
+
+      "returns none until valid json is encountered" in {
+        val buffer = new JsonObjectParser()
+
+        """{ "name": "john"""".foreach {
+          c ⇒
+            buffer.offer(ByteString(c))
+            buffer.poll() should ===(None)
+        }
+
+        buffer.offer(ByteString("}"))
+        buffer.poll().get.utf8String shouldBe """{ "name": "john"}"""
+      }
+
+      "invalid json is supplied" should {
+        "fail if it's broken from the start" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""THIS IS NOT VALID { "name": "john"}"""))
+          a[FramingException] shouldBe thrownBy { buffer.poll() }
+        }
+
+        "fail if it's broken at the end" in {
+          val buffer = new JsonObjectParser()
+          buffer.offer(ByteString("""{ "name": "john"} THIS IS NOT VALID"""))
+          buffer.poll() // first emitting the valid element
+          a[FramingException] shouldBe thrownBy { buffer.poll() }
+        }
+      }
+    }
+
+    "fail on too large initial object" in {
+      val input =
+        """
+          | { "name": "john" }, { "name": "jack" }
+        """.stripMargin
+
+      val result = Source.single(ByteString(input))
+        .via(JsonFraming.objectScanner(5)).map(_.utf8String)
+        .runFold(Seq.empty[String]) {
+          case (acc, entry) ⇒ acc ++ Seq(entry)
+        }
+
+      a[FramingException] shouldBe thrownBy {
+        Await.result(result, 3.seconds)
+      }
+    }
+
+    "fail when 2nd object is too large" in {
+      val input = List(
+        """{ "name": "john" }""",
+        """{ "name": "jack" }""",
+        """{ "name": "very very long name somehow. how did this happen?" }""").map(s ⇒ ByteString(s))
+
+      val probe = Source(input)
+        .via(JsonFraming.objectScanner(48))
+        .runWith(TestSink.probe)
+
+      probe.ensureSubscription()
+      probe
+        .request(1)
+        .expectNext(ByteString("""{ "name": "john" }"""))
+        .request(1)
+        .expectNext(ByteString("""{ "name": "jack" }"""))
+        .request(1)
+        .expectError().getMessage should include("exceeded")
+    }
+  }
+}
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LastSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LastSinkSpec.scala
index 16a8e69347..dcee12902d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LastSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LastSinkSpec.scala
@@ -10,9 +10,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class LastSinkSpec extends AkkaSpec with ScriptedTest {
+class LastSinkSpec extends StreamSpec with ScriptedTest {
 
   val settings = ActorMaterializerSettings(system)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LazySinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LazySinkSpec.scala
index ee806f3eea..943ca3aabe 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LazySinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/LazySinkSpec.scala
@@ -8,16 +8,15 @@ import java.util.concurrent.TimeoutException
 import akka.stream.ActorAttributes.supervisionStrategy
 import akka.stream.Supervision._
 import akka.stream._
-import akka.stream.testkit.TestPublisher
+import akka.stream.testkit.{ StreamSpec, TestPublisher }
 import akka.stream.testkit.TestSubscriber.Probe
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSink
-import akka.testkit.AkkaSpec
 
 import scala.concurrent.{ Promise, Future, Await }
 import scala.concurrent.duration._
 
-class LazySinkSpec extends AkkaSpec {
+class LazySinkSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 1, maxSize = 1)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/PublisherSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/PublisherSinkSpec.scala
index 53e728e67e..3b79135e96 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/PublisherSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/PublisherSinkSpec.scala
@@ -3,15 +3,15 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ ClosedShape, ActorMaterializer }
 
-import akka.testkit.AkkaSpec
 import akka.stream.testkit.Utils._
 import scala.concurrent.duration._
 
 import scala.concurrent.Await
 
-class PublisherSinkSpec extends AkkaSpec {
+class PublisherSinkSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSinkSpec.scala
index aeebb483a1..73531d4f77 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSinkSpec.scala
@@ -6,16 +6,14 @@ package akka.stream.scaladsl
 import akka.actor.Status
 import akka.pattern.pipe
 import akka.stream.Attributes.inputBuffer
-import akka.stream.{ ActorMaterializer }
+import akka.stream.ActorMaterializer
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
-import org.scalatest.concurrent.ScalaFutures
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
-import akka.testkit.AkkaSpec
 
-class QueueSinkSpec extends AkkaSpec {
+class QueueSinkSpec extends StreamSpec {
   implicit val ec = system.dispatcher
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSourceSpec.scala
index ce78c46ed6..157fd54708 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/QueueSourceSpec.scala
@@ -3,23 +3,19 @@
  */
 package akka.stream.scaladsl
 
-import akka.actor.{ Status }
+import akka.actor.Status
 import akka.pattern.pipe
 import akka.stream._
 import akka.stream.impl.QueueSource
 import akka.stream.testkit.Utils._
-import akka.testkit.{ AkkaSpec, TestProbe }
+import akka.testkit.TestProbe
 import scala.concurrent.duration._
 import scala.concurrent._
 import akka.Done
-import org.scalatest.concurrent.ScalaFutures
-import akka.testkit.AkkaSpec
-import akka.stream.testkit.TestSubscriber
-import akka.stream.testkit.TestSourceStage
-import akka.stream.testkit.GraphStageMessages
+import akka.stream.testkit.{ StreamSpec, TestSubscriber, TestSourceStage, GraphStageMessages }
 import akka.stream.testkit.scaladsl.TestSink
 
-class QueueSourceSpec extends AkkaSpec {
+class QueueSourceSpec extends StreamSpec {
   implicit val materializer = ActorMaterializer()
   implicit val ec = system.dispatcher
   val pause = 300.millis
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ReverseArrowSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ReverseArrowSpec.scala
index 1025f07ab0..35c1a287bb 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ReverseArrowSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/ReverseArrowSpec.scala
@@ -5,9 +5,8 @@ import akka.stream._
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import org.scalactic.ConversionCheckedTripleEquals
-import akka.testkit.AkkaSpec
 
-class ReverseArrowSpec extends AkkaSpec {
+class ReverseArrowSpec extends StreamSpec {
   import GraphDSL.Implicits._
 
   implicit val materializer = ActorMaterializer()
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/RunnableGraphSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/RunnableGraphSpec.scala
new file mode 100644
index 0000000000..723c94f530
--- /dev/null
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/RunnableGraphSpec.scala
@@ -0,0 +1,25 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.stream.scaladsl
+
+import akka.NotUsed
+import akka.stream.{ ActorMaterializer, Attributes }
+import akka.stream.testkit.StreamSpec
+
+class RunnableGraphSpec extends StreamSpec {
+
+  implicit val materializer = ActorMaterializer()
+
+  "A RunnableGraph" must {
+
+    "suitably override attribute handling methods" in {
+      import Attributes._
+      val r: RunnableGraph[NotUsed] = RunnableGraph.fromGraph(Source.empty.to(Sink.ignore)).async.addAttributes(none).named("useless")
+
+      r.module.attributes.getFirst[Name] shouldEqual Some(Name("useless"))
+      r.module.attributes.getFirst[AsyncBoundary.type] shouldEqual (Some(AsyncBoundary))
+    }
+
+  }
+}
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SeqSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SeqSinkSpec.scala
index c4a95ceada..71e8477736 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SeqSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SeqSinkSpec.scala
@@ -3,13 +3,12 @@
  */
 package akka.stream.scaladsl
 
+import akka.stream.testkit.StreamSpec
 import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
-import akka.testkit.AkkaSpec
 import scala.collection.immutable
 import scala.concurrent.{ Future, Await }
-import scala.concurrent.duration._
 
-class SeqSinkSpec extends AkkaSpec {
+class SeqSinkSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
index 3016309c9a..74cc827994 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
@@ -11,10 +11,9 @@ import akka.stream._
 import akka.stream.testkit.Utils._
 import akka.stream.testkit._
 import akka.stream.testkit.scaladsl.TestSource
-import akka.testkit.AkkaSpec
 import akka.util.ByteString
 
-class SinkAsJavaStreamSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class SinkAsJavaStreamSpec extends StreamSpec(UnboundedMailboxConfig) {
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkForeachParallelSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkForeachParallelSpec.scala
index 600b621a4b..e20a0cdf8c 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkForeachParallelSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkForeachParallelSpec.scala
@@ -8,15 +8,15 @@ import java.util.concurrent.{ CountDownLatch, TimeUnit }
 import akka.stream.ActorMaterializer
 import akka.stream.ActorAttributes._
 import akka.stream.Supervision._
+import akka.stream.testkit.StreamSpec
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 import akka.testkit.{ TestLatch, TestProbe }
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
 import scala.util.control.NoStackTrace
 
-class SinkForeachParallelSpec extends AkkaSpec {
+class SinkForeachParallelSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
index 4a1b9e492c..086c8a5331 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
@@ -16,9 +16,8 @@ import akka.testkit.DefaultTimeout
 import org.scalatest.concurrent.ScalaFutures
 import scala.concurrent.{ Await, Future }
 import scala.concurrent.duration._
-import akka.testkit.AkkaSpec
 
-class SinkSpec extends AkkaSpec with DefaultTimeout with ScalaFutures {
+class SinkSpec extends StreamSpec with DefaultTimeout with ScalaFutures {
 
   import GraphDSL.Implicits._
 
@@ -128,7 +127,10 @@ class SinkSpec extends AkkaSpec with DefaultTimeout with ScalaFutures {
 
     "suitably override attribute handling methods" in {
       import Attributes._
-      val s: Sink[Int, Future[Int]] = Sink.head[Int].async.addAttributes(none).named("")
+      val s: Sink[Int, Future[Int]] = Sink.head[Int].async.addAttributes(none).named("name")
+
+      s.module.attributes.getFirst[Name] shouldEqual Some(Name("name"))
+      s.module.attributes.getFirst[AsyncBoundary.type] shouldEqual (Some(AsyncBoundary))
     }
 
     "support contramap" in {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SourceSpec.scala
index 1beda33549..21ece8e421 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SourceSpec.scala
@@ -14,10 +14,9 @@ import akka.stream._
 import akka.stream.testkit._
 import akka.NotUsed
 import akka.testkit.EventFilter
-import akka.testkit.AkkaSpec
 import scala.collection.immutable
 
-class SourceSpec extends AkkaSpec with DefaultTimeout {
+class SourceSpec extends StreamSpec with DefaultTimeout {
 
   implicit val materializer = ActorMaterializer()
   implicit val config = PatienceConfig(timeout = Span(timeout.duration.toMillis, Millis))
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StageActorRefSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StageActorRefSpec.scala
index 566e036383..8d738a1abf 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StageActorRefSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StageActorRefSpec.scala
@@ -7,13 +7,13 @@ import akka.actor.{ Kill, PoisonPill, NoSerializationVerificationNeeded, ActorRe
 import akka.event.Logging
 import akka.stream._
 import akka.stream.stage.{ GraphStageWithMaterializedValue, GraphStageLogic, InHandler }
-import akka.testkit.{ AkkaSpec, TestProbe, TestEvent, EventFilter, ImplicitSender }
-import org.scalatest.concurrent.ScalaFutures
+import akka.stream.testkit.StreamSpec
+import akka.testkit.{ TestProbe, TestEvent, EventFilter, ImplicitSender }
 
 import scala.concurrent.{ Future, Promise }
 import scala.concurrent.duration._
 
-class StageActorRefSpec extends AkkaSpec with ImplicitSender {
+class StageActorRefSpec extends StreamSpec with ImplicitSender {
   implicit val materializer = ActorMaterializer()
 
   import StageActorRefSpec._
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSinkSpec.scala
index 293530e9e9..46083b9546 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSinkSpec.scala
@@ -7,9 +7,8 @@ import akka.stream.ActorMaterializer
 import akka.stream.ActorMaterializerSettings
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class SubscriberSinkSpec extends AkkaSpec {
+class SubscriberSinkSpec extends StreamSpec {
 
   val settings = ActorMaterializerSettings(system)
     .withInputBuffer(initialSize = 2, maxSize = 16)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSourceSpec.scala
index ec0d9f8bfb..b329da179a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubscriberSourceSpec.scala
@@ -4,13 +4,13 @@
 package akka.stream.scaladsl
 
 import akka.stream.ActorMaterializer
+import akka.stream.testkit.StreamSpec
 
-import akka.testkit.AkkaSpec
 import scala.concurrent.duration._
 
 import scala.concurrent.Await
 
-class SubscriberSourceSpec extends AkkaSpec {
+class SubscriberSourceSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubstreamSubscriptionTimeoutSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubstreamSubscriptionTimeoutSpec.scala
index dcfb94fda8..3eee036947 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubstreamSubscriptionTimeoutSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SubstreamSubscriptionTimeoutSpec.scala
@@ -7,12 +7,11 @@ import akka.stream.{ ActorMaterializer, ActorMaterializerSettings }
 import akka.stream.impl.SubscriptionTimeoutException
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
 import scala.concurrent.Await
 import scala.concurrent.duration._
 
-class SubstreamSubscriptionTimeoutSpec(conf: String) extends AkkaSpec(conf) {
+class SubstreamSubscriptionTimeoutSpec(conf: String) extends StreamSpec(conf) {
   import FlowGroupBySpec._
 
   def this(subscriptionTimeout: FiniteDuration) {
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/TickSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/TickSourceSpec.scala
index 7c817e5faf..5549bb3704 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/TickSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/TickSourceSpec.scala
@@ -7,21 +7,17 @@ import scala.concurrent.duration._
 import akka.stream.{ ClosedShape, ActorMaterializer }
 import akka.stream.testkit._
 import akka.stream.testkit.Utils._
-import akka.testkit.AkkaSpec
 
-class TickSourceSpec extends AkkaSpec {
+class TickSourceSpec extends StreamSpec {
 
   implicit val materializer = ActorMaterializer()
 
   "A Flow based on tick publisher" must {
     "produce ticks" in assertAllStagesStopped {
       val c = TestSubscriber.manualProbe[String]()
-      Source.tick(1.second, 500.millis, "tick").to(Sink.fromSubscriber(c)).run()
+      Source.tick(1.second, 1.second, "tick").to(Sink.fromSubscriber(c)).run()
       val sub = c.expectSubscription()
-      sub.request(3)
-      c.expectNoMsg(600.millis)
-      c.expectNext("tick")
-      c.expectNoMsg(200.millis)
+      sub.request(2)
       c.expectNext("tick")
       c.expectNoMsg(200.millis)
       c.expectNext("tick")
@@ -85,16 +81,14 @@ class TickSourceSpec extends AkkaSpec {
 
     "be possible to cancel" in assertAllStagesStopped {
       val c = TestSubscriber.manualProbe[String]()
-      val tickSource = Source.tick(1.second, 500.millis, "tick")
+      val tickSource = Source.tick(1.second, 1.second, "tick")
       val cancellable = tickSource.to(Sink.fromSubscriber(c)).run()
       val sub = c.expectSubscription()
-      sub.request(3)
+      sub.request(2)
       c.expectNoMsg(600.millis)
       c.expectNext("tick")
       c.expectNoMsg(200.millis)
       c.expectNext("tick")
-      c.expectNoMsg(200.millis)
-      c.expectNext("tick")
       cancellable.cancel()
       awaitCond(cancellable.isCancelled)
       sub.request(3)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceAsyncSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceAsyncSourceSpec.scala
index 669f8a6e6e..cf8467876a 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceAsyncSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceAsyncSourceSpec.scala
@@ -6,23 +6,21 @@ package akka.stream.scaladsl
 import java.io._
 
 import akka.Done
-import akka.actor.{ NoSerializationVerificationNeeded, ActorSystem }
+import akka.actor.ActorSystem
 import akka.stream.ActorAttributes._
 import akka.stream.Supervision._
 import akka.stream.{ ActorMaterializer, _ }
 import akka.stream.impl.StreamSupervisor.Children
 import akka.stream.impl.{ ActorMaterializerImpl, StreamSupervisor }
-import akka.stream.testkit.TestSubscriber
+import akka.stream.testkit.{ StreamSpec, TestSubscriber }
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSink
-import akka.util.{ ByteString, Timeout }
-import akka.testkit.AkkaSpec
+import akka.util.ByteString
 
 import scala.concurrent.{ Await, Future, Promise }
 import scala.concurrent.duration._
-import scala.util.control.NoStackTrace
 
-class UnfoldResourceAsyncSourceSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class UnfoldResourceAsyncSourceSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceSourceSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceSourceSpec.scala
index bfd560f2f1..15cd88c5a6 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceSourceSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/UnfoldResourceSourceSpec.scala
@@ -11,16 +11,14 @@ import akka.stream.Supervision._
 import akka.stream.{ ActorMaterializer, _ }
 import akka.stream.impl.StreamSupervisor.Children
 import akka.stream.impl.{ ActorMaterializerImpl, StreamSupervisor }
-import akka.stream.testkit.TestSubscriber
+import akka.stream.testkit.{ StreamSpec, TestSubscriber }
 import akka.stream.testkit.Utils._
 import akka.stream.testkit.scaladsl.TestSink
-import akka.util.{ ByteString, Timeout }
-import akka.testkit.AkkaSpec
+import akka.util.ByteString
 
 import scala.concurrent.duration._
-import scala.util.control.NoStackTrace
 
-class UnfoldResourceSourceSpec extends AkkaSpec(UnboundedMailboxConfig) {
+class UnfoldResourceSourceSpec extends StreamSpec(UnboundedMailboxConfig) {
 
   val settings = ActorMaterializerSettings(system).withDispatcher("akka.actor.default-dispatcher")
   implicit val materializer = ActorMaterializer(settings)
diff --git a/akka-stream/src/main/boilerplate/akka/stream/scaladsl/GraphApply.scala.template b/akka-stream/src/main/boilerplate/akka/stream/scaladsl/GraphApply.scala.template
index 0f811c7f09..48c027abe7 100644
--- a/akka-stream/src/main/boilerplate/akka/stream/scaladsl/GraphApply.scala.template
+++ b/akka-stream/src/main/boilerplate/akka/stream/scaladsl/GraphApply.scala.template
@@ -67,7 +67,7 @@ object GraphApply {
     override def withAttributes(attr: Attributes): Graph[S, Mat] =
       new GraphImpl(shape, module.withAttributes(attr))
 
-    override def named(name: String): Graph[S, Mat] = withAttributes(Attributes.name(name))
+    override def named(name: String): Graph[S, Mat] = addAttributes(Attributes.name(name))
   }
 }
 
diff --git a/akka-stream/src/main/scala/akka/stream/Graph.scala b/akka-stream/src/main/scala/akka/stream/Graph.scala
index 066355c699..c2321a6a1a 100644
--- a/akka-stream/src/main/scala/akka/stream/Graph.scala
+++ b/akka-stream/src/main/scala/akka/stream/Graph.scala
@@ -24,7 +24,7 @@ trait Graph[+S <: Shape, +M] {
 
   def withAttributes(attr: Attributes): Graph[S, M]
 
-  def named(name: String): Graph[S, M] = withAttributes(Attributes.name(name))
+  def named(name: String): Graph[S, M] = addAttributes(Attributes.name(name))
 
   /**
    * Put an asynchronous boundary around this `Graph`
diff --git a/akka-stream/src/main/scala/akka/stream/impl/ActorMaterializerImpl.scala b/akka-stream/src/main/scala/akka/stream/impl/ActorMaterializerImpl.scala
index 8bcda5503c..1f9b53e632 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/ActorMaterializerImpl.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/ActorMaterializerImpl.scala
@@ -211,9 +211,9 @@ private[akka] case class ActorMaterializerImpl(
 
       private def matGraph(graph: GraphModule, effectiveAttributes: Attributes, matVal: ju.Map[Module, Any]): Unit = {
         val calculatedSettings = effectiveSettings(effectiveAttributes)
-        val (inHandlers, outHandlers, logics) = graph.assembly.materialize(effectiveAttributes, graph.matValIDs, matVal, registerSrc)
+        val (connections, logics) = graph.assembly.materialize(effectiveAttributes, graph.matValIDs, matVal, registerSrc)
 
-        val shell = new GraphInterpreterShell(graph.assembly, inHandlers, outHandlers, logics, graph.shape,
+        val shell = new GraphInterpreterShell(graph.assembly, connections, logics, graph.shape,
           calculatedSettings, ActorMaterializerImpl.this)
 
         val impl =
@@ -283,8 +283,8 @@ class FlowNames extends Extension {
 object StreamSupervisor {
   def props(settings: ActorMaterializerSettings, haveShutDown: AtomicBoolean): Props =
     Props(new StreamSupervisor(settings, haveShutDown)).withDeploy(Deploy.local)
-
-  private val actorName = SeqActorName("StreamSupervisor")
+  private[stream] val baseName = "StreamSupervisor"
+  private val actorName = SeqActorName(baseName)
   def nextName(): String = actorName.next()
 
   final case class Materialize(props: Props, name: String)
diff --git a/akka-stream/src/main/scala/akka/stream/impl/JsonObjectParser.scala b/akka-stream/src/main/scala/akka/stream/impl/JsonObjectParser.scala
new file mode 100644
index 0000000000..f35895ef1b
--- /dev/null
+++ b/akka-stream/src/main/scala/akka/stream/impl/JsonObjectParser.scala
@@ -0,0 +1,155 @@
+/**
+ * Copyright (C) 2014-2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.stream.impl
+
+import akka.stream.scaladsl.Framing.FramingException
+import akka.util.ByteString
+
+import scala.annotation.switch
+
+/**
+ * INTERNAL API: Use [[akka.stream.scaladsl.JsonFraming]] instead.
+ */
+private[akka] object JsonObjectParser {
+
+  final val SquareBraceStart = '['.toByte
+  final val SquareBraceEnd = ']'.toByte
+  final val CurlyBraceStart = '{'.toByte
+  final val CurlyBraceEnd = '}'.toByte
+  final val DoubleQuote = '"'.toByte
+  final val Backslash = '\\'.toByte
+  final val Comma = ','.toByte
+
+  final val LineBreak = '\n'.toByte
+  final val LineBreak2 = '\r'.toByte
+  final val Tab = '\t'.toByte
+  final val Space = ' '.toByte
+
+  final val Whitespace = Set(LineBreak, LineBreak2, Tab, Space)
+
+  def isWhitespace(input: Byte): Boolean =
+    Whitespace.contains(input)
+
+}
+
+/**
+ * INTERNAL API: Use [[akka.stream.scaladsl.JsonFraming]] instead.
+ *
+ * **Mutable** framing implementation that given any number of [[ByteString]] chunks, can emit JSON objects contained within them.
+ * Typically JSON objects are separated by new-lines or commas, however a top-level JSON Array can also be understood and chunked up
+ * into valid JSON objects by this framing implementation.
+ *
+ * Leading whitespace between elements will be trimmed.
+ */
+private[akka] class JsonObjectParser(maximumObjectLength: Int = Int.MaxValue) {
+  import JsonObjectParser._
+
+  private var buffer: ByteString = ByteString.empty
+
+  private var pos = 0 // latest position of pointer while scanning for json object end
+  private var trimFront = 0 // number of chars to drop from the front of the bytestring before emitting (skip whitespace etc)
+  private var depth = 0 // counter of object-nesting depth, once hits 0 an object should be emitted
+
+  private var charsInObject = 0
+  private var completedObject = false
+  private var inStringExpression = false
+  private var isStartOfEscapeSequence = false
+
+  /**
+   * Appends input ByteString to internal byte string buffer.
+   * Use [[poll]] to extract contained JSON objects.
+   */
+  def offer(input: ByteString): Unit =
+    buffer ++= input
+
+  def isEmpty: Boolean = buffer.isEmpty
+
+  /**
+   * Attempt to locate next complete JSON object in buffered ByteString and returns `Some(it)` if found.
+   * May throw a [[akka.stream.scaladsl.Framing.FramingException]] if the contained JSON is invalid or max object size is exceeded.
+   */
+  def poll(): Option[ByteString] = {
+    val foundObject = seekObject()
+    if (!foundObject) None
+    else
+      (pos: @switch) match {
+        case -1 | 0 ⇒ None
+        case _ ⇒
+          val (emit, buf) = buffer.splitAt(pos)
+          buffer = buf.compact
+          pos = 0
+
+          val tf = trimFront
+          trimFront = 0
+
+          if (tf == 0) Some(emit)
+          else {
+            val trimmed = emit.drop(tf)
+            if (trimmed.isEmpty) None
+            else Some(trimmed)
+          }
+      }
+  }
+
+  /** @return true if an entire valid JSON object was found, false otherwise */
+  private def seekObject(): Boolean = {
+    completedObject = false
+    val bufSize = buffer.size
+    while (pos != -1 && (pos < bufSize && pos < maximumObjectLength) && !completedObject)
+      proceed(buffer(pos))
+
+    if (pos >= maximumObjectLength)
+      throw new FramingException(s"""JSON element exceeded maximumObjectLength ($maximumObjectLength bytes)!""")
+
+    completedObject
+  }
+
+  private def proceed(input: Byte): Unit =
+    if (input == SquareBraceStart && outsideObject) {
+      // outer object is an array
+      pos += 1
+      trimFront += 1
+    } else if (input == SquareBraceEnd && outsideObject) {
+      // outer array completed!
+      pos = -1
+    } else if (input == Comma && outsideObject) {
+      // do nothing
+      pos += 1
+      trimFront += 1
+    } else if (input == Backslash) {
+      isStartOfEscapeSequence = true
+      pos += 1
+    } else if (input == DoubleQuote) {
+      if (!isStartOfEscapeSequence) inStringExpression = !inStringExpression
+      isStartOfEscapeSequence = false
+      pos += 1
+    } else if (input == CurlyBraceStart && !inStringExpression) {
+      isStartOfEscapeSequence = false
+      depth += 1
+      pos += 1
+    } else if (input == CurlyBraceEnd && !inStringExpression) {
+      isStartOfEscapeSequence = false
+      depth -= 1
+      pos += 1
+      if (depth == 0) {
+        charsInObject = 0
+        completedObject = true
+      }
+    } else if (isWhitespace(input) && !inStringExpression) {
+      pos += 1
+      if (depth == 0) trimFront += 1
+    } else if (insideObject) {
+      isStartOfEscapeSequence = false
+      pos += 1
+    } else {
+      throw new FramingException(s"Invalid JSON encountered at position [$pos] of [$buffer]")
+    }
+
+  @inline private final def insideObject: Boolean =
+    !outsideObject
+
+  @inline private final def outsideObject: Boolean =
+    depth == 0
+
+}
diff --git a/akka-stream/src/main/scala/akka/stream/impl/Stages.scala b/akka-stream/src/main/scala/akka/stream/impl/Stages.scala
index c5c8371cd6..961a3b8a5a 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/Stages.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/Stages.scala
@@ -156,10 +156,6 @@ object Stages {
 
   }
 
-  final case class Map[In, Out](f: In ⇒ Out, attributes: Attributes = map) extends SymbolicStage[In, Out] {
-    override def create(attr: Attributes): Stage[In, Out] = fusing.Map(f, supervision(attr))
-  }
-
   final case class Buffer[T](size: Int, overflowStrategy: OverflowStrategy, attributes: Attributes = buffer) extends SymbolicStage[T, T] {
     require(size > 0, s"Buffer size must be larger than zero but was [$size]")
     override def create(attr: Attributes): Stage[T, T] = fusing.Buffer(size, overflowStrategy)
diff --git a/akka-stream/src/main/scala/akka/stream/impl/Throttle.scala b/akka-stream/src/main/scala/akka/stream/impl/Throttle.scala
index 577ea899e0..44cd31ee6c 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/Throttle.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/Throttle.scala
@@ -15,11 +15,11 @@ import scala.concurrent.duration.{ FiniteDuration, _ }
  * INTERNAL API
  */
 class Throttle[T](
-  cost:            Int,
-  per:             FiniteDuration,
-  maximumBurst:    Int,
-  costCalculation: (T) ⇒ Int,
-  mode:            ThrottleMode)
+  val cost:            Int,
+  val per:             FiniteDuration,
+  val maximumBurst:    Int,
+  val costCalculation: (T) ⇒ Int,
+  val mode:            ThrottleMode)
   extends SimpleLinearGraphStage[T] {
   require(cost > 0, "cost must be > 0")
   require(per.toNanos > 0, "per time must be > 0")
diff --git a/akka-stream/src/main/scala/akka/stream/impl/Timers.scala b/akka-stream/src/main/scala/akka/stream/impl/Timers.scala
index daa0fea687..5706fc0e25 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/Timers.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/Timers.scala
@@ -31,7 +31,7 @@ object Timers {
       TimeUnit.NANOSECONDS)
   }
 
-  final class Initial[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+  final class Initial[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
     override def initialAttributes = DefaultAttributes.initial
 
     override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
@@ -58,7 +58,7 @@ object Timers {
 
   }
 
-  final class Completion[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+  final class Completion[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
     override def initialAttributes = DefaultAttributes.completion
 
     override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
@@ -79,7 +79,7 @@ object Timers {
 
   }
 
-  final class Idle[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+  final class Idle[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
     override def initialAttributes = DefaultAttributes.idle
 
     override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
@@ -106,7 +106,7 @@ object Timers {
 
   }
 
-  final class BackpressureTimeout[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+  final class BackpressureTimeout[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
     override def initialAttributes = DefaultAttributes.backpressureTimeout
 
     override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
@@ -208,7 +208,7 @@ object Timers {
 
   }
 
-  final class IdleInject[I, O >: I](val timeout: FiniteDuration, inject: () ⇒ O) extends GraphStage[FlowShape[I, O]] {
+  final class IdleInject[I, O >: I](val timeout: FiniteDuration, val inject: () ⇒ O) extends GraphStage[FlowShape[I, O]] {
     val in: Inlet[I] = Inlet("IdleInject.in")
     val out: Outlet[O] = Outlet("IdleInject.out")
 
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/ActorGraphInterpreter.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/ActorGraphInterpreter.scala
index 3b14652c29..403513cda9 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/ActorGraphInterpreter.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/ActorGraphInterpreter.scala
@@ -12,7 +12,7 @@ import akka.stream._
 import akka.stream.impl.ReactiveStreamsCompliance._
 import akka.stream.impl.StreamLayout.{ AtomicModule, CompositeModule, CopiedModule, Module }
 import akka.stream.impl.{ SubFusingActorMaterializerImpl, _ }
-import akka.stream.impl.fusing.GraphInterpreter.{ DownstreamBoundaryStageLogic, GraphAssembly, UpstreamBoundaryStageLogic }
+import akka.stream.impl.fusing.GraphInterpreter.{ Connection, DownstreamBoundaryStageLogic, GraphAssembly, UpstreamBoundaryStageLogic }
 import akka.stream.stage.{ GraphStageLogic, InHandler, OutHandler }
 import org.reactivestreams.{ Subscriber, Subscription }
 
@@ -308,8 +308,7 @@ object ActorGraphInterpreter {
  */
 final class GraphInterpreterShell(
   assembly:    GraphAssembly,
-  inHandlers:  Array[InHandler],
-  outHandlers: Array[OutHandler],
+  connections: Array[Connection],
   logics:      Array[GraphStageLogic],
   shape:       Shape,
   settings:    ActorMaterializerSettings,
@@ -322,7 +321,7 @@ final class GraphInterpreterShell(
 
   private var enqueueToShortCircuit: (Any) ⇒ Unit = _
 
-  lazy val interpreter: GraphInterpreter = new GraphInterpreter(assembly, mat, log, inHandlers, outHandlers, logics,
+  lazy val interpreter: GraphInterpreter = new GraphInterpreter(assembly, mat, log, logics, connections,
     (logic, event, handler) ⇒ {
       val asyncInput = AsyncInput(this, logic, event, handler)
       val currentInterpreter = GraphInterpreter.currentInterpreterOrNull
@@ -366,7 +365,7 @@ final class GraphInterpreterShell(
     while (i < inputs.length) {
       val in = new BatchingActorInputBoundary(settings.maxInputBufferSize, i)
       inputs(i) = in
-      interpreter.attachUpstreamBoundary(i, in)
+      interpreter.attachUpstreamBoundary(connections(i), in)
       i += 1
     }
     val offset = assembly.connectionCount - outputs.length
@@ -374,7 +373,7 @@ final class GraphInterpreterShell(
     while (i < outputs.length) {
       val out = new ActorOutputBoundary(self, this, i)
       outputs(i) = out
-      interpreter.attachDownstreamBoundary(i + offset, out)
+      interpreter.attachDownstreamBoundary(connections(i + offset), out)
       i += 1
     }
     interpreter.init(subMat)
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/Fusing.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/Fusing.scala
index 4930267cb0..7ace7f49dd 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/Fusing.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/Fusing.scala
@@ -436,12 +436,6 @@ private[stream] object Fusing {
       case Ignore ⇒ Ignore
     }
 
-  private implicit class NonNull[T](val x: T) extends AnyVal {
-    def nonNull(msg: String): T =
-      if (x != null) x
-      else throw new IllegalArgumentException("null encountered: " + msg)
-  }
-
   /**
    * INTERNAL API
    *
@@ -671,8 +665,8 @@ private[stream] object Fusing {
      */
     def wire(out: OutPort, in: InPort, indent: Int): Unit = {
       if (Debug) println("  " * indent + s"wiring $out (${hash(out)}) -> $in (${hash(in)})")
-      val newOut = removeMapping(out, newOuts) nonNull s"$out (${hash(out)})"
-      val newIn = removeMapping(in, newIns) nonNull s"$in (${hash(in)})"
+      val newOut = nonNullForPort(removeMapping(out, newOuts), out)
+      val newIn = nonNullForPort(removeMapping(in, newIns), in)
       downstreams.put(newOut, newIn)
       upstreams.put(newIn, newOut)
     }
@@ -683,10 +677,10 @@ private[stream] object Fusing {
     def rewire(oldShape: Shape, newShape: Shape, indent: Int): Unit = {
       if (Debug) println("  " * indent + s"rewiring ${printShape(oldShape)} -> ${printShape(newShape)}")
       oldShape.inlets.iterator.zip(newShape.inlets.iterator).foreach {
-        case (oldIn, newIn) ⇒ addMapping(newIn, removeMapping(oldIn, newIns) nonNull s"$oldIn (${hash(oldIn)})", newIns)
+        case (oldIn, newIn) ⇒ addMapping(newIn, nonNullForPort(removeMapping(oldIn, newIns), oldIn), newIns)
       }
       oldShape.outlets.iterator.zip(newShape.outlets.iterator).foreach {
-        case (oldOut, newOut) ⇒ addMapping(newOut, removeMapping(oldOut, newOuts) nonNull s"$oldOut (${hash(oldOut)})", newOuts)
+        case (oldOut, newOut) ⇒ addMapping(newOut, nonNullForPort(removeMapping(oldOut, newOuts), oldOut), newOuts)
       }
     }
 
@@ -701,6 +695,13 @@ private[stream] object Fusing {
      */
     def newOutlets(old: immutable.Seq[Outlet[_]]): immutable.Seq[Outlet[_]] =
       old.map(o ⇒ newOuts.get(o).head.outlet)
+
+    // optimization - specialized null check avoiding allocation or creation of unused strings
+    private def nonNullForPort[T](t: T, port: AnyRef): T = {
+      if (t != null) t
+      else throw new IllegalArgumentException(s"null encountered: $port (${hash(port)})")
+    }
+
   }
 
   /**
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphInterpreter.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphInterpreter.scala
index da05746a19..57a1d6ea5c 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphInterpreter.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphInterpreter.scala
@@ -27,7 +27,7 @@ object GraphInterpreter {
    */
   final val Debug = false
 
-  final val NoEvent = -1
+  final val NoEvent = null
   final val Boundary = -1
 
   final val InReady = 1
@@ -64,6 +64,37 @@ object GraphInterpreter {
 
   val singleNoAttribute: Array[Attributes] = Array(Attributes.none)
 
+  /**
+   * INERNAL API
+   *
+   * Contains all the necessary information for the GraphInterpreter to be able to implement a connection
+   * between an output and input ports.
+   *
+   * @param id Identifier of the connection. Corresponds to the array slot in the [[GraphAssembly]]
+   * @param inOwnerId Identifier of the owner of the input side of the connection. Corresponds to the array slot in
+   *                  the [[GraphAssembly]]
+   * @param inOwner The stage logic that corresponds to the input side of the connection.
+   * @param outOwnerId Identifier of the owner of the output side of the connection. Corresponds to the array slot
+   *                   in the [[GraphAssembly]]
+   * @param outOwner The stage logic that corresponds to the output side of the connection.
+   * @param inHandler The handler that contains the callback for input events.
+   * @param outHandler The handler that contains the callback for output events.
+   */
+  final class Connection(
+    val id:         Int,
+    val inOwnerId:  Int,
+    val inOwner:    GraphStageLogic,
+    val outOwnerId: Int,
+    val outOwner:   GraphStageLogic,
+    var inHandler:  InHandler,
+    var outHandler: OutHandler
+  ) {
+    var portState: Int = InReady
+    var slot: Any = Empty
+
+    override def toString = s"Connection($id, $portState, $slot, $inHandler, $outHandler)"
+  }
+
   /**
    * INTERNAL API
    *
@@ -115,16 +146,14 @@ object GraphInterpreter {
      * handlers and the stage logic instances.
      *
      * Returns a tuple of
-     *  - lookup table for InHandlers
-     *  - lookup table for OutHandlers
+     *  - lookup table for Connections
      *  - array of the logics
-     *  - materialized value
      */
     def materialize(
       inheritedAttributes: Attributes,
       copiedModules:       Array[Module],
       matVal:              ju.Map[Module, Any],
-      register:            MaterializedValueSource[Any] ⇒ Unit): (Array[InHandler], Array[OutHandler], Array[GraphStageLogic]) = {
+      register:            MaterializedValueSource[Any] ⇒ Unit): (Array[Connection], Array[GraphStageLogic]) = {
       val logics = Array.ofDim[GraphStageLogic](stages.length)
 
       var i = 0
@@ -165,32 +194,43 @@ object GraphInterpreter {
         i += 1
       }
 
-      val inHandlers = Array.ofDim[InHandler](connectionCount)
-      val outHandlers = Array.ofDim[OutHandler](connectionCount)
+      val connections = Array.ofDim[Connection](connectionCount)
 
       i = 0
       while (i < connectionCount) {
+        connections(i) = new Connection(
+          id = i,
+          inOwner = if (inOwners(i) == Boundary) null else logics(inOwners(i)),
+          inOwnerId = inOwners(i),
+          outOwner = if (outOwners(i) == Boundary) null else logics(outOwners(i)),
+          outOwnerId = outOwners(i),
+          inHandler = null,
+          outHandler = null
+        )
+
         if (ins(i) ne null) {
           val logic = logics(inOwners(i))
           logic.handlers(ins(i).id) match {
-            case null         ⇒ throw new IllegalStateException(s"no handler defined in stage $logic for port ${ins(i)}")
-            case h: InHandler ⇒ inHandlers(i) = h
+            case null ⇒ throw new IllegalStateException(s"no handler defined in stage $logic for port ${ins(i)}")
+            case h: InHandler ⇒
+              connections(i).inHandler = h
           }
-          logics(inOwners(i)).portToConn(ins(i).id) = i
+          logics(inOwners(i)).portToConn(ins(i).id) = connections(i)
         }
         if (outs(i) ne null) {
           val logic = logics(outOwners(i))
           val inCount = logic.inCount
           logic.handlers(outs(i).id + inCount) match {
-            case null          ⇒ throw new IllegalStateException(s"no handler defined in stage $logic for port ${outs(i)}")
-            case h: OutHandler ⇒ outHandlers(i) = h
+            case null ⇒ throw new IllegalStateException(s"no handler defined in stage $logic for port ${outs(i)}")
+            case h: OutHandler ⇒
+              connections(i).outHandler = h
           }
-          logic.portToConn(outs(i).id + inCount) = i
+          logic.portToConn(outs(i).id + inCount) = connections(i)
         }
         i += 1
       }
 
-      (inHandlers, outHandlers, logics)
+      (connections, logics)
     }
 
     override def toString: String = {
@@ -291,25 +331,27 @@ object GraphInterpreter {
  * The internal architecture of the interpreter is based on the usage of arrays and optimized for reducing allocations
  * on the hot paths.
  *
- * One of the basic abstractions inside the interpreter is the notion of *connection*. In the abstract sense a
- * connection represents an output-input port pair (an analogue for a connected RS Publisher-Subscriber pair),
- * while in the practical sense a connection is a number which represents slots in certain arrays.
+ * One of the basic abstractions inside the interpreter is the [[akka.stream.impl.fusing.GraphInterpreter.Connection]].
+ * A connection represents an output-input port pair (an analogue for a connected RS Publisher-Subscriber pair).
+ * The Connection object contains all the necessary data for the interpreter to pass elements, demand, completion
+ * or errors across the Connection.
  * In particular
  *  - portStates contains a bitfield that tracks the states of the ports (output-input) corresponding to this
  *    connection. This bitfield is used to decode the event that is in-flight.
- *  - connectionSlots is a mapping from a connection id to a potential element or exception that accompanies the
+ *  - connectionSlot contains a potential element or exception that accompanies the
  *    event encoded in the portStates bitfield
- *  - inHandlers is a mapping from a connection id to the [[InHandler]] instance that handles the events corresponding
+ *  - inHandler contains the [[InHandler]] instance that handles the events corresponding
  *    to the input port of the connection
- *  - outHandlers is a mapping from a connection id to the [[OutHandler]] instance that handles the events corresponding
+ *  - outHandler contains the [[OutHandler]] instance that handles the events corresponding
  *    to the output port of the connection
  *
- * On top of these lookup tables there is an eventQueue, represented as a circular buffer of integers. The integers
- * it contains represents connections that have pending events to be processed. The pending event itself is encoded
- * in the portStates bitfield. This implies that there can be only one event in flight for a given connection, which
- * is true in almost all cases, except a complete-after-push or fail-after-push.
+ * On top of the Connection table there is an eventQueue, represented as a circular buffer of Connections. The queue
+ * contains the Connections that have pending events to be processed. The pending event itself is encoded
+ * in the portState bitfield of the Connection. This implies that there can be only one event in flight for a given
+ * Connection, which is true in almost all cases, except a complete-after-push or fail-after-push which has to
+ * be decoded accordingly.
  *
- * The layout of the portStates bitfield is the following:
+ * The layout of the portState bitfield is the following:
  *
  *             |- state machn.-| Only one bit is hot among these bits
  *  64  32  16 | 8   4   2   1 |
@@ -333,10 +375,10 @@ object GraphInterpreter {
  * Sending an event is usually the following sequence:
  *  - An action is requested by a stage logic (push, pull, complete, etc.)
  *  - the state machine in portStates is transitioned from a ready state to a pending event
- *  - the id of the affected connection is enqueued
+ *  - the affected Connection is enqueued
  *
  * Receiving an event is usually the following sequence:
- *  - id of connection to be processed is dequeued
+ *  - the Connection to be processed is dequeued
  *  - the type of the event is determined from the bits set on portStates
  *  - the state machine in portStates is transitioned to a ready state
  *  - using the inHandlers/outHandlers table the corresponding callback is called on the stage logic.
@@ -350,21 +392,14 @@ final class GraphInterpreter(
   private val assembly: GraphInterpreter.GraphAssembly,
   val materializer:     Materializer,
   val log:              LoggingAdapter,
-  val inHandlers:       Array[InHandler], // Lookup table for the InHandler of a connection
-  val outHandlers:      Array[OutHandler], // Lookup table for the outHandler of the connection
   val logics:           Array[GraphStageLogic], // Array of stage logics
+  val connections:      Array[GraphInterpreter.Connection],
   val onAsyncInput:     (GraphStageLogic, Any, (Any) ⇒ Unit) ⇒ Unit,
   val fuzzingMode:      Boolean,
   val context:          ActorRef) {
   import GraphInterpreter._
 
-  // Maintains additional information for events, basically elements in-flight, or failure.
-  // Other events are encoded in the portStates bitfield.
-  val connectionSlots = Array.fill[Any](assembly.connectionCount)(Empty)
-
-  // Bitfield encoding pending events and various states for efficient querying and updates. See the documentation
-  // of the class for a full description.
-  val portStates = Array.fill[Int](assembly.connectionCount)(InReady)
+  private[this] val ChaseLimit = if (fuzzingMode) 0 else 16
 
   /**
    * INTERNAL API
@@ -381,20 +416,24 @@ final class GraphInterpreter(
     shape.inlets.size + shape.outlets.size
   }
 
-  private var _subFusingMaterializer: Materializer = _
+  private[this] var _subFusingMaterializer: Materializer = _
   def subFusingMaterializer: Materializer = _subFusingMaterializer
 
   // An event queue implemented as a circular buffer
   // FIXME: This calculates the maximum size ever needed, but most assemblies can run on a smaller queue
-  private[this] val eventQueue = Array.ofDim[Int](1 << (32 - Integer.numberOfLeadingZeros(assembly.connectionCount - 1)))
+  private[this] val eventQueue = Array.ofDim[Connection](1 << (32 - Integer.numberOfLeadingZeros(assembly.connectionCount - 1)))
   private[this] val mask = eventQueue.length - 1
   private[this] var queueHead: Int = 0
   private[this] var queueTail: Int = 0
 
+  private[this] var chaseCounter = 0 // the first events in preStart blocks should be not chased
+  private[this] var chasedPush: Connection = NoEvent
+  private[this] var chasedPull: Connection = NoEvent
+
   private def queueStatus: String = {
     val contents = (queueHead until queueTail).map(idx ⇒ {
       val conn = eventQueue(idx & mask)
-      (conn, portStates(conn), connectionSlots(conn))
+      conn
     })
     s"(${eventQueue.length}, $queueHead, $queueTail)(${contents.mkString(", ")})"
   }
@@ -414,36 +453,42 @@ final class GraphInterpreter(
    * Assign the boundary logic to a given connection. This will serve as the interface to the external world
    * (outside the interpreter) to process and inject events.
    */
-  def attachUpstreamBoundary(connection: Int, logic: UpstreamBoundaryStageLogic[_]): Unit = {
+  def attachUpstreamBoundary(connection: Connection, logic: UpstreamBoundaryStageLogic[_]): Unit = {
     logic.portToConn(logic.out.id + logic.inCount) = connection
     logic.interpreter = this
-    outHandlers(connection) = logic.handlers(0).asInstanceOf[OutHandler]
+    connection.outHandler = logic.handlers(0).asInstanceOf[OutHandler]
   }
 
+  def attachUpstreamBoundary(connection: Int, logic: UpstreamBoundaryStageLogic[_]): Unit =
+    attachUpstreamBoundary(connections(connection), logic)
+
   /**
    * Assign the boundary logic to a given connection. This will serve as the interface to the external world
    * (outside the interpreter) to process and inject events.
    */
-  def attachDownstreamBoundary(connection: Int, logic: DownstreamBoundaryStageLogic[_]): Unit = {
+  def attachDownstreamBoundary(connection: Connection, logic: DownstreamBoundaryStageLogic[_]): Unit = {
     logic.portToConn(logic.in.id) = connection
     logic.interpreter = this
-    inHandlers(connection) = logic.handlers(0).asInstanceOf[InHandler]
+    connection.inHandler = logic.handlers(0).asInstanceOf[InHandler]
   }
 
+  def attachDownstreamBoundary(connection: Int, logic: DownstreamBoundaryStageLogic[_]): Unit =
+    attachDownstreamBoundary(connections(connection), logic)
+
   /**
    * Dynamic handler changes are communicated from a GraphStageLogic by this method.
    */
-  def setHandler(connection: Int, handler: InHandler): Unit = {
+  def setHandler(connection: Connection, handler: InHandler): Unit = {
     if (Debug) println(s"$Name SETHANDLER ${inOwnerName(connection)} (in) $handler")
-    inHandlers(connection) = handler
+    connection.inHandler = handler
   }
 
   /**
    * Dynamic handler changes are communicated from a GraphStageLogic by this method.
    */
-  def setHandler(connection: Int, handler: OutHandler): Unit = {
+  def setHandler(connection: Connection, handler: OutHandler): Unit = {
     if (Debug) println(s"$Name SETHANDLER ${outOwnerName(connection)} (out) $handler")
-    outHandlers(connection) = handler
+    connection.outHandler = handler
   }
 
   /**
@@ -496,29 +541,29 @@ final class GraphInterpreter(
   }
 
   // Debug name for a connections input part
-  private def inOwnerName(connection: Int): String =
-    assembly.inOwners(connection) match {
+  private def inOwnerName(connection: Connection): String =
+    assembly.inOwners(connection.id) match {
       case Boundary ⇒ "DownstreamBoundary"
       case owner    ⇒ assembly.stages(owner).toString
     }
 
   // Debug name for a connections output part
-  private def outOwnerName(connection: Int): String =
-    assembly.outOwners(connection) match {
+  private def outOwnerName(connection: Connection): String =
+    assembly.outOwners(connection.id) match {
       case Boundary ⇒ "UpstreamBoundary"
       case owner    ⇒ assembly.stages(owner).toString
     }
 
   // Debug name for a connections input part
-  private def inLogicName(connection: Int): String =
-    assembly.inOwners(connection) match {
+  private def inLogicName(connection: Connection): String =
+    assembly.inOwners(connection.id) match {
       case Boundary ⇒ "DownstreamBoundary"
       case owner    ⇒ logics(owner).toString
     }
 
   // Debug name for a connections output part
-  private def outLogicName(connection: Int): String =
-    assembly.outOwners(connection) match {
+  private def outLogicName(connection: Connection): String =
+    assembly.outOwners(connection.id) match {
       case Boundary ⇒ "UpstreamBoundary"
       case owner    ⇒ logics(owner).toString
     }
@@ -539,20 +584,94 @@ final class GraphInterpreter(
     try {
       while (eventsRemaining > 0 && queueTail != queueHead) {
         val connection = dequeue()
+        eventsRemaining -= 1
+        chaseCounter = math.min(ChaseLimit, eventsRemaining)
+
+        def reportStageError(e: Throwable): Unit = {
+          if (activeStage == null) throw e
+          else {
+            val stage = assembly.stages(activeStage.stageId)
+
+            log.error(e, "Error in stage [{}]: {}", stage, e.getMessage)
+            activeStage.failStage(e)
+
+            // Abort chasing
+            chaseCounter = 0
+            if (chasedPush ne NoEvent) {
+              enqueue(chasedPush)
+              chasedPush = NoEvent
+            }
+            if (chasedPull ne NoEvent) {
+              enqueue(chasedPull)
+              chasedPull = NoEvent
+            }
+          }
+        }
+
+        /*
+         * This is the "normal" event processing code which dequeues directly from the internal event queue. Since
+         * most execution paths tend to produce either a Push that will be propagated along a longer chain we take
+         * extra steps below to make this more efficient.
+         */
         try processEvent(connection)
         catch {
-          case NonFatal(e) ⇒
-            if (activeStage == null) throw e
-            else {
-              val stage = assembly.stages(activeStage.stageId)
-
-              log.error(e, "Error in stage [{}]: {}", stage, e.getMessage)
-              activeStage.failStage(e)
-            }
+          case NonFatal(e) ⇒ reportStageError(e)
         }
         afterStageHasRun(activeStage)
-        eventsRemaining -= 1
+
+        /*
+         * "Event chasing" optimization follows from here. This optimization works under the assumption that a Push or
+         * Pull is very likely immediately followed by another Push/Pull. The difference from the "normal" event
+         * dispatch is that chased events are never touching the event queue, they use a "streamlined" execution path
+         * instead. Looking at the scenario of a Push, the following events will happen.
+         *  - "normal" dispatch executes an onPush event
+         *  - stage eventually calls push()
+         *  - code inside the push() method checks the validity of the call, and also if it can be safely ignored
+         *    (because the target stage already completed we just have not been notified yet)
+         *  - if the upper limit of ChaseLimit has not been reached, then the Connection is put into the chasedPush
+         *    variable
+         *  - the loop below immediately captures this push and dispatches it
+         *
+         * What is saved by this optimization is three steps:
+         *  - no need to enqueue the Connection in the queue (array), it ends up in a simple variable, reducing
+         *    pressure on array load-store
+         *  - no need to dequeue the Connection from the queue, similar to above
+         *  - no need to decode the event, we know it is a Push already
+         *  - no need to check for validity of the event because we already checked at the push() call, and there
+         *    can be no concurrent events interleaved unlike with the normal dispatch (think about a cancel() that is
+         *    called in the target stage just before the onPush() arrives). This avoids unnecessary branching.
+         */
+
+        // Chasing PUSH events
+        while (chasedPush != NoEvent) {
+          val connection = chasedPush
+          chasedPush = NoEvent
+          try processPush(connection)
+          catch {
+            case NonFatal(e) ⇒ reportStageError(e)
+          }
+          afterStageHasRun(activeStage)
+        }
+
+        // Chasing PULL events
+        while (chasedPull != NoEvent) {
+          val connection = chasedPull
+          chasedPull = NoEvent
+          try processPull(connection)
+          catch {
+            case NonFatal(e) ⇒ reportStageError(e)
+          }
+          afterStageHasRun(activeStage)
+        }
+
+        if (chasedPush != NoEvent) {
+          enqueue(chasedPush)
+          chasedPush = NoEvent
+        }
+
       }
+      // Event *must* be enqueued while not in the execute loop (events enqueued from external, possibly async events)
+      chaseCounter = 0
     } finally {
       currentInterpreterHolder(0) = previousInterpreter
     }
@@ -578,65 +697,64 @@ final class GraphInterpreter(
     }
 
   // Decodes and processes a single event for the given connection
-  private def processEvent(connection: Int): Unit = {
-    def safeLogics(id: Int) =
-      if (id == Boundary) null
-      else logics(id)
-
-    def processElement(): Unit = {
-      if (Debug) println(s"$Name PUSH ${outOwnerName(connection)} -> ${inOwnerName(connection)}, ${connectionSlots(connection)} (${inHandlers(connection)}) [${inLogicName(connection)}]")
-      activeStage = safeLogics(assembly.inOwners(connection))
-      portStates(connection) ^= PushEndFlip
-      inHandlers(connection).onPush()
-    }
+  private def processEvent(connection: Connection): Unit = {
 
     // this must be the state after returning without delivering any signals, to avoid double-finalization of some unlucky stage
     // (this can happen if a stage completes voluntarily while connection close events are still queued)
     activeStage = null
-    val code = portStates(connection)
+    val code = connection.portState
 
     // Manual fast decoding, fast paths are PUSH and PULL
     //   PUSH
     if ((code & (Pushing | InClosed | OutClosed)) == Pushing) {
-      processElement()
+      processPush(connection)
 
       // PULL
     } else if ((code & (Pulling | OutClosed | InClosed)) == Pulling) {
-      if (Debug) println(s"$Name PULL ${inOwnerName(connection)} -> ${outOwnerName(connection)} (${outHandlers(connection)}) [${outLogicName(connection)}]")
-      portStates(connection) ^= PullEndFlip
-      activeStage = safeLogics(assembly.outOwners(connection))
-      outHandlers(connection).onPull()
+      processPull(connection)
 
       // CANCEL
     } else if ((code & (OutClosed | InClosed)) == InClosed) {
-      val stageId = assembly.outOwners(connection)
-      activeStage = safeLogics(stageId)
-      if (Debug) println(s"$Name CANCEL ${inOwnerName(connection)} -> ${outOwnerName(connection)} (${outHandlers(connection)}) [${outLogicName(connection)}]")
-      portStates(connection) |= OutClosed
-      completeConnection(stageId)
-      outHandlers(connection).onDownstreamFinish()
+      activeStage = connection.outOwner
+      if (Debug) println(s"$Name CANCEL ${inOwnerName(connection)} -> ${outOwnerName(connection)} (${connection.outHandler}) [${outLogicName(connection)}]")
+      connection.portState |= OutClosed
+      completeConnection(connection.outOwnerId)
+      connection.outHandler.onDownstreamFinish()
     } else if ((code & (OutClosed | InClosed)) == OutClosed) {
       // COMPLETIONS
 
       if ((code & Pushing) == 0) {
         // Normal completion (no push pending)
-        if (Debug) println(s"$Name COMPLETE ${outOwnerName(connection)} -> ${inOwnerName(connection)} (${inHandlers(connection)}) [${inLogicName(connection)}]")
-        portStates(connection) |= InClosed
-        val stageId = assembly.inOwners(connection)
-        activeStage = safeLogics(stageId)
-        completeConnection(stageId)
-        if ((portStates(connection) & InFailed) == 0) inHandlers(connection).onUpstreamFinish()
-        else inHandlers(connection).onUpstreamFailure(connectionSlots(connection).asInstanceOf[Failed].ex)
+        if (Debug) println(s"$Name COMPLETE ${outOwnerName(connection)} -> ${inOwnerName(connection)} (${connection.inHandler}) [${inLogicName(connection)}]")
+        connection.portState |= InClosed
+        activeStage = connection.inOwner
+        completeConnection(connection.inOwnerId)
+        if ((connection.portState & InFailed) == 0) connection.inHandler.onUpstreamFinish()
+        else connection.inHandler.onUpstreamFailure(connection.slot.asInstanceOf[Failed].ex)
       } else {
         // Push is pending, first process push, then re-enqueue closing event
-        processElement()
+        processPush(connection)
         enqueue(connection)
       }
 
     }
   }
 
-  private def dequeue(): Int = {
+  private def processPush(connection: Connection): Unit = {
+    if (Debug) println(s"$Name PUSH ${outOwnerName(connection)} -> ${inOwnerName(connection)}, ${connection.slot} (${connection.inHandler}) [${inLogicName(connection)}]")
+    activeStage = connection.inOwner
+    connection.portState ^= PushEndFlip
+    connection.inHandler.onPush()
+  }
+
+  private def processPull(connection: Connection): Unit = {
+    if (Debug) println(s"$Name PULL ${inOwnerName(connection)} -> ${outOwnerName(connection)} (${connection.outHandler}) [${outLogicName(connection)}]")
+    activeStage = connection.outOwner
+    connection.portState ^= PullEndFlip
+    connection.outHandler.onPull()
+  }
+
+  private def dequeue(): Connection = {
     val idx = queueHead & mask
     if (fuzzingMode) {
       val swapWith = (ThreadLocalRandom.current.nextInt(queueTail - queueHead) + queueHead) & mask
@@ -650,7 +768,7 @@ final class GraphInterpreter(
     elem
   }
 
-  private def enqueue(connection: Int): Unit = {
+  def enqueue(connection: Connection): Unit = {
     if (Debug) if (queueTail - queueHead > mask) new Exception(s"$Name internal queue full ($queueStatus) + $connection").printStackTrace()
     eventQueue(queueTail & mask) = connection
     queueTail += 1
@@ -688,52 +806,55 @@ final class GraphInterpreter(
     }
   }
 
-  private[stream] def push(connection: Int, elem: Any): Unit = {
-    val currentState = portStates(connection)
-    portStates(connection) = currentState ^ PushStartFlip
-    if ((currentState & InClosed) == 0) {
-      connectionSlots(connection) = elem
-      enqueue(connection)
-    }
+  private[stream] def chasePush(connection: Connection): Unit = {
+    if (chaseCounter > 0 && chasedPush == NoEvent) {
+      chaseCounter -= 1
+      chasedPush = connection
+    } else enqueue(connection)
   }
 
-  private[stream] def pull(connection: Int): Unit = {
-    val currentState = portStates(connection)
-    portStates(connection) = currentState ^ PullStartFlip
-    if ((currentState & OutClosed) == 0) {
-      enqueue(connection)
-    }
+  private[stream] def chasePull(connection: Connection): Unit = {
+    if (chaseCounter > 0 && chasedPull == NoEvent) {
+      chaseCounter -= 1
+      chasedPull = connection
+    } else enqueue(connection)
   }
 
-  private[stream] def complete(connection: Int): Unit = {
-    val currentState = portStates(connection)
+  private[stream] def complete(connection: Connection): Unit = {
+    val currentState = connection.portState
     if (Debug) println(s"$Name   complete($connection) [$currentState]")
-    portStates(connection) = currentState | OutClosed
-    if ((currentState & (InClosed | Pushing | Pulling | OutClosed)) == 0) enqueue(connection)
-    if ((currentState & OutClosed) == 0) completeConnection(assembly.outOwners(connection))
+    connection.portState = currentState | OutClosed
+
+    // Push-Close needs special treatment, cannot be chased, convert back to ordinary event
+    if (chasedPush == connection) {
+      chasedPush = NoEvent
+      enqueue(connection)
+    } else if ((currentState & (InClosed | Pushing | Pulling | OutClosed)) == 0) enqueue(connection)
+
+    if ((currentState & OutClosed) == 0) completeConnection(connection.outOwnerId)
   }
 
-  private[stream] def fail(connection: Int, ex: Throwable): Unit = {
-    val currentState = portStates(connection)
+  private[stream] def fail(connection: Connection, ex: Throwable): Unit = {
+    val currentState = connection.portState
     if (Debug) println(s"$Name   fail($connection, $ex) [$currentState]")
-    portStates(connection) = currentState | OutClosed
+    connection.portState = currentState | OutClosed
     if ((currentState & (InClosed | OutClosed)) == 0) {
-      portStates(connection) = currentState | (OutClosed | InFailed)
-      connectionSlots(connection) = Failed(ex, connectionSlots(connection))
+      connection.portState = currentState | (OutClosed | InFailed)
+      connection.slot = Failed(ex, connection.slot)
       if ((currentState & (Pulling | Pushing)) == 0) enqueue(connection)
     }
-    if ((currentState & OutClosed) == 0) completeConnection(assembly.outOwners(connection))
+    if ((currentState & OutClosed) == 0) completeConnection(connection.outOwnerId)
   }
 
-  private[stream] def cancel(connection: Int): Unit = {
-    val currentState = portStates(connection)
+  private[stream] def cancel(connection: Connection): Unit = {
+    val currentState = connection.portState
     if (Debug) println(s"$Name   cancel($connection) [$currentState]")
-    portStates(connection) = currentState | InClosed
+    connection.portState = currentState | InClosed
     if ((currentState & OutClosed) == 0) {
-      connectionSlots(connection) = Empty
+      connection.slot = Empty
       if ((currentState & (Pulling | Pushing | InClosed)) == 0) enqueue(connection)
     }
-    if ((currentState & InClosed) == 0) completeConnection(assembly.inOwners(connection))
+    if ((currentState & InClosed) == 0) completeConnection(connection.inOwnerId)
   }
 
   /**
@@ -762,8 +883,8 @@ final class GraphInterpreter(
       else "N" + owner
     }
 
-    for (i ← portStates.indices) {
-      portStates(i) match {
+    for (i ← connections.indices) {
+      connections(i).portState match {
         case InReady ⇒
           builder.append(s"""  ${nameIn(i)} -> ${nameOut(i)} [label=shouldPull; color=blue]""")
         case OutReady ⇒
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphStages.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphStages.scala
index 4e2fe7e682..0a08583d84 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphStages.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/GraphStages.scala
@@ -221,7 +221,7 @@ object GraphStages {
     }
   }
 
-  final class TickSource[T](initialDelay: FiniteDuration, interval: FiniteDuration, tick: T)
+  final class TickSource[T](val initialDelay: FiniteDuration, val interval: FiniteDuration, val tick: T)
     extends GraphStageWithMaterializedValue[SourceShape[T], Cancellable] {
     override val shape = SourceShape(Outlet[T]("TickSource.out"))
     val out = shape.out
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/IteratorInterpreter.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/IteratorInterpreter.scala
index 263cece018..cb011795b3 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/IteratorInterpreter.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/IteratorInterpreter.scala
@@ -137,20 +137,19 @@ private[akka] class IteratorInterpreter[I, O](
     }
     val assembly = new GraphAssembly(stagesArray, attributes, ins, inOwners, outs, outOwners)
 
-    val (inHandlers, outHandlers, logics) =
+    val (connections, logics) =
       assembly.materialize(Attributes.none, assembly.stages.map(_.module), new ju.HashMap, _ ⇒ ())
     val interpreter = new GraphInterpreter(
       assembly,
       NoMaterializer,
       NoLogging,
-      inHandlers,
-      outHandlers,
       logics,
+      connections,
       (_, _, _) ⇒ throw new UnsupportedOperationException("IteratorInterpreter does not support asynchronous events."),
       fuzzingMode = false,
       null)
-    interpreter.attachUpstreamBoundary(0, upstream)
-    interpreter.attachDownstreamBoundary(length, downstream)
+    interpreter.attachUpstreamBoundary(connections(0), upstream)
+    interpreter.attachDownstreamBoundary(connections(length), downstream)
     interpreter.init(null)
   }
 
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/Ops.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/Ops.scala
index 6fcbbb7c00..da46440efd 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/Ops.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/Ops.scala
@@ -25,10 +25,33 @@ import akka.stream.impl.Stages.DefaultAttributes
 /**
  * INTERNAL API
  */
-final case class Map[In, Out](f: In ⇒ Out, decider: Supervision.Decider) extends PushStage[In, Out] {
-  override def onPush(elem: In, ctx: Context[Out]): SyncDirective = ctx.push(f(elem))
+// FIXME: Not final because InterpreterSupervisionSpec. Some better option is needed here
+case class Map[In, Out](f: In ⇒ Out) extends GraphStage[FlowShape[In, Out]] {
+  val in = Inlet[In]("Map.in")
+  val out = Outlet[Out]("Map.out")
+  override val shape = FlowShape(in, out)
+  override def initialAttributes: Attributes = DefaultAttributes.map
 
-  override def decide(t: Throwable): Supervision.Directive = decider(t)
+  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
+    new GraphStageLogic(shape) with InHandler with OutHandler {
+      private def decider =
+        inheritedAttributes.get[SupervisionStrategy].map(_.decider).getOrElse(Supervision.stoppingDecider)
+
+      override def onPush(): Unit = {
+        try {
+          push(out, f(grab(in)))
+        } catch {
+          case NonFatal(ex) ⇒ decider(ex) match {
+            case Supervision.Stop ⇒ failStage(ex)
+            case _                ⇒ pull(in)
+          }
+        }
+      }
+
+      override def onPull(): Unit = pull(in)
+
+      setHandlers(in, out, this)
+    }
 }
 
 /**
@@ -356,19 +379,24 @@ final case class Fold[In, Out](zero: Out, f: (Out, In) ⇒ Out) extends GraphSta
   override val initialAttributes = DefaultAttributes.fold
 
   override def createLogic(inheritedAttributes: Attributes): GraphStageLogic =
-    new SupervisedGraphStageLogic(inheritedAttributes, shape) with InHandler with OutHandler {
+    new GraphStageLogic(shape) with InHandler with OutHandler {
       private var aggregator: Out = zero
 
-      override def onResume(t: Throwable): Unit = {
-        aggregator = zero
-      }
+      private def decider =
+        inheritedAttributes.get[SupervisionStrategy].map(_.decider).getOrElse(Supervision.stoppingDecider)
 
-      override def onPush(): Unit = withSupervision(() ⇒ grab(in)) match {
-        case Some(elem) ⇒ {
-          aggregator = f(aggregator, elem)
+      override def onPush(): Unit = {
+        try {
+          aggregator = f(aggregator, grab(in))
           pull(in)
+        } catch {
+          case NonFatal(ex) ⇒ decider(ex) match {
+            case Supervision.Stop ⇒ failStage(ex)
+            case _ ⇒
+              aggregator = zero
+              pull(in)
+          }
         }
-        case None ⇒ pull(in)
       }
 
       override def onPull(): Unit = {
@@ -494,7 +522,7 @@ final case class Grouped[T](n: Int) extends GraphStage[FlowShape[T, immutable.Se
 /**
  * INTERNAL API
  */
-final case class LimitWeighted[T](n: Long, costFn: T ⇒ Long) extends GraphStage[FlowShape[T, T]] {
+final case class LimitWeighted[T](val n: Long, val costFn: T ⇒ Long) extends GraphStage[FlowShape[T, T]] {
   val in = Inlet[T]("LimitWeighted.in")
   val out = Outlet[T]("LimitWeighted.out")
   override val shape = FlowShape(in, out)
@@ -526,7 +554,7 @@ final case class LimitWeighted[T](n: Long, costFn: T ⇒ Long) extends GraphStag
 /**
  * INTERNAL API
  */
-final case class Sliding[T](n: Int, step: Int) extends GraphStage[FlowShape[T, immutable.Seq[T]]] {
+final case class Sliding[T](val n: Int, val step: Int) extends GraphStage[FlowShape[T, immutable.Seq[T]]] {
   require(n > 0, "n must be greater than 0")
   require(step > 0, "step must be greater than 0")
 
@@ -644,7 +672,7 @@ final case class Buffer[T](size: Int, overflowStrategy: OverflowStrategy) extend
 /**
  * INTERNAL API
  */
-final case class Batch[In, Out](max: Long, costFn: In ⇒ Long, seed: In ⇒ Out, aggregate: (Out, In) ⇒ Out)
+final case class Batch[In, Out](val max: Long, val costFn: In ⇒ Long, val seed: In ⇒ Out, val aggregate: (Out, In) ⇒ Out)
   extends GraphStage[FlowShape[In, Out]] {
 
   val in = Inlet[In]("Batch.in")
@@ -770,7 +798,7 @@ final case class Batch[In, Out](max: Long, costFn: In ⇒ Long, seed: In ⇒ Out
 /**
  * INTERNAL API
  */
-final class Expand[In, Out](extrapolate: In ⇒ Iterator[Out]) extends GraphStage[FlowShape[In, Out]] {
+final class Expand[In, Out](val extrapolate: In ⇒ Iterator[Out]) extends GraphStage[FlowShape[In, Out]] {
   private val in = Inlet[In]("expand.in")
   private val out = Outlet[Out]("expand.out")
 
@@ -1099,7 +1127,7 @@ private[stream] object TimerKeys {
   case object GroupedWithinTimerKey
 }
 
-final class GroupedWithin[T](n: Int, d: FiniteDuration) extends GraphStage[FlowShape[T, immutable.Seq[T]]] {
+final class GroupedWithin[T](val n: Int, val d: FiniteDuration) extends GraphStage[FlowShape[T, immutable.Seq[T]]] {
   require(n > 0, "n must be greater than 0")
   require(d > Duration.Zero)
 
@@ -1175,7 +1203,7 @@ final class GroupedWithin[T](n: Int, d: FiniteDuration) extends GraphStage[FlowS
   }
 }
 
-final class Delay[T](d: FiniteDuration, strategy: DelayOverflowStrategy) extends SimpleLinearGraphStage[T] {
+final class Delay[T](val d: FiniteDuration, val strategy: DelayOverflowStrategy) extends SimpleLinearGraphStage[T] {
   private[this] def timerName = "DelayedTimer"
   override def initialAttributes: Attributes = DefaultAttributes.delay
   override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new TimerGraphStageLogic(shape) {
@@ -1261,7 +1289,7 @@ final class Delay[T](d: FiniteDuration, strategy: DelayOverflowStrategy) extends
   override def toString = "Delay"
 }
 
-final class TakeWithin[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+final class TakeWithin[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
 
   override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new TimerGraphStageLogic(shape) {
     setHandler(in, new InHandler {
@@ -1281,7 +1309,7 @@ final class TakeWithin[T](timeout: FiniteDuration) extends SimpleLinearGraphStag
   override def toString = "TakeWithin"
 }
 
-final class DropWithin[T](timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
+final class DropWithin[T](val timeout: FiniteDuration) extends SimpleLinearGraphStage[T] {
   override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new TimerGraphStageLogic(shape) {
 
     private var allow = false
@@ -1307,7 +1335,7 @@ final class DropWithin[T](timeout: FiniteDuration) extends SimpleLinearGraphStag
 /**
  * INTERNAL API
  */
-final class Reduce[T](f: (T, T) ⇒ T) extends SimpleLinearGraphStage[T] {
+final class Reduce[T](val f: (T, T) ⇒ T) extends SimpleLinearGraphStage[T] {
   override def initialAttributes: Attributes = DefaultAttributes.reduce
 
   override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with InHandler with OutHandler { self ⇒
@@ -1351,7 +1379,7 @@ private[stream] object RecoverWith {
   val InfiniteRetries = -1
 }
 
-final class RecoverWith[T, M](maximumRetries: Int, pf: PartialFunction[Throwable, Graph[SourceShape[T], M]]) extends SimpleLinearGraphStage[T] {
+final class RecoverWith[T, M](val maximumRetries: Int, val pf: PartialFunction[Throwable, Graph[SourceShape[T], M]]) extends SimpleLinearGraphStage[T] {
   require(maximumRetries >= -1, "number of retries must be non-negative or equal to -1")
   override def initialAttributes = DefaultAttributes.recoverWith
 
diff --git a/akka-stream/src/main/scala/akka/stream/impl/fusing/StreamOfStreams.scala b/akka-stream/src/main/scala/akka/stream/impl/fusing/StreamOfStreams.scala
index f238a5eedd..43cc221160 100644
--- a/akka-stream/src/main/scala/akka/stream/impl/fusing/StreamOfStreams.scala
+++ b/akka-stream/src/main/scala/akka/stream/impl/fusing/StreamOfStreams.scala
@@ -24,7 +24,7 @@ import scala.collection.JavaConversions._
 /**
  * INTERNAL API
  */
-final class FlattenMerge[T, M](breadth: Int) extends GraphStage[FlowShape[Graph[SourceShape[T], M], T]] {
+final class FlattenMerge[T, M](val breadth: Int) extends GraphStage[FlowShape[Graph[SourceShape[T], M], T]] {
   private val in = Inlet[Graph[SourceShape[T], M]]("flatten.in")
   private val out = Outlet[T]("flatten.out")
 
@@ -103,7 +103,7 @@ final class FlattenMerge[T, M](breadth: Int) extends GraphStage[FlowShape[Graph[
 /**
  * INTERNAL API
  */
-final class PrefixAndTail[T](n: Int) extends GraphStage[FlowShape[T, (immutable.Seq[T], Source[T, NotUsed])]] {
+final class PrefixAndTail[T](val n: Int) extends GraphStage[FlowShape[T, (immutable.Seq[T], Source[T, NotUsed])]] {
   val in: Inlet[T] = Inlet("PrefixAndTail.in")
   val out: Outlet[(immutable.Seq[T], Source[T, NotUsed])] = Outlet("PrefixAndTail.out")
   override val shape: FlowShape[T, (immutable.Seq[T], Source[T, NotUsed])] = FlowShape(in, out)
@@ -211,7 +211,7 @@ final class PrefixAndTail[T](n: Int) extends GraphStage[FlowShape[T, (immutable.
 /**
  * INTERNAL API
  */
-final class GroupBy[T, K](maxSubstreams: Int, keyFor: T ⇒ K) extends GraphStage[FlowShape[T, Source[T, NotUsed]]] {
+final class GroupBy[T, K](val maxSubstreams: Int, val keyFor: T ⇒ K) extends GraphStage[FlowShape[T, Source[T, NotUsed]]] {
   val in: Inlet[T] = Inlet("GroupBy.in")
   val out: Outlet[Source[T, NotUsed]] = Outlet("GroupBy.out")
   override val shape: FlowShape[T, Source[T, NotUsed]] = FlowShape(in, out)
@@ -403,7 +403,7 @@ object Split {
 /**
  * INTERNAL API
  */
-final class Split[T](decision: Split.SplitDecision, p: T ⇒ Boolean, substreamCancelStrategy: SubstreamCancelStrategy) extends GraphStage[FlowShape[T, Source[T, NotUsed]]] {
+final class Split[T](val decision: Split.SplitDecision, val p: T ⇒ Boolean, val substreamCancelStrategy: SubstreamCancelStrategy) extends GraphStage[FlowShape[T, Source[T, NotUsed]]] {
   val in: Inlet[T] = Inlet("Split.in")
   val out: Outlet[Source[T, NotUsed]] = Outlet("Split.out")
   override val shape: FlowShape[T, Source[T, NotUsed]] = FlowShape(in, out)
diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/FileIO.scala b/akka-stream/src/main/scala/akka/stream/javadsl/FileIO.scala
index 0b452c4bfc..9fde2002e2 100644
--- a/akka-stream/src/main/scala/akka/stream/javadsl/FileIO.scala
+++ b/akka-stream/src/main/scala/akka/stream/javadsl/FileIO.scala
@@ -34,7 +34,7 @@ object FileIO {
   def toFile(f: File): javadsl.Sink[ByteString, CompletionStage[IOResult]] = toPath(f.toPath)
 
   /**
-   * Creates a Sink that writes incoming [[ByteString]] elements to the given file.
+   * Creates a Sink that writes incoming [[ByteString]] elements to the given file path.
    * Overwrites existing files, if you want to append to an existing file use [[#file(Path, util.Set[StandardOpenOption])]].
    *
    * Materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] that will be completed with the size of the file (in bytes) at the streams completion,
@@ -43,7 +43,7 @@ object FileIO {
    * You can configure the default dispatcher for this Source by changing the `akka.stream.blocking-io-dispatcher` or
    * set it for a given Source by using [[ActorAttributes]].
    *
-   * @param f The file to write to
+   * @param f The file path to write to
    */
   def toPath(f: Path): javadsl.Sink[ByteString, CompletionStage[IOResult]] =
     new Sink(scaladsl.FileIO.toPath(f).toCompletionStage())
@@ -65,7 +65,7 @@ object FileIO {
     toPath(f.toPath)
 
   /**
-   * Creates a Sink that writes incoming [[ByteString]] elements to the given file.
+   * Creates a Sink that writes incoming [[ByteString]] elements to the given file path.
    *
    * Materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] that will be completed with the size of the file (in bytes) at the streams completion,
    * and a possible exception if IO operation was not completed successfully.
@@ -73,7 +73,7 @@ object FileIO {
    * You can configure the default dispatcher for this Source by changing the `akka.stream.blocking-io-dispatcher` or
    * set it for a given Source by using [[ActorAttributes]].
    *
-   * @param f The file to write to
+   * @param f The file path to write to
    * @param options File open options
    */
   def toPath(f: Path, options: util.Set[StandardOpenOption]): javadsl.Sink[ByteString, CompletionStage[IOResult]] =
@@ -89,6 +89,8 @@ object FileIO {
    *
    * It materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] containing the number of bytes read from the source file upon completion,
    * and a possible exception if IO operation was not completed successfully.
+   *
+   * @param f         the file to read from
    */
   @deprecated("Use `fromPath` instead.", "2.4.5")
   def fromFile(f: File): javadsl.Source[ByteString, CompletionStage[IOResult]] = fromPath(f.toPath)
@@ -103,6 +105,8 @@ object FileIO {
    *
    * It materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] containing the number of bytes read from the source file upon completion,
    * and a possible exception if IO operation was not completed successfully.
+   *
+   * @param f         the file path to read from
    */
   def fromPath(f: Path): javadsl.Source[ByteString, CompletionStage[IOResult]] = fromPath(f, 8192)
 
@@ -116,6 +120,8 @@ object FileIO {
    *
    * It materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] containing the number of bytes read from the source file upon completion,
    * and a possible exception if IO operation was not completed successfully.
+   * @param f         the file to read from
+   * @param chunkSize the size of each read operation
    */
   @deprecated("Use `fromPath` instead.", "2.4.5")
   def fromFile(f: File, chunkSize: Int): javadsl.Source[ByteString, CompletionStage[IOResult]] =
@@ -131,6 +137,9 @@ object FileIO {
    *
    * It materializes a [[java.util.concurrent.CompletionStage]] of [[IOResult]] containing the number of bytes read from the source file upon completion,
    * and a possible exception if IO operation was not completed successfully.
+   *
+   * @param f         the file path to read from
+   * @param chunkSize the size of each read operation
    */
   def fromPath(f: Path, chunkSize: Int): javadsl.Source[ByteString, CompletionStage[IOResult]] =
     new Source(scaladsl.FileIO.fromPath(f, chunkSize).toCompletionStage())
diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala b/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala
index 70e500dadc..0d88054317 100644
--- a/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala
+++ b/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala
@@ -1919,12 +1919,6 @@ object RunnableGraph {
       if (newRunnable eq runnable) this
       else new RunnableGraphAdapter(newRunnable)
     }
-
-    override def named(name: String): RunnableGraphAdapter[Mat] = {
-      val newRunnable = runnable.named(name)
-      if (newRunnable eq runnable) this
-      else new RunnableGraphAdapter(newRunnable)
-    }
   }
 }
 /**
@@ -1942,4 +1936,12 @@ abstract class RunnableGraph[+Mat] extends Graph[ClosedShape, Mat] {
    * Transform only the materialized value of this RunnableGraph, leaving all other properties as they were.
    */
   def mapMaterializedValue[Mat2](f: function.Function[Mat, Mat2]): RunnableGraph[Mat2]
+
+  override def withAttributes(attr: Attributes): RunnableGraph[Mat]
+
+  override def addAttributes(attr: Attributes): RunnableGraph[Mat] =
+    withAttributes(module.attributes and attr)
+
+  override def named(name: String): RunnableGraph[Mat] =
+    withAttributes(Attributes.name(name))
 }
diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/JsonFraming.scala b/akka-stream/src/main/scala/akka/stream/javadsl/JsonFraming.scala
new file mode 100644
index 0000000000..99ec1d03cf
--- /dev/null
+++ b/akka-stream/src/main/scala/akka/stream/javadsl/JsonFraming.scala
@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.stream.javadsl
+
+import akka.NotUsed
+import akka.util.ByteString
+
+/** Provides JSON framing stages that can separate valid JSON objects from incoming [[akka.util.ByteString]] objects. */
+object JsonFraming {
+
+  /**
+   * Returns a Flow that implements a "brace counting" based framing stage for emitting valid JSON chunks.
+   *
+   * Typical examples of data that one may want to frame using this stage include:
+   *
+   * **Very large arrays**:
+   * {{{
+   *   [{"id": 1}, {"id": 2}, [...], {"id": 999}]
+   * }}}
+   *
+   * **Multiple concatenated JSON objects** (with, or without commas between them):
+   *
+   * {{{
+   *   {"id": 1}, {"id": 2}, [...], {"id": 999}
+   * }}}
+   *
+   * The framing works independently of formatting, i.e. it will still emit valid JSON elements even if two
+   * elements are separated by multiple newlines or other whitespace characters. And of course is insensitive
+   * (and does not impact the emitting frame) to the JSON object's internal formatting.
+   *
+   * @param maximumObjectLength The maximum length of allowed frames while decoding. If the maximum length is exceeded
+   *                            this Flow will fail the stream.
+   */
+  def objectScanner(maximumObjectLength: Int): Flow[ByteString, ByteString, NotUsed] =
+    akka.stream.scaladsl.JsonFraming.objectScanner(maximumObjectLength).asJava
+
+}
diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/Sink.scala b/akka-stream/src/main/scala/akka/stream/javadsl/Sink.scala
index 97ea1214aa..61ed2566bb 100644
--- a/akka-stream/src/main/scala/akka/stream/javadsl/Sink.scala
+++ b/akka-stream/src/main/scala/akka/stream/javadsl/Sink.scala
@@ -8,11 +8,11 @@ import akka.{ Done, NotUsed }
 import akka.actor.{ ActorRef, Props }
 import akka.dispatch.ExecutionContexts
 import akka.japi.function
-import akka.stream.impl.{ LazySink, StreamLayout, SinkQueueAdapter }
+import akka.stream.impl.{ StreamLayout, SinkQueueAdapter }
 import akka.stream.{ javadsl, scaladsl, _ }
 import org.reactivestreams.{ Publisher, Subscriber }
 import scala.compat.java8.OptionConverters._
-import scala.concurrent.{ Future, ExecutionContext }
+import scala.concurrent.ExecutionContext
 import scala.util.Try
 import java.util.concurrent.CompletionStage
 import scala.compat.java8.FutureConverters._
@@ -110,7 +110,7 @@ object Sink {
   /**
    * A `Sink` that materializes into a `CompletionStage` of the first value received.
    * If the stream completes before signaling at least a single element, the CompletionStage will be failed with a [[NoSuchElementException]].
-   * If the stream signals an error errors before signaling at least a single element, the CompletionStage will be failed with the streams exception.
+   * If the stream signals an error before signaling at least a single element, the CompletionStage will be failed with the streams exception.
    *
    * See also [[headOption]].
    */
@@ -266,7 +266,7 @@ object Sink {
 /**
  * Java API
  *
- * A `Sink` is a set of stream processing steps that has one open input and an attached output.
+ * A `Sink` is a set of stream processing steps that has one open input.
  * Can be used as a `Subscriber`
  */
 final class Sink[-In, +Mat](delegate: scaladsl.Sink[In, Mat]) extends Graph[SinkShape[In], Mat] {
@@ -276,7 +276,9 @@ final class Sink[-In, +Mat](delegate: scaladsl.Sink[In, Mat]) extends Graph[Sink
 
   override def toString: String = delegate.toString
 
-  /** Converts this Sink to its Scala DSL counterpart */
+  /**
+   * Converts this Sink to its Scala DSL counterpart.
+   */
   def asScala: scaladsl.Sink[In, Mat] = delegate
 
   /**
@@ -303,7 +305,7 @@ final class Sink[-In, +Mat](delegate: scaladsl.Sink[In, Mat]) extends Graph[Sink
     new Sink(delegate.mapMaterializedValue(f.apply _))
 
   /**
-   * Change the attributes of this [[Source]] to the given ones and seal the list
+   * Change the attributes of this [[Sink]] to the given ones and seal the list
    * of attributes. This means that further calls will not be able to remove these
    * attributes, but instead add new ones. Note that this
    * operation has no effect on an empty Flow (because the attributes apply
@@ -313,7 +315,7 @@ final class Sink[-In, +Mat](delegate: scaladsl.Sink[In, Mat]) extends Graph[Sink
     new Sink(delegate.withAttributes(attr))
 
   /**
-   * Add the given attributes to this Source. Further calls to `withAttributes`
+   * Add the given attributes to this Sink. Further calls to `withAttributes`
    * will not remove these attributes. Note that this
    * operation has no effect on an empty Flow (because the attributes apply
    * only to the contained processing stages).
@@ -322,7 +324,7 @@ final class Sink[-In, +Mat](delegate: scaladsl.Sink[In, Mat]) extends Graph[Sink
     new Sink(delegate.addAttributes(attr))
 
   /**
-   * Add a ``name`` attribute to this Flow.
+   * Add a ``name`` attribute to this Sink.
    */
   override def named(name: String): javadsl.Sink[In, Mat] =
     new Sink(delegate.named(name))
diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala b/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala
index 94b31c0fd3..420b4edfe1 100644
--- a/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala
+++ b/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala
@@ -309,7 +309,7 @@ object Source {
   }
 
   /**
-   * Creates a `Source` that is materialized as an [[akka.stream.SourceQueue]].
+   * Creates a `Source` that is materialized as an [[akka.stream.javadsl.SourceQueue]].
    * You can push elements to the queue and they will be emitted to the stream if there is demand from downstream,
    * otherwise they will be buffered until request for demand is received. Elements in the buffer will be discarded
    * if downstream is terminated.
@@ -318,15 +318,15 @@ object Source {
    * there is no space available in the buffer.
    *
    * Acknowledgement mechanism is available.
-   * [[akka.stream.SourceQueue.offer]] returns `CompletionStage<StreamCallbackStatus<Boolean>>` which completes with `Success(true)`
+   * [[akka.stream.javadsl.SourceQueue.offer]] returns `CompletionStage<StreamCallbackStatus<Boolean>>` which completes with `Success(true)`
    * if element was added to buffer or sent downstream. It completes with `Success(false)` if element was dropped. Can also complete
-   * with [[akka.stream.StreamCallbackStatus.Failure]] - when stream failed or [[akka.stream.StreamCallbackStatus.StreamCompleted]]
+   * with [[akka.stream.javadsl.StreamCallbackStatus.Failure]] - when stream failed or [[akka.stream.StreamCallbackStatus.StreamCompleted]]
    * when downstream is completed.
    *
    * The strategy [[akka.stream.OverflowStrategy.backpressure]] will not complete last `offer():CompletionStage`
    * call when buffer is full.
    *
-   * You can watch accessibility of stream with [[akka.stream.SourceQueue.watchCompletion]].
+   * You can watch accessibility of stream with [[akka.stream.javadsl.SourceQueue.watchCompletion]].
    * It returns future that completes with success when stream is completed or fail when stream is failed.
    *
    * The buffer can be disabled by using `bufferSize` of 0 and then received message will wait for downstream demand.
@@ -376,7 +376,7 @@ object Source {
 
   /**
    * Start a new `Source` from some resource which can be opened, read and closed.
-   * It's similar to `unfoldResource` but takes functions that return `CopletionStage` instead of plain values.
+   * It's similar to `unfoldResource` but takes functions that return `CompletionStage` instead of plain values.
    *
    * You can use the supervision strategy to handle exceptions for `read` function or failures of produced `Futures`.
    * All exceptions thrown by `create` or `close` as well as fails of returned futures will fail the stream.
@@ -418,7 +418,9 @@ final class Source[+Out, +Mat](delegate: scaladsl.Source[Out, Mat]) extends Grap
 
   override def toString: String = delegate.toString
 
-  /** Converts this Java DSL element to its Scala DSL counterpart. */
+  /**
+   * Converts this Java DSL element to its Scala DSL counterpart.
+   */
   def asScala: scaladsl.Source[Out, Mat] = delegate
 
   /**
@@ -909,6 +911,7 @@ final class Source[+Out, +Mat](delegate: scaladsl.Source[Out, Mat]) extends Grap
    */
   def recoverWithRetries[T >: Out](attempts: Int, pf: PartialFunction[Throwable, _ <: Graph[SourceShape[T], NotUsed]]): Source[T, Mat @uncheckedVariance] =
     new Source(delegate.recoverWithRetries(attempts, pf))
+
   /**
    * Transform each input element into an `Iterable` of output elements that is
    * then flattened into the output stream.
@@ -1553,7 +1556,6 @@ final class Source[+Out, +Mat](delegate: scaladsl.Source[Out, Mat]) extends Grap
    *
    * '''Cancels when''' downstream cancels
    *
-   * @param seed Provides the first state for extrapolation using the first unconsumed element
    * @param extrapolate Takes the current extrapolation state to produce an output element and the next extrapolation
    *                    state.
    */
@@ -2001,7 +2003,7 @@ final class Source[+Out, +Mat](delegate: scaladsl.Source[Out, Mat]) extends Grap
     new Source(delegate.addAttributes(attr))
 
   /**
-   * Add a ``name`` attribute to this Flow.
+   * Add a ``name`` attribute to this Source.
    */
   override def named(name: String): javadsl.Source[Out, Mat] =
     new Source(delegate.named(name))
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/FileIO.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/FileIO.scala
index 69942f543d..00ebfe4a6d 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/FileIO.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/FileIO.scala
@@ -51,7 +51,7 @@ object FileIO {
    * It materializes a [[Future]] of [[IOResult]] containing the number of bytes read from the source file upon completion,
    * and a possible exception if IO operation was not completed successfully.
    *
-   * @param f         the file to read from
+   * @param f         the file path to read from
    * @param chunkSize the size of each read operation, defaults to 8192
    */
   def fromPath(f: Path, chunkSize: Int = 8192): Source[ByteString, Future[IOResult]] =
@@ -74,7 +74,7 @@ object FileIO {
     toPath(f.toPath, options)
 
   /**
-   * Creates a Sink which writes incoming [[ByteString]] elements to the given file. Overwrites existing files by default.
+   * Creates a Sink which writes incoming [[ByteString]] elements to the given file path. Overwrites existing files by default.
    *
    * Materializes a [[Future]] of [[IOResult]] that will be completed with the size of the file (in bytes) at the streams completion,
    * and a possible exception if IO operation was not completed successfully.
@@ -82,7 +82,7 @@ object FileIO {
    * This source is backed by an Actor which will use the dedicated `akka.stream.blocking-io-dispatcher`,
    * unless configured otherwise by using [[ActorAttributes]].
    *
-   * @param f the file to write to
+   * @param f the file path to write to
    * @param options File open options, defaults to Set(WRITE, CREATE)
    */
   def toPath(f: Path, options: Set[StandardOpenOption] = Set(WRITE, CREATE)): Sink[ByteString, Future[IOResult]] =
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala
index c0ee5ef4e0..0db0efd21d 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala
@@ -350,10 +350,17 @@ final case class RunnableGraph[+Mat](val module: StreamLayout.Module) extends Gr
    */
   def run()(implicit materializer: Materializer): Mat = materializer.materialize(this)
 
+  override def addAttributes(attr: Attributes): RunnableGraph[Mat] =
+    withAttributes(module.attributes and attr)
+
   override def withAttributes(attr: Attributes): RunnableGraph[Mat] =
     new RunnableGraph(module.withAttributes(attr))
 
-  override def named(name: String): RunnableGraph[Mat] = withAttributes(Attributes.name(name))
+  override def named(name: String): RunnableGraph[Mat] =
+    addAttributes(Attributes.name(name))
+
+  override def async: RunnableGraph[Mat] =
+    addAttributes(Attributes.asyncBoundary)
 }
 
 /**
@@ -472,7 +479,7 @@ trait FlowOps[+Out, +Mat] {
    * '''Cancels when''' downstream cancels
    *
    */
-  def map[T](f: Out ⇒ T): Repr[T] = andThen(Map(f))
+  def map[T](f: Out ⇒ T): Repr[T] = via(Map(f))
 
   /**
    * Transform each input element into an `Iterable` of output elements that is
@@ -1822,6 +1829,14 @@ trait FlowOps[+Out, +Mat] {
 
   def named(name: String): Repr[Out]
 
+  /**
+   * Put an asynchronous boundary around this `Flow`.
+   *
+   * If this is a `SubFlow` (created e.g. by `groupBy`), this creates an
+   * asynchronous boundary around each materialized sub-flow, not the
+   * super-flow. That way, the super-flow will communicate with sub-flows
+   * asynchronously.
+   */
   def async: Repr[Out]
 
   /** INTERNAL API */
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Framing.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Framing.scala
index 7ff38cae36..15726b2457 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Framing.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Framing.scala
@@ -193,7 +193,7 @@ object Framing {
         } else if (buffer.slice(possibleMatchPos, possibleMatchPos + separatorBytes.size) == separatorBytes) {
           // Found a match
           val parsedFrame = buffer.slice(0, possibleMatchPos).compact
-          buffer = buffer.drop(possibleMatchPos + separatorBytes.size)
+          buffer = buffer.drop(possibleMatchPos + separatorBytes.size).compact
           nextPossibleMatch = 0
           if (isClosed(in) && buffer.isEmpty) {
             push(out, parsedFrame)
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Graph.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Graph.scala
index 8c73568d52..28d6ab58dd 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Graph.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Graph.scala
@@ -40,7 +40,7 @@ object Merge {
  *
  * '''Cancels when''' downstream cancels
  */
-final class Merge[T] private (val inputPorts: Int, val eagerComplete: Boolean) extends GraphStage[UniformFanInShape[T, T]] {
+final class Merge[T](val inputPorts: Int, val eagerComplete: Boolean) extends GraphStage[UniformFanInShape[T, T]] {
   // one input might seem counter intuitive but saves us from special handling in other places
   require(inputPorts >= 1, "A Merge must have one or more input ports")
 
@@ -49,8 +49,7 @@ final class Merge[T] private (val inputPorts: Int, val eagerComplete: Boolean) e
   override def initialAttributes = DefaultAttributes.merge
   override val shape: UniformFanInShape[T, T] = UniformFanInShape(out, in: _*)
 
-  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) {
-    private var initialized = false
+  override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = new GraphStageLogic(shape) with OutHandler {
 
     private val pendingQueue = FixedSizeBuffer[Inlet[T]](inputPorts)
     private def pending: Boolean = pendingQueue.nonEmpty
@@ -60,11 +59,21 @@ final class Merge[T] private (val inputPorts: Int, val eagerComplete: Boolean) e
 
     override def preStart(): Unit = in.foreach(tryPull)
 
+    @tailrec
     private def dequeueAndDispatch(): Unit = {
       val in = pendingQueue.dequeue()
-      push(out, grab(in))
-      if (upstreamsClosed && !pending) completeStage()
-      else tryPull(in)
+      if (in == null) {
+        // in is null if we reached the end of the queue
+        if (upstreamsClosed) completeStage()
+      } else if (isAvailable(in)) {
+        push(out, grab(in))
+        if (upstreamsClosed && !pending) completeStage()
+        else tryPull(in)
+      } else {
+        // in was closed after being enqueued
+        // try next in queue
+        dequeueAndDispatch()
+      }
     }
 
     in.foreach { i ⇒
@@ -90,12 +99,12 @@ final class Merge[T] private (val inputPorts: Int, val eagerComplete: Boolean) e
       })
     }
 
-    setHandler(out, new OutHandler {
-      override def onPull(): Unit = {
-        if (pending)
-          dequeueAndDispatch()
-      }
-    })
+    override def onPull(): Unit = {
+      if (pending)
+        dequeueAndDispatch()
+    }
+
+    setHandler(out, this)
   }
 
   override def toString = "Merge"
@@ -137,7 +146,7 @@ object MergePreferred {
  *
  * A `Broadcast` has one `in` port and 2 or more `out` ports.
  */
-final class MergePreferred[T] private (val secondaryPorts: Int, val eagerComplete: Boolean) extends GraphStage[MergePreferred.MergePreferredShape[T]] {
+final class MergePreferred[T](val secondaryPorts: Int, val eagerComplete: Boolean) extends GraphStage[MergePreferred.MergePreferredShape[T]] {
   require(secondaryPorts >= 1, "A MergePreferred must have more than 0 secondary input ports")
 
   override def initialAttributes = DefaultAttributes.mergePreferred
@@ -249,7 +258,7 @@ object Interleave {
  * '''Cancels when''' downstream cancels
  *
  */
-final class Interleave[T] private (val inputPorts: Int, val segmentSize: Int, val eagerClose: Boolean) extends GraphStage[UniformFanInShape[T, T]] {
+final class Interleave[T](val inputPorts: Int, val segmentSize: Int, val eagerClose: Boolean) extends GraphStage[UniformFanInShape[T, T]] {
   require(inputPorts > 1, "input ports must be > 1")
   require(segmentSize > 0, "segmentSize must be > 0")
 
@@ -388,7 +397,7 @@ object Broadcast {
  *   If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel
  *
  */
-final class Broadcast[T](private val outputPorts: Int, eagerCancel: Boolean) extends GraphStage[UniformFanOutShape[T, T]] {
+final class Broadcast[T](val outputPorts: Int, val eagerCancel: Boolean) extends GraphStage[UniformFanOutShape[T, T]] {
   // one output might seem counter intuitive but saves us from special handling in other places
   require(outputPorts >= 1, "A Broadcast must have one or more output ports")
   val in: Inlet[T] = Inlet[T]("Broadcast.in")
@@ -487,7 +496,7 @@ object Partition {
  *   when all downstreams cancel
  */
 
-final class Partition[T](outputPorts: Int, partitioner: T ⇒ Int) extends GraphStage[UniformFanOutShape[T, T]] {
+final class Partition[T](val outputPorts: Int, val partitioner: T ⇒ Int) extends GraphStage[UniformFanOutShape[T, T]] {
 
   val in: Inlet[T] = Inlet[T]("Partition.in")
   val out: Seq[Outlet[T]] = Seq.tabulate(outputPorts)(i ⇒ Outlet[T]("Partition.out" + i))
@@ -593,7 +602,7 @@ object Balance {
  *
  * '''Cancels when''' all downstreams cancel
  */
-final class Balance[T](val outputPorts: Int, waitForAllDownstreams: Boolean) extends GraphStage[UniformFanOutShape[T, T]] {
+final class Balance[T](val outputPorts: Int, val waitForAllDownstreams: Boolean) extends GraphStage[UniformFanOutShape[T, T]] {
   // one output might seem counter intuitive but saves us from special handling in other places
   require(outputPorts >= 1, "A Balance must have one or more output ports")
   val in: Inlet[T] = Inlet[T]("Balance.in")
@@ -608,10 +617,20 @@ final class Balance[T](val outputPorts: Int, waitForAllDownstreams: Boolean) ext
     private var needDownstreamPulls: Int = if (waitForAllDownstreams) outputPorts else 0
     private var downstreamsRunning: Int = outputPorts
 
+    @tailrec
     private def dequeueAndDispatch(): Unit = {
       val out = pendingQueue.dequeue()
-      push(out, grab(in))
-      if (!noPending) pull(in)
+      // out is null if depleted pendingQueue without reaching
+      // an out that is not closed, in which case we just return
+      if (out ne null) {
+        if (!isClosed(out)) {
+          push(out, grab(in))
+          if (!noPending) pull(in)
+        } else {
+          // try to find one output that isn't closed
+          dequeueAndDispatch()
+        }
+      }
     }
 
     setHandler(in, new InHandler {
@@ -851,7 +870,7 @@ object Concat {
  *
  * '''Cancels when''' downstream cancels
  */
-final class Concat[T](inputPorts: Int) extends GraphStage[UniformFanInShape[T, T]] {
+final class Concat[T](val inputPorts: Int) extends GraphStage[UniformFanInShape[T, T]] {
   require(inputPorts > 1, "A Concat must have more than 1 input ports")
   val in: immutable.IndexedSeq[Inlet[T]] = Vector.tabulate(inputPorts)(i ⇒ Inlet[T]("Concat.in" + i))
   val out: Outlet[T] = Outlet[T]("Concat.out")
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/JsonFraming.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/JsonFraming.scala
new file mode 100644
index 0000000000..d0dffb52c9
--- /dev/null
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/JsonFraming.scala
@@ -0,0 +1,78 @@
+/**
+ * Copyright (C) 2015-2016 Lightbend Inc. <http://www.lightbend.com>
+ */
+package akka.stream.scaladsl
+
+import akka.NotUsed
+import akka.stream.Attributes
+import akka.stream.impl.JsonObjectParser
+import akka.stream.impl.fusing.GraphStages.SimpleLinearGraphStage
+import akka.stream.stage.{ InHandler, OutHandler, GraphStageLogic }
+import akka.util.ByteString
+
+import scala.util.control.NonFatal
+
+/** Provides JSON framing stages that can separate valid JSON objects from incoming [[ByteString]] objects. */
+object JsonFraming {
+
+  /**
+   * Returns a Flow that implements a "brace counting" based framing stage for emitting valid JSON chunks.
+   * It scans the incoming data stream for valid JSON objects and returns chunks of ByteStrings containing only those valid chunks.
+   *
+   * Typical examples of data that one may want to frame using this stage include:
+   *
+   * **Very large arrays**:
+   * {{{
+   *   [{"id": 1}, {"id": 2}, [...], {"id": 999}]
+   * }}}
+   *
+   * **Multiple concatenated JSON objects** (with, or without commas between them):
+   *
+   * {{{
+   *   {"id": 1}, {"id": 2}, [...], {"id": 999}
+   * }}}
+   *
+   * The framing works independently of formatting, i.e. it will still emit valid JSON elements even if two
+   * elements are separated by multiple newlines or other whitespace characters. And of course is insensitive
+   * (and does not impact the emitting frame) to the JSON object's internal formatting.
+   *
+   * @param maximumObjectLength The maximum length of allowed frames while decoding. If the maximum length is exceeded
+   *                            this Flow will fail the stream.
+   */
+  def objectScanner(maximumObjectLength: Int): Flow[ByteString, ByteString, NotUsed] =
+    Flow[ByteString].via(new SimpleLinearGraphStage[ByteString] {
+
+      override protected def initialAttributes: Attributes = Attributes.name("JsonFraming.objectScanner")
+
+      override def createLogic(inheritedAttributes: Attributes) = new GraphStageLogic(shape) with InHandler with OutHandler {
+        private val buffer = new JsonObjectParser(maximumObjectLength)
+
+        setHandlers(in, out, this)
+
+        override def onPush(): Unit = {
+          buffer.offer(grab(in))
+          tryPopBuffer()
+        }
+
+        override def onPull(): Unit =
+          tryPopBuffer()
+
+        override def onUpstreamFinish(): Unit = {
+          buffer.poll() match {
+            case Some(json) ⇒ emit(out, json)
+            case _          ⇒ completeStage()
+          }
+        }
+
+        def tryPopBuffer() = {
+          try buffer.poll() match {
+            case Some(json) ⇒ push(out, json)
+            case _          ⇒ if (isClosed(in)) completeStage() else pull(in)
+          } catch {
+            case NonFatal(ex) ⇒ failStage(ex)
+          }
+        }
+      }
+    })
+
+}
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Sink.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Sink.scala
index e2964f727e..c82445586c 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Sink.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Sink.scala
@@ -23,7 +23,7 @@ import scala.concurrent.{ Await, ExecutionContext, Future }
 import scala.util.{ Failure, Success, Try }
 
 /**
- * A `Sink` is a set of stream processing steps that has one open input and an attached output.
+ * A `Sink` is a set of stream processing steps that has one open input.
  * Can be used as a `Subscriber`
  */
 final class Sink[-In, +Mat](override val module: Module)
@@ -50,11 +50,14 @@ final class Sink[-In, +Mat](override val module: Module)
   def runWith[Mat2](source: Graph[SourceShape[In], Mat2])(implicit materializer: Materializer): Mat2 =
     Source.fromGraph(source).to(this).run()
 
+  /**
+   * Transform only the materialized value of this Sink, leaving all other properties as they were.
+   */
   def mapMaterializedValue[Mat2](f: Mat ⇒ Mat2): Sink[In, Mat2] =
     new Sink(module.transformMaterializedValue(f.asInstanceOf[Any ⇒ Any]))
 
   /**
-   * Change the attributes of this [[Source]] to the given ones and seal the list
+   * Change the attributes of this [[Sink]] to the given ones and seal the list
    * of attributes. This means that further calls will not be able to remove these
    * attributes, but instead add new ones. Note that this
    * operation has no effect on an empty Flow (because the attributes apply
@@ -64,7 +67,7 @@ final class Sink[-In, +Mat](override val module: Module)
     new Sink(module.withAttributes(attr))
 
   /**
-   * Add the given attributes to this Source. Further calls to `withAttributes`
+   * Add the given attributes to this Sink. Further calls to `withAttributes`
    * will not remove these attributes. Note that this
    * operation has no effect on an empty Flow (because the attributes apply
    * only to the contained processing stages).
@@ -73,7 +76,7 @@ final class Sink[-In, +Mat](override val module: Module)
     withAttributes(module.attributes and attr)
 
   /**
-   * Add a ``name`` attribute to this Flow.
+   * Add a ``name`` attribute to this Sink.
    */
   override def named(name: String): Sink[In, Mat] = addAttributes(Attributes.name(name))
 
@@ -82,7 +85,9 @@ final class Sink[-In, +Mat](override val module: Module)
    */
   override def async: Sink[In, Mat] = addAttributes(Attributes.asyncBoundary)
 
-  /** Converts this Scala DSL element to it's Java DSL counterpart. */
+  /**
+   * Converts this Scala DSL element to it's Java DSL counterpart.
+   */
   def asJava: javadsl.Sink[In, Mat] = new javadsl.Sink(this)
 }
 
@@ -228,7 +233,7 @@ object Sink {
    * [[akka.stream.Supervision.Resume]] or [[akka.stream.Supervision.Restart]] the
    * element is dropped and the stream continues.
    *
-   * @see [[#mapAsyncUnordered]]
+   * See also [[Flow.mapAsyncUnordered]]
    */
   def foreachParallel[T](parallelism: Int)(f: T ⇒ Unit)(implicit ec: ExecutionContext): Sink[T, Future[Done]] =
     Flow[T].mapAsyncUnordered(parallelism)(t ⇒ Future(f(t))).toMat(Sink.ignore)(Keep.right)
@@ -344,7 +349,7 @@ object Sink {
    * For stream completion you need to pull all elements from [[akka.stream.scaladsl.SinkQueue]] including last None
    * as completion marker
    *
-   * @see [[akka.stream.scaladsl.SinkQueueWithCancel]]
+   * See also [[akka.stream.scaladsl.SinkQueueWithCancel]]
    */
   def queue[T](): Sink[T, SinkQueueWithCancel[T]] =
     Sink.fromGraph(new QueueSink())
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala
index 3ce9ddc387..c0549efb71 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala
@@ -136,7 +136,7 @@ final class Source[+Out, +Mat](override val module: Module)
   override def addAttributes(attr: Attributes): Repr[Out] = withAttributes(module.attributes and attr)
 
   /**
-   * Add a ``name`` attribute to this Flow.
+   * Add a ``name`` attribute to this Source.
    */
   override def named(name: String): Repr[Out] = addAttributes(Attributes.name(name))
 
@@ -145,7 +145,9 @@ final class Source[+Out, +Mat](override val module: Module)
    */
   override def async: Repr[Out] = addAttributes(Attributes.asyncBoundary)
 
-  /** Converts this Scala DSL element to it's Java DSL counterpart. */
+  /**
+   * Converts this Scala DSL element to it's Java DSL counterpart.
+   */
   def asJava: javadsl.Source[Out, Mat] = new javadsl.Source(this)
 
   /**
@@ -436,7 +438,7 @@ object Source {
   }
 
   /**
-   * Creates a `Source` that is materialized as an [[akka.stream.SourceQueue]].
+   * Creates a `Source` that is materialized as an [[akka.stream.scaladsl.SourceQueue]].
    * You can push elements to the queue and they will be emitted to the stream if there is demand from downstream,
    * otherwise they will be buffered until request for demand is received. Elements in the buffer will be discarded
    * if downstream is terminated.
@@ -445,7 +447,7 @@ object Source {
    * there is no space available in the buffer.
    *
    * Acknowledgement mechanism is available.
-   * [[akka.stream.SourceQueue.offer]] returns ``Future[StreamCallbackStatus[Boolean]]`` which completes with `Success(true)`
+   * [[akka.stream.scaladsl.SourceQueue.offer]] returns ``Future[StreamCallbackStatus[Boolean]]`` which completes with `Success(true)`
    * if element was added to buffer or sent downstream. It completes with `Success(false)` if element was dropped. Can also complete
    * with [[akka.stream.StreamCallbackStatus.Failure]] - when stream failed or [[akka.stream.StreamCallbackStatus.StreamCompleted]]
    * when downstream is completed.
@@ -453,7 +455,7 @@ object Source {
    * The strategy [[akka.stream.OverflowStrategy.backpressure]] will not complete last `offer():Future`
    * call when buffer is full.
    *
-   * You can watch accessibility of stream with [[akka.stream.SourceQueue.watchCompletion]].
+   * You can watch accessibility of stream with [[akka.stream.scaladsl.SourceQueue.watchCompletion]].
    * It returns future that completes with success when stream is completed or fail when stream is failed.
    *
    * The buffer can be disabled by using `bufferSize` of 0 and then received message will wait for downstream demand.
diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Tcp.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Tcp.scala
index bdcbf0ad99..43e2dd2b2e 100644
--- a/akka-stream/src/main/scala/akka/stream/scaladsl/Tcp.scala
+++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Tcp.scala
@@ -183,5 +183,5 @@ final class Tcp(system: ExtendedActorSystem) extends akka.actor.Extension {
    * It represents a prospective TCP client connection to the given endpoint.
    */
   def outgoingConnection(host: String, port: Int): Flow[ByteString, ByteString, Future[OutgoingConnection]] =
-    outgoingConnection(new InetSocketAddress(host, port))
+    outgoingConnection(InetSocketAddress.createUnresolved(host, port))
 }
diff --git a/akka-stream/src/main/scala/akka/stream/stage/GraphStage.scala b/akka-stream/src/main/scala/akka/stream/stage/GraphStage.scala
index 493335fa9c..85a3b7e90f 100644
--- a/akka-stream/src/main/scala/akka/stream/stage/GraphStage.scala
+++ b/akka-stream/src/main/scala/akka/stream/stage/GraphStage.scala
@@ -19,6 +19,7 @@ import akka.stream.actor.ActorSubscriberMessage
 
 abstract class GraphStageWithMaterializedValue[+S <: Shape, +M] extends Graph[S, M] {
 
+  @throws(classOf[Exception])
   def createLogicAndMaterializedValue(inheritedAttributes: Attributes): (GraphStageLogic, M)
 
   protected def initialAttributes: Attributes = Attributes.none
@@ -42,6 +43,7 @@ abstract class GraphStage[S <: Shape] extends GraphStageWithMaterializedValue[S,
   final override def createLogicAndMaterializedValue(inheritedAttributes: Attributes): (GraphStageLogic, NotUsed) =
     (createLogic(inheritedAttributes), NotUsed)
 
+  @throws(classOf[Exception])
   def createLogic(inheritedAttributes: Attributes): GraphStageLogic
 }
 
@@ -220,7 +222,7 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    * INTERNAL API
    */
   // Using common array to reduce overhead for small port counts
-  private[stream] val portToConn = Array.ofDim[Int](handlers.length)
+  private[stream] val portToConn = Array.ofDim[Connection](handlers.length)
 
   /**
    * INTERNAL API
@@ -318,8 +320,8 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
     if (_interpreter != null) _interpreter.setHandler(conn(out), handler)
   }
 
-  private def conn(in: Inlet[_]): Int = portToConn(in.id)
-  private def conn(out: Outlet[_]): Int = portToConn(out.id + inCount)
+  private def conn(in: Inlet[_]): Connection = portToConn(in.id)
+  private def conn(out: Outlet[_]): Connection = portToConn(out.id + inCount)
 
   /**
    * Retrieves the current callback for the events on the given [[Outlet]]
@@ -340,12 +342,21 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    * query whether pull is allowed to be called or not. This method will also fail if the port is already closed.
    */
   final protected def pull[T](in: Inlet[T]): Unit = {
-    if ((interpreter.portStates(conn(in)) & (InReady | InClosed)) == InReady) {
-      interpreter.pull(conn(in))
+    val connection = conn(in)
+    val it = interpreter
+    val portState = connection.portState
+
+    if ((portState & (InReady | InClosed | OutClosed)) == InReady) {
+      connection.portState = portState ^ PullStartFlip
+      it.chasePull(connection)
     } else {
       // Detailed error information should not add overhead to the hot path
       require(!isClosed(in), s"Cannot pull closed port ($in)")
       require(!hasBeenPulled(in), s"Cannot pull port ($in) twice")
+
+      // There were no errors, the pull was simply ignored as the target stage already closed its port. We
+      // still need to track proper state though.
+      connection.portState = portState ^ PullStartFlip
     }
   }
 
@@ -371,18 +382,19 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    */
   final protected def grab[T](in: Inlet[T]): T = {
     val connection = conn(in)
+    val it = interpreter
+    val elem = connection.slot
+
     // Fast path
-    if ((interpreter.portStates(connection) & (InReady | InFailed)) == InReady &&
-      (interpreter.connectionSlots(connection).asInstanceOf[AnyRef] ne Empty)) {
-      val elem = interpreter.connectionSlots(connection)
-      interpreter.connectionSlots(connection) = Empty
+    if ((connection.portState & (InReady | InFailed)) == InReady && (elem.asInstanceOf[AnyRef] ne Empty)) {
+      connection.slot = Empty
       elem.asInstanceOf[T]
     } else {
       // Slow path
       require(isAvailable(in), s"Cannot get element from already empty input port ($in)")
-      val failed = interpreter.connectionSlots(connection).asInstanceOf[Failed]
+      val failed = connection.slot.asInstanceOf[Failed]
       val elem = failed.previousElem.asInstanceOf[T]
-      interpreter.connectionSlots(connection) = Failed(failed.ex, Empty)
+      connection.slot = Failed(failed.ex, Empty)
       elem
     }
   }
@@ -391,7 +403,7 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    * Indicates whether there is already a pending pull for the given input port. If this method returns true
    * then [[isAvailable()]] must return false for that same port.
    */
-  final protected def hasBeenPulled[T](in: Inlet[T]): Boolean = (interpreter.portStates(conn(in)) & (InReady | InClosed)) == 0
+  final protected def hasBeenPulled[T](in: Inlet[T]): Boolean = (conn(in).portState & (InReady | InClosed)) == 0
 
   /**
    * Indicates whether there is an element waiting at the given input port. [[grab()]] can be used to retrieve the
@@ -402,14 +414,14 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
   final protected def isAvailable[T](in: Inlet[T]): Boolean = {
     val connection = conn(in)
 
-    val normalArrived = (interpreter.portStates(conn(in)) & (InReady | InFailed)) == InReady
+    val normalArrived = (conn(in).portState & (InReady | InFailed)) == InReady
 
     // Fast path
-    if (normalArrived) interpreter.connectionSlots(connection).asInstanceOf[AnyRef] ne Empty
+    if (normalArrived) connection.slot.asInstanceOf[AnyRef] ne Empty
     else {
       // Slow path on failure
-      if ((interpreter.portStates(conn(in)) & (InReady | InFailed)) == (InReady | InFailed)) {
-        interpreter.connectionSlots(connection) match {
+      if ((connection.portState & (InReady | InFailed)) == (InReady | InFailed)) {
+        connection.slot match {
           case Failed(_, elem) ⇒ elem.asInstanceOf[AnyRef] ne Empty
           case _               ⇒ false // This can only be Empty actually (if a cancel was concurrent with a failure)
         }
@@ -420,7 +432,7 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
   /**
    * Indicates whether the port has been closed. A closed port cannot be pulled.
    */
-  final protected def isClosed[T](in: Inlet[T]): Boolean = (interpreter.portStates(conn(in)) & InClosed) != 0
+  final protected def isClosed[T](in: Inlet[T]): Boolean = (conn(in).portState & InClosed) != 0
 
   /**
    * Emits an element through the given output port. Calling this method twice before a [[pull()]] has been arrived
@@ -428,13 +440,26 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    * used to check if the port is ready to be pushed or not.
    */
   final protected def push[T](out: Outlet[T], elem: T): Unit = {
-    if ((interpreter.portStates(conn(out)) & (OutReady | OutClosed)) == OutReady && (elem != null)) {
-      interpreter.push(conn(out), elem)
+    val connection = conn(out)
+    val it = interpreter
+    val portState = connection.portState
+
+    connection.portState = portState ^ PushStartFlip
+
+    if ((portState & (OutReady | OutClosed | InClosed)) == OutReady && (elem != null)) {
+      connection.slot = elem
+      it.chasePush(connection)
     } else {
+      // Restore state for the error case
+      connection.portState = portState
+
       // Detailed error information should not add overhead to the hot path
       ReactiveStreamsCompliance.requireNonNullElement(elem)
-      require(isAvailable(out), s"Cannot push port ($out) twice")
       require(!isClosed(out), s"Cannot pull closed port ($out)")
+      require(isAvailable(out), s"Cannot push port ($out) twice")
+
+      // No error, just InClosed caused the actual pull to be ignored, but the status flag still needs to be flipped
+      connection.portState = portState ^ PushStartFlip
     }
   }
 
@@ -500,12 +525,12 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
    * Return true if the given output port is ready to be pushed.
    */
   final def isAvailable[T](out: Outlet[T]): Boolean =
-    (interpreter.portStates(conn(out)) & (OutReady | OutClosed)) == OutReady
+    (conn(out).portState & (OutReady | OutClosed)) == OutReady
 
   /**
    * Indicates whether the port has been closed. A closed port cannot be pushed.
    */
-  final protected def isClosed[T](out: Outlet[T]): Boolean = (interpreter.portStates(conn(out)) & OutClosed) != 0
+  final protected def isClosed[T](out: Outlet[T]): Boolean = (conn(out).portState & OutClosed) != 0
 
   /**
    * Read a number of elements from the given inlet and continue with the given function,
@@ -925,11 +950,13 @@ abstract class GraphStageLogic private[stream] (val inCount: Int, val outCount:
   /**
    * Invoked before any external events are processed, at the startup of the stage.
    */
+  @throws(classOf[Exception])
   def preStart(): Unit = ()
 
   /**
    * Invoked after processing of external events stopped because the stage is about to stop or fail.
    */
+  @throws(classOf[Exception])
   def postStop(): Unit = ()
 
   /**
@@ -1132,6 +1159,7 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
    *
    * @param timerKey key of the scheduled timer
    */
+  @throws(classOf[Exception])
   protected def onTimer(timerKey: Any): Unit = ()
 
   // Internal hooks to avoid reliance on user calling super in postStop
@@ -1309,14 +1337,12 @@ private[akka] trait CallbackWrapper[T] extends AsyncCallback[T] {
     callbackState.get() match {
       case Initialized(cb)          ⇒ cb(arg)
       case list @ NotInitialized(l) ⇒ callbackState.compareAndSet(list, NotInitialized(arg :: l))
-      case Stopped(cb) ⇒
-        lock.unlock()
-        cb(arg)
+      case Stopped(cb)              ⇒ cb(arg)
     }
   }
 
   private[this] def locked(body: ⇒ Unit): Unit = {
     lock.lock()
-    try body finally if (lock.isLocked) lock.unlock()
+    try body finally lock.unlock()
   }
 }
diff --git a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
index 7a1675b405..b13b6218ca 100644
--- a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
+++ b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
@@ -44,7 +44,7 @@ object AkkaSpec {
 
   def getCallerName(clazz: Class[_]): String = {
     val s = (Thread.currentThread.getStackTrace map (_.getClassName) drop 1)
-      .dropWhile(_ matches "(java.lang.Thread|.*AkkaSpec.?$)")
+      .dropWhile(_ matches "(java.lang.Thread|.*AkkaSpec.?$|.*StreamSpec.?$)")
     val reduced = s.lastIndexWhere(_ == clazz.getName) match {
       case -1 ⇒ s
       case z  ⇒ s drop (z + 1)
diff --git a/akka-typed/src/test/scala/akka/typed/ActorContextSpec.scala b/akka-typed/src/test/scala/akka/typed/ActorContextSpec.scala
index 0fad48a56a..7fce39a353 100644
--- a/akka-typed/src/test/scala/akka/typed/ActorContextSpec.scala
+++ b/akka-typed/src/test/scala/akka/typed/ActorContextSpec.scala
@@ -2,7 +2,6 @@ package akka.typed
 
 import scala.concurrent.duration._
 import scala.concurrent.Future
-import org.scalautils.ConversionCheckedTripleEquals
 import com.typesafe.config.ConfigFactory
 import akka.actor.DeadLetterSuppression
 
diff --git a/akka-typed/src/test/scala/akka/typed/BehaviorSpec.scala b/akka-typed/src/test/scala/akka/typed/BehaviorSpec.scala
index 9ce6bd9dac..241b3dc794 100644
--- a/akka-typed/src/test/scala/akka/typed/BehaviorSpec.scala
+++ b/akka-typed/src/test/scala/akka/typed/BehaviorSpec.scala
@@ -3,8 +3,6 @@
  */
 package akka.typed
 
-import org.scalautils.ConversionCheckedTripleEquals
-
 class BehaviorSpec extends TypedSpec {
 
   sealed trait Command {
diff --git a/project/AkkaBuild.scala b/project/AkkaBuild.scala
index 87856727ef..e5453761fb 100644
--- a/project/AkkaBuild.scala
+++ b/project/AkkaBuild.scala
@@ -259,8 +259,10 @@ object AkkaBuild extends Build {
   lazy val httpTests = Project(
     id = "akka-http-tests",
     base = file("akka-http-tests"),
-    dependencies = Seq(httpTestkit % "test", streamTestkit % "test->test", testkit % "test->test", httpSprayJson, httpXml, httpJackson)
-  ).disablePlugins(ValidatePullRequest, MimaPlugin)
+    dependencies = Seq(
+      httpTestkit % "test", streamTestkit % "test->test", testkit % "test->test", httpSprayJson, httpXml, httpJackson, 
+      multiNodeTestkit, remoteTests % "test->test") // required for multi-node latency/throughput Spec
+  ).configs(MultiJvm).disablePlugins(ValidatePullRequest, MimaPlugin)
 
   lazy val httpMarshallersScala = Project(
     id = "akka-http-marshallers-scala-experimental",
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index a057e19ac7..f2df03ccbc 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -19,19 +19,17 @@ object Dependencies {
     crossScalaVersions := Seq("2.11.8"), // "2.12.0-M4"
     scalaVersion := crossScalaVersions.value.head,
     scalaStmVersion := sys.props.get("akka.build.scalaStmVersion").getOrElse("0.7"),
-    scalaCheckVersion := sys.props.get("akka.build.scalaCheckVersion").getOrElse("1.11.6"),
+    scalaCheckVersion := sys.props.get("akka.build.scalaCheckVersion").getOrElse("1.13.2"),
     scalaTestVersion := {
       scalaVersion.value match {
-        case "2.12.0-M1" => "2.2.5-M1"
-        case "2.12.0-M2" => "2.2.5-M2"
-        case "2.12.0-M3" => "2.2.5-M3"
-        case "2.12.0-M4" => "2.2.6"
-        case _ => "2.2.4"
+        case "2.12.0-M5" => "3.0.0"
+        case _ => "3.0.0"
       }
     },
     java8CompatVersion := {
       scalaVersion.value match {
         case "2.12.0-M4" => "0.8.0-RC1"
+        case "2.12.0-M5" => "0.8.0-RC3"
         case _ => "0.7.0"
       }
     }
@@ -70,7 +68,7 @@ object Dependencies {
     val sprayJson   = "io.spray"                     %% "spray-json"                   % "1.3.2"       // ApacheV2
 
     // For akka-http-jackson support
-    val jackson     = "com.fasterxml.jackson.core"    % "jackson-databind"             % "2.7.4"       // ApacheV2
+    val jackson     = "com.fasterxml.jackson.core"    % "jackson-databind"             % "2.7.6"       // ApacheV2
 
     // For akka-http-testkit-java
     val junit       = "junit"                         % "junit"                        % junitVersion  // Common Public License 1.0
diff --git a/project/MiMa.scala b/project/MiMa.scala
index fa318a84a6..e7a2a6c6a7 100644
--- a/project/MiMa.scala
+++ b/project/MiMa.scala
@@ -917,7 +917,48 @@ object MiMa extends AutoPlugin {
         ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.cluster.pubsub.protobuf.msg.DistributedPubSubMessages#StatusOrBuilder.hasReplyToStatus"),
 
         // #20543 GraphStage subtypes should not be private to akka
-        ProblemFilters.exclude[DirectAbstractMethodProblem]("akka.stream.ActorMaterializer.actorOf")
+        ProblemFilters.exclude[DirectAbstractMethodProblem]("akka.stream.ActorMaterializer.actorOf"),
+
+        // Interpreter internals change
+        ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.stream.stage.GraphStageLogic.portToConn"),
+        
+	// #20994 adding new decode method, since we're on JDK7+ now
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.util.ByteString.decodeString"),
+
+        // #20508  HTTP: Document how to be able to support custom request methods
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.http.javadsl.model.HttpMethod.getRequestEntityAcceptance"),
+        
+        // #20976 provide different options to deal with the illegal response header value
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.http.javadsl.settings.ParserSettings.getIllegalResponseHeaderValueProcessingMode"),
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.http.scaladsl.settings.ParserSettings.illegalResponseHeaderValueProcessingMode"),
+        
+        ProblemFilters.exclude[DirectAbstractMethodProblem]("akka.stream.ActorMaterializer.actorOf"),
+
+        // #20628 migrate Masker to GraphStage
+        ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.engine.ws.Masking$Masking"),
+        ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.engine.ws.Masking$Masker"),
+        ProblemFilters.exclude[DirectMissingMethodProblem]("akka.http.impl.engine.ws.Masking#Masker.initial"),
+        ProblemFilters.exclude[MissingClassProblem]("akka.http.impl.engine.ws.Masking$Masker$Running"),
+        ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.engine.ws.Masking$Unmasking"),
+        
+        // #
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.http.javadsl.model.HttpEntity.discardBytes"),
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.http.scaladsl.model.HttpEntity.discardBytes"),
+
+        // #20630 corrected return types of java methods
+        ProblemFilters.exclude[IncompatibleResultTypeProblem]("akka.stream.javadsl.RunnableGraph#RunnableGraphAdapter.named"),
+        ProblemFilters.exclude[ReversedMissingMethodProblem]("akka.stream.javadsl.RunnableGraph.withAttributes"),
+
+        // #19872 double wildcard for actor deployment config
+        ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.actor.Deployer.lookup"),
+        ProblemFilters.exclude[DirectMissingMethodProblem]("akka.util.WildcardTree.apply"),
+        ProblemFilters.exclude[DirectMissingMethodProblem]("akka.util.WildcardTree.find"),
+        
+        // #20942 ClusterSingleton
+        ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.cluster.singleton.ClusterSingletonManager.addRemoved"),
+        ProblemFilters.exclude[DirectMissingMethodProblem]("akka.cluster.singleton.ClusterSingletonManager.selfAddressOption")
+      ),
+      "2.4.9" -> Seq(
       )
     )
   }
diff --git a/project/OSGi.scala b/project/OSGi.scala
index 7417ada953..869bffd371 100644
--- a/project/OSGi.scala
+++ b/project/OSGi.scala
@@ -3,6 +3,7 @@
  */
 package akka
 
+import com.typesafe.sbt.osgi.OsgiKeys
 import com.typesafe.sbt.osgi.SbtOsgi._
 import sbt._
 import sbt.Keys._
@@ -13,7 +14,10 @@ object OSGi {
   // in the .../bundles directory which makes testing locally published artifacts
   // a pain. Create bundles but publish them to the normal .../jars directory.
   def osgiSettings = defaultOsgiSettings ++ Seq(
-    packagedArtifact in (Compile, packageBin) <<= (artifact in (Compile, packageBin), OsgiKeys.bundle).identityMap
+    packagedArtifact in (Compile, packageBin) <<= (artifact in (Compile, packageBin), OsgiKeys.bundle).identityMap,
+    // This will fail the build instead of accidentally removing classes from the resulting artifact.
+    // Each package contained in a project MUST be known to be private or exported, if it's undecided we MUST resolve this
+    OsgiKeys.failOnUndecidedPackage := true 
   )
 
   val actor = osgiSettings ++ Seq(
@@ -52,10 +56,17 @@ object OSGi {
 
   val httpCore = exports(Seq("akka.http.*"), imports = Seq(scalaJava8CompatImport()))
 
-  val http = exports(Seq("akka.http.impl.server",
-    "akka.http.scaladsl.server.*", "akka.http.javadsl.server.*",
-    "akka.http.scaladsl.client", "akka.http.scaladsl.coding", "akka.http.scaladsl.common",
-    "akka.http.scaladsl.marshalling", "akka.http.scaladsl.unmarshalling"),
+  val http = exports(Seq("akka.http.impl.server") ++ 
+    Seq(
+      "akka.http.$DSL$.server.*",
+      "akka.http.$DSL$.client.*",
+      "akka.http.$DSL$.coding.*",
+      "akka.http.$DSL$.common.*",
+      "akka.http.$DSL$.marshalling.*",
+      "akka.http.$DSL$.unmarshalling.*"
+    ) flatMap { p =>
+      Seq(p.replace("$DSL$", "scaladsl"), p.replace("$DSL$", "javadsl"))  
+    },
     imports = Seq(
       scalaJava8CompatImport(),
       akkaImport("akka.stream.*"),
diff --git a/project/plugins.sbt b/project/plugins.sbt
index a8d01a6513..b847781fc9 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -13,7 +13,7 @@ addSbtPlugin("org.scalariform" % "sbt-scalariform" % "1.6.0")
 
 addSbtPlugin("com.typesafe.sbt" % "sbt-site" % "0.7.1")
 
-addSbtPlugin("com.typesafe.sbt" % "sbt-osgi" % "0.6.0")
+addSbtPlugin("com.typesafe.sbt" % "sbt-osgi" % "0.9.1")
 
 addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.9")
 
@@ -25,7 +25,7 @@ addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.3.3")
 
 addSbtPlugin("com.thoughtworks.sbt-api-mappings" % "sbt-api-mappings" % "0.2.2")
 
-addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.2.6")
+addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.2.11")
 
 addSbtPlugin("pl.project13.sbt" % "sbt-jol" % "0.1.1")