Difference between broadcast , broadcast_to and broadcast_for in rails 5 - ruby-on-rails

From the Rails Guide I found following three code snippets
ActionCable.server.broadcast("chat_#{params[:room]}", data)
This simple broadcast sends the data to a specific chat room
while broadcast_to as shown below seems to send data to all chatrooms within a channel to which current user is subscribed .
WebNotificationsChannel.broadcast_to(
current_user,
title: 'New things!',
body: 'All the news fit to print'
)
Here is another type of broadcast broadcast_for - for which i couldn't get any example .
My question is what is actual difference between these three and when to use each of 'em - thanks in advance

broadcasting_for returns an object that can be reused. This is useful for sending multiple messages to the same room in different points in code / time. broadcast ends up calling broadcasting_for, so it's basically the same.
broadcast_to comes off the channel class. You use this after you've created a channel. Let's say you want to notify all the subscribers of blog post comments. Then your channel would look like the example:
class CommentsChannel < ApplicationCable::Channel
def subscribed
post = Post.find(params[:id])
stream_for post
end
end
# use CommentsChannel.broadcast_to(#post, #comment)
But if you wanted to send more directed messages to a particular user then you could have a class called EmailNotifications that only cares about a particular user.
class EmailNotificationsChannel < ApplicationCable::Channel
...
EmailNotificationsChannel.broadcast_to(
current_user,
title: 'You have mail!',
body: data[:email_preview] # some assumption of passed in or existing data hash here
)

Related

multiple users chat receiving on action-cable

I have created one project where I have one customer and another contractor. I implemented ruby on rails actioncable for chat. All it is going good but issue is coming when two different people chat with one person, that person is receiving both messages in socket window. I realised that I have setup conversation-#{user_id} as a channel, so user is listening on this channel now two people send chat to him, they both will come on same channel. How can I avoid this? or can I add another user in channel string, but I found it is very difficult. Any idea where I have to send params to subscribe method.
connection
module ApplicationCable
class Connection < ActionCable::Connection::Base
identified_by :current_user
def connect
self.current_user = find_session_user
end
def find_session_user
current_user = User.find_by(id: cookies.signed[:actioncable_user_id])
current_user || reject_unauthorized_connection
end
end
My conversation channel
class ConversationChannel < ApplicationCable::Channel
def subscribed
stream_from "conversations-#{current_user.id}"
end
def unsubscribed
stop_all_streams
end
def speak(data)
message_params = data["message"].each_with_object({}) do |el, hash|
hash[el.values.first] = el.values.last
end
end
ActionCable.server.broadcast(
"conversations-#{current_user.id}",
message: message_params,
)
end
This code is just condense version, but as it will start conversation-user_id as a channel, so definitely when it is connected and other people send message, this user will receive them in same socket. so I have to do like `conversation-user_id-anotehr_user. Right now it is working on web/mobile and all good, but when two user communicate with one user it create issue by displaying two users chat on one socket.
Any idea how can I create such channel.
I have solved this issue by binding chat with 2 persons and I have another requirement of job specific chats, so have bound it with it too. Now my conversation channel is like conversation-(talk_id)-(listern_id)-job_id so it all good now. Following are changes I did
1. I removed channel file from assets/javascript as it is automatically load on my application, but I want to bound it with few parameters so I added it to specific view. My controller has already few parameters so I have changed this javascript to following
<script>
App.conversation = App.cable.subscriptions.create({channel: "ConversationChannel",
job_id: <%= #job.id %>,
contractor: <%= #contractor %>
}, {
connected: function() {},
disconnected: function() {},
received: function(data) {
var conversation = $('#conversations-list').find("[data-conversation-id='" + data['conversation_id'] + "']");
conversation.find('.messages-list').find('ul').append(data['message']);
var messages_list = conversation.find('.messages-list');
var height = messages_list[0].scrollHeight;
messages_list.scrollTop(height);
},
speak: function(message) {
return this.perform('speak', {
message: message
});
}
});
Now when connection establish it sends both parameters and channel channel properly individual. On my conversation.rb I have just minor change
def subscribed
stream_from "conversations-#{current_user.id}-#{params[:contractor]}-#{params[:job_id]}"
end
Now everything working perfectly as per our requirements, each channel is being made with 2 users+job Id so I they can communicate on specific job and with specific users, so there no more other person can listen other conversation.
Just posting may help someone.

How to call ActionCable method from controller or model - "uninitialized constant QuizSession::App" Error

I'm trying to write a simple quiz app with Ruby on Rails with 2 users, who get to see different views:
the quiz hoster view shows the current question and a "next question"-button (which he is supposed to project onto a wall for the audience) and
the participant view shows the 4 buttons with answer options corresponding to the current question (so the audience can participate in the quiz from their smartphones).
I'm at the point, where I'm trying to use ActionCable to broadcast these 4 answer buttons to my channel, but when I try calling the method I defined in my channel I get the error "uninitialized constant QuizSession::App".
These are the steps I've taken to enable ActionCable:
1) I generated a new channel in /app/channels/quiz_data_channel.rb:
class QuizDataChannel < ApplicationCable::Channel
def subscribed
stream_from "quiz_data"
end
def unsubscribed
# Any cleanup needed when channel is unsubscribed
end
def send_data
Services::QuizDataCreation.new(user: current_user).create
end
end
# /app/assets/javascripts/channels/quiz_data.coffee:
App.quiz_data = App.cable.subscriptions.create "QuizDataChannel",
connected: ->
# Called when the subscription is ready for use on the server
disconnected: ->
# Called when the subscription has been terminated by the server
received: (data) ->
# Called when there's incoming data on the websocket for this channel
$('answer-buttons').append(data.partial)
send_data: ->
#perform 'send_data'
2) Then I made a new service in app/models/services/quiz_data_creation.rb:
module Services
class QuizDataCreation
def initialize(user)
self.user = user
end
def create
create_quiz_data
broadcast_creation
end
private
attr_accessor :user, :answers
def create_quiz_data #not sure if this will work
#quiz_session = user.quiz_session
self.answers = #quiz_session.quiz.questions[#quiz_session.current_question_index].answers
end
def broadcast_creation
QuizDataBroadcastJob.perform_now(answers)
end
end
end
3) Then I generated a new job at /app/jobs/quiz_data_broadcast_job.rb:
class QuizDataBroadcastJob < ApplicationJob
queue_as :default
def perform(answers)
ActionCable.server.broadcast('quiz_data', data: render_answer_options(answers))
end
private
def render_answer_options(answers)
answers.each do |answer|
ApplicationController.render(
#render student/quiz_question page and render as many answer_option partials as needed
partial: 'pages/student/answer_option',
locals: {answer: answer}
)
end
end
end
4) I mounted ActionCable in my routes.rb:
mount ActionCable.server => '/cable'
5) And finally I'm trying to broadcast data by calling the send_data function elsewhere in my application:
def send_current_question
App.quiz_data.send_data <--- this is apparently where the error gets thrown
end
What I would like to know is:
How do I solve this error?
Is the problem that I haven't established the socket connection correctly?
I have read 3 ActionCable guides and watched 2 guide videos - since most of them seem to be about chat applications (which in my mind is a 1 to 1 connection) I am now thoroughly confused as to how to get my app to work in the one-to-many broadcasting fashion I need.
I'm new to Rails, so any pointers would be appreciated! :)
WebSockets are designed such that it doesn't matter whether you are building a one-to-one, many-to-one, one-to-many or many-to-many feature. The reason is as a Publisher to a channel, you do not know who is Subscribed to it, so whether it is just 1 or 1000 users, they will all receive the message that is published.
As for why you are getting the error, well the App object is a JavaScript object (see how you are accessing it in your coffeescript files), so you cannot use it in Ruby code.
The App object is not made available in your Ruby code (backend) because it is supposed to be a method for the client (user) to communicate with the server (backend), which is why it is initialized in your coffeescript code.
So you will need to call the send_data method by attaching a click handler to your button. Let's say in your html your button looks like:
<button id="broadcast-button">Broadcast</button>
In your client side code (coffeescript), you would do the following:
$('#broadcast-button').on 'click', (e) ->
App.quiz_data.send_data()
So when the user clicks on that button, the send_data method will be called.
As for why you are getting the error, well the App object is a JavaScript object (see how you are accessing it in your coffeescript files), so you cannot use it in Ruby code.
The App object is not made available in your Ruby code (backend)
because it is supposed to be a method for the client (user) to
communicate with the server (backend), which is why it is initialized
in your coffeescript code.
As #Laith Azer pointed out, it is not possible to call a CoffeeScript method (since that represents the frontend) from a controller or model, but all my CoffeeScript method send_data really does, is call its counterpart on the backend:
#/app/assets/javascripts/channels/quiz_data.coffee:
App.quiz_data = App.cable.subscriptions.create "QuizDataChannel",
...
send_data: ->
#perform 'send_data'
So what is possible, is to call this backend method directly:
#In some controller or model:
QuizDataChannel.send_data(current_user)
For that to work we need to change the method in our ActionCable channel to a class method:
#/app/channels/quiz_data_channel.rb:
class QuizDataChannel < ApplicationCable::Channel
def self.send_data(current_user) #self. makes it a class method
new_quiz_html = Services::QuizDataCreation.new(user: current_user).create
#change "some_room" to the room name you want to send the page on
ActionCable.server.broadcast("some_room", html: new_quiz_html)
end
end
And all that is left is to receive this html page and display it:
#/app/assets/javascripts/channels/quiz_data.coffee:
App.quiz_data = App.cable.subscriptions.create "QuizDataChannel",
...
send_data: ->
#perform 'send_data'
received: (data) ->
# This will replace your body with the page html string:
$('body').html(data.html)

What's the "Rails Way"? ActionCable channel vs controller

In several tutorials (even one by David Heinemeier Hansson) you are encouraged to use a method inside the your x_channel.rb file to create a new message for instance.
It would look something like this (from David's tutorial):
class RoomChannel < ApplicationCable::Channel
def subscribed
stream_from "room_channel"
end
def unsubscribed
# Any cleanup needed when channel is unsubscribed
end
def speak
Message.create! content: data['message']
end
end
He then uses the messages_controller.rb only to set up a after_create_commit for broadcasting the message to all subscribers.
The speak method is called by JavaScript.
Now, I was thinking, why use the channel at all for that? I could also just get rid of the speak method and instead put a create method inside the messages_controller.rb with something like this:
def create
Message.create! content: data['message']
end
(obviously a little more sophisticated than that but for the sake of demonstration). In the views I would then use a plain old form and an AJAX request to call the create method.
Now, I'm wondering which of the two options would be the best or the "Rails Way" of handling this.
Is it "Once you use a channel do everything in there"? Or rather "continue using controllers as much as you can. That's what they were built for"?

Rails 5 ActionCable establish stream from URL parameters

I am almost completely new to Rails, or I am sure I would know how to answer this question myself. I am just trying to modify the basic chat app created in the basic ActionCable demo: https://medium.com/#dhh/rails-5-action-cable-demo-8bba4ccfc55e#.6lmd6tfi7
Instead of having just one chat room, I want to have multiple chat rooms, so I modified my routes.rb by adding this line:
get '/rooms/show/:topic', to: 'rooms#show'
So now I can visit different chat rooms based on different topics. The rooms controller at /app/controllers/rooms_controller.rb handles these routes with no problem:
class RoomsController < ApplicationController
def show
#topic = params[:topic]
#messages = Message.all
end
end
But this parameter is not being passed to app/channels/room_channel.rb, and I'm just not sure what modifications I need to make. My current attempt:
class RoomChannel < ApplicationCable::Channel
def subscribed
stream_from "room_channel_#{params[:topic]}"
end
only returns "room_channel_"
The problem here was that I failed to understand from where the subscribed method was being called, and thus did not know how to pass parameters to it.
By reading the actioncable documentation: https://github.com/rails/rails/tree/master/actioncable
I found out that the subscribed method is called via client-side javascript, not by the rails controller. In the case of the example chat app, this means I had to change the first line of the file /app/assets/javascripts/channels/room.coffee
App.room = App.cable.subscriptions.create "RoomChannel",
to
App.room = App.cable.subscriptions.create { channel: "RoomChannel", topic: topic},
Passing a javascript object to this method allowed me to access those parameters in the subscribed method of rooms_controller.rb.
Set the topic_id in a HTML tag, maybe in the body tag in your layout file.
<body data-topic-id="<%= #topic.id %>">
Now read it from JS like this:
document.querySelector('body').dataset.topicId
Your subscription creation line would look like this:
App.room = App.cable.subscriptions.create (channel: 'RoomChannel', topic_id: document.querySelector('body').dataset.topicId)

ActionCable - how to display number of connected users?

I'm trying to create a simple chat-like application (planning poker app) with Action Cable. I'm a little bit confused by the terminology, files hierarchy and how the callbacks work.
This is the action that creates user session:
class SessionsController < ApplicationController
def create
cookies.signed[:username] = params[:session][:username]
redirect_to votes_path
end
end
A user can then post a vote that should be broadcasted to everyone:
class VotesController < ApplicationController
def create
ActionCable.server.broadcast 'poker',
vote: params[:vote][:body],
username: cookies.signed[:username]
head :ok
end
end
Up to this point everything is clear for me and works fine. The problem is - how do I display the number of connected users? Is there a callback that fires in JS when a user (consumer?) connects? What I want is when I open 3 tabs in 3 different browsers in incognito mode I would like to display "3". When a new user connects, I would like the number to increment. If any user disconnects, the number should decrement.
My PokerChannel:
class PokerChannel < ApplicationCable::Channel
def subscribed
stream_from 'poker'
end
end
app/assets/javascripts/poker.coffee:
App.poker = App.cable.subscriptions.create 'PokerChannel',
received: (data) ->
$('#votes').append #renderMessage(data)
renderMessage: (data) ->
"<p><b>[#{data.username}]:</b> #{data.vote}</p>"
Seems that one way is to use
ActionCable.server.connections.length
(See caveats in the comments)
For a quick (and probably not ideal) solution you can write a module that tracks subscription counts (using Redis to store data):
#app/lib/subscriber_tracker.rb
module SubscriberTracker
#add a subscriber to a Chat rooms channel
def self.add_sub(room)
count = sub_count(room)
$redis.set(room, count + 1)
end
def self.remove_sub(room)
count = sub_count(room)
if count == 1
$redis.del(room)
else
$redis.set(room, count - 1)
end
end
def self.sub_count(room)
$redis.get(room).to_i
end
end
And update your subscribed and unsubscribed methods in the channel class:
class ChatRoomsChannel < ApplicationCable::Channel
def subscribed
SubscriberTracker.add_sub params['room_id']
end
def unsubscribed
SubscriberTracker.remove_sub params['chat_room_id']
end
end
In a related question on who is connected, there was an answer for those who uses redis:
Redis.new.pubsub("channels", "action_cable/*")
and if you just want number of connections:
Redis.new.pubsub("NUMPAT", "action_cable/*")
This will summarize connections from all your servers.
All the magic covered inside RemoteConnections class and InternalChannel module.
TL;DR all connections subscibed on special channels with a prefix action_cable/* with only purpose of disconnecting sockets from main rails app.
I think i found a answer for you.
Try this:
ActionCable.server.connections.select { |con| con.current_room == room }.length?
I can use it everywhere in my code and check amount of connected users to selected stream :)
in my connection.rb I have something like this:
module ApplicationCable
class Connection < ActionCable::Connection::Base
identified_by :current_room
def connect
self.current_room = find_room
end
private
def find_room
.....
end
end
end
Hope that helps anyone.
With
ActionCable.server.pubsub.send(:listener).instance_variable_get("#subscribers")
you can get map with subscription identifier in the key and array of procedures which will be executed on the broadcast. All procedures accept message as argument and have memoized connection.

Resources