anycable-rack-server 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 416a34b5853c2b0f81f4693e59fe4c9b10021b41fc8eb2e710b8fd82b5a67c04
-  data.tar.gz: fcb0f8b569adc737b704025393237b573b7de616ea4e5deedaa77e442a51bc09
+  metadata.gz: 9e57a096cf575590410db4c25e824d0b754af2b85eb0927e4d9fdf553da4ccea
+  data.tar.gz: e6c5fce5b74f12bc41ce06955812cff608f50c4c66b063a459fa34ca8ed5e8e1
 SHA512:
-  metadata.gz: 7cd8bcd7b5afda208b3df2e476b0729faf9fbfbfd9d6fb36735f26cba48b9589e3a4704a9dbc69c6743bdf4f209c2ee9e6d44f8521a5fc89036a42859f0f9090
-  data.tar.gz: 68f4b98948bb3ec8fb330947faed0f933ee7dd12dab2f1ca6abbb35af41ab3f7b7f3ad720ea74be82af486f309b250c340603e8e10716478a03975704c3ba3f5
+  metadata.gz: 304f417fc3d477625effcc7134c81708d222df3da565613f4f5878b5c0365fecd5ed2a3e9620cc692976051f9a634a66623f8adfce2729664f34882135eeec2b
+  data.tar.gz: d5a926617db60ec606f15b73189da24ed80d69012e87b8b4968ea6e0c1e0b7f26b86a3af593a48804f575dfd2c5c7867070555df968c69ba43926d4c97df4501

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Yulia Oletskaya
+Copyright (c) 2019 Yulia Oletskaya
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,37 +1,86 @@
+[![Gem Version](https://badge.fury.io/rb/anycable-rack-server.svg)](https://rubygems.org/gems/anycable-rack-server) [![Build Status](https://travis-ci.org/anycable/anycable-rack-server.svg?branch=master)](https://travis-ci.org/anycable/anycable-rack-server)
+
 # anycable-rack-server
 
-AnyCable-compatible Rack hijack based Ruby Web Socket server middleware designed for development and testing purposes.
+[AnyCable](https://anycable.io)-compatible Rack hijack based Ruby Web Socket server designed for development and testing purposes.
 
-## Usage
+## Using with Rack
 
-Mount the rack middleware
 ```ruby
-# config/routes.rb
-Rails.application.routes.draw do
-  mount AnyCable::Rack.new => '/cable'
+# Initialize server instance first.
+#
+# NOTE: you must run RPC server yourself and provide its host
+ws_server = AnyCable::Rack::Server.new rpc_host: "localhost:50051"
+
+app = Rack::Builder.new do
+  map "/cable" do
+    run ws_server
+  end
 end
+
+# NOTE: don't forget to call `start!` method 
+ws_server.start!
+
+run app
 ```
 
+## Usage with Rails
+
+Add `gem "anycable-rack-server"` to you `Gemfile` and make sure your Action Cable adapter is set to `:any_cable`. That's it! We automatically start AnyCable Rack server for your at `/cable` path.
+
 ## Settings
 
-Customizable options: headers being sent with each gRPC request. The gem uses AnyCable config for redis and gRPC host settings.
+You can customize the headers being sent with each gRPC request.
 
 Default headers: `'cookie', 'x-api-token'`.
 
-Can be specified via env variable
+Can be specified via options:
+
+```ruby
+ws_server = AnyCable::Rack::Server.new(
+  rpc_host: "localhost:50051",
+  headers: ["cookie", "x-my-header"]
+)
 ```
-ANYCABLE_HEADERS=cookie,x-api-token,origin
+
+In case of Rails you can set server options via `config.any_cable_rack`:
+
+```ruby
+# <environment>.rb
+config.any_cable_rack.headers = %w[cookie]
+config.any_cable_rack.mount_path = "/cable"
+# NOTE: here we specify only the port (we assume that a server is running locally)
+config.any_cable_rack.rpc_port = 50051
 ```
 
-Or
+## Running RPC from the same process
+
+The goal of the Rack server is to simplify the development/testing process. But we still have to run the RPC server.
+
+This gem also provides a way to run RPC server from the same process (spawning a new process):
 
 ```ruby
-options = { headers: ['cookie', 'origin'] }
-AnyCable::Rack.new(nil, options)
+# in Rack app
+
+AnyCable::Rack::RPCRunner.run(
+  root_dir: "<path to your app root directory to run `anycable` from>",
+  rpc_host: "...", # optional host to run RPC server on (defaults to '[::]::50051')
+  command_args: [] # additional CLI arguments
+)
+
+# in Rails app you can just specify the configuration parameter (`false` by default)
+# and we'll take care of it
+config.any_cable_rack.run_rpc = true
 ```
 
 ## Testing
 
-Run units with `rake`.
+Run units with `bundle exec rake`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/anycable/anycable-rack-server.
+
+## License
 
-Instructions for testing with [anyt](https://github.com/anycable/anyt) (anycable conformance testing) can be found [here](https://github.com/tuwukee/anycable-rack-server/tree/master/test/support).
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/anycable-rack-server.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
-require 'anycable/rack-server'
+require "anycable/rack/server"
+require "anycable/rack/railtie" if defined?(Rails)

data/lib/anycable/{rack-server → rack}/broadcast_subscribers/redis_subscriber.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require 'redis'
+require "redis"
+require "json"
 
 module AnyCable
-  module RackServer
+  module Rack
     module BroadcastSubscribers
+      # Redis Pub/Sub subscriber
       class RedisSubscriber
         attr_reader :hub, :coder, :redis_conn, :threads
 
-        def initialize(hub:, coder:, options:)
+        def initialize(hub:, coder:, **options)
           @hub        = hub
           @coder      = coder
           @redis_conn = ::Redis.new(options)
@@ -18,13 +20,13 @@ module AnyCable
         def subscribe(channel)
           @threads[channel] = Thread.new do
             redis_conn.subscribe(channel) do |on|
-              on.message { |_channel, msg|  handle_message(msg) }
+              on.message { |_channel, msg| handle_message(msg) }
             end
           end
         end
 
         def unsubscribe(channel)
-          @threads[channel].terminate unless @threads[channel].nil?
+          @threads[channel]&.terminate
           @threads.delete(channel)
         end
 
@@ -32,7 +34,7 @@ module AnyCable
 
         def handle_message(msg)
           data = JSON.parse(msg)
-          hub.broadcast(data['stream'], data['data'], coder)
+          hub.broadcast(data["stream"], data["data"], coder)
         end
       end
     end

data/lib/anycable/{rack-server → rack}/coders/json.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "json"
+
 module AnyCable
-  module RackServer
+  module Rack
     module Coders
-      module JSON
+      module JSON # :nodoc:
         class << self
           def decode(json_str)
             ::JSON.parse(json_str)

data/lib/anycable/{rack-server → rack}/connection.rb

@@ -1,33 +1,35 @@
 # frozen_string_literal: true
 
-require 'anycable/rack-server/rpc/client'
-require 'anycable/rack-server/logging'
-require 'anycable/rack-server/errors'
+require "securerandom"
+require "set"
+require "json"
+
+require "anycable/rack/rpc/client"
+require "anycable/rack/logging"
+require "anycable/rack/errors"
 
 module AnyCable
-  # rubocop:disable Metrics/LineLength
-  module RackServer
-    class Connection
-      # rubocop:enable Metrics/LineLength
+  module Rack
+    class Connection # :nodoc:
       include Logging
 
       attr_reader :coder,
-                  :header_names,
+                  :headers,
                   :hub,
                   :socket,
                   :rpc_client,
-                  :server_id
+                  :sid
 
-      def initialize(socket, hub, coder, host, header_names, server_id)
-        @socket       = socket
-        @coder        = coder
-        @hub          = hub
-        @header_names = header_names
-        @server_id    = server_id
+      def initialize(socket, hub:, coder:, rpc_host:, headers:)
+        @socket = socket
+        @coder = coder
+        @headers = headers
+        @hub = hub
+        @sid = SecureRandom.hex(6)
 
-        @rpc_client = RPC::Client.new(host)
+        @rpc_client = RPC::Client.new(rpc_host)
 
-        @_identifiers   = '{}'
+        @_identifiers   = "{}"
         @_subscriptions = Set.new
       end
 
@@ -44,17 +46,21 @@ module AnyCable
 
       def handle_command(websocket_message)
         decoded = decode(websocket_message)
-        command = decoded.delete('command')
+        command = decoded.delete("command")
+
+        channel_identifier = decoded["identifier"]
 
-        channel_identifier = decoded['identifier']
+        log(:debug) { "Command: #{decoded}" }
 
         case command
-        when 'subscribe'   then subscribe(channel_identifier)
-        when 'unsubscribe' then unsubscribe(channel_identifier)
-        when 'message'     then send_message(channel_identifier, decoded['data'])
+        when "subscribe"   then subscribe(channel_identifier)
+        when "unsubscribe" then unsubscribe(channel_identifier)
+        when "message"     then send_message(channel_identifier, decoded["data"])
         else
-          raise Errors::UnknownCommand, "Command not found #{command}"
+          log(:error, "Command not found #{command}")
         end
+      rescue Exception => e
+        log(:error, "Failed to execute command #{command}: #{e.message}")
       end
 
       private
@@ -88,7 +94,7 @@ module AnyCable
         )
       end
 
-      def rpc_command(command, identifier, data = '')
+      def rpc_command(command, identifier, data = "")
         rpc_client.command(
           command: command,
           identifier: identifier,
@@ -98,43 +104,31 @@ module AnyCable
       end
 
       def subscribe(identifier)
-        response = rpc_command('subscribe', identifier)
+        response = rpc_command("subscribe", identifier)
         if response.status == :SUCCESS
           @_subscriptions.add(identifier)
-        else
-          log(:debug, log_fmt("RPC subscribe command failed: #{response.inspect}"))
+        elsif response.status == :ERROR
+          log(:error, "RPC subscribe command failed: #{response.inspect}")
         end
         process_command(response, identifier)
       end
 
       def unsubscribe(identifier)
-        response = rpc_command('unsubscribe', identifier)
+        response = rpc_command("unsubscribe", identifier)
         if response.status == :SUCCESS
           @_subscriptions.delete(identifier)
-        else
-          log(:debug, log_fmt("RPC unsubscribe command failed: #{response.inspect}"))
+        elsif response.status == :ERROR
+          log(:error, "RPC unsubscribe command failed: #{response.inspect}")
         end
         process_command(response, identifier)
       end
 
       def send_message(identifier, data)
-        response = rpc_command('message', identifier, data)
-        unless response.status == :SUCCESS
-          log(:debug, log_fmt("RPC message command failed: #{response.inspect}"))
-        end
+        response = rpc_command("message", identifier, data)
+        log(:error, "RPC message command failed: #{response.inspect}") if response.status == :ERROR
         process_command(response, identifier)
       end
 
-      def headers
-        @headers ||= begin
-          header_names.inject({}) do |acc, name|
-            header_val = request.env["HTTP_#{name.gsub(/-/,'_').upcase}"]
-            acc[name]  = header_val unless header_val.nil? || header_val.empty?
-            acc
-          end
-        end
-      end
-
       def process_command(response, identifier)
         response.transmissions.each { |transmission| transmit(decode(transmission)) }
         hub.remove_channel(socket, identifier) if response.stop_streams
@@ -146,23 +140,23 @@ module AnyCable
         if response.status == :SUCCESS
           @_identifiers = response.identifiers
           response.transmissions.each { |transmission| transmit(decode(transmission)) }
-          log(:debug) { log_fmt('Opened') }
+          log(:debug) { "Opened" }
         else
-          log(:error, log_fmt("RPC connection command failed: #{response.inspect}"))
+          log(:error, "RPC connection command failed: #{response.inspect}")
           close_connection
         end
       end
 
       def process_close(response)
         if response.status == :SUCCESS
-          log(:debug) { log_fmt('Closed') }
+          log(:debug) { "Closed" }
         else
-          log(:error, log_fmt("RPC disconnection command failed: #{response.inspect}"))
+          log(:error, "RPC disconnection command failed: #{response.inspect}")
         end
       end
 
       def reset_connection
-        @_identifiers = '{}'
+        @_identifiers = "{}"
         @_subscriptions = []
 
         hub.remove_socket(socket)
@@ -181,8 +175,12 @@ module AnyCable
         coder.decode(websocket_message)
       end
 
+      def log(level, msg = nil)
+        super(level, msg ? log_fmt(msg) : nil) { log_fmt(yield) }
+      end
+
       def log_fmt(msg)
-        "[connection:#{server_id}] #{msg}"
+        "[sid=#{sid}] #{msg}"
       end
     end
   end

data/lib/anycable/{rack-server → rack}/errors.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 module AnyCable
-  module RackServer
+  module Rack
     module Errors
       class HijackNotAvailable < RuntimeError; end
-      class UnknownCommand < StandardError; end
       class MiddlewareSetup < StandardError; end
     end
   end

data/lib/anycable/{rack-server → rack}/hub.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "set"
+
 module AnyCable
-  module RackServer
+  module Rack
     # From https://github.com/rails/rails/blob/v5.0.1/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
     class Hub
       attr_reader :streams, :sockets
@@ -67,6 +69,13 @@ module AnyCable
         end
       end
 
+      def close_all
+        hub.sockets.dup.each do |socket|
+          hub.remove_socket(socket)
+          socket.close
+        end
+      end
+
       private
 
       def cleanup(stream, socket, channel)

data/lib/anycable/{rack-server → rack}/logging.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module AnyCable
-  module RackServer
+  module Rack
     module Logging # :nodoc:
-      PREFIX = 'AnycableRackServer'
+      PREFIX = "AnyCableRackServer"
 
       private
 

data/lib/anycable/{rack-server → rack}/middleware.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require 'anycable/rack-server/connection'
-require 'anycable/rack-server/errors'
-require 'anycable/rack-server/socket'
+require "websocket"
+
+require "anycable/rack/connection"
+require "anycable/rack/errors"
+require "anycable/rack/socket"
 
 module AnyCable
-  module RackServer
-    class Middleware
-      PROTOCOLS = ['actioncable-v1-json', 'actioncable-unsupported'].freeze
+  module Rack
+    class Middleware # :nodoc:
+      PROTOCOLS = ["actioncable-v1-json", "actioncable-unsupported"].freeze
       attr_reader :pinger,
                   :hub,
                   :coder,
                   :rpc_host,
-                  :headers,
-                  :server_id
+                  :header_names
 
-      def initialize(_app, pinger:, hub:, coder:, rpc_host:, headers:, server_id:)
+      def initialize(pinger:, hub:, coder:, rpc_host:, header_names:)
         @pinger    = pinger
         @hub       = hub
         @coder     = coder
         @rpc_host  = rpc_host
-        @headers   = headers
-        @server_id = server_id
+        @header_names = header_names
       end
 
       def call(env)
@@ -40,34 +40,40 @@ module AnyCable
       end
 
       def rack_hijack(env)
-        raise Errors::HijackNotAvailable unless env['rack.hijack']
+        raise Errors::HijackNotAvailable unless env["rack.hijack"]
 
-        env['rack.hijack'].call
+        env["rack.hijack"].call
         send_handshake(env)
       end
 
       def send_handshake(env)
         handshake.from_rack(env)
-        env['rack.hijack_io'].write(handshake.to_s)
+        env["rack.hijack_io"].write(handshake.to_s)
       end
 
       def listen_socket(env)
-        socket = Socket.new(env, env['rack.hijack_io'], handshake.version)
+        socket = Socket.new(env, env["rack.hijack_io"], handshake.version)
         init_connection(socket)
         init_pinger(socket)
         socket.listen
       end
 
       def not_found
-        [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
+        [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
       end
 
       def websocket?(env)
-        env['HTTP_UPGRADE'] == 'websocket'
+        env["HTTP_UPGRADE"] == "websocket"
       end
 
       def init_connection(socket)
-        connection = Connection.new(socket, hub, coder, rpc_host, headers, server_id)
+        connection = Connection.new(
+          socket,
+          hub: hub,
+          coder: coder,
+          rpc_host: rpc_host,
+          headers: fetch_headers(socket.request)
+        )
         socket.onopen { connection.handle_open }
         socket.onclose { connection.handle_close }
         socket.onmessage { |data| connection.handle_command(data) }
@@ -77,6 +83,13 @@ module AnyCable
         pinger.add(socket)
         socket.onclose { pinger.remove(socket) }
       end
+
+      def fetch_headers(request)
+        header_names.each_with_object({}) do |name, acc|
+          header_val = request.env["HTTP_#{name.tr('-', '_').upcase}"]
+          acc[name]  = header_val unless header_val.nil? || header_val.empty?
+        end
+      end
     end
   end
 end

data/lib/anycable/{rack-server → rack}/pinger.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "json"
+
 module AnyCable
-  module RackServer
+  module Rack
     # Sends pings to sockets
     class Pinger
       INTERVAL = 3
@@ -9,7 +11,6 @@ module AnyCable
       def initialize
         @_sockets = []
         @_stopped = false
-        run
       end
 
       def add(socket)
@@ -24,7 +25,6 @@ module AnyCable
         @_stopped = true
       end
 
-      # rubocop: disable Metrics/MethodLength
       def run
         Thread.new do
           loop do
@@ -41,7 +41,6 @@ module AnyCable
           end
         end
       end
-      # rubocop: enable Metrics/MethodLength
 
       private
 

data/lib/anycable/rack/railtie.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rack
+    class Railtie < ::Rails::Railtie # :nodoc: all
+      class Config < Anyway::Config
+        config_name :anycable_rack
+        env_prefix "ANYCABLE_RACK"
+
+        attr_config mount_path: "/cable",
+                    headers: AnyCable::Rack::Server::DEFAULT_HEADERS,
+                    rpc_port: 50_051,
+                    rpc_host: "localhost",
+                    run_rpc: false,
+                    running_rpc: false
+
+        private :running_rpc=
+      end
+
+      config.before_configuration do
+        config.any_cable_rack = Config.new
+      end
+
+      initializer "anycable.rack.mount", after: "action_cable.routes" do
+        config.after_initialize do |app|
+          config = app.config.any_cable_rack
+
+          # Only if AnyCable adapter is used
+          next unless ::ActionCable.server.config.cable&.fetch("adapter", nil) == "any_cable"
+
+          server = AnyCable::Rack::Server.new(
+            headers: config.headers,
+            rpc_host: "#{config.rpc_host}:#{config.rpc_port}"
+          )
+
+          app.routes.prepend do
+            mount server => config.mount_path
+          end
+
+          if config.run_rpc && !config.running_rpc
+            AnyCable::Rack::RPCRunner.run(
+              rpc_host: "[::]:#{config.rpc_port}",
+              root_dir: ::Rails.root.to_s,
+              env: {
+                "ANYCABLE_RACK_RUNNING_RPC" => "true"
+              }
+            )
+          end
+
+          server.start!
+        end
+      end
+    end
+  end
+end

data/lib/anycable/{rack-server → rack}/rpc/client.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'grpc'
+require "grpc"
 
 module AnyCable
-  module RackServer
+  module Rack
     module RPC
+      # AnyCable RPC client
       class Client
         attr_reader :stub
 

data/lib/anycable/rack/rpc_runner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "anycable"
+require "anycable/rack/logging"
+
+$stdout.sync = true
+
+module AnyCable
+  module Rack
+    # Runs AnyCable CLI in a separate process
+    module RPCRunner
+      class << self
+        include Logging
+
+        attr_accessor :running, :pid
+
+        def run(root_dir:, command_args: [], rpc_host: "[::]:50051", env: {})
+          return if @running
+
+          command_args << "--rpc-host=\"#{rpc_host}\""
+
+          command = "bundle exec anycable #{command_args.join(' ')}"
+
+          log(:info, "Running AnyCable (from #{root_dir}): #{command}")
+
+          out = AnyCable.config.debug? ? STDOUT : IO::NULL
+
+          @pid = Dir.chdir(root_dir) do
+            Process.spawn(
+              env,
+              command,
+              out: out,
+              err: out
+            )
+          end
+
+          log(:debug) { "AnyCable PID: #{pid}" }
+
+          @running = true
+
+          at_exit { stop }
+        end
+
+        def stop
+          return unless running
+
+          log(:debug) { "Terminate PID: #{pid}" }
+
+          Process.kill("SIGKILL", pid)
+
+          @running = false
+        end
+
+        def running?
+          running == true
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack/server.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "anycable"
+
+require "anycable/rack/hub"
+require "anycable/rack/pinger"
+require "anycable/rack/errors"
+require "anycable/rack/middleware"
+require "anycable/rack/logging"
+require "anycable/rack/rpc_runner"
+require "anycable/rack/broadcast_subscribers/redis_subscriber"
+require "anycable/rack/coders/json"
+
+module AnyCable # :nodoc: all
+  module Rack
+    class Server
+      include Logging
+
+      DEFAULT_HEADERS = %w[cookie x-api-token].freeze
+
+      attr_reader :broadcast,
+                  :coder,
+                  :hub,
+                  :middleware,
+                  :pinger,
+                  :pubsub_channel,
+                  :rpc_host,
+                  :headers
+
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.last : {}
+
+        @hub = Hub.new
+        @pinger = Pinger.new
+        @coder = options.fetch(:coder, Coders::JSON)
+        @pubsub_channel = pubsub_channel
+
+        @headers = options.fetch(:headers, DEFAULT_HEADERS)
+        @rpc_host = options.fetch(:rpc_host)
+
+        @broadcast = BroadcastSubscribers::RedisSubscriber.new(
+          hub: hub,
+          coder: coder,
+          **AnyCable.config.to_redis_params
+        )
+
+        @middleware = Middleware.new(
+          header_names: headers,
+          pinger: pinger,
+          hub: hub,
+          rpc_host: rpc_host,
+          coder: coder
+        )
+
+        log(:info) { "Using RPC server at #{rpc_host}" }
+      end
+      # rubocop:enable
+
+      def start!
+        log(:info) { "Starting..." }
+
+        pinger.run
+
+        broadcast.subscribe(AnyCable.config.redis_channel)
+
+        log(:info) { "Subscribed to #{AnyCable.config.redis_channel}" }
+
+        @_started = true
+      end
+
+      def started?
+        @_started == true
+      end
+
+      def stop
+        return unless started?
+
+        @_started = false
+        broadcast_subscriber.unsubscribe(@_redis_channel)
+        pinger.stop
+        hub.close_all
+      end
+
+      def call(env)
+        middleware.call(env)
+      end
+
+      def inspect
+        "#<AnyCable::Rack::Server(rpc_host: #{rpc_host}, headers: [#{headers.join(', ')}])>"
+      end
+    end
+  end
+end

data/lib/anycable/{rack-server → rack}/socket.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'anycable/rack-server/logging'
+require "anycable/rack/logging"
 
 module AnyCable
-  module RackServer
+  module Rack
+    # Socket wrapper
     class Socket
       include Logging
       attr_reader :version, :socket
@@ -34,7 +35,7 @@ module AnyCable
       end
 
       def request
-        @_request ||= ::Rack::Request.new(@env)
+        @request ||= ::Rack::Request.new(@env)
       end
 
       def onopen(&block)
@@ -53,11 +54,10 @@ module AnyCable
         @_error_handlers << block
       end
 
-      # rubocop: disable Metrics/MethodLength
       def listen
         keepalive
         Thread.new do
-          Thread.current.abort_on_exception = true
+          Thread.current.report_on_exception = true
           begin
             @_open_handlers.each(&:call)
             each_frame do |data|
@@ -76,7 +76,6 @@ module AnyCable
           end
         end
       end
-      # rubocop: enable Metrics/MethodLength
 
       def close
         return unless @_active
@@ -105,7 +104,7 @@ module AnyCable
         frame = WebSocket::Frame::Outgoing::Server.new(version: version, type: :close, code: 1000)
         socket.write(frame.to_s) if frame.supported?
         socket.close
-      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT # rubocop:disable Lint/HandleExceptions
+      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT
         # already closed
       end
 
@@ -124,17 +123,14 @@ module AnyCable
         end
       end
 
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      # rubocop:disable Metrics/MethodLength
       def each_frame
         framebuffer = WebSocket::Frame::Incoming::Server.new(version: version)
         while IO.select([socket])
           if socket.respond_to?(:recvfrom)
             data, _addrinfo = socket.recvfrom(2000)
           else
-            data, _addrinfo = socket.readpartial(2000), socket.peeraddr
+            data = socket.readpartial(2000)
+            _addrinfo = socket.peeraddr
           end
 
           break if data.empty?

data/lib/anycable/{rack-server → rack}/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module AnyCable
-  module RackServer
-    VERSION = '0.0.1'
+  module Rack
+    VERSION = "0.1.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anycable-rack-server
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Yulia Oletskaya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-06 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable
@@ -58,28 +58,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.8.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.8.4
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.60.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.60.0
 description: AnyCable-compatible Ruby Rack middleware
 email: yulia.oletskaya@gmail.com
 executables: []
@@ -103,19 +131,21 @@ files:
 - LICENSE
 - README.md
 - lib/anycable-rack-server.rb
-- lib/anycable/rack-server.rb
-- lib/anycable/rack-server/broadcast_subscribers/redis_subscriber.rb
-- lib/anycable/rack-server/coders/json.rb
-- lib/anycable/rack-server/connection.rb
-- lib/anycable/rack-server/errors.rb
-- lib/anycable/rack-server/hub.rb
-- lib/anycable/rack-server/logging.rb
-- lib/anycable/rack-server/middleware.rb
-- lib/anycable/rack-server/pinger.rb
-- lib/anycable/rack-server/rpc/client.rb
-- lib/anycable/rack-server/rpc/rpc.proto
-- lib/anycable/rack-server/socket.rb
-- lib/anycable/rack-server/version.rb
+- lib/anycable/rack/broadcast_subscribers/redis_subscriber.rb
+- lib/anycable/rack/coders/json.rb
+- lib/anycable/rack/connection.rb
+- lib/anycable/rack/errors.rb
+- lib/anycable/rack/hub.rb
+- lib/anycable/rack/logging.rb
+- lib/anycable/rack/middleware.rb
+- lib/anycable/rack/pinger.rb
+- lib/anycable/rack/railtie.rb
+- lib/anycable/rack/rpc/client.rb
+- lib/anycable/rack/rpc/rpc.proto
+- lib/anycable/rack/rpc_runner.rb
+- lib/anycable/rack/server.rb
+- lib/anycable/rack/socket.rb
+- lib/anycable/rack/version.rb
 homepage: 
 licenses:
 - MIT

data/lib/anycable/rack-server.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require 'json'
-require 'anycable'
-require 'websocket'
-require 'securerandom'
-require 'anycable/rack-server/hub'
-require 'anycable/rack-server/pinger'
-require 'anycable/rack-server/errors'
-require 'anycable/rack-server/middleware'
-require 'anycable/rack-server/broadcast_subscribers/redis_subscriber'
-require 'anycable/rack-server/coders/json'
-
-module AnyCable
-  module RackServer
-    DEFAULT_OPTIONS = {
-      headers:  ['cookie', 'x-api-token']
-    }.freeze
-
-    class << self
-      attr_reader :broadcast_subscriber,
-                  :coder,
-                  :hub,
-                  :middleware,
-                  :pinger,
-                  :server_id
-
-      def start(options = {})
-        options  = DEFAULT_OPTIONS.merge(options)
-        @hub     = Hub.new
-        @pinger  = Pinger.new
-        @coder   = Coders::JSON
-
-        rpc_host = unpack_host(AnyCable.config.rpc_host)
-        headers  = parse_env_headers || options[:headers]
-
-        @server_id = "anycable-rack-server-#{SecureRandom.hex}"
-        @middleware = Middleware.new(
-          nil,
-          pinger:    pinger,
-          hub:       hub,
-          coder:     coder,
-          rpc_host:  rpc_host,
-          headers:   headers,
-          server_id: server_id
-        )
-
-        broadcast_subscribe
-
-        @_started = true
-      end
-
-      def started?
-        @_started == true
-      end
-
-      def stop
-        return unless started?
-
-        @_started = false
-        broadcast_subscriber.unsubscribe(@_redis_channel)
-        pinger.stop
-
-        hub.sockets.each do |socket|
-          hub.remove_socket(socket)
-          socket.close
-        end
-      end
-
-      private
-
-      def broadcast_subscribe
-        @_redis_params  = AnyCable.config.to_redis_params
-        @_redis_channel = AnyCable.config.redis_channel
-
-        @broadcast_subscriber = BroadcastSubscribers::RedisSubscriber.new(
-          hub:     @hub,
-          coder:   @coder,
-          options: @_redis_params
-        )
-
-        @broadcast_subscriber.subscribe(@_redis_channel)
-      end
-
-      def parse_env_headers
-        headers = ENV['ANYCABLE_HEADERS'].to_s.split(',')
-        return nil if headers.empty?
-        headers
-      end
-
-      def unpack_host(str)
-        str.gsub('[::]', '0.0.0.0')
-      end
-    end
-  end
-
-  class Rack
-    def initialize(_app = nil, options = {})
-      AnyCable::RackServer.start(options)
-    end
-
-    def call(env)
-      AnyCable::RackServer.middleware.call(env)
-    end
-  end
-end