anycable 0.5.2 → 0.6.0.rc1

data/lib/anycable/handler/capture_exceptions.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "anycable/rpc/rpc_pb"
+
+module AnyCable
+  module Handler # :nodoc:
+    # Handle app-level errors.
+    #
+    # NOTE: this functionality couldn't be implemeted
+    # as middleware, 'cause interceptors do not support
+    # aborting the call and returning a data
+    module CaptureExceptions
+      RESPONSE_CLASS = {
+        command: AnyCable::CommandResponse,
+        connect: AnyCable::ConnectionResponse,
+        disconnect: AnyCable::DisconnectResponse
+      }.freeze
+
+      RESPONSE_CLASS.keys.each do |mid|
+        module_eval <<~CODE, __FILE__, __LINE__ + 1
+          def #{mid}(*)
+            capture_exceptions(:#{mid}) { super }
+          end
+        CODE
+      end
+
+      def capture_exceptions(method_name)
+        yield
+      rescue StandardError => exp
+        AnyCable::ExceptionsHandling.notify(exp)
+
+        RESPONSE_CLASS.fetch(method_name).new(
+          status: AnyCable::Status::ERROR,
+          error_msg: exp.message
+        )
+      end
+    end
+  end
+end

data/lib/anycable/health_server.rb

@@ -1,44 +1,66 @@
 # frozen_string_literal: true
 
-require 'webrick'
-require 'anycable/server'
+require "webrick"
+require "anycable/server"
 
-module Anycable
-  # Server for HTTP healthchecks
-  module HealthServer
-    class << self
-      def start(port)
-        return if running?
+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
 
-        @health_server ||= build_server(port)
-        Thread.new { @health_server.start }
+    attr_reader :grpc_server, :port, :path, :server
 
-        Anycable.logger.info "HTTP health server is listening on #{port}"
-      end
+    def initialize(grpc_server, port:, path: "/health", logger: AnyCable.logger)
+      @grpc_server = grpc_server
+      @port = port
+      @path = path
+      @logger = logger
+      @server = build_server
+    end
 
-      def stop
-        return unless running?
-        @health_server.shutdown
-      end
+    def start
+      return if running?
 
-      def running?
-        @health_server&.status == :Running
-      end
+      Thread.new { server.start }
+
+      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
 
-      SUCCESS_RESPONSE = [200, "Ready"].freeze
-      FAILURE_RESPONSE = [503, "Not Ready"].freeze
+    attr_reader :logger
 
-      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
+    def build_server
+      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,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'anycable/socket'
-require 'anycable/rpc/rpc_pb'
-require 'anycable/rpc/rpc_services_pb'
+require "anycable/socket"
+require "anycable/rpc/rpc_pb"
+require "anycable/rpc/rpc_services_pb"
 
-require 'anycable/handler/exceptions_handling'
+require "anycable/handler/capture_exceptions"
 
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/MethodLength
-module Anycable
+module AnyCable
   # RPC service handler
-  class RPCHandler < Anycable::RPC::Service
-    prepend Handler::ExceptionsHandling
+  class RPCHandler < AnyCable::RPC::Service
+    prepend AnyCable::Handler::CaptureExceptions
 
     # Handle connection request from WebSocket server
     def connect(request, _unused_call)
@@ -24,10 +24,10 @@ 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
         )
@@ -46,9 +46,9 @@ 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
     end
 
@@ -68,8 +68,8 @@ 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,
@@ -83,36 +83,38 @@ module Anycable
     def rack_env(request)
       uri = URI.parse(request.path)
       {
-        'QUERY_STRING' => uri.query,
-        'SCRIPT_NAME' => '',
-        'PATH_INFO' => uri.path,
-        'SERVER_PORT' => uri.port.to_s,
-        'HTTP_HOST' => uri.host,
+        "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' => {}
+        "rack.request.form_input" => "",
+        "rack.input" => "",
+        "rack.request.form_hash" => {}
       }.merge(build_headers(request.headers))
     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
   end
 end
+# rubocop:enable Metrics/AbcSize
+# rubocop:enable Metrics/MethodLength

data/lib/anycable/server.rb

@@ -1,59 +1,134 @@
 # 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 [::]:50051 (default host)
+  #   server = AnyCable::Server.new(host: "[::]: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
+          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
+        server = new(
+          host: AnyCable.config.rpc_host,
+          **AnyCable.config.to_grpc_params,
+          interceptors: AnyCable.middleware.to_a,
+          **options
+        )
 
-      def stop
-        return unless running?
-        @grpc_server.stop
-      end
+        AnyCable.middleware.freeze
 
-      def running?
-        grpc_server&.running_state == :running
-      end
+        if AnyCable.config.http_health_port_provided?
+          health_server = AnyCable::HealthServer.new(
+            server,
+            **AnyCable.config.to_http_health_params
+          )
+          health_server.start
+        end
 
-      # Enable GRPC logging
-      def log_grpc!
-        GRPC.define_singleton_method(:logger) { Anycable.logger }
+        at_exit do
+          server.stop
+          health_server&.stop
+        end
+
+        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
+    DEFAULT_HOST = "0.0.0.0:50051"
 
-      def start_grpc_server
-        @grpc_server ||= build_server
+    attr_reader :grpc_server, :host
 
-        Anycable.logger.info "RPC server is listening on #{Anycable.config.rpc_host}"
-        Anycable.logger.info "Broadcasting Redis channel: #{Anycable.config.redis_channel}"
+    def initialize(host: DEFAULT_HOST, logger: AnyCable.logger, **options)
+      @logger = logger
+      @host = host
+      @grpc_server = build_server(options)
+    end
 
-        grpc_server.run_till_terminated
-      end
+    # Start gRPC server in background and
+    # wait untill it ready to accept connections
+    def start
+      return if running?
 
-      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
+      raise "Cannot re-start stopped server" if stopped?
 
-      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 }
+      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 :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
   end
 end