wsapi.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718
  1. // Discordgo - Discord bindings for Go
  2. // Available at https://github.com/bwmarrin/discordgo
  3. // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>. All rights reserved.
  4. // Use of this source code is governed by a BSD-style
  5. // license that can be found in the LICENSE file.
  6. // This file contains low level functions for interacting with the Discord
  7. // data websocket interface.
  8. package discordgo
  9. import (
  10. "errors"
  11. "fmt"
  12. "runtime"
  13. "time"
  14. "github.com/gorilla/websocket"
  15. )
  16. // Open opens a websocket connection to Discord.
  17. func (s *Session) Open() (err error) {
  18. s.Lock()
  19. defer func() {
  20. s.Unlock()
  21. // Fire OnConnect after we have unlocked the mutex,
  22. // otherwise we may deadlock.
  23. if err == nil && s.OnConnect != nil {
  24. s.OnConnect(s)
  25. }
  26. }()
  27. if s.wsConn != nil {
  28. err = errors.New("Web socket already opened.")
  29. return
  30. }
  31. // Get the gateway to use for the Websocket connection
  32. g, err := s.Gateway()
  33. if err != nil {
  34. return
  35. }
  36. // TODO: See if there's a use for the http response.
  37. // conn, response, err := websocket.DefaultDialer.Dial(session.Gateway, nil)
  38. s.wsConn, _, err = websocket.DefaultDialer.Dial(g, nil)
  39. if err != nil {
  40. return
  41. }
  42. return
  43. }
  44. // Close closes a websocket and stops all listening/heartbeat goroutines.
  45. // TODO: Add support for Voice WS/UDP connections
  46. func (s *Session) Close() (err error) {
  47. s.Lock()
  48. defer func() {
  49. s.Unlock()
  50. // Fire OnDisconnect after we have unlocked the mutex
  51. // otherwise we may deadlock, especially in reconnect logic.
  52. if err == nil && s.OnDisconnect != nil {
  53. s.OnDisconnect(s)
  54. }
  55. }()
  56. s.DataReady = false
  57. if s.listening != nil {
  58. close(s.listening)
  59. s.listening = nil
  60. }
  61. if s.wsConn != nil {
  62. err = s.wsConn.Close()
  63. s.wsConn = nil
  64. }
  65. return
  66. }
  67. type handshakeProperties struct {
  68. OS string `json:"$os"`
  69. Browser string `json:"$browser"`
  70. Device string `json:"$device"`
  71. Referer string `json:"$referer"`
  72. ReferringDomain string `json:"$referring_domain"`
  73. }
  74. type handshakeData struct {
  75. Version int `json:"v"`
  76. Token string `json:"token"`
  77. Properties handshakeProperties `json:"properties"`
  78. }
  79. type handshakeOp struct {
  80. Op int `json:"op"`
  81. Data handshakeData `json:"d"`
  82. }
  83. // Handshake sends the client data to Discord during websocket initial connection.
  84. func (s *Session) Handshake() error {
  85. data := handshakeOp{2, handshakeData{3, s.Token, handshakeProperties{runtime.GOOS, "Discordgo v" + VERSION, "", "", ""}}}
  86. return s.wsConn.WriteJSON(data)
  87. }
  88. type updateStatusGame struct {
  89. Name string `json:"name"`
  90. }
  91. type updateStatusData struct {
  92. IdleSince *int `json:"idle_since"`
  93. Game *updateStatusGame `json:"game"`
  94. }
  95. type updateStatusOp struct {
  96. Op int `json:"op"`
  97. Data updateStatusData `json:"d"`
  98. }
  99. // UpdateStatus is used to update the authenticated user's status.
  100. // If idle>0 then set status to idle. If game>0 then set game.
  101. // if otherwise, set status to active, and no game.
  102. func (s *Session) UpdateStatus(idle int, game string) (err error) {
  103. s.RLock()
  104. defer s.RUnlock()
  105. if s.wsConn == nil {
  106. return errors.New("No websocket connection exists.")
  107. }
  108. var usd updateStatusData
  109. if idle > 0 {
  110. usd.IdleSince = &idle
  111. }
  112. if game != "" {
  113. usd.Game = &updateStatusGame{game}
  114. }
  115. data := updateStatusOp{3, usd}
  116. err = s.wsConn.WriteJSON(data)
  117. return
  118. }
  119. // Listen starts listening to the websocket connection for events.
  120. func (s *Session) Listen() (err error) {
  121. s.Lock()
  122. if s.wsConn == nil {
  123. s.Unlock()
  124. return errors.New("No websocket connection exists.")
  125. }
  126. if s.listening != nil {
  127. s.Unlock()
  128. return errors.New("Already listening to websocket.")
  129. }
  130. s.listening = make(chan interface{})
  131. s.Unlock()
  132. // Keep a reference, as s.listening can be nilled out.
  133. listening := s.listening
  134. for {
  135. messageType, message, err1 := s.wsConn.ReadMessage()
  136. if err1 != nil {
  137. err = err1
  138. // Defer so we get better log ordering.
  139. defer s.Close()
  140. return fmt.Errorf("Websocket Listen Error", err)
  141. }
  142. select {
  143. case <-listening:
  144. return
  145. default:
  146. go s.event(messageType, message)
  147. }
  148. }
  149. return
  150. }
  151. // Not sure how needed this is and where it would be best to call it.
  152. // somewhere.
  153. func unmarshalEvent(event *Event, i interface{}) (err error) {
  154. if err = unmarshal(event.RawData, i); err != nil {
  155. fmt.Println(event.Type, err)
  156. printJSON(event.RawData) // TODO: Better error loggingEvent.
  157. }
  158. return
  159. }
  160. // Front line handler for all Websocket Events. Determines the
  161. // event type and passes the message along to the next handler.
  162. // event is the front line handler for all events. This needs to be
  163. // broken up into smaller functions to be more idiomatic Go.
  164. // Events will be handled by any implemented handler in Session.
  165. // All unhandled events will then be handled by OnEvent.
  166. func (s *Session) event(messageType int, message []byte) (err error) {
  167. if s.Debug {
  168. printJSON(message)
  169. }
  170. var e *Event
  171. if err = unmarshal(message, &e); err != nil {
  172. fmt.Println(err)
  173. return
  174. }
  175. switch e.Type {
  176. case "READY":
  177. s.DataReady = true
  178. var st *Ready
  179. if err = unmarshalEvent(e, &st); err == nil {
  180. if s.StateEnabled {
  181. s.State.OnReady(st)
  182. }
  183. if s.OnReady != nil {
  184. s.OnReady(s, st)
  185. }
  186. }
  187. go s.heartbeat(st.HeartbeatInterval)
  188. if s.OnReady != nil {
  189. return
  190. }
  191. case "VOICE_SERVER_UPDATE":
  192. // TEMP CODE FOR TESTING VOICE
  193. var st *VoiceServerUpdate
  194. if err = unmarshalEvent(e, &st); err == nil {
  195. s.onVoiceServerUpdate(st)
  196. }
  197. return
  198. case "VOICE_STATE_UPDATE":
  199. // TEMP CODE FOR TESTING VOICE
  200. var st *VoiceState
  201. if err = unmarshalEvent(e, &st); err == nil {
  202. s.onVoiceStateUpdate(st)
  203. }
  204. return
  205. case "USER_UPDATE":
  206. if s.OnUserUpdate != nil {
  207. var st *User
  208. if err = unmarshalEvent(e, &st); err == nil {
  209. s.OnUserUpdate(s, st)
  210. }
  211. return
  212. }
  213. case "PRESENCE_UPDATE":
  214. if s.OnPresenceUpdate != nil {
  215. var st *PresenceUpdate
  216. if err = unmarshalEvent(e, &st); err == nil {
  217. s.OnPresenceUpdate(s, st)
  218. }
  219. return
  220. }
  221. case "TYPING_START":
  222. if s.OnTypingStart != nil {
  223. var st *TypingStart
  224. if err = unmarshalEvent(e, &st); err == nil {
  225. s.OnTypingStart(s, st)
  226. }
  227. return
  228. }
  229. /* Never seen this come in but saw it in another Library.
  230. case "MESSAGE_ACK":
  231. if s.OnMessageAck != nil {
  232. }
  233. */
  234. case "MESSAGE_CREATE":
  235. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  236. if !stateEnabled && s.OnMessageCreate == nil {
  237. break
  238. }
  239. var st *Message
  240. if err = unmarshalEvent(e, &st); err == nil {
  241. if stateEnabled {
  242. s.State.MessageAdd(st)
  243. }
  244. if s.OnMessageCreate != nil {
  245. s.OnMessageCreate(s, st)
  246. }
  247. }
  248. if s.OnMessageCreate != nil {
  249. return
  250. }
  251. case "MESSAGE_UPDATE":
  252. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  253. if !stateEnabled && s.OnMessageUpdate == nil {
  254. break
  255. }
  256. var st *Message
  257. if err = unmarshalEvent(e, &st); err == nil {
  258. if stateEnabled {
  259. s.State.MessageAdd(st)
  260. }
  261. if s.OnMessageUpdate != nil {
  262. s.OnMessageUpdate(s, st)
  263. }
  264. }
  265. return
  266. if s.OnMessageUpdate != nil {
  267. return
  268. }
  269. case "MESSAGE_DELETE":
  270. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  271. if !stateEnabled && s.OnMessageDelete == nil {
  272. break
  273. }
  274. var st *Message
  275. if err = unmarshalEvent(e, &st); err == nil {
  276. if stateEnabled {
  277. s.State.MessageRemove(st)
  278. }
  279. if s.OnMessageDelete != nil {
  280. s.OnMessageDelete(s, st)
  281. }
  282. }
  283. return
  284. if s.OnMessageDelete != nil {
  285. return
  286. }
  287. case "MESSAGE_ACK":
  288. if s.OnMessageAck != nil {
  289. var st *MessageAck
  290. if err = unmarshalEvent(e, &st); err == nil {
  291. s.OnMessageAck(s, st)
  292. }
  293. return
  294. }
  295. case "CHANNEL_CREATE":
  296. if !s.StateEnabled && s.OnChannelCreate == nil {
  297. break
  298. }
  299. var st *Channel
  300. if err = unmarshalEvent(e, &st); err == nil {
  301. if s.StateEnabled {
  302. s.State.ChannelAdd(st)
  303. }
  304. if s.OnChannelCreate != nil {
  305. s.OnChannelCreate(s, st)
  306. }
  307. }
  308. if s.OnChannelCreate != nil {
  309. return
  310. }
  311. case "CHANNEL_UPDATE":
  312. if !s.StateEnabled && s.OnChannelUpdate == nil {
  313. break
  314. }
  315. var st *Channel
  316. if err = unmarshalEvent(e, &st); err == nil {
  317. if s.StateEnabled {
  318. s.State.ChannelAdd(st)
  319. }
  320. if s.OnChannelUpdate != nil {
  321. s.OnChannelUpdate(s, st)
  322. }
  323. }
  324. if s.OnChannelUpdate != nil {
  325. return
  326. }
  327. case "CHANNEL_DELETE":
  328. if !s.StateEnabled && s.OnChannelDelete == nil {
  329. break
  330. }
  331. var st *Channel
  332. if err = unmarshalEvent(e, &st); err == nil {
  333. if s.StateEnabled {
  334. s.State.ChannelRemove(st)
  335. }
  336. if s.OnChannelDelete != nil {
  337. s.OnChannelDelete(s, st)
  338. }
  339. }
  340. if s.OnChannelDelete != nil {
  341. return
  342. }
  343. case "GUILD_CREATE":
  344. if !s.StateEnabled && s.OnGuildCreate == nil {
  345. break
  346. }
  347. var st *Guild
  348. if err = unmarshalEvent(e, &st); err == nil {
  349. if s.StateEnabled {
  350. s.State.GuildAdd(st)
  351. }
  352. if s.OnGuildCreate != nil {
  353. s.OnGuildCreate(s, st)
  354. }
  355. }
  356. if s.OnGuildCreate != nil {
  357. return
  358. }
  359. case "GUILD_UPDATE":
  360. if !s.StateEnabled && s.OnGuildUpdate == nil {
  361. break
  362. }
  363. var st *Guild
  364. if err = unmarshalEvent(e, &st); err == nil {
  365. if s.StateEnabled {
  366. s.State.GuildAdd(st)
  367. }
  368. if s.OnGuildCreate != nil {
  369. s.OnGuildUpdate(s, st)
  370. }
  371. }
  372. if s.OnGuildUpdate != nil {
  373. return
  374. }
  375. case "GUILD_DELETE":
  376. if !s.StateEnabled && s.OnGuildDelete == nil {
  377. break
  378. }
  379. var st *Guild
  380. if err = unmarshalEvent(e, &st); err == nil {
  381. if s.StateEnabled {
  382. s.State.GuildRemove(st)
  383. }
  384. if s.OnGuildDelete != nil {
  385. s.OnGuildDelete(s, st)
  386. }
  387. }
  388. if s.OnGuildDelete != nil {
  389. return
  390. }
  391. case "GUILD_MEMBER_ADD":
  392. if !s.StateEnabled && s.OnGuildMemberAdd == nil {
  393. break
  394. }
  395. var st *Member
  396. if err = unmarshalEvent(e, &st); err == nil {
  397. if s.StateEnabled {
  398. s.State.MemberAdd(st)
  399. }
  400. if s.OnGuildMemberAdd != nil {
  401. s.OnGuildMemberAdd(s, st)
  402. }
  403. }
  404. if s.OnGuildMemberAdd != nil {
  405. return
  406. }
  407. case "GUILD_MEMBER_REMOVE":
  408. if !s.StateEnabled && s.OnGuildMemberRemove == nil {
  409. break
  410. }
  411. var st *Member
  412. if err = unmarshalEvent(e, &st); err == nil {
  413. if s.StateEnabled {
  414. s.State.MemberRemove(st)
  415. }
  416. if s.OnGuildMemberRemove != nil {
  417. s.OnGuildMemberRemove(s, st)
  418. }
  419. }
  420. if s.OnGuildMemberRemove != nil {
  421. return
  422. }
  423. case "GUILD_MEMBER_UPDATE":
  424. if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
  425. break
  426. }
  427. var st *Member
  428. if err = unmarshalEvent(e, &st); err == nil {
  429. if s.StateEnabled {
  430. s.State.MemberAdd(st)
  431. }
  432. if s.OnGuildMemberUpdate != nil {
  433. s.OnGuildMemberUpdate(s, st)
  434. }
  435. }
  436. if s.OnGuildMemberUpdate != nil {
  437. return
  438. }
  439. case "GUILD_ROLE_CREATE":
  440. if s.OnGuildRoleCreate != nil {
  441. var st *GuildRole
  442. if err = unmarshalEvent(e, &st); err == nil {
  443. s.OnGuildRoleCreate(s, st)
  444. }
  445. return
  446. }
  447. case "GUILD_ROLE_UPDATE":
  448. if s.OnGuildRoleUpdate != nil {
  449. var st *GuildRole
  450. if err = unmarshalEvent(e, &st); err == nil {
  451. s.OnGuildRoleUpdate(s, st)
  452. }
  453. return
  454. }
  455. case "GUILD_ROLE_DELETE":
  456. if s.OnGuildRoleDelete != nil {
  457. var st *GuildRoleDelete
  458. if err = unmarshalEvent(e, &st); err == nil {
  459. s.OnGuildRoleDelete(s, st)
  460. }
  461. return
  462. }
  463. case "GUILD_INTEGRATIONS_UPDATE":
  464. if s.OnGuildIntegrationsUpdate != nil {
  465. var st *GuildIntegrationsUpdate
  466. if err = unmarshalEvent(e, &st); err == nil {
  467. s.OnGuildIntegrationsUpdate(s, st)
  468. }
  469. return
  470. }
  471. case "GUILD_BAN_ADD":
  472. if s.OnGuildBanAdd != nil {
  473. var st *GuildBan
  474. if err = unmarshalEvent(e, &st); err == nil {
  475. s.OnGuildBanAdd(s, st)
  476. }
  477. return
  478. }
  479. case "GUILD_BAN_REMOVE":
  480. if s.OnGuildBanRemove != nil {
  481. var st *GuildBan
  482. if err = unmarshalEvent(e, &st); err == nil {
  483. s.OnGuildBanRemove(s, st)
  484. }
  485. return
  486. }
  487. case "GUILD_EMOJIS_UPDATE":
  488. if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
  489. break
  490. }
  491. var st *GuildEmojisUpdate
  492. if err = unmarshalEvent(e, &st); err == nil {
  493. if s.StateEnabled {
  494. s.State.EmojisAdd(st.GuildID, st.Emojis)
  495. }
  496. if s.OnGuildEmojisUpdate != nil {
  497. s.OnGuildEmojisUpdate(s, st)
  498. }
  499. }
  500. if s.OnGuildEmojisUpdate != nil {
  501. return
  502. }
  503. case "USER_SETTINGS_UPDATE":
  504. if s.OnUserSettingsUpdate != nil {
  505. var st map[string]interface{}
  506. if err = unmarshalEvent(e, &st); err == nil {
  507. s.OnUserSettingsUpdate(s, st)
  508. }
  509. return
  510. }
  511. default:
  512. fmt.Println("UNKNOWN EVENT: ", e.Type)
  513. printJSON(message)
  514. }
  515. // if still here, send to generic OnEvent
  516. if s.OnEvent != nil {
  517. s.OnEvent(s, e)
  518. return
  519. }
  520. return
  521. }
  522. func (s *Session) sendHeartbeat() error {
  523. return s.wsConn.WriteJSON(map[string]int{
  524. "op": 1,
  525. "d": int(time.Now().Unix()),
  526. })
  527. }
  528. // heartbeat sends regular heartbeats to Discord so it knows the client
  529. // is still connected. If you do not send these heartbeats Discord will
  530. // disconnect the websocket connection after a few seconds.
  531. func (s *Session) heartbeat(i time.Duration) {
  532. // Keep a reference, as s.listening can be nilled out.
  533. listening := s.listening
  534. // Send first heartbeat immediately because lag could put the
  535. // first heartbeat outside the required heartbeat interval window.
  536. err := s.sendHeartbeat()
  537. if err != nil {
  538. fmt.Println("Error sending initial heartbeat:", err)
  539. return
  540. }
  541. ticker := time.NewTicker(i * time.Millisecond)
  542. for {
  543. select {
  544. case <-ticker.C:
  545. err := s.sendHeartbeat()
  546. if err != nil {
  547. fmt.Println("Error sending heartbeat:", err)
  548. return
  549. }
  550. case <-listening:
  551. return
  552. }
  553. }
  554. }
  555. // ------------------------------------------------------------------------------------------------
  556. // Code related to voice connections that initiate over the data websocket
  557. // ------------------------------------------------------------------------------------------------
  558. // A VoiceServerUpdate stores the data received during the Voice Server Update
  559. // data websocket event. This data is used during the initial Voice Channel
  560. // join handshaking.
  561. type VoiceServerUpdate struct {
  562. Token string `json:"token"`
  563. GuildID string `json:"guild_id"`
  564. Endpoint string `json:"endpoint"`
  565. }
  566. type voiceChannelJoinData struct {
  567. GuildID string `json:"guild_id"`
  568. ChannelID string `json:"channel_id"`
  569. SelfMute bool `json:"self_mute"`
  570. SelfDeaf bool `json:"self_deaf"`
  571. }
  572. type voiceChannelJoinOp struct {
  573. Op int `json:"op"`
  574. Data voiceChannelJoinData `json:"d"`
  575. }
  576. // ChannelVoiceJoin joins the session user to a voice channel. After calling
  577. // this func please monitor the Session.Voice.Ready bool to determine when
  578. // it is ready and able to send/receive audio, that should happen quickly.
  579. //
  580. // gID : Guild ID of the channel to join.
  581. // cID : Channel ID of the channel to join.
  582. // mute : If true, you will be set to muted upon joining.
  583. // deaf : If true, you will be set to deafened upon joining.
  584. func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (err error) {
  585. if s.wsConn == nil {
  586. return fmt.Errorf("no websocket connection exists.")
  587. }
  588. // Create new voice{} struct if one does not exist.
  589. // If you create this prior to calling this func then you can manually
  590. // set some variables if needed, such as to enable debugging.
  591. if s.Voice == nil {
  592. s.Voice = &Voice{}
  593. }
  594. // TODO : Determine how to properly change channels and change guild
  595. // and channel when you are already connected to an existing channel.
  596. // Send the request to Discord that we want to join the voice channel
  597. data := voiceChannelJoinOp{4, voiceChannelJoinData{gID, cID, mute, deaf}}
  598. err = s.wsConn.WriteJSON(data)
  599. if err != nil {
  600. return
  601. }
  602. // Store gID and cID for later use
  603. s.Voice.guildID = gID
  604. s.Voice.channelID = cID
  605. return
  606. }
  607. // onVoiceStateUpdate handles Voice State Update events on the data
  608. // websocket. This comes immediately after the call to VoiceChannelJoin
  609. // for the session user.
  610. func (s *Session) onVoiceStateUpdate(st *VoiceState) {
  611. // If s.Voice is nil, we must not have even requested to join
  612. // a voice channel yet, so this shouldn't be processed.
  613. if s.Voice == nil {
  614. return
  615. }
  616. // Need to have this happen at login and store it in the Session
  617. // TODO : This should be done upon connecting to Discord, or
  618. // be moved to a small helper function
  619. self, err := s.User("@me") // TODO: move to Login/New
  620. if err != nil {
  621. fmt.Println(err)
  622. return
  623. }
  624. // This event comes for all users, if it's not for the session
  625. // user just ignore it.
  626. // TODO Move this IF to the event() func
  627. if st.UserID != self.ID {
  628. return
  629. }
  630. // Store the SessionID for later use.
  631. s.Voice.userID = self.ID // TODO: Review
  632. s.Voice.sessionID = st.SessionID
  633. }
  634. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  635. // This event tells us the information needed to open a voice websocket
  636. // connection and should happen after the VOICE_STATE event.
  637. func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
  638. // This shouldn't ever be the case, I don't think.
  639. if s.Voice == nil {
  640. return
  641. }
  642. // Store values for later use
  643. s.Voice.token = st.Token
  644. s.Voice.endpoint = st.Endpoint
  645. s.Voice.guildID = st.GuildID
  646. // We now have enough information to open a voice websocket conenction
  647. // so, that's what the next call does.
  648. err := s.Voice.Open()
  649. if err != nil {
  650. fmt.Println("onVoiceServerUpdate Voice.Open error: ", err)
  651. // TODO better logging
  652. }
  653. }