Protocol switching successfully or not - scala

Question

I have the following code snippet, that does not compile:
import akka.actor.ActorSystem
import akka.Done
import akka.http.scaladsl.Http
import akka.stream.ActorMaterializer
import akka.stream.scaladsl._
import akka.http.scaladsl.model._
import akka.http.scaladsl.model.ws._
import scala.concurrent._
import scala.concurrent.duration._
object Main extends App {
implicit val system = ActorSystem()
implicit val materializer = ActorMaterializer()
import system.dispatcher
// Future[Done] is the materialized value of Sink.foreach,
// emitted when the stream completes
val incoming: Sink[Message, Future[Done]] =
Sink.foreach[Message] {
case message: TextMessage.Strict =>
println(message.text)
}
// flow to use (note: not re-usable!)
val sourceSocketFlow = RestartSource.withBackoff(
minBackoff = 3.seconds,
maxBackoff = 30.seconds,
randomFactor = 0.2,
maxRestarts = 3
) { () =>
Source.tick(2.seconds, 2.seconds, TextMessage("Hello world!!!"))
.viaMat(Http().webSocketClientFlow(WebSocketRequest("ws://127.0.0.1:8080/")))(Keep.right)
}
// the materialized value is a tuple with
// upgradeResponse is a Future[WebSocketUpgradeResponse] that
// completes or fails when the connection succeeds or fails
// and closed is a Future[Done] with the stream completion from the incoming sink
val (upgradeResponse, closed) =
sourceSocketFlow
.toMat(incoming)(Keep.both) // also keep the Future[Done]
.run()
// just like a regular http request we can access response status which is available via upgrade.response.status
// status code 101 (Switching Protocols) indicates that server support WebSockets
val connected = upgradeResponse.flatMap { upgrade =>
if (upgrade.response.status == StatusCodes.SwitchingProtocols) {
Future.successful(Done)
} else {
throw new RuntimeException(s"Connection failed: ${upgrade.response.status}")
}
}
connected.onComplete(println)
closed.foreach(_ => println("closed"))
}
The problem here is, that:
// the materialized value is a tuple with
// upgradeResponse is a Future[WebSocketUpgradeResponse] that
// completes or fails when the connection succeeds or fails
// and closed is a Future[Done] with the stream completion from the incoming sink
val (upgradeResponse, closed) =
sourceSocketFlow
.toMat(incoming)(Keep.both) // also keep the Future[Done]
.run()
does not return Future[WebSocketUpgradeResponse] at first position in the tuple but instead it returns NotUsed.
The question is, how to get the return type Future[WebSocketUpgradeResponse] to identify, that the connection was successfull.

Answer 1

RestartSource#withBackoff accepts a sourceFactory of a type () => Source[T, _] and returns a new source of a type Source[T, NotUsed]. So it's not possible to extract the materialized value from the wrapped source. That's probably because the materialized value will be different on every RestartSource restart.
The question is, how to get the return type Future[WebSocketUpgradeResponse] to identify, that the connection was successful.
If you want to check if the connection was established, and if WebSockets handshake succeeded, you can prematerialize the source using Source#preMaterialize. A slightly modified version of your code would look like the following:
val sourceSocketFlow: Source[Message, NotUsed] = RestartSource.withBackoff(
minBackoff = 3.seconds,
maxBackoff = 30.seconds,
randomFactor = 0.2,
maxRestarts = 3
) { () =>
val (response, source) = Source
.tick(2.seconds, 2.seconds, TextMessage("Hello world!!!"))
.viaMat(Http().webSocketClientFlow(WebSocketRequest("ws://mockbin.org/bin/82b160d4-6c05-4943-908a-a15122603e20")))(Keep.right).preMaterialize()
response.onComplete {
case Failure(e) ⇒
println(s"Connection failed")
case Success(value) ⇒
if (value.response.status == StatusCodes.SwitchingProtocols) {
println("Server supports websockets")
} else {
println("Server does not support websockets")
}
}
source
}
In case the connection fails, or websocket handshake fails, you don't have to do anything. Both cases will be handled by RestartSource.