async-websocket 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a501ecd90b68be17ff1a832c672ed917da9edd521d478cb0da3565f596c8f9d6
-  data.tar.gz: 7e3e8cb233c53198506f2ced5a2771f150248c4de916921741f0d60ea07c79e0
+  metadata.gz: 0ba6df1f81d1727db806e398e804b402a821f138e46298fe501c49462a68d5fd
+  data.tar.gz: 898bd7a5f9dc2ca60b4d0b4f3ca94a8e5488a18161543002a0cbf5b397d5d7d0
 SHA512:
-  metadata.gz: 0b83359dd959354e0d31463065782e7b0b86a63b900930ca44252ca228366e99ac1fb69251aa605c72ae3e8ab281add7eb522f9ee01949d2c497b5500a300e77
-  data.tar.gz: 40912574da9db4d7bde1e8d6854ac33a35c193c0a662eed6b0426a1a5152127e7275e22279ee72f97b7fea2613acd90389b7af449a1fa4d417d2c727dfcd7d54
+  metadata.gz: bc6798196531c1994e077f41c090851c7e3de09347672f26fd913a5a4e6ebf97986d3113d0caa4a49de56060104ebbbe4528854fa77b4dfcf6d72a5d1d27a6be
+  data.tar.gz: 29693d7fe7ae34a21a5105d4231512181f611bfd51ff25e7a66b2feba53a309aee952bc5e6bf9d95b9d01a51ecc83b873275911a096786032dd6e090a170e637

data/.travis.yml

@@ -1,23 +1,19 @@
 language: ruby
+dist: xenial
 cache: bundler
 
-before_script:
-  - gem update --system
-  - gem install bundler
-
 matrix:
   include:
-    - rvm: 2.3
     - rvm: 2.4
     - rvm: 2.5
     - rvm: 2.6
     - rvm: 2.6
-      env: COVERAGE=BriefSummary,Coveralls
+      env: COVERAGE=PartialSummary,Coveralls
+    - rvm: truffleruby
     - rvm: jruby-head
       env: JRUBY_OPTS="--debug -X+O"
-    - rvm: truffleruby
     - rvm: ruby-head
   allow_failures:
-    - rvm: jruby-head
     - rvm: truffleruby
-    - rvm: ruby-head
+    - rvm: ruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -6,3 +6,7 @@ group :test do
 	gem 'rack-test'
 	gem 'pry'
 end
+
+group :development do
+	gem 'tty-progressbar'
+end

data/README.md

@@ -69,7 +69,9 @@ require 'async/websocket/server'
 $connections = []
 
 run lambda {|env|
-	Async::WebSocket::Server.open(env) do |connection|
+	# Options for websocket-driver-ruby can be passed as second argument to open
+	# Supported options here: https://github.com/faye/websocket-driver-ruby#driver-api
+	Async::WebSocket::Server.open(env, protocols: ['ws']) do |connection|
 		$connections << connection
 		
 		while message = connection.next_message

data/async-websocket.gemspec

@@ -14,13 +14,13 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 	spec.require_paths = ["lib"]
-
-	spec.add_dependency "websocket-driver", "~> 0.7.0"
-
-	spec.add_dependency "async-io"
+	
+	spec.add_dependency "async-io", "~> 1.23"
+	spec.add_dependency "protocol-http1", "~> 0.1"
+	spec.add_dependency "protocol-websocket", "~> 0.3"
 	
 	spec.add_development_dependency "async-rspec"
-	spec.add_development_dependency "falcon", "~> 0.17"
+	spec.add_development_dependency "falcon", "~> 0.30"
 	
 	spec.add_development_dependency "covered"
 	spec.add_development_dependency "bundler"

data/examples/chat/client.rb

@@ -3,39 +3,30 @@
 require 'async'
 require 'async/io/stream'
 require 'async/http/url_endpoint'
-require 'async/websocket/client'
+require_relative '../../lib/async/websocket/client'
 
 USER = ARGV.pop || "anonymous"
-URL = ARGV.pop || "ws://localhost:9292"
+URL = ARGV.pop || "http://127.0.0.1:8080"
+ENDPOINT = Async::HTTP::URLEndpoint.parse(URL)
 
 Async do |task|
 	stdin = Async::IO::Stream.new(
 		Async::IO::Generic.new($stdin)
 	)
 	
-	endpoint = Async::HTTP::URLEndpoint.parse(URL)
-	
-	endpoint.connect do |socket|
-		connection = Async::WebSocket::Client.new(socket, URL)
-		
-		connection.send_message({
-			user: USER,
-			status: "connected",
-		})
-		
-		task.async do
-			puts "Waiting for input..."
+	Async::WebSocket::Client.open(ENDPOINT) do |connection|
+		input_task = task.async do
 			while line = stdin.read_until("\n")
-				puts "Sending text: #{line}"
-				connection.send_message({
-					user: USER,
-					text: line,
-				})
+				connection.send_message({text: line})
+				connection.flush
 			end
 		end
 		
+		puts "Connected..."
 		while message = connection.next_message
-			puts "From server: #{message.inspect}"
+			puts "> #{message.inspect}"
 		end
+	ensure
+		input_task&.stop
 	end
 end

data/examples/chat/config.ru

@@ -1,15 +1,18 @@
-#!/usr/bin/env falcon serve --concurrency 1 -c
+#!/usr/bin/env -S falcon serve --bind http://127.0.0.1:8080 --count 1 -c
 
-require 'async/websocket/server'
+require_relative '../../lib/async/websocket/server/rack'
+require 'async/clock'
+require 'async/semaphore'
+require 'async/logger'
 
-require 'async/actor'
 require 'set'
 
-bus = Async::Actor::Bus::Redis.new
+GC.disable
 
 class Room
 	def initialize
 		@connections = Set.new
+		@semaphore = Async::Semaphore.new(512)
 	end
 	
 	def connect connection
@@ -23,29 +26,87 @@ class Room
 	def each(&block)
 		@connections.each(&block)
 	end
-end
-
-bus.supervise(:room) do
-	Room.new
-end
-
-run lambda {|env|
-	room = bus[:room]
 	
-	Async::WebSocket::Server.open(env) do |connection|
-		begin
-			room.connect(connection)
+	def allocations
+		counts = Hash.new{|h,k| h[k] = 0}
+		
+		ObjectSpace.each_object do |object|
+			counts[object.class] += 1
+		end
+		
+		return counts
+	end
+	
+	def show_allocations(key, limit = 1000)
+		Async.logger.info(self) do |buffer|
+			ObjectSpace.each_object(key).each do |object|
+				buffer.puts object
+			end
+		end
+	end
+	
+	def print_allocations(minimum = @connections.count)
+		count = 0
+		
+		Async.logger.info(self) do |buffer|
+			allocations.select{|k,v| v >= minimum}.sort_by{|k,v| -v}.each do |key, value|
+				count += value
+				buffer.puts "#{key}: #{value} allocations"
+			end
 			
-			while message = connection.next_message
-				room.each do |connection|
-					connection.send_message(message)
+			buffer.puts "** #{count.to_f / @connections.count} objects per connection."
+		end
+	end
+	
+	def command(code)
+		Async.logger.warn self, "eval(#{code})"
+		
+		eval(code)
+	end
+	
+	def broadcast(message)
+		Async.logger.info "Broadcast: #{message.inspect}"
+		start_time = Async::Clock.now
+		
+		@connections.each do |connection|
+			@semaphore.async do
+				connection.send_message(message)
+			end
+		end
+		
+		end_time = Async::Clock.now
+		Async.logger.info "Duration: #{(end_time - start_time).round(3)}s for #{@connections.count} connected clients."
+	end
+	
+	def open(connection)
+		self.connect(connection)
+		
+		while message = connection.next_message
+			if message["text"] =~ /^\/(.*?)$/
+				begin
+					result = self.command($1)
+					
+					if result.is_a? Hash
+						connection.send_message(result)
+					else
+						connection.send_message({result: result.inspect})
+					end
+				rescue
+					connection.send_message({error: $!.inspect})
 				end
+			else
+				self.broadcast(message)
 			end
-		rescue
-			room.disconnect(connection)
 		end
+		
+		connection.close
+	ensure
+		self.disconnect(connection)
 	end
 	
-	Async::Task.current.sleep(0.1)
-	[200, {}, ["Hello World"]]
-}
+	def call(env)
+		Async::WebSocket::Server::Rack.open(env, &self.method(:open))
+	end
+end
+
+run Room.new

data/examples/chat/multi-client.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'async'
+require 'async/semaphore'
+require 'async/clock'
+require 'async/io/stream'
+require 'async/http/url_endpoint'
+require_relative '../../lib/async/websocket/client'
+
+require 'samovar'
+require 'ruby-prof'
+
+require 'tty/progressbar'
+
+GC.disable
+
+class Command < Samovar::Command
+	options do
+		option "-c/--count <integer>", "The total number of connections to make.", default: 1000, type: Integer
+		option "--bind <address>", "The local address to bind to before making a connection."
+		option "--connect <string>", "The remote server to connect to.", default: "http://127.0.0.1:8080"
+		
+		option "-s/--semaphore <integer>", "The number of simultaneous connections to perform."
+	end
+	
+	def local_address
+		if bind = @options[:bind]
+			Async::IO::Address.tcp(bind, 0)
+		end
+	end
+	
+	def call
+		endpoint = Async::HTTP::URLEndpoint.parse(@options[:connect], local_address: self.local_address)
+		count = @options[:count]
+		
+		connections = Async::Queue.new
+		progress = TTY::ProgressBar.new(":rate connection/s [:bar] :current/:total (:eta/:elapsed)", total: count)
+		
+		# profile = RubyProf::Profile.new(merge_fibers: true)
+		# profile.start
+		
+		Async do |task|
+			task.logger.info!
+			
+			task.async do |subtask|
+				while connection = connections.dequeue
+					subtask.async(connection) do |subtask, connection|
+						pp connection.next_message
+						
+						while message = connection.next_message
+							pp message
+						end
+					ensure
+						connection.close
+					end
+				end
+				
+				# subtask.children.each(&:stop)
+			end
+			
+			client = Async::WebSocket::Client.new(endpoint)
+			
+			count.times do |i|
+				connections.enqueue(client.get)
+				progress.advance(1)
+			end
+			
+			connections.enqueue(nil)
+		end
+	
+	# ensure
+	# 	result = profile.stop
+	# 	printer = RubyProf::FlatPrinter.new(result)
+	# 	printer.print(STDOUT, min_percent: 0.5)
+	# 
+	# 	printer = RubyProf::GraphPrinter.new(result)
+	# 	printer.print(STDOUT, min_percent: 0.5)
+	end
+end
+
+Command.call

data/examples/middleware/client.rb

@@ -15,7 +15,7 @@ Async do |task|
 	
 	endpoint = Async::HTTP::URLEndpoint.parse(URL)
 	
-	endpoint.connect do |socket|
+	endpoint.with(local_address: local_address).connect do |socket|
 		connection = Async::WebSocket::Client.new(socket, URL)
 		
 		connection.send_message({

data/lib/async/websocket/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literals: true
+#
 # Copyright, 2015, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -18,23 +20,95 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'protocol/http1/connection'
+require 'protocol/websocket/digest'
+
 require_relative 'connection'
+require_relative 'error'
 
 module Async
 	module WebSocket
 		# This is a basic synchronous websocket client:
-		class Client < Connection
-			def initialize(socket, url = "ws://.", **options)
-				@url = url
-
-				super socket, build_client(**options)
+		class Client
+			def self.open(endpoint, **options, &block)
+				# endpoint = Async::HTTP::URLEndpoint.parse(url)
+				client = self.new(endpoint, **options)
+				
+				return client unless block_given?
+				
+				client.get(endpoint.path, &block)
 			end
-
-			def build_client(headers: nil, **options)
-				::WebSocket::Driver.client(self, options).tap do |client|
-					headers&.each do |key, value|
-						client.set_header(key, value)
-					end
+			
+			# @option protocols [Array] a list of supported sub-protocols to negotiate with the server.
+			def initialize(endpoint, headers: [], protocols: [], version: 13, key: SecureRandom.base64(16))
+				@endpoint = endpoint
+				@version = version
+				@headers = headers
+				
+				@protocols = protocols
+				
+				@key = key
+			end
+			
+			attr :headers
+			
+			def connect
+				peer = @endpoint.connect
+				
+				return ::Protocol::HTTP1::Connection.new(IO::Stream.new(peer), false)
+			end
+			
+			def request_headers
+				headers = [
+					['sec-websocket-key', @key],
+					['sec-websocket-version', @version]
+				] + @headers.to_a
+				
+				if @protocols.any?
+					headers << ['sec-websocket-protocol', @protocols.join(',')]
+				end
+				
+				return headers
+			end
+			
+			def get(path = '/', &block)
+				self.call('GET', path, &block)
+			end
+			
+			HTTP_VERSION = 'HTTP/1.0'.freeze
+			
+			def make_connection(stream, headers)
+				protocol = headers['sec-websocket-protocol']&.first
+				
+				framer = Protocol::WebSocket::Framer.new(stream)
+				
+				return Connection.new(framer, protocol)
+			end
+			
+			def call(method, path)
+				client = connect
+				client.upgrade!("websocket")
+				
+				client.write_request(@endpoint.authority, method, @endpoint.path, HTTP_VERSION, self.request_headers)
+				stream = client.write_upgrade_body
+				
+				version, status, reason, headers, body = client.read_response(method)
+				
+				raise ProtocolError, "Expected status 101, got #{status}!" unless status == 101
+				
+				accept_digest = headers['sec-websocket-accept'].first
+				if accept_digest.nil? or accept_digest != ::Protocol::WebSocket.accept_digest(@key)
+					raise ProtocolError, "Invalid accept header, got #{accept_digest.inspect}!"
+				end
+				
+				connection = make_connection(stream, headers)
+					
+				return connection unless block_given?
+				
+				begin
+					yield connection
+				ensure
+					connection.close
 				end
 			end
 		end

data/lib/async/websocket/connection.rb

@@ -18,83 +18,41 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'websocket/driver'
-require 'json'
+require 'protocol/websocket/connection'
 
-require 'async/io/stream'
+require 'json'
+require 'securerandom'
 
 module Async
 	module WebSocket
+		Frame = ::Protocol::WebSocket::Frame
+		
 		# This is a basic synchronous websocket client:
-		class Connection
-			BLOCK_SIZE = Async::IO::Stream::BLOCK_SIZE
-			
-			EVENTS = [:open, :message, :close]
-			
-			def initialize(socket, driver)
-				@socket = socket
-				@driver = driver
-				
-				@queue = []
-				
-				@driver.on(:error) do |error|
-					raise error
-				end
-				
-				EVENTS.each do |event|
-					@driver.on(event) do |data|
-						@queue.push(data)
-					end
-				end
+		class Connection < ::Protocol::WebSocket::Connection
+			def initialize(framer, protocol, mask: SecureRandom.bytes(4), format: JSON)
+				super(framer)
 				
-				@driver.start
+				@protocol = protocol
+				@mask = mask
+				@format = format
 			end
 			
-			attr :driver
-			attr :url
-			
-			def next_event
-				@socket.flush
-				
-				while @queue.empty?
-					data = @socket.readpartial(BLOCK_SIZE)
-					
-					if data and !data.empty?
-						@driver.parse(data)
-					else
-						return nil
-					end
-				end
-				
-				@queue.shift
-			rescue EOFError, Errno::ECONNRESET
-				return nil
-			end
+			attr :protocol
 			
 			def next_message
-				while event = next_event
-					if event.is_a? ::WebSocket::Driver::MessageEvent
-						return JSON.parse(event.data)
-					elsif event.is_a? ::WebSocket::Driver::CloseEvent
-						return nil
+				if frames = super
+					if frames.first.is_a? Protocol::WebSocket::TextFrame
+						buffer = frames.collect(&:unpack).join
+						
+						return @format.load(buffer)
+					else
+						return frames
 					end
 				end
 			end
 			
-			def send_text(text)
-				@driver.text(text)
-			end
-			
-			def send_message(message)
-				@driver.text(JSON.dump(message))
-			end
-			
-			def write(data)
-				@socket.write(data)
-			end
-			
-			def close
-				@driver.close
+			def send_message(data)
+				send_text(@format.dump(data))
 			end
 		end
 	end

data/lib/async/websocket/error.rb

@@ -0,0 +1,28 @@
+# Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'protocol/websocket/error'
+
+module Async
+	module WebSocket
+		class ProtocolError < ::Protocol::WebSocket::ProtocolError
+		end
+	end
+end

data/lib/async/websocket/server.rb

@@ -22,44 +22,7 @@ require_relative 'connection'
 
 module Async
 	module WebSocket
-		class Server < Connection
-			def initialize(env, socket, **options)
-				scheme = env['rack.url_scheme'] == 'https' ? 'wss' : 'ws'
-				
-				@url = "#{scheme}://#{env['HTTP_HOST']}#{env['REQUEST_URI']}"
-				@env = env
-				
-				super(socket, ::WebSocket::Driver.rack(self, options))
-			end
-			
-			attr :env
-			attr :url
-			
-			HIJACK_RESPONSE = [-1, {}, []].freeze
-			
-			def self.open(env, **options)
-				if ::WebSocket::Driver.websocket?(env)
-					return nil unless env['rack.hijack?']
-					
-					# https://github.com/rack/rack/blob/master/SPEC#L89-L93
-					peer = Async::IO.try_convert(
-						env['rack.hijack'].call
-					)
-					
-					connection = self.new(env, peer, options)
-					
-					return connection unless block_given?
-					
-					begin
-						yield(connection)
-						
-						return HIJACK_RESPONSE
-					ensure
-						connection.close
-						peer.close
-					end
-				end
-			end
+		module Server
 		end
 	end
 end

data/lib/async/websocket/server/rack.rb

@@ -0,0 +1,96 @@
+# frozen_string_literals: true
+#
+# Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'protocol/websocket/digest'
+
+require_relative '../connection'
+
+module Async
+	module WebSocket
+		module Server
+			class Rack
+				def self.open(env, **options, &block)
+					return nil unless env['rack.hijack?']
+					
+					connection = self.new(env, **options)
+					
+					if connection.supported?
+						return connection.response(&block)
+					else
+						return nil
+					end
+				end
+				
+				def initialize(env, supported_protocols: [], **options)
+					scheme = env['rack.url_scheme'] == 'https' ? 'wss' : 'ws'
+					@url = "#{scheme}://#{env['HTTP_HOST']}#{env['REQUEST_URI']}"
+					
+					@key = env['HTTP_SEC_WEBSOCKET_KEY']
+					@version = Integer(env['HTTP_SEC_WEBSOCKET_VERSION'])
+					
+					@protocol = negotiate_protocol(env, supported_protocols)
+				end
+				
+				def negotiate_protocol(env, supported_protocols)
+					if supported_protocols and client_protocols = env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+						return (supported_protocols & client_protocols.split(/\s*,\s/)).first
+					end
+				end
+				
+				attr :protocol
+				
+				def supported?
+					@key and @version == 13
+				end
+				
+				def make_connection(stream)
+					framer = Protocol::WebSocket::Framer.new(stream)
+					
+					Connection.new(framer, @protocol)
+				end
+				
+				def response_headers
+					headers = [
+						['connection', 'upgrade'],
+						['upgrade', 'websocket'],
+						['sec-websocket-accept', ::Protocol::WebSocket.accept_digest(@key)],
+					]
+					
+					if @protocol
+						headers << ['sec-websocket-protocol', @protocol]
+					end
+					
+					return headers
+				end
+				
+				def response(&block)
+					headers = [
+						['rack.hijack', ->(stream){block.call(make_connection(stream))}]
+					]
+					
+					# https://stackoverflow.com/questions/13545453/http-response-code-when-requested-websocket-subprotocol-isnt-supported-recogniz
+					return [101, response_headers + headers, nil]
+				end
+			end
+		end
+	end
+end

data/lib/async/websocket/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module WebSocket
-		VERSION = "0.8.0"
+		VERSION = "0.9.0"
 	end
 end

data/spec/async/websocket/client_spec.rb

@@ -21,32 +21,16 @@
 require "async/websocket/client"
 
 RSpec.describe Async::WebSocket::Client do
-	let(:client_double) {
-		instance_double(WebSocket::Driver::Client, on: nil, start: nil)
-	}
-
-	before do
-		allow(WebSocket::Driver).to receive(:client).and_return(client_double)
-	end
-
-	it "sets headers on the driver" do
-		headers = {
-			"Foo" => "Bar",
-			"Baz" => "Qux"
-		}
-
-		headers.each do |key, value|
-			expect(client_double).to receive(:set_header).with(key, value)
-		end
-
-		described_class.new(double(write: nil), "", headers: headers)
-	end
-
-	context "without passing headers" do
-		it "does not fail" do
-			expect {
-				described_class.new(double(write: nil))
-			}.not_to raise_error
+	context "headers:" do
+		let(:headers) {[
+			["Foo", "Bar"],
+			["Baz", "Qux"]
+		]}
+		
+		subject {described_class.new(nil, headers: headers)}
+		
+		it "sets client request headers" do
+			expect(subject.request_headers.to_h).to include(headers.to_h)
 		end
 	end
 end

data/spec/async/websocket/connection_spec.rb

@@ -26,8 +26,6 @@ require 'falcon/server'
 require 'falcon/adapters/rack'
 require 'async/http/url_endpoint'
 
-require 'pry'
-
 RSpec.describe Async::WebSocket::Connection, timeout: nil do
 	include_context Async::RSpec::Reactor
 	
@@ -42,14 +40,14 @@ RSpec.describe Async::WebSocket::Connection, timeout: nil do
 		
 		events = []
 		
-		server_address.connect do |socket|
-			client = Async::WebSocket::Client.new(socket)
-			
-			while event = client.next_event
+		Async::WebSocket::Client.open(server_address) do |connection|
+			while event = connection.next_message
+				expect(event).to include("line")
+				
 				events << event
 			end
 			
-			client.close # optional
+			connection.close # optional
 		end
 		
 		expect(events.size).to be > 0
@@ -57,20 +55,13 @@ RSpec.describe Async::WebSocket::Connection, timeout: nil do
 		server_task.stop
 	end
 
-	it "should send back Sec-WebSocket-Protocol header" do
+	it "should negotiate protocol" do
 		server_task = reactor.async do
 			server.run
 		end
 		
-		# Should send and receive Sec-WebSocket-Protocol header as
-		# `ws`
-		
-		server_address.connect do |socket|
-			client = Async::WebSocket::Client.new(socket, protocols: ['ws'])
-			
-			expect(client.next_event).to be_kind_of(WebSocket::Driver::OpenEvent)
-			
-			expect(client.driver.protocol).to be == 'ws'
+		Async::WebSocket::Client.open(server_address, protocols: ['ws']) do |connection|
+			expect(connection.protocol).to be == 'ws'
 		end
 		
 		server_task.stop

data/spec/async/websocket/upgrade.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/websocket/server'
+require 'async/websocket/server/rack'
 
 class Upgrade
 	def initialize(app)
@@ -26,16 +26,18 @@ class Upgrade
 	end
 	
 	def call(env)
-		result = Async::WebSocket::Server.open(env, protocols: ['ws']) do |server|
+		Async::WebSocket::Server::Rack.open(env, supported_protocols: ['ws']) do |connection|
 			read, write = IO.pipe
 			
 			Process.spawn("ls -lah", :out => write)
 			write.close
 			
 			read.each_line do |line|
-				server.send_text(line)
+				connection.send_message({line: line})
 			end
 			
+			# Gracefully close the connection:
+			connection.close
 		end or @app.call(env)
 	end
 end

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: async-websocket
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-04 00:00:00.000000000 Z
+date: 2019-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: websocket-driver
+  name: async-io
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '1.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '1.23'
 - !ruby/object:Gem::Dependency
-  name: async-io
+  name: protocol-http1
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: protocol-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '0.30'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: covered
   requirement: !ruby/object:Gem::Requirement
@@ -139,6 +153,7 @@ files:
 - async-websocket.gemspec
 - examples/chat/client.rb
 - examples/chat/config.ru
+- examples/chat/multi-client.rb
 - examples/middleware/client.rb
 - examples/middleware/config.ru
 - examples/utopia/.bowerrc
@@ -178,7 +193,9 @@ files:
 - lib/async/websocket.rb
 - lib/async/websocket/client.rb
 - lib/async/websocket/connection.rb
+- lib/async/websocket/error.rb
 - lib/async/websocket/server.rb
+- lib/async/websocket/server/rack.rb
 - lib/async/websocket/version.rb
 - spec/async/websocket/client_spec.rb
 - spec/async/websocket/connection_spec.rb
@@ -204,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: An async websocket library on top of websocket-driver.