wsapi.go 17 KB

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