Http Websocket as Akka Stream Source

Question

I'd like to listen on a websocket using akka streams. That is, I'd like to treat it as nothing but a Source.

However, all official examples treat the websocket connection as a Flow.

My current approach is using the websocketClientFlow in combination with a Source.maybe. This eventually results in the upstream failing due to a TcpIdleTimeoutException, when there are no new Messages being sent down the stream.

Therefore, my question is twofold:

Is there a way – which I obviously missed – to treat a websocket as just a Source?
If using the Flow is the only option, how does one handle the TcpIdleTimeoutException properly? The exception can not be handled by providing a stream supervision strategy. Restarting the source by using a RestartSource doesn't help either, because the source is not the problem.

Update

So I tried two different approaches, setting the idle timeout to 1 second for convenience

application.conf

akka.http.client.idle-timeout = 1s

Using keepAlive (as suggested by Stefano)

Source.<Message>maybe()
    .keepAlive(Duration.apply(1, "second"), () -> (Message) TextMessage.create("keepalive"))
    .viaMat(Http.get(system).webSocketClientFlow(WebSocketRequest.create(websocketUri)), Keep.right())
    { ... }

When doing this, the Upstream still fails with a TcpIdleTimeoutException.

Using RestartFlow

However, I found out about this approach, using a RestartFlow:

final Flow<Message, Message, NotUsed> restartWebsocketFlow = RestartFlow.withBackoff(
    Duration.apply(3, TimeUnit.SECONDS),
    Duration.apply(30, TimeUnit.SECONDS),
    0.2,
    () -> createWebsocketFlow(system, websocketUri)
);

Source.<Message>maybe()
    .viaMat(restartWebsocketFlow, Keep.right()) // One can treat this part of the resulting graph as a `Source<Message, NotUsed>`
    { ... }

(...)

private Flow<Message, Message, CompletionStage<WebSocketUpgradeResponse>> createWebsocketFlow(final ActorSystem system, final String websocketUri) {
    return Http.get(system).webSocketClientFlow(WebSocketRequest.create(websocketUri));
}

This works in that I can treat the websocket as a Source (although artifically, as explained by Stefano) and keep the tcp connection alive by restarting the websocketClientFlow whenever an Exception occurs.

This doesn't feel like the optimal solution though.

Stefano Bonetti · Accepted Answer · 2018-01-09T20:25:17.290

5

No. WebSocket is a bidirectional channel, and Akka-HTTP therefore models it as a Flow. If in your specific case you care only about one side of the channel, it's up to you to form a Flow with a "muted" side, by using either Flow.fromSinkAndSource(Sink.ignore, mySource) or Flow.fromSinkAndSource(mySink, Source.maybe), depending on the case.
as per the documentation:

Inactive WebSocket connections will be dropped according to the idle-timeout settings. In case you need to keep inactive connections alive, you can either tweak your idle-timeout or inject ‘keep-alive’ messages regularly.

There is an ad-hoc combinator to inject keep-alive messages, see the example below and this Akka cookbook recipe. NB: this should happen on the client side.

src.keepAlive(1.second, () => TextMessage.Strict("ping"))

edited Jan 09 '18 at 20:25

answered Jan 08 '18 at 18:23

Stefano Bonetti

8,973
1
25
44

Your answer to #1 makes perfect sense. I did pretty much what u suggested, but without understanding websockets properly. On #2: I came up with using a `RestartFlow` to reset the websocket connection in case of an exception. I tried keepalives before that, but the messages were just sent downstream... Which didn't do any good. So how does this work then? Does one have to send keepalives from the source *through* the websocket flow? – Rea Sand Jan 08 '18 at 22:37
As in e.g.: `Source[Message].maybe.keepAlive(...).viaMat(websocketClientFlow)...`? (will post an example asap if that helps) – Rea Sand Jan 08 '18 at 22:41
sorry if I didn't clarify before, the `keepAlive` injection should happen on the client side. The clients should be responsible for keeping their connection alive, whilst the server should employ idle-timeouts to avoid connection thrashing in case clients disappear. I have edited my answer. – Stefano Bonetti Jan 09 '18 at 20:28

score 0 · Answer 2 · answered Jan 08 '18 at 18:02

0

I hope I understand your question correctly. Are you looking for asSourceOf?

path("measurements") {
  entity(asSourceOf[Measurement]) { measurements =>
    // measurement has type Source[Measurement, NotUsed]
    ...
  }
}

answered Jan 08 '18 at 18:02

Sebastian

16,813
4
49
56

Nope. I was looking for a "listen-only" websocket `Source`, client side. – Rea Sand Jan 08 '18 at 22:37

Http Websocket as Akka Stream Source

Update

Using keepAlive (as suggested by Stefano)

Using RestartFlow

2 Answers2