anycable 0.5.2 → 0.6.4

data/lib/anycable/exceptions_handling.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module ExceptionsHandling # :nodoc:
+    class << self
+      def add_handler(block)
+        handlers << procify(block)
+      end
+
+      alias << add_handler
+
+      def notify(exp, method_name, message)
+        handlers.each do |handler|
+          begin
+            handler.call(exp, method_name, message)
+          rescue StandardError => exp
+            AnyCable.logger.error "!!! EXCEPTION HANDLER THREW AN ERROR !!!"
+            AnyCable.logger.error exp
+            AnyCable.logger.error exp.backtrace.join("\n") unless exp.backtrace.nil?
+          end
+        end
+      end
+
+      private
+
+      def procify(block)
+        return block unless block.lambda?
+
+        proc { |*args| block.call(*args.take(block.arity)) }
+      end
+
+      def handlers
+        @handlers ||= []
+      end
+    end
+  end
+end

data/lib/anycable/health_server.rb

@@ -1,44 +1,65 @@
 # frozen_string_literal: true
 
-require 'webrick'
-require 'anycable/server'
+module AnyCable
+  # Server for HTTP healthchecks.
+  #
+  # Basic usage:
+  #
+  #  # create a new healthcheck server for a specified
+  #  # gRPC server lisening on the port
+  #  health_server = AnyCable::HealthServer.new(grpc_server, port)
+  #
+  #  # start health server in background
+  #  health_server.start
+  #
+  #  # stop health server
+  #  health_server.stop
+  class HealthServer
+    SUCCESS_RESPONSE = [200, "Ready"].freeze
+    FAILURE_RESPONSE = [503, "Not Ready"].freeze
 
-module Anycable
-  # Server for HTTP healthchecks
-  module HealthServer
-    class << self
-      def start(port)
-        return if running?
+    attr_reader :grpc_server, :port, :path, :server
 
-        @health_server ||= build_server(port)
-        Thread.new { @health_server.start }
+    def initialize(grpc_server, port:, path: "/health", logger: AnyCable.logger)
+      @grpc_server = grpc_server
+      @port = port
+      @path = path
+      @logger = logger
+      @server = build_server
+    end
 
-        Anycable.logger.info "HTTP health server is listening on #{port}"
-      end
+    def start
+      return if running?
 
-      def stop
-        return unless running?
-        @health_server.shutdown
-      end
+      Thread.new { server.start }
 
-      def running?
-        @health_server&.status == :Running
-      end
+      logger.info "HTTP health server is listening on localhost:#{port} and mounted at \"#{path}\""
+    end
+
+    def stop
+      return unless running?
+
+      server.shutdown
+    end
+
+    def running?
+      server.status == :Running
+    end
+
+    private
 
-      private
+    attr_reader :logger
 
-      SUCCESS_RESPONSE = [200, "Ready"].freeze
-      FAILURE_RESPONSE = [503, "Not Ready"].freeze
+    def build_server
+      require "webrick"
 
-      def build_server(port)
-        WEBrick::HTTPServer.new(
-          Port: port,
-          Logger: Anycable.logger,
-          AccessLog: []
-        ).tap do |server|
-          server.mount_proc '/health' do |_, res|
-            res.status, res.body = Anycable::Server.running? ? SUCCESS_RESPONSE : FAILURE_RESPONSE
-          end
+      WEBrick::HTTPServer.new(
+        Port: port,
+        Logger: logger,
+        AccessLog: []
+      ).tap do |server|
+        server.mount_proc path do |_, res|
+          res.status, res.body = grpc_server.running? ? SUCCESS_RESPONSE : FAILURE_RESPONSE
         end
       end
     end

data/lib/anycable/middleware.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "grpc"
+
+module AnyCable
+  # Middleware is a wrapper over gRPC interceptors
+  # for request/response calls
+  class Middleware < GRPC::Interceptor
+    def request_response(request: nil, call: nil, method: nil)
+      call(request, call, method) do
+        yield
+      end
+    end
+
+    def call(*)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/anycable/middleware_chain.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "anycable/middleware"
+require "monitor"
+
+module AnyCable
+  # Middleware chain is used to build the list of
+  # gRPC server interceptors.
+  #
+  # Each interceptor should be a subsclass of
+  # AnyCable::Middleware and implement `#call` method.
+  class MiddlewareChain
+    def initialize
+      @registry = []
+      @mu = Monitor.new
+    end
+
+    def use(middleware)
+      check_frozen!
+      middleware = build_middleware(middleware)
+      sync { registry << middleware }
+    end
+
+    def freeze
+      registry.freeze
+      super
+    end
+
+    def to_a
+      registry
+    end
+
+    private
+
+    attr_reader :mu, :registry
+
+    def sync
+      mu.synchronize { yield }
+    end
+
+    def check_frozen!
+      raise "Cannot modify AnyCable middlewares after server started" if frozen?
+    end
+
+    def build_middleware(middleware)
+      middleware = middleware.new if
+        middleware.is_a?(Class) && middleware <= AnyCable::Middleware
+
+      unless middleware.is_a?(AnyCable::Middleware)
+        raise ArgumentError,
+              "AnyCable middleware must be a subclass of AnyCable::Middleware, " \
+              "got #{middleware} instead"
+      end
+
+      middleware
+    end
+  end
+end

data/lib/anycable/rpc/rpc_pb.rb

@@ -45,7 +45,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   end
 end
 
-module Anycable
+module AnyCable
   ConnectionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.ConnectionRequest").msgclass
   ConnectionResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.ConnectionResponse").msgclass
   CommandMessage = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.CommandMessage").msgclass

data/lib/anycable/rpc/rpc_services_pb.rb

@@ -3,7 +3,7 @@
 
 require 'grpc'
 
-module Anycable
+module AnyCable
   module RPC
     class Service
 

data/lib/anycable/rpc_handler.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 
-require 'anycable/socket'
-require 'anycable/rpc/rpc_pb'
-require 'anycable/rpc/rpc_services_pb'
-
-require 'anycable/handler/exceptions_handling'
+require "anycable/socket"
+require "anycable/rpc/rpc_pb"
+require "anycable/rpc/rpc_services_pb"
 
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/MethodLength
-module Anycable
+# rubocop:disable Metrics/ClassLength
+module AnyCable
   # RPC service handler
-  class RPCHandler < Anycable::RPC::Service
-    prepend Handler::ExceptionsHandling
-
+  class RPCHandler < AnyCable::RPC::Service
     # Handle connection request from WebSocket server
     def connect(request, _unused_call)
       logger.debug("RPC Connect: #{request.inspect}")
@@ -24,14 +21,21 @@ module Anycable
       connection.handle_open
 
       if socket.closed?
-        Anycable::ConnectionResponse.new(status: Anycable::Status::FAILURE)
+        AnyCable::ConnectionResponse.new(status: AnyCable::Status::FAILURE)
       else
-        Anycable::ConnectionResponse.new(
-          status: Anycable::Status::SUCCESS,
+        AnyCable::ConnectionResponse.new(
+          status: AnyCable::Status::SUCCESS,
           identifiers: connection.identifiers_json,
           transmissions: socket.transmissions
         )
       end
+    rescue StandardError => exp
+      notify_exception(exp, :connect, request)
+
+      AnyCable::ConnectionResponse.new(
+        status: AnyCable::Status::ERROR,
+        error_msg: exp.message
+      )
     end
 
     def disconnect(request, _unused_call)
@@ -46,16 +50,25 @@ module Anycable
       )
 
       if connection.handle_close
-        Anycable::DisconnectResponse.new(status: Anycable::Status::SUCCESS)
+        AnyCable::DisconnectResponse.new(status: AnyCable::Status::SUCCESS)
       else
-        Anycable::DisconnectResponse.new(status: Anycable::Status::FAILURE)
+        AnyCable::DisconnectResponse.new(status: AnyCable::Status::FAILURE)
       end
+    rescue StandardError => 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
+      # We don't have path/headers information here,
+      # but we still want `connection.env` to work
+      socket = build_socket(env: base_rack_env)
 
       connection = factory.call(
         socket,
@@ -68,51 +81,83 @@ module Anycable
         message.data
       )
 
-      Anycable::CommandResponse.new(
-        status: result ? Anycable::Status::SUCCESS : Anycable::Status::FAILURE,
+      AnyCable::CommandResponse.new(
+        status: result ? AnyCable::Status::SUCCESS : AnyCable::Status::FAILURE,
         disconnect: socket.closed?,
         stop_streams: socket.stop_streams?,
         streams: socket.streams,
         transmissions: socket.transmissions
       )
+    rescue StandardError => exp
+      notify_exception(exp, :command, message)
+
+      AnyCable::CommandResponse.new(
+        status: AnyCable::Status::ERROR,
+        error_msg: exp.message
+      )
     end
 
     private
 
-    # Build env from path
+    # Build Rack env from request
     def rack_env(request)
       uri = URI.parse(request.path)
+
+      env = base_rack_env
+      env.merge!(
+        "PATH_INFO" => uri.path,
+        "QUERY_STRING" => uri.query,
+        "SERVER_NAME" => uri.host,
+        "SERVER_PORT" => uri.port.to_s,
+        "HTTP_HOST" => uri.host,
+        "REMOTE_ADDR" => request.headers.delete("REMOTE_ADDR"),
+        "rack.url_scheme" => uri.scheme
+      )
+
+      env.merge!(build_headers(request.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
       {
-        'QUERY_STRING' => uri.query,
-        'SCRIPT_NAME' => '',
-        'PATH_INFO' => uri.path,
-        'SERVER_PORT' => uri.port.to_s,
-        'HTTP_HOST' => uri.host,
-        # Hack to avoid Missing rack.input error
-        'rack.request.form_input' => '',
-        'rack.input' => '',
-        'rack.request.form_hash' => {}
-      }.merge(build_headers(request.headers))
+        "REQUEST_METHOD" => "GET",
+        "SCRIPT_NAME" => "",
+        "PATH_INFO" => "/",
+        "QUERY_STRING" => "",
+        "SERVER_NAME" => "",
+        "SERVER_PORT" => "80",
+        "rack.url_scheme" => "http",
+        "rack.input" => ""
+      }
     end
 
     def build_socket(**options)
-      Anycable::Socket.new(options)
+      AnyCable::Socket.new(**options)
     end
 
     def build_headers(headers)
       headers.each_with_object({}) do |(k, v), obj|
         k = k.upcase
-        k.tr!('-', '_')
+        k.tr!("-", "_")
         obj["HTTP_#{k}"] = v
       end
     end
 
     def logger
-      Anycable.logger
+      AnyCable.logger
     end
 
     def factory
-      Anycable.connection_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/server.rb

@@ -1,59 +1,152 @@
 # frozen_string_literal: true
 
-require 'grpc'
-require 'anycable/rpc_handler'
-require 'anycable/health_server'
+require "grpc"
+require "grpc/health/checker"
+require "grpc/health/v1/health_services_pb"
 
-module Anycable
-  # Wrapper over GRPC server
-  module Server
+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
     class << self
-      attr_reader :grpc_server
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def start(**options)
+        warn <<~DEPRECATION
+          DEPRECATION WARNING: Using AnyCable::Server.start is deprecated!
+          Please, use anycable CLI instead.
 
-      def start
-        log_grpc! if Anycable.config.log_grpc
+          See https://docs.anycable.io/#upgrade_to_0_6_0
+        DEPRECATION
 
-        start_http_health_server
-        start_grpc_server
-      end
+        AnyCable.server_callbacks.each(&:call)
 
-      def stop
-        return unless running?
-        @grpc_server.stop
-      end
+        server = new(
+          host: AnyCable.config.rpc_host,
+          **AnyCable.config.to_grpc_params,
+          interceptors: AnyCable.middleware.to_a,
+          **options
+        )
 
-      def running?
-        grpc_server&.running_state == :running
-      end
+        AnyCable.middleware.freeze
+
+        if AnyCable.config.http_health_port_provided?
+          health_server = AnyCable::HealthServer.new(
+            server,
+            **AnyCable.config.to_http_health_params
+          )
+          health_server.start
+        end
+
+        at_exit do
+          server.stop
+          health_server&.stop
+        end
 
-      # Enable GRPC logging
-      def log_grpc!
-        GRPC.define_singleton_method(:logger) { Anycable.logger }
+        AnyCable.logger.info "Broadcasting Redis channel: #{AnyCable.config.redis_channel}"
+
+        server.start
+        server.wait_till_terminated
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
 
-      private
+    attr_reader :grpc_server, :host
 
-      def start_grpc_server
-        @grpc_server ||= build_server
+    def initialize(host:, logger: AnyCable.logger, **options)
+      @logger = logger
+      @host = host
+      @grpc_server = build_server(options)
+    end
 
-        Anycable.logger.info "RPC server is listening on #{Anycable.config.rpc_host}"
-        Anycable.logger.info "Broadcasting Redis channel: #{Anycable.config.redis_channel}"
+    # Start gRPC server in background and
+    # wait untill it ready to accept connections
+    def start
+      return if running?
 
-        grpc_server.run_till_terminated
-      end
+      raise "Cannot re-start stopped server" if stopped?
 
-      def build_server
-        GRPC::RpcServer.new.tap do |server|
-          server.add_http2_port(Anycable.config.rpc_host, :this_port_is_insecure)
-          server.handle(Anycable::RPCHandler)
-        end
-      end
+      check_default_host
+
+      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?
 
-      def start_http_health_server
-        return unless Anycable.config.http_health_port_provided?
-        Anycable::HealthServer.start(Anycable.config.http_health_port)
-        at_exit { Anycable::HealthServer.stop }
+      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 :logger, :start_thread
+
+    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
+
+    def check_default_host
+      return unless host.is_a?(Anycable::Config::DefaultHostWrapper)
+
+      warn <<~DEPRECATION
+        DEPRECATION WARNING: You're using default rpc_host configuration which starts AnyCable RPC
+        server on all available interfaces including external IPv4 and IPv6.
+        This is about to be changed to loopback interface only in future versions.
+
+        Please, consider switching to the loopback interface or set "[::]:50051"
+        explicitly in your configuration, if you want to continue with the current
+        behavior and supress this message.
+
+        See https://docs.anycable.io/#/configuration
+      DEPRECATION
+    end
   end
 end