anycable 1.0.3 → 1.1.0.pre1

data/lib/anycable/config.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "anyway_config"
-require "grpc"
-
-require "uri"
-
-module AnyCable
-  # AnyCable configuration.
-  class Config < Anyway::Config
-    config_name :anycable
-
-    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: {},
-
-      ## 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,
-      log_grpc: false,
-      debug: false, # Shortcut to enable GRPC logging and debug level
-
-      ### Health check options
-      http_health_port: nil,
-      http_health_path: "/health",
-
-      ### Misc options
-      version_check_enabled: true
-    )
-
-    alias_method :version_check_enabled?, :version_check_enabled
-
-    ignore_options :rpc_server_args
-    flag_options :log_grpc, :debug
-
-    # 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_level
-        debug? ? :debug : super
-      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_method :debug?, :debug
-    end
-
-    def http_health_port_provided?
-      !http_health_port.nil? && http_health_port != ""
-    end
-
-    # 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
-
-    # Build Redis parameters
-    def to_redis_params
-      {url: redis_url}.tap do |params|
-        next if redis_sentinels.nil? || redis_sentinels.empty?
-
-        sentinels = Array(redis_sentinels)
-
-        next if sentinels.empty?
-
-        params[:sentinels] = sentinels.map(&method(:parse_sentinel))
-      end.tap do |params|
-        next unless redis_url.match?(/rediss:\/\//)
-
-        params[:ssl_params] = {verify_mode: OpenSSL::SSL::VERIFY_NONE}
-      end
-    end
-
-    # Build HTTP health server parameters
-    def to_http_health_params
-      {
-        port: http_health_port,
-        path: http_health_path
-      }
-    end
-
-    private
-
-    def parse_sentinel(sentinel)
-      return sentinel.transform_keys!(&:to_sym) if sentinel.is_a?(Hash)
-
-      uri = URI.parse("redis://#{sentinel}")
-
-      {host: uri.host, port: uri.port}.tap do |opts|
-        opts[:password] = uri.password if uri.password
-      end
-    end
-  end
-end

data/lib/anycable/exceptions_handling.rb

@@ -1,35 +0,0 @@
-# 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/health_server.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-    attr_reader :grpc_server, :port, :path, :server
-
-    def initialize(grpc_server, port:, logger: nil, path: "/health")
-      @grpc_server = grpc_server
-      @port = port
-      @path = path
-      @logger = logger
-      @server = build_server
-    end
-
-    def start
-      return if running?
-
-      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
-
-    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 |server|
-        server.mount_proc path do |_, res|
-          res.status, res.body = grpc_server.running? ? SUCCESS_RESPONSE : FAILURE_RESPONSE
-        end
-      end
-    end
-  end
-end

data/lib/anycable/middleware.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "grpc"
-
-module AnyCable
-  # Middleware is a wrapper over gRPC interceptors
-  # for request/response calls
-  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
-  end
-end

data/lib/anycable/middleware_chain.rb

@@ -1,58 +0,0 @@
-# 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/middlewares/check_version.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module Middlewares
-    # Checks that RPC client version is compatible with
-    # the current RPC proto version
-    class CheckVersion < Middleware
-      attr_reader :version
-
-      def initialize(version)
-        @version = version
-      end
-
-      def call(_request, call, _method)
-        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/rpc.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "anycable/rpc/rpc_pb"
-require "anycable/rpc/rpc_services_pb"
-
-# Extend some PB auto-generated classes
-module AnyCable
-  # Current RPC proto version (used for compatibility checks)
-  PROTO_VERSION = "v1"
-  SESSION_KEY = "_s_"
-
-  # Add setters/getter for cstate field
-  module WithConnectionState
-    def initialize(session: nil, **other)
-      if session
-        other[:cstate] ||= {}
-        other[:cstate][SESSION_KEY] = session
-      end
-      super(**other)
-    end
-
-    def session=(val)
-      self.cstate = {} unless cstate
-      cstate[SESSION_KEY] = val
-    end
-
-    def session
-      cstate[SESSION_KEY]
-    end
-
-    def cstate
-      env.cstate
-    end
-
-    def cstate=(val)
-      env.cstate = val
-    end
-
-    def istate
-      env.istate
-    end
-
-    def istate=(val)
-      env.istate = val
-    end
-  end
-
-  # Status predicates
-  module StatusPredicates
-    def success?
-      status == :SUCCESS
-    end
-
-    def failure?
-      status == :FAILURE
-    end
-
-    def error?
-      status == :ERROR
-    end
-  end
-
-  class ConnectionResponse
-    prepend WithConnectionState
-    include StatusPredicates
-  end
-
-  class CommandMessage
-    prepend WithConnectionState
-  end
-
-  class CommandResponse
-    prepend WithConnectionState
-    include StatusPredicates
-  end
-
-  class DisconnectRequest
-    prepend WithConnectionState
-  end
-
-  class DisconnectResponse
-    include StatusPredicates
-  end
-end

data/lib/anycable/rpc/rpc_pb.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: rpc.proto
-
-require "google/protobuf"
-
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_file("rpc.proto", syntax: :proto3) do
-    add_message "anycable.Env" do
-      optional :url, :string, 1
-      map :headers, :string, :string, 2
-      map :cstate, :string, :string, 3
-      map :istate, :string, :string, 4
-    end
-    add_message "anycable.EnvResponse" do
-      map :cstate, :string, :string, 1
-      map :istate, :string, :string, 2
-    end
-    add_message "anycable.ConnectionRequest" do
-      optional :env, :message, 3, "anycable.Env"
-    end
-    add_message "anycable.ConnectionResponse" do
-      optional :status, :enum, 1, "anycable.Status"
-      optional :identifiers, :string, 2
-      repeated :transmissions, :string, 3
-      optional :error_msg, :string, 4
-      optional :env, :message, 5, "anycable.EnvResponse"
-    end
-    add_message "anycable.CommandMessage" do
-      optional :command, :string, 1
-      optional :identifier, :string, 2
-      optional :connection_identifiers, :string, 3
-      optional :data, :string, 4
-      optional :env, :message, 5, "anycable.Env"
-    end
-    add_message "anycable.CommandResponse" do
-      optional :status, :enum, 1, "anycable.Status"
-      optional :disconnect, :bool, 2
-      optional :stop_streams, :bool, 3
-      repeated :streams, :string, 4
-      repeated :transmissions, :string, 5
-      optional :error_msg, :string, 6
-      optional :env, :message, 7, "anycable.EnvResponse"
-      repeated :stopped_streams, :string, 8
-    end
-    add_message "anycable.DisconnectRequest" do
-      optional :identifiers, :string, 1
-      repeated :subscriptions, :string, 2
-      optional :env, :message, 5, "anycable.Env"
-    end
-    add_message "anycable.DisconnectResponse" do
-      optional :status, :enum, 1, "anycable.Status"
-      optional :error_msg, :string, 2
-    end
-    add_enum "anycable.Status" do
-      value :ERROR, 0
-      value :SUCCESS, 1
-      value :FAILURE, 2
-    end
-  end
-end
-
-module AnyCable
-  Env = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.Env").msgclass
-  EnvResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.EnvResponse").msgclass
-  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
-  CommandResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.CommandResponse").msgclass
-  DisconnectRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.DisconnectRequest").msgclass
-  DisconnectResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.DisconnectResponse").msgclass
-  Status = Google::Protobuf::DescriptorPool.generated_pool.lookup("anycable.Status").enummodule
-end