discorb 0.15.1 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bc9c7d6433e9e093a0d58d821ed97e3f001d63224c9f65eb1693a2ee3d16f7d
-  data.tar.gz: daff87553c1996cbc1a68765ee3df54947f46b7660fc1a16f0a17a0e0660e2c7
+  metadata.gz: 6537aa3c45f64e6b0e8040a5a0d989934fb58d766ee6de305bf04132630a7b94
+  data.tar.gz: 68512bc0d2abd0738cc6e81ba2b794feb87480d6d84197a51a6deba739d31d5a
 SHA512:
-  metadata.gz: dceaba51436368feeb9e99bc4afda5cea9ac45aa0525bb44cdd33c427fef6c6617d17bf1a56b27acac137df05b4d6f27395e22883ce574e4e48d3e7a8ca05a13
-  data.tar.gz: 81622ca789eee2f8c55b4fd98e7c0bdc602d164247602508c8b041757d61fcb77f659d01142db8a8c16b9dd6e6cc402ebf9f45cf881e787a77449ba4831b8376
+  metadata.gz: 239e4658a2ade0ea8382655970a1eecbb3c62c7c3619e3de8fdf932c1c0a4053e35b722bef5dcdbd67477754388cc3c157c9be6360ef7625fe9f84504b5ecf90
+  data.tar.gz: d830a06c7a505ee31aeb3242e7aa59dadf6abab24a26c357b9e29e5f94d5fef7a889b114d4b7793ffda3f50b19a6be0c3f87921934393b03e71c5f50bfa96de4

data/Changelog.md

@@ -4,6 +4,15 @@
 
 # Changelog
 
+## v0.16
+
+### v0.16.0
+
+- Change!: Use built-in Logger instead of custom Logger.
+- Delete!: `--log-level`, `--[no-]log-color` is deleted.
+- Add: Support sharding
+- Add: Use Mutex for preventing connection duplications.
+
 ## v0.15
 
 ### v0.15.1

data/docs/events.md

@@ -30,13 +30,13 @@ class << client
 end
 ```
 
-If you want to seperate event handlers from the client, consider using {Discorb::Extension}. {file:docs/extension.md Learn more about extensions}.
+If you want to separate event handlers from the client, consider using {Discorb::Extension}. {file:docs/extension.md Learn more about extensions}.
 
-Since v0.6.1, you can set `:override` to `true` to register overridable event handlers.
+Since v0.6.1, you can set `:override` to `true` to register event handlers that can be overridden.
 
 ```ruby
 client.on :message, override: true do |event|
-  puts "This event handler is overrideable!"
+  puts "This event handler can be overridden."
 end
 
 client.on :message do |event|
@@ -44,8 +44,8 @@ client.on :message do |event|
 end
 ```
 
-This example will print `Override!`, but not `This event handler is overrideable!`.
-This is useful for registering event handlers as default behaviour, such as error handlers.
+This example will print `Override!`, but not `This event handler can be overridden.`.
+This is useful for registering event handlers as default behavior, such as error handlers.
 
 ```ruby
 # In the library...
@@ -95,6 +95,22 @@ Defaults to printing the error to stderr, override to handle it yourself.
 Fires when `discorb setup` is run.
 This is useful for setting up some dependencies, such as the database.
 
+#### `shard_standby(shard)`
+
+Fires when a shard is standby.
+
+| Parameter  | Type  | Description |
+| ---------- | ----- | ----------- |
+|`shard`     | {Discorb::Shard} | The shard that is standby. |
+
+#### `shard_resumed(shard)`
+
+Fires when a shard is resumed connection.
+
+| Parameter  | Type  | Description |
+| ---------- | ----- | ----------- |
+|`shard`     | {Discorb::Shard} | The shard that is standby. |
+
 ### Guild events
 
 #### `guild_join(guild)`

data/examples/simple/rolepanel.rb

@@ -2,7 +2,7 @@
 require "discorb"
 intents = Discorb::Intents.new
 intents.members = true
-client = Discorb::Client.new(intents: intents, log: $stdout, colorize_log: true)
+client = Discorb::Client.new(intents: intents)
 
 def convert_role(guild, string)
   guild.roles.find do |role|

data/examples/simple/shard.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "discorb"
+
+client = Discorb::Client.new(log: Logger.new($stdout))
+
+client.once :standby do
+  puts "Logged in as #{client.user}"
+end
+
+client.on :message do |message|
+  next if message.author.bot?
+  next unless message.content == "!inspect"
+
+  message.channel.post("I'm #{client.user}, running on shard #{client.shard_id}!")
+end
+
+client.run(ENV["DISCORD_BOT_TOKEN"], shards: [0, 1], shard_count: 2)

data/lib/discorb/app_command/handler.rb

@@ -160,7 +160,7 @@ module Discorb
               end
             end
           end
-          @log.info "Successfully setup commands"
+          @logger.info "Successfully setup commands"
         end
       end
     end

data/lib/discorb/channel.rb

@@ -67,7 +67,7 @@ module Discorb
       descendants.each do |klass|
         return klass.new(client, data, no_cache: no_cache) if !klass.channel_type.nil? && klass.channel_type == data[:type]
       end
-      client.log.warn("Unknown channel type #{data[:type]}, initialized GuildChannel")
+      client.logger.warn("Unknown channel type #{data[:type]}, initialized GuildChannel")
       GuildChannel.new(client, data)
     end
 

data/lib/discorb/client.rb

@@ -40,8 +40,6 @@ module Discorb
     attr_reader :emojis
     # @return [Discorb::Dictionary{Discorb::Snowflake => Discorb::Message}] A dictionary of messages.
     attr_reader :messages
-    # @return [Discorb::Logger] The logger.
-    attr_reader :log
     # @return [Array<Discorb::ApplicationCommand::Command>] The commands that the client is using.
     attr_reader :commands
     # @return [Float] The ping of the client.
@@ -50,15 +48,28 @@ module Discorb
     attr_reader :ping
     # @return [:initialized, :running, :closed] The status of the client.
     attr_reader :status
-    # @return [Integer] The session ID of connection.
-    attr_reader :session_id
     # @return [Hash{String => Discorb::Extension}] The loaded extensions.
     attr_reader :extensions
-    #
+    # @return [Hash{Integer => Discorb::Shard}] The shards of the client.
+    attr_reader :shards
     # @private
     # @return [Hash{Discorb::Snowflake => Discorb::ApplicationCommand::Command}] The commands on the top level.
-    #
     attr_reader :bottom_commands
+    # @private
+    # @return [{String => Thread::Mutex}] A hash of mutexes.
+    attr_reader :mutex
+
+    # @!attribute [r] session_id
+    #   @return [String] The session ID of the client or current shard.
+    #   @return [nil] If not connected to the gateway.
+    # @!attribute [r] shard
+    #   @return [Discorb::Shard] The current shard. This is implemented with Thread variables.
+    #   @return [nil] If client has no shard.
+    # @!attribute [r] shard_id
+    #   @return [Discorb::Shard] The current shard ID. This is implemented with Thread variables.
+    #   @return [nil] If client has no shard.
+    # @!attribute [r] logger
+    #   @return [Logger] The logger.
 
     #
     # Initializes a new client.
@@ -66,8 +77,7 @@ module Discorb
     # @param [Discorb::AllowedMentions] allowed_mentions The allowed mentions that the client is using.
     # @param [Discorb::Intents] intents The intents that the client is currently using.
     # @param [Integer] message_caches The number of messages to cache.
-    # @param [#write] log The IO object to use for logging.
-    # @param [Boolean] colorize_log Whether to colorize the log.
+    # @param [Logger] logger The IO object to use for logging.
     # @param [:debug, :info, :warn, :error, :critical] log_level The log level.
     # @param [Boolean] wait_until_ready Whether to delay event dispatch until ready.
     # @param [Boolean] fetch_member Whether to fetch member on ready. This may slow down the client. Default to `false`.
@@ -75,7 +85,7 @@ module Discorb
     #
     def initialize(
       allowed_mentions: nil, intents: nil, message_caches: 1000,
-      log: nil, colorize_log: false, log_level: :info,
+      logger: nil,
       wait_until_ready: true, fetch_member: false,
       title: nil
     )
@@ -83,7 +93,7 @@ module Discorb
       @intents = (intents or Intents.default)
       @events = {}
       @api_version = nil
-      @log = Logger.new(log, colorize_log, log_level)
+      @logger = logger || Logger.new($stdout, progname: "discorb")
       @user = nil
       @users = Discorb::Dictionary.new
       @channels = Discorb::Dictionary.new
@@ -103,6 +113,8 @@ module Discorb
       @fetch_member = fetch_member
       @title = title
       @extensions = {}
+      @mutex = {}
+      @shards = {}
       set_default_events
     end
 
@@ -183,16 +195,16 @@ module Discorb
           events << event_method
         end
         if events.nil?
-          @log.debug "Event #{event_name} doesn't have any proc, skipping"
+          logger.debug "Event #{event_name} doesn't have any proc, skipping"
           next
         end
-        @log.debug "Dispatching event #{event_name}"
+        logger.debug "Dispatching event #{event_name}"
         events.each do |block|
           Async do
             Async(annotation: "Discorb event: #{event_name}") do |_task|
               @events[event_name].delete(block) if block.is_a?(Discorb::EventHandler) && block.metadata[:once]
               block.call(*args)
-              @log.debug "Dispatched proc with ID #{block.id.inspect}"
+              logger.debug "Dispatched proc with ID #{block.id.inspect}"
             rescue StandardError, ScriptError => e
               dispatch(:error, event_name, args, e)
             end
@@ -316,7 +328,7 @@ module Discorb
       }
       payload[:activities] = [activity.to_hash] unless activity.nil?
       payload[:status] = status unless status.nil?
-      if @connection
+      if connection
         Async do
           send_gateway(3, **payload)
         end
@@ -427,15 +439,15 @@ module Discorb
     #
     # @note If the token is nil, you should use `discorb run` with the `-e` or `--env` option.
     #
-    def run(token = nil)
+    def run(token = nil, shards: nil, shard_count: nil)
       token ||= ENV["DISCORB_CLI_TOKEN"]
       raise ArgumentError, "Token is not specified, and -e/--env is not specified" if token.nil?
       case ENV["DISCORB_CLI_FLAG"]
       when nil
-        start_client(token)
+        start_client(token, shards: shards, shard_count: shard_count)
       when "run"
         before_run(token)
-        start_client(token)
+        start_client(token, shards: shards, shard_count: shard_count)
       when "setup"
         run_setup(token)
       end
@@ -445,10 +457,33 @@ module Discorb
     # Stops the client.
     #
     def close!
-      @connection.send_close
+      if @shards.any?
+        @shards.each(&:close!)
+      else
+        @connection.send_close
+      end
       @tasks.each(&:stop)
       @status = :closed
-      @close_condition.signal
+    end
+
+    def session_id
+      if shard
+        shard.session_id
+      else
+        @session_id
+      end
+    end
+
+    def logger
+      shard&.logger || @logger
+    end
+
+    def shard
+      Thread.current.thread_variable_get("shard")
+    end
+
+    def shard_id
+      Thread.current.thread_variable_get("shard_id")
     end
 
     private
@@ -457,22 +492,6 @@ module Discorb
       require "json"
       options = JSON.parse(ENV["DISCORB_CLI_OPTIONS"], symbolize_names: true)
       setup_commands(token) if options[:setup]
-      if options[:log_level]
-        if options[:log_level] == "none"
-          @log.out = nil
-        else
-          @log.out = case options[:log_file]
-            when nil, "stderr"
-              $stderr
-            when "stdout"
-              $stdout
-            else
-              ::File.open(options[:log_file], "a")
-            end
-          @log.level = options[:log_level].to_sym
-          @log.colorize_log = options[:log_color].nil? ? @log.out.isatty : options[:log_color]
-        end
-      end
     end
 
     def run_setup(token)
@@ -490,32 +509,93 @@ module Discorb
       end
     end
 
-    def start_client(token)
-      Async do |_task|
-        Signal.trap(:SIGINT) do
-          @log.info "SIGINT received, closing..."
-          Signal.trap(:SIGINT, "DEFAULT")
-          close!
+    def set_status(status, shard)
+      if shard.nil?
+        @status = status
+      else
+        @shards[shard].status = status
+      end
+    end
+
+    def connection
+      if shard_id
+        @shards[shard_id].connection
+      else
+        @connection
+      end
+    end
+
+    def connection=(value)
+      if shard_id
+        @shards[shard_id].connection = value
+      else
+        @connection = value
+      end
+    end
+
+    def session_id=(value)
+      if shard_id
+        @shards[shard_id].session_id = value
+      else
+        @session_id = value
+      end
+    end
+
+    def start_client(token, shards: nil, shard_count: nil)
+      @token = token.to_s
+      @shard_count = shard_count
+      Signal.trap(:SIGINT) do
+        logger.info "SIGINT received, closing..."
+        Signal.trap(:SIGINT, "DEFAULT")
+        close!
+      end
+      if shards.nil?
+        main_loop(nil)
+      else
+        @shards = shards.map.with_index do |shard, i|
+          Shard.new(self, shard, shard_count, i)
         end
-        @token = token.to_s
-        @close_condition = Async::Condition.new
-        @main_task = Async do
-          @status = :running
-          connect_gateway(false).wait
-        rescue StandardError
-          @status = :stopped
-          @close_condition.signal
-          raise
+        @shards[..-1].each_with_index do |shard, i|
+          shard.next_shard = @shards[i + 1]
         end
-        @close_condition.wait
-        @main_task.stop
+        @shards.each { |s| s.thread.join }
+      end
+    end
+
+    def main_loop(shard)
+      close_condition = Async::Condition.new
+      self.main_task = Async do
+        set_status(:running, shard)
+        connect_gateway(false).wait
+      rescue StandardError
+        set_status(:running, shard)
+        close_condition.signal
+        raise
+      end
+      close_condition.wait
+      main_task.stop
+    end
+
+    def main_task
+      if shard_id
+        shard.main_task
+      else
+        @main_task
+      end
+    end
+
+    def main_task=(value)
+      if shard_id
+        shard.main_task = value
+      else
+        @main_task = value
       end
     end
 
     def set_default_events
       on :error, override: true do |event_name, _args, e|
         message = "An error occurred while dispatching #{event_name}:\n#{e.full_message}"
-        @log.error message, fallback: $stderr
+        logger.error message, fallback: $stderr
       end
 
       once :standby do

data/lib/discorb/common.rb

@@ -4,7 +4,7 @@ module Discorb
   # @return [String] The API base URL.
   API_BASE_URL = "https://discord.com/api/v10"
   # @return [String] The version of discorb.
-  VERSION = "0.15.1"
+  VERSION = "0.16.0"
   # @return [Array<Integer>] The version array of discorb.
   VERSION_ARRAY = VERSION.split(".").map(&:to_i).freeze
   # @return [String] The user agent for the bot.

data/lib/discorb/exe/new.rb

@@ -164,8 +164,8 @@ def git_init
   system "git add ."
   system "git commit -m \"Initial commit\""
   sputs "Initialized repository, use " \
-          "\e[32mgit commit --amend -m '...'\e[92m" \
-          " to change commit message of initial commit.\n"
+        "\e[32mgit commit --amend -m '...'\e[92m" \
+        " to change commit message of initial commit.\n"
 end
 
 # @private
@@ -228,9 +228,9 @@ if (dir = ARGV[0])
       iputs "Found \e[30m#{dir}\e[90m and empty, using this directory."
     elsif $values[:force]
       iputs "Found \e[30m#{dir}\e[90m and not empty, but force is on, using this directory."
-      else
-        eputs "Directory \e[31m#{dir}\e[91m already exists and not empty. Use \e[31m-f\e[91m to force."
-        exit
+    else
+      eputs "Directory \e[31m#{dir}\e[91m already exists and not empty. Use \e[31m-f\e[91m to force."
+      exit
     end
   else
     Dir.mkdir($path)

data/lib/discorb/exe/run.rb

@@ -4,10 +4,9 @@ require "optparse"
 require "json"
 require "discorb/utils/colored_puts"
 require "io/console"
+require "discorb"
 
 ARGV.delete_at 0
-# @private
-LOG_LEVELS = %w[none debug info warn error fatal].freeze
 
 opt = OptionParser.new <<~BANNER
                          This command will run a client.
@@ -18,23 +17,10 @@ opt = OptionParser.new <<~BANNER
                        BANNER
 options = {
   title: nil,
-  log_level: nil,
-  log_file: nil,
-  log_color: nil,
   setup: nil,
   token: false,
   bundler: :default,
 }
-opt.on("-l", "--log-level LEVEL", "Log level.") do |v|
-  unless LOG_LEVELS.include? v.downcase
-    eputs "Invalid log level: \e[31m#{v}\e[91m"
-    eputs "Valid log levels: \e[31m#{LOG_LEVELS.join("\e[91m, \e[31m")}\e[91m"
-    exit 1
-  end
-  options[:log_level] = v.downcase
-end
-opt.on("-f", "--log-file FILE", "File to write log to.") { |v| options[:log_file] = v }
-opt.on("-c", "--[no-]log-color", "Whether to colorize log output.") { |v| options[:log_color] = v }
 opt.on("-s", "--setup", "Whether to setup application commands.") { |v| options[:setup] = v }
 opt.on("-e", "--env [ENV]", "The name of the environment variable to use for token, or just `-e` or `--env` for intractive prompt.") { |v| options[:token] = v }
 opt.on("-t", "--title TITLE", "The title of process.") { |v| options[:title] = v }