mij-discord 1.0.0

data/lib/mij-discord/cache.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module MijDiscord::Cache
+  class BotCache
+    def initialize(bot)
+      @bot = bot
+
+      reset
+    end
+
+    def reset
+      @servers, @channels, @users = {}, {}, {}
+      @pm_channels, @restricted_channels = {}, {}
+    end
+
+    def list_servers
+      @servers.values
+    end
+
+    def list_channels
+      @channels.values
+    end
+
+    def list_users
+      @users.values
+    end
+
+    def get_server(key, local: false)
+      id = key&.to_id
+      return @servers[id] if @servers.has_key?(id)
+      return nil if local
+
+      begin
+        response = MijDiscord::Core::API::Server.resolve(@bot.token, id)
+      rescue RestClient::ResourceNotFound
+        return nil
+      end
+
+      @servers[id] = MijDiscord::Data::Server.new(JSON.parse(response), @bot)
+    end
+
+    def get_channel(key, server, local: false)
+      id = key&.to_id
+      return @channels[id] if @channels.has_key?(id)
+      raise MijDiscord::Errors::NoPermission if @restricted_channels[id]
+      return nil if local
+
+      begin
+        response = MijDiscord::Core::API::Channel.resolve(@bot.token, id)
+      rescue RestClient::ResourceNotFound
+        return nil
+      rescue MijDiscord::Errors::NoPermission
+        @restricted_channels[id] = true
+        raise
+      end
+
+      channel = @channels[id] = MijDiscord::Data::Channel.create(JSON.parse(response), @bot, server)
+      @pm_channels[channel.recipient.id] = channel if channel.pm?
+
+      if (server = channel.server)
+        server.cache.put_channel!(channel)
+      end
+
+      channel
+    end
+
+    def get_pm_channel(key, local: false)
+      id = key&.to_id
+      return @pm_channels[id] if @pm_channels.has_key?(id)
+      return nil if local
+
+      response = MijDiscord::Core::API::User.create_pm(@bot.token, id)
+      channel = MijDiscord::Data::Channel.create(JSON.parse(response), @bot, nil)
+
+      @channels[channel.id] = @pm_channels[id] = channel
+    end
+
+    def get_user(key, local: false)
+      id = key&.to_id
+      return @users[id] if @users.has_key?(id)
+      return nil if local
+
+      begin
+        response = MijDiscord::Core::API::User.resolve(@bot.token, id)
+      rescue RestClient::ResourceNotFound
+        return nil
+      end
+
+      @users[id] = MijDiscord::Data::User.new(JSON.parse(response), @bot)
+    end
+
+    def put_server(data, update: false)
+      id = data['id'].to_i
+      if @servers.has_key?(id)
+        @servers[id].update_data(data) if update
+        return @servers[id]
+      end
+
+      @servers[id] = MijDiscord::Data::Server.new(data, @bot)
+    end
+
+    def put_channel(data, server, update: false)
+      id = data['id'].to_i
+      if @channels.has_key?(id)
+        @channels[id].update_data(data) if update
+        return @channels[id]
+      end
+
+      channel = @channels[id] = MijDiscord::Data::Channel.create(data, @bot, server)
+      @pm_channels[channel.recipient.id] = channel if channel.pm?
+
+      if (server = channel.server)
+        server.cache.put_channel!(channel)
+      end
+
+      channel
+    end
+
+    def put_user(data, update: false)
+      id = data['id'].to_i
+      if @users.has_key?(id)
+        @users[id].update_data(data) if update
+        return @users[id]
+      end
+
+      @users[id] = MijDiscord::Data::User.new(data, @bot)
+    end
+
+    def remove_server(key)
+      @servers.delete(key&.to_id)
+    end
+
+    def remove_channel(key)
+      channel = @channels.delete(key&.to_id)
+      @pm_channels.delete(channel.recipient.id) if channel&.pm?
+
+      if (server = channel&.server)
+        server.cache.remove_channel(key)
+      end
+
+      channel
+    end
+
+    def remove_user(key)
+      @users.delete(key&.to_id)
+    end
+  end
+
+  class ServerCache
+    def initialize(server, bot)
+      @server, @bot = server, bot
+
+      reset
+    end
+
+    def reset
+      @channels, @members, @roles = {}, {}, {}
+    end
+
+    def list_members
+      @members.values
+    end
+
+    def list_roles
+      @roles.values
+    end
+
+    def list_channels
+      @channels.values
+    end
+
+    def get_member(key, local: false)
+      id = key&.to_id
+      return @members[id] if @members.has_key?(id)
+      return nil if local
+
+      begin
+        response = MijDiscord::Core::API::Server.resolve_member(@bot.token, @server.id, id)
+      rescue RestClient::ResourceNotFound
+        return nil
+      end
+
+      @members[id] = MijDiscord::Data::Member.new(JSON.parse(response), @server, @bot)
+    end
+
+    def get_role(key, local: false)
+      id = key&.to_id
+      return @roles[id] if @roles.has_key?(id)
+      return nil if local
+
+      # No API to get individual role
+      nil
+    end
+
+    def get_channel(key, local: false)
+      id = key&.to_id
+      return @channels[id] if @channels.has_key?(id)
+
+      channel = @bot.cache.get_channel(key, local: local)
+      return nil unless channel&.server == @server
+
+      @channels[channel.id] = channel
+    end
+
+    def put_member(data, update: false)
+      id = data['user']['id'].to_i
+      if @members.has_key?(id)
+        @members[id].update_data(data) if update
+        return @members[id]
+      end
+
+      @members[id] = MijDiscord::Data::Member.new(data, @server, @bot)
+    end
+
+    def put_role(data, update: false)
+      id = data['id'].to_i
+      if @roles.has_key?(id)
+        @roles[id].update_data(data) if update
+        return @roles[id]
+      end
+
+      @roles[id] = MijDiscord::Data::Role.new(data, @server, @bot)
+    end
+
+    def put_channel(data, update: false)
+      channel = @bot.cache.put_channel(data, @server, update: update)
+      @channels[channel.id] = channel
+    end
+
+    def put_channel!(channel)
+      @channels[channel.id] = channel
+    end
+
+    def remove_member(key)
+      @members.delete(key&.to_id)
+    end
+
+    def remove_role(key)
+      @roles.delete(key&.to_id)
+    end
+
+    def remove_channel(key)
+      channel = @channels.delete(key&.to_id)
+      @bot.cache.remove_channel(key) if channel
+
+      channel
+    end
+  end
+
+  class ChannelCache
+    MAX_MESSAGES = 200
+
+    def initialize(channel, bot, max_messages: MAX_MESSAGES)
+      @channel, @bot = channel, bot
+      @max_messages = max_messages
+
+      reset
+    end
+
+    def reset
+      @messages = {}
+    end
+
+    def get_message(key, local: false)
+      id = key&.to_id
+      return @messages[id] if @messages.has_key?(id)
+      return nil if local
+
+      begin
+        response = MijDiscord::Core::API::Channel.message(@bot.token, @channel.id, key)
+      rescue RestClient::ResourceNotFound
+        return nil
+      end
+
+      message = @messages.store(id, MijDiscord::Data::Message.new(JSON.parse(response), @bot))
+      @messages.shift while @messages.length > @max_messages
+
+      message
+    end
+
+    def put_message(data, update: false)
+      id = data['id'].to_i
+      if @messages.has_key?(id)
+        @messages[id].update_data(data) if update
+        return @messages[id]
+      end
+
+      message = @messages.store(id, MijDiscord::Data::Message.new(data, @bot))
+      @messages.shift while @messages.length > @max_messages
+
+      message
+    end
+
+    def remove_message(key)
+      @messages.delete(key&.to_id)
+    end
+  end
+end

data/lib/mij-discord/core/api.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module MijDiscord::Core::API
+  APIBASE_URL = 'https://discordapp.com/api/v6'
+
+  CDN_URL = 'https://cdn.discordapp.com'
+
+  class << self
+    attr_accessor :bot_name
+
+    def user_agent
+      bot_name = @bot_name || 'generic'
+      ua_base = "DiscordBot (https://github.com/Mijyuoon/mij-discord, v#{MijDiscord::VERSION})"
+
+      "#{ua_base} mij-discord/#{MijDiscord::VERSION} #{bot_name}"
+    end
+
+    # Make an icon URL from server and icon IDs
+    def icon_url(server_id, icon_id, format = :webp)
+      "#{CDN_URL}/icons/#{server_id}/#{icon_id}.#{format}"
+    end
+
+    # Make an icon URL from application and icon IDs
+    def app_icon_url(app_id, icon_id, format = :webp)
+      "#{CDN_URL}/app-icons/#{app_id}/#{icon_id}.#{format}"
+    end
+
+    # Make a widget picture URL from server ID
+    def widget_url(server_id, style = 'shield')
+      "#{APIBASE_URL}/guilds/#{server_id}/widget.png?style=#{style}"
+    end
+
+    # Make a splash URL from server and splash IDs
+    def splash_url(server_id, splash_id)
+      "#{CDN_URL}{/splashes/#{server_id}/#{splash_id}.jpg"
+    end
+
+    # Make an emoji icon URL from emoji ID
+    def emoji_icon_url(emoji_id, format = :webp)
+      "#{CDN_URL}/emojis/#{emoji_id}.#{format}"
+    end
+
+    # Login to the server
+    def login(email, password)
+      request(
+        :auth_login,
+        nil,
+        :post,
+        "#{APIBASE_URL}/auth/login",
+        email: email,
+        password: password
+      )
+    end
+
+    # Logout from the server
+    def logout(token)
+      request(
+        :auth_logout,
+        nil,
+        :post,
+        "#{APIBASE_URL}/auth/logout",
+        nil,
+        Authorization: token
+      )
+    end
+
+    # Create an OAuth application
+    def create_oauth_application(token, name, redirect_uris)
+      request(
+        :oauth2_applications,
+        nil,
+        :post,
+        "#{APIBASE_URL}/oauth2/applications",
+        { name: name, redirect_uris: redirect_uris }.to_json,
+        Authorization: token,
+        content_type: :json
+      )
+    end
+
+    # Change an OAuth application's properties
+    def update_oauth_application(token, name, redirect_uris, description = '', icon = nil)
+      request(
+        :oauth2_applications,
+        nil,
+        :put,
+        "#{APIBASE_URL}/oauth2/applications",
+        { name: name, redirect_uris: redirect_uris, description: description, icon: icon }.to_json,
+        Authorization: token,
+        content_type: :json
+      )
+    end
+
+    # Get the bot's OAuth application's information
+    def oauth_application(token)
+      request(
+        :oauth2_applications_me,
+        nil,
+        :get,
+        "#{APIBASE_URL}/oauth2/applications/@me",
+        Authorization: token
+      )
+    end
+
+    # Acknowledge that a message has been received
+    # The last acknowledged message will be sent in the ready packet,
+    # so this is an easy way to catch up on messages
+    def acknowledge_message(token, channel_id, message_id)
+      request(
+        :channels_cid_messages_mid_ack,
+        nil, # This endpoint is unavailable for bot accounts and thus isn't subject to its rate limit requirements.
+        :post,
+        "#{APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/ack",
+        nil,
+        Authorization: token
+      )
+    end
+
+    # Get the gateway to be used
+    def gateway(token)
+      request(
+        :gateway,
+        nil,
+        :get,
+        "#{APIBASE_URL}/gateway",
+        Authorization: token
+      )
+    end
+
+    # Validate a token (this request will fail if the token is invalid)
+    def validate_token(token)
+      request(
+        :auth_login,
+        nil,
+        :post,
+        "#{APIBASE_URL}/auth/login",
+        {}.to_json,
+        Authorization: token,
+        content_type: :json
+      )
+    end
+
+    # Get a list of available voice regions
+    def voice_regions(token)
+      request(
+        :voice_regions,
+        nil,
+        :get,
+        "#{APIBASE_URL}/voice/regions",
+        Authorization: token,
+        content_type: :json
+      )
+    end
+
+    def raw_request(type, attributes)
+      RestClient.send(type, *attributes)
+    rescue RestClient::Forbidden
+      raise MijDiscord::Core::Errors::NoPermission
+    rescue RestClient::BadGateway
+      MijDiscord::LOGGER.warn('HTTP') { 'Received 502 Bad Gateway during API request' }
+      retry
+    end
+
+    def request(key, major_param, type, *attributes)
+      ratelimit_delta, response = nil, nil
+
+      if (params = attributes.last).is_a?(Hash)
+        params[:user_agent] = user_agent
+        ratelimit_delta = params.delete(:header_bypass_delay)
+      end
+
+      key = [key, major_param].freeze
+      key_mutex = (@rate_limit_mutex[key] ||= Mutex.new)
+      global_mutex = @rate_limit_mutex[:global]
+
+      begin
+        mutex_wait(key_mutex)
+        mutex_wait(global_mutex) if global_mutex.locked?
+
+        response = raw_request(type, attributes)
+      rescue RestClient::TooManyRequests => e
+        response = e.response
+
+        is_global = response.headers[:x_ratelimit_global]
+        mutex = is_global == 'true' ? global_mutex : key_mutex
+
+        unless mutex.locked?
+          response = JSON.parse(e.response)
+          retry_after = response['retry_after'].to_i / 1000.0
+
+          MijDiscord::LOGGER.info('HTTP') { "Hit Discord rate limit on <#{key}>, waiting for #{retry_after} seconds" }
+          sync_wait(retry_after, mutex)
+        end
+
+        retry
+      rescue RestClient::Exception => e
+        response = e.response
+        raise
+      ensure
+        headers = response&.headers
+        if headers && headers[:x_ratelimit_remaining] == '0' && !key_mutex.locked?
+          unless ratelimit_delta
+            now = Time.rfc2822(headers[:date])
+            reset = Time.at(headers[:x_ratelimit_reset].to_i)
+            ratelimit_delta = reset - now
+          end
+
+          sync_wait(ratelimit_delta, key_mutex)
+        end
+      end
+
+      response
+    end
+
+    private
+
+    def sync_wait(time, mutex)
+      mutex.synchronize { sleep(time) }
+    end
+
+    def mutex_wait(mutex)
+      mutex.lock
+      mutex.unlock
+    end
+  end
+
+  # Initialize rate limit mutexes
+  @rate_limit_mutex = { global: Mutex.new }
+end