harmony/src/gateway/index.ts

283 lines
9.3 KiB
TypeScript
Raw Normal View History

import { unzlib } from 'https://deno.land/x/denoflate/mod.ts'
import { Client } from '../models/client.ts'
import {
DISCORD_GATEWAY_URL,
DISCORD_API_VERSION
} from '../consts/urlsAndVersions.ts'
import { GatewayResponse } from '../types/gatewayResponse.ts'
2020-11-01 12:05:22 +00:00
import { GatewayOpcodes, GatewayIntents, GatewayCloseCodes } from '../types/gateway.ts'
import { gatewayHandlers } from './handlers/index.ts'
import { GATEWAY_BOT } from '../types/endpoint.ts'
import { GatewayBotPayload } from "../types/gatewayBot.ts"
import { GatewayCache } from "../managers/GatewayCache.ts"
/**
* Handles Discord gateway connection.
* You should not use this and rather use Client class.
*
* @beta
*/
class Gateway {
websocket: WebSocket
token: string
intents: GatewayIntents[]
connected = false
initialized = false
heartbeatInterval = 0
heartbeatIntervalID?: number
sequenceID?: number
lastPingTimestamp = 0
sessionID?: string
private heartbeatServerResponded = false
client: Client
cache: GatewayCache
constructor (client: Client, token: string, intents: GatewayIntents[]) {
this.token = token
this.intents = intents
this.client = client
this.cache = new GatewayCache(client)
this.websocket = new WebSocket(
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
`${DISCORD_GATEWAY_URL}/?v=${DISCORD_API_VERSION}&encoding=json`,
[]
)
this.websocket.binaryType = 'arraybuffer'
this.websocket.onopen = this.onopen.bind(this)
this.websocket.onmessage = this.onmessage.bind(this)
this.websocket.onclose = this.onclose.bind(this)
this.websocket.onerror = this.onerror.bind(this)
}
private onopen (): void {
this.connected = true
this.debug("Connected to Gateway!")
}
private async onmessage (event: MessageEvent): Promise<void> {
let data = event.data
if (data instanceof ArrayBuffer) {
data = new Uint8Array(data)
}
if (data instanceof Uint8Array) {
data = unzlib(data)
data = new TextDecoder('utf-8').decode(data)
}
const { op, d, s, t }: GatewayResponse = JSON.parse(data)
switch (op) {
case GatewayOpcodes.HELLO:
this.heartbeatInterval = d.heartbeat_interval
this.debug(`Received HELLO. Heartbeat Interval: ${this.heartbeatInterval}`)
this.heartbeatIntervalID = setInterval(() => {
if (this.heartbeatServerResponded) {
this.heartbeatServerResponded = false
} else {
clearInterval(this.heartbeatIntervalID)
this.reconnect()
return
}
this.websocket.send(
JSON.stringify({
op: GatewayOpcodes.HEARTBEAT,
d: this.sequenceID ?? null
})
)
this.lastPingTimestamp = Date.now()
}, this.heartbeatInterval)
if (!this.initialized) {
this.sendIdentify(this.client.forceNewSession)
this.initialized = true
} else {
console.log("Calling Resume")
this.sendResume()
}
break
case GatewayOpcodes.HEARTBEAT_ACK:
this.heartbeatServerResponded = true
this.client.ping = Date.now() - this.lastPingTimestamp
this.debug(`Received Heartbeat Ack. Ping Recognized: ${this.client.ping}ms`)
break
case GatewayOpcodes.INVALID_SESSION:
// Because we know this gonna be bool
this.debug(`Invalid Session! Identifying with forced new session`)
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
setTimeout(() => this.sendIdentify(true), 3000)
break
case GatewayOpcodes.DISPATCH: {
this.heartbeatServerResponded = true
if (s !== null) {
this.sequenceID = s
await this.cache.set("seq", s)
}
if (t !== null && t !== undefined) {
const handler = gatewayHandlers[t]
if (handler !== undefined) {
handler(this, d)
}
}
break
}
case GatewayOpcodes.RESUME: {
// this.token = d.token
this.sessionID = d.session_id
this.sequenceID = d.seq
await this.cache.set("seq", d.seq)
await this.cache.set("session_id", this.sessionID)
break
}
case GatewayOpcodes.RECONNECT: {
this.reconnect()
break
}
default:
break
}
}
private onclose (event: CloseEvent): void {
this.debug("Connection Closed with code: " + event.code)
if(event.code == GatewayCloseCodes.UNKNOWN_ERROR) {
this.debug("API has encountered Unknown Error. Reconnecting...")
this.reconnect()
} else if(event.code == GatewayCloseCodes.UNKNOWN_OPCODE) {
throw new Error("Unknown OP Code was sent. This shouldn't happen!")
} else if(event.code == GatewayCloseCodes.DECODE_ERROR) {
throw new Error("Invalid Payload was sent. This shouldn't happen!")
} else if(event.code == GatewayCloseCodes.NOT_AUTHENTICATED) {
throw new Error("Not Authorized: Payload was sent before Identifying.")
} else if(event.code == GatewayCloseCodes.AUTHENTICATION_FAILED) {
throw new Error("Invalid Token provided!")
} else if(event.code == GatewayCloseCodes.INVALID_SEQ) {
this.debug("Invalid Seq was sent. Reconnecting.")
this.reconnect()
} else if(event.code == GatewayCloseCodes.RATE_LIMITED) {
throw new Error("You're ratelimited. Calm down.")
} else if(event.code == GatewayCloseCodes.SESSION_TIMED_OUT) {
this.debug("Session Timeout. Reconnecting.")
this.reconnect(true)
} else if(event.code == GatewayCloseCodes.INVALID_SHARD) {
this.debug("Invalid Shard was sent. Reconnecting.")
this.reconnect()
} else if(event.code == GatewayCloseCodes.SHARDING_REQUIRED) {
throw new Error("Couldn't connect. Sharding is requried!")
} else if(event.code == GatewayCloseCodes.INVALID_API_VERSION) {
throw new Error("Invalid API Version was used. This shouldn't happen!")
} else if(event.code == GatewayCloseCodes.INVALID_INTENTS) {
throw new Error("Invalid Intents")
} else if(event.code == GatewayCloseCodes.DISALLOWED_INTENTS) {
throw new Error("Given Intents aren't allowed")
} else {
this.debug("Unknown Close code, probably connection error. Reconnecting.")
this.reconnect()
}
}
private onerror (event: Event | ErrorEvent): void {
const eventError = event as ErrorEvent
console.log(eventError)
}
private async sendIdentify (forceNewSession?: boolean) {
this.debug("Fetching /gateway/bot...")
const info = await this.client.rest.get(GATEWAY_BOT()) as GatewayBotPayload
if(info.session_start_limit.remaining == 0) throw new Error("Session Limit Reached. Retry After " + info.session_start_limit.reset_after + "ms")
this.debug("Recommended Shards: " + info.shards)
this.debug("=== Session Limit Info ===")
this.debug(`Remaining: ${info.session_start_limit.remaining}/${info.session_start_limit.total}`)
this.debug(`Reset After: ${info.session_start_limit.reset_after}ms`)
if(!forceNewSession) {
let sessionIDCached = await this.cache.get("session_id")
if(sessionIDCached) {
this.debug("Found Cached SessionID: " + sessionIDCached)
this.sessionID = sessionIDCached
return this.sendResume()
}
}
this.websocket.send(
JSON.stringify({
op: GatewayOpcodes.IDENTIFY,
d: {
token: this.token,
properties: {
$os: Deno.build.os,
$browser: 'discord.deno',
$device: 'discord.deno'
},
compress: true,
shard: [0, 1], // TODO: Make sharding possible
intents: this.intents.reduce(
(previous, current) => previous | current,
0
),
presence: {
// TODO: User should can customize this
status: 'online',
since: null,
afk: false
}
}
})
)
}
private async sendResume (): Promise<void> {
this.debug(`Preparing to resume with Session: ${this.sessionID}`)
if(this.sequenceID === undefined) {
let cached = await this.cache.get("seq")
if(cached) this.sequenceID = typeof cached == "string" ? parseInt(cached) : cached
}
const resumePayload = {
op: GatewayOpcodes.RESUME,
d: {
token: this.token,
session_id: this.sessionID,
seq: this.sequenceID || null
}
}
this.websocket.send(
JSON.stringify(resumePayload)
)
}
debug(msg: string) {
this.client.debug("Gateway", msg)
}
async reconnect(forceNew?: boolean) {
clearInterval(this.heartbeatIntervalID)
if(forceNew) await this.cache.delete("session_id")
this.close()
this.initWebsocket()
}
initWebsocket (): void {
this.websocket = new WebSocket(
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
`${DISCORD_GATEWAY_URL}/?v=${DISCORD_API_VERSION}&encoding=json`,
[]
)
this.websocket.binaryType = 'arraybuffer'
this.websocket.onopen = this.onopen.bind(this)
this.websocket.onmessage = this.onmessage.bind(this)
this.websocket.onclose = this.onclose.bind(this)
this.websocket.onerror = this.onerror.bind(this)
}
close (): void {
this.websocket.close(1000)
}
}
export type GatewayEventHandler = (gateway: Gateway, d: any) => void
export { Gateway }