slack-ruby-client 0.12.0 → 0.14.6

data/examples/new_ticket/new_ticket.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'slack-ruby-client'
 
 Slack.configure do |config|

data/lib/slack-ruby-client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'slack/version'
 require_relative 'slack/logger'
 require_relative 'slack/config'
@@ -14,18 +15,19 @@ require 'json'
 require 'logger'
 begin
   require 'picky'
-rescue LoadError
+rescue LoadError # rubocop:disable Lint/HandleExceptions
   # ignore, only used in users_search
 end
 begin
   require 'openssl'
-rescue LoadError
+rescue LoadError # rubocop:disable Lint/HandleExceptions
   # Used in slack/web/config
 end
 require_relative 'slack/web/config'
 require_relative 'slack/web/api/errors/slack_error'
 require_relative 'slack/web/api/errors/too_many_requests_error'
 require_relative 'slack/web/api/error'
+require_relative 'slack/web/api/errors'
 require_relative 'slack/web/faraday/response/raise_error'
 require_relative 'slack/web/faraday/connection'
 require_relative 'slack/web/faraday/request'
@@ -47,3 +49,7 @@ require_relative 'slack/real_time/models'
 require_relative 'slack/real_time/stores'
 require_relative 'slack/real_time/config'
 require_relative 'slack/real_time/client'
+
+# Events API
+require_relative 'slack/events/config'
+require_relative 'slack/events/request'

data/lib/slack.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 require 'slack-ruby-client'

data/lib/slack/config.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Config
     extend self

data/lib/slack/events/config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Slack
+  module Events
+    module Config
+      extend self
+
+      ATTRIBUTES = %i[
+        signing_secret
+        signature_expires_in
+      ].freeze
+
+      attr_accessor(*Config::ATTRIBUTES)
+
+      def reset
+        self.signing_secret = ENV['SLACK_SIGNING_SECRET']
+        self.signature_expires_in = 5 * 60
+      end
+    end
+
+    class << self
+      def configure
+        block_given? ? yield(Config) : Config
+      end
+
+      def config
+        Config
+      end
+    end
+  end
+end
+
+Slack::Events::Config.reset

data/lib/slack/events/request.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Slack
+  module Events
+    class Request
+      class MissingSigningSecret < StandardError; end
+      class TimestampExpired < StandardError; end
+      class InvalidSignature < StandardError; end
+
+      attr_reader :http_request,
+                  :signing_secret,
+                  :signature_expires_in
+
+      def initialize(http_request, options = {})
+        @http_request = http_request
+        @signing_secret = options[:signing_secret] || Slack::Events.config.signing_secret
+        @signature_expires_in =
+          options[:signature_expires_in] || Slack::Events.config.signature_expires_in
+      end
+
+      # Request timestamp.
+      def timestamp
+        @timestamp ||= http_request.headers['X-Slack-Request-Timestamp']
+      end
+
+      # The signature is created by combining the signing secret with the body of the request
+      # Slack is sending using a standard HMAC-SHA256 keyed hash.
+      def signature
+        @signature ||= http_request.headers['X-Slack-Signature']
+      end
+
+      # Signature version.
+      def version
+        'v0'
+      end
+
+      # Request body.
+      def body
+        @body ||= http_request.body.read
+      end
+
+      # Returns true if the signature coming from Slack has expired.
+      def expired?
+        timestamp.nil? || (Time.now.to_i - timestamp.to_i).abs > signature_expires_in
+      end
+
+      # Returns true if the signature coming from Slack is valid.
+      def valid?
+        raise MissingSigningSecret unless signing_secret
+
+        digest = OpenSSL::Digest::SHA256.new
+        signature_basestring = [version, timestamp, body].join(':')
+        hex_hash = OpenSSL::HMAC.hexdigest(digest, signing_secret, signature_basestring)
+        computed_signature = [version, hex_hash].join('=')
+        computed_signature == signature
+      end
+
+      # Validates the request signature and its expiration.
+      def verify!
+        raise TimestampExpired if expired?
+        raise InvalidSignature unless valid?
+
+        true
+      end
+    end
+  end
+end

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,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Messages
     module Formatting

data/lib/slack/messages/message.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Slack
   module Messages
     class Message < Hashie::Mash

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/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
@@ -19,8 +20,8 @@ module Slack
       attr_accessor :store
       attr_accessor :url
       attr_accessor(*Config::ATTRIBUTES)
+      attr_accessor :logger
 
-      protected :logger, :logger=
       protected :store_class, :store_class=
 
       def initialize(options = {})
@@ -35,7 +36,7 @@ module Slack
 
       %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 +48,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 +56,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!
         raise ClientNotStartedError unless started?
-        @socket.disconnect! if @socket
+
+        @socket&.disconnect!
       end
 
       def started?
-        @socket && @socket.connected?
+        @socket&.connected?
       end
 
       class << self
@@ -80,38 +82,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' 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
         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
@@ -139,17 +208,15 @@ module Slack
 
       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 +224,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, &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