anycable 1.0.3 → 1.1.0.pre1

data/lib/anycable/rpc/rpc_services_pb.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# Source: rpc.proto for package 'anycable'
-
-require "grpc"
-
-module AnyCable
-  module RPC
-    class Service
-      include GRPC::GenericService
-
-      self.marshal_class_method = :encode
-      self.unmarshal_class_method = :decode
-      self.service_name = "anycable.RPC"
-
-      rpc :Connect, ConnectionRequest, ConnectionResponse
-      rpc :Command, CommandMessage, CommandResponse
-      rpc :Disconnect, DisconnectRequest, DisconnectResponse
-    end
-
-    Stub = Service.rpc_stub_class
-  end
-end

data/lib/anycable/rpc_handler.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require "anycable/socket"
-require "anycable/rpc"
-
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/ClassLength
-module AnyCable
-  # RPC service handler
-  class RPCHandler < AnyCable::RPC::Service
-    # Handle connection request from WebSocket server
-    def connect(request, _unused_call)
-      logger.debug("RPC Connect: #{request.inspect}")
-
-      socket = build_socket(env: rack_env(request.env))
-
-      connection = factory.call(socket)
-
-      connection.handle_open
-
-      if socket.closed?
-        AnyCable::ConnectionResponse.new(
-          status: AnyCable::Status::FAILURE,
-          transmissions: socket.transmissions
-        )
-      else
-        AnyCable::ConnectionResponse.new(
-          status: AnyCable::Status::SUCCESS,
-          identifiers: connection.identifiers_json,
-          transmissions: socket.transmissions,
-          env: build_env_response(socket)
-        )
-      end
-    rescue => exp
-      notify_exception(exp, :connect, request)
-
-      AnyCable::ConnectionResponse.new(
-        status: AnyCable::Status::ERROR,
-        error_msg: exp.message
-      )
-    end
-
-    def disconnect(request, _unused_call)
-      logger.debug("RPC Disconnect: #{request.inspect}")
-
-      socket = build_socket(env: rack_env(request.env))
-
-      connection = factory.call(
-        socket,
-        identifiers: request.identifiers,
-        subscriptions: request.subscriptions
-      )
-
-      if connection.handle_close
-        AnyCable::DisconnectResponse.new(status: AnyCable::Status::SUCCESS)
-      else
-        AnyCable::DisconnectResponse.new(status: AnyCable::Status::FAILURE)
-      end
-    rescue => exp
-      notify_exception(exp, :disconnect, request)
-
-      AnyCable::DisconnectResponse.new(
-        status: AnyCable::Status::ERROR,
-        error_msg: exp.message
-      )
-    end
-
-    def command(message, _unused_call)
-      logger.debug("RPC Command: #{message.inspect}")
-
-      socket = build_socket(env: rack_env(message.env))
-
-      connection = factory.call(
-        socket,
-        identifiers: message.connection_identifiers
-      )
-
-      result = connection.handle_channel_command(
-        message.identifier,
-        message.command,
-        message.data
-      )
-
-      AnyCable::CommandResponse.new(
-        status: result ? AnyCable::Status::SUCCESS : AnyCable::Status::FAILURE,
-        disconnect: socket.closed?,
-        stop_streams: socket.stop_streams?,
-        streams: socket.streams[:start],
-        stopped_streams: socket.streams[:stop],
-        transmissions: socket.transmissions,
-        env: build_env_response(socket)
-      )
-    rescue => exp
-      notify_exception(exp, :command, message)
-
-      AnyCable::CommandResponse.new(
-        status: AnyCable::Status::ERROR,
-        error_msg: exp.message
-      )
-    end
-
-    private
-
-    # Build Rack env from request
-    def rack_env(request_env)
-      uri = URI.parse(request_env.url)
-
-      env = base_rack_env
-      env.merge!({
-        "PATH_INFO" => uri.path,
-        "QUERY_STRING" => uri.query,
-        "SERVER_NAME" => uri.host,
-        "SERVER_PORT" => uri.port,
-        "HTTP_HOST" => uri.host,
-        "REMOTE_ADDR" => request_env.headers.delete("REMOTE_ADDR"),
-        "rack.url_scheme" => uri.scheme&.sub(/^ws/, "http"),
-        # AnyCable specific fields
-        "anycable.raw_cstate" => request_env.cstate&.to_h,
-        "anycable.raw_istate" => request_env.istate&.to_h
-      }.delete_if { |_k, v| v.nil? })
-
-      env.merge!(build_headers(request_env.headers))
-    end
-
-    def base_rack_env
-      # Minimum required variables according to Rack Spec
-      # (not all of them though, just those enough for Action Cable to work)
-      # See https://rubydoc.info/github/rack/rack/master/file/SPEC
-      # and https://github.com/rack/rack/blob/master/lib/rack/lint.rb
-      {
-        "REQUEST_METHOD" => "GET",
-        "SCRIPT_NAME" => "",
-        "PATH_INFO" => "/",
-        "QUERY_STRING" => "",
-        "SERVER_NAME" => "",
-        "SERVER_PORT" => "80",
-        "rack.url_scheme" => "http",
-        "rack.input" => StringIO.new("", "r").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) },
-        "rack.version" => ::Rack::VERSION,
-        "rack.errors" => StringIO.new("").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) },
-        "rack.multithread" => true,
-        "rack.multiprocess" => false,
-        "rack.run_once" => false,
-        "rack.hijack?" => false
-      }
-    end
-
-    def build_socket(**options)
-      AnyCable::Socket.new(**options)
-    end
-
-    def build_headers(headers)
-      headers.each_with_object({}) do |(k, v), obj|
-        k = k.upcase
-        k.tr!("-", "_")
-        obj["HTTP_#{k}"] = v
-      end
-    end
-
-    def build_env_response(socket)
-      AnyCable::EnvResponse.new(
-        cstate: socket.cstate.changed_fields,
-        istate: socket.istate.changed_fields
-      )
-    end
-
-    def logger
-      AnyCable.logger
-    end
-
-    def factory
-      AnyCable.connection_factory
-    end
-
-    def notify_exception(exp, method_name, message)
-      AnyCable::ExceptionsHandling.notify(exp, method_name.to_s, message.to_h)
-    end
-  end
-end
-# rubocop:enable Metrics/AbcSize
-# rubocop:enable Metrics/MethodLength
-# rubocop:enable Metrics/ClassLength

data/lib/anycable/rspec.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-# Utils for testing AnyCable and its plugins
-require "anycable/rspec/rpc_stub_context"
-require "anycable/rspec/rpc_command_context"
-require "anycable/rspec/with_grpc_server"

data/lib/anycable/rspec/rpc_command_context.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context "anycable:rpc:command" do
-  include_context "anycable:rpc:stub"
-
-  let(:command) { "" }
-  let(:channel_id) { "" }
-  let(:identifiers) { {} }
-  let(:data) { {} }
-
-  let(:request) do
-    AnyCable::CommandMessage.new(
-      command: command,
-      identifier: channel_id,
-      connection_identifiers: identifiers.to_json,
-      data: data.to_json,
-      env: env
-    )
-  end
-end

data/lib/anycable/rspec/rpc_stub_context.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context "anycable:rpc:stub" do
-  before(:all) do
-    @service = AnyCable::RPC::Stub.new(AnyCable.config.rpc_host, :this_channel_is_insecure)
-  end
-
-  let(:service) { @service }
-
-  let(:url) { "ws://example.anycable.com/cable" }
-  let(:headers) { {} }
-  let(:env) { AnyCable::Env.new(url: url, headers: headers) }
-end

data/lib/anycable/rspec/with_grpc_server.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context "anycable:rpc:server" do
-  before(:all) do
-    @server = AnyCable::Server.new(
-      host: AnyCable.config.rpc_host,
-      **AnyCable.config.to_grpc_params,
-      interceptors: AnyCable.middleware.to_a
-    )
-
-    @server.start
-    sleep 0.1
-  end
-
-  after(:all) { @server.stop }
-end

data/lib/anycable/server.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "grpc"
-require "grpc/health/checker"
-require "grpc/health/v1/health_services_pb"
-
-require "anycable/rpc_handler"
-require "anycable/health_server"
-
-module AnyCable
-  # Wrapper over gRPC server.
-  #
-  # Basic example:
-  #
-  #   # create new server listening on the loopback interface with 50051 port
-  #   server = AnyCable::Server.new(host: "127.0.0.1:50051")
-  #
-  #   # run gRPC server in bakground
-  #   server.start
-  #
-  #   # stop server
-  #   server.stop
-  class Server
-    attr_reader :grpc_server, :host
-
-    def initialize(host:, logger: nil, **options)
-      @logger = logger
-      @host = host
-      @grpc_server = build_server(options)
-    end
-
-    # Start gRPC server in background and
-    # wait untill it ready to accept connections
-    def start
-      return if running?
-
-      raise "Cannot re-start stopped server" if stopped?
-
-      logger.info "RPC server is starting..."
-
-      @start_thread = Thread.new { grpc_server.run }
-
-      grpc_server.wait_till_running
-
-      logger.info "RPC server is listening on #{host}"
-    end
-
-    def wait_till_terminated
-      raise "Server is not running" unless running?
-
-      start_thread.join
-    end
-
-    # Stop gRPC server if it's running
-    def stop
-      return unless running?
-
-      grpc_server.stop
-
-      logger.info "RPC server stopped"
-    end
-
-    def running?
-      grpc_server.running_state == :running
-    end
-
-    def stopped?
-      grpc_server.running_state == :stopped
-    end
-
-    private
-
-    attr_reader :start_thread
-
-    def logger
-      @logger ||= AnyCable.logger
-    end
-
-    def build_server(options)
-      GRPC::RpcServer.new(**options).tap do |server|
-        server.add_http2_port(host, :this_port_is_insecure)
-        server.handle(AnyCable::RPCHandler)
-        server.handle(build_health_checker)
-      end
-    end
-
-    def build_health_checker
-      health_checker = Grpc::Health::Checker.new
-      health_checker.add_status(
-        "anycable.RPC",
-        Grpc::Health::V1::HealthCheckResponse::ServingStatus::SERVING
-      )
-      health_checker
-    end
-  end
-end

data/lib/anycable/socket.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  # Socket mock to be used with application connection
-  class Socket
-    # Represents the per-connection store
-    # (for example, used to keep session beetween RPC calls)
-    class State
-      attr_reader :dirty_keys, :source
-
-      def initialize(from)
-        @source = from
-        @dirty_keys = nil
-      end
-
-      def read(key)
-        source&.[](key)
-      end
-
-      alias_method :[], :read
-
-      def write(key, val)
-        return if source&.[](key) == val
-
-        @source ||= {}
-        @dirty_keys ||= []
-        dirty_keys << key
-        source[key] = val
-      end
-
-      alias_method :[]=, :write
-
-      def changed_fields
-        return unless source && dirty_keys
-        source.slice(*dirty_keys)
-      end
-    end
-
-    attr_reader :transmissions, :env, :cstate, :istate
-
-    def initialize(env: nil)
-      @transmissions = []
-      @env = env
-      @cstate = env["anycable.cstate"] = State.new(env["anycable.raw_cstate"])
-      @istate = env["anycable.istate"] = State.new(env["anycable.raw_istate"])
-    end
-
-    def transmit(websocket_message)
-      transmissions << websocket_message
-    end
-
-    def subscribe(_channel, broadcasting)
-      streams[:start] << broadcasting
-    end
-
-    def unsubscribe(_channel, broadcasting)
-      streams[:stop] << broadcasting
-    end
-
-    def unsubscribe_from_all(_channel)
-      @stop_all_streams = true
-    end
-
-    def streams
-      @streams ||= {start: [], stop: []}
-    end
-
-    def close
-      @closed = true
-      @streams&.clear
-      @stop_all_streams = true
-    end
-
-    def closed?
-      @closed == true
-    end
-
-    def stop_streams?
-      @stop_all_streams == true
-    end
-
-    def session
-      cstate.read(SESSION_KEY)
-    end
-
-    def session=(val)
-      cstate.write(SESSION_KEY, val)
-    end
-  end
-end