'}),b.prototype=a.extend({},a.fn.tooltip.Constructor.prototype),b.prototype.constructor=b,b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle(),c=this.getContent();a.find(".popover-title")[this.options.html?"html":"text"](b),a.find(".popover-content")[this.options.html?"string"==typeof c?"html":"append":"text"](c),a.removeClass("fade top bottom left right in"),a.find(".popover-title").html()||a.find(".popover-title").hide()},b.prototype.hasContent=function(){return this.getTitle()||this.getContent()},b.prototype.getContent=function(){var a=this.$element,b=this.options;return a.attr("data-content")||("function"==typeof b.content?b.content.call(a[0]):b.content)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")},b.prototype.tip=function(){return this.$tip||(this.$tip=a(this.options.template)),this.$tip};var c=a.fn.popover;a.fn.popover=function(c){return this.each(function(){var d=a(this),e=d.data("bs.popover"),f="object"==typeof c&&c;(e||"destroy"!=c)&&(e||d.data("bs.popover",e=new b(this,f)),"string"==typeof c&&e[c]())})},a.fn.popover.Constructor=b,a.fn.popover.noConflict=function(){return a.fn.popover=c,this}}(jQuery),+function(a){"use strict";function b(c,d){var e,f=a.proxy(this.process,this);this.$element=a(a(c).is("body")?window:c),this.$body=a("body"),this.$scrollElement=this.$element.on("scroll.bs.scroll-spy.data-api",f),this.options=a.extend({},b.DEFAULTS,d),this.selector=(this.options.target||(e=a(c).attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"")||"")+" .nav li > a",this.offsets=a([]),this.targets=a([]),this.activeTarget=null,this.refresh(),this.process()}b.DEFAULTS={offset:10},b.prototype.refresh=function(){var b=this.$element[0]==window?"offset":"position";this.offsets=a([]),this.targets=a([]);{var c=this;this.$body.find(this.selector).map(function(){var d=a(this),e=d.data("target")||d.attr("href"),f=/^#./.test(e)&&a(e);return f&&f.length&&f.is(":visible")&&[[f[b]().top+(!a.isWindow(c.$scrollElement.get(0))&&c.$scrollElement.scrollTop()),e]]||null}).sort(function(a,b){return a[0]-b[0]}).each(function(){c.offsets.push(this[0]),c.targets.push(this[1])})}},b.prototype.process=function(){var a,b=this.$scrollElement.scrollTop()+this.options.offset,c=this.$scrollElement[0].scrollHeight||this.$body[0].scrollHeight,d=c-this.$scrollElement.height(),e=this.offsets,f=this.targets,g=this.activeTarget;if(b>=d)return g!=(a=f.last()[0])&&this.activate(a);if(g&&b<=e[0])return g!=(a=f[0])&&this.activate(a);for(a=e.length;a--;)g!=f[a]&&b>=e[a]&&(!e[a+1]||b<=e[a+1])&&this.activate(f[a])},b.prototype.activate=function(b){this.activeTarget=b,a(this.selector).parentsUntil(this.options.target,".active").removeClass("active");var c=this.selector+'[data-target="'+b+'"],'+this.selector+'[href="'+b+'"]',d=a(c).parents("li").addClass("active");d.parent(".dropdown-menu").length&&(d=d.closest("li.dropdown").addClass("active")),d.trigger("activate.bs.scrollspy")};var c=a.fn.scrollspy;a.fn.scrollspy=function(c){return this.each(function(){var d=a(this),e=d.data("bs.scrollspy"),f="object"==typeof c&&c;e||d.data("bs.scrollspy",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.scrollspy.Constructor=b,a.fn.scrollspy.noConflict=function(){return a.fn.scrollspy=c,this},a(window).on("load",function(){a('[data-spy="scroll"]').each(function(){var b=a(this);b.scrollspy(b.data())})})}(jQuery),+function(a){"use strict";var b=function(b){this.element=a(b)};b.prototype.show=function(){var b=this.element,c=b.closest("ul:not(.dropdown-menu)"),d=b.data("target");if(d||(d=b.attr("href"),d=d&&d.replace(/.*(?=#[^\s]*$)/,"")),!b.parent("li").hasClass("active")){var e=c.find(".active:last a")[0],f=a.Event("show.bs.tab",{relatedTarget:e});if(b.trigger(f),!f.isDefaultPrevented()){var g=a(d);this.activate(b.parent("li"),c),this.activate(g,g.parent(),function(){b.trigger({type:"shown.bs.tab",relatedTarget:e})})}}},b.prototype.activate=function(b,c,d){function e(){f.removeClass("active").find("> .dropdown-menu > .active").removeClass("active"),b.addClass("active"),g?(b[0].offsetWidth,b.addClass("in")):b.removeClass("fade"),b.parent(".dropdown-menu")&&b.closest("li.dropdown").addClass("active"),d&&d()}var f=c.find("> .active"),g=d&&a.support.transition&&f.hasClass("fade");g?f.one(a.support.transition.end,e).emulateTransitionEnd(150):e(),f.removeClass("in")};var c=a.fn.tab;a.fn.tab=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tab");e||d.data("bs.tab",e=new b(this)),"string"==typeof c&&e[c]()})},a.fn.tab.Constructor=b,a.fn.tab.noConflict=function(){return a.fn.tab=c,this},a(document).on("click.bs.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"]',function(b){b.preventDefault(),a(this).tab("show")})}(jQuery),+function(a){"use strict";var b=function(c,d){this.options=a.extend({},b.DEFAULTS,d),this.$window=a(window).on("scroll.bs.affix.data-api",a.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",a.proxy(this.checkPositionWithEventLoop,this)),this.$element=a(c),this.affixed=this.unpin=this.pinnedOffset=null,this.checkPosition()};b.RESET="affix affix-top affix-bottom",b.DEFAULTS={offset:0},b.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(b.RESET).addClass("affix");var a=this.$window.scrollTop(),c=this.$element.offset();return this.pinnedOffset=c.top-a},b.prototype.checkPositionWithEventLoop=function(){setTimeout(a.proxy(this.checkPosition,this),1)},b.prototype.checkPosition=function(){if(this.$element.is(":visible")){var c=a(document).height(),d=this.$window.scrollTop(),e=this.$element.offset(),f=this.options.offset,g=f.top,h=f.bottom;"top"==this.affixed&&(e.top+=d),"object"!=typeof f&&(h=g=f),"function"==typeof g&&(g=f.top(this.$element)),"function"==typeof h&&(h=f.bottom(this.$element));var i=null!=this.unpin&&d+this.unpin<=e.top?!1:null!=h&&e.top+this.$element.height()>=c-h?"bottom":null!=g&&g>=d?"top":!1;if(this.affixed!==i){this.unpin&&this.$element.css("top","");var j="affix"+(i?"-"+i:""),k=a.Event(j+".bs.affix");this.$element.trigger(k),k.isDefaultPrevented()||(this.affixed=i,this.unpin="bottom"==i?this.getPinnedOffset():null,this.$element.removeClass(b.RESET).addClass(j).trigger(a.Event(j.replace("affix","affixed"))),"bottom"==i&&this.$element.offset({top:c-h-this.$element.height()}))}}};var c=a.fn.affix;a.fn.affix=function(c){return this.each(function(){var d=a(this),e=d.data("bs.affix"),f="object"==typeof c&&c;e||d.data("bs.affix",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.affix.Constructor=b,a.fn.affix.noConflict=function(){return a.fn.affix=c,this},a(window).on("load",function(){a('[data-spy="affix"]').each(function(){var b=a(this),c=b.data();c.offset=c.offset||{},c.offsetBottom&&(c.offset.bottom=c.offsetBottom),c.offsetTop&&(c.offset.top=c.offsetTop),b.affix(c)})})}(jQuery);
--------------------------------------------------------------------------------
/src/main/resources/js/main.js:
--------------------------------------------------------------------------------
1 | var tweetHtml =
2 | ' \
3 | \
4 | \
5 | Now \
6 | \
7 |
\
8 | ';
9 |
10 | $(document).ready(function() {
11 | var user = getUrlParameter('user');
12 | var latestTweetsPath = (user && '/users/' + user) || "/all" ;
13 |
14 | if (user) {
15 | $.ajax({
16 | url: "http://localhost:8080/resources/tweets" + latestTweetsPath
17 | }).then(function (tweets) {
18 | tweets.reverse().forEach(function(tweet) {
19 | appendTweet(tweet);
20 | });
21 | });
22 | }
23 |
24 | $("#post-tweet").submit(function(event) {
25 | var json = {
26 | user: { name: $("#user").val() },
27 | text: $("#tweet").val()
28 | };
29 |
30 | $.ajax({
31 | url: 'http://localhost:8080/resources/tweets',
32 | method: 'POST',
33 | contentType: "application/json",
34 | data: JSON.stringify(json)
35 | });
36 | $("#post-tweet")[0].reset();
37 | event.preventDefault();
38 | });
39 |
40 | var socket = getWebsocket();
41 |
42 | socket.onmessage = function (msg) {
43 | var tweet = JSON.parse(msg.data);
44 | appendTweet(tweet);
45 | }
46 | });
47 |
48 | function appendTweet(tweet) {
49 | $("#tweets li:first-child").after(tweetHtml.replace("__USERNAME__", tweet.user.name).replace("__TWEET__", tweet.text));
50 | }
51 |
52 | function getWebsocket() {
53 | var path = "ws://localhost:8080/ws/tweets/";
54 |
55 | if (getUrlParameter('user')) {
56 | path += "users/" + getUrlParameter('user');
57 | } else if (getUrlParameter('hashtag')) {
58 | path += "hashtag/" + getUrlParameter('hashtag');
59 | } else {
60 | path += "all";
61 | }
62 |
63 | return new WebSocket(path);
64 | }
65 |
66 | function getUrlParameter(sParam) {
67 | var sPageURL = window.location.search.substring(1);
68 | var sURLVariables = sPageURL.split('&');
69 | for (var i = 0; i < sURLVariables.length; i++)
70 | {
71 | var sParameterName = sURLVariables[i].split('=');
72 | if (sParameterName[0] == sParam)
73 | {
74 | return sParameterName[1];
75 | }
76 | }
77 | }
--------------------------------------------------------------------------------
/src/main/scala/reactive/Main.scala:
--------------------------------------------------------------------------------
1 | package reactive
2 |
3 | import akka.actor.ActorSystem
4 | import akka.http.scaladsl.Http
5 | import akka.http.scaladsl.marshalling.ToResponseMarshallable.apply
6 | import akka.http.scaladsl.model.StatusCodes
7 | import akka.http.scaladsl.server.Directive.{addByNameNullaryApply, addDirectiveApply}
8 | import akka.http.scaladsl.server.Directives._
9 | import akka.http.scaladsl.server.PathMatcher.segmentStringToPathMatcher
10 | import akka.http.scaladsl.server.PathMatchers.Segment
11 | import akka.http.scaladsl.server.Route
12 | import akka.http.scaladsl.server.RouteResult.route2HandlerFlow
13 | import akka.pattern.ask
14 | import akka.stream.ActorMaterializer
15 | import akka.util.Timeout
16 | import reactive.tweets.domain.{Tweet, User}
17 | import reactive.tweets.incoming.TweetActor.{GetLastTen, LastTenResponse}
18 | import reactive.tweets.incoming.TweetActorManager
19 | import reactive.tweets.outgoing.TweetFlow
20 |
21 | import scala.concurrent.ExecutionContext
22 | import scala.concurrent.duration.DurationInt
23 |
24 | object Main extends App with TweetFlow {
25 | implicit val system = ActorSystem("webapi")
26 | implicit val executor = system.dispatcher
27 | implicit val timeout = Timeout(1000.millis)
28 |
29 | implicit val materializer = ActorMaterializer()
30 | val serverBinding = Http().bindAndHandle(interface = "0.0.0.0", port = 8080, handler = mainFlow)
31 |
32 | def mainFlow(implicit system: ActorSystem, timeout: Timeout, executor: ExecutionContext): Route = {
33 | val tweetActorManager = system.actorOf(TweetActorManager.props)
34 |
35 | def getLatestTweetsOfUser = (pathPrefix("users") & path(Segment)) { userName =>
36 | complete {
37 | (tweetActorManager ? GetLastTen(User(userName)))
38 | .mapTo[LastTenResponse]
39 | .map(_.lastTen)
40 | }
41 | }
42 |
43 | def tweetsOfUserSocket = (pathPrefix("users") & path(Segment)) { userName =>
44 | handleWebsocketMessages(tweetFlowOfUser(userName))
45 | }
46 |
47 | def allTweetsSocket = path("all") {
48 | handleWebsocketMessages(tweetFlowOfAll)
49 | }
50 |
51 | // TODO Add implementation (Part 2 of tutorial)
52 | def tweetsWithHashTagSocket = ???
53 |
54 | def addTweet = {
55 | post {
56 | entity(as[Tweet]) { tweet =>
57 | complete {
58 | (tweetActorManager ? tweet).map(_ => StatusCodes.NoContent)
59 | }
60 | }
61 | }
62 | }
63 |
64 | // Frontend
65 | def index = (path("") | pathPrefix("index.htm")) {
66 | getFromResource("index.html")
67 | }
68 | def css = (pathPrefix("css") & path(Segment)) { resource => getFromResource(s"css/$resource") }
69 | def fonts = (pathPrefix("fonts") & path(Segment)) { resource => getFromResource(s"fonts/$resource") }
70 | def img = (pathPrefix("img") & path(Segment)) { resource => getFromResource(s"img/$resource") }
71 | def js = (pathPrefix("js") & path(Segment)) { resource => getFromResource(s"js/$resource") }
72 |
73 | get {
74 | index ~ css ~ fonts ~ img ~ js
75 | } ~
76 | // REST endpoints
77 | pathPrefix("resources") {
78 | pathPrefix("tweets") {
79 | get {
80 | getLatestTweetsOfUser
81 | } ~
82 | addTweet
83 | }
84 | } ~
85 | // Websocket endpoints
86 | pathPrefix("ws") {
87 | pathPrefix("tweets") {
88 | get {
89 | allTweetsSocket ~
90 | tweetsOfUserSocket
91 | // TODO Call hash tag functionality from here (Part 2 of tutorial)
92 | }
93 | }
94 | }
95 | }
96 |
97 | }
98 |
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/domain/Domain.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.domain
2 |
3 | case class Tweet(user: User, text: String)
4 |
5 | case class User(name: String)
6 |
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/incoming/TweetActor.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.incoming
2 |
3 | import akka.actor.{Props, Status, actorRef2Scala}
4 | import akka.persistence.{PersistentActor, SnapshotOffer}
5 | import reactive.tweets.domain.{Tweet, User}
6 | import reactive.tweets.incoming.TweetActor.{GetLastTen, LastTenResponse}
7 | import akka.persistence.SaveSnapshotSuccess
8 |
9 | object TweetActor {
10 | def props(user: User): Props = Props(new TweetActor(user))
11 |
12 | case class GetLastTen(user: User)
13 | case class LastTenResponse(lastTen: List[Tweet])
14 | }
15 |
16 | class TweetActor(val user: User) extends PersistentActor {
17 | override def persistenceId = user.name
18 | var latestTweets = List.empty[Tweet]
19 |
20 | override def receiveCommand = {
21 | case tweet: Tweet =>
22 | persist(tweet) { event =>
23 | sender ! Status.Success
24 | context.system.eventStream.publish(tweet)
25 | addToLatest(tweet)
26 | }
27 |
28 | case GetLastTen(_) =>
29 | sender ! LastTenResponse(latestTweets.take(10))
30 |
31 | case _: SaveSnapshotSuccess => // Ignore
32 |
33 | case msg =>
34 | throw new UnsupportedOperationException(s"received unexpected message $msg from ${sender}")
35 | }
36 |
37 | override def receiveRecover = {
38 | case tweet: Tweet =>
39 | addToLatest(tweet)
40 | case SnapshotOffer(_, latest: List[Tweet] @unchecked) =>
41 | latestTweets = latest
42 | case _ =>
43 | }
44 |
45 | private def addToLatest(tweet: Tweet) {
46 | latestTweets = tweet :: latestTweets
47 |
48 | if (latestTweets.length > 100) {
49 | latestTweets = latestTweets.take(10)
50 | saveSnapshot(latestTweets)
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/incoming/TweetActorManager.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.incoming
2 |
3 | import akka.actor.{ Actor, Props }
4 | import reactive.tweets.domain.{ Tweet, User }
5 | import reactive.tweets.incoming.TweetActor.GetLastTen
6 |
7 | class TweetActorManager extends Actor {
8 |
9 | override def receive = {
10 | case tweet: Tweet => forward(tweet, tweet.user.name)
11 |
12 | case lastTen: GetLastTen => forward(lastTen, lastTen.user.name)
13 |
14 | case msg => throw new UnsupportedOperationException(s"received unexpected message $msg from ${sender}")
15 | }
16 |
17 | def forward(message: Any, userName: String) = {
18 | def createTweetActor = context.actorOf(TweetActor.props(User(userName)), userName)
19 | val tweetPublisherActor = context.child(userName).getOrElse(createTweetActor)
20 | tweetPublisherActor forward message
21 | }
22 | }
23 |
24 | object TweetActorManager {
25 | def props: Props = Props[TweetActorManager]
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/marshalling/TweetJsonProtocol.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.marshalling
2 |
3 | import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
4 | import akka.http.scaladsl.marshalling._
5 | import akka.http.scaladsl.model.ws.{Message, TextMessage}
6 | import akka.http.scaladsl.unmarshalling._
7 | import akka.stream.Materializer
8 | import reactive.tweets.domain.{Tweet, User}
9 | import spray.json._
10 |
11 | trait TweetJsonProtocol extends DefaultJsonProtocol {
12 | implicit val userFormat = jsonFormat1(User.apply)
13 | implicit val tweetFormat = jsonFormat2(Tweet.apply)
14 |
15 | implicit val tweetMarshaller: ToEntityMarshaller[Tweet] = SprayJsonSupport.sprayJsonMarshaller[Tweet]
16 | implicit val tweetListMarshaller: ToEntityMarshaller[List[Tweet]] = SprayJsonSupport.sprayJsonMarshaller[List[Tweet]]
17 | implicit def tweetUnmarshaller(implicit materializer: Materializer): FromEntityUnmarshaller[Tweet] =
18 | SprayJsonSupport.sprayJsonUnmarshaller[Tweet]
19 |
20 | def toMessage(tweet: Tweet): Message = TextMessage.Strict(tweet.toJson.compactPrint)
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/outgoing/TweetFlow.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.outgoing
2 |
3 | import akka.actor.ActorRef
4 | import akka.http.scaladsl.model.ws.Message
5 | import akka.stream.scaladsl._
6 | import reactive.tweets.domain.Tweet
7 | import reactive.tweets.marshalling.TweetJsonProtocol
8 |
9 | trait TweetFlow extends TweetJsonProtocol {
10 | private val tweetSource: Source[Tweet, ActorRef] = Source.actorPublisher[Tweet](TweetPublisher.props)
11 | type TweetFilter = Tweet => Boolean
12 |
13 | private def tweetFlow(tweetFilter: TweetFilter): Flow[Message, Message, Unit] =
14 | Flow.wrap(Sink.ignore, tweetSource filter tweetFilter map toMessage)(Keep.none)
15 |
16 | def tweetFlowOfUser(userName: String) = tweetFlow(_.user.name.equalsIgnoreCase(userName))
17 |
18 | def tweetFlowOfAll = tweetFlow(_ => true)
19 |
20 | def tweetFlowWithHashTag(hashTag: String): Flow[Message, Message, Unit] = ???
21 | }
--------------------------------------------------------------------------------
/src/main/scala/reactive/tweets/outgoing/TweetPublisher.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.outgoing
2 |
3 | import akka.actor._
4 | import akka.stream.actor.ActorPublisher
5 | import reactive.tweets.domain.Tweet
6 |
7 | class TweetPublisher extends ActorPublisher[Tweet] {
8 |
9 | override def preStart = {
10 | context.system.eventStream.subscribe(self, classOf[Tweet])
11 | }
12 |
13 | override def receive = {
14 | case tweet: Tweet =>
15 | //We do not send tweets if a client is not reading from the stream fast enough.
16 | if (isActive && totalDemand > 0)
17 | onNext(tweet)
18 | }
19 |
20 | }
21 |
22 | object TweetPublisher {
23 | def props: Props = Props(new TweetPublisher())
24 | }
25 |
26 |
--------------------------------------------------------------------------------
/src/test/resources/application.conf:
--------------------------------------------------------------------------------
1 | akka{
2 | log-dead-letters = off
3 | log-dead-letters-during-shutdown = off
4 |
5 | persistence{
6 |
7 | journal{
8 | plugin = "akka.persistence.journal.inmem"
9 | }
10 |
11 | snapshot-store{
12 | plugin = "in-memory-snapshot-store"
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/src/test/scala/reactive/ActorTestUtils.scala:
--------------------------------------------------------------------------------
1 | package reactive
2 |
3 | import scala.reflect.ClassTag
4 |
5 | import org.scalatest.BeforeAndAfterAll
6 | import org.scalatest.FlatSpecLike
7 | import org.scalatest.Matchers
8 |
9 | import akka.actor.ActorSystem
10 | import akka.actor.Status
11 | import akka.testkit.DefaultTimeout
12 | import akka.testkit.ImplicitSender
13 | import akka.testkit.TestKit
14 |
15 | class ActorTestUtils extends TestKit(ActorTestUtils.actorSystem())
16 | with DefaultTimeout with ImplicitSender
17 | with FlatSpecLike with Matchers with BeforeAndAfterAll {
18 |
19 | override protected def afterAll = shutdown()
20 |
21 | def expectFailure[A <: Exception: ClassTag] = {
22 | expectMsgPF() {
23 | case Status.Failure(e: A) => true
24 | }
25 | }
26 | }
27 |
28 | object ActorTestUtils {
29 | def actorSystem() = ActorSystem("TestKitActorSystem")
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/scala/reactive/MainRoutingSpec.scala:
--------------------------------------------------------------------------------
1 | package reactive
2 |
3 | import akka.http.scaladsl.model.StatusCodes.{ NoContent, OK, SwitchingProtocols }
4 | import akka.http.scaladsl.model.headers.{ CustomHeader, Upgrade, UpgradeProtocol }
5 | import akka.http.scaladsl.model.ContentTypes.`application/json`
6 | import akka.http.scaladsl.model.ws.{ Message, UpgradeToWebsocket }
7 | import akka.http.scaladsl.model.{ HttpRequest, HttpResponse, StatusCodes }
8 | import akka.http.scaladsl.testkit.ScalatestRouteTest
9 | import akka.stream.Materializer
10 | import akka.stream.scaladsl.Flow
11 | import akka.util.Timeout
12 | import org.scalatest.{ FlatSpec, Matchers }
13 | import reactive.tweets.domain.{ Tweet, User }
14 | import reactive.tweets.marshalling.TweetJsonProtocol
15 |
16 | import scala.concurrent.duration.DurationInt
17 |
18 | class MainRoutingSpec extends FlatSpec with Matchers with ScalatestRouteTest with TweetJsonProtocol {
19 | implicit val timeout = Timeout(1000.millis)
20 |
21 | "Main" should "serve the index page on /" in {
22 | Get("/") ~> Main.mainFlow ~> check {
23 | status shouldBe OK
24 | }
25 | }
26 |
27 | it should "allow to post a tweet for a user" in {
28 | Post("/resources/tweets", Tweet(User("test"), "Some tweet")) ~> Main.mainFlow ~> check {
29 | status shouldBe NoContent
30 | }
31 | }
32 |
33 | it should "serve tweets of a user on /resources/tweets/users/test" in {
34 | Get("/resources/tweets/users/test") ~> Main.mainFlow ~> check {
35 | status shouldBe OK
36 | contentType shouldBe `application/json`
37 | entityAs[String] should include regex ("Some tweet")
38 | }
39 | }
40 |
41 | it should "handle websocket requests for tweets" in {
42 | Get("/ws/tweets/all") ~> Upgrade(List(UpgradeProtocol("websocket"))) ~> emulateHttpCore ~> Main.mainFlow ~> check {
43 | status shouldEqual SwitchingProtocols
44 | }
45 | }
46 |
47 | it should "handle websocket requests for users" in {
48 | Get("/ws/tweets/users/test") ~> Upgrade(List(UpgradeProtocol("websocket"))) ~> emulateHttpCore ~> Main.mainFlow ~> check {
49 | status shouldEqual SwitchingProtocols
50 | }
51 | }
52 |
53 | /**
54 | * TODO Make this test succeed (Part 2 of tutorial)
55 | */
56 | it should "handle websocket requests for hash tags" in {
57 | Get("/ws/tweets/hashtag/test") ~> Upgrade(List(UpgradeProtocol("websocket"))) ~> emulateHttpCore ~> Main.mainFlow ~> check {
58 | status shouldEqual SwitchingProtocols
59 | }
60 | }
61 |
62 | /** Only checks for upgrade header and then adds UpgradeToWebsocket mock header */
63 | private def emulateHttpCore(req: HttpRequest): HttpRequest =
64 | req.header[Upgrade] match {
65 | case Some(upgrade) if upgrade.hasWebsocket => req.copy(headers = req.headers :+ upgradeToWebsocketHeaderMock)
66 | case _ => req
67 | }
68 |
69 | private def upgradeToWebsocketHeaderMock: UpgradeToWebsocket =
70 | new CustomHeader() with UpgradeToWebsocket {
71 | override def requestedProtocols = Nil
72 | override def name = "dummy"
73 | override def value = "dummy"
74 |
75 | override def handleMessages(handlerFlow: Flow[Message, Message, Any], subprotocol: Option[String]): HttpResponse =
76 | HttpResponse(SwitchingProtocols)
77 | }
78 | }
--------------------------------------------------------------------------------
/src/test/scala/reactive/tweets/incoming/TweetActorSpec.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.incoming
2 |
3 | import akka.actor.Status
4 | import reactive.ActorTestUtils
5 | import reactive.tweets.domain.{ Tweet, User }
6 | import scala.concurrent.duration.DurationInt
7 | import reactive.tweets.incoming.TweetActor.GetLastTen
8 | import reactive.tweets.incoming.TweetActor.LastTenResponse
9 |
10 | class TweetActorSpec extends ActorTestUtils {
11 |
12 | def tweetActorManager = system.actorOf(TweetActorManager.props)
13 |
14 | val tweet = Tweet(User("test"), "Hello World!")
15 | val tweetLatest = Tweet(User("test"), "Hello World! again")
16 |
17 | "The actor manager" should "forward the tweet to the persistent actor" in {
18 | within(500.millis) {
19 | tweetActorManager ! tweet
20 | expectMsg(Status.Success)
21 | expectNoMsg()
22 | }
23 | }
24 |
25 | "The persistent actor" should "broadcast a successfully saved tweet" in {
26 | within(500.millis) {
27 | system.eventStream.subscribe(testActor, classOf[Tweet])
28 |
29 | tweetActorManager ! tweet
30 | expectMsg(Status.Success)
31 | expectMsg(tweet)
32 | expectNoMsg()
33 |
34 | system.eventStream.unsubscribe(testActor)
35 | }
36 | }
37 |
38 | it should "save the latest tweets" in {
39 | within(500.millis) {
40 |
41 | tweetActorManager ! tweetLatest
42 | expectMsg(Status.Success)
43 | tweetActorManager ! GetLastTen(tweet.user)
44 |
45 | expectMsg(LastTenResponse(List(tweetLatest, tweet, tweet)))
46 | }
47 | }
48 |
49 | it should "save only the latest ten tweets" in {
50 | within(500.millis) {
51 |
52 | for (i <- 1 to 100) yield {
53 | tweetActorManager ! tweetLatest
54 | expectMsg(Status.Success)
55 | }
56 |
57 | tweetActorManager ! GetLastTen(tweet.user)
58 |
59 | expectMsg(LastTenResponse((1 to 10).map(_ => tweetLatest).toList))
60 | }
61 | }
62 |
63 | it should "recover with the latest messages" in {
64 | within(500.millis) {
65 |
66 | val user = system.actorOf(TweetActor.props(tweet.user))
67 | system.stop(user)
68 | tweetActorManager ! GetLastTen(tweet.user)
69 |
70 | expectMsg(LastTenResponse((1 to 10).map(_ => tweetLatest).toList))
71 | }
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/src/test/scala/reactive/tweets/outgoing/TweetFlowSpec.scala:
--------------------------------------------------------------------------------
1 | package reactive.tweets.outgoing
2 |
3 | import akka.http.scaladsl.model.ws.{Message, TextMessage}
4 | import akka.stream.ActorMaterializer
5 | import akka.stream.testkit.scaladsl.{TestSink, TestSource}
6 | import reactive.ActorTestUtils
7 | import reactive.tweets.domain.{Tweet, User}
8 |
9 | import scala.concurrent.duration.DurationInt
10 |
11 | class TweetFlowSpec extends ActorTestUtils with TweetFlow {
12 | implicit val materializer = ActorMaterializer()
13 | private val noMessageTimeout = 100.millis
14 |
15 | "The flow for tweets" should "ignore incoming messages" in {
16 | val sut = tweetFlowOfAll.runWith(TestSource.probe[Message], TestSink.probe[Message])
17 | val (mockSource, mockSink) = sut
18 |
19 | mockSource.sendNext(TextMessage.Strict("Should be ignored"))
20 |
21 | mockSink.request(1)
22 | mockSink.expectNoMsg(noMessageTimeout)
23 | }
24 |
25 | it should "forward all tweets published to the event stream" in {
26 | val sut = tweetFlowOfAll.runWith(TestSource.probe[Message], TestSink.probe[Message])
27 | val (_, mockSink) = sut
28 |
29 | val tweet = Tweet(User("test"), "Hello World!")
30 | system.eventStream.publish(tweet)
31 |
32 | mockSink.request(1)
33 | mockSink.expectNext()
34 | mockSink.expectNoMsg(noMessageTimeout)
35 | }
36 |
37 | "The flow for tweets with user" should "only forward tweets with matching user name" in {
38 | val userName = "test"
39 | val sut = tweetFlowOfUser(userName).runWith(TestSource.probe[Message], TestSink.probe[Message])
40 | val (_, mockSink) = sut
41 |
42 | val tweet = Tweet(User(userName), s"Hello World!")
43 | system.eventStream.publish(tweet)
44 |
45 | mockSink.request(1)
46 | mockSink.expectNext()
47 | mockSink.expectNoMsg(noMessageTimeout)
48 | }
49 |
50 | it should " not forward tweets form users with a different name" in {
51 | val sut = tweetFlowOfUser("different").runWith(TestSource.probe[Message], TestSink.probe[Message])
52 | val (_, mockSink) = sut
53 |
54 | val tweet = Tweet(User("test"), "Hello World!")
55 | system.eventStream.publish(tweet)
56 |
57 | mockSink.request(1)
58 | mockSink.expectNoMsg(noMessageTimeout)
59 | }
60 |
61 | /**
62 | * TODO Make this test succeed (Part 2 of tutorial)
63 | */
64 | "The flow for tweets with hash tag" should "only forward tweets with matching hash tag" in {
65 | val hashTag = "shouldMatch"
66 | val sut = tweetFlowWithHashTag(hashTag).runWith(TestSource.probe[Message], TestSink.probe[Message])
67 | val (_, mockSink) = sut
68 |
69 | val tweet = Tweet(User("test"), s"Hello World! #${hashTag}")
70 | system.eventStream.publish(tweet)
71 |
72 | mockSink.request(1)
73 | mockSink.expectNext()
74 | mockSink.expectNoMsg(noMessageTimeout)
75 | }
76 |
77 | it should "not forward tweets without matching hash tag" in {
78 | val sut = tweetFlowWithHashTag("shouldNotMatch").runWith(TestSource.probe[Message], TestSink.probe[Message])
79 | val (_, mockSink) = sut
80 |
81 | val tweet = Tweet(User("test"), "Hello World! #otherhashtag")
82 | system.eventStream.publish(tweet)
83 |
84 | mockSink.request(1)
85 | mockSink.expectNoMsg(noMessageTimeout)
86 | }
87 |
88 | }
89 |
--------------------------------------------------------------------------------
/tutorial/img/flow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/J-Technologies/akka-http-websocket-activator-template/4153b17c16df75656db406b8a44b1dc9fed4d522/tutorial/img/flow.png
--------------------------------------------------------------------------------
/tutorial/img/ordina-logo-big.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/J-Technologies/akka-http-websocket-activator-template/4153b17c16df75656db406b8a44b1dc9fed4d522/tutorial/img/ordina-logo-big.png
--------------------------------------------------------------------------------
/tutorial/img/ordina-logo-small.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/J-Technologies/akka-http-websocket-activator-template/4153b17c16df75656db406b8a44b1dc9fed4d522/tutorial/img/ordina-logo-small.png
--------------------------------------------------------------------------------
/tutorial/img/ready-set-go.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/J-Technologies/akka-http-websocket-activator-template/4153b17c16df75656db406b8a44b1dc9fed4d522/tutorial/img/ready-set-go.jpg
--------------------------------------------------------------------------------
/tutorial/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | Akka HTTP to Persistent Actor to Akka Stream to Websocket
4 |
5 |
6 |
7 |
Getting started with this template
8 |
9 |
10 | In this template you will learn some of the basics of
11 |
12 |
13 | - Akka Http
14 | - Akka Persistence
15 | - Reactive Streams
16 | - Websockets
17 |
18 |
19 |
20 |
21 | This template consists of two parts, a theoretical and a hands-on part.
22 | In the theoretical part you will learn about the techniques mentioned above by means of a fully working example.
23 | In the hands-on part you will test-drive your own flow.
24 | So don't mind the failing tests for now, you will fix them soon enough ;)
25 |
26 |
27 | Next: An Overview
28 |
29 |
32 |
Part 1: An Overview
33 |
34 |
35 | In this tutorial we will use a simple Twitter like application to demonstrate the different techniques. You can
36 | post a tweet as a user and monitor a reactive timeline that changes whenever a new tweet is posted. We
37 | simplified
38 | the functionality a bit to keep the focus on the essentials.
39 |
40 |
41 |
Posting tweets
42 |
43 |
44 | You can post tweets via a simple REST endpoint. A tweet consists of a username and the message. We use
45 | Akka Persistence to keep track of the tweets for each user and be able to recover the
46 | timeline for a user after a restart of the application. All incoming tweets are put on the event bus that comes
47 | with Akka, after they are persisted.
48 |
49 |
50 |
Streaming tweets via Websockets
51 |
52 |
53 | On the other side an actor is subscribed to the event bus. This means the actor will be notified every time a
54 | new tweet is put on the event bus. Since Akka implements the
56 | Reactive Streams SPI we can turn the actor into a Publisher which we can then turn into a
57 | Source so we can use it in an Akka Http Flow.
58 |
59 |
60 |
The same story but now in a nice diagram
61 |
62 |
The complete flow from posting a tweet to it being pushed on the websocket
63 |
64 | Next: Posting a Tweet
65 |
66 |
69 |
Part 1: Posting a Tweet
70 |
71 |
72 | We start in Main.scala which defines the
73 | routes. The route (in this case a REST endpoint) for posting a tweet is defined in the following method:
74 |
75 |
def addTweet = {
76 | post {
77 | entity(as[Tweet]) { tweet =>
78 | complete {
79 | (system.actorOf(TweetActorManager.props) ? tweet).map(_ => StatusCodes.NoContent)
80 | }
81 | }
82 | }
83 | }
84 |
85 | The interesting part resides within the
complete directive. There we create an actor (
TweetActorManager)
88 | and send it the tweet. For simplicity we ignore failure and transform a successful completion to an appropriate
89 | HTTP status code.
90 |
91 |
92 | Next: Using Akka Persistence
93 |
94 |
97 |
Part 1: Using Akka Persistence
98 |
99 |
Forwarding tweets to persistent actors
100 |
101 |
102 | All posted tweets end up at the TweetActorManager.
104 | This actor forwards the tweet to a persistent actor based on the user that posted the tweet. Because we
105 | want to keep track of the last tweets of a user we associate each user with a dedicated persistent actor.
106 | The job of the TweetActorManager
107 | is to ensure the tweets end up at the correct persistent actor.
108 |
109 |
110 |
Persisting and recovering tweets
111 |
112 |
113 | It is the job of the TweetActor
114 | to persist the tweet and put it on the event bus. It also knows how to recover the tweets for a user after a
115 | system failure.
116 |
117 |
case tweet: Tweet =>
118 | persist(tweet) { event =>
119 | sender() ! Status.Success
120 | context.system.eventStream.publish(tweet)
121 | }
122 |
123 | After successful storage the callback is triggered. We send out a
Success message and publish the tweet
124 | on the event bus.
125 |
126 |
127 | Next: Reactive Streams
128 |
129 |
132 |
Part 1: Reactive Streams
133 |
134 |
135 | If we want to stream the tweets via websockets to our users we need to get them from somewhere. That place is
136 | the
137 | event bus. However, we need to perform some transformations before Akka Http is able to use the
138 | bus as a source. The first step is hook up an actor to the event bus and expose that actor as a
139 | Publisher.
140 |
141 |
142 |
143 | The Reactive
144 | Streams Specification defines a Publisher as
145 |
146 |
147 |
a provider of a potentially unbounded number of sequenced elements, publishing them according to the
148 | demand received from its Subscriber(s).
149 |
150 |
151 | Akka implements the Reactive Streams SPI and fortunately the code to turn an actor into a Publisher is pretty
152 | straightforward:
153 | we just have to extend ActorPublisher which exposes (among others) the onNext which we
154 | can use to push a new tweet to our subscribers when one arrives. Only thing left is to subscribe to the event
155 | bus when the
156 | actor is started. The code can be found in TweetPublisher.scala
158 | and should look like this:
159 |
160 |
161 |
class TweetPublisher extends ActorPublisher[Tweet] {
162 |
163 | override def preStart = {
164 | context.system.eventStream.subscribe(self, classOf[Tweet])
165 | }
166 |
167 | override def receive = {
168 | case tweet: Tweet => onNext(tweet)
169 | //We do not send tweets if a client is not reading from the stream fast enough.
170 | if (isActive && totalDemand > 0)
171 | onNext(tweet)
172 | }
173 |
174 | }
175 |
176 |
177 | note: You should not call onNext if the stream is not active or there is no demand.
178 | Next: Running the Flow
179 |
180 |
182 |
Part 1: Running the Flow
183 |
184 |
185 | In the previous section we described how to define an actor as a Reactive Streams Publisher. To start streaming
186 | we still need to instantiate the actor and - in one go - transform it into a Source. This is done in TweetFlow.scala.
188 |
189 |
private val tweetSource: Source[Tweet, ActorRef] =
190 | Source.actorPublisher[Tweet](TweetPublisher.props)
191 |
192 | Now we've got our hands on a proper
Source we can use it to construct a
Flow:
193 |
194 |
def tweetFlow(tweetFilter: TweetFilter): Flow[Message, Message, Unit] =
195 | Flow.wrap(Sink.ignore, tweetSource filter tweetFilter map toMessage)(Keep.none)
196 |
197 | Note: ignore the tweetFilter for now, this is just a convenience parameter to be able to construct specific streams,
198 | like the stream of tweets for a specific user, or the stream of tweets that contain a specific hash tag.
199 |
200 |
201 |
202 | We are only interested in one way communication with our Websocket. We push new tweets to the client on their
203 | arrival. Theoretically we could also receive messages over the same channel from the client. We just ignore
204 | those.
205 | So what does this look like in terms of a Flow?
206 |
207 |
208 |
209 | +-----------------------------+
210 | | Our Websocket Flow |
211 | | |
212 | | +--------+ +------+ |
213 | | \ | | \ |
214 | In ~~> | SINK | | SOURCE |~~> Out
215 | | / | | / |
216 | | +--------+ +------+ |
217 | +-----------------------------+
218 |
219 |
220 |
221 | The important thing to note is that the inner parts of the Flow (the Sink and the Source) have no connection
222 | with each other. Incoming messages from the Websocket are ignored by routing them to the Ignore Sink
223 | while on the other hand the outgoing channel will be serviced by our transformed actor that is listening to the
224 | event bus:
225 |
226 |
Flow.wrap(Sink.ignore, tweetSource filter tweetFilter map toMessage)(Keep.none)
227 |
228 |
229 | Next: The Websocket
230 |
231 |
234 |
Part 1: The Websocket
235 |
236 |
237 | So we have a nice Flow, the next step is plugging it into Akka Http.
238 | The most notable part is the handleWebsocketMessages directive, which comes out of the box with Akka Http.
239 |
def tweetsOfUserSocket = (pathPrefix("users") & path(Segment)) { userName =>
240 | handleWebsocketMessages(tweetFlowOfUser(userName))
241 | }
242 |
243 | The part below describes the path at which the Websocket for this Flow can be found:
/ws/tweets/users/[userName].
244 |
245 |
pathPrefix("ws") {
246 | pathPrefix("tweets") {
247 | get {
248 | tweetsOfUserSocket
249 | }
250 | }
251 | }
252 | Now we have explained all the pieces you can
run the application and see everything in action.
253 |
254 |
255 | In the next part you will extend the application with a flow containing only tweets with a certain hash tag.
256 |
257 |
258 | Next: Building your own Flow
259 |
260 |
262 |
Part 2: Building your own Flow
263 |
Implementing a Websocket for tweets with a certain hash tag
264 |
265 | It's time to get your hands dirty. Tweets for a user are nice to have, but having a different channel to only follow
266 | tweets with a certain hash tag would be even nicer, don't you agree?
267 |
268 | In this second part we will create this feature step by step. Each step will have a failing test and an unimplemented
269 | method to help you on the way.
270 |
271 |
272 |
273 | Next: Creating a New Flow
274 |
275 |
277 |
Part 2: Creating a New Flow
278 |
279 |
280 | Before we can expose a stream of filtered tweets on hash tag to the outside world, we'll first need something to
281 | actually expose. This basically comes down to the fact that we need an extra flow, besides the flow for all tweets
282 | and the flow for tweets of a user. Let's start by looking at the failing tests in TweetFlowSpec.scala.
284 |
285 |
"The flow for tweets with hash tag" should "only forward tweets with matching hash tag" in {
286 | val hashTag = "shouldMatch"
287 | val sut = tweetFlowWithHashTag(hashTag).runWith(TestSource.probe[Message], TestSink.probe[Message])
288 | val (_, mockSink) = sut
289 |
290 | val tweet = Tweet(User("test"), s"Hello World! #${hashTag}")
291 | system.eventStream.publish(tweet)
292 |
293 | mockSink.request(1)
294 | mockSink.expectNext()
295 | mockSink.expectNoMsg(noMessageTimeout)
296 | }
297 |
298 | We mock out the Source and Sink to be able to control the input and output for a flow,
299 | which makes testing a lot easier. We expect, given a flow that filters on hash tag X and putting a tweet on the
300 | event bus with that same tag X, that we will actually receive that tweet in our mock sink. Because we only put
301 | one tweet on the bus, we expect no more message after our first request.
302 |
303 |
304 | There is another test to test the opposite scenario (putting a tweet on the bus with a non matching tag and
305 | expecting not to see it arrive), but we'll not discuss since it is analogous to the test described above. Open
306 | TweetFlow.scala and
307 | add an implementation on the spot marked with ???. Of course your implementation should satisfy both
308 | failing tests in TweetFlowSpec.scala.
310 |
311 |
312 | Next: The Solution for this challenge (spoiler alert!)
313 |
314 |
316 |
Part 2: Solution New Flow
317 |
Drumroll...
318 |
def tweetFlowWithHashTag(hashTag: String) = tweetFlow(_.text contains hashTag)
319 |
320 | Your method should look something like this. Yes, it was that easy. Sorry.
321 |
322 |
323 | Now we have a Flow we can expose it via a new Websocket route.
324 |
325 |
326 | Next: Hash Tag Websocket
327 |
328 |
330 |
Part 2: Hash Tag Websocket
331 |
Let's take a look at the failing test in MainRoutingSpec.scala first.
333 |
it should "handle websocket requests for hash tags" in {
334 | Get("/ws/tweets/hashtag/test") ~> Upgrade(List(UpgradeProtocol("websocket"))) ~> emulateHttpCore ~> Main.mainFlow ~> check {
335 | status shouldEqual SwitchingProtocols
336 | }
337 | }
338 |
339 |
340 | The test should make clear on which path it expects the stream to be exposed. You can implement the functionality in
341 | Main.scala. Look for the ???
342 | and comments with TODO.
343 |
344 |
345 | Next: The Solution for this challenge (spoiler alert!)
346 |
347 |
349 |
Part 2: Solution Websocket
350 |
def tweetsWithHashTagSocket = (pathPrefix("hashtag") & path(Segment)) { hashTag =>
351 | handleWebsocketMessages(tweetFlowWithHashTag(hashTag))
352 | }
353 |
354 |
We can then use this method in our main routing declaration:
355 |
// Websocket endpoints
356 | pathPrefix("ws") {
357 | pathPrefix("tweets") {
358 | get {
359 | allTweetsSocket ~
360 | tweetsOfUserSocket ~
361 | tweetsWithHashTagSocket
362 | }
363 | }
364 | }
365 |
366 |
367 | Et voilà! We just extended our application with a nice flow to monitor tweet streams for certain hash tags. And
368 | all that with only a few lines of extra code. Run the application and enjoy the fruits
369 | of your hard labour.
370 |
371 |
372 | Next: Time to wrap it all up
373 |
374 |
376 |
Conclusion
377 |
378 | In this Activator template we explored the following techniques:
379 |
380 |
381 | - Akka Http
382 | - Akka Persistence
383 | - Reactive Streams
384 | - Websockets
385 |
386 |
387 |
388 | We hope you enjoyed this tutorial. Feedback and suggestions are always appreciated.
389 | So if you want to get in touch
390 | contact us @ Github.
391 |
392 |
393 | Next: Not tired yet?
394 |
395 |
397 |
Further Explorations
398 |
399 | So, still not tired? Try implementing some (or all) of the following functionality:
400 |
401 |
402 | - Exposing a combined stream of tweets for a user with a certain hash tag
403 | - Distribute the application using Akka Cluster
404 | - Perform real time analytics with Spark
405 | - [Insert your own creative insight here]
406 |
407 |
408 |
409 |