New method for WebSocketBuilder taking Pipe[F, WebSocketFrame, WebSocketFrame]

[asoltysik]

What's your opinion about another build method that looks like this:

 def build(
        pipe: Pipe[F, WebSocketFrame, WebSocketFrame]
        headers: Headers = Headers.empty,
        onNonWebSocketRequest: F[Response[F]] =
          Response[F](Status.NotImplemented).withEntity("This is a WebSocket route.").pure[F],
        onHandshakeFailure: F[Response[F]] = Response[F](Status.BadRequest)
          .withEntity("WebSocket handshake failed.").pure[F])

Similarly how it's done in akka-http. I believe it is enough for many use cases of websockets, can simplify the code and it's easier to reason about for these use cases.

[rossabaker]

As an additional builder or as the only builder?

What does it mean? The input to the pipe are received frames and the output is sent frames?

[SystemFw]

From what I could get, it would be an additional builder, and yes, a Pipe from input to output

[SystemFw]

I'm actually thinking that a model based on a Pipe might be cleaner than what we have now, here's a small snippet discussing translating back and forth between the two:

case class Builder(pipe: Pipe[F, Frame, Frame])
case class Split(in: Sink[F, Frame], out: Stream[F, Frame])

def splitToBuilder(s: Split) = Builder(input =>  s.out.concurrently(input.to(s.in))

case class Builder(in: Sink[F, Frame], out: Stream[F, Frame])
case class Piped(pipe: Pipe[F, Frame, Frame])

def pipedToBuilder(p: Piped): F[Builder] = 
needs to create the queue, and also quite possibly wrap everything in Option to use `unNoneTerminate`, 
without it you get race conditions like the one in Chris example that requires `sleep`

[jmcardon]

p.s I am 👍 on this, in that reacting to messages is often what you want

[rossabaker]

This exists now.