anycable 0.6.4 → 1.0.0.rc2

data/lib/anycable/broadcast_adapters/http.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "net/http"
+
+module AnyCable
+  module BroadcastAdapters
+    # HTTP adapter for broadcasting.
+    #
+    # Example:
+    #
+    #   AnyCable.broadast_adapter = :http
+    #
+    # It uses configuration from global AnyCable config
+    # by default.
+    #
+    # You can override these params:
+    #
+    #   AnyCable.broadcast_adapter = :http, url: "http://ws.example.com/_any_cable_"
+    class Http < Base
+      # Taken from: https://github.com/influxdata/influxdb-ruby/blob/886058079c66d4fd019ad74ca11342fddb0b753d/lib/influxdb/errors.rb#L18
+      RECOVERABLE_EXCEPTIONS = [
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::EINVAL,
+        Errno::ENETUNREACH,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError,
+        (OpenSSL::SSL::SSLError if defined?(OpenSSL))
+      ].compact.freeze
+
+      OPEN_TIMEOUT = 5
+      READ_TIMEOUT = 10
+
+      MAX_ATTEMPTS = 3
+      DELAY = 2
+
+      attr_reader :url, :headers, :authorized
+      alias authorized? authorized
+
+      def initialize(url: AnyCable.config.http_broadcast_url, secret: AnyCable.config.http_broadcast_secret)
+        @url = url
+        @headers = {}
+        if secret
+          headers["Authorization"] = "Bearer #{secret}"
+          @authorized = true
+        end
+
+        @uri = URI.parse(url)
+        @queue = Queue.new
+      end
+
+      def raw_broadcast(payload)
+        ensure_thread_is_alive
+        queue << payload
+      end
+
+      # Wait for background thread to process all the messages
+      # and stop it
+      def shutdown
+        queue << :stop
+        thread.join if thread&.alive?
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        logger.error "Broadcasting thread exited with exception: #{e.message}"
+      end
+
+      def announce!
+        logger.info "Broadcasting HTTP url: #{url}#{authorized? ? " (with authorization)" : ""}"
+      end
+
+      private
+
+      attr_reader :uri, :queue, :thread
+
+      def ensure_thread_is_alive
+        return if thread&.alive?
+
+        @thread = Thread.new do
+          loop do
+            msg = queue.pop
+            break if msg == :stop
+
+            handle_response perform_request(msg)
+          end
+        end
+      end
+
+      def perform_request(payload)
+        build_http do |http|
+          req = Net::HTTP::Post.new(url, {"Content-Type" => "application/json"}.merge(headers))
+          req.body = payload
+          http.request(req)
+        end
+      end
+
+      def handle_response(response)
+        return unless response
+        return if Net::HTTPCreated === response
+
+        logger.error "Broadcast request responded with unexpected status: #{response.code}"
+      end
+
+      def build_http
+        retry_count = 0
+
+        begin
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = OPEN_TIMEOUT
+          http.read_timeout = READ_TIMEOUT
+          http.use_ssl = url.match?(/^https/)
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          yield http
+        rescue Timeout::Error, *RECOVERABLE_EXCEPTIONS => e
+          retry_count += 1
+          return logger.error("Broadcast request failed: #{e.message}") if MAX_ATTEMPTS < retry_count
+
+          sleep((DELAY**retry_count) * retry_count)
+          retry
+        ensure
+          http.finish if http.started?
+        end
+      end
+    end
+  end
+end

data/lib/anycable/broadcast_adapters/redis.rb

@@ -19,7 +19,7 @@ module AnyCable
     # You can override these params:
     #
     #   AnyCable.broadcast_adapter = :redis, url: "redis://my_redis", channel: "_any_cable_"
-    class Redis
+    class Redis < Base
       attr_reader :redis_conn, :channel
 
       def initialize(
@@ -31,11 +31,12 @@ module AnyCable
         @channel = channel
       end
 
-      def broadcast(stream, payload)
-        redis_conn.publish(
-          channel,
-          { stream: stream, data: payload }.to_json
-        )
+      def raw_broadcast(payload)
+        redis_conn.publish(channel, payload)
+      end
+
+      def announce!
+        logger.info "Broadcasting Redis channel: #{channel}"
       end
     end
   end

data/lib/anycable/cli.rb

@@ -20,27 +20,32 @@ module AnyCable
     # Wait for external process termination (s)
     WAIT_PROCESS = 2
 
-    attr_reader :server, :health_server
+    attr_reader :server, :health_server, :embedded
+    alias embedded? embedded
+
+    def initialize(embedded: false)
+      @embedded = embedded
+    end
 
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def run(args = {})
+    def run(args = [])
       @at_stop = []
 
       extra_options = parse_cli_options!(args)
 
       # Boot app first, 'cause it might change
       # configuration, loggin settings, etc.
-      boot_app!
+      boot_app! unless embedded?
 
       parse_gem_options!(extra_options)
 
       configure_server!
 
-      logger.info "Starting AnyCable gRPC server (pid: #{Process.pid})"
+      logger.info "Starting AnyCable gRPC server (pid: #{Process.pid}, workers_num: #{config.rpc_pool_size})"
 
       print_versions!
 
-      logger.info "Serving #{defined?(::Rails) ? 'Rails ' : ''}application from #{boot_file}"
+      logger.info "Serving #{defined?(::Rails) ? "Rails " : ""}application from #{boot_file}" unless embedded?
 
       verify_connection_factory!
 
@@ -48,6 +53,8 @@ module AnyCable
 
       log_errors!
 
+      use_version_check! if config.version_check_enabled?
+
       @server = AnyCable::Server.new(
         host: config.rpc_host,
         **config.to_grpc_params,
@@ -64,6 +71,8 @@ module AnyCable
 
       run_custom_server_command! unless server_command.nil?
 
+      return if embedded?
+
       begin
         wait_till_terminated
       rescue Interrupt => e
@@ -79,7 +88,7 @@ module AnyCable
 
     def shutdown
       at_stop.each(&:call)
-      server.stop
+      server&.stop
     end
 
     private
@@ -124,7 +133,7 @@ module AnyCable
     end
 
     def print_versions!
-      logger.info "AnyCable version: #{AnyCable::VERSION}"
+      logger.info "AnyCable version: #{AnyCable::VERSION} (proto_version: #{AnyCable::PROTO_VERSION})"
       logger.info "gRPC version: #{GRPC::VERSION}"
     end
 
@@ -162,6 +171,14 @@ module AnyCable
       AnyCable.server_callbacks.each(&:call)
     end
 
+    def use_version_check!
+      require "anycable/middlewares/check_version"
+
+      AnyCable.middleware.use(
+        AnyCable::Middlewares::CheckVersion.new(AnyCable::PROTO_VERSION)
+      )
+    end
+
     def start_health_server!
       @health_server = AnyCable::HealthServer.new(
         server,
@@ -173,7 +190,7 @@ module AnyCable
     end
 
     def start_pubsub!
-      logger.info "Broadcasting Redis channel: #{config.redis_channel}"
+      AnyCable.broadcast_adapter.announce!
     end
 
     # rubocop: disable Metrics/MethodLength, Metrics/AbcSize
@@ -303,9 +320,7 @@ module AnyCable
             -r, --require=path                Location of application file to require, default: "config/environment.rb"
             --server-command=command          Command to run WebSocket server
             --rpc-host=host                   Local address to run gRPC server on, default: "[::]:50051"
-            --redis-url=url                   Redis URL for pub/sub, default: REDIS_URL or "redis://localhost:6379/5"
-            --redis-channel=name              Redis channel for broadcasting, default: "__anycable__"
-            --redis-sentinels=<...hosts>      Redis Sentinel followers addresses (as a comma-separated list), default: nil
+            --broadcast-adapter=type          Pub/sub adapter type for broadcasts, default: redis
             --log-level=level                 Logging level, default: "info"
             --log-file=path                   Path to log file, default: <none> (log to STDOUT)
             --log-grpc                        Enable gRPC logging (disabled by default)
@@ -313,6 +328,15 @@ module AnyCable
             -v, --version                     Print version and exit
             -h, --help                        Show this help
 
+        REDIS PUB/SUB OPTIONS
+            --redis-url=url                   Redis URL for pub/sub, default: REDIS_URL or "redis://localhost:6379/5"
+            --redis-channel=name              Redis channel for broadcasting, default: "__anycable__"
+            --redis-sentinels=<...hosts>      Redis Sentinel followers addresses (as a comma-separated list), default: nil
+
+        HTTP PUB/SUB OPTIONS
+            --http-broadcast-url              HTTP pub/sub endpoint URL, default: "http://localhost:8090/_broadcast"
+            --http-broadcast-secret           HTTP pub/sub authorization secret, default: <none> (disabled)
+
         HTTP HEALTH CHECKER OPTIONS
             --http-health-port=port           Port to run HTTP health server on, default: <none> (disabled)
             --http-health-path=path           Endpoint to server health cheks, default: "/health"

data/lib/anycable/config.rb

@@ -8,11 +8,9 @@ module AnyCable
   class Config < Anyway::Config
     config_name :anycable
 
-    DefaultHostWrapper = Class.new(String)
-
     attr_config(
       ### gRPC options
-      rpc_host: DefaultHostWrapper.new("[::]:50051"),
+      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,
@@ -21,11 +19,18 @@ module AnyCable
       # See https://github.com/grpc/grpc/blob/f526602bff029b8db50a8d57134d72da33d8a752/include/grpc/impl/codegen/grpc_types.h#L292-L315
       rpc_server_args: {},
 
+      ## PubSub
+      broadcast_adapter: :redis,
+
       ### Redis options
       redis_url: ENV.fetch("REDIS_URL", "redis://localhost:6379/5"),
       redis_sentinels: nil,
       redis_channel: "__anycable__",
 
+      ### HTTP broadcasting options
+      http_broadcast_url: "http://localhost:8090/_broadcast",
+      http_broadcast_secret: nil,
+
       ### Logging options
       log_file: nil,
       log_level: :info,
@@ -34,25 +39,44 @@ module AnyCable
 
       ### Health check options
       http_health_port: nil,
-      http_health_path: "/health"
+      http_health_path: "/health",
+
+      ### Misc options
+      version_check_enabled: true
     )
 
+    alias version_check_enabled? version_check_enabled
+
     ignore_options :rpc_server_args
     flag_options :log_grpc, :debug
 
-    def log_level
-      debug ? :debug : @log_level
-    end
+    # Support both anyway_config 1.4 and 2.0.
+    # DEPRECATE: Drop <2.0 support in 1.1
+    if respond_to?(:on_load)
+      on_load { self.debug = debug != false }
 
-    def log_grpc
-      debug || @log_grpc
-    end
+      def log_level
+        debug? ? :debug : super
+      end
 
-    def debug
-      @debug != false
-    end
+      def log_grpc
+        debug? || super
+      end
+    else
+      def log_level
+        debug ? :debug : @log_level
+      end
+
+      def log_grpc
+        debug || @log_grpc
+      end
+
+      def debug
+        @debug != false
+      end
 
-    alias debug? debug
+      alias debug? debug
+    end
 
     def http_health_port_provided?
       !http_health_port.nil? && http_health_port != ""
@@ -71,15 +95,14 @@ module AnyCable
 
     # Build Redis parameters
     def to_redis_params
-      { url: redis_url }.tap do |params|
+      {url: redis_url}.tap do |params|
         next if redis_sentinels.nil?
 
-        raise ArgumentError, "redis_sentinels must be an array; got #{redis_sentinels}" unless
-          redis_sentinels.is_a?(Array)
+        sentinels = Array(redis_sentinels)
 
-        next if redis_sentinels.empty?
+        next if sentinels.empty?
 
-        params[:sentinels] = redis_sentinels.map(&method(:parse_sentinel))
+        params[:sentinels] = sentinels.map(&method(:parse_sentinel))
       end
     end
 
@@ -96,13 +119,13 @@ module AnyCable
     SENTINEL_RXP = /^([\w\-_]*)\:(\d+)$/.freeze
 
     def parse_sentinel(sentinel)
-      return sentinel if sentinel.is_a?(Hash)
+      return sentinel.transform_keys!(&:to_sym) if sentinel.is_a?(Hash)
 
       matches = sentinel.match(SENTINEL_RXP)
 
       raise ArgumentError, "Invalid Sentinel value: #{sentinel}" if matches.nil?
 
-      { "host" => matches[1], "port" => matches[2].to_i }
+      {host: matches[1], port: matches[2].to_i}
     end
   end
 end

data/lib/anycable/exceptions_handling.rb

@@ -11,13 +11,11 @@ module AnyCable
 
       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
+          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
 

data/lib/anycable/health_server.rb

@@ -20,7 +20,7 @@ module AnyCable
 
     attr_reader :grpc_server, :port, :path, :server
 
-    def initialize(grpc_server, port:, path: "/health", logger: AnyCable.logger)
+    def initialize(grpc_server, port:, logger: nil, path: "/health")
       @grpc_server = grpc_server
       @port = port
       @path = path
@@ -48,7 +48,9 @@ module AnyCable
 
     private
 
-    attr_reader :logger
+    def logger
+      @logger ||= AnyCable.logger
+    end
 
     def build_server
       require "webrick"

data/lib/anycable/middleware.rb

@@ -5,13 +5,21 @@ require "grpc"
 module AnyCable
   # Middleware is a wrapper over gRPC interceptors
   # for request/response calls
-  class Middleware < GRPC::Interceptor
+  class Middleware < GRPC::ServerInterceptor
     def request_response(request: nil, call: nil, method: nil)
+      # Call middlewares only for AnyCable service
+      return yield unless method.receiver.is_a?(AnyCable::RPCHandler)
+
       call(request, call, method) do
         yield
       end
     end
 
+    def server_streamer(**kwargs)
+      p kwargs
+      yield
+    end
+
     def call(*)
       raise NotImplementedError
     end