anycable-rack-server 0.0.1 → 0.3.0

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

@@ -1,40 +0,0 @@
-# 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/connection.rb

@@ -1,189 +0,0 @@
-# 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/middleware.rb

@@ -1,82 +0,0 @@
-# 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/rpc/client.rb

@@ -1,42 +0,0 @@
-# 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