anycable 0.5.2 → 0.6.0.rc1

data/benchmarks/benchmark.yml

@@ -5,16 +5,18 @@
   remote_user: ubuntu
   gather_facts: False
   vars:
-    server_host: '172.31.17.82'
+    server_host: '172.31.21.207'
     hostname: ws-bench-client
-    local_ips: ['172.31.17.191', '172.31.17.192', '172.31.17.193', '172.31.17.194']
-    local_ips_str: '-l 172.31.17.191 -l 172.31.17.192 -l 172.31.17.193 -l 172.31.17.194'
-    steps: 20
+    local_ips: ['172.31.19.119', '172.31.19.120', '172.31.17.121', '172.31.17.122']
+    # local_ips_str: '-l 172.31.19.119 -l 172.31.19.120 -l 172.31.17.121 -l 172.31.17.122'
+    local_ips_str: ''
+    steps: 10
     step_size: 1000
     sample_size: 100
     concurrency: 8
     payload_size: 200
     prepare: False
+    log_file: "./last_bench.log"
   tasks:
     - name: Prepare the machine
       tags: prepare
@@ -41,15 +43,15 @@
         chdir: /webapps/anycable_bench
       ignore_errors: yes
 
-    - name: Print Plezi command
+    - name: Print base command
       debug: msg="bin/websocket-bench broadcast {{ local_ips_str }} --concurrent {{ concurrency }} --sample-size {{ sample_size }} --step-size {{ step_size }} --payload-padding {{ payload_size }} --total-steps {{ steps }} ws://{{ server_host }}:3334/cable"
-      tags: plezi
+      tags: base
 
-    - name: Plezi benchmark
+    - name: Base benchmark
       become_user: deplo
       shell: bin/websocket-bench broadcast {{ local_ips_str }} --concurrent {{ concurrency }} --sample-size {{ sample_size }} --step-size {{ step_size }} --payload-padding {{ payload_size }} --total-steps {{ steps }} ws://{{ server_host }}:3334/cable
       register: bench
-      tags: plezi
+      tags: base
       args:
         chdir: /webapps/anycable_bench
       ignore_errors: yes
@@ -58,10 +60,10 @@
       debug: var=bench.stdout_lines
       tags:
         - action_cable
-        - plezi
+        - base
 
     - name: Benchmark results (stderr)
       debug: var=bench.stderr_lines
       tags:
         - action_cable
-        - plezi
+        - base

data/benchmarks/hosts

@@ -1,5 +1,5 @@
 [benchmark]
-ec2-52-19-57-142.eu-west-1.compute.amazonaws.com ansible_ssh_private_key_file=/Users/palkan/.ssh/macos-dev
+ec2-18-202-197-244.eu-west-1.compute.amazonaws.com ansible_ssh_private_key_file=/Users/palkan/.ssh/macos-dev
 
 [servers]
-ec2-34-252-33-102.eu-west-1.compute.amazonaws.com ansible_ssh_private_key_file=/Users/palkan/.ssh/macos-dev
+ec2-34-255-216-103.eu-west-1.compute.amazonaws.com ansible_ssh_private_key_file=/Users/palkan/.ssh/macos-dev

data/benchmarks/rtt_plot.py

@@ -0,0 +1,74 @@
+#coding: utf-8
+
+import sys
+import os
+import re
+import argparse
+
+def process_file(input_file):
+	log = {}
+	log['clients'] = []
+	log['95per'] = []
+	log['min'] = []
+	log['med'] = []
+	log['max'] = []
+		
+	for line in input_file:
+		point = parse_line(line)
+		if point:
+			log['clients'].append(point['clients'])
+			log['95per'].append(point['95per'])
+			log['min'].append(point['min'])
+			log['med'].append(point['med'])
+			log['max'].append(point['max'])
+	return log
+			
+def parse_line(line):
+  # clients:  1000    95per-rtt: 1328ms    min-rtt:   2ms    median-rtt: 457ms    max-rtt: 1577ms
+	matches = re.search('clients:\s+(\d+)\s+95per\-rtt:\s+(\d+)ms\s+min\-rtt:\s+(\d+)ms\s+median\-rtt:\s+(\d+)ms\s+max\-rtt:\s+(\d+)ms', line)
+	if matches:
+		return {
+			'clients': int(matches.group(1)),
+			'95per': int(matches.group(2)),
+			'min': int(matches.group(3)),
+			'med': int(matches.group(4)),
+			'max': int(matches.group(5))
+		}
+	return False
+
+def generate_plot(log, output):
+	import matplotlib.patches as mpatches
+	import matplotlib.pyplot as plt
+
+	with plt.rc_context({'backend': 'Agg'}):
+
+		fig = plt.figure()
+		ax = fig.add_subplot(1, 1, 1)
+
+		ax.plot(log['clients'], log['95per'], '-', lw=1, color='r', label='95 percentile')
+		ax.plot(log['clients'], log['med'], '-', lw=1, color='green', dashes=[10, 5], label='Median')
+		ax.plot(log['clients'], log['max'], '-', lw=1, color='grey', label='Max')
+
+		ax.set_ylabel('RTT ms', color='r')
+		ax.set_xlabel('clients num')
+		ax.set_ylim(0., max(log['max']) * 1.1)
+
+		handles, labels = ax.get_legend_handles_labels()
+		ax.legend(handles, labels, bbox_to_anchor=(0.4, 1))
+
+		ax.grid()
+
+		fig.savefig(output)
+	
+if __name__ == "__main__":
+	parser = argparse.ArgumentParser(description='Generate RTT chart')
+	parser.add_argument('-i', dest='inputfile', type=argparse.FileType('r'), help='input file containing benchmark results', required=True)
+	parser.add_argument('-o', dest='outputfile', type=argparse.FileType('w'), help='output file to write resulted chart PNG', required=True)
+
+	args = parser.parse_args()
+		
+	data = process_file(args.inputfile)
+
+	generate_plot(data, args.outputfile)
+
+	print('Done')	

data/benchmarks/rtt_plot_test.py

@@ -0,0 +1,16 @@
+import unittest
+import os
+import rtt_plot
+
+class TestRttPlot(unittest.TestCase):
+	def test_parse_line(self):
+		self.assertEqual(
+      { 'clients': 1000, '95per': 1328, 'min': 2, 'med': 457, 'max': 1577 },
+      rtt_plot.parse_line('   "clients:  1000    95per-rtt: 1328ms    min-rtt:   2ms    median-rtt: 457ms    max-rtt: 1577ms"')
+    )
+		self.assertFalse(
+      rtt_plot.parse_line('2018/10/28 02:24:13 Missing received broadcasts: expected 23100000, got 23005351')
+    )
+
+if __name__ == '__main__':
+    unittest.main()

data/benchmarks/servers.yml

@@ -13,24 +13,46 @@
         - action_cable
         - anycable
         - plezi
+        - iodine_cable
+        - falcon_cable
+        - falcon_async
+        - kill
       with_items:
         - "3334"
       ignore_errors: true
     - name: Run Action Cable
       become_user: deplo
       tags: action_cable
-      shell: WEB_CONCURRENCY={{ web_concurrency }} bundle exec rails s -p 3334 -e production
+      command: bash -lc "WEB_CONCURRENCY={{ web_concurrency }} bundle exec rails s -p 3334 -e production"
       args:
         chdir: /webapps/anycable_bench/ruby/action-cable-server
     - name: Run Anycable Go
       become_user: deplo
       tags: anycable
-      shell: ANYCABLE_GO_BIN="anycable-go-0.6.0" ANYCABLE_PORT="3334" bundle exec bin/anycable
+      shell: bash -lc "ANYCABLE_GO_BIN="anycable-go-0.6.0-alpha" ANYCABLE_PORT="3334" bundle exec bin/anycable"
       args:
         chdir: /webapps/anycable_bench/ruby/action-cable-server
     - name: Run Iodine/Plezi
       become_user: deplo
       tags: plezi
-      shell: iodine -p 3334
+      shell: bash -lc "bundle exec iodine -p 3334 -w {{ web_concurrency }} -t 16"
       args:
         chdir: /webapps/anycable_bench/ruby/plezi-iodine
+    - name: Run Iodine/ActionCable
+      become_user: deplo
+      tags: iodine_cable
+      shell:  bash -lc "RAILS_ENV=production bundle exec iodine -p 3334 -w {{ web_concurrency }} -t 16"
+      args:
+        chdir: /webapps/anycable_bench/ruby/action-cable-server
+    - name: Run Falcon/ActionCable
+      become_user: deplo
+      tags: falcon_cable
+      shell:  bash -lc "RAILS_ENV=production bundle exec falcon serve -b http://0.0.0.0:3334"
+      args:
+        chdir: /webapps/anycable_bench/ruby/action-cable-server
+    - name: Run Falcon/Async
+      become_user: deplo
+      tags: falcon_async
+      shell:  bash -lc "bundle exec falcon serve -b http://0.0.0.0:3334"
+      args:
+        chdir: /webapps/anycable_bench/ruby/falcon

data/bin/anycable

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/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/etc/bug_report_template.rb

@@ -25,7 +25,7 @@ ENV['ANYT_TARGET_URL'] ||= "ws://localhost:8080/cable"
 # Comment this line if you want to run WebSocket server manually
 ENV['ANYT_COMMAND'] ||= "anycable-go"
 
-ActionCable.server.config.logger = Rails.logger = Anycable.logger
+ActionCable.server.config.logger = Rails.logger = AnyCable.logger
 
 # Test scenario
 feature "issue_xyz" do

data/lib/anycable.rb

@@ -4,29 +4,37 @@ require "anycable/version"
 require "anycable/config"
 require "logger"
 
-# Anycable allows to use any websocket service (written in any language) as a replacement
+require "anycable/exceptions_handling"
+require "anycable/broadcast_adapters"
+
+require "anycable/middleware_chain"
+
+require "anycable/server"
+
+# AnyCable allows to use any websocket service (written in any language) as a replacement
 # for ActionCable server.
 #
-# Anycable includes a gRPC server, which is used by external WS server to execute commands
+# AnyCable includes a gRPC server, which is used by external WS server to execute commands
 # (authentication, subscription authorization, client-to-server messages).
 #
-# Broadcasting messages to WS is done through Redis Pub/Sub.
-module Anycable
+# 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
 
-    def logger=(logger)
-      @logger = logger
-    end
+    attr_writer :logger
+
+    attr_reader :middleware
 
     def logger
       return @logger if instance_variable_defined?(:@logger)
-      log_output = Anycable.config.log_file || STDOUT
+
+      log_output = AnyCable.config.log_file || STDOUT
       @logger = Logger.new(log_output).tap do |logger|
-        logger.level = Anycable.config.log_level
+        logger.level = AnyCable.config.log_level
       end
     end
 
@@ -38,22 +46,51 @@ module Anycable
       yield(config) if block_given?
     end
 
+    # Register a custom block that will be called
+    # when an exception is raised during gRPC call
+    def capture_exception(&block)
+      ExceptionsHandling << block
+    end
+
     def error_handlers
-      return @error_handlers if instance_variable_defined?(:@error_handlers)
-      @error_handlers = []
+      warn <<~DEPRECATION
+        Using `AnyCable.error_handlers` is deprecated!
+        Please, use `AnyCable.capture_exception` instead.
+      DEPRECATION
+      ExceptionsHandling
     end
 
-    def pubsub
-      @pubsub ||= PubSub.new
+    def broadcast_adapter
+      self.broadcast_adapter = :redis 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)
-      pubsub.broadcast(channel, payload)
+      broadcast_adapter.broadcast(channel, payload)
     end
+
+    private
+
+    attr_writer :middleware
   end
+
+  self.middleware = MiddlewareChain.new
 end
 
-require "anycable/server"
-require "anycable/pubsub"
+# Backward compatibility
+Anycable = AnyCable

data/lib/anycable/broadcast_adapters.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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/redis.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+gem "redis", ">= 4.0"
+
+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
+      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 broadcast(stream, payload)
+        redis_conn.publish(
+          channel,
+          { stream: stream, data: payload }.to_json
+        )
+      end
+    end
+  end
+end