Question

I’m building a project which uses EM and WebSockets and involves broadcasting data to subscribed clients.

I’m wondering why would one prefer subscribing a websocket to a channel, like the following:

EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws|

ws.onopen {
  sid = @channel.subscribe { |msg| ws.send msg }
  @channel.push "#{sid} connected!"

  ws.onmessage { |msg|
    @channel.push "<#{sid}>: #{msg}"
  }

  ws.onclose {
    @channel.unsubscribe(sid)
  }
}

end

Over adding each websocket to an array:

EM::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws|
ws.onopen {
  puts "Websocket connection opened"
  websocket_connections << ws
}
ws.onclose {
  puts "Websocket connection closed"
  websocket_connections.delete(ws)
}
end

and simply iterating over the entire array and make a similar ws.send msg call when appropriate (or the other way around).

Does the channel alternative has better optimisation for the entire non-blocking characteristics of EventMachine? (e.g. broadcast to some of the subscribed sockets in one time, and then continue with the others instead of sending all of them at once)

Answer 1

The EventMachine::Channel class is simply an abstraction that handles the iteration of a subscribers array. If you look at the Ruby source code for EventMachine::Channel#push, you see it is similar to what you propose:

def push(*items)
  items = items.dup
  EM.schedule { @subs.values.each { |s| items.each { |i| s.call i } } }
end

In fact, if you don’t need to duplicate your items array, it is actually slower than manually iterating the list. However, I doubt that the performance impact is significant. EventMachine::Channel is simply an abstraction that makes managing lists of clients easier.