slack-ruby-client 0.12.0 → 0.14.6

data/lib/slack/real_time/concurrency.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Concurrency
+      autoload :Async, 'slack/real_time/concurrency/async'
       autoload :Eventmachine, 'slack/real_time/concurrency/eventmachine'
       autoload :Celluloid, 'slack/real_time/concurrency/celluloid'
     end

data/lib/slack/real_time/concurrency/async.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+require 'async/websocket'
+require 'async/notification'
+require 'async/clock'
+
+module Slack
+  module RealTime
+    module Concurrency
+      module Async
+        class Client < ::Async::WebSocket::Client
+          extend ::Forwardable
+          def_delegators :@driver, :on, :text, :binary, :emit
+        end
+
+        class Socket < Slack::RealTime::Socket
+          attr_reader :client
+
+          def start_sync(client)
+            start_reactor(client).wait
+          end
+
+          def start_async(client)
+            Thread.new do
+              start_reactor(client)
+            end
+          end
+
+          def start_reactor(client)
+            Async do |task|
+              @restart = ::Async::Notification.new
+
+              if client.run_ping?
+                @ping_task = task.async do |subtask|
+                  subtask.annotate "#{client} keep-alive"
+
+                  # The timer task will naturally exit after the driver is set to nil.
+                  while @restart
+                    subtask.sleep client.websocket_ping_timer
+                    client.run_ping! if @restart
+                  end
+                end
+              end
+
+              while @restart
+                @client_task&.stop
+
+                @client_task = task.async do |subtask|
+                  begin
+                    subtask.annotate "#{client} run-loop"
+                    client.run_loop
+                  rescue ::Async::Wrapper::Cancelled => e
+                    # Will get restarted by ping worker.
+                  rescue StandardError => e
+                    client.logger.error(subtask.to_s) { e.message }
+                  end
+                end
+
+                @restart.wait
+              end
+
+              @ping_task&.stop
+            end
+          end
+
+          def restart_async(_client, new_url)
+            @url = new_url
+            @last_message_at = current_time
+
+            @restart&.signal
+          end
+
+          def current_time
+            ::Async::Clock.now
+          end
+
+          def connect!
+            super
+            run_loop
+          end
+
+          # Kill the restart/ping loop.
+          def disconnect!
+            super
+          ensure
+            if (restart = @restart)
+              @restart = nil
+              restart.signal
+            end
+          end
+
+          # Close the socket.
+          def close
+            super
+          ensure
+            if @socket
+              @socket.close
+              @socket = nil
+            end
+          end
+
+          def run_loop
+            while @driver&.next_event
+              # $stderr.puts event.inspect
+            end
+          end
+
+          protected
+
+          def build_ssl_context
+            OpenSSL::SSL::SSLContext.new(:TLSv1_2_client).tap do |ctx|
+              ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+            end
+          end
+
+          def build_endpoint
+            endpoint = ::Async::IO::Endpoint.tcp(addr, port)
+            if secure?
+              endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: build_ssl_context)
+            end
+            endpoint
+          end
+
+          def connect_socket
+            build_endpoint.connect
+          end
+
+          def connect
+            @socket = connect_socket
+            @driver = Client.new(@socket, url)
+          end
+        end
+      end
+    end
+  end
+end
+
+if Gem::Version.new(Async::WebSocket::VERSION) >= Gem::Version.new('0.9.0')
+  raise(
+    "Incompatible version of async-websocket, #{Async::WebSocket::VERSION}, " \
+    "use \"gem 'async-websocket', '~> 0.8.0'\"."
+  )
+end

data/lib/slack/real_time/concurrency/celluloid.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'websocket/driver'
 require 'socket'
 require 'forwardable'
@@ -36,30 +37,34 @@ module Slack
             loop { read } if socket
           rescue EOFError, Errno::ECONNRESET, Errno::EPIPE => e
             logger.debug("#{self.class}##{__method__}") { e }
-            driver.emit(:close, WebSocket::Driver::CloseEvent.new(1001, 'server closed connection')) unless @closing
-          ensure
-            begin
-              current_actor.terminate if current_actor.alive?
-            rescue StandardError
-              nil
+            unless @closing
+              driver.emit(
+                :close,
+                WebSocket::Driver::CloseEvent.new(1001, 'server closed connection')
+              )
             end
           end
 
+          def disconnect!
+            super
+            @ping_timer&.cancel
+          end
+
           def close
             @closing = true
-            driver.close
             super
           end
 
           def read
             buffer = socket.readpartial(BLOCK_SIZE)
             raise EOFError unless buffer && !buffer.empty?
+
             async.handle_read(buffer)
           end
 
           def handle_read(buffer)
             logger.debug("#{self.class}##{__method__}") { buffer }
-            driver.parse buffer
+            driver&.parse buffer
           end
 
           def write(data)
@@ -69,15 +74,34 @@ module Slack
 
           def start_async(client)
             @client = client
+            Actor.new(future.run_ping_loop)
             Actor.new(future.run_client_loop)
           end
 
           def run_client_loop
             @client.run_loop
+          rescue StandardError => e
+            logger.debug("#{self.class}##{__method__}") { e }
+            raise e
+          end
+
+          def run_ping_loop
+            return unless @client.run_ping?
+
+            @ping_timer = every @client.websocket_ping_timer do
+              @client.run_ping!
+            end
+          end
+
+          def restart_async(client, new_url)
+            @last_message_at = current_time
+            @url = new_url
+            @client = client
+            Actor.new(future.run_client_loop)
           end
 
           def connected?
-            !@connected.nil?
+            !@connected.nil? && !@driver.nil?
           end
 
           protected

data/lib/slack/real_time/concurrency/eventmachine.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'faye/websocket'
 require 'eventmachine'
 
@@ -6,12 +7,10 @@ module Slack
     module Concurrency
       module Eventmachine
         class Client < Faye::WebSocket::Client
-          attr_reader :logger
-          protected :logger
-
           def initialize(url, protocols = nil, options = {})
-            @logger = options.delete(:logger) || Slack::RealTime::Config.logger || Slack::Config.logger
-            super
+            @logger =
+              options.fetch(:logger) || Slack::RealTime::Config.logger || Slack::Config.logger
+            super url, protocols, options.except(:logger)
           end
 
           def parse(data)
@@ -23,15 +22,41 @@ module Slack
             logger.debug("#{self.class}##{__method__}") { data }
             super data
           end
+
+          protected
+
+          attr_reader :logger
         end
 
         class Socket < Slack::RealTime::Socket
           def start_async(client)
-            thread = ensure_reactor_running
+            @thread = ensure_reactor_running
+
+            if client.run_ping?
+              EventMachine.add_periodic_timer client.websocket_ping_timer do
+                client.run_ping!
+              end
+            end
 
             client.run_loop
 
-            thread
+            @thread
+          end
+
+          def restart_async(client, new_url)
+            @url = new_url
+            @last_message_at = current_time
+            @thread = ensure_reactor_running
+
+            client.run_loop
+
+            @thread
+          end
+
+          def disconnect!
+            super
+            EventMachine.stop_event_loop if EventMachine.reactor_running?
+            @thread = nil
           end
 
           def send_data(message)

data/lib/slack/real_time/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Config
@@ -36,7 +37,7 @@ module Slack
       private
 
       def detect_concurrency
-        %i[Eventmachine Celluloid].each do |concurrency|
+        %i[Async Eventmachine Celluloid].each do |concurrency|
           begin
             return Slack::RealTime::Concurrency.const_get(concurrency)
           rescue LoadError, NameError
@@ -44,7 +45,11 @@ module Slack
           end
         end
 
-        raise NoConcurrencyError, 'Missing concurrency. Add faye-websocket or celluloid-io to your Gemfile.'
+        raise(
+          NoConcurrencyError,
+          'Missing concurrency. Add async-websocket, faye-websocket ' \
+          'or celluloid-io to your Gemfile.'
+        )
       end
     end
 

data/lib/slack/real_time/models.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'models/base'
 require_relative 'models/user'
 require_relative 'models/bot'

data/lib/slack/real_time/models/base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/bot.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/channel.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/group.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/im.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/team.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/models/user.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models

data/lib/slack/real_time/socket.rb

@@ -1,25 +1,25 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     class Socket
       attr_accessor :url
       attr_accessor :options
       attr_reader :driver
-      attr_reader :logger
-      protected :logger
 
       def initialize(url, options = {})
         @url = url
         @options = options
         @driver = nil
         @logger = options.delete(:logger) || Slack::RealTime::Config.logger || Slack::Config.logger
+        @last_message_at = nil
       end
 
       def send_data(message)
         logger.debug("#{self.class}##{__method__}") { message }
         case message
-        when Numeric then driver.text(message.to_s)
-        when String  then driver.text(message)
-        when Array   then driver.binary(message)
+        when Numeric then @driver.text(message.to_s)
+        when String  then @driver.text(message)
+        when Array   then @driver.binary(message)
         else false
         end
       end
@@ -28,24 +28,31 @@ module Slack
         return if connected?
 
         connect
-        logger.debug("#{self.class}##{__method__}") { driver.class }
+        logger.debug("#{self.class}##{__method__}") { @driver.class }
+
+        @driver.on :message do
+          @last_message_at = current_time
+        end
 
-        yield driver if block_given?
+        yield @driver if block_given?
       end
 
+      # Gracefully shut down the connection.
       def disconnect!
-        driver.close
+        @driver.close
+      ensure
+        close
       end
 
       def connected?
-        !driver.nil?
+        !@driver.nil?
       end
 
       def start_sync(client)
         thread = start_async(client)
-        thread.join if thread
+        thread&.join
       rescue Interrupt
-        thread.exit if thread
+        thread&.exit
       end
 
       # @return [#join]
@@ -53,12 +60,34 @@ module Slack
         raise NotImplementedError, "Expected #{self.class} to implement #{__method__}."
       end
 
+      def restart_async(_client, _url)
+        raise NotImplementedError, "Expected #{self.class} to implement #{__method__}."
+      end
+
+      def time_since_last_message
+        return 0 unless @last_message_at
+
+        current_time - @last_message_at
+      end
+
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def close
+        # When you call `driver.emit(:close)`, it will typically end up calling `client.close`
+        # which will call `@socket.close` and end up back here. In order to break this infinite
+        # recursion, we check and set `@driver = nil` before invoking `client.close`.
+        return unless (driver = @driver)
+
         @driver = nil
+        driver.emit(:close)
       end
 
       protected
 
+      attr_reader :logger
+
       def addr
         URI(url).host
       end
@@ -69,9 +98,9 @@ module Slack
 
       def port
         case (uri = URI(url)).scheme
-        when 'wss'.freeze, 'https'.freeze
+        when 'wss', 'https'
           URI::HTTPS::DEFAULT_PORT
-        when 'ws', 'http'.freeze
+        when 'ws', 'http'
           URI::HTTP::DEFAULT_PORT
         else
           uri.port