diff --git a/akka-docs-dev/rst/java/code/docs/http/javadsl/HttpClientExampleDocTest.java b/akka-docs-dev/rst/java/code/docs/http/javadsl/HttpClientExampleDocTest.java index 44c41146c1..6879b1a969 100644 --- a/akka-docs-dev/rst/java/code/docs/http/javadsl/HttpClientExampleDocTest.java +++ b/akka-docs-dev/rst/java/code/docs/http/javadsl/HttpClientExampleDocTest.java @@ -4,10 +4,14 @@ package docs.http.javadsl; +import akka.actor.AbstractActor; import akka.actor.ActorSystem; import akka.http.javadsl.HostConnectionPool; import akka.japi.Pair; +import akka.japi.pf.ReceiveBuilder; +import akka.stream.Materializer; +import scala.concurrent.ExecutionContextExecutor; import scala.concurrent.Future; import akka.stream.ActorMaterializer; import akka.stream.javadsl.*; @@ -16,6 +20,8 @@ import akka.http.javadsl.model.*; import akka.http.javadsl.Http; import scala.util.Try; +import static akka.pattern.Patterns.*; + @SuppressWarnings("unused") public class HttpClientExampleDocTest { @@ -62,11 +68,32 @@ public class HttpClientExampleDocTest { public void testSingleRequestExample() { //#single-request-example final ActorSystem system = ActorSystem.create(); - final ActorMaterializer materializer = ActorMaterializer.create(system); + final Materializer materializer = ActorMaterializer.create(system); final Future responseFuture = Http.get(system) .singleRequest(HttpRequest.create("http://akka.io"), materializer); //#single-request-example } -} \ No newline at end of file + + static + //#single-request-in-actor-example + class Myself extends AbstractActor { + final Http http = Http.get(context().system()); + final ExecutionContextExecutor dispatcher = context().dispatcher(); + final Materializer materializer = ActorMaterializer.create(context()); + + public Myself() { + receive(ReceiveBuilder + .match(String.class, url -> { + pipe(fetch (url), dispatcher).to(self()); + }).build()); + } + + Future fetch(String url) { + return http.singleRequest(HttpRequest.create(url), materializer); + } + } + //#single-request-in-actor-example + +} diff --git a/akka-docs-dev/rst/java/http/client-side/request-level.rst b/akka-docs-dev/rst/java/http/client-side/request-level.rst index 9c00c71d7b..daf33add03 100644 --- a/akka-docs-dev/rst/java/http/client-side/request-level.rst +++ b/akka-docs-dev/rst/java/http/client-side/request-level.rst @@ -44,8 +44,13 @@ request's effective URI. Just like in the case of the super-pool flow described above the request must have either an absolute URI or a valid ``Host`` header, otherwise the returned future will be completed with an error. +.. includecode:: ../../code/docs/http/javadsl/HttpClientExampleDocTest.java#single-request-example -Example -------- +Using the Future-Based API in Actors +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +When using the ``Future`` based API from inside an ``Actor``, all the usual caveats apply to how one should deal +with the futures completion. For example you should not access the Actors state from within the Future's callbacks +(such as ``map``, ``onComplete``, ...) and instead you should use the ``pipe`` pattern to pipe the result back +to the Actor as a message: -.. includecode:: ../../code/docs/http/javadsl/HttpClientExampleDocTest.java#single-request-example \ No newline at end of file +.. includecode:: ../../code/docs/http/javadsl/HttpClientExampleDocTest.java#single-request-in-actor-example diff --git a/akka-docs-dev/rst/scala/code/docs/http/scaladsl/HttpClientExampleSpec.scala b/akka-docs-dev/rst/scala/code/docs/http/scaladsl/HttpClientExampleSpec.scala index 5f0daec767..69075c8d5f 100644 --- a/akka-docs-dev/rst/scala/code/docs/http/scaladsl/HttpClientExampleSpec.scala +++ b/akka-docs-dev/rst/scala/code/docs/http/scaladsl/HttpClientExampleSpec.scala @@ -4,7 +4,8 @@ package docs.http.scaladsl -import akka.actor.ActorSystem +import akka.actor.{ ActorLogging, ActorSystem } +import akka.util.ByteString import org.scalatest.{ Matchers, WordSpec } class HttpClientExampleSpec extends WordSpec with Matchers { @@ -12,11 +13,12 @@ class HttpClientExampleSpec extends WordSpec with Matchers { "outgoing-connection-example" in { pending // compile-time only test //#outgoing-connection-example - import scala.concurrent.Future + import akka.http.scaladsl.Http + import akka.http.scaladsl.model._ import akka.stream.ActorMaterializer import akka.stream.scaladsl._ - import akka.http.scaladsl.model._ - import akka.http.scaladsl.Http + + import scala.concurrent.Future implicit val system = ActorSystem() implicit val materializer = ActorMaterializer() @@ -33,12 +35,13 @@ class HttpClientExampleSpec extends WordSpec with Matchers { "host-level-example" in { pending // compile-time only test //#host-level-example - import scala.concurrent.Future - import scala.util.Try + import akka.http.scaladsl.Http + import akka.http.scaladsl.model._ import akka.stream.ActorMaterializer import akka.stream.scaladsl._ - import akka.http.scaladsl.model._ - import akka.http.scaladsl.Http + + import scala.concurrent.Future + import scala.util.Try implicit val system = ActorSystem() implicit val materializer = ActorMaterializer() @@ -55,10 +58,11 @@ class HttpClientExampleSpec extends WordSpec with Matchers { "single-request-example" in { pending // compile-time only test //#single-request-example - import scala.concurrent.Future - import akka.stream.ActorMaterializer - import akka.http.scaladsl.model._ import akka.http.scaladsl.Http + import akka.http.scaladsl.model._ + import akka.stream.ActorMaterializer + + import scala.concurrent.Future implicit val system = ActorSystem() implicit val materializer = ActorMaterializer() @@ -68,4 +72,37 @@ class HttpClientExampleSpec extends WordSpec with Matchers { //#single-request-example } + "single-request-in-actor-example" in { + pending // compile-time only test + //#single-request-in-actor-example + import akka.actor.Actor + import akka.http.scaladsl.Http + import akka.http.scaladsl.model._ + import akka.stream.scaladsl.ImplicitMaterializer + + class Myself extends Actor + with ImplicitMaterializer + with ActorLogging { + + import akka.pattern.pipe + import context.dispatcher + + val http = Http(context.system) + + override def preStart() = { + http.singleRequest(HttpRequest(uri = "http://akka.io")) + .pipeTo(self) + } + + def receive = { + case HttpResponse(StatusCodes.OK, headers, entity, _) => + log.info("Got response, body: " + entity.dataBytes.runFold(ByteString(""))(_ ++ _)) + case HttpResponse(code, _, _, _) => + log.info("Request failed, response code: " + code) + } + + } + //#single-request-in-actor-example + } + } diff --git a/akka-docs-dev/rst/scala/http/client-side/request-level.rst b/akka-docs-dev/rst/scala/http/client-side/request-level.rst index c862b6fc82..b262b0b660 100644 --- a/akka-docs-dev/rst/scala/http/client-side/request-level.rst +++ b/akka-docs-dev/rst/scala/http/client-side/request-level.rst @@ -44,6 +44,18 @@ request's effective URI. Just like in the case of the super-pool flow described above the request must have either an absolute URI or a valid ``Host`` header, otherwise the returned future will be completed with an error. +Using the Future-Based API in Actors +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +When using the ``Future`` based API from inside an ``Actor``, all the usual caveats apply to how one should deal +with the futures completion. For example you should not access the Actors state from within the Future's callbacks +(such as ``map``, ``onComplete``, ...) and instead you should use the ``pipeTo`` pattern to pipe the result back +to the Actor as a message. + +.. includecode:: ../../code/docs/http/scaladsl/HttpClientExampleSpec.scala + :include: single-request-in-actor-example + +An ``ActorMaterializer`` instance needed for Http to perfom its duties can be obtained using the ``ImplicitMaterializer`` +helper trait. Example -------