Introduction

I had some time due to the corona turmoil, so I touched Rails' Action Cable.

I looked up the basic usage in the Rails guide, but it didn't come out very well, so I drew a diagram to understand it. In particular [Chapter on Terms](https://railsguides.jp/action_cable_overview.html#%E7%94%A8%E8%AA%9E%E3%81%AB%E3%81%A4%E3%81%84 Even after reading% E3% 81% A6), I didn't understand the relationship between each term, so I've organized it myself.

About terms

Connection, Consumer

WebSocket basics

Communication standard for realizing two-way communication between client and server on the Web
ʻUpgrade: Start with HTTP request with websocket` header
When HTTP status 101 (Switching Protocols) is returned as a response, you can use TCP connection and communicate as WebSocket.
Data that can be sent is text or binary
Since it is a different protocol from HTTP, cookies etc. are not sent
After communication is established, it is possible to send a message from either the client or the server.

Connection

A class that represents a connection as a WebSocket
(Probably) Instanced when communication is established as WebSocket
Since the initial request is normal HTTP, a cookie is also sent
So you can use cookies in connection.rb
Authentication process is described in this class

Consumer

WebSocket connection client (browser, etc.)
Unlike HTTP, different tabs in the same browser are treated as completely different clients

How to distinguish Consumer

Unlike HTTP, authentication information is not sent every time, so it is necessary to manage "who this connection belongs to" on the server side when establishing a connection.

Action Cable uses the Connection class ʻidentified_by` as a mechanism for this.

# app/channels/application_cable/connection.rb
module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user
 
    def connect
      self.current_user = User.find_by(id: cookies.encrypted[:user_id])
    end
 
  end
end

Channel, Subscription

Channel

Literally channel
Something like Controller

Subscription

Channel subscription
You can create as many as you want in one connection
Consumers are also called subscribers in the sense that they are subscribing to a channel.

A new Subscription object is created with consumer.subscriptions.create and added to consumer.subscriptions as shown below.

`chat_channel.js`


import consumer from "./consumer"
consumer.subscriptions.create("ChatChannel", {
  //Abbreviation
});

Stream

Used when broadcasting
Channel associates subscription with stream
If you broadcast to a stream, a message will be sent to the subscription associated with that stream.

Example

For example, if you define the following channel class, it will be linked to the stream chat_001 when you subscribe to ChatChannel.

`chat_channel.rb`


class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_001"
  end
end

When the following code is executed in this state, the JSON string {" text ":" Hello, World! "} Is sent to the subscriber.

`broadcast`


data = {text: "Hello, World!"}
ActionCable.server.broadcast("chat_001", data)

The broadcast itself to the stream can be done from anywhere in your Rails application.

Multiple Streams

In the example in the previous section, it was a fixed string, so every subscription was tied to the same stream. However, since parameters can be passed to the server side when subscribing to a channel, it is possible to link to different streams for each user or each open page.

Summary

ActionCable-まとめ.png

I didn't really understand the relationship between streams and subscriptions, so I focused on that. In this figure, the stream seems to be indispensable, so I will organize it from the viewpoint of executing the server side method by the action parameter and write it in a separate article.

[RUBY] Draw and understand Action Cable