slack-ruby-client 0.13.1 → 0.14.0

data/lib/slack/events/request.rb

@@ -0,0 +1,60 @@
+module Slack
+  module Events
+    class Request
+      class MissingSigningSecret < StandardError; end
+      class TimestampExpired < StandardError; end
+      class InvalidSignature < StandardError; end
+
+      attr_reader :http_request
+
+      def initialize(http_request)
+        @http_request = http_request
+      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 > Slack::Events.config.signature_expires_in
+      end
+
+      # Returns true if the signature coming from Slack is valid.
+      def valid?
+        raise MissingSigningSecret unless Slack::Events.config.signing_secret
+
+        digest = OpenSSL::Digest::SHA256.new
+        signature_basestring = [version, timestamp, body].join(':')
+        hex_hash = OpenSSL::HMAC.hexdigest(digest, Slack::Events.config.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/real_time/client.rb

@@ -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,12 +55,13 @@ 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
       end
 
@@ -102,16 +103,41 @@ module Slack
         end
       end
 
+      def run_ping!
+        time_since_last_message = @socket.time_since_last_message
+        return if time_since_last_message < websocket_ping
+        raise Slack::RealTime::Client::ClientNotStartedError if !@socket.connected? || time_since_last_message > (websocket_ping * 2)
+
+        ping
+      rescue Slack::RealTime::Client::ClientNotStartedError
+        restart_async
+      end
+
+      def run_ping?
+        !websocket_ping.nil? && websocket_ping > 0
+      end
+
       protected
 
+      def restart_async
+        logger.debug("#{self.class}##{__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,6 +165,7 @@ module Slack
 
       def send_json(data)
         raise ClientNotStartedError unless started?
+
         logger.debug("#{self.class}##{__method__}") { data }
         @socket.send_data(data.to_json)
       end
@@ -146,10 +173,7 @@ module Slack
       def open(_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,6 +181,7 @@ module Slack
       def callback(event, type)
         callbacks = self.callbacks[type.to_s]
         return false unless callbacks
+
         callbacks.each do |c|
           c.call(event)
         end
@@ -168,9 +193,11 @@ module Slack
 
       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 }
         run_handlers(type, data) if @store
@@ -195,6 +222,7 @@ module Slack
       def run_callbacks(type, data)
         callbacks = self.callbacks[type]
         return false unless callbacks
+
         callbacks.each do |c|
           c.call(data)
         end

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

@@ -1,9 +1,14 @@
 require 'async/websocket'
+require 'async/clock'
 
 module Slack
   module RealTime
     module Concurrency
       module Async
+        class Reactor < ::Async::Reactor
+          def_delegators :@timers, :cancel
+        end
+
         class Client < ::Async::WebSocket::Client
           extend ::Forwardable
           def_delegators :@driver, :on, :text, :binary, :emit
@@ -13,13 +18,40 @@ module Slack
           attr_reader :client
 
           def start_async(client)
+            @reactor = Reactor.new
             Thread.new do
-              ::Async::Reactor.run do
-                client.run_loop
+              if client.run_ping?
+                @reactor.every(client.websocket_ping) do
+                  client.run_ping!
+                end
+              end
+              @reactor.run do |task|
+                task.async do
+                  client.run_loop
+                end
               end
             end
           end
 
+          def restart_async(client, new_url)
+            @url = new_url
+            @last_message_at = current_time
+            return unless @reactor
+
+            @reactor.async do
+              client.run_loop
+            end
+          end
+
+          def disconnect!
+            super
+            @reactor.cancel
+          end
+
+          def current_time
+            ::Async::Clock.now
+          end
+
           def connect!
             super
             run_loop

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

@@ -37,29 +37,29 @@ module Slack
           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
-            end
+          end
+
+          def disconnect!
+            super
+            @ping_timer.cancel if @ping_timer
           end
 
           def close
             @closing = true
-            driver.close
+            driver.close if driver
             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 if driver
           end
 
           def write(data)
@@ -70,14 +70,33 @@ module Slack
           def start_async(client)
             @client = client
             Actor.new(future.run_client_loop)
+            Actor.new(future.run_ping_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 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

@@ -10,8 +10,8 @@ module Slack
           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)
@@ -29,17 +29,38 @@ module Slack
           def start_async(client)
             @thread = ensure_reactor_running
 
+            if client.run_ping?
+              EventMachine.add_periodic_timer(client.websocket_ping) do
+                client.run_ping!
+              end
+            end
+
             client.run_loop
 
             @thread
           end
 
-          def close
+          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 if @thread
+            EventMachine.stop_event_loop if EventMachine.reactor_running?
             @thread = nil
           end
 
+          def close
+            driver.close if driver
+            super
+          end
+
           def send_data(message)
             logger.debug("#{self.class}##{__method__}") { message }
             driver.send(message)

data/lib/slack/real_time/socket.rb

@@ -12,6 +12,7 @@ module Slack
         @options = options
         @driver = nil
         @logger = options.delete(:logger) || Slack::RealTime::Config.logger || Slack::Config.logger
+        @last_message_at = nil
       end
 
       def send_data(message)
@@ -30,6 +31,10 @@ module Slack
         connect
         logger.debug("#{self.class}##{__method__}") { driver.class }
 
+        driver.on :message do
+          @last_message_at = current_time
+        end
+
         yield driver if block_given?
       end
 
@@ -53,6 +58,20 @@ 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
         @driver = nil
       end

data/lib/slack/real_time/stores/store.rb

@@ -369,6 +369,7 @@ module Slack
         # @see https://github.com/slack-ruby/slack-api-ref/blob/master/events/im_close.json
         on :im_close do |data|
           return unless ims && ims.key?(data.channel)
+
           ims[data.channel].is_open = false
         end
 
@@ -394,6 +395,7 @@ module Slack
         # @see https://github.com/slack-ruby/slack-api-ref/blob/master/events/im_open.json
         on :im_open do |data|
           return unless ims && ims.key?(data.channel)
+
           ims[data.channel].is_open = true
         end
 

data/lib/slack/version.rb

@@ -1,3 +1,3 @@
 module Slack
-  VERSION = '0.13.1'.freeze
+  VERSION = '0.14.0'.freeze
 end

data/lib/slack/web/api/endpoints.rb

@@ -1,6 +1,7 @@
 # This file was auto-generated by lib/tasks/web.rake
 
 require_relative 'endpoints/api'
+require_relative 'endpoints/apps'
 require_relative 'endpoints/apps_permissions'
 require_relative 'endpoints/apps_permissions_resources'
 require_relative 'endpoints/apps_permissions_scopes'
@@ -44,6 +45,7 @@ module Slack
         include Slack::Web::Api::Mixins::Groups
 
         include Api
+        include Apps
         include AppsPermissions
         include AppsPermissionsResources
         include AppsPermissionsScopes

data/lib/slack/web/api/endpoints/apps.rb

@@ -0,0 +1,26 @@
+# This file was auto-generated by lib/tasks/web.rake
+
+module Slack
+  module Web
+    module Api
+      module Endpoints
+        module Apps
+          #
+          # Uninstalls your app from a workspace.
+          #
+          # @option options [Object] :client_id
+          #   Issued when you created your application.
+          # @option options [Object] :client_secret
+          #   Issued when you created your application.
+          # @see https://api.slack.com/methods/apps.uninstall
+          # @see https://github.com/slack-ruby/slack-api-ref/blob/master/methods/apps/apps.uninstall.json
+          def apps_uninstall(options = {})
+            throw ArgumentError.new('Required arguments :client_id missing') if options[:client_id].nil?
+            throw ArgumentError.new('Required arguments :client_secret missing') if options[:client_secret].nil?
+            post('apps.uninstall', options)
+          end
+        end
+      end
+    end
+  end
+end