wsapi.go 17 KB

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