anycable 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 281158d65c6c109cf2b79f1bc2094e97ff2a35a3
-  data.tar.gz: b66137f82d301f38d0ebecfce186175848748a26
+  metadata.gz: 1728535555e8fb2b4117c3acc46a37c99f854b20
+  data.tar.gz: 50344774fb497a690c610a6e4d2758ab8237aa89
 SHA512:
-  metadata.gz: 24a693ba7d9bf4378d7b990d520289721565cec10f324849c4f2c74cbb0f09204a5eb5fd65babea3e2752e9d91696d58b1a875240c2aa00dd5c846483addf02f
-  data.tar.gz: 06fd5a2620adaada64272eaca7390a73d9e47a1b7f9df1f2192b2a0c916e2080c91a1ef5746dbcc269bdb82bbba33bdd288707d2ff39b80076110ac2eabd6fc6
+  metadata.gz: d1679838e7116f199f29e1ef51d156422da51daa52c6f6b61e42adf0d1d17e36c47f45614fa05f400757a3811d80e03ca26196cca1055c314a3f7b97b9dec523
+  data.tar.gz: 3cf4eb06da615053c914b86da466d77f3f4f9bc84265d3fcb4079ebd8e30ce451d9bbd2cf5fa62637f543bfc3fbe0f5ba21594e0870bef9e6c1fe6b53ad70c66

data/.rubocop.yml

@@ -9,6 +9,7 @@ AllCops:
     - 'spec/dummy/**/*'
     - 'tmp/**/*'
     - 'bench/**/*'
+    - 'lib/anycable/rpc/**/*'
   DisplayCopNames: true
   StyleGuideCopsOnly: false
   TargetRubyVersion: 2.3

data/Makefile

@@ -0,0 +1,4 @@
+all: build
+
+build:
+	protoc --ruby_out=./lib/anycable/rpc --grpc_out=./lib/anycable/rpc --proto_path=./protos --plugin=protoc-gen-grpc=`which grpc_tools_ruby_protoc_plugin.rb` ./protos/rpc.proto

data/README.md

@@ -2,15 +2,87 @@
 
 # Anycable
 
+AnyCable allows you to use any WebSocket server (written in any language) as a replacement for built-in Ruby ActionCable server.
+
+With AnyCable you can use channels, client-side JS, broadcasting - (almost) all that you can do with ActionCable.
+
+You can even use ActionCable in development and not be afraid of compatibility issues.
+
+## Requirements
+
+- Ruby ~> 2.3;
+- Rails ~> 5.0;
+- Redis
+
+## How It Works?
+
 TBD
 
-## Usage
+## Compatible WebSocket servers
 
 TBD
 
+
 ## Installation
 
-TBD
+Add Anycable to your application's Gemfile:
+
+```ruby
+gem 'anycable', group: :production
+```
+
+And then run:
+
+```shell
+rails generate anycable
+```
+
+to create executable.
+
+You can use _built-in_ ActionCable for test and development.
+
+## Configuration
+
+Add `config/anycable.yml`if you want to override defaults (see below):
+
+```yml
+production:
+  # gRPC server host and port
+  rpc_host: "localhost:50051"
+  # Redis URL (for broadcasting) 
+  redis_url: "redis://localhost:6379/2"
+  # Redis channel name
+  redis_channel: "anycable"
+
+```
+
+Anycable uses [anyway_config](https://github.com/palkan/anyway_config), thus it is also possible to set configuration variables through `secrets.yml` or environment vars.
+
+## Usage
+
+Run Anycable server:
+
+```ruby
+bundle exec anycable
+```
+
+## ActionCable Compatibility
+
+
+Feature                  | Status 
+-------------------------|--------
+Connection Identifiers   | +
+Connection Request (cookies, params) | +
+Disconnect Handling | coming soon
+Subscribe to channels | +
+Parameterized subscriptions | coming soon
+Unsubscribe from channels | +
+[Subscription Instance Variables](http://edgeapi.rubyonrails.org/classes/ActionCable/Channel/Streams.html) | -
+Performing Channel Actions | +
+Streaming | +
+[Custom stream callbacks](http://edgeapi.rubyonrails.org/classes/ActionCable/Channel/Streams.html) | -
+Broadcasting | +
+
 
 ## Contributing
 

data/Rakefile

@@ -2,3 +2,5 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/anycable.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "rails", "~> 5"
+  spec.add_dependency "anyway_config", "~>0.4.0"
+  spec.add_dependency "grpc", "~> 1.0"
+  spec.add_dependency "redis", "~> 3.0"
 
   spec.add_development_dependency "bundler", "~> 1"
   spec.add_development_dependency "rake", "~> 10.0"

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rails"
+require "anycable/server"
+
+require "pry"
+Pry.start

data/lib/anycable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require "anycable/version"
+require "anycable/config"
+require "anycable/actioncable/server"
 
 # Anycable allows to use any websocket service (written in any language) as a replacement
 # for ActionCable server.
@@ -9,4 +11,19 @@ require "anycable/version"
 #
 # Broadcasting messages to WS is done through Redis Pub/Sub.
 module Anycable
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= Anycable.config.debug ? Logger.new(STDOUT) : Logger.new('/dev/null')
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield(config) if block_given?
+  end
 end

data/lib/anycable/actioncable/channel.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "action_cable"
+
+module ActionCable
+  module Channel
+    class Base # :nodoc:
+      alias do_subscribe subscribe_to_channel
+
+      public :do_subscribe, :subscription_rejected?
+
+      def subscribe_to_channel
+        # noop
+      end
+
+      attr_reader :stop_streams
+
+      def stream_from(broadcasting, callback = nil, coder: nil)
+        raise ArgumentError('Unsupported') if callback.present? || coder.present? || block_given?
+        streams << broadcasting
+      end
+
+      def stop_all_streams
+        @stop_streams = true
+      end
+
+      def streams
+        @streams ||= []
+      end
+
+      def stop_streams?
+        stop_streams == true
+      end
+
+      def delegate_connection_identifiers
+        connection.identifiers.each do |identifier|
+          define_singleton_method(identifier) do
+            connection.fetch_identifier(identifier)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/actioncable/connection.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require "action_cable"
+
+module ActionCable
+  module Connection
+    class Base # :nodoc:
+      attr_reader :transmissions
+
+      def initialize(env: {}, identifiers_json: '{}')
+        @ids = ActiveSupport::JSON.decode(identifiers_json)
+        @cached_ids = {}
+        @env = env
+        @coder = ActiveSupport::JSON
+        @closed = false
+        @transmissions = []
+        @subscriptions = ActionCable::Connection::Subscriptions.new(self)
+      end
+
+      def handle_open
+        connect if respond_to?(:connect)
+        send_welcome_message
+      rescue ActionCable::Connection::Authorization::UnauthorizedError
+        close
+      end
+
+      def handle_close
+        # subscriptions.unsubscribe_from_all
+        disconnect if respond_to?(:disconnect)
+      end
+
+      def close
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      def transmit(cable_message)
+        transmissions << encode(cable_message)
+      end
+
+      def dispose
+        @closed = false
+        transmissions.clear
+      end
+
+      # Generate identifiers info.
+      # Converts GlobalID compatible vars to corresponding global IDs params.
+      def identifiers_hash
+        identifiers.each_with_object({}) do |id, acc|
+          obj = instance_variable_get("@#{id}")
+          next unless obj
+          acc[id] = obj.try(:to_gid_param) || obj
+        end
+      end
+
+      # Fetch identifier and deserialize if neccessary
+      def fetch_identifier(name)
+        @cached_ids[name] ||= @cached_ids.fetch(name) do
+          val = @ids[name.to_s]
+          next val unless val.is_a?(String)
+          GlobalID::Locator.locate(val) || val
+        end
+      end
+
+      def logger
+        ::Rails.logger
+      end
+    end
+  end
+end

data/lib/anycable/actioncable/server.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require "action_cable"
+require "anycable/pubsub"
+
+module ActionCable
+  module Server
+    # Override pubsub for ActionCable
+    class Base
+      def pubsub
+        @any_pubsub ||= Anycable::PubSub.new
+      end
+    end
+  end
+end

data/lib/anycable/config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require "anyway"
+
+module Anycable
+  # Anycable configuration
+  class Config < Anyway::Config
+    config_name :anycable
+
+    attr_config rpc_host: "localhost:50051",
+                redis_url: "redis://localhost:6379/5",
+                redis_channel: "anycable",
+                debug: false
+  end
+end

data/lib/anycable/pubsub.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require "redis"
+
+module Anycable
+  # PubSub for broadcasting
+  class PubSub
+    attr_reader :redis_conn
+
+    def initialize
+      @redis_conn = Redis.new(url: Anycable.config.redis_url)
+    end
+
+    def broadcast(channel, payload)
+      redis_conn.publish(
+        Anycable.config.redis_channel,
+        { stream: channel, data: payload }.to_json
+      )
+    end
+  end
+end

data/lib/anycable/rpc/rpc.rb

@@ -0,0 +1,51 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: rpc.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "anycable.ConnectionRequest" do
+    optional :path, :string, 1
+    map :headers, :string, :string, 2
+  end
+  add_message "anycable.ConnectionResponse" do
+    optional :status, :enum, 1, "anycable.Status"
+    optional :identifiers, :string, 2
+    repeated :transmissions, :string, 3
+  end
+  add_message "anycable.CommandMessage" do
+    optional :command, :string, 1
+    optional :identifier, :string, 2
+    optional :connection_identifiers, :string, 3
+    optional :data, :string, 4
+  end
+  add_message "anycable.CommandResponse" do
+    optional :status, :enum, 1, "anycable.Status"
+    optional :disconnect, :bool, 2
+    optional :stop_streams, :bool, 3
+    optional :stream_from, :bool, 4
+    optional :stream_id, :string, 5
+    repeated :transmissions, :string, 6
+  end
+  add_message "anycable.DisconnectRequest" do
+    optional :identifiers, :string, 1
+    repeated :subscriptions, :string, 2
+  end
+  add_message "anycable.DisconnectResponse" do
+    optional :status, :enum, 1, "anycable.Status"
+  end
+  add_enum "anycable.Status" do
+    value :ERROR, 0
+    value :SUCCESS, 1
+  end
+end
+
+module Anycable
+  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/rpc_services.rb

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

data/lib/anycable/rpc_handler.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+require 'anycable/actioncable/connection'
+require 'anycable/actioncable/channel'
+require 'anycable/rpc/rpc'
+require 'anycable/rpc/rpc_services'
+
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/MethodLength
+module Anycable
+  # RPC service handler
+  class RPCHandler < Anycable::RPC::Service
+    # Handle connection request from WebSocket server
+    def connect(request, _unused_call)
+      logger.debug("RPC Connect: #{request}")
+
+      connection = ApplicationCable::Connection.new(
+        env:
+          path_env(request.path).merge(
+            'HTTP_COOKIE' => request.headers['Cookie']
+          )
+      )
+
+      connection.handle_open
+
+      if connection.closed?
+        Anycable::ConnectionResponse.new(status: Anycable::Status::ERROR)
+      else
+        Anycable::ConnectionResponse.new(
+          status: Anycable::Status::SUCCESS,
+          identifiers: connection.identifiers_hash.to_json,
+          transmissions: connection.transmissions
+        )
+      end
+    end
+
+    def disconnect(request, _unused_call)
+      logger.debug("RPC Disonnect: #{request}")
+      # TODO: implement disconnect logic
+      Anycable::DisconnectResponse.new(status: Anycable::Status::SUCCESS)
+    end
+
+    def subscribe(message, _unused_call)
+      logger.debug("RPC Subscribe: #{message}")
+      connection = ApplicationCable::Connection.new(
+        identifiers_json: message.connection_identifiers
+      )
+
+      channel = channel_for(connection, message)
+
+      if channel.present?
+        channel.do_subscribe
+        if channel.subscription_rejected?
+          Anycable::CommandResponse.new(
+            status: Anycable::Status::ERROR,
+            disconnect: connection.closed?,
+            transmissions: connection.transmissions
+          )
+        else
+          Anycable::CommandResponse.new(
+            status: Anycable::Status::SUCCESS,
+            disconnect: connection.closed?,
+            stop_streams: channel.stop_streams?,
+            stream_from: channel.streams.present?,
+            stream_id: channel.streams.first || '',
+            transmissions: connection.transmissions
+          )
+        end
+      else
+        Anycable::CommandResponse.new(
+          status: Anycable::Status::ERROR
+        )
+      end
+    end
+
+    def unsubscribe(message, _unused_call)
+      logger.debug("RPC Unsubscribe: #{message}")
+      Anycable::CommandResponse.new(
+        status: Anycable::Status::SUCCESS,
+        disconnect: false,
+        stop_streams: true,
+        stream_from: false
+      )
+    end
+
+    def perform(message, _unused_call)
+      logger.debug("RPC Perform: #{message}")
+      connection = ApplicationCable::Connection.new(
+        identifiers_json: message.connection_identifiers
+      )
+
+      channel = channel_for(connection, message)
+
+      if channel.present?
+        channel.perform_action(ActiveSupport::JSON.decode(message.data))
+        Anycable::CommandResponse.new(
+          status: Anycable::Status::SUCCESS,
+          disconnect: connection.closed?,
+          stop_streams: channel.stop_streams?,
+          stream_from: channel.streams.present?,
+          stream_id: channel.streams.first || '',
+          transmissions: connection.transmissions
+        )
+      else
+        Anycable::CommandResponse.new(
+          status: Anycable::Status::ERROR
+        )
+      end
+    end
+
+    private
+
+    # Build env from path
+    def path_env(path)
+      uri = URI.parse(path)
+      {
+        'QUERY_STRING' => uri.query,
+        'SCRIPT_NAME' => '',
+        'PATH_INFO' => uri.path,
+        'SERVER_PORT' => uri.port.to_s,
+        'HTTP_HOST' => uri.host,
+        # Hack to avoid Missing rack.input error
+        'rack.request.form_input' => '',
+        'rack.input' => '',
+        'rack.request.form_hash' => {}
+      }
+    end
+
+    def channel_for(connection, message)
+      id_key = message.identifier
+      id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+
+      subscription_klass = id_options[:channel].safe_constantize
+
+      if subscription_klass
+        subscription_klass.new(connection, id_key, id_options)
+      else
+        logger.error "Subscription class not found (#{message.inspect})"
+        nil
+      end
+    end
+
+    def logger
+      Anycable.logger
+    end
+  end
+end

data/lib/anycable/server.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'grpc'
+require 'anycable'
+require 'anycable/rpc_handler'
+
+# Set GRPC logger
+module GRPC
+  def self.logger
+    Anycable.logger
+  end
+end
+
+module Anycable
+  # Wrapper over GRPC server
+  module Server
+    class << self
+      attr_accessor :grpc_server
+
+      def start
+        @grpc_server = GRPC::RpcServer.new
+        grpc_server.add_http2_port(Anycable.config.rpc_host, :this_port_is_insecure)
+        grpc_server.handle(Anycable::RPCHandler)
+        Anycable.logger.info "RPC server is listening on #{Anycable.config.rpc_host}"
+        grpc_server.run_till_terminated
+      end
+    end
+  end
+end

data/lib/anycable/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Anycable
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/generators/anycable/USAGE

@@ -0,0 +1,7 @@
+Description:
+  Generates Anycable executable
+  
+Examples:
+  rails generate anycable
+
+    This will generate Anycable executable

data/lib/generators/anycable/anycable_generator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "rails/generators/base"
+
+class AnycableGenerator < Rails::Generators::Base # :nodoc:
+  source_root File.expand_path('../templates', __FILE__)
+
+  def create_executable_file
+    template "script", "bin/anycable"
+    chmod "bin/anycable", 0o755
+  end
+end

data/lib/generators/anycable/templates/script

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require ::File.expand_path('../../config/environment', __FILE__)
+Rails.application.eager_load!
+
+require 'anycable/server'
+
+Anycable::Server.start

data/lib/tasks/anycable_tasks.rake

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
-# desc "Explaining what the task does"
-# task :anycable do
-#   # Task goes here
-# end
+namespace :anycable do
+  desc "Make test gRPC call"
+  task check: :environment do
+    require 'grpc'
+    require 'anycable/rpc/rpc_services'
+
+    Anycable.logger = Logger.new(STDOUT)
+    stub = Anycable::RPC::Stub.new(Anycable.config.rpc_host, :this_channel_is_insecure)
+    stub.connect(
+      Anycable::ConnectionRequest.new(
+        path: 'http://example.com',
+        headers: { 'Cookie' => 'test=1;' }
+      )
+    )
+  end
+end

data/protos/rpc.proto

@@ -0,0 +1,52 @@
+syntax = "proto3";
+
+package anycable;
+
+service RPC {
+  rpc Connect (ConnectionRequest) returns (ConnectionResponse) {}
+  rpc Subscribe (CommandMessage) returns (CommandResponse) {}
+  rpc Unsubscribe (CommandMessage) returns (CommandResponse) {}
+  rpc Perform (CommandMessage) returns (CommandResponse) {}
+  rpc Disconnect (DisconnectRequest) returns (DisconnectResponse) {}
+}
+
+enum Status {
+  ERROR = 0;
+  SUCCESS = 1;
+}
+
+message ConnectionRequest {
+  string path = 1;
+  map<string,string> headers = 2;
+}
+
+message ConnectionResponse {
+  Status status = 1;
+  string identifiers = 2;
+  repeated string transmissions = 3;
+}
+
+message CommandMessage {
+  string command = 1;
+  string identifier = 2;
+  string connection_identifiers = 3;
+  string data = 4;
+}
+
+message CommandResponse {
+  Status status = 1;
+  bool disconnect = 2;
+  bool stop_streams = 3;
+  bool stream_from = 4;
+  string stream_id = 5;
+  repeated string transmissions = 6;
+}
+
+message DisconnectRequest {
+  string identifiers = 1;
+  repeated string subscriptions = 2;
+}
+
+message DisconnectResponse {
+  Status status = 1;
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: anycable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - palkan
@@ -24,6 +24,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,14 +150,29 @@ files:
 - CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
+- Makefile
 - README.md
 - Rakefile
 - anycable.gemspec
+- bin/console
 - bin/setup
 - circle.yml
 - lib/anycable.rb
+- lib/anycable/actioncable/channel.rb
+- lib/anycable/actioncable/connection.rb
+- lib/anycable/actioncable/server.rb
+- lib/anycable/config.rb
+- lib/anycable/pubsub.rb
+- lib/anycable/rpc/rpc.rb
+- lib/anycable/rpc/rpc_services.rb
+- lib/anycable/rpc_handler.rb
+- lib/anycable/server.rb
 - lib/anycable/version.rb
+- lib/generators/anycable/USAGE
+- lib/generators/anycable/anycable_generator.rb
+- lib/generators/anycable/templates/script
 - lib/tasks/anycable_tasks.rake
+- protos/rpc.proto
 homepage: http://github.com/anycable/anycable
 licenses:
 - MIT