anycable 1.0.1 → 1.1.0

data/lib/anycable/broadcast_adapters.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "anycable/broadcast_adapters/base"
-
-module AnyCable
-  module BroadcastAdapters # :nodoc:
-    module_function
-
-    # rubocop: disable Metrics/AbcSize, Metrics/MethodLength
-    def lookup_adapter(args)
-      adapter, options = Array(args)
-      path_to_adapter = "anycable/broadcast_adapters/#{adapter}"
-      adapter_class_name = adapter.to_s.split("_").map(&:capitalize).join
-
-      unless BroadcastAdapters.const_defined?(adapter_class_name, false)
-        begin
-          require path_to_adapter
-        rescue LoadError => e
-          # We couldn't require the adapter itself.
-          if e.path == path_to_adapter
-            raise e.class, "Couldn't load the '#{adapter}' broadcast adapter for AnyCable",
-              e.backtrace
-          # Bubbled up from the adapter require.
-          else
-            raise e.class, "Error loading the '#{adapter}' broadcast adapter for AnyCable",
-              e.backtrace
-          end
-        end
-      end
-
-      BroadcastAdapters.const_get(adapter_class_name, false).new(**(options || {}))
-    end
-    # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
-  end
-end

data/lib/anycable/broadcast_adapters/base.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module BroadcastAdapters
-    class Base
-      def raw_broadcast(_data)
-        raise NotImplementedError
-      end
-
-      def broadcast(stream, payload)
-        raw_broadcast({stream: stream, data: payload}.to_json)
-      end
-
-      def broadcast_command(command, **payload)
-        raw_broadcast({command: command, payload: payload}.to_json)
-      end
-
-      def announce!
-        logger.info "Broadcasting via #{self.class.name}"
-      end
-
-      private
-
-      def logger
-        AnyCable.logger
-      end
-    end
-  end
-end

data/lib/anycable/broadcast_adapters/http.rb

@@ -1,130 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-gem "redis", ">= 3"
-
-require "redis"
-require "json"
-
-module AnyCable
-  module BroadcastAdapters
-    # Redis adapter for broadcasting.
-    #
-    # Example:
-    #
-    #   AnyCable.broadast_adapter = :redis
-    #
-    # It uses Redis configuration from global AnyCable config
-    # by default.
-    #
-    # You can override these params:
-    #
-    #   AnyCable.broadcast_adapter = :redis, url: "redis://my_redis", channel: "_any_cable_"
-    class Redis < Base
-      attr_reader :redis_conn, :channel
-
-      def initialize(
-        channel: AnyCable.config.redis_channel,
-        **options
-      )
-        options = AnyCable.config.to_redis_params.merge(options)
-        @redis_conn = ::Redis.new(options)
-        @channel = channel
-      end
-
-      def raw_broadcast(payload)
-        redis_conn.publish(channel, payload)
-      end
-
-      def announce!
-        logger.info "Broadcasting Redis channel: #{channel}"
-      end
-    end
-  end
-end

data/lib/anycable/cli.rb

@@ -1,353 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-require "anycable"
-
-$stdout.sync = true
-
-module AnyCable
-  # Command-line interface for running AnyCable gRPC server
-  # rubocop:disable Metrics/ClassLength
-  class CLI
-    # (not-so-big) List of common boot files for
-    # different applications
-    APP_CANDIDATES = %w[
-      ./config/anycable.rb
-      ./config/environment.rb
-    ].freeze
-
-    # Wait for external process termination (s)
-    WAIT_PROCESS = 2
-
-    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 = [])
-      @at_stop = []
-
-      extra_options = parse_cli_options!(args)
-
-      # Boot app first, 'cause it might change
-      # configuration, loggin settings, etc.
-      boot_app! unless embedded?
-
-      parse_gem_options!(extra_options)
-
-      configure_server!
-
-      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}" unless embedded?
-
-      verify_connection_factory!
-
-      log_grpc! if config.log_grpc
-
-      log_errors!
-
-      use_version_check! if config.version_check_enabled?
-
-      @server = AnyCable::Server.new(
-        host: config.rpc_host,
-        **config.to_grpc_params,
-        interceptors: AnyCable.middleware.to_a
-      )
-
-      # Make sure middlewares are not adding after server has started
-      AnyCable.middleware.freeze
-
-      start_health_server! if config.http_health_port_provided?
-      start_pubsub!
-
-      server.start
-
-      run_custom_server_command! unless server_command.nil?
-
-      return if embedded?
-
-      begin
-        wait_till_terminated
-      rescue Interrupt => e
-        logger.info "Stopping... #{e.message}"
-
-        shutdown
-
-        logger.info "Stopped. Good-bye!"
-        exit(0)
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-    def shutdown
-      at_stop.each(&:call)
-      server&.stop
-    end
-
-    private
-
-    attr_reader :boot_file, :server_command
-
-    def config
-      AnyCable.config
-    end
-
-    def logger
-      AnyCable.logger
-    end
-
-    def at_stop
-      if block_given?
-        @at_stop << Proc.new
-      else
-        @at_stop
-      end
-    end
-
-    def wait_till_terminated
-      self_read = setup_signals
-
-      while readable_io = IO.select([self_read]) # rubocop:disable Lint/AssignmentInCondition
-        signal = readable_io.first[0].gets.strip
-        raise Interrupt, "SIG#{signal} received"
-      end
-    end
-
-    def setup_signals
-      self_read, self_write = IO.pipe
-
-      %w[INT TERM].each do |signal|
-        trap signal do
-          self_write.puts signal
-        end
-      end
-
-      self_read
-    end
-
-    def print_versions!
-      logger.info "AnyCable version: #{AnyCable::VERSION} (proto_version: #{AnyCable::PROTO_VERSION})"
-      logger.info "gRPC version: #{GRPC::VERSION}"
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def boot_app!
-      @boot_file ||= try_detect_app
-
-      if boot_file.nil?
-        $stdout.puts(
-          "Couldn't find an application to load. " \
-          "Please specify the explicit path via -r option, e.g:" \
-          " anycable -r ./config/boot.rb or anycable -r /app/config/load_me.rb"
-        )
-        exit(1)
-      end
-
-      begin
-        require boot_file
-      rescue LoadError => e
-        $stdout.puts(
-          "Failed to load application: #{e.message}. " \
-          "Please specify the explicit path via -r option, e.g:" \
-          " anycable -r ./config/boot.rb or anycable -r /app/config/load_me.rb"
-        )
-        exit(1)
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def try_detect_app
-      APP_CANDIDATES.detect { |path| File.exist?(path) }
-    end
-
-    def configure_server!
-      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,
-        **config.to_http_health_params
-      )
-      health_server.start
-
-      at_stop { health_server.stop }
-    end
-
-    def start_pubsub!
-      AnyCable.broadcast_adapter.announce!
-    end
-
-    # rubocop: disable Metrics/MethodLength, Metrics/AbcSize
-    def run_custom_server_command!
-      pid = nil
-      stopped = false
-      command_thread = Thread.new do
-        pid = Process.spawn(server_command)
-        logger.info "Started command: #{server_command} (pid: #{pid})"
-
-        Process.wait pid
-        pid = nil
-        raise Interrupt, "Server command exit unexpectedly" unless stopped
-      end
-
-      command_thread.abort_on_exception = true
-
-      at_stop do
-        stopped = true
-        next if pid.nil?
-
-        Process.kill("SIGTERM", pid)
-
-        logger.info "Wait till process #{pid} stop..."
-
-        tick = 0
-
-        loop do
-          tick += 0.2
-          break if tick > WAIT_PROCESS
-
-          if pid.nil?
-            logger.info "Process #{pid} stopped."
-            break
-          end
-        end
-      end
-    end
-    # rubocop: enable Metrics/MethodLength, Metrics/AbcSize
-
-    def log_grpc!
-      ::GRPC.define_singleton_method(:logger) { AnyCable.logger }
-    end
-
-    # Add default exceptions handler: print error message to log
-    def log_errors!
-      if AnyCable.config.debug?
-        # Print error with backtrace in debug mode
-        AnyCable.capture_exception do |e|
-          AnyCable.logger.error("#{e.message}:\n#{e.backtrace.take(20).join("\n")}")
-        end
-      else
-        AnyCable.capture_exception { |e| AnyCable.logger.error(e.message) }
-      end
-    end
-
-    def verify_connection_factory!
-      return if AnyCable.connection_factory
-
-      logger.error "AnyCable connection factory must be configured. " \
-                   "Make sure you've required a gem (e.g. `anycable-rails`) or " \
-                   "configured `AnyCable.connection_factory` yourself"
-      exit(1)
-    end
-
-    def parse_gem_options!(args)
-      config.parse_options!(args)
-    rescue OptionParser::InvalidOption => e
-      $stdout.puts e.message
-      $stdout.puts "Run anycable -h to see available options"
-      exit(1)
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def parse_cli_options!(args)
-      unknown_opts = []
-
-      parser = build_cli_parser
-
-      begin
-        parser.parse!(args)
-      rescue OptionParser::InvalidOption => e
-        unknown_opts << e.args[0]
-        unless args.size.zero?
-          unknown_opts << args.shift unless args.first.start_with?("-")
-          retry
-        end
-      end
-
-      unknown_opts
-    end
-
-    def build_cli_parser
-      OptionParser.new do |o|
-        o.on "-v", "--version", "Print version and exit" do |_arg|
-          $stdout.puts "AnyCable v#{AnyCable::VERSION}"
-          exit(0)
-        end
-
-        o.on "-r", "--require [PATH|DIR]", "Location of application file to require" do |arg|
-          @boot_file = arg
-        end
-
-        o.on "--server-command VALUE", "Command to run WebSocket server" do |arg|
-          @server_command = arg
-        end
-
-        o.on_tail "-h", "--help", "Show help" do
-          $stdout.puts usage
-          exit(0)
-        end
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def usage
-      <<~HELP
-        anycable: run AnyCable gRPC server (https://anycable.io)
-
-        VERSION
-          anycable/#{AnyCable::VERSION}
-
-        USAGE
-          $ anycable [options]
-
-        BASIC OPTIONS
-            -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"
-            --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)
-            --debug                           Turn on verbose logging ("debug" level and gRPC logging on)
-            -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"
-
-        GRPC OPTIONS
-            --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
-      HELP
-    end
-  end
-  # rubocop:enable Metrics/ClassLength
-end