slack-ruby-client 0.7.9 → 0.16.0

data/lib/slack/logger.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
 require 'logger'
 
 module Slack
   class Logger < ::Logger
     def self.default
-      @logger ||= begin
-        logger = new STDOUT
-        logger.level = Logger::WARN
-        logger
-      end
+      return @default if @default
+
+      logger = new STDOUT
+      logger.level = Logger::WARN
+      @default = logger
     end
   end
 end

data/lib/slack/messages/formatting.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 module Slack
   module Messages
     module Formatting
@@ -10,9 +10,9 @@ module Slack
         def unescape(message)
           CGI.unescapeHTML(message.gsub(/[“”]/, '"')
             .gsub(/[‘’]/, "'")
-            .gsub(/<(?<sign>[?@#!]?)(?<dt>.*?)>/) do |match|
-              sign = $~[:sign]
-              dt = $~[:dt]
+            .gsub(/<(?<sign>[?@#!]?)(?<dt>.*?)>/) do
+              sign = Regexp.last_match[:sign]
+              dt = Regexp.last_match[:dt]
               rhs = dt.split('|', 2).last
               case sign
               when '@', '!'

data/lib/slack/messages/message.rb

@@ -1,10 +1,7 @@
+# frozen_string_literal: true
 module Slack
   module Messages
     class Message < Hashie::Mash
-      def presence
-        super['presence']
-      end
-
       def to_s
         keys.sort_by(&:to_s).map do |key|
           "#{key}=#{self[key]}"
@@ -14,8 +11,7 @@ module Slack
       private
 
       # see https://github.com/intridea/hashie/issues/394
-      def log_built_in_message(*)
-      end
+      def log_built_in_message(*); end
     end
   end
 end

data/lib/slack/real_time/api/message.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Api
@@ -6,7 +7,8 @@ module Slack
         # Sends a message to a channel.
         #
         # @option options [channel] :channel
-        #   Channel to send message to. Can be a public channel, private group or IM channel. Can be an encoded ID, or a name.
+        #   Channel to send message to. Can be a public channel, private group or IM channel.
+        #   Can be an encoded ID, or a name.
         # @option options [Object] :text
         #   Text of the message to send. See below for an explanation of formatting.
         def message(options = {})

data/lib/slack/real_time/api/message_id.rb

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

data/lib/slack/real_time/api/ping.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Api
       module Ping
         #
-        # Clients should try to quickly detect disconnections, even in idle periods, so that users can easily tell the
-        # difference between being disconnected and everyone being quiet. Not all web browsers support the WebSocket
+        # Clients should try to quickly detect disconnections, even in idle periods, so that users
+        # can easily tell the
+        # difference between being disconnected and everyone being quiet. Not all web browsers
+        # support the WebSocket
         # ping spec, so the RTM protocol also supports ping/pong messages.
         #
         def ping(options = {})

data/lib/slack/real_time/api/templates/event_handler.erb

@@ -1,4 +1,4 @@
         # <%= desc %>
         # @see https://api.slack.com/events/<%= name %>
-        # @see https://github.com/dblock/slack-api-ref/blob/master/events/<%= name %>.json
+        # @see https://github.com/slack-ruby/slack-api-ref/blob/master/events/<%= name %>.json
         # on :<%= name %> do |data|

data/lib/slack/real_time/api/typing.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     module Api
@@ -6,7 +7,8 @@ module Slack
         # Send a typing indicator to indicate that the user is currently writing a message.
         #
         # @option options [channel] :channel
-        #   Channel to send message to. Can be a public channel, private group or IM channel. Can be an encoded ID, or a name.
+        #   Channel to send message to. Can be a public channel, private group or IM channel.
+        #   Can be an encoded ID, or a name.
         def typing(options = {})
           throw ArgumentError.new('Required arguments :channel missing') if options[:channel].nil?
           send_json({ type: 'typing', id: next_id }.merge(options))

data/lib/slack/real_time/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module RealTime
     class Client
@@ -20,7 +21,6 @@ module Slack
       attr_accessor :url
       attr_accessor(*Config::ATTRIBUTES)
 
-      protected :logger, :logger=
       protected :store_class, :store_class=
 
       def initialize(options = {})
@@ -33,9 +33,9 @@ module Slack
         @web_client = Slack::Web::Client.new(token: token, logger: logger)
       end
 
-      [:users, :self, :channels, :team, :teams, :groups, :ims, :bots].each do |store_method|
+      %i[users self channels team teams groups ims bots].each do |store_method|
         define_method store_method do
-          store.send(store_method) if store
+          store&.send(store_method)
         end
       end
 
@@ -47,7 +47,7 @@ module Slack
       # Start RealTime client and block until it disconnects.
       def start!(&block)
         @callback = block if block_given?
-        @socket = build_socket
+        build_socket
         @socket.start_sync(self)
       end
 
@@ -55,17 +55,18 @@ module Slack
       # The RealTime::Client will run in the background.
       def start_async(&block)
         @callback = block if block_given?
-        @socket = build_socket
+        build_socket
         @socket.start_async(self)
       end
 
       def stop!
-        fail ClientNotStartedError unless started?
-        @socket.disconnect! if @socket
+        raise ClientNotStartedError unless started?
+
+        @socket&.disconnect!
       end
 
       def started?
-        @socket && @socket.connected?
+        @socket&.connected?
       end
 
       class << self
@@ -80,38 +81,115 @@ 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' then
+          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.send(rtm_start_method, start_options)
+        data = Slack::Messages::Message.new(start)
+        @url = data.url
+        @store = @store_class.new(data) if @store_class
+        @socket.restart_async(self, @url)
+      end
+
       # @return [Slack::RealTime::Socket]
       def build_socket
-        fail ClientAlreadyStartedError if started?
-        start = web_client.rtm_start(start_options)
+        raise ClientAlreadyStartedError if started?
+
+        start = web_client.send(rtm_start_method, 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)
+        @socket = 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
       end
 
       def socket_options
@@ -128,19 +206,16 @@ module Slack
       end
 
       def send_json(data)
-        fail ClientNotStartedError unless started?
-        logger.debug("#{self.class}##{__method__}") { data }
+        raise ClientNotStartedError unless started?
+
+        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
@@ -148,48 +223,54 @@ 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)
+        return unless store.class.events
+
         handlers = store.class.events[type.to_s]
-        handlers.each do |handler|
+        handlers&.each do |handler|
           store.instance_exec(data, &handler)
-        end if handlers
+        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.rb

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

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

@@ -0,0 +1,140 @@
+# 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)
+            endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: build_ssl_context) if secure?
+            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