anycable-rack-server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 416a34b5853c2b0f81f4693e59fe4c9b10021b41fc8eb2e710b8fd82b5a67c04
+  data.tar.gz: fcb0f8b569adc737b704025393237b573b7de616ea4e5deedaa77e442a51bc09
+SHA512:
+  metadata.gz: 7cd8bcd7b5afda208b3df2e476b0729faf9fbfbfd9d6fb36735f26cba48b9589e3a4704a9dbc69c6743bdf4f209c2ee9e6d44f8521a5fc89036a42859f0f9090
+  data.tar.gz: 68f4b98948bb3ec8fb330947faed0f933ee7dd12dab2f1ca6abbb35af41ab3f7b7f3ad720ea74be82af486f309b250c340603e8e10716478a03975704c3ba3f5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Yulia Oletskaya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# anycable-rack-server
+
+AnyCable-compatible Rack hijack based Ruby Web Socket server middleware designed for development and testing purposes.
+
+## Usage
+
+Mount the rack middleware
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  mount AnyCable::Rack.new => '/cable'
+end
+```
+
+## Settings
+
+Customizable options: headers being sent with each gRPC request. The gem uses AnyCable config for redis and gRPC host settings.
+
+Default headers: `'cookie', 'x-api-token'`.
+
+Can be specified via env variable
+```
+ANYCABLE_HEADERS=cookie,x-api-token,origin
+```
+
+Or
+
+```ruby
+options = { headers: ['cookie', 'origin'] }
+AnyCable::Rack.new(nil, options)
+```
+
+## Testing
+
+Run units with `rake`.
+
+Instructions for testing with [anyt](https://github.com/anycable/anyt) (anycable conformance testing) can be found [here](https://github.com/tuwukee/anycable-rack-server/tree/master/test/support).

data/lib/anycable-rack-server.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'anycable/rack-server'

data/lib/anycable/rack-server.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'json'
+require 'anycable'
+require 'websocket'
+require 'securerandom'
+require 'anycable/rack-server/hub'
+require 'anycable/rack-server/pinger'
+require 'anycable/rack-server/errors'
+require 'anycable/rack-server/middleware'
+require 'anycable/rack-server/broadcast_subscribers/redis_subscriber'
+require 'anycable/rack-server/coders/json'
+
+module AnyCable
+  module RackServer
+    DEFAULT_OPTIONS = {
+      headers:  ['cookie', 'x-api-token']
+    }.freeze
+
+    class << self
+      attr_reader :broadcast_subscriber,
+                  :coder,
+                  :hub,
+                  :middleware,
+                  :pinger,
+                  :server_id
+
+      def start(options = {})
+        options  = DEFAULT_OPTIONS.merge(options)
+        @hub     = Hub.new
+        @pinger  = Pinger.new
+        @coder   = Coders::JSON
+
+        rpc_host = unpack_host(AnyCable.config.rpc_host)
+        headers  = parse_env_headers || options[:headers]
+
+        @server_id = "anycable-rack-server-#{SecureRandom.hex}"
+        @middleware = Middleware.new(
+          nil,
+          pinger:    pinger,
+          hub:       hub,
+          coder:     coder,
+          rpc_host:  rpc_host,
+          headers:   headers,
+          server_id: server_id
+        )
+
+        broadcast_subscribe
+
+        @_started = true
+      end
+
+      def started?
+        @_started == true
+      end
+
+      def stop
+        return unless started?
+
+        @_started = false
+        broadcast_subscriber.unsubscribe(@_redis_channel)
+        pinger.stop
+
+        hub.sockets.each do |socket|
+          hub.remove_socket(socket)
+          socket.close
+        end
+      end
+
+      private
+
+      def broadcast_subscribe
+        @_redis_params  = AnyCable.config.to_redis_params
+        @_redis_channel = AnyCable.config.redis_channel
+
+        @broadcast_subscriber = BroadcastSubscribers::RedisSubscriber.new(
+          hub:     @hub,
+          coder:   @coder,
+          options: @_redis_params
+        )
+
+        @broadcast_subscriber.subscribe(@_redis_channel)
+      end
+
+      def parse_env_headers
+        headers = ENV['ANYCABLE_HEADERS'].to_s.split(',')
+        return nil if headers.empty?
+        headers
+      end
+
+      def unpack_host(str)
+        str.gsub('[::]', '0.0.0.0')
+      end
+    end
+  end
+
+  class Rack
+    def initialize(_app = nil, options = {})
+      AnyCable::RackServer.start(options)
+    end
+
+    def call(env)
+      AnyCable::RackServer.middleware.call(env)
+    end
+  end
+end

data/lib/anycable/rack-server/broadcast_subscribers/redis_subscriber.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+module AnyCable
+  module RackServer
+    module BroadcastSubscribers
+      class RedisSubscriber
+        attr_reader :hub, :coder, :redis_conn, :threads
+
+        def initialize(hub:, coder:, options:)
+          @hub        = hub
+          @coder      = coder
+          @redis_conn = ::Redis.new(options)
+          @threads    = {}
+        end
+
+        def subscribe(channel)
+          @threads[channel] = Thread.new do
+            redis_conn.subscribe(channel) do |on|
+              on.message { |_channel, msg|  handle_message(msg) }
+            end
+          end
+        end
+
+        def unsubscribe(channel)
+          @threads[channel].terminate unless @threads[channel].nil?
+          @threads.delete(channel)
+        end
+
+        private
+
+        def handle_message(msg)
+          data = JSON.parse(msg)
+          hub.broadcast(data['stream'], data['data'], coder)
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/coders/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    module Coders
+      module JSON
+        class << self
+          def decode(json_str)
+            ::JSON.parse(json_str)
+          end
+
+          def encode(ruby_obj)
+            ruby_obj.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/connection.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'anycable/rack-server/rpc/client'
+require 'anycable/rack-server/logging'
+require 'anycable/rack-server/errors'
+
+module AnyCable
+  # rubocop:disable Metrics/LineLength
+  module RackServer
+    class Connection
+      # rubocop:enable Metrics/LineLength
+      include Logging
+
+      attr_reader :coder,
+                  :header_names,
+                  :hub,
+                  :socket,
+                  :rpc_client,
+                  :server_id
+
+      def initialize(socket, hub, coder, host, header_names, server_id)
+        @socket       = socket
+        @coder        = coder
+        @hub          = hub
+        @header_names = header_names
+        @server_id    = server_id
+
+        @rpc_client = RPC::Client.new(host)
+
+        @_identifiers   = '{}'
+        @_subscriptions = Set.new
+      end
+
+      def handle_open
+        response = rpc_connect
+        process_open(response)
+      end
+
+      def handle_close
+        response = rpc_disconnect
+        process_close(response)
+        reset_connection
+      end
+
+      def handle_command(websocket_message)
+        decoded = decode(websocket_message)
+        command = decoded.delete('command')
+
+        channel_identifier = decoded['identifier']
+
+        case command
+        when 'subscribe'   then subscribe(channel_identifier)
+        when 'unsubscribe' then unsubscribe(channel_identifier)
+        when 'message'     then send_message(channel_identifier, decoded['data'])
+        else
+          raise Errors::UnknownCommand, "Command not found #{command}"
+        end
+      end
+
+      private
+
+      def transmit(cable_message)
+        socket.transmit(encode(cable_message))
+      end
+
+      def close
+        socket.close
+      end
+
+      def request
+        socket.request
+      end
+
+      def request_path
+        request.fullpath
+      end
+
+      def rpc_connect
+        rpc_client.connect(headers: headers, path: request_path)
+      end
+
+      def rpc_disconnect
+        rpc_client.disconnect(
+          identifiers: @_identifiers,
+          subscriptions: @_subscriptions.to_a,
+          headers: headers,
+          path: request_path
+        )
+      end
+
+      def rpc_command(command, identifier, data = '')
+        rpc_client.command(
+          command: command,
+          identifier: identifier,
+          connection_identifiers: @_identifiers,
+          data: data
+        )
+      end
+
+      def subscribe(identifier)
+        response = rpc_command('subscribe', identifier)
+        if response.status == :SUCCESS
+          @_subscriptions.add(identifier)
+        else
+          log(:debug, log_fmt("RPC subscribe command failed: #{response.inspect}"))
+        end
+        process_command(response, identifier)
+      end
+
+      def unsubscribe(identifier)
+        response = rpc_command('unsubscribe', identifier)
+        if response.status == :SUCCESS
+          @_subscriptions.delete(identifier)
+        else
+          log(:debug, log_fmt("RPC unsubscribe command failed: #{response.inspect}"))
+        end
+        process_command(response, identifier)
+      end
+
+      def send_message(identifier, data)
+        response = rpc_command('message', identifier, data)
+        unless response.status == :SUCCESS
+          log(:debug, log_fmt("RPC message command failed: #{response.inspect}"))
+        end
+        process_command(response, identifier)
+      end
+
+      def headers
+        @headers ||= begin
+          header_names.inject({}) do |acc, name|
+            header_val = request.env["HTTP_#{name.gsub(/-/,'_').upcase}"]
+            acc[name]  = header_val unless header_val.nil? || header_val.empty?
+            acc
+          end
+        end
+      end
+
+      def process_command(response, identifier)
+        response.transmissions.each { |transmission| transmit(decode(transmission)) }
+        hub.remove_channel(socket, identifier) if response.stop_streams
+        response.streams.each { |stream| hub.add_subscriber(stream, socket, identifier) }
+        close_connection if response.disconnect
+      end
+
+      def process_open(response)
+        if response.status == :SUCCESS
+          @_identifiers = response.identifiers
+          response.transmissions.each { |transmission| transmit(decode(transmission)) }
+          log(:debug) { log_fmt('Opened') }
+        else
+          log(:error, log_fmt("RPC connection command failed: #{response.inspect}"))
+          close_connection
+        end
+      end
+
+      def process_close(response)
+        if response.status == :SUCCESS
+          log(:debug) { log_fmt('Closed') }
+        else
+          log(:error, log_fmt("RPC disconnection command failed: #{response.inspect}"))
+        end
+      end
+
+      def reset_connection
+        @_identifiers = '{}'
+        @_subscriptions = []
+
+        hub.remove_socket(socket)
+      end
+
+      def close_connection
+        reset_connection
+        close
+      end
+
+      def encode(cable_message)
+        coder.encode(cable_message)
+      end
+
+      def decode(websocket_message)
+        coder.decode(websocket_message)
+      end
+
+      def log_fmt(msg)
+        "[connection:#{server_id}] #{msg}"
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    module Errors
+      class HijackNotAvailable < RuntimeError; end
+      class UnknownCommand < StandardError; end
+      class MiddlewareSetup < StandardError; end
+    end
+  end
+end

data/lib/anycable/rack-server/hub.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    # From https://github.com/rails/rails/blob/v5.0.1/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
+    class Hub
+      attr_reader :streams, :sockets
+
+      def initialize
+        @streams = Hash.new do |streams, stream_id|
+          streams[stream_id] = Hash.new { |channels, channel_id| channels[channel_id] = Set.new }
+        end
+        @sockets = Hash.new { |h, k| h[k] = Set.new }
+        @sync = Mutex.new
+      end
+
+      def add_subscriber(stream, socket, channel)
+        @sync.synchronize do
+          @streams[stream][channel] << socket
+          @sockets[socket] << [channel, stream]
+        end
+      end
+
+      def remove_subscriber(stream, socket, channel)
+        @sync.synchronize do
+          @streams[stream][channel].delete(socket)
+          @sockets[socket].delete([channel, stream])
+          cleanup stream, socket, channel
+        end
+      end
+
+      def remove_channel(socket, channel)
+        list = @sync.synchronize do
+          return unless @sockets.key?(socket)
+
+          @sockets[socket].dup
+        end
+
+        list.each do |(channel_id, stream)|
+          remove_subscriber(stream, socket, channel) if channel == channel_id
+        end
+      end
+
+      def remove_socket(socket)
+        list = @sync.synchronize do
+          return unless @sockets.key?(socket)
+
+          @sockets[socket].dup
+        end
+
+        list.each do |(channel_id, stream)|
+          remove_subscriber(stream, socket, channel_id)
+        end
+      end
+
+      def broadcast(stream, message, coder)
+        list = @sync.synchronize do
+          return unless @streams.key?(stream)
+
+          @streams[stream].to_a
+        end
+
+        list.each do |(channel_id, sockets)|
+          decoded = coder.decode(message)
+          cmessage = channel_message(channel_id, decoded, coder)
+          sockets.each { |socket| socket.transmit(cmessage) }
+        end
+      end
+
+      private
+
+      def cleanup(stream, socket, channel)
+        @streams[stream].delete(channel) if @streams[stream][channel].empty?
+        @streams.delete(stream) if @streams[stream].empty?
+        @sockets.delete(socket) if @sockets[socket].empty?
+      end
+
+      def channel_message(channel_id, message, coder)
+        coder.encode(identifier: channel_id, message: message)
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/logging.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    module Logging # :nodoc:
+      PREFIX = 'AnycableRackServer'
+
+      private
+
+      def log(level, message = nil, logger = AnyCable.logger)
+        logger.send(level, PREFIX) { message || yield }
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/middleware.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'anycable/rack-server/connection'
+require 'anycable/rack-server/errors'
+require 'anycable/rack-server/socket'
+
+module AnyCable
+  module RackServer
+    class Middleware
+      PROTOCOLS = ['actioncable-v1-json', 'actioncable-unsupported'].freeze
+      attr_reader :pinger,
+                  :hub,
+                  :coder,
+                  :rpc_host,
+                  :headers,
+                  :server_id
+
+      def initialize(_app, pinger:, hub:, coder:, rpc_host:, headers:, server_id:)
+        @pinger    = pinger
+        @hub       = hub
+        @coder     = coder
+        @rpc_host  = rpc_host
+        @headers   = headers
+        @server_id = server_id
+      end
+
+      def call(env)
+        return not_found unless websocket?(env)
+
+        rack_hijack(env)
+        listen_socket(env)
+
+        [-1, {}, []]
+      end
+
+      private
+
+      def handshake
+        @handshake ||= WebSocket::Handshake::Server.new(protocols: PROTOCOLS)
+      end
+
+      def rack_hijack(env)
+        raise Errors::HijackNotAvailable unless env['rack.hijack']
+
+        env['rack.hijack'].call
+        send_handshake(env)
+      end
+
+      def send_handshake(env)
+        handshake.from_rack(env)
+        env['rack.hijack_io'].write(handshake.to_s)
+      end
+
+      def listen_socket(env)
+        socket = Socket.new(env, env['rack.hijack_io'], handshake.version)
+        init_connection(socket)
+        init_pinger(socket)
+        socket.listen
+      end
+
+      def not_found
+        [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
+      end
+
+      def websocket?(env)
+        env['HTTP_UPGRADE'] == 'websocket'
+      end
+
+      def init_connection(socket)
+        connection = Connection.new(socket, hub, coder, rpc_host, headers, server_id)
+        socket.onopen { connection.handle_open }
+        socket.onclose { connection.handle_close }
+        socket.onmessage { |data| connection.handle_command(data) }
+      end
+
+      def init_pinger(socket)
+        pinger.add(socket)
+        socket.onclose { pinger.remove(socket) }
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/pinger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    # Sends pings to sockets
+    class Pinger
+      INTERVAL = 3
+
+      def initialize
+        @_sockets = []
+        @_stopped = false
+        run
+      end
+
+      def add(socket)
+        @_sockets << socket
+      end
+
+      def remove(socket)
+        @_sockets.delete(socket)
+      end
+
+      def stop
+        @_stopped = true
+      end
+
+      # rubocop: disable Metrics/MethodLength
+      def run
+        Thread.new do
+          loop do
+            break if @_stopped
+
+            unless @_sockets.empty?
+              msg = ping_message(Time.now.to_i)
+              @_sockets.each do |socket|
+                socket.transmit(msg)
+              end
+            end
+
+            sleep(INTERVAL)
+          end
+        end
+      end
+      # rubocop: enable Metrics/MethodLength
+
+      private
+
+      def ping_message(time)
+        { type: :ping, message: time }.to_json
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/rpc/client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'grpc'
+
+module AnyCable
+  module RackServer
+    module RPC
+      class Client
+        attr_reader :stub
+
+        def initialize(host)
+          @stub = AnyCable::RPC::Service.rpc_stub_class.new(host, :this_channel_is_insecure)
+        end
+
+        def connect(headers:, path:)
+          request = ConnectionRequest.new(headers: headers, path: path)
+          stub.connect(request)
+        end
+
+        def command(command:, identifier:, connection_identifiers:, data:)
+          message = CommandMessage.new(
+            command: command,
+            identifier: identifier,
+            connection_identifiers: connection_identifiers,
+            data: data
+          )
+          stub.command(message)
+        end
+
+        def disconnect(identifiers:, subscriptions:, headers:, path:)
+          request = DisconnectRequest.new(
+            identifiers: identifiers,
+            subscriptions: subscriptions,
+            headers: headers,
+            path: path
+          )
+          stub.disconnect(request)
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/rpc/rpc.proto

@@ -0,0 +1,55 @@
+syntax = "proto3";
+
+package anycable;
+
+service RPC {
+  rpc Connect (ConnectionRequest) returns (ConnectionResponse) {}
+  rpc Command (CommandMessage) returns (CommandResponse) {}
+  rpc Disconnect (DisconnectRequest) returns (DisconnectResponse) {}
+}
+
+enum Status {
+  ERROR = 0;
+  SUCCESS = 1;
+  FAILURE = 2;
+}
+
+message ConnectionRequest {
+  string path = 1;
+  map<string,string> headers = 2;
+}
+
+message ConnectionResponse {
+  Status status = 1;
+  string identifiers = 2;
+  repeated string transmissions = 3;
+  string error_msg = 4;
+}
+
+message CommandMessage {
+  string command = 1;
+  string identifier = 2;
+  string connection_identifiers = 3;
+  string data = 4;
+}
+
+message CommandResponse {
+  Status status = 1;
+  bool disconnect = 2;
+  bool stop_streams = 3;
+  repeated string streams = 4;
+  repeated string transmissions = 5;
+  string error_msg = 6;
+}
+
+message DisconnectRequest {
+  string identifiers = 1;
+  repeated string subscriptions = 2;
+  string path = 3;
+  map<string,string> headers = 4;
+}
+
+message DisconnectResponse {
+  Status status = 1;
+  string error_msg = 2;
+}

data/lib/anycable/rack-server/socket.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'anycable/rack-server/logging'
+
+module AnyCable
+  module RackServer
+    class Socket
+      include Logging
+      attr_reader :version, :socket
+
+      def initialize(env, socket, version)
+        log(:debug, "WebSocket version #{version}")
+        @env = env
+        @socket = socket
+        @version = version
+
+        @_open_handlers    = []
+        @_message_handlers = []
+        @_close_handlers   = []
+        @_error_handlers   = []
+        @_active           = true
+      end
+
+      def transmit(data, type: :text)
+        frame = WebSocket::Frame::Outgoing::Server.new(
+          version: version,
+          data: data,
+          type: type
+        )
+        socket.write(frame.to_s)
+      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT => e
+        log(:error, "Socket send failed: #{e}")
+        close
+      end
+
+      def request
+        @_request ||= ::Rack::Request.new(@env)
+      end
+
+      def onopen(&block)
+        @_open_handlers << block
+      end
+
+      def onmessage(&block)
+        @_message_handlers << block
+      end
+
+      def onclose(&block)
+        @_close_handlers << block
+      end
+
+      def onerror(&block)
+        @_error_handlers << block
+      end
+
+      # rubocop: disable Metrics/MethodLength
+      def listen
+        keepalive
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          begin
+            @_open_handlers.each(&:call)
+            each_frame do |data|
+              @_message_handlers.each do |handler|
+                begin
+                  handler.call(data)
+                rescue => e # rubocop: disable Style/RescueStandardError
+                  log(:error, "Socket receive failed: #{e}")
+                  @_error_handlers.each { |eh| eh.call(e, data) }
+                  close
+                end
+              end
+            end
+          ensure
+            close
+          end
+        end
+      end
+      # rubocop: enable Metrics/MethodLength
+
+      def close
+        return unless @_active
+
+        @_close_handlers.each(&:call)
+        close!
+
+        @_active = false
+      end
+
+      def closed?
+        socket.closed?
+      end
+
+      private
+
+      def close!
+        if socket.respond_to?(:closed?)
+          close_socket unless @socket.closed?
+        else
+          close_socket
+        end
+      end
+
+      def close_socket
+        frame = WebSocket::Frame::Outgoing::Server.new(version: version, type: :close, code: 1000)
+        socket.write(frame.to_s) if frame.supported?
+        socket.close
+      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT # rubocop:disable Lint/HandleExceptions
+        # already closed
+      end
+
+      def keepalive
+        thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          loop do
+            sleep 5
+            time = Time.now.to_i
+            transmit({ message: time, type: :ping }.to_json)
+          end
+        end
+
+        onclose do
+          thread.kill
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/MethodLength
+      def each_frame
+        framebuffer = WebSocket::Frame::Incoming::Server.new(version: version)
+        while IO.select([socket])
+          if socket.respond_to?(:recvfrom)
+            data, _addrinfo = socket.recvfrom(2000)
+          else
+            data, _addrinfo = socket.readpartial(2000), socket.peeraddr
+          end
+
+          break if data.empty?
+
+          framebuffer << data
+
+          while frame = framebuffer.next
+            case frame.type
+            when :close
+              return
+            when :text, :binary
+              yield frame.data
+            end
+          end
+        end
+      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNRESET, IOError, Errno::EBADF => e
+        log(:error, "Socket frame error: #{e}")
+        nil # client disconnected or timed out
+      end
+    end
+  end
+end

data/lib/anycable/rack-server/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RackServer
+    VERSION = '0.0.1'
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: anycable-rack-server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yulia Oletskaya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anycable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: anyt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: AnyCable-compatible Ruby Rack middleware
+email: yulia.oletskaya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/anycable-rack-server.rb
+- lib/anycable/rack-server.rb
+- lib/anycable/rack-server/broadcast_subscribers/redis_subscriber.rb
+- lib/anycable/rack-server/coders/json.rb
+- lib/anycable/rack-server/connection.rb
+- lib/anycable/rack-server/errors.rb
+- lib/anycable/rack-server/hub.rb
+- lib/anycable/rack-server/logging.rb
+- lib/anycable/rack-server/middleware.rb
+- lib/anycable/rack-server/pinger.rb
+- lib/anycable/rack-server/rpc/client.rb
+- lib/anycable/rack-server/rpc/rpc.proto
+- lib/anycable/rack-server/socket.rb
+- lib/anycable/rack-server/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Anycable Rack Server
+test_files: []