anycable-core 1.1.0.pre1

data/lib/anycable/middlewares/exceptions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Middlewares
+    class Exceptions < AnyCable::Middleware
+      def call(method_name, request)
+        yield
+      rescue => exp
+        notify_exception(exp, method_name, request)
+
+        response_class(method_name).new(
+          status: AnyCable::Status::ERROR,
+          error_msg: exp.message
+        )
+      end
+
+      private
+
+      def notify_exception(exp, method_name, message)
+        AnyCable::ExceptionsHandling.notify(exp, method_name.to_s, message.to_h)
+      end
+
+      def response_class(method_name)
+        case method_name
+        when :connect
+          AnyCable::ConnectionResponse
+        when :disconnect
+          AnyCable::DisconnectResponse
+        else
+          AnyCable::CommandResponse
+        end
+      end
+    end
+  end
+end

data/lib/anycable/protos/rpc_pb.rb

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

data/lib/anycable/rpc.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "anycable/protos/rpc_pb"
+
+require "anycable/rpc/handler"
+
+# 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
+      state_ = cstate
+      if state_
+        state_[SESSION_KEY] = val
+      end
+    end
+
+    def session
+      state_ = cstate
+      if state_
+        state_[SESSION_KEY]
+      end
+    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/handler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "anycable/rpc/handlers/connect"
+require "anycable/rpc/handlers/disconnect"
+require "anycable/rpc/handlers/command"
+
+module AnyCable
+  module RPC
+    # Generic RPC handler
+    class Handler
+      include Handlers::Connect
+      include Handlers::Disconnect
+      include Handlers::Command
+
+      def initialize(middleware: AnyCable.middleware)
+        @middleware = middleware
+        @commands = {}
+      end
+
+      def handle(cmd, data)
+        middleware.call(cmd, data) do
+          send(cmd, data)
+        end
+      end
+
+      private
+
+      attr_reader :commands, :middleware
+
+      def build_socket(env:)
+        AnyCable::Socket.new(env: env)
+      end
+
+      def build_env_response(socket)
+        AnyCable::EnvResponse.new(
+          cstate: socket.cstate.changed_fields,
+          istate: socket.istate.changed_fields
+        )
+      end
+
+      def logger
+        AnyCable.logger
+      end
+
+      def factory
+        AnyCable.connection_factory
+      end
+    end
+  end
+end

data/lib/anycable/rpc/handlers/command.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RPC
+    module Handlers
+      module Command
+        def command(message)
+          logger.debug("RPC Command: #{message.inspect}")
+
+          socket = build_socket(env: message.env)
+
+          connection = factory.call(
+            socket,
+            identifiers: message.connection_identifiers
+          )
+
+          result = connection.handle_channel_command(
+            message.identifier,
+            message.command,
+            message.data
+          )
+
+          AnyCable::CommandResponse.new(
+            status: result ? AnyCable::Status::SUCCESS : AnyCable::Status::FAILURE,
+            disconnect: socket.closed?,
+            stop_streams: socket.stop_streams?,
+            streams: socket.streams[:start],
+            stopped_streams: socket.streams[:stop],
+            transmissions: socket.transmissions,
+            env: build_env_response(socket)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rpc/handlers/connect.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RPC
+    module Handlers
+      module Connect
+        def connect(request)
+          logger.debug("RPC Connect: #{request.inspect}")
+
+          socket = build_socket(env: request.env)
+
+          connection = factory.call(socket)
+
+          connection.handle_open
+
+          if socket.closed?
+            AnyCable::ConnectionResponse.new(
+              status: AnyCable::Status::FAILURE,
+              transmissions: socket.transmissions
+            )
+          else
+            AnyCable::ConnectionResponse.new(
+              status: AnyCable::Status::SUCCESS,
+              identifiers: connection.identifiers_json,
+              transmissions: socket.transmissions,
+              env: build_env_response(socket)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rpc/handlers/disconnect.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module RPC
+    module Handlers
+      module Disconnect
+        def disconnect(request)
+          logger.debug("RPC Disconnect: #{request.inspect}")
+
+          socket = build_socket(env: request.env)
+
+          connection = factory.call(
+            socket,
+            identifiers: request.identifiers,
+            subscriptions: request.subscriptions
+          )
+
+          if connection.handle_close
+            AnyCable::DisconnectResponse.new(status: AnyCable::Status::SUCCESS)
+          else
+            AnyCable::DisconnectResponse.new(status: AnyCable::Status::FAILURE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rspec.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Utils for testing AnyCable and its plugins
+require "anycable/rspec/rpc_command_context"

data/lib/anycable/rspec/rpc_command_context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "anycable:rpc:command" do
+  let(:url) { "ws://example.anycable.com/cable" }
+  let(:headers) { {} }
+  let(:env) { AnyCable::Env.new(url: url, headers: headers) }
+  let(:command) { "" }
+  let(:channel_id) { "" }
+  let(:identifiers) { {} }
+  let(:data) { {} }
+
+  let(:request) do
+    AnyCable::CommandMessage.new(
+      command: command,
+      identifier: channel_id,
+      connection_identifiers: identifiers.to_json,
+      data: data.to_json,
+      env: env
+    )
+  end
+end

data/lib/anycable/socket.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module AnyCable
+  # Socket mock to be used with application connection
+  class Socket
+    # Represents the per-connection store
+    # (for example, used to keep session beetween RPC calls)
+    class State
+      attr_reader :dirty_keys, :source
+
+      def initialize(from)
+        @source = from
+        @dirty_keys = nil
+      end
+
+      def read(key)
+        source&.[](key)
+      end
+
+      alias_method :[], :read
+
+      def write(key, val)
+        return if source&.[](key) == val
+
+        @source ||= {}
+
+        keys = (@dirty_keys ||= [])
+        keys << key
+
+        source[key] = val
+      end
+
+      alias_method :[]=, :write
+
+      def changed_fields
+        return unless source
+
+        keys = dirty_keys
+        return if keys.nil?
+
+        source.slice(*keys)
+      end
+    end
+
+    attr_reader :transmissions
+
+    def initialize(env:)
+      @transmissions = []
+      @request_env = env
+    end
+
+    def transmit(websocket_message)
+      transmissions << websocket_message
+    end
+
+    def subscribe(_channel, broadcasting)
+      streams[:start] << broadcasting
+    end
+
+    def unsubscribe(_channel, broadcasting)
+      streams[:stop] << broadcasting
+    end
+
+    def unsubscribe_from_all(_channel)
+      @stop_all_streams = true
+    end
+
+    def streams
+      @streams ||= {start: [], stop: []}
+    end
+
+    def close
+      @closed = true
+      @streams&.clear
+      @stop_all_streams = true
+    end
+
+    def closed?
+      @closed == true
+    end
+
+    def stop_streams?
+      @stop_all_streams == true
+    end
+
+    def session
+      cstate.read(SESSION_KEY)
+    end
+
+    def session=(val)
+      cstate.write(SESSION_KEY, val)
+    end
+
+    def env
+      return @env if defined?(@env)
+
+      @env = build_rack_env
+    end
+
+    def istate
+      return @istate if defined?(@istate)
+
+      @istate = env["anycable.istate"] = State.new(env["anycable.raw_istate"])
+    end
+
+    def cstate
+      return @cstate if defined?(@cstate)
+
+      @cstate = env["anycable.cstate"] = State.new(env["anycable.raw_cstate"])
+    end
+
+    private
+
+    attr_reader :request_env
+
+    # Build Rack env from request
+    def build_rack_env
+      uri = URI.parse(request_env.url)
+
+      env = base_rack_env
+      env.merge!({
+        "PATH_INFO" => uri.path,
+        "QUERY_STRING" => uri.query,
+        "SERVER_NAME" => uri.host,
+        "SERVER_PORT" => uri.port,
+        "HTTP_HOST" => uri.host,
+        "REMOTE_ADDR" => request_env.headers.delete("REMOTE_ADDR"),
+        "rack.url_scheme" => uri.scheme&.sub(/^ws/, "http"),
+        # AnyCable specific fields
+        "anycable.raw_cstate" => request_env.cstate&.to_h,
+        "anycable.raw_istate" => request_env.istate&.to_h
+      }.delete_if { |_k, v| v.nil? })
+
+      env.merge!(build_headers(request_env.headers))
+    end
+
+    def base_rack_env
+      # Minimum required variables according to Rack Spec
+      # (not all of them though, just those enough for Action Cable to work)
+      # See https://rubydoc.info/github/rack/rack/master/file/SPEC
+      # and https://github.com/rack/rack/blob/master/lib/rack/lint.rb
+      {
+        "REQUEST_METHOD" => "GET",
+        "SCRIPT_NAME" => "",
+        "PATH_INFO" => "/",
+        "QUERY_STRING" => "",
+        "SERVER_NAME" => "",
+        "SERVER_PORT" => "80",
+        "rack.url_scheme" => "http",
+        "rack.input" => StringIO.new("", "r").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) },
+        "rack.version" => ::Rack::VERSION,
+        "rack.errors" => StringIO.new("").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) },
+        "rack.multithread" => true,
+        "rack.multiprocess" => false,
+        "rack.run_once" => false,
+        "rack.hijack?" => false
+      }
+    end
+
+    def build_headers(headers)
+      headers.each_with_object({}) do |header, obj|
+        k, v = *header
+        k = k.upcase
+        k.tr!("-", "_")
+        obj["HTTP_#{k}"] = v
+      end
+    end
+  end
+end