discordrb 3.1.1 → 3.4.0

data/lib/discordrb/events/webhooks.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Event raised when a webhook is updated
+  class WebhookUpdateEvent < Event
+    # @return [Server] the server where the webhook updated
+    attr_reader :server
+
+    # @return [Channel] the channel the webhook is associated to
+    attr_reader :channel
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data['guild_id'].to_i)
+      @channel = bot.channel(data['channel_id'].to_i)
+    end
+  end
+
+  # Event handler for {WebhookUpdateEvent}
+  class WebhookUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? WebhookUpdateEvent
+
+      [
+        matches_all(@attributes[:server], event.server) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end,
+        matches_all(@attributes[:channel], event.channel) do |a, e|
+          case a
+          when String
+            # Make sure to remove the "#" from channel names in case it was specified
+            a.delete('#') == e.name
+          when Integer
+            a == e.id
+          else
+            a == e
+          end
+        end,
+        matches_all(@attributes[:webhook], event) do |a, e|
+          a == case a
+               when String
+                 e.name
+               when Integer
+                 e.id
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+end

data/lib/discordrb/gateway.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file uses code from Websocket::Client::Simple, licensed under the following license:
 #
 # Copyright (c) 2013-2014 Sho Hashimoto
@@ -23,8 +25,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'thread'
-
 module Discordrb
   # Gateway packet opcodes
   module Opcodes
@@ -72,8 +72,9 @@ module Discordrb
     # members when it receives them. (Sending this is never necessary for a gateway client to behave correctly)
     REQUEST_MEMBERS = 8
 
-    # **Received**: The functionality of this opcode is less known than the others but it appears to specifically
-    # tell the client to invalidate its local session and continue by {IDENTIFY}ing.
+    # **Received**: Sent by Discord when the session becomes invalid for any reason. This may include improperly
+    # resuming existing sessions, attempting to start sessions with invalid data, or something else entirely. The client
+    # should handle this by simply starting a new session.
     INVALIDATE_SESSION = 9
 
     # **Received**: Sent immediately for any opened connection; tells the client to start heartbeating early on, so the
@@ -93,12 +94,13 @@ module Discordrb
     attr_accessor :sequence
 
     def initialize(session_id)
-      @id = session_id
+      @session_id = session_id
       @sequence = 0
       @suspended = false
       @invalid = false
     end
 
+    # Flags this session as suspended, so we know not to try and send heartbeats, etc. to the gateway until we've reconnected
     def suspend
       @suspended = true
     end
@@ -107,6 +109,12 @@ module Discordrb
       @suspended
     end
 
+    # Flags this session as no longer being suspended, so we can resume
+    def resume
+      @suspended = false
+    end
+
+    # Flags this session as being invalid
     def invalidate
       @invalid = true
     end
@@ -128,14 +136,26 @@ module Discordrb
     # The version of the gateway that's supposed to be used.
     GATEWAY_VERSION = 6
 
-    def initialize(bot, token)
+    # Heartbeat ACKs are Discord's way of verifying on the client side whether the connection is still alive. If this is
+    # set to true (default value) the gateway client will use that functionality to detect zombie connections and
+    # reconnect in such a case; however it may lead to instability if there's some problem with the ACKs. If this occurs
+    # it can simply be set to false.
+    # @return [true, false] whether or not this gateway should check for heartbeat ACKs.
+    attr_accessor :check_heartbeat_acks
+
+    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = nil)
       @token = token
       @bot = bot
 
-      @getc_mutex = Mutex.new
+      @shard_key = shard_key
 
       # Whether the connection to the gateway has succeeded yet
       @ws_success = false
+
+      @check_heartbeat_acks = true
+
+      @compress_mode = compress_mode
+      @intents = intents
     end
 
     # Connect to the gateway server in a separate thread
@@ -147,27 +167,41 @@ module Discordrb
       end
 
       LOGGER.debug('WS thread created! Now waiting for confirmation that everything worked')
-      sleep(0.5) until @ws_success
-      LOGGER.debug('Confirmation received! Exiting run.')
+      loop do
+        sleep(0.5)
+
+        if @ws_success
+          LOGGER.debug('Confirmation received! Exiting run.')
+          break
+        end
+
+        if @should_reconnect == false
+          LOGGER.debug('Reconnection flag was unset. Exiting run.')
+          break
+        end
+      end
     end
 
-    # Prevents all further execution until the websocket thread stops (e. g. through a closed connection).
+    # Prevents all further execution until the websocket thread stops (e.g. through a closed connection).
     def sync
       @ws_thread.join
     end
 
     # Whether the WebSocket connection to the gateway is currently open
     def open?
-      @handshake && @handshake.finished? && !@closed
+      @handshake&.finished? && !@closed
     end
 
     # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
     # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
     #
     # If this method doesn't work or you're looking for something more drastic, use {#kill} instead.
-    def stop(no_sync = false)
+    def stop
       @should_reconnect = false
-      close(no_sync)
+      close
+
+      # Return nil so command bots don't send a message
+      nil
     end
 
     # Kills the websocket thread, stopping all connections to Discord.
@@ -213,6 +247,21 @@ module Discordrb
     # before it), or if none have been received yet, with 0.
     # @see #send_heartbeat
     def heartbeat
+      if check_heartbeat_acks
+        unless @last_heartbeat_acked
+          # We're in a bad situation - apparently the last heartbeat wasn't ACK'd, which means the connection is likely
+          # a zombie. Reconnect
+          LOGGER.warn('Last heartbeat was not acked, so this is a zombie connection! Reconnecting')
+
+          # We can't send anything on zombie connections
+          @pipe_broken = true
+          reconnect
+          return
+        end
+
+        @last_heartbeat_acked = false
+      end
+
       send_heartbeat(@session ? @session.sequence : 0)
     end
 
@@ -226,13 +275,14 @@ module Discordrb
     # Identifies to Discord with the default parameters.
     # @see #send_identify
     def identify
+      compress = @compress_mode == :large
       send_identify(@token, {
-                      :'$os' => RUBY_PLATFORM,
-                      :'$browser' => 'discordrb',
-                      :'$device' => 'discordrb',
-                      :'$referrer' => '',
-                      :'$referring_domain' => ''
-                    }, true, 100)
+                      '$os': RUBY_PLATFORM,
+                      '$browser': 'discordrb',
+                      '$device': 'discordrb',
+                      '$referrer': '',
+                      '$referring_domain': ''
+                    }, compress, 100, @shard_key)
     end
 
     # Sends an identify packet (op 2). This starts a new session on the current connection and tells Discord who we are.
@@ -251,7 +301,9 @@ module Discordrb
     # @param compress [true, false] Whether certain large packets should be compressed using zlib.
     # @param large_threshold [Integer] The member threshold after which a server counts as large and will have to have
     #   its member list chunked.
-    def send_identify(token, properties, compress, large_threshold)
+    # @param shard_key [Array(Integer, Integer), nil] The shard key to use for sharding, represented as
+    #   [shard_id, num_shards], or nil if the bot should not be sharded.
+    def send_identify(token, properties, compress, large_threshold, shard_key = nil)
       data = {
         # Don't send a v anymore as it's entirely determined by the URL now
         token: token,
@@ -259,13 +311,17 @@ module Discordrb
         compress: compress,
         large_threshold: large_threshold
       }
+      data[:intents] = @intents unless @intents.nil?
+
+      # Don't include the shard key at all if it is nil as Discord checks for its mere existence
+      data[:shard] = shard_key if shard_key
 
       send_packet(Opcodes::IDENTIFY, data)
     end
 
     # Sends a status update packet (op 3). This sets the bot user's status (online/idle/...) and game playing/streaming.
     # @param status [String] The status that should be set (`online`, `idle`, `dnd`, `invisible`).
-    # @param since [Integer] The unix timestamp in milliseconds when the status was set. Should only be provided when
+    # @param since [Integer] The Unix timestamp in milliseconds when the status was set. Should only be provided when
     #   `afk` is true.
     # @param game [Hash<Symbol => Object>, nil] `nil` if no game should be played, or a hash of `:game => "name"` if a
     #   game should be played. The hash can also contain additional attributes for streaming statuses.
@@ -305,6 +361,17 @@ module Discordrb
       send_resume(@token, @session.session_id, @session.sequence)
     end
 
+    # Reconnects the gateway connection in a controlled manner.
+    # @param attempt_resume [true, false] Whether a resume should be attempted after the reconnection.
+    def reconnect(attempt_resume = true)
+      @session.suspend if @session && attempt_resume
+
+      @instant_reconnect = true
+      @should_reconnect = true
+
+      close(4000)
+    end
+
     # Sends a resume packet (op 6). This replays all events from a previous point specified by its packet sequence. This
     # will not work if the packet to resume from has already been acknowledged using a heartbeat, or if the session ID
     # belongs to a now invalid session.
@@ -342,9 +409,35 @@ module Discordrb
       send_packet(Opcodes::REQUEST_MEMBERS, data)
     end
 
+    # Sends a custom packet over the connection. This can be useful to implement future yet unimplemented functionality
+    # or for testing. You probably shouldn't use this unless you know what you're doing.
+    # @param opcode [Integer] The opcode the packet should be sent as. Can be one of {Opcodes} or a custom value if
+    #   necessary.
+    # @param packet [Object] Some arbitrary JSON-serializable data that should be sent as the `d` field.
+    def send_packet(opcode, packet)
+      data = {
+        op: opcode,
+        d: packet
+      }
+
+      send(data.to_json)
+    end
+
+    # Sends custom raw data over the connection. Only useful for testing; even if you know what you're doing you
+    # probably want to use {#send_packet} instead.
+    # @param data [String] The data to send.
+    # @param type [Symbol] The type the WebSocket frame should have; either `:text`, `:binary`, `:ping`, `:pong`, or
+    #   `:close`.
+    def send_raw(data, type = :text)
+      send(data, type)
+    end
+
     private
 
     def setup_heartbeats(interval)
+      # Make sure to reset ACK handling, so we don't keep reconnecting
+      @last_heartbeat_acked = true
+
       # We don't want to have redundant heartbeat threads, so if one already exists, don't start a new one
       return if @heartbeat_thread
 
@@ -352,20 +445,18 @@ module Discordrb
       @heartbeat_thread = Thread.new do
         Thread.current[:discordrb_name] = 'heartbeat'
         loop do
-          begin
-            # Send a heartbeat if heartbeats are active and either no session exists yet, or an existing session is
-            # suspended (e.g. after op7)
-            if (@session && !@session.suspended?) || !@session
-              sleep @heartbeat_interval
-              @bot.raise_heartbeat_event
-              heartbeat
-            else
-              sleep 1
-            end
-          rescue => e
-            LOGGER.error('An error occurred while heartbeating!')
-            LOGGER.log_exception(e)
+          # Send a heartbeat if heartbeats are active and either no session exists yet, or an existing session is
+          # suspended (e.g. after op7)
+          if (@session && !@session.suspended?) || !@session
+            sleep @heartbeat_interval
+            @bot.raise_heartbeat_event
+            heartbeat
+          else
+            sleep 1
           end
+        rescue StandardError => e
+          LOGGER.error('An error occurred while heartbeating!')
+          LOGGER.log_exception(e)
         end
       end
     end
@@ -381,14 +472,13 @@ module Discordrb
         break unless @should_reconnect
 
         if @instant_reconnect
-          # We got an op 7! Don't wait before reconnecting
-          LOGGER.info('Got an op 7, reconnecting right away')
+          LOGGER.info('Instant reconnection flag was set - reconnecting right away')
           @instant_reconnect = false
         else
           wait_for_reconnect
         end
 
-        # Restart the loop, i. e. reconnect
+        # Restart the loop, i.e. reconnect
       end
     end
 
@@ -410,14 +500,19 @@ module Discordrb
 
       if secure_uri?(uri)
         ctx = OpenSSL::SSL::SSLContext.new
-        ctx.ssl_version = 'SSLv23'
-        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE # use VERIFY_PEER for verification
 
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.set_default_paths
-        ctx.cert_store = cert_store
+        if ENV['DISCORDRB_SSL_VERIFY_NONE']
+          ctx.ssl_version = 'SSLv23'
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE # use VERIFY_PEER for verification
+
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.set_default_paths
+          ctx.cert_store = cert_store
+        else
+          ctx.set_params ssl_version: :TLSv1_2 # rubocop:disable Naming/VariableNumber
+        end
 
-        socket = ::OpenSSL::SSL::SSLSocket.new(socket, ctx)
+        socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
         socket.connect
       end
 
@@ -426,7 +521,7 @@ module Discordrb
 
     # Whether the URI is secure (connection should be encrypted)
     def secure_uri?(uri)
-      %w(https wss).include? uri.scheme
+      %w[https wss].include? uri.scheme
     end
 
     # The port we should connect to, if the URI doesn't have one set.
@@ -445,8 +540,13 @@ module Discordrb
       # Append a slash in case it's not there (I'm not sure how well WSCS handles it otherwise)
       raw_url += '/' unless raw_url.end_with? '/'
 
-      # Add the parameters we want
-      raw_url + "?encoding=json&v=#{GATEWAY_VERSION}"
+      query = if @compress_mode == :stream
+                "?encoding=json&v=#{GATEWAY_VERSION}&compress=zlib-stream"
+              else
+                "?encoding=json&v=#{GATEWAY_VERSION}"
+              end
+
+      raw_url + query
     end
 
     def connect
@@ -459,6 +559,9 @@ module Discordrb
       # Parse it
       gateway_uri = URI.parse(url)
 
+      # Zlib context for this gateway connection
+      @zlib_reader = Zlib::Inflate.new
+
       # Connect to the obtained URI with a socket
       @socket = obtain_socket(gateway_uri)
       LOGGER.debug('Obtained socket')
@@ -471,7 +574,7 @@ module Discordrb
 
       # We're done! Delegate to the websocket loop
       websocket_loop
-    rescue => e
+    rescue StandardError => e
       LOGGER.error('An error occurred while connecting to the websocket!')
       LOGGER.log_exception(e)
     end
@@ -485,10 +588,20 @@ module Discordrb
 
       until @closed
         begin
-          recv_data = nil
+          unless @socket
+            LOGGER.warn('Socket is nil in websocket_loop! Reconnecting')
+            handle_internal_close('Socket is nil in websocket_loop')
+            next
+          end
 
-          # Get some data from the socket, synchronised so the socket can't be closed during this
-          @getc_mutex.synchronize { recv_data = @socket.getc }
+          # Get some data from the socket
+          begin
+            recv_data = @socket.readpartial(4096)
+          rescue EOFError
+            @pipe_broken = true
+            handle_internal_close('Socket EOF in websocket_loop')
+            next
+          end
 
           # Check if we actually got data
           unless recv_data
@@ -519,7 +632,7 @@ module Discordrb
             # If the handshake hasn't finished, handle it
             handle_handshake_data(recv_data)
           end
-        rescue => e
+        rescue StandardError => e
           handle_error(e)
         end
       end
@@ -533,18 +646,31 @@ module Discordrb
       handle_open
     end
 
-    def handle_open
-    end
+    def handle_open; end
 
     def handle_error(e)
       LOGGER.error('An error occurred in the main websocket loop!')
       LOGGER.log_exception(e)
     end
 
+    ZLIB_SUFFIX = "\x00\x00\xFF\xFF".b.freeze
+
     def handle_message(msg)
-      if msg.byteslice(0) == 'x'
-        # The message is compressed, inflate it
-        msg = Zlib::Inflate.inflate(msg)
+      case @compress_mode
+      when :large
+        if msg.byteslice(0) == 'x'
+          # The message is compressed, inflate it
+          msg = Zlib::Inflate.inflate(msg)
+        end
+      when :stream
+        # Write deflated string to buffer
+        @zlib_reader << msg
+
+        # Check if message ends in `ZLIB_SUFFIX`
+        return if msg.bytesize < 4 || msg.byteslice(-4, 4) != ZLIB_SUFFIX
+
+        # Inflate the deflated buffer
+        msg = @zlib_reader.inflate('')
       end
 
       # Parse packet
@@ -571,6 +697,8 @@ module Discordrb
         handle_invalidate_session
       when Opcodes::HEARTBEAT_ACK
         handle_heartbeat_ack(packet)
+      when Opcodes::HEARTBEAT
+        handle_heartbeat(packet)
       else
         LOGGER.warn("Received invalid opcode #{op} - please report with this information: #{msg}")
       end
@@ -587,24 +715,28 @@ module Discordrb
 
         @session = Session.new(data['session_id'])
         @session.sequence = 0
+        @bot.__send__(:notify_ready) if @intents && (@intents & INTENTS[:servers]).zero?
       when :RESUMED
         # The RESUMED event is received after a successful op 6 (resume). It does nothing except tell the bot the
         # connection is initiated (like READY would). Starting with v5, it doesn't set a new heartbeat interval anymore
         # since that is handled by op 10 (HELLO).
-        LOGGER.debug('Connection resumed')
+        LOGGER.info 'Resumed'
         return
       end
 
       @bot.dispatch(type, data)
     end
 
+    # Op 1
+    def handle_heartbeat(packet)
+      # If we receive a heartbeat, we have to resend one with the same sequence
+      send_heartbeat(packet['s'])
+    end
+
     # Op 7
     def handle_reconnect
-      @instant_reconnect = true
-      close
-
-      # Suspend session so we resume afterwards
-      @session.suspend
+      LOGGER.debug('Received op 7, reconnecting and attempting resume')
+      reconnect
     end
 
     # Op 9
@@ -629,8 +761,13 @@ module Discordrb
       setup_heartbeats(interval)
 
       LOGGER.debug("Trace: #{packet['d']['_trace']}")
+      LOGGER.debug("Session: #{@session.inspect}")
+
+      if @session&.should_resume?
+        # Make sure we're sending heartbeats again
+        @session.resume
 
-      if @session && @session.should_resume?
+        # Send the actual resume packet to get the missing events
         resume
       else
         identify
@@ -640,6 +777,7 @@ module Discordrb
     # Op 11
     def handle_heartbeat_ack(packet)
       LOGGER.debug("Received heartbeat ack for packet: #{packet.inspect}")
+      @last_heartbeat_acked = true if @check_heartbeat_acks
     end
 
     # Called when the websocket has been disconnected in some way - say due to a pipe error while sending
@@ -648,31 +786,31 @@ module Discordrb
       handle_close(e)
     end
 
+    # Close codes that are unrecoverable, after which we should not try to reconnect.
+    # - 4003: Not authenticated. How did this happen?
+    # - 4004: Authentication failed. Token was wrong, nothing we can do.
+    # - 4011: Sharding required. Currently requires developer intervention.
+    FATAL_CLOSE_CODES = [4003, 4004, 4011].freeze
+
     def handle_close(e)
+      @bot.__send__(:raise_event, Events::DisconnectEvent.new(@bot))
+
       if e.respond_to? :code
         # It is a proper close frame we're dealing with, print reason and message to console
         LOGGER.error('Websocket close frame received!')
         LOGGER.error("Code: #{e.code}")
         LOGGER.error("Message: #{e.data}")
+        @should_reconnect = false if FATAL_CLOSE_CODES.include?(e.code)
       elsif e.is_a? Exception
         # Log the exception
         LOGGER.error('The websocket connection has closed due to an error!')
         LOGGER.log_exception(e)
       else
-        LOGGER.error("The websocket connection has closed: #{e.inspect}")
+        LOGGER.error("The websocket connection has closed: #{e&.inspect || '(no information)'}")
       end
     end
 
-    def send_packet(op, packet)
-      data = {
-        op: op,
-        d: packet
-      }
-
-      send(data.to_json)
-    end
-
-    def send(data, type = :text)
+    def send(data, type = :text, code = nil)
       LOGGER.out(data)
 
       unless @handshaked && !@closed
@@ -681,40 +819,33 @@ module Discordrb
       end
 
       # Create the frame we're going to send
-      frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @handshake.version)
+      frame = ::WebSocket::Frame::Outgoing::Client.new(data: data, type: type, version: @handshake.version, code: code)
 
       # Try to send it
       begin
         @socket.write frame.to_s
-      rescue Errno::EPIPE => e
+      rescue StandardError => e
         # There has been an error!
         @pipe_broken = true
         handle_internal_close(e)
       end
     end
 
-    def close(no_sync = false)
+    def close(code = 1000)
       # If we're already closed, there's no need to do anything - return
       return if @closed
 
       # Suspend the session so we don't send heartbeats
-      @session.suspend if @session
+      @session&.suspend
 
       # Send a close frame (if we can)
-      send nil, :close unless @pipe_broken
+      send nil, :close, code unless @pipe_broken
 
       # We're officially closed, notify the main loop.
-      # This needs to be synchronised with the getc mutex, so the notification, and especially the actual
-      # close afterwards, don't coincide with the main loop reading something from the SSL socket.
-      # This would cause a segfault due to (I suspect) Ruby bug #12292: https://bugs.ruby-lang.org/issues/12292
-      if no_sync
-        @closed = true
-      else
-        @getc_mutex.synchronize { @closed = true }
-      end
+      @closed = true
 
       # Close the socket if possible
-      @socket.close if @socket
+      @socket&.close
       @socket = nil
 
       # Make sure we do necessary things as soon as we're closed