discordrb 1.4.8 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca25846076f05d2e3363e4f6efb7126d50659d17
-  data.tar.gz: c3f210ead11cf9fe48a10de9b9cd719171bdd467
+  metadata.gz: bc7dfd36f58df8feea4180b9f2ee01246094ee67
+  data.tar.gz: e3abfaca8e1216f1ad67f0abfc93d5631369bb9f
 SHA512:
-  metadata.gz: 156b8249969001de05be16fa0602cef916ae57e4d6ad976d515a7cb7d831d09e73518b86ee894d7d1f4d300cf79d59fbe42e2a4a9bfc86c1f67c4455e5a0eb03
-  data.tar.gz: 8c6cb05c57bb799716818d099f6288b31381accb85cfbfd2899bf1179f59ae88f30fb61d7101cd19fe2d67ca9293278acf1c27668354ef6a091c4ccf83cd63f7
+  metadata.gz: 7c7226d0b7f7c7bf675942661d39a499d3161e97cbc872ab9931bc59a2881d0115217fe97db7fa4709cb19cf97b4172ac16ce81070ae4b8b26bae9142330e7f9
+  data.tar.gz: 242b86beeee1d91d9bb5de6f72d239ebb98e73911c1287d825f3668f93eae38ab1e3ec8f075f2b0cd23d28827d49fa21cdfb995248359e36544e278a2cbd6554

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/.idea/

data/CHANGELOG.md

@@ -1,4 +1,17 @@
 # Changelog
+
+## 1.5.0
+* Voice support: discordrb can now connect to voice using `bot.voice_connect` and do the following things:
+  * Play files and URLs using `VoiceBot.play_file`
+  * Play arbitrary streams using `VoiceBot.play_io`
+  * Set the volume of future playbacks using `VoiceBot.volume=`
+  * Pause and resume playback (`VoiceBot.pause` and `VoiceBot.continue`)
+* Authentication tokens are now cached and no login request will be made if a cached token is found. This is mostly to reduce strain on Discord's servers.
+
+### Bugfixes
+* Some latent ID casting errors were fixed - those would probably never have been noticed anyway, but they're fixed now.
+* `Bot.parse_mention` now works, it didn't work at all previously
+
 ## 1.4.8
 * The `User` class now has the methods `add_role` and `remove_role` which add a role to a user and remove it, respectively.
 * All data classes now have a useful `==` implementation.
@@ -13,7 +26,7 @@
 * `Message` now has a useful `to_s` method that just returns the content.
 
 ### Bugfixes
-* The `TypingEvent` `user` property is now initialized correctly.
+* The `TypingEvent` `user` property is now initialized correctly (#29, thanks @purintal)
 
 ## 1.4.6
 *Bugfix-only release.*
@@ -24,3 +37,99 @@
 ## 1.4.5
 * The `Bot.game` property can now be set to an arbitrary string.
 * Discord mentions are handled in the old way again, after Discord reverted an API change.
+
+## 1.4.4
+* Add `Server.leave_server` as an alias for `delete_server`
+* Use the new Discord mention format (mentions array). **Reverted in 1.4.5**
+* Discord rate limited API calls are now handled correctly - discordrb will try again after the specified time.
+* Debug logging is now handled by a separate `Logger` class
+
+### Bugfixes
+* Message timestamps are now parsed correctly.
+* The quickadders for awaits (`User.await`, `Channel.await` etc.) now add the correct awaits.
+
+## 1.4.3
+* Added a method `Bot.find_user` analogous to `Bot.find`.
+
+### Bugfixes
+* Remove a leftover debug line (#23, thanks @VxJasonxV)
+
+## 1.4.2
+* discordrb will now send a user agent in the format requested by the Discord devs.
+
+## 1.4.1
+*Bugfix-only release.*
+
+### Bugfixes
+* Empty messages will now never be sent
+* The command-not-found message in `CommandBot` can now be disabled properly
+
+## 1.4.0
+* All methods and classes where the words "colour" or "color" are used now have had aliases added with the respective other spelling. (Internally, everything uses "colour" now).
+* discordrb now supports everything on the Discord API comparison, except for voice (see also #22)
+  * Roles can now be created, edited and deleted and their permissions modified.
+  * There is now a method to get a channel's message history.
+  * The bot's user profile can now be edited.
+  * Servers can now be created, edited and deleted.
+  * The user can now display a "typing" message in a channel.
+  * Invites can now be created and deleted, and an `Invite` class was made to represent them.
+* Command and event handling is now threaded, with each command/event handler execution in a separate thread.
+* Debug messages now specify the current thread's name.
+* discordrb now handles created/updated/deleted servers properly with events added to handle them.
+* The list of games handled by Discord will now be updated automatically.
+
+### Bugfixes
+* Fixed a bug where command handling would crash if the command didn't exist.
+
+## 1.3.12
+* Add an attribute `Bot.should_parse_self` (false by default) that prevents the bot from raising an event if it receives a message from itself.
+* `User.bot?` and `Message.from_bot?` were implemented to check whether the user is the bot or the message was sent by it.
+* Add an event for private messages specifically (`Bot.pm` and `PrivateMessageEvent`)
+
+### Bugfixes
+* Fix the `MessageEvent` attribute that checks whether the message is from the bot not working at all.
+
+## 1.3.11
+* Add a user selector (`:bot`) that is usable in the `from:` `MessageEvent` attribute to check whether the message was sent by a bot.
+
+### Bugfixes
+* `Channel.private?` now checks for the server being nil instead of the `is_private` attribute provided by Discord as the latter is unreliable. (wtf)
+
+## 1.3.10
+* Add a method `Channel.private?` to check for a PM channel
+* Add a `MessageEvent` attribute (`:private`) to check whether a message was sent in a PM channel
+* Add various aliases to `MessageEvent` attributes
+* Allow regexes to check for strings in `MessageEvent` attributes
+
+### Bugfixes
+* The `matches_all` method would break in certain edge cases. This didn't really affect discordrb and I don't think anyone else uses that method (it's pretty useless otherwise). This has been fixed
+
+## 1.3.9
+* Add awaits, a powerful way to add temporary event handlers.
+* Add a `Bot.find` method to fuzzy-search for channels.
+* Add methods to kick, ban and unban users.
+
+### Bugfixes
+* Permission overrides now work correctly for private channels (i. e. they don't exist at all)
+* Users joining and leaving servers are now handled correctly.
+
+## 1.3.8
+* Added `Bot.users` and `Bot.servers` readers to get the list of users and servers.
+
+### Bugfixes
+* POST requests to API calls that don't need a payload will now send a `nil` payload instead. This fixes the bot being unable to join any servers and various other latent problems. (#21, thanks @davidkus)
+
+## 1.3.7
+*Bugfix-only release.*
+
+### Bugfixes
+* Fix the command bot being included wrong, which caused crashes upon startup.
+
+## 1.3.6
+* The bot can now be stopped from the script using the new method `Bot.stop`.
+
+### Bugfixes
+* Fix some wrong file requires which caused crashes sometimes.
+
+## 1.3.5
+* The bot can now be run asynchronously using `Bot.run(:async)` to do further initialization after the bot was started.

data/README.md

@@ -67,6 +67,10 @@ bot.run
 
 This bot responds to every "Ping!" with a "Pong!".
 
+## Support
+
+You can find me (@meew0, ID 66237334693085184) on the unofficial Discord API server - if you have a question, just ask there, I or somebody else will probably answer you: https://discord.gg/0SBTUU1wZTWfFQL2
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/discordrb.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'faye-websocket'
   spec.add_dependency 'rest-client'
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'opus-ruby'
 
   spec.required_ruby_version = '>= 2.1.0'
 

data/lib/discordrb/bot.rb

@@ -21,6 +21,9 @@ require 'discordrb/api'
 require 'discordrb/exceptions'
 require 'discordrb/data'
 require 'discordrb/await'
+require 'discordrb/token_cache'
+
+require 'discordrb/voice/voice_bot'
 
 module Discordrb
   # Represents a Discord bot, including servers, users, etc.
@@ -77,6 +80,9 @@ module Discordrb
       @email = email
       @password = password
 
+      debug('Creating token cache')
+      @token_cache = Discordrb::TokenCache.new
+      debug('Token cache created successfully')
       @token = login
 
       @event_handlers = {}
@@ -192,6 +198,38 @@ module Discordrb
       API.join_server(@token, resolved)
     end
 
+    attr_reader :voice
+
+    def voice_connect(channel)
+      if @voice
+        debug('Voice bot exists already! Destroying it')
+        @voice.destroy
+        @voice = nil
+      end
+
+      @voice_channel = channel
+      debug("Got voice channel: #{@voice_channel}")
+
+      data = {
+        op: 4,
+        d: {
+          guild_id: @voice_channel.server.id.to_s,
+          channel_id: @voice_channel.id.to_s,
+          self_mute: false,
+          self_deaf: false
+        }
+      }
+      debug("Voice channel init packet is: #{data.to_json}")
+
+      @should_connect_to_voice = true
+      @ws.send(data.to_json)
+      debug('Voice channel init packet sent! Now waiting.')
+
+      sleep(0.05) until @voice
+      debug('Voice connect succeeded!')
+      @voice
+    end
+
     # Revokes an invite to a server. Will fail unless you have the *Manage Server* permission.
     # It is recommended that you use {Invite#delete} instead.
     # @param code [String, Invite] The invite to revoke. For possible formats see {#resolve_invite_code}.
@@ -330,7 +368,7 @@ module Discordrb
     def parse_mention(mention)
       # Mention format: <@id>
       return nil unless /\<@(?<id>\d+)\>?/ =~ mention
-      user(id)
+      user(id.to_i)
     end
 
     # Sets the currently playing game to the specified game.
@@ -590,6 +628,24 @@ module Discordrb
       channel = nil
       channel = @channels[channel_id.to_i] if channel_id
       user.move(channel)
+
+      @session_id = data['session_id']
+    end
+
+    # Internal handler for VOICE_SERVER_UPDATE
+    def update_voice_server(data)
+      debug("Voice server update received! should connect: #{@should_connect_to_voice}")
+      return unless @should_connect_to_voice
+      @should_connect_to_voice = false
+      debug('Updating voice server!')
+
+      token = data['token']
+      endpoint = data['endpoint']
+      channel = @voice_channel
+
+      debug('Got data, now creating the bot.')
+      @voice = Discordrb::Voice::VoiceBot.new(channel, self, token, @session_id, endpoint)
+      @voice
     end
 
     # Internal handler for CHANNEL_CREATE
@@ -679,7 +735,7 @@ module Discordrb
 
     # Internal handler for GUILD_DELETE
     def delete_guild(data)
-      id = data['id']
+      id = data['id'].to_i
 
       @users.each do |_, user|
         user.delete_roles(id)
@@ -734,6 +790,13 @@ module Discordrb
       debug('Logging in')
       login_attempts ||= 0
 
+      # First, attempt to get the token from the cache
+      token = @token_cache.token(@email, @password)
+      if token
+        debug("Token successfully obtained from cache: #{token}")
+        return token
+      end
+
       # Login
       login_response = API.login(@email, @password)
       fail HTTPStatusException, login_response.code if login_response.code >= 400
@@ -743,6 +806,10 @@ module Discordrb
       fail InvalidAuthenticationException unless login_response_object['token']
 
       debug("Received token: #{login_response_object['token']}")
+
+      # Cache the token
+      @token_cache.store_token(@email, @password, login_response_object['token'])
+
       login_response_object['token']
     rescue Exception => e
       response_code = login_response.nil? ? 0 : login_response.code ######## mackmm145
@@ -877,6 +944,10 @@ module Discordrb
 
         event = VoiceStateUpdateEvent.new(data, self)
         raise_event(event)
+      when 'VOICE_SERVER_UPDATE'
+        update_voice_server(data)
+
+        # no event as this is irrelevant to users
       when 'CHANNEL_CREATE'
         create_channel(data)
 

data/lib/discordrb/data.rb

@@ -587,7 +587,7 @@ module Discordrb
         user.server_deaf = element['deaf']
         user.self_mute = element['self_mute']
         user.self_mute = element['self_mute']
-        channel_id = element['channel_id']
+        channel_id = element['channel_id'].to_i
         channel = channel_id ? @channels_by_id[channel_id] : nil
         user.move(channel)
       end

data/lib/discordrb/events/typing.rb

@@ -8,7 +8,7 @@ module Discordrb::Events
     def initialize(data, bot)
       @user_id = data['user_id'].to_i
       @user = bot.user(@user_id)
-      @channel_id = data['channel_id']
+      @channel_id = data['channel_id'].to_i
       @channel = bot.channel(@channel_id)
       @timestamp = Time.at(data['timestamp'].to_i)
     end

data/lib/discordrb/logger.rb

@@ -7,9 +7,9 @@ module Discordrb
       puts "[DEBUG : #{Thread.current[:discordrb_name]} @ #{Time.now}] #{message}" if @debug || important
     end
 
-    def log_exception(e)
-      debug("Exception: #{e.inspect}", true)
-      e.backtrace.each { |line| debug(line, true) }
+    def log_exception(e, important = true)
+      debug("Exception: #{e.inspect}", important)
+      e.backtrace.each { |line| debug(line, important) }
     end
   end
 end

data/lib/discordrb/token_cache.rb

@@ -0,0 +1,140 @@
+require 'base64'
+require 'json'
+require 'openssl'
+require 'discordrb/api'
+
+# Discordrb
+module Discordrb
+  # Amount of bytes the key should be long (32 bytes = 256 bits -> AES256)
+  KEYLEN = 32
+
+  # Represents a cached token with encryption data
+  class CachedToken
+    def initialize(data = nil)
+      if data
+        @verify_salt = Base64.decode64(data['verify_salt'])
+        @password_hash = Base64.decode64(data['password_hash'])
+        @encrypt_salt = Base64.decode64(data['encrypt_salt'])
+        @iv = Base64.decode64(data['iv'])
+        @encrypted_token = Base64.decode64(data['encrypted_token'])
+      else
+        generate_salts
+      end
+    end
+
+    def data
+      {
+        verify_salt: Base64.encode64(@verify_salt),
+        password_hash: Base64.encode64(@password_hash),
+        encrypt_salt: Base64.encode64(@encrypt_salt),
+        iv: Base64.encode64(@iv),
+        encrypted_token: Base64.encode64(@encrypted_token)
+      }
+    end
+
+    def verify_password(password)
+      hash_password(password) == @password_hash
+    end
+
+    def generate_verify_hash(password)
+      @password_hash = hash_password(password)
+    end
+
+    def obtain_key(password)
+      @key = OpenSSL::PKCS5.pbkdf2_hmac_sha1(password, @encrypt_salt, 20_000, KEYLEN)
+    end
+
+    def generate_salts
+      @verify_salt = OpenSSL::Random.random_bytes(KEYLEN)
+      @encrypt_salt = OpenSSL::Random.random_bytes(KEYLEN)
+    end
+
+    def decrypt_token(password)
+      key = obtain_key(password)
+      decipher = OpenSSL::Cipher::AES256.new(:CBC)
+      decipher.decrypt
+      decipher.key = key
+      decipher.iv = @iv
+      decipher.update(@encrypted_token) + decipher.final
+    end
+
+    def encrypt_token(password, token)
+      key = obtain_key(password)
+      cipher = OpenSSL::Cipher::AES256.new(:CBC)
+      cipher.encrypt
+      cipher.key = key
+      @iv = cipher.random_iv
+      @encrypted_token = cipher.update(token) + cipher.final
+      @encrypted_token
+    end
+
+    def test_token(token)
+      Discordrb::API.gateway(token)
+    end
+
+    private
+
+    def hash_password(password)
+      digest = OpenSSL::Digest::SHA256.new
+      OpenSSL::PKCS5.pbkdf2_hmac(password, @verify_salt, 20_000, digest.digest_length, digest)
+    end
+  end
+
+  # Path where the cache file will be stored
+  CACHE_PATH = Dir.home + '/.discordrb_token_cache.json'
+
+  # Represents a token file
+  class TokenCache
+    def initialize
+      if File.file? CACHE_PATH
+        @data = JSON.parse(File.read(CACHE_PATH))
+      else
+        LOGGER.debug("Cache file #{CACHE_PATH} not found. Using empty cache")
+        @data = {}
+      end
+    end
+
+    def token(email, password)
+      if @data[email]
+        begin
+          cached = CachedToken.new(@data[email])
+          if cached.verify_password(password)
+            token = cached.decrypt_token(password)
+            if token
+              begin
+                cached.test_token(token)
+                token
+              rescue => e; fail_token('Token cached, verified and decrypted, but rejected by Discord', email, e)
+              end
+            else; fail_token('Token cached and verified, but decryption failed', email)
+            end
+          else; fail_token('Token verification failed', email)
+          end
+        rescue => e; fail_token('Token cached but invalid', email, e)
+        end
+      else; fail_token('Token not cached at all')
+      end
+    end
+
+    def store_token(email, password, token)
+      cached = CachedToken.new
+      cached.generate_verify_hash(password)
+      cached.encrypt_token(password, token)
+      @data[email] = cached.data
+      write_cache
+    end
+
+    def write_cache
+      File.write(CACHE_PATH, @data.to_json)
+    end
+
+    private
+
+    def fail_token(msg, email = nil, e = nil)
+      LOGGER.debug("Token not retrieved from cache - #{msg}")
+      LOGGER.log_exception(e, false) if e
+      @data.delete(email) if email
+      nil
+    end
+  end
+end

data/lib/discordrb/version.rb

@@ -1,4 +1,4 @@
 # Discordrb and all its functionality, in this case only the version.
 module Discordrb
-  VERSION = '1.4.8'
+  VERSION = '1.5.0'
 end

data/lib/discordrb/voice/encoder.rb

@@ -0,0 +1,37 @@
+require 'opus-ruby'
+
+# Discord voice chat support
+module Discordrb::Voice
+  # Wrapper class around opus-ruby
+  class Encoder
+    attr_accessor :volume
+
+    def initialize
+      @sample_rate = 48_000
+      @frame_size = 960
+      @channels = 2
+      @volume = 1.0
+      @opus = Opus::Encoder.new(@sample_rate, @frame_size, @channels)
+    end
+
+    def encode(buffer)
+      @opus.encode(buffer, 1920)
+    end
+
+    def destroy
+      @opus.destroy
+    end
+
+    def encode_file(file)
+      command = "ffmpeg -loglevel 0 -i #{file.path} -f s16le -ar 48000 -ac 2 -af volume=#{@volume} pipe:1"
+      IO.popen(command)
+    end
+
+    def encode_io(io)
+      ret_io, writer = IO.pipe
+      command = "ffmpeg -loglevel 0 -i - -f s16le -ar 48000 -ac 2 -af volume=#{@volume} pipe:1"
+      spawn(command, in: io, out: writer)
+      ret_io
+    end
+  end
+end

data/lib/discordrb/voice/network.rb

@@ -0,0 +1,216 @@
+require 'websocket-client-simple'
+require 'resolv'
+require 'socket'
+require 'json'
+
+module Discordrb::Voice
+  # Represents a UDP connection to a voice server
+  class VoiceUDP
+    # Only creates a socket as the discovery reply may come before the data is initialized.
+    def initialize
+      @socket = UDPSocket.new
+    end
+
+    # Initializes the data from opcode 2
+    def connect(endpoint, port, ssrc)
+      @endpoint = endpoint
+      @endpoint = @endpoint[6..-1] if @endpoint.start_with? 'wss://'
+      @endpoint.gsub!(':80', '') # The endpoint may contain a port, we don't want that
+      @endpoint = Resolv.getaddress @endpoint
+
+      @port = port
+      @ssrc = ssrc
+    end
+
+    def receive_discovery_reply
+      # Wait for a UDP message
+      message = @socket.recvmsg.first
+      ip = message[4..-3].delete("\0")
+      port = message[-2..-1].to_i
+      [ip, port]
+    end
+
+    def send_audio(buf, sequence, time)
+      packet = [0x80, 0x78, sequence, time, @ssrc].pack('CCnNN') + buf
+      send_packet(packet)
+    end
+
+    def send_discovery
+      discovery_packet = [@ssrc].pack('N')
+
+      # Add 66 zeroes so the packet is 70 bytes long
+      discovery_packet += "\0" * 66
+      send_packet(discovery_packet)
+    end
+
+    private
+
+    def send_packet(packet)
+      @socket.send(packet, 0, @endpoint, @port)
+    end
+  end
+
+  # Represents a websocket connection to the voice server
+  class VoiceWS
+    attr_reader :udp
+
+    def initialize(channel, bot, token, session, endpoint)
+      @channel = channel
+      @bot = bot
+      @token = token
+      @session = session
+
+      @endpoint = endpoint
+      @endpoint.gsub!(':80', '')
+
+      @udp = VoiceUDP.new
+    end
+
+    # Send a connection init packet (op 0)
+    def send_init(server_id, bot_user_id, session_id, token)
+      @client.send({
+        op: 0,
+        d: {
+          server_id: server_id,
+          user_id: bot_user_id,
+          session_id: session_id,
+          token: token
+        }
+      }.to_json)
+    end
+
+    # Sends the UDP connection packet (op 1)
+    def send_udp_connection(ip, port, mode)
+      @client.send({
+        op: 1,
+        d: {
+          protocol: 'udp',
+          data: {
+            address: ip,
+            port: port,
+            mode: mode
+          }
+        }
+      }.to_json)
+    end
+
+    # Send a heartbeat (op 3), has to be done every @heartbeat_interval seconds or the connection will terminate
+    def send_heartbeat
+      millis = Time.now.strftime('%s%L').to_i
+      @bot.debug("Sending voice heartbeat at #{millis}")
+
+      @client.send({
+        'op' => 3,
+        'd' => nil
+      }.to_json)
+    end
+
+    # Send a speaking packet (op 5). This determines the green circle around the avatar in the voice channel
+    def send_speaking(value)
+      @bot.debug("Speaking: #{value}")
+      @client.send({
+        op: 5,
+        d: {
+          speaking: value,
+          delay: 0
+        }
+      }.to_json)
+    end
+
+    # Event handlers; public for websocket-simple to work correctly
+    def websocket_open
+      # Send the init packet
+      send_init(@channel.server.id, @bot.bot_user.id, @session, @token)
+    end
+
+    def websocket_message(msg)
+      @bot.debug("Received VWS message! #{msg}")
+      packet = JSON.parse(msg)
+
+      case packet['op']
+      when 2
+        # Opcode 2 contains data to initialize the UDP connection
+        @ws_data = packet['d']
+
+        @heartbeat_interval = @ws_data['heartbeat_interval']
+        @ssrc = @ws_data['ssrc']
+        @port = @ws_data['port']
+        @udp_mode = @ws_data['modes'][0]
+
+        @udp.connect(@endpoint, @port, @ssrc)
+        @udp.send_discovery
+      when 4
+        # I'm not 100% sure what this packet does, but I'm keeping it for future compatibility.
+        @ws_data = packet['d']
+        @ready = true
+        @mode = @ws_data['mode']
+      end
+    end
+
+    # Communication goes like this:
+    # me                    discord
+    #   |                      |
+    # websocket connect ->     |
+    #   |                      |
+    #   |     <- websocket opcode 2
+    #   |                      |
+    # UDP discovery ->         |
+    #   |                      |
+    #   |       <- UDP reply packet
+    #   |                      |
+    # websocket opcode 1 ->    |
+    #   |                      |
+    # ...
+    def connect
+      # Connect websocket
+      @thread = Thread.new do
+        Thread.current[:discordrb_name] = 'vws'
+        init_ws
+      end
+
+      @bot.debug('Started websocket initialization, now waiting for UDP discovery reply')
+
+      # Now wait for opcode 2 and the resulting UDP reply packet
+      ip, port = @udp.receive_discovery_reply
+      @bot.debug("UDP discovery reply received! #{ip} #{port}")
+
+      # Send UDP init packet with received UDP data
+      send_udp_connection(ip, port, @udp_mode)
+    end
+
+    def destroy
+      @thread.kill if @thread
+    end
+
+    private
+
+    def heartbeat_loop
+      loop do
+        if @heartbeat_interval
+          sleep @heartbeat_interval / 1000.0
+          send_heartbeat
+        else
+          # If no interval has been set yet, sleep a second and check again
+          sleep 1
+        end
+      end
+    end
+
+    def init_ws
+      host = "wss://#{@endpoint}:443"
+      @bot.debug("Connecting VWS to host: #{host}")
+      @client = WebSocket::Client::Simple.connect(host)
+
+      # Change some instance to local variables for the blocks
+      instance = self
+
+      @client.on(:open) { instance.websocket_open }
+      @client.on(:message) { |msg| instance.websocket_message(msg.data) }
+      @client.on(:error) { |e| puts e.to_s }
+      @client.on(:close) { |e| puts e.to_s }
+
+      # Block any further execution
+      heartbeat_loop
+    end
+  end
+end

data/lib/discordrb/voice/voice_bot.rb

@@ -0,0 +1,152 @@
+require 'discordrb/voice/encoder'
+require 'discordrb/voice/network'
+
+# Voice support
+module Discordrb::Voice
+  # How long one packet should ideally be (20 ms as defined by Discord)
+  IDEAL_LENGTH = 20.0
+
+  # How many bytes of data to read (1920 bytes * 2 channels)
+  DATA_LENGTH = 1920 * 2
+
+  # A voice connection consisting of a UDP socket and a websocket client
+  class VoiceBot
+    attr_reader :stream_time
+
+    def initialize(channel, bot, token, session, endpoint)
+      @bot = bot
+      @ws = VoiceWS.new(channel, bot, token, session, endpoint)
+      @udp = @ws.udp
+
+      @sequence = @time = 0
+
+      @encoder = Encoder.new
+      @ws.connect
+    end
+
+    # Set the volume. Only applies to future playbacks
+    def volume=(value)
+      @encoder.volume = value
+    end
+
+    # Pause playback
+    def pause
+      @paused = true
+    end
+
+    # Continue playback
+    def continue
+      @paused = false
+    end
+
+    def speaking=(value)
+      @playing = value
+      @ws.send_speaking(value)
+    end
+
+    def stop_playing
+      @was_playing_before = @playing
+      @speaking = false
+      @io.close if @io
+      @io = nil
+      sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
+    end
+
+    def destroy
+      stop_playing
+      @ws.destroy
+      @encoder.destroy
+    end
+
+    def play(encoded_io)
+      stop_playing if @playing
+      @io = encoded_io
+      play_internal
+    end
+
+    def play_file(file)
+      play @encoder.encode_file(file)
+    end
+
+    def play_io(io)
+      play @encoder.encode_io(io)
+    end
+
+    alias_method :play_stream, :play_io
+
+    private
+
+    # Plays the data from the @io stream as Discord requires it
+    def play_internal
+      count = 0
+      @playing = true
+      @retry_attempts = 3
+
+      # Default play length (ms), will be adjusted later
+      @length = IDEAL_LENGTH
+
+      self.speaking = true
+      loop do
+        break unless @playing
+
+        if count % 100 == 10
+          # Starting from the tenth packet, perform length adjustment every 100 packets (2 seconds)
+          @length_adjust = Time.now.nsec
+        end
+
+        # Read some data from the buffer
+        buf = nil
+        begin
+          buf = @io.readpartial(DATA_LENGTH)
+        rescue EOFError
+          @bot.debug('EOF while reading, breaking immediately')
+          break
+        end
+
+        # Check whether the buffer has enough data
+        if !buf || buf.length != DATA_LENGTH
+          @bot.debug("No data is available! Retrying #{@retry_attempts} more times")
+          if @retry_attempts == 0
+            break
+          else
+            @retry_attempts -= 1
+            next
+          end
+        end
+
+        # Track packet count, sequence and time (Discord requires this)
+        count += 1
+        (@sequence + 10 < 65_535) ? @sequence += 1 : @sequence = 0
+        (@time + 9600 < 4_294_967_295) ? @time += 960 : @time = 0
+
+        # Encode the packet and send it
+        @udp.send_audio(@encoder.encode(buf), @sequence, @time)
+
+        # Set the stream time (for tracking how long we've been playing)
+        @stream_time = count * @length / 1000
+
+        # Perform length adjustment
+        if @length_adjust
+          # Difference between length_adjust and now in ms
+          ms_diff = (Time.now.nsec - @length_adjust) / 1_000_000.0
+          if ms_diff >= 0
+            @length = IDEAL_LENGTH - ms_diff
+            @bot.debug("Length adjustment: new length #{@length}")
+          end
+          @length_adjust = nil
+        end
+
+        # If paused, wait
+        sleep 0.1 while @paused
+
+        # Wait `length` ms, then send the next packet
+        sleep @length / 1000.0
+      end
+
+      @bot.debug('Performing final cleanup after stream ended')
+
+      # Final cleanup
+      stop_playing
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discordrb
 version: !ruby/object:Gem::Version
-  version: 1.4.8
+  version: 1.5.0
 platform: ruby
 authors:
 - meew0
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-06 00:00:00.000000000 Z
+date: 2016-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: opus-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,7 +143,11 @@ files:
 - lib/discordrb/exceptions.rb
 - lib/discordrb/logger.rb
 - lib/discordrb/permissions.rb
+- lib/discordrb/token_cache.rb
 - lib/discordrb/version.rb
+- lib/discordrb/voice/encoder.rb
+- lib/discordrb/voice/network.rb
+- lib/discordrb/voice/voice_bot.rb
 homepage: https://github.com/meew0/discordrb
 licenses:
 - MIT