slack-ruby-client 0.13.1 → 2.0.0

data/lib/slack/real_time/client.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     class Client
       class ClientNotStartedError < StandardError; end
+
       class ClientAlreadyStartedError < StandardError; end
 
       include Api::MessageId
@@ -9,19 +11,9 @@ module Slack
       include Api::Message
       include Api::Typing
 
-      @events = {}
-
-      class << self
-        attr_accessor :events
-      end
-
-      attr_accessor :web_client
-      attr_accessor :store
-      attr_accessor :url
-      attr_accessor(*Config::ATTRIBUTES)
+      attr_accessor :web_client, :store, :url, *Config::ATTRIBUTES
 
-      protected :logger, :logger=
-      protected :store_class, :store_class=
+      protected :store_class, :store_class=, :store_options, :store_options=
 
       def initialize(options = {})
         @callbacks = Hash.new { |h, k| h[k] = [] }
@@ -33,9 +25,9 @@ module Slack
         @web_client = Slack::Web::Client.new(token: token, logger: logger)
       end
 
-      %i[users self channels team teams groups ims bots].each do |store_method|
+      [:self, :team, *Stores::Base::CACHES].each do |store_method|
         define_method store_method do
-          store.send(store_method) if store
+          store&.send(store_method)
         end
       end
 
@@ -46,26 +38,27 @@ module Slack
 
       # Start RealTime client and block until it disconnects.
       def start!(&block)
-        @callback = block if block_given?
-        @socket = build_socket
+        @callback = block if block
+        build_socket
         @socket.start_sync(self)
       end
 
       # Start RealTime client and return immediately.
       # The RealTime::Client will run in the background.
       def start_async(&block)
-        @callback = block if block_given?
-        @socket = build_socket
+        @callback = block if block
+        build_socket
         @socket.start_async(self)
       end
 
       def stop!
         raise ClientNotStartedError unless started?
-        @socket.disconnect! if @socket
+
+        @socket&.disconnect!
       end
 
       def started?
-        @socket && @socket.connected?
+        @socket&.connected?
       end
 
       class << self
@@ -80,48 +73,105 @@ module Slack
 
       def run_loop
         @socket.connect! do |driver|
-          @callback.call(driver) if @callback
-
           driver.on :open do |event|
-            logger.debug("#{self.class}##{__method__}") { event.class.name }
-            open(event)
+            logger.debug("#{self}##{__method__}") { event.class.name }
+            open_event(event)
             callback(event, :open)
           end
 
           driver.on :message do |event|
-            logger.debug("#{self.class}##{__method__}") { "#{event.class}, #{event.data}" }
+            logger.debug("#{self}##{__method__}") { "#{event.class}, #{event.data}" }
             dispatch(event)
           end
 
           driver.on :close do |event|
-            logger.debug("#{self.class}##{__method__}") { event.class.name }
+            logger.debug("#{self}##{__method__}") { event.class.name }
             callback(event, :close)
             close(event)
             callback(event, :closed)
           end
+
+          # This must be called last to ensure any events are registered before invoking user code.
+          @callback&.call(driver)
+        end
+      end
+
+      # Ensure the server is running, and ping the remote server if no other messages were sent.
+      def keep_alive?
+        # We can't ping the remote server if we aren't connected.
+        return false if @socket.nil? || !@socket.connected?
+
+        time_since_last_message = @socket.time_since_last_message
+
+        # If the server responded within the specified time, we are okay:
+        return true if time_since_last_message < websocket_ping
+
+        # If the server has not responded for a while:
+        return false if time_since_last_message > (websocket_ping * 2)
+
+        # Kick off the next ping message:
+        ping
+
+        true
+      end
+
+      # Check if the remote server is responsive, and if not, restart the connection.
+      def run_ping!
+        return if keep_alive?
+
+        logger.warn(to_s) { 'is offline' }
+
+        restart_async
+      rescue Slack::Web::Api::Errors::SlackError => e
+        # stop pinging if bot was uninstalled
+        case e.message
+        when 'account_inactive', 'invalid_auth'
+          logger.warn(to_s) { e.message }
+          raise e
+        end
+        logger.debug("#{self}##{__method__}") { e }
+      rescue StandardError => e
+        # disregard all ping worker failures, keep pinging
+        logger.debug("#{self}##{__method__}") { e }
+      end
+
+      def run_ping?
+        !websocket_ping.nil? && websocket_ping.positive?
+      end
+
+      def websocket_ping_timer
+        websocket_ping / 2
+      end
+
+      def to_s
+        if store&.team
+          "id=#{store.team.id}, name=#{store.team.name}, domain=#{store.team.domain}"
+        else
+          super
         end
       end
 
       protected
 
+      def restart_async
+        logger.debug("#{self}##{__method__}")
+        @socket.close
+        start = web_client.rtm_connect(start_options)
+        data = Slack::Messages::Message.new(start)
+        @url = data.url
+        @store = store_class.new(data, store_options.to_h) if store_class
+        @socket.restart_async(self, @url)
+      end
+
       # @return [Slack::RealTime::Socket]
       def build_socket
         raise ClientAlreadyStartedError if started?
-        start = web_client.send(rtm_start_method, start_options)
+
+        start = web_client.rtm_connect(start_options)
         data = Slack::Messages::Message.new(start)
         @url = data.url
-        @store = @store_class.new(data) if @store_class
-        socket_class.new(@url, socket_options)
-      end
-
-      def rtm_start_method
-        if start_method
-          start_method
-        elsif @store_class && @store_class <= Slack::RealTime::Stores::Store
-          :rtm_start
-        else
-          :rtm_connect
-        end
+        @store = store_class.new(data, store_options.to_h) if store_class
+        @socket = socket_class.new(@url, socket_options)
       end
 
       def socket_options
@@ -133,23 +183,22 @@ module Slack
       end
 
       attr_reader :callbacks
+
       def socket_class
         concurrency::Socket
       end
 
       def send_json(data)
         raise ClientNotStartedError unless started?
-        logger.debug("#{self.class}##{__method__}") { data }
+
+        logger.debug("#{self}##{__method__}") { data }
         @socket.send_data(data.to_json)
       end
 
-      def open(_event); end
+      def open_event(_event); end
 
       def close(_event)
-        socket = @socket
-        @socket = nil
-
-        [socket, socket_class].each do |s|
+        [@socket, socket_class].each do |s|
           s.close if s.respond_to?(:close)
         end
       end
@@ -157,50 +206,52 @@ module Slack
       def callback(event, type)
         callbacks = self.callbacks[type.to_s]
         return false unless callbacks
+
         callbacks.each do |c|
           c.call(event)
         end
         true
       rescue StandardError => e
-        logger.error e
+        logger.error("#{self}##{__method__}") { e }
         false
       end
 
       def dispatch(event)
         return false unless event.data
+
         data = Slack::Messages::Message.new(JSON.parse(event.data))
         type = data.type
         return false unless type
+
         type = type.to_s
-        logger.debug("#{self.class}##{__method__}") { data.to_s }
+        logger.debug("#{self}##{__method__}") { data.to_s }
         run_handlers(type, data) if @store
         run_callbacks(type, data)
       rescue StandardError => e
-        logger.error e
+        logger.error("#{self}##{__method__}") { e }
         false
       end
 
       def run_handlers(type, data)
         handlers = store.class.events[type.to_s]
-        if handlers
-          handlers.each do |handler|
-            store.instance_exec(data, &handler)
-          end
+        handlers.each do |handler|
+          store.instance_exec(data, self, &handler)
         end
       rescue StandardError => e
-        logger.error e
+        logger.error("#{self}##{__method__}") { e }
         false
       end
 
       def run_callbacks(type, data)
         callbacks = self.callbacks[type]
         return false unless callbacks
+
         callbacks.each do |c|
           c.call(data)
         end
         true
       rescue StandardError => e
-        logger.error e
+        logger.error("#{self}##{__method__}") { e }
         false
       end
     end

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
 require 'async/websocket'
+require 'async/notification'
+require 'async/clock'
 
 module Slack
   module RealTime
@@ -12,28 +15,89 @@ module Slack
         class Socket < Slack::RealTime::Socket
           attr_reader :client
 
+          def start_sync(client)
+            start_reactor(client).wait
+          end
+
           def start_async(client)
             Thread.new do
-              ::Async::Reactor.run do
-                client.run_loop
+              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|
+                  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
+
+                @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
-            @closing = true
-            @driver.close if @driver
             super
+          ensure
+            if @socket
+              @socket.close
+              @socket = nil
+            end
           end
 
           def run_loop
-            @closing = false
-            while @driver && @driver.next_event
+            while @driver&.next_event
               # $stderr.puts event.inspect
             end
           end
@@ -65,3 +129,10 @@ module Slack
     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.rb

@@ -1,9 +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
   end
 end

data/lib/slack/real_time/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Config
@@ -10,22 +11,23 @@ module Slack
         websocket_ping
         websocket_proxy
         concurrency
-        start_method
         start_options
         store_class
+        store_options
         logger
       ].freeze
 
-      attr_accessor(*Config::ATTRIBUTES)
+      attr_accessor(*Config::ATTRIBUTES - [:concurrency])
+      attr_writer :concurrency
 
       def reset
         self.websocket_ping = 30
         self.websocket_proxy = nil
         self.token = nil
         self.concurrency = method(:detect_concurrency)
-        self.start_method = nil
         self.start_options = { request: { timeout: 180 } }
-        self.store_class = Slack::RealTime::Store
+        self.store_class = Slack::RealTime::Stores::Starter
+        self.store_options = {}
         self.logger = nil
       end
 
@@ -36,15 +38,9 @@ module Slack
       private
 
       def detect_concurrency
-        %i[Async Eventmachine Celluloid].each do |concurrency|
-          begin
-            return Slack::RealTime::Concurrency.const_get(concurrency)
-          rescue LoadError, NameError
-            false # could not be loaded, missing dependencies
-          end
-        end
-
-        raise NoConcurrencyError, 'Missing concurrency. Add async-websocket, faye-websocket or celluloid-io to your Gemfile.'
+        Slack::RealTime::Concurrency.const_get(:Async)
+      rescue LoadError, NameError
+        raise NoConcurrencyError, 'Missing concurrency. Add async-websocket to your Gemfile.'
       end
     end
 

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

@@ -1,11 +1,8 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models
       class Base < Hashie::Mash
-        def presence
-          super['presence']
-        end
-
         # see https://github.com/intridea/hashie/issues/394
         def log_built_in_message(*); end
       end

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,7 +1,12 @@
+# frozen_string_literal: true
+
 module Slack
   module RealTime
     module Models
       class Channel < Base
+        def is_public? # rubocop:disable Naming/PredicateName
+          !is_private?
+        end
       end
     end
   end

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/{group.rb → mpim.rb}

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Models
-      class Group < Base
+      class Mpim < Base
       end
     end
   end

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/models.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require_relative 'models/base'
 require_relative 'models/user'
 require_relative 'models/bot'
 require_relative 'models/channel'
-require_relative 'models/group'
 require_relative 'models/team'
 require_relative 'models/im'
+require_relative 'models/mpim'

data/lib/slack/real_time/socket.rb

@@ -1,25 +1,24 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     class Socket
-      attr_accessor :url
-      attr_accessor :options
+      attr_accessor :url, :options
       attr_reader :driver
-      attr_reader :logger
-      protected :logger
 
       def initialize(url, options = {})
         @url = url
-        @options = options
+        @options = options.dup
         @driver = nil
-        @logger = options.delete(:logger) || Slack::RealTime::Config.logger || Slack::Config.logger
+        @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 +27,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 +59,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 +97,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