anycable-core 1.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f3906d5bd75c90a70af60b0ce10ab49c5940bc7818aa90f4e2af61831b9d5f2
+  data.tar.gz: 3a5b9eea11ea0769d5dcfebd8721c3cf0d6925b470d636f895c37e8da82818a4
+SHA512:
+  metadata.gz: 116b8c9a943c5785773f4286115cb01955e188bcc45e9583986db08cbbc7c945817280217df07956d2ca3bc739ad95a1120b7f1bf7a19655b19c1cccd49d290a
+  data.tar.gz: aacd6b3e0dda79471150f6305dde49ec1efafdc05fae3c4e9da7ccaf1fa9dfb9c1d7554ac3154e74104b99807f2400f0da465f53da2dcd283870715609384e3f

data/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Change log
+
+## master
+
+## 1.1.0-dev
+
+- **BREAKING** Move middlewares from gRPC interceptors to custom implementation. ([@palkan][])
+
+That allowed us to have _real_ middlewares with ability to modify responses, intercept exceptions, etc.
+The API changed a bit:
+
+```diff
+ class SomeMiddleware < AnyCable::Middleware
+-  def call(request, rpc_call, rpc_handler)
++  def call(rpc_method_name, request)
+     yield
+   end
+ end
+```
+
+- **Ruby >= 2.6** is required.
+- **Anyway Config >= 2.1** is required.
+
+## 1.0.3 (2021-03-05)
+
+- Ruby 3.0 compatibility. ([@palkan][])
+
+## 1.0.2 (2021-01-05)
+
+- Handle TLS Redis connections by using VERIFY_NONE mode. ([@palkan][])
+
+## 1.0.1 (2020-07-07)
+
+- Support providing passwords for Redis Sentinels. ([@palkan][])
+
+Use the following format: `ANYCABLE_REDIS_SENTINELS=:password1@my.redis.sentinel.first:26380,:password2@my.redis.sentinel.second:26380`.
+
+## 1.0.0 (2020-07-01)
+
+- Add `embedded` option to CLI runner. ([@palkan][])
+
+- Add `Env#istate` and `EnvResponse#istate` to store channel state. ([@palkan][])
+
+That would allow to mimic instance variables usage in Action Cable channels.
+
+- Add `CommandResponse#stopped_streams` to support unsubscribing from particular broadcastings. ([@palkan])
+
+`Socket#unsubscribe` is now implemented as well.
+
+- Add `AnyCable.broadcast_adapter#broadcast_command` method. ([@palkan][])
+
+It could be used to send commands to WS server (e.g., remote disconnect).
+
+- Add `:http` broadcasting adapter. ([@palkan][])
+
+- **RPC schema has changed**. ([@palkan][])
+
+Using `anycable-go` v1.x is required.
+
+- **Ruby 2.5+ is required**. ([@palkan][])
+
+- Added RPC proto version check. ([@palkan][])
+
+Server must sent `protov` metadata with the supported versions (comma-separated list). If there is no matching version an exception is raised.
+
+Current RPC proto version is **v1**.
+
+- Added `request` support to channels. ([@palkan][])
+
+Now you can access `request` object in channels, too (e.g., to read headers/cookies/URL/etc).
+
+- Change default server address from `[::]:50051` to `127.0.0.1:50051`. ([@palkan][])
+
+See [#71](https://github.com/anycable/anycable/pull/71).
+
+- Fix building Redis Sentinel config. ([@palkan][])
+
+---
+
+See [Changelog](https://github.com/anycable/anycable/blob/0-6-stable/CHANGELOG.md) for versions <1.0.0.
+
+[@palkan]: https://github.com/palkan
+[@sponomarev]: https://github.com/sponomarev
+[@bibendi]: https://github.com/bibendi

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017-2021 Vladimir Dementyev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+[![Gem Version](https://badge.fury.io/rb/anycable.svg)](https://rubygems.org/gems/anycable)
+[![Build](https://github.com/anycable/anycable/workflows/Build/badge.svg)](https://github.com/anycable/anycable/actions)
+[![Gitter](https://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/anycable/Lobby)
+[![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://docs.anycable.io/v1)
+
+# AnyCable
+
+<img align="right" height="150" width="129"
+     title="AnyCable logo" src="https://docs.anycable.io/assets/images/logo.svg">
+
+AnyCable allows you to use any WebSocket server (written in any language) as a replacement for your Ruby server (such as Faye, Action Cable, etc).
+
+AnyCable uses the same protocol as ActionCable, so you can use its [JavaScript client](https://www.npmjs.com/package/actioncable) without any monkey-patching.
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Requirements
+
+- Ruby >= 2.6
+- Redis (for broadcasting **in production**, [discuss other options](https://github.com/anycable/anycable/issues/2) with us!)
+
+## Usage
+
+Check out our 📑 [Documentation](https://docs.anycable.io/v1).
+
+## Links
+
+- [AnyCable 1.0: Four years of real-time web with Ruby and Go](https://evilmartians.com/chronicles/anycable-1-0-four-years-of-real-time-web-with-ruby-and-go)
+
+- [AnyCable: Action Cable on steroids!](https://evilmartians.com/chronicles/anycable-actioncable-on-steroids)
+
+- [Connecting LiteCable to Hanami](http://gabrielmalakias.com.br/ruby/hanami/iot/2017/05/26/websockets-connecting-litecable-to-hanami.html) by [@GabrielMalakias](https://github.com/GabrielMalakias)
+
+- [From Action to Any](https://medium.com/@leshchuk/from-action-to-any-1e8d863dd4cf) by [@alekseyl](https://github.com/alekseyl)
+
+## Talks
+
+- High-speed cables for Ruby, RubyConf 2018, [slides](https://speakerdeck.com/palkan/rubyconf-2018-high-speed-cables-for-ruby) and [video](https://www.youtube.com/watch?v=8XRcOZXOzV4) (EN)
+
+- One cable to rule them all, RubyKaigi 2018, [slides](https://speakerdeck.com/palkan/rubykaigi-2018-anycable-one-cable-to-rule-them-all) and [video](https://www.youtube.com/watch?v=jXCPuNICT8s) (EN)
+
+- Wroc_Love.rb 2018 [slides](https://speakerdeck.com/palkan/wroc-love-dot-rb-2018-cables-cables-cables) and [video](https://www.youtube.com/watch?v=AUxFFOehiy0) (EN)
+
+- RubyConfMY 2017 [slides](https://speakerdeck.com/palkan/rubyconf-malaysia-2017-anycable) and [video](https://www.youtube.com/watch?v=j5oFx525zNw) (EN)
+
+- RailsClub Moscow 2016 [slides](https://speakerdeck.com/palkan/railsclub-moscow-2016-anycable) and [video](https://www.youtube.com/watch?v=-k7GQKuBevY&list=PLiWUIs1hSNeOXZhotgDX7Y7qBsr24cu7o&index=4) (RU)
+
+## Building
+
+### Generating gRPC files from `.proto`
+
+- Install required GRPC gems:
+
+```sh
+gem install grpc
+gem install grpc-tools
+```
+
+- Re-generate GRPC files (if necessary):
+
+```sh
+make
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/anycable/anycable](https://github.com/anycable/anycable).
+
+Please, provide reproduction script (using [this template](https://github.com/anycable/anycable/blob/master/etc/bug_report_template.rb)) when submitting bugs if possible.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Security Contact
+
+To report a security vulnerability, please contact us at `anycable@evilmartians.com`. We will coordinate the fix and disclosure.

data/bin/anycable

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "anycable/cli"
+
+begin
+  cli = AnyCable::CLI.new
+  cli.run(ARGV)
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/bin/anycabled

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require "anycable/cli"
+
+begin
+  require "daemons"
+rescue LoadError
+  raise <<~MSG
+    You need to add gem 'daemons' to your Gemfile if you want to use `anycabled`:
+
+      # Gemfile
+      gem "daemons", "~> 1.3", require: false
+  MSG
+end
+
+options = {
+  dir: "tmp/pids",
+  log_output: false
+}
+
+# Preserve current directory. We need it inside the server.
+current_dir = Dir.pwd
+
+# Clean ARGV from daemon command and args
+_, _, args = Daemons::Controller.split_argv(ARGV)
+
+Daemons.run_proc("anycable", options) do
+  Dir.chdir current_dir
+  AnyCable::CLI.new.run(args)
+end

data/bin/console

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

data/bin/setup

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+set -e
+
+gem install bundler --conservative
+bundle check || bundle install

data/lib/anycable.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "anycable/version"
+require "anycable/config"
+require "logger"
+
+require "anycable/exceptions_handling"
+require "anycable/broadcast_adapters"
+
+require "anycable/middleware_chain"
+require "anycable/middlewares/exceptions"
+
+require "anycable/socket"
+require "anycable/rpc"
+require "anycable/health_server"
+
+# AnyCable allows to use any websocket service (written in any language) as a replacement
+# for ActionCable server.
+#
+# AnyCable includes an RPC server (gRPC by default), which is used by external WS server to execute commands
+# (authentication, subscription authorization, client-to-server messages).
+#
+# Broadcasting messages to WS is done through _broadcast adapter_ (Redis Pub/Sub by default).
+module AnyCable
+  class << self
+    # Provide connection factory which
+    # is a callable object with build
+    # a Connection object
+    attr_accessor :connection_factory
+
+    # Provide a method to build a server to serve RPC
+    attr_accessor :server_builder
+
+    attr_writer :logger, :rpc_handler
+
+    attr_reader :middleware
+
+    def logger
+      return @logger if instance_variable_defined?(:@logger)
+
+      log_output = AnyCable.config.log_file || $stdout
+      @logger = Logger.new(log_output).tap do |logger|
+        logger.level = AnyCable.config.log_level
+      end
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield(config) if block_given?
+    end
+
+    # Register a custom block that will be called
+    # when an exception is raised during RPC call
+    def capture_exception(&block)
+      ExceptionsHandling << block
+    end
+
+    # Register a callback to be invoked before
+    # the server starts
+    def configure_server(&block)
+      server_callbacks << block
+    end
+
+    def server_callbacks
+      @server_callbacks ||= []
+    end
+
+    def broadcast_adapter
+      self.broadcast_adapter = AnyCable.config.broadcast_adapter.to_sym unless instance_variable_defined?(:@broadcast_adapter)
+      @broadcast_adapter
+    end
+
+    def broadcast_adapter=(adapter)
+      if adapter.is_a?(Symbol) || adapter.is_a?(Array)
+        adapter = BroadcastAdapters.lookup_adapter(adapter)
+      end
+
+      unless adapter.respond_to?(:broadcast)
+        raise ArgumentError, "BroadcastAdapter must implement #broadcast method. " \
+                             "#{adapter.class} doesn't implement it."
+      end
+
+      @broadcast_adapter = adapter
+    end
+
+    # Raw broadcast message to the channel, sends only string!
+    # To send hash or object use ActionCable.server.broadcast instead!
+    def broadcast(channel, payload)
+      broadcast_adapter.broadcast(channel, payload)
+    end
+
+    def rpc_handler
+      @rpc_handler ||= AnyCable::RPC::Handler.new
+    end
+
+    private
+
+    attr_writer :middleware
+  end
+
+  self.middleware = MiddlewareChain.new.tap do |chain|
+    # Include exceptions handling middleware by default
+    chain.use(Middlewares::Exceptions)
+  end
+end
+
+# gRPC is the default for now, so, let's try to load it.
+begin
+  require "anycable/grpc"
+rescue LoadError
+end

data/lib/anycable/broadcast_adapters.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "anycable/broadcast_adapters/base"
+
+module AnyCable
+  module BroadcastAdapters # :nodoc:
+    module_function
+
+    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
+
+      options ||= {}
+      BroadcastAdapters.const_get(adapter_class_name, false).new(**options)
+    end
+  end
+end

data/lib/anycable/broadcast_adapters/base.rb

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

@@ -0,0 +1,131 @@
+# 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_method :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
+            # @type break: nil
+            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).to_int * retry_count)
+          retry
+        ensure
+          http.finish if http.started?
+        end
+      end
+    end
+  end
+end