discordrb 3.3.0 → 3.5.0

data/lib/discordrb/events/voice_server_update.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Event raised when a server's voice server is updating.
+  # Sent when initially connecting to voice and when a voice instance fails
+  # over to a new server.
+  # This event is exposed for use with library agnostic interfaces like telecom and
+  # lavalink.
+  class VoiceServerUpdateEvent < Event
+    # @return [String] The voice connection token
+    attr_reader :token
+
+    # @return [Server] The server this update is for.
+    attr_reader :server
+
+    # @return [String] The voice server host.
+    attr_reader :endpoint
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @token = data['token']
+      @endpoint = data['endpoint']
+      @server = bot.server(data['guild_id'])
+    end
+  end
+
+  # Event handler for VoiceServerUpdateEvent
+  class VoiceServerUpdateEventHandler < EventHandler
+    def matches?(event)
+      return false unless event.is_a? VoiceServerUpdateEvent
+
+      [
+        matches_all(@attributes[:from], event.server) do |a, e|
+          a == if a.is_a? String
+                 e.name
+               else
+                 e
+               end
+        end
+      ]
+    end
+  end
+end

data/lib/discordrb/events/voice_state_update.rb

@@ -38,37 +38,38 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:from], event.user) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
                end
         end,
         matches_all(@attributes[:mute], event.mute) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:deaf], event.deaf) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:self_mute], event.self_mute) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
                end
         end,
         matches_all(@attributes[:self_deaf], event.self_deaf) do |a, e|
-          a == if a.is_a?(TrueClass) || a.is_a?(FalseClass)
+          a == if a.is_a? String
                  e.to_s
                else
                  e
@@ -76,9 +77,11 @@ module Discordrb::Events
         end,
         matches_all(@attributes[:channel], event.channel) do |a, e|
           next unless e # Don't bother if the channel is nil
-          a == if a.is_a? String
+
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
@@ -86,9 +89,11 @@ module Discordrb::Events
         end,
         matches_all(@attributes[:old_channel], event.old_channel) do |a, e|
           next unless e # Don't bother if the channel is nil
-          a == if a.is_a? String
+
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e

data/lib/discordrb/events/webhooks.rb

@@ -28,28 +28,31 @@ module Discordrb::Events
 
       [
         matches_all(@attributes[:server], event.server) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e
                end
         end,
         matches_all(@attributes[:channel], event.channel) do |a, e|
-          if a.is_a? String
+          case a
+          when String
             # Make sure to remove the "#" from channel names in case it was specified
             a.delete('#') == e.name
-          elsif a.is_a? Integer
+          when Integer
             a == e.id
           else
             a == e
           end
         end,
         matches_all(@attributes[:webhook], event) do |a, e|
-          a == if a.is_a? String
+          a == case a
+               when String
                  e.name
-               elsif a.is_a? Integer
+               when Integer
                  e.id
                else
                  e

data/lib/discordrb/gateway.rb

@@ -25,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
@@ -136,7 +134,7 @@ module Discordrb
     LARGE_THRESHOLD = 100
 
     # The version of the gateway that's supposed to be used.
-    GATEWAY_VERSION = 6
+    GATEWAY_VERSION = 9
 
     # 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
@@ -145,20 +143,22 @@ module Discordrb
     # @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)
+    # @return [Integer] the intent parameter sent to the gateway server.
+    attr_reader :intents
+
+    def initialize(bot, token, shard_key = nil, compress_mode = :stream, intents = ALL_INTENTS)
       @token = token
       @bot = bot
 
       @shard_key = shard_key
 
-      @getc_mutex = Mutex.new
-
       # 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
@@ -170,8 +170,19 @@ 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).
@@ -181,16 +192,16 @@ module Discordrb
 
     # 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
@@ -241,7 +252,7 @@ module Discordrb
     def heartbeat
       if check_heartbeat_acks
         unless @last_heartbeat_acked
-          # We're in a bad situation - apparently the last heartbeat wasn't acked, which means the connection is likely
+          # 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')
 
@@ -269,12 +280,12 @@ module Discordrb
     def identify
       compress = @compress_mode == :large
       send_identify(@token, {
-                      '$os': RUBY_PLATFORM,
-                      '$browser': 'discordrb',
-                      '$device': 'discordrb',
-                      '$referrer': '',
-                      '$referring_domain': ''
-                    }, compress, 100, @shard_key)
+                      os: RUBY_PLATFORM,
+                      browser: 'discordrb',
+                      device: 'discordrb',
+                      referrer: '',
+                      referring_domain: ''
+                    }, compress, LARGE_THRESHOLD, @shard_key, @intents)
     end
 
     # Sends an identify packet (op 2). This starts a new session on the current connection and tells Discord who we are.
@@ -284,24 +295,25 @@ module Discordrb
     # @param properties [Hash<Symbol => String>] A list of properties for Discord to use in analytics. The following
     #   keys are recognised:
     #
-    #    - "$os" (recommended value: the operating system the bot is running on)
-    #    - "$browser" (recommended value: library name)
-    #    - "$device" (recommended value: library name)
-    #    - "$referrer" (recommended value: empty)
-    #    - "$referring_domain" (recommended value: empty)
+    #    - "os" (recommended value: the operating system the bot is running on)
+    #    - "browser" (recommended value: library name)
+    #    - "device" (recommended value: library name)
+    #    - "referrer" (recommended value: empty)
+    #    - "referring_domain" (recommended value: empty)
     #
     # @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.
     # @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)
+    def send_identify(token, properties, compress, large_threshold, shard_key = nil, intents = ALL_INTENTS)
       data = {
         # Don't send a v anymore as it's entirely determined by the URL now
         token: token,
         properties: properties,
         compress: compress,
-        large_threshold: large_threshold
+        large_threshold: large_threshold,
+        intents: intents
       }
 
       # Don't include the shard key at all if it is nil as Discord checks for its mere existence
@@ -312,7 +324,7 @@ module Discordrb
 
     # 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.
@@ -360,7 +372,7 @@ module Discordrb
       @instant_reconnect = true
       @should_reconnect = true
 
-      close
+      close(4000)
     end
 
     # Sends a resume packet (op 6). This replays all events from a previous point specified by its packet sequence. This
@@ -402,12 +414,12 @@ module Discordrb
 
     # 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 op [Integer] The opcode the packet should be sent as. Can be one of {Opcodes} or a custom value if
+    # @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-serialisable data that should be sent as the `d` field.
-    def send_packet(op, packet)
+    # @param packet [Object] Some arbitrary JSON-serializable data that should be sent as the `d` field.
+    def send_packet(opcode, packet)
       data = {
-        op: op,
+        op: opcode,
         d: packet
       }
 
@@ -436,20 +448,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
@@ -502,7 +512,7 @@ module Discordrb
           cert_store.set_default_paths
           ctx.cert_store = cert_store
         else
-          ctx.set_params ssl_version: :TLSv1_2
+          ctx.set_params ssl_version: :TLSv1_2 # rubocop:disable Naming/VariableNumber
         end
 
         socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
@@ -567,7 +577,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
@@ -584,13 +594,17 @@ module Discordrb
           unless @socket
             LOGGER.warn('Socket is nil in websocket_loop! Reconnecting')
             handle_internal_close('Socket is nil in websocket_loop')
+            next
           end
 
-          recv_data = nil
-
-          # Get some data from the socket, synchronised so the socket can't be closed during this
-          # 24: remove locking
-          @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
@@ -621,7 +635,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
@@ -645,12 +659,13 @@ module Discordrb
     ZLIB_SUFFIX = "\x00\x00\xFF\xFF".b.freeze
 
     def handle_message(msg)
-      if @compress_mode == :large
+      case @compress_mode
+      when :large
         if msg.byteslice(0) == 'x'
           # The message is compressed, inflate it
           msg = Zlib::Inflate.inflate(msg)
         end
-      elsif @compress_mode == :stream
+      when :stream
         # Write deflated string to buffer
         @zlib_reader << msg
 
@@ -703,6 +718,7 @@ 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
@@ -750,7 +766,7 @@ module Discordrb
       LOGGER.debug("Trace: #{packet['d']['_trace']}")
       LOGGER.debug("Session: #{@session.inspect}")
 
-      if @session && @session.should_resume?
+      if @session&.should_resume?
         # Make sure we're sending heartbeats again
         @session.resume
 
@@ -773,22 +789,41 @@ 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.
+    # - 4014: Use of disabled privileged intents.
+    FATAL_CLOSE_CODES = [4003, 4004, 4011, 4014].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}")
+
+        if e.code == 4014
+          LOGGER.error(<<~ERROR)
+            You attempted to identify with privileged intents that your bot is not authorized to use
+            Please enable the privileged intents on the bot page of your application on the discord developer page.
+            Read more here https://discord.com/developers/docs/topics/gateway#privileged-intents
+          ERROR
+        end
+
+        @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(data, type = :text)
+    def send(data, type = :text, code = nil)
       LOGGER.out(data)
 
       unless @handshaked && !@closed
@@ -797,40 +832,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 => 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

data/lib/discordrb/id_object.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # Mixin for objects that have IDs
+  module IDObject
+    # @return [Integer] the ID which uniquely identifies this object across Discord.
+    attr_reader :id
+    alias_method :resolve_id, :id
+    alias_method :hash, :id
+
+    # ID based comparison
+    def ==(other)
+      Discordrb.id_compare(@id, other)
+    end
+
+    alias_method :eql?, :==
+
+    # Estimates the time this object was generated on based on the beginning of the ID. This is fairly accurate but
+    # shouldn't be relied on as Discord might change its algorithm at any time
+    # @return [Time] when this object was created at
+    def creation_time
+      # Milliseconds
+      ms = (@id >> 22) + DISCORD_EPOCH
+      Time.at(ms / 1000.0)
+    end
+
+    # Creates an artificial snowflake at the given point in time. Useful for comparing against.
+    # @param time [Time] The time the snowflake should represent.
+    # @return [Integer] a snowflake with the timestamp data as the given time
+    def self.synthesise(time)
+      ms = (time.to_f * 1000).to_i
+      (ms - DISCORD_EPOCH) << 22
+    end
+
+    class << self
+      alias_method :synthesize, :synthesise
+    end
+  end
+end

data/lib/discordrb/light/integrations.rb

@@ -49,7 +49,7 @@ module Discordrb::Light
     #   Twitch account connection of the server owner).
     attr_reader :server_connection
 
-    # @return [Connection] the connection integrated with the server (i. e. your connection)
+    # @return [Connection] the connection integrated with the server (i.e. your connection)
     attr_reader :integrated_connection
 
     # @!visibility private

data/lib/discordrb/light/light_bot.rb

@@ -6,7 +6,7 @@ require 'discordrb/api/user'
 require 'discordrb/light/data'
 require 'discordrb/light/integrations'
 
-# This module contains classes to allow connections to bots without a connection to the gateway socket, i. e. bots
+# This module contains classes to allow connections to bots without a connection to the gateway socket, i.e. bots
 # that only use the REST part of the API.
 module Discordrb::Light
   # A bot that only uses the REST part of the API. Hierarchically unrelated to the regular {Discordrb::Bot}. Useful to

data/lib/discordrb/logger.rb

@@ -2,7 +2,7 @@
 
 module Discordrb
   # The format log timestamps should be in, in strftime format
-  LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'.freeze
+  LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
 
   # Logs debug messages
   class Logger
@@ -18,7 +18,7 @@ module Discordrb
     # Creates a new logger.
     # @param fancy [true, false] Whether this logger uses fancy mode (ANSI escape codes to make the output colourful)
     # @param streams [Array<IO>, Array<#puts & #flush>] the streams the logger should write to.
-    def initialize(fancy = false, streams = [STDOUT])
+    def initialize(fancy = false, streams = [$stdout])
       @fancy = fancy
       self.mode = :normal
 
@@ -38,10 +38,10 @@ module Discordrb
     }.freeze
 
     # The ANSI format code that resets formatting
-    FORMAT_RESET = "\u001B[0m".freeze
+    FORMAT_RESET = "\u001B[0m"
 
     # The ANSI format code that makes something bold
-    FORMAT_BOLD = "\u001B[1m".freeze
+    FORMAT_BOLD = "\u001B[1m"
 
     MODES.each do |mode, hash|
       define_method(mode) do |message|