Rails5 中引入的可以实现实时通讯的新功能,ActionCable,可以说是这个版本的 Rails 的重大特性之一,ActionCable 底层究竟是如何进行通讯,本文就来聊一聊这些相关的技术。
简单的说,websocket 是一个基于 TCP 的应用层协议,使用 http 协议建立连接,并且能够通过一个已经建立的连接,进行双向的通讯,也就是不仅仅能够从客户端发送信息到服务器端,服务端还可以推送信息到客户端,而且这一切的是建立在一个连接中进行的,有了它我们就不需要再使用,polling 或 long polling 做轮询信息了。
它的通讯过程是,通过向 http 头添加特定信息,然后发送到服务器,如果服务器能够支持 websocket 的话,就会识别出 http 头中关于 websocket 的信息,并且升级 http 连接为 websocket 连接并返回,一个同样包含 websocket 头信息的 http response,这样下来,客户端和服务器的连接就已经建立了,直到一方关闭连接。
请求:
GET /cable HTTP/1.1
Host: example.com:3000
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
应答:
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
上面的请求和应答头中 upgrade: websocket代表着这是一个 websocket 的连接请求,Sec-WebSocket-Key 和 Sec-WebSocket-Accept,是用于确认服务器是否真的,能够出来 websocket 请求的验证方式,过程是,服务器端介绍到 websocket-key 后,通过组合magic string,之后再进行 SHA-1 和 base64 编码,然后以 Sec-WebSocket-Accept 返回给客户端,客户端接受到后验证正确,这就表明服务器真正的可以处理 websocket 请求了。
ActionCable 本身可以作为一个单独的服务,绑定到单独的端口上运行,也可以与 rails 一起在同一个端口上一起启动运行,这是因为它实际上是一个处理 websocket 的 rack app。
单独启动的 ActionCable Server,先加载 Rails 环境,然后再运行的 rack app。
# cable/config.ru
require ::File.expand_path('../../config/environment', __FILE__)
Rails.application.eager_load!
run ActionCable.server
与 Rails 一同启动的时候,是通过挂载 ActionCable.server 到指定的 PATH 上。
# actioncable/lib/action_cable/engine.rb
initializer "action_cable.routes" do
config.after_initialize do |app|
config = app.config
unless config.action_cable.mount_path.nil?
app.routes.prepend do
mount ActionCable.server => config.action_cable.mount_path, internal: true
end
end
end
end
不管是,单独端口启动的 ActionCable,或是与 Rails 一同启动的。它们实际都是用 rack up 作为统一入口的。
# actioncable/lib/action_cable/connection/base.rb
# Called by Rack to setup the server.
def call(env)
setup_heartbeat_timer
config.connection_class.call.new(self, env).process
end
call 方法中第一是,每个三秒发送一个心跳包到客户端,已确定连接是否还可用,第二行就是初始化 action-cable 自己的连接类,执行响应。
# actioncable/lib/action_cable/connection/base.rb
def process #:nodoc:
logger.info started_request_message
if websocket.possible? && allow_request_origin?
respond_to_successful_request
else
respond_to_invalid_request
end
end
首先输出日志表示请求已经接受,然后判断请求是否为 websocket,并且判断 HTTP_ORIGIN 是否允许。
# actioncable/lib/action_cable/connection/base.rb
def respond_to_successful_request
logger.info successful_request_message # 输出日志:成功升级连接为 Websocket
websocket.rack_response # 调用 websocket对象,返回websocket响应。
end
走到这一步,服务器端的连接已经确认是可以继续 websocket 通讯了,但是与客户端的握手还没有完成,还需要发送一个,验证服务器端接受并有能力处理 websocket 的信息给客户端。
可以从下面看出来,action-cable 使用了Websocket-driver 这个 Gem 来完成 websocket 的通讯工作。
# actioncable/lib/action_cable/connection/web_socket.rb
require 'websocket/driver'
module ActionCable
module Connection
# Wrap the real socket to minimize the externally-presented API
class WebSocket
def initialize(env, event_target, event_loop, client_socket_class, protocols: ActionCable::INTERNAL[:protocols])
@websocket = ::WebSocket::Driver.websocket?(env) ? client_socket_class.new(env, event_target, event_loop, protocols) : nil
end
def possible?
websocket
end
def alive?
websocket && websocket.alive?
end
def transmit(data)
websocket.transmit data
end
def close
websocket.close
end
def protocol
websocket.protocol
end
def rack_response
websocket.rack_response
end
protected
attr_reader :websocket
end
end
end
# actioncable/lib/action_cable/connection/client_socket.rb
module ActionCable
module Connection
class ClientSocket
def initialize(env, event_target, event_loop, protocols)
············
@driver = ::WebSocket::Driver.rack(self, protocols: protocols)
@driver.on(:open) { |e| open }
@driver.on(:message) { |e| receive_message(e.data) }
@driver.on(:close) { |e| begin_close(e.reason, e.code) }
@driver.on(:error) { |e| emit_error(e.message) }
············
end
end
end
end
那么接下来就不得不讲一讲,websocket-driver 这个 Gem 了。
简单的说,websocket-driver 是一个利用,EventMachine,来读写 socket-io 对象的驱动器。使用了它的 API 就可以很轻松的实现 websocket-server。
websocket-driver 提供了一个基于 rack 的接口,action-cable 就是使用这个接口进行通讯的。下面的代码通过一个 socket 代理对象,初始化一个 driver,然后再向客户端发送一段信息。这里最重要的地方就是,被传入的 socket 代理对象,它必须能够响应三个方法,env,url,和write,分别是告诉 driver 向哪个 URL,如何发送信息。这里的 env 返回的就是 rack app 的 env 变量,webscoket-driver 实际上就是利用 Rack hijacking API 来实现获取 socket-io 对象进行读写的,所以 action-cable 基于 websocket-driver 就代表着像 webrick 这类不支持 full hijacking API 的应用程序服务器,也不能支持 action-cable。
driver = WebSocket::Driver.rack(socket, options)
driver.text "I'm websocket server"
使用 rack hijacking API
require 'websocket/driver'
require 'eventmachine'
class WS
attr_reader :env, :url
def initialize(env)
@env = env
secure = Rack::Request.new(env).ssl?
scheme = secure ? 'wss:' : 'ws:'
@url = scheme + '//' + env['HTTP_HOST'] + env['REQUEST_URI']
@driver = WebSocket::Driver.rack(self)
env['rack.hijack'].call
@io = env['rack.hijack_io']
EM.attach(@io, Reader) { |conn| conn.driver = @driver }
@driver.start
end
def write(string)
@io.write(string)
end
module Reader
attr_writer :driver
def receive_data(string)
@driver.parse(string)
end
end
end
Rack hijacking API 是在 Rack 1.5 中引入的,hijack 即为劫持,听起来好想是挺危险的样子,不过其实只是名字而已,它实际上是通过支持 Rack 的应用程序服务器上,拦截下 client 端的请求和 server 的相应的 Rack 的 hijacking API 提供了两种模式:
接下来我们就通过 full hijacking 来写一个能够同时处理 HTTP 请求和 websocket 请求的 rack app 下面的代码通过env['rack.hijack'].call来运行 full hijack,再使用env['rack.hijack_io']返回 socket 对象,然后我们就可以通过这个 socket 对象进行通信了。
#encoding: utf-8
require 'thread'
def websocket(env)
env['rack.hijack'].call
io = env['rack.hijack_io']
begin
start = 'HTTP/1.1 101 Switching Protocols'
headers = [start, 'Upgrade: websocket', 'Connection: Upgrade', '']
io.write headers.join("\r\n")
io.write("\r\n")
10.times do |i|
io.write("Line #{i + 1}!\n")
io.flush
sleep 1
end
ensure
io.close
end
end
def http(env)
['200', {'Content-Type' => 'text/html'}, ['Normal HTTP']]
end
app = lambda do |env|
if env['REQUEST_URI'] == '/cable' && env['HTTP_UPGRADE'] == 'websocket'
websocket env
else
http env
end
end
run app
上面的 Rack app 使用了两个方法分别处理,HTTP 和 websocket 请求,其中 webscoket 处理绑定在 '/cable'这个 URI 上。websocket 方法接受一个 rack env 变量,进行 websocket 处理,首先是运行 full hijack,然后再通过 socket 对象返回 websocket response header,这样就与客户端建立了 websocket 连接,并在连接上每个 1 秒发送一个消息,共 10 个。
这个例子中的 websocket 方法是不严谨的仅作为参考。首先是判断请求是否是 websocket 请求,再一个是 reponse header 中缺少对 websocket-key 进行加密,然后返回的 WebSocket-Accept。
使用 Puma 运行
$ puma app.ru
Puma starting in single mode...
* Version 3.4.0 (ruby 2.3.0-p0), codename: Owl Bowl Brawl
* Min threads: 0, max threads: 16
* Environment: development
* Listening on tcp://0.0.0.0:9292
首先发送一个常规的 HTTP 请求
$ curl -X GET -i -H "Cache-Control: no-cache" "http://localhost:9292"
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 11
Normal HTTP%
接下来在发送一个 websocket 请求:
通过 socket 对象连续发送 10 行数据后,关闭连接。
ActionCable 最底层是一个利用 rack hijacking 和 EventMachine 的 Rack App,通过不断地使用 websocket-driver 和自身的抽象封装,在上层提供了一个非常好用的方法,与 rails server 也可以无缝的结合在一起。