arikawa/gateway/identify.go

package gateway

import (
	"context"
	"runtime"
	"strings"
	"time"

	"github.com/diamondburned/arikawa/v3/api"
	"github.com/diamondburned/arikawa/v3/discord"
	"github.com/diamondburned/arikawa/v3/utils/json/option"
	"github.com/pkg/errors"
	"golang.org/x/time/rate"
)

// DefaultPresence is used as the default presence when initializing a new
// Gateway.
var DefaultPresence *UpdatePresenceCommand

// Identifier is a wrapper around IdentifyCommand to add in appropriate rate
// limiters.
type Identifier struct {
	IdentifyCommand

	IdentifyShortLimit  *rate.Limiter `json:"-"` // optional
	IdentifyGlobalLimit *rate.Limiter `json:"-"` // optional
}

// DefaultIdentifier creates a new default Identifier
func DefaultIdentifier(token string) Identifier {
	return NewIdentifier(DefaultIdentifyCommand(token))
}

// NewIdentifier creates a new identifier with the given IdentifyCommand and
// default rate limiters.
func NewIdentifier(data IdentifyCommand) Identifier {
	return Identifier{
		IdentifyCommand:     data,
		IdentifyShortLimit:  rate.NewLimiter(rate.Every(5*time.Second), 1),
		IdentifyGlobalLimit: rate.NewLimiter(rate.Every(24*time.Hour), 1000),
	}
}

// Wait waits for the rate limiters to pass. If a limiter is nil, then it will
// not be used to wait. This is useful
func (id *Identifier) Wait(ctx context.Context) error {
	if id.IdentifyShortLimit != nil {
		if err := id.IdentifyShortLimit.Wait(ctx); err != nil {
			return errors.Wrap(err, "can't wait for short limit")
		}
	}

	if id.IdentifyGlobalLimit != nil {
		if err := id.IdentifyGlobalLimit.Wait(ctx); err != nil {
			return errors.Wrap(err, "can't wait for global limit")
		}
	}

	return nil
}

// QueryGateway queries the gateway for the URL and updates the Identifier with
// the appropriate information.
func (id *Identifier) QueryGateway(ctx context.Context) (gatewayURL string, err error) {
	var botData *api.BotData

	if strings.HasPrefix(id.Token, "Bot ") {
		botData, err = BotURL(ctx, id.Token)
		if err != nil {
			return "", errors.Wrap(err, "failed to get bot data")
		}
		gatewayURL = botData.URL
	} else {
		gatewayURL, err = URL(ctx)
		if err != nil {
			return "", errors.Wrap(err, "failed to get gateway endpoint")
		}
	}

	// Use the supplied connect rate limit, if any.
	if botData != nil && botData.StartLimit != nil {
		resetAt := time.Now().Add(botData.StartLimit.ResetAfter.Duration())
		limiter := id.IdentifyGlobalLimit

		// Update the burst to be the current given time and reset it back to
		// the default when the given time is reached.
		limiter.SetBurst(botData.StartLimit.Remaining)
		limiter.SetBurstAt(resetAt, botData.StartLimit.Total)

		// Update the maximum number of identify requests allowed per 5s.
		id.IdentifyShortLimit.SetBurst(botData.StartLimit.MaxConcurrency)
	}

	return
}

// DefaultIdentity is used as the default identity when initializing a new
// Gateway.
var DefaultIdentity = IdentifyProperties{
	OS:      runtime.GOOS,
	Browser: "Arikawa",
	Device:  "Arikawa",
}

// IdentifyCommand is a command for Op 2. It is the struct for a data that's
// sent over in an Identify command.
type IdentifyCommand struct {
	Token      string             `json:"token"`
	Properties IdentifyProperties `json:"properties"`

	Compress       bool `json:"compress,omitempty"`        // true
	LargeThreshold uint `json:"large_threshold,omitempty"` // 50

	Shard *Shard `json:"shard,omitempty"` // [ shard_id, num_shards ]

	Presence *UpdatePresenceCommand `json:"presence,omitempty"`

	// ClientState is the client state for a user's accuont. Bot accounts should
	// NOT touch this field.
	ClientState *ClientState `json:"client_state,omitempty"`

	// Capabilities defines the client's capabilities when connecting to the
	// gateway with a user account. Bot accounts should NOT touch this field.
	// The official client sets this at 125 at the time of this commit.
	Capabilities int `json:"capabilities,omitempty"`
	// Intents specifies which groups of events the gateway
	// connection will receive.
	//
	// For user accounts, it must be nil.
	//
	// For bot accounts, it must not be nil, and
	// Gateway.AddIntents(0) can be used if you want to
	// specify no intents.
	Intents option.Uint `json:"intents"`
}

// DefaultIdentifyCommand creates a default IdentifyCommand with the given token.
func DefaultIdentifyCommand(token string) IdentifyCommand {
	return IdentifyCommand{
		Token:      token,
		Properties: DefaultIdentity,
		Presence:   DefaultPresence,

		Compress:       true,
		LargeThreshold: 50,
	}
}

// SetShard is a helper function to set the shard configuration inside
// IdentifyCommand.
func (i *IdentifyCommand) SetShard(id, num int) {
	if i.Shard == nil {
		i.Shard = new(Shard)
	}
	i.Shard[0], i.Shard[1] = id, num
}

// AddIntents adds gateway intents into the identify data.
func (i *IdentifyCommand) AddIntents(intents Intents) {
	if i.Intents == nil {
		i.Intents = option.NewUint(uint(intents))
	} else {
		*i.Intents |= uint(intents)
	}
}

// HasIntents reports if the Gateway has the passed Intents.
//
// If no intents are set, e.g. if using a user account, HasIntents will always
// return true.
func (i *IdentifyCommand) HasIntents(intents Intents) bool {
	if i.Intents == nil {
		return true
	}

	return Intents(*i.Intents).Has(intents)
}

type IdentifyProperties struct {
	// Required
	OS      string `json:"os"`      // GOOS
	Browser string `json:"browser"` // Arikawa
	Device  string `json:"device"`  // Arikawa

	// Optional
	BrowserUserAgent string `json:"browser_user_agent,omitempty"`
	BrowserVersion   string `json:"browser_version,omitempty"`
	OSVersion        string `json:"os_version,omitempty"`
	Referrer         string `json:"referrer,omitempty"`
	ReferringDomain  string `json:"referring_domain,omitempty"`
}

// Shard is a type for two numbers that represent the Bot's shard configuration.
// The first number is the shard's ID, which could be obtained through the
// ShardID method. The second number is the total number of shards, which could
// be obtained through the NumShards method.
type Shard [2]int

// DefaultShard returns the default shard configuration of 1 shard total, in
// which the current shard ID is 0.
var DefaultShard = &Shard{0, 1}

// ShardID returns the current shard's ID. It uses the first number.
func (s Shard) ShardID() int {
	return s[0]
}

// NumShards returns the total number of shards. It uses the second number.
func (s Shard) NumShards() int {
	return s[1]
}

// ClientState describes the undocumented client_state field in the Identify
// command. Little is known about this type.
type ClientState struct {
	GuildHashes          map[discord.GuildID]interface{} `json:"guild_hashes"`            // {}
	HighestLastMessageID discord.MessageID               `json:"highest_last_message_id"` // "0"

	ReadStateVersion         int `json:"read_state_version"`          // 0
	UserGuildSettingsVersion int `json:"user_guild_settings_version"` // -1
	UserSettingsVersion      int `json:"user_settings_version"`       // -1
}