anycable-core 1.1.0.pre1

data/lib/anycable/exceptions_handling.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module ExceptionsHandling # :nodoc:
+    class << self
+      def add_handler(block)
+        handlers << procify(block)
+      end
+
+      alias_method :<<, :add_handler
+
+      def notify(exp, method_name, message)
+        handlers.each do |handler|
+          handler.call(exp, method_name, message)
+        rescue => 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
+
+      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/grpc.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "grpc"
+
+module AnyCable
+  module GRPC
+  end
+end
+
+require "anycable/grpc/config"
+require "anycable/grpc/server"
+require "anycable/grpc/check_version"
+
+AnyCable.server_builder = ->(config) {
+  AnyCable.logger.info "gRPC version: #{::GRPC::VERSION}"
+
+  ::GRPC.define_singleton_method(:logger) { AnyCable.logger } if config.log_grpc?
+
+  interceptors = []
+
+  if config.version_check_enabled?
+    interceptors << AnyCable::GRPC::CheckVersion.new(AnyCable::PROTO_VERSION)
+  end
+
+  params = config.to_grpc_params
+  params[:host] = config.rpc_host
+  params[:interceptors] = interceptors
+
+  AnyCable::GRPC::Server.new(**params)
+}

data/lib/anycable/grpc/check_version.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module GRPC
+    # Checks that gRPC client version is compatible with
+    # the current RPC proto version
+    class CheckVersion < ::GRPC::ServerInterceptor
+      attr_reader :version
+
+      def initialize(version)
+        @version = version
+      end
+
+      def request_response(request: nil, call: nil, method: nil)
+        # Call only for AnyCable service
+        return yield unless method.receiver.is_a?(AnyCable::GRPC::Handler)
+
+        check_version(call) do
+          yield
+        end
+      end
+
+      def check_version(call)
+        supported_versions = call.metadata["protov"]&.split(",")
+        return yield if supported_versions&.include?(version)
+
+        raise ::GRPC::Internal,
+          "Incompatible AnyCable RPC client.\nCurrent server version: #{version}.\n" \
+          "Client supported versions: #{call.metadata["protov"] || "unknown"}."
+      end
+    end
+  end
+end

data/lib/anycable/grpc/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+AnyCable::Config.attr_config(
+  ### gRPC options
+  rpc_host: "127.0.0.1:50051",
+  # For defaults see https://github.com/grpc/grpc/blob/51f0d35509bcdaba572d422c4f856208162022de/src/ruby/lib/grpc/generic/rpc_server.rb#L186-L216
+  rpc_pool_size: ::GRPC::RpcServer::DEFAULT_POOL_SIZE,
+  rpc_max_waiting_requests: ::GRPC::RpcServer::DEFAULT_MAX_WAITING_REQUESTS,
+  rpc_poll_period: ::GRPC::RpcServer::DEFAULT_POLL_PERIOD,
+  rpc_pool_keep_alive: ::GRPC::Pool::DEFAULT_KEEP_ALIVE,
+  # See https://github.com/grpc/grpc/blob/f526602bff029b8db50a8d57134d72da33d8a752/include/grpc/impl/codegen/grpc_types.h#L292-L315
+  rpc_server_args: {},
+  log_grpc: false
+)
+
+AnyCable::Config.ignore_options :rpc_server_args
+AnyCable::Config.flag_options :log_grpc
+
+module AnyCable
+  module GRPC
+    module Config
+      def log_grpc
+        debug? || super
+      end
+
+      # Add alias explicitly, 'cause previous alias refers to the original log_grpc method
+      alias_method :log_grpc?, :log_grpc
+
+      # Build gRPC server parameters
+      def to_grpc_params
+        {
+          pool_size: rpc_pool_size,
+          max_waiting_requests: rpc_max_waiting_requests,
+          poll_period: rpc_poll_period,
+          pool_keep_alive: rpc_pool_keep_alive,
+          server_args: rpc_server_args
+        }
+      end
+    end
+  end
+end
+
+AnyCable::Config.prepend AnyCable::GRPC::Config
+
+AnyCable::Config.usage <<~TXT
+  GRPC OPTIONS
+      --rpc-host=host                   Local address to run gRPC server on, default: "127.0.0.1:50051"
+      --rpc-pool-size=size              gRPC workers pool size, default: 30
+      --rpc-max-waiting-requests=num    Max waiting requests queue size, default: 20
+      --rpc-poll-period=seconds         Poll period (sec), default: 1
+      --rpc-pool-keep-alive=seconds     Keep-alive polling interval (sec), default: 1
+      --log-grpc                        Enable gRPC logging (disabled by default)
+TXT

data/lib/anycable/grpc/handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "anycable/socket"
+require "anycable/rpc"
+require "anycable/grpc/rpc_services_pb"
+
+module AnyCable
+  module GRPC
+    # RPC service handler
+    class Handler < AnyCable::GRPC::Service
+      # Handle connection request from WebSocket server
+      def connect(request, _unused_call)
+        AnyCable.rpc_handler.handle(:connect, request)
+      end
+
+      def disconnect(request, _unused_call)
+        AnyCable.rpc_handler.handle(:disconnect, request)
+      end
+
+      def command(request, _unused_call)
+        AnyCable.rpc_handler.handle(:command, request)
+      end
+    end
+  end
+end

data/lib/anycable/grpc/rpc_services_pb.rb

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

data/lib/anycable/grpc/server.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "grpc"
+require "grpc/health/checker"
+require "grpc/health/v1/health_services_pb"
+
+require "anycable/grpc/handler"
+
+module AnyCable
+  module GRPC
+    using(Module.new do
+      refine ::GRPC::RpcServer do
+        attr_reader :pool_size
+      end
+    end)
+
+    # Wrapper over gRPC server.
+    #
+    # Basic example:
+    #
+    #   # create new server listening on the loopback interface with 50051 port
+    #   server = AnyCable::GRPC::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} (workers_num: #{grpc_server.pool_size})"
+      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::GRPC::Handler)
+          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
+end

data/lib/anycable/health_server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module AnyCable
+  # Server for HTTP healthchecks.
+  #
+  # Basic usage:
+  #
+  #  # create a new healthcheck server for a specified
+  #  # server listening on the port
+  #  health_server = AnyCable::HealthServer.new(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
+
+    attr_reader :server, :port, :path, :http_server
+
+    def initialize(server, port:, logger: nil, path: "/health")
+      @server = server
+      @port = port
+      @path = path
+      @logger = logger
+      @http_server = build_server
+    end
+
+    def start
+      return if running?
+
+      Thread.new { http_server.start }
+
+      logger.info "HTTP health server is listening on localhost:#{port} and mounted at \"#{path}\""
+    end
+
+    def stop
+      return unless running?
+
+      http_server.shutdown
+    end
+
+    def running?
+      http_server.status == :Running
+    end
+
+    private
+
+    def logger
+      @logger ||= AnyCable.logger
+    end
+
+    def build_server
+      begin
+        require "webrick"
+      rescue LoadError
+        raise "Please, install webrick gem to use health server"
+      end
+
+      WEBrick::HTTPServer.new(
+        Port: port,
+        Logger: logger,
+        AccessLog: []
+      ).tap do |http_server|
+        http_server.mount_proc path do |_, res|
+          res.status, res.body = server.running? ? SUCCESS_RESPONSE : FAILURE_RESPONSE
+        end
+      end
+    end
+  end
+end

data/lib/anycable/middleware.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCable
+  # Middleware is an analague of Rack middlewares but for AnyCable RPC calls
+  class Middleware
+    def call(_method_name, _request)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/anycable/middleware_chain.rb

@@ -0,0 +1,74 @@
+# 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
+
+    def call(method_name, request, &block)
+      return yield(method_name, request) if registry.none?
+
+      execute_next_middleware(0, method_name, request, block)
+    end
+
+    private
+
+    def execute_next_middleware(ind, method_name, request, block)
+      return block.call(method_name, request) if ind >= registry.size
+
+      registry[ind].call(method_name, request) do
+        execute_next_middleware(ind + 1, method_name, request, block)
+      end
+    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