async-websocket 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 237b59048febd538e6112ea06b520c154386d057bd3b58a22bb153d45cd3209f
-  data.tar.gz: '0966a1666e31463adb1c2975f7e72534c7a8003794825ab94c24c3d5d02223e7'
+  metadata.gz: cc7cbd8769e7a5f2c98114c19e3e5b17b8e65b1d172e961b2efaca084b108dda
+  data.tar.gz: 25f69580b9e2f8839c2e3408bb926430eb720e9ec98ff483b4e69d9c3202f207
 SHA512:
-  metadata.gz: 7e25c38a3d25b98209d3999e803f031cb216dd1ccd47f1c2af92fd75cab7859d888ee9fd79873aab8d41d9d6e1ff4bd3bf64addcba74bad619613c948ec17e89
-  data.tar.gz: a7284a36f8525415327177da55e83d35001f329d50b4b1843e4cd0b4d2488b17da26559df0248e493bea86ac163e0f3434113a6b76e4d1c9a16978e3c4118a41
+  metadata.gz: dee41300f15a14eab436499d4ffaf3ec6906bd23000b4f2d1d5db996d70d43aec64f63d4c444731888eed71ecb6258a3361db643b782c815b85e74a062e45e7e
+  data.tar.gz: 68228e3e5abb6ac3eab178ecaf4d7a2e4556d6baa99c088b4b0bab6788cef669d1fdd1dae54a512b042b586fe35f94b2031d0540aa7261d3c2af26cffc5eaad5

data/.travis.yml

@@ -2,11 +2,13 @@ language: ruby
 dist: xenial
 cache: bundler
 
+script: bundle exec rspec
+
 matrix:
   include:
-    - rvm: 2.4
     - rvm: 2.5
     - rvm: 2.6
+    - rvm: 2.7
     - rvm: 2.6
       env: COVERAGE=PartialSummary,Coveralls
     - rvm: truffleruby
@@ -16,3 +18,4 @@ matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: truffleruby

data/Gemfile

@@ -4,9 +4,4 @@ gemspec
 
 group :test do
 	gem 'rack-test'
-	gem 'pry'
-end
-
-group :development do
-	gem 'tty-progressbar'
 end

data/README.md

@@ -6,6 +6,8 @@ A simple asynchronous websocket client/server implementation for [HTTP/1](https:
 [![Code Climate](https://codeclimate.com/github/socketry/async-websocket.svg)](https://codeclimate.com/github/socketry/async-websocket)
 [![Coverage Status](https://coveralls.io/repos/socketry/async-websocket/badge.svg)](https://coveralls.io/r/socketry/async-websocket)
 
+[![WebSocket Client & Server for Ruby](https://img.youtube.com/vi/aHop4Yyjs_o/0.jpg)](https://www.youtube.com/watch?v=aHop4Yyjs_o)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -48,7 +50,7 @@ Async do |task|
 	
 	endpoint = Async::HTTP::Endpoint.parse(URL)
 	
-	Async::WebSocket::Client.open(endpoint) do |connection|
+	Async::WebSocket::Client.connect(endpoint) do |connection|
 		input_task = task.async do
 			while line = stdin.read_until("\n")
 				connection.write({user: USER, text: line})
@@ -96,6 +98,18 @@ run lambda {|env|
 }
 ```
 
+### Force HTTP/1 Connection
+
+This forces the endpoint to connect using `HTTP/1.1`.
+
+```ruby
+endpoint = Async::HTTP::Endpoint.parse("https://remote-server.com", alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
+
+Async::WebSocket::Client.connect(endpoint) do ...
+```
+
+You may want to use this if the server advertises `HTTP/2` but doesn't support `HTTP/2` for WebSocket connections.
+
 ## Contributing
 
 1. Fork it

data/async-websocket.gemspec

@@ -9,21 +9,21 @@ Gem::Specification.new do |spec|
 	spec.summary       = %q{An async websocket library on top of websocket-driver.}
 	spec.homepage      = ""
 	spec.license       = "MIT"
-
+	
 	spec.files         = `git ls-files -z`.split("\x0")
 	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 "async-io", "~> 1.23"
-	spec.add_dependency "async-http", "~> 0.43"
+	spec.add_dependency "async-http", "~> 0.51"
 	spec.add_dependency "protocol-websocket", "~> 0.7.0"
 	
 	spec.add_development_dependency "async-rspec"
-	spec.add_development_dependency "falcon", "~> 0.32"
+	spec.add_development_dependency "falcon", "~> 0.34"
 	
 	spec.add_development_dependency "covered"
 	spec.add_development_dependency "bundler"
 	spec.add_development_dependency "rspec", "~> 3.6"
-	spec.add_development_dependency "rake"
+	spec.add_development_dependency "bake-bundler"
 end

data/examples/chat/.env

@@ -0,0 +1,3 @@
+export RUBY_FIBER_VM_STACK_SIZE=0
+export RUBY_FIBER_MACHINE_STACK_SIZE=0
+export RUBY_SHARED_FIBER_POOL_FREE_STACKS=0

data/examples/chat/README.md

@@ -1,3 +1,147 @@
 # The Journey to One Million
 
+## Allocations per Connection
 
+```
+Array: 188498 allocations
+Hash: 137041 allocations
+String: 91387 allocations
+Proc: 81242 allocations
+Fiber: 30169 allocations
+Async::Task: 30168 allocations
+Async::IO::Buffer: 20904 allocations
+Protocol::HTTP2::Window: 20162 allocations
+Set: 20091 allocations
+Async::Queue: 20082 allocations
+Method: 20006 allocations
+Protocol::HTTP::Headers::Merged: 10100 allocations
+Protocol::HTTP::Headers: 10100 allocations
+Async::Condition: 10002 allocations
+Protocol::WebSocket::Framer: 10001 allocations
+Async::HTTP::Body::Stream: 10001 allocations
+Async::HTTP::Body::Hijack: 10001 allocations
+Async::WebSocket::ConnectResponse: 10001 allocations
+Async::WebSocket::Connection: 10001 allocations
+Async::HTTP::Body::Writable: 10001 allocations
+Async::HTTP::Protocol::HTTP2::Request::Stream: 10001 allocations
+Async::HTTP::Protocol::HTTP2::Request: 10001 allocations
+Falcon::Adapters::Input: 10001 allocations
+Protocol::HTTP::Headers::Split: 10001 allocations
+Async::HTTP::Protocol::HTTP2::Stream::Input: 10001 allocations
+Async::HTTP::Protocol::HTTP2::Stream::Output: 10001 allocations
+** 80.98830116988302 objects per connection.
+```
+
+## System Limits
+
+### Fiber Performance
+
+To improve fiber performance:
+
+	export RUBY_FIBER_VM_STACK_SIZE=0
+	export RUBY_FIBER_MACHINE_STACK_SIZE=0
+	export RUBY_SHARED_FIBER_POOL_FREE_STACKS=0
+
+`RUBY_SHARED_FIBER_POOL_FREE_STACKS` is an experimental feature on `ruby-head`.
+
+### FiberError: can't set a guard page: Cannot allocate memory
+
+This error occurs because the operating system has limited resources for allocating fiber stacks.
+
+You can find the current limit:
+
+	% sysctl vm.max_map_count
+	vm.max_map_count = 65530
+
+You can increase it:
+
+	% sysctl -w vm.max_map_count=2500000
+
+## Logs
+
+### 2020
+
+```
+koyoko% ./multi-client.rb -c 100000
+ 0.15s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:39 +1300]
+               | Made 1 connections: 202.88 connections/second...
+ 0.15s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:39 +1300]
+               | GC.start duration=0.0s GC.count=27
+ 8.82s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:47 +1300]
+               | Made 10001 connections: 1152.85 connections/second...
+ 8.89s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:47 +1300]
+               | GC.start duration=0.06s GC.count=28
+ 17.7s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:56 +1300]
+               | Made 20001 connections: 1139.39 connections/second...
+17.84s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:11:56 +1300]
+               | GC.start duration=0.14s GC.count=29
+26.71s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:05 +1300]
+               | Made 30001 connections: 1129.44 connections/second...
+ 26.9s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:05 +1300]
+               | GC.start duration=0.19s GC.count=30
+35.97s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:14 +1300]
+               | Made 40001 connections: 1116.59 connections/second...
+36.22s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:15 +1300]
+               | GC.start duration=0.25s GC.count=31
+45.41s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:24 +1300]
+               | Made 50001 connections: 1104.74 connections/second...
+45.65s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:24 +1300]
+               | GC.start duration=0.24s GC.count=32
+54.94s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:33 +1300]
+               | Made 60001 connections: 1095.18 connections/second...
+ 55.3s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:34 +1300]
+               | GC.start duration=0.37s GC.count=33
+  1m4s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:43 +1300]
+               | Made 70001 connections: 1085.98 connections/second...
+  1m5s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:43 +1300]
+               | GC.start duration=0.44s GC.count=34
+ 1m14s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:53 +1300]
+               | Made 80001 connections: 1074.6 connections/second...
+ 1m14s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:12:53 +1300]
+               | GC.start duration=0.36s GC.count=35
+ 1m24s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:13:03 +1300]
+               | Made 90001 connections: 1066.37 connections/second...
+ 1m24s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:13:03 +1300]
+               | GC.start duration=0.35s GC.count=36
+ 1m34s     info: Command [oid=0x2f8] [pid=820099] [2020-02-04 23:13:13 +1300]
+               | Finished top level connection loop...
+```
+
+### 2019
+
+This report is affected by `tty-progressbar` bugs.
+
+```
+koyoko% bundle exec ./multi-client.rb --count 100000
+145.94 connection/s [                                                                                                         ] 1/100000 ( 6s/ 0s)
+ 0.11s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:29:58 +1200]
+               | GC.start -> 0.01s
+591.10 connection/s [==========                                                                                        ] 10001/100000 ( 1m52s/12s)
+12.92s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:30:11 +1200]
+               | GC.start -> 0.3s
+455.06 connection/s [====================                                                                              ] 20001/100000 ( 1m42s/25s)
+26.17s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:30:24 +1200]
+               | GC.start -> 0.45s
+294.11 connection/s [=============================                                                                     ] 30001/100000 ( 1m31s/39s)
+39.95s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:30:38 +1200]
+               | GC.start -> 0.68s
+153.08 connection/s [=======================================                                                           ] 40001/100000 ( 1m19s/53s)
+ 53.9s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:30:52 +1200]
+               | GC.start -> 0.8s
+23.03 connection/s [================================================                                                ] 50001/100000 ( 1m 7s/ 1m 7s)
+  1m8s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:31:07 +1200]
+               | GC.start -> 0.95s
+0.87552 connection/s [==========================================================                                       ] 60001/100000 (55s/ 1m23s)
+ 1m24s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:31:23 +1200]
+               | GC.start -> 1.04s
+0.74375 connection/s [====================================================================                             ] 70001/100000 (43s/ 1m42s)
+ 1m43s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:31:42 +1200]
+               | GC.start -> 1.17s
+0.64832 connection/s [==============================================================================                   ] 80001/100000 (30s/ 2m 2s)
+  2m4s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:32:02 +1200]
+               | GC.start -> 1.29s
+0.57842 connection/s [=======================================================================================          ] 90001/100000 (16s/ 2m26s)
+ 2m27s     info: #<Command:0x000055de596579e8> [pid=14815] [2019-07-08 00:32:26 +1200]
+               | GC.start -> 1.55s
+435.05 connection/s [=================================================================================================] 100000/100000 ( 0s/ 2m50s)
+```

data/examples/chat/config.ru

@@ -13,10 +13,21 @@ class Room
 	def initialize
 		@connections = Set.new
 		@semaphore = Async::Semaphore.new(512)
+		
+		@count = 0
+		@profile = nil
 	end
 	
 	def connect connection
 		@connections << connection
+		
+		@count += 1
+		
+		if (@count % 10000).zero?
+			# (full_mark: false, immediate_sweep: false)
+			duration = Async::Clock.measure{GC.start}
+			Async.logger.info(self) {"GC.start duration=#{duration.round(2)}s GC.count=#{GC.count} @connections.count=#{@connections.count}"}
+		end
 	end
 	
 	def disconnect connection
@@ -58,6 +69,28 @@ class Room
 		end
 	end
 	
+	def start_profile
+		require 'ruby-prof' unless defined?(RubyProf)
+		
+		return false if @profile
+		
+		@profile = RubyProf::Profile.new(merge_fibers: true)
+		@profile.start
+	end
+	
+	def stop_profile
+		return false unless @profile
+		
+		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)
+		
+		@profile = nil
+	end
+	
 	def command(code)
 		Async.logger.warn self, "eval(#{code})"
 		
@@ -82,6 +115,10 @@ class Room
 	def open(connection)
 		self.connect(connection)
 		
+		if @connections.size == 1_000_000
+			connection.write("Congratulations, you have completed the journey to one million! 🥳 👏👏👏🏼")
+		end
+		
 		while message = connection.read
 			if message[:text] =~ /^\/(.*?)$/
 				begin

data/examples/chat/multi-client.rb

@@ -8,9 +8,6 @@ require 'async/http/endpoint'
 require_relative '../../lib/async/websocket/client'
 
 require 'samovar'
-require 'ruby-prof'
-
-require 'tty/progressbar'
 
 GC.disable
 
@@ -30,14 +27,12 @@ class Command < Samovar::Command
 	end
 	
 	def call
-		endpoint = Async::HTTP::Endpoint.parse(@options[:connect], local_address: self.local_address)
+		endpoint = Async::HTTP::Endpoint.parse(@options[:connect])
+		# endpoint = endpoint.each.first
+		
 		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!
@@ -45,36 +40,39 @@ class Command < Samovar::Command
 			task.async do |subtask|
 				while connection = connections.dequeue
 					subtask.async(connection) do |subtask, connection|
-						pp connection.read
-						
 						while message = connection.read
-							pp message
+							puts "> #{message.inspect}"
 						end
 					ensure
 						connection.close
 					end
 				end
 				
-				# subtask.children.each(&:stop)
+				GC.start
 			end
 			
 			client = Async::WebSocket::Client.open(endpoint)
+			start_time = Async::Clock.now
 			
 			count.times do |i|
 				connections.enqueue(client.connect(endpoint.path))
-				progress.advance(1)
+				
+				if (i % 10000).zero?
+					count = i+1
+					duration = Async::Clock.now - start_time
+					Async.logger.info(self) {"Made #{count} connections: #{(count/duration).round(2)} connections/second..."}
+				end
+				
+				if (i % 10000).zero?
+					duration = Async::Clock.measure{GC.start(full_mark: false, immediate_sweep: false)}
+					Async.logger.info(self) {"GC.start duration=#{duration.round(2)}s GC.count=#{GC.count}"}
+				end
 			end
 			
 			connections.enqueue(nil)
+			
+			Async.logger.info(self) {"Finished top level connection loop..."}
 		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
 

data/examples/mud/client.rb

@@ -15,7 +15,7 @@ Async do |task|
 	
 	endpoint = Async::HTTP::Endpoint.parse(URL)
 	
-	Async::WebSocket::Client.open(endpoint) do |connection|
+	Async::WebSocket::Client.connect(endpoint) do |connection|
 		task.async do
 			$stdout.write "> "
 			

data/examples/mud/config.ru

@@ -1,4 +1,4 @@
-#!/usr/bin/env falcon serve --count 1 --bind http://127.0.0.1:7070 -c
+#!/usr/bin/env -S falcon serve --count 1 --bind http://127.0.0.1:7070 -c
 
 require 'async/websocket/adapters/rack'
 
@@ -124,7 +124,7 @@ class Server
 	end
 	
 	def call(env)
-		Async::WebSocket::Adapters::Rack.open(env, connect: User) do |user|
+		Async::WebSocket::Adapters::Rack.open(env, handler: User) do |user|
 			@entrance.enter(user)
 			
 			while message = user.read

data/examples/rack/client.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'async'
-require 'async/io/stream'
 require 'async/http/endpoint'
 require 'async/websocket/client'
 
@@ -11,7 +10,7 @@ Async do |task|
 	endpoint = Async::HTTP::Endpoint.parse(URL)
 	
 	Async::WebSocket::Client.connect(endpoint) do |connection|
-		connection.write ["Hello World"]
+		connection.write ["Hello", "World"]
 		
 		while message = connection.read
 			p message

data/examples/rack/config.ru

@@ -3,11 +3,9 @@
 require 'async/websocket/adapters/rack'
 
 app = lambda do |env|
-	Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
-		p [env["REMOTE_ADDR"], "connected", env["VERSION"]]
+	Async::WebSocket::Adapters::Rack.open(env) do |connection|
 		message = connection.read
-		p message
-		connection.write message
+		connection.write message.reverse
 	end
 end
 

data/examples/utopia/Gemfile

@@ -1,7 +1,7 @@
 
 source "https://rubygems.org"
 
-gem "utopia", "~> 2.9.0"
+gem "utopia", "~> 2.9.3"
 
 gem "rake"
 gem "bundler"

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

@@ -35,20 +35,26 @@ module Async
 				
 				def self.open(env, headers: [], protocols: [], handler: Connection, **options, &block)
 					if request = env['async.http.request'] and Array(request.protocol).include?(PROTOCOL)
+						env = nil
+						
 						# Select websocket sub-protocol:
 						if requested_protocol = request.headers[SEC_WEBSOCKET_PROTOCOL]
 							protocol = (requested_protocol & protocols).first
 						end
 						
 						response = Response.for(request, headers, protocol: protocol, **options) do |stream|
+							response = nil
+							
 							framer = Protocol::WebSocket::Framer.new(stream)
 							
 							connection = handler.call(framer, protocol)
+							
 							yield connection
 							
 							connection.close unless connection.closed?
 						end
 						
+						request = nil
 						headers = response.headers
 						
 						if protocol = response.protocol

data/lib/async/websocket/client.rb

@@ -34,6 +34,7 @@ module Async
 		class Client < ::Protocol::HTTP::Middleware
 			include ::Protocol::WebSocket::Headers
 			
+			# @return [Client] a client which can be used to establish websocket connections to the given endpoint.
 			def self.open(endpoint, *args, &block)
 				client = self.new(HTTP::Client.new(endpoint, *args), mask: endpoint.secure?)
 				
@@ -46,6 +47,7 @@ module Async
 				end
 			end
 			
+			# @return [Connection] an open websocket connection to the given endpoint.
 			def self.connect(endpoint, *args, **options, &block)
 				self.open(endpoint, *args) do |client|
 					connection = client.connect(endpoint.path, **options)
@@ -60,33 +62,47 @@ module Async
 				end
 			end
 			
-			def initialize(delegate, **options)
-				super(delegate)
+			def initialize(client, **options)
+				super(client)
 				
 				@options = options
 			end
 			
-			def connect(path, headers: [], handler: Connection, **options)
+			class Framer < ::Protocol::WebSocket::Framer
+				def initialize(pool, connection, stream)
+					super(stream)
+					@pool = pool
+					@connection = connection
+				end
+				
+				def close
+					super
+					
+					if @pool
+						@pool.release(@connection)
+						@pool = nil
+						@connection = nil
+					end
+				end
+			end
+			
+			def connect(path, headers: nil, handler: Connection, **options, &block)
+				headers = ::Protocol::HTTP::Headers[headers]
 				request = Request.new(nil, nil, path, headers, **options)
 				
-				response = self.call(request)
+				pool = @delegate.pool
+				connection = pool.acquire
+				
+				response = request.call(connection)
 				
 				unless response.stream?
 					raise ProtocolError, "Failed to negotiate connection: #{response.status}"
 				end
 				
 				protocol = response.headers[SEC_WEBSOCKET_PROTOCOL]&.first
-				framer = Protocol::WebSocket::Framer.new(response.stream)
-				
-				connection = handler.call(framer, protocol, **@options)
-				
-				return connection unless block_given?
+				framer = Framer.new(pool, connection, response.stream)
 				
-				begin
-					yield connection
-				ensure
-					connection.close
-				end
+				handler.call(framer, protocol, **@options, &block)
 			end
 		end
 	end

data/lib/async/websocket/connect_request.rb

@@ -34,17 +34,19 @@ module Async
 			include ::Protocol::WebSocket::Headers
 			
 			class Wrapper
-				def initialize(output, response)
-					@output = output
-					@body = output
+				def initialize(stream, response)
 					@response = response
-					@stream = nil
+					@body = @response.body
+					@stream = stream
 				end
 				
+				attr_accessor :response
+				
 				attr_accessor :body
+				attr_accessor :stream
 				
 				def stream?
-					@response.success?
+					@response.success? and @stream
 				end
 				
 				def status
@@ -62,30 +64,39 @@ module Async
 				def protocol
 					@response.protocol
 				end
+			end
+			
+			class Hijack < Async::HTTP::Body::Readable
+				def initialize(request)
+					@request = request
+					@stream = nil
+				end
+				
+				attr :stream
 				
-				def stream
-					@stream ||= Async::HTTP::Body::Stream.new(@response.body, @output)
+				def call(stream)
+					@stream = stream
 				end
 			end
 			
-			def initialize(request, protocols: [], version: 13)
-				body = Async::HTTP::Body::Writable.new
+			def initialize(request, protocols: [], version: 13, &block)
+				body = Hijack.new(self)
 				
-				headers = []
+				headers = ::Protocol::HTTP::Headers[request.headers]
 				
-				headers << [SEC_WEBSOCKET_VERSION, version]
+				headers.add(SEC_WEBSOCKET_VERSION, String(version))
 				
 				if protocols.any?
-					headers << [SEC_WEBSOCKET_PROTOCOL, protocols.join(',')]
+					headers.add(SEC_WEBSOCKET_PROTOCOL, protocols.join(','))
 				end
 				
-				merged_headers = ::Protocol::HTTP::Headers::Merged.new(request.headers, headers)
-				
-				super(request.scheme, request.authority, ::Protocol::HTTP::Methods::CONNECT, request.path, nil, merged_headers, body, PROTOCOL)
+				super(request.scheme, request.authority, ::Protocol::HTTP::Methods::CONNECT, request.path, nil, headers, body, PROTOCOL)
 			end
 			
 			def call(connection)
-				Wrapper.new(body, super)
+				response = super
+				
+				Wrapper.new(@body.stream, response)
 			end
 		end
 	end

data/lib/async/websocket/connect_response.rb

@@ -30,10 +30,10 @@ module Async
 			include ::Protocol::WebSocket::Headers
 			
 			def initialize(request, headers = nil, protocol: nil, &block)
-				headers = Protocol::HTTP::Headers::Merged.new(headers)
+				headers = ::Protocol::HTTP::Headers[headers]
 				
 				if protocol
-					headers << [[SEC_WEBSOCKET_PROTOCOL, protocol]]
+					headers.add(SEC_WEBSOCKET_PROTOCOL, protocol)
 				end
 				
 				body = Async::HTTP::Body::Hijack.wrap(request, &block)

data/lib/async/websocket/connection.rb

@@ -32,12 +32,30 @@ module Async
 			include ::Protocol::WebSocket::Headers
 			
 			def self.call(framer, protocol = [], **options)
-				return self.new(framer, Array(protocol).first, **options)
+				instance = self.new(framer, Array(protocol).first, **options)
+				
+				return instance unless block_given?
+				
+				begin
+					yield instance
+				ensure
+					instance.close
+				end
 			end
 			
-			def initialize(framer, protocol = nil, **options)
+			def initialize(framer, protocol = nil, response: nil, **options)
 				super(framer, **options)
 				@protocol = protocol
+				@response = response
+			end
+			
+			def close
+				super
+				
+				if @response
+					@response.finish
+					@response = nil
+				end
 			end
 			
 			attr :protocol

data/lib/async/websocket/request.rb

@@ -30,7 +30,7 @@ module Async
 				Array(request.protocol).include?(PROTOCOL)
 			end
 			
-			def initialize(scheme = nil, authority = nil, path = nil, headers = [], **options)
+			def initialize(scheme = nil, authority = nil, path = nil, headers = nil, **options, &block)
 				@scheme = scheme
 				@authority = authority
 				@path = path

data/lib/async/websocket/response.rb

@@ -27,7 +27,7 @@ module Async
 	module WebSocket
 		module Response
 			# Send the request to the given connection.
-			def self.for(request, headers = [], **options, &body)
+			def self.for(request, headers = nil, **options, &body)
 				if request.version =~ /http\/1/i
 					return UpgradeResponse.new(request, headers, **options, &body)
 				elsif request.version =~ /h2/i

data/lib/async/websocket/server.rb

@@ -49,6 +49,8 @@ module Async
 					# Select websocket sub-protocol:
 					protocol = select_protocol(request)
 					
+					# request.headers = nil
+					
 					Response.for(request, headers, protocol: protocol, **options) do |stream|
 						framer = Protocol::WebSocket::Framer.new(stream)
 						

data/lib/async/websocket/upgrade_request.rb

@@ -42,6 +42,8 @@ module Async
 					@stream = nil
 				end
 				
+				attr_accessor :response
+				
 				def stream?
 					@response.status == 101
 				end
@@ -71,21 +73,19 @@ module Async
 				end
 			end
 			
-			def initialize(request, protocols: [], version: 13)
+			def initialize(request, protocols: [], version: 13, &block)
 				@key = Nounce.generate_key
 				
-				headers = [
-					[SEC_WEBSOCKET_KEY, @key],
-					[SEC_WEBSOCKET_VERSION, version],
-				]
+				headers = ::Protocol::HTTP::Headers[request.headers]
+				
+				headers.add(SEC_WEBSOCKET_KEY, @key)
+				headers.add(SEC_WEBSOCKET_VERSION, String(version))
 				
 				if protocols.any?
-					headers << [SEC_WEBSOCKET_PROTOCOL, protocols.join(',')]
+					headers.add(SEC_WEBSOCKET_PROTOCOL, protocols.join(','))
 				end
 				
-				merged_headers = ::Protocol::HTTP::Headers::Merged.new(request.headers, headers)
-				
-				super(request.scheme, request.authority, ::Protocol::HTTP::Methods::GET, request.path, nil, merged_headers, nil, PROTOCOL)
+				super(request.scheme, request.authority, ::Protocol::HTTP::Methods::GET, request.path, nil, headers, nil, PROTOCOL)
 			end
 			
 			def call(connection)

data/lib/async/websocket/upgrade_response.rb

@@ -31,17 +31,17 @@ module Async
 			include ::Protocol::WebSocket::Headers
 			
 			def initialize(request, headers = nil, protocol: nil, &block)
-				headers = Protocol::HTTP::Headers::Merged.new(headers)
+				headers = ::Protocol::HTTP::Headers[headers]
 				
 				if accept_nounce = request.headers[SEC_WEBSOCKET_KEY]&.first
-					headers << [[SEC_WEBSOCKET_ACCEPT, Nounce.accept_digest(accept_nounce)]]
+					headers.add(SEC_WEBSOCKET_ACCEPT, Nounce.accept_digest(accept_nounce))
 					status = 101
 				else
 					status = 400
 				end
 				
 				if protocol
-					headers << [[SEC_WEBSOCKET_PROTOCOL, protocol]]
+					headers.add(SEC_WEBSOCKET_PROTOCOL, protocol)
 				end
 				
 				body = Async::HTTP::Body::Hijack.wrap(request, &block)

data/lib/async/websocket/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module WebSocket
-		VERSION = "0.13.1"
+		VERSION = "0.14.0"
 	end
 end

data/spec/async/websocket/server_examples.rb

@@ -72,10 +72,46 @@ RSpec.shared_context Async::WebSocket::Server do
 	it "can establish connection" do
 		connection = client.connect("/server")
 		
-		expect(connection.read).to be == message
-		expect(connection.read).to be_nil
-		expect(connection).to be_closed
+		begin
+			expect(connection.read).to be == message
+			expect(connection.read).to be_nil
+			expect(connection).to be_closed
+		ensure
+			connection.close
+		end
+	end
+	
+	context "with headers" do
+		let(:headers) {{"foo" => "bar"}}
 		
-		connection.close
+		let(:server) do
+			Async::HTTP::Server.for(endpoint, protocol) do |request|
+				if Async::WebSocket::Request.websocket?(request)
+					Async::WebSocket::Response.for(request, headers) do |stream|
+						framer = Protocol::WebSocket::Framer.new(stream)
+						
+						connection = handler.call(framer)
+						
+						connection.write(request.headers.fields)
+						
+						connection.close
+					end
+				else
+					Protocol::HTTP::Response[404, {}, []]
+				end
+			end
+		end
+		
+		it "can send headers" do
+			connection = client.connect("/headers", headers: headers)
+			
+			begin
+				expect(connection.read.to_h).to include(*headers.keys)
+				expect(connection.read).to be_nil
+				expect(connection).to be_closed
+			ensure
+				connection.close
+			end
+		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-websocket
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-04 00:00:00.000000000 Z
+date: 2020-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-io
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.43'
+        version: '0.51'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.43'
+        version: '0.51'
 - !ruby/object:Gem::Dependency
   name: protocol-websocket
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.32'
+        version: '0.34'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.32'
+        version: '0.34'
 - !ruby/object:Gem::Dependency
   name: covered
   requirement: !ruby/object:Gem::Requirement
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.6'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bake-bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -149,8 +149,8 @@ files:
 - ".travis.yml"
 - Gemfile
 - README.md
-- Rakefile
 - async-websocket.gemspec
+- examples/chat/.env
 - examples/chat/README.md
 - examples/chat/client.rb
 - examples/chat/config.ru
@@ -209,7 +209,6 @@ files:
 - spec/async/websocket/adapters/rack/client.rb
 - spec/async/websocket/adapters/rack/config.ru
 - spec/async/websocket/adapters/rack_spec.rb
-- spec/async/websocket/client_spec.rb
 - spec/async/websocket/connection_spec.rb
 - spec/async/websocket/server_examples.rb
 - spec/async/websocket/server_spec.rb
@@ -234,7 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: An async websocket library on top of websocket-driver.
@@ -242,7 +241,6 @@ test_files:
 - spec/async/websocket/adapters/rack/client.rb
 - spec/async/websocket/adapters/rack/config.ru
 - spec/async/websocket/adapters/rack_spec.rb
-- spec/async/websocket/client_spec.rb
 - spec/async/websocket/connection_spec.rb
 - spec/async/websocket/server_examples.rb
 - spec/async/websocket/server_spec.rb

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/spec/async/websocket/client_spec.rb

@@ -1,48 +0,0 @@
-# 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 "async/websocket/client"
-require "async/websocket/response"
-
-RSpec.describe Async::WebSocket::Client do
-	describe '#connect' do
-		let(:headers) {[
-			["Foo", "Bar"],
-			["Baz", "Qux"]
-		]}
-		
-		let(:client) {double}
-		let(:stream) {double}
-		
-		subject {described_class.new(client)}
-		let(:response) {Protocol::HTTP::Response.new(nil, 101, {}, nil, Protocol::WebSocket::Headers::PROTOCOL)}
-		
-		it "sets client request headers" do
-			expect(response).to receive(:stream?).and_return(true)
-			expect(response).to receive(:stream).and_return(stream)
-			
-			expect(client).to receive(:call) do |request|
-				expect(request.headers.to_h).to include("Foo", "Baz")
-			end.and_return(response)
-			
-			subject.connect("/server", headers: headers)
-		end
-	end
-end