async-websocket 0.10.0 → 0.11.0

data/lib/async/websocket/connection.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require 'protocol/websocket/connection'
+require 'protocol/websocket/headers'
 
 require 'json'
 
@@ -28,8 +29,10 @@ module Async
 		
 		# This is a basic synchronous websocket client:
 		class Connection < ::Protocol::WebSocket::Connection
-			def self.call(framer, protocol = nil, **options)
-				self.new(framer, protocol, **options)
+			include ::Protocol::WebSocket::Headers
+			
+			def self.call(framer, protocol = [], **options)
+				return self.new(framer, Array(protocol).first, **options)
 			end
 			
 			def initialize(framer, protocol = nil, **options)
@@ -40,7 +43,9 @@ module Async
 			attr :protocol
 			
 			def read
-				parse(super)
+				if buffer = super
+					parse(buffer)
+				end
 			end
 			
 			def write(object)
@@ -54,6 +59,10 @@ module Async
 			def dump(object)
 				JSON.dump(object)
 			end
+			
+			def call
+				self.close
+			end
 		end
 	end
 end

data/lib/async/websocket/request.rb

@@ -0,0 +1,71 @@
+# Copyright, 2017, 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_relative 'connect_request'
+require_relative 'upgrade_request'
+
+module Async
+	module WebSocket
+		class Request
+			include ::Protocol::WebSocket::Headers
+			
+			def self.websocket?(request)
+				Array(request.protocol).include?(PROTOCOL)
+			end
+			
+			def initialize(scheme = nil, authority = nil, path = nil, headers = [], **options)
+				@scheme = scheme
+				@authority = authority
+				@path = path
+				@headers = headers
+				
+				@options = options
+				
+				@body = nil
+			end
+			
+			attr_accessor :scheme
+			attr_accessor :authority
+			attr_accessor :path
+			attr_accessor :headers
+			
+			attr_accessor :body
+			
+			# Send the request to the given connection.
+			def call(connection)
+				if connection.http1?
+					return UpgradeRequest.new(self, **@options).call(connection)
+				elsif connection.http2?
+					return ConnectRequest.new(self, **@options).call(connection)
+				end
+				
+				raise HTTP::Error, "Unsupported HTTP version: #{connection.version}!"
+			end
+			
+			def idempotent?
+				true
+			end
+			
+			def to_s
+				"\#<#{self.class} #{@scheme}://#{@authority}: #{@path}>"
+			end
+		end
+	end
+end

data/lib/async/websocket/response.rb

@@ -0,0 +1,41 @@
+# Copyright, 2017, 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_relative 'upgrade_response'
+require_relative 'connect_response'
+
+require_relative 'error'
+
+module Async
+	module WebSocket
+		module Response
+			# Send the request to the given connection.
+			def self.for(request, headers = [], **options, &body)
+				if request.version =~ /http\/1/i
+					return UpgradeResponse.new(request, headers, **options, &body)
+				elsif request.version =~ /h2/i
+					return ConnectResponse.new(request, headers, **options, &body)
+				end
+				
+				raise ProtocolError, "Unsupported HTTP version: #{request.version}!"
+			end
+		end
+	end
+end

data/lib/async/websocket/server.rb

@@ -19,10 +19,45 @@
 # THE SOFTWARE.
 
 require_relative 'connection'
+require_relative 'response'
+
+require 'protocol/http/middleware'
 
 module Async
 	module WebSocket
-		module Server
+		class Server < ::Protocol::HTTP::Middleware
+			include ::Protocol::WebSocket::Headers
+			
+			def initialize(delegate, protocols: [], handler: Connection)
+				super(delegate)
+				
+				@protocols = protocols
+				@handler = handler
+			end
+			
+			def select_protocol(request)
+				if requested_protocol = request.headers[SEC_WEBSOCKET_PROTOCOL]
+					return (requested_protocol & @protocols).first
+				end
+			end
+			
+			def response(request)
+			end
+			
+			def call(request)
+				if request.protocol == PROTOCOL
+					# Select websocket sub-protocol:
+					protocol = select_protocol(request)
+					
+					Response.for(request, headers, protocol: protocol, **options) do |stream|
+						framer = Protocol::WebSocket::Framer.new(stream)
+						
+						yield handler.call(framer, protocol)
+					end
+				else
+					super
+				end
+			end
 		end
 	end
 end

data/lib/async/websocket/upgrade_request.rb

@@ -0,0 +1,106 @@
+# 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
+# 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/http/middleware'
+require 'protocol/http/request'
+
+require 'protocol/http/headers'
+require 'protocol/websocket/headers'
+
+require 'securerandom'
+
+require_relative 'error'
+
+module Async
+	module WebSocket
+		# This is required for HTTP/1.x to upgrade the connection to the WebSocket protocol.
+		class UpgradeRequest < ::Protocol::HTTP::Request
+			include ::Protocol::WebSocket::Headers
+			
+			class Wrapper
+				def initialize(response)
+					@response = response
+					@stream = nil
+				end
+				
+				def stream?
+					@response.status == 101
+				end
+				
+				def status
+					@response.status
+				end
+				
+				def headers
+					@response.headers
+				end
+				
+				def body?
+					false
+				end
+				
+				def body
+					nil
+				end
+				
+				def protocol
+					@response.protocol
+				end
+				
+				def stream
+					@stream ||= @response.hijack!
+				end
+			end
+			
+			def initialize(request, protocols: [], version: 13)
+				@key = Nounce.generate_key
+				
+				headers = [
+					[SEC_WEBSOCKET_KEY, @key],
+					[SEC_WEBSOCKET_VERSION, version],
+				]
+				
+				if protocols.any?
+					headers << [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)
+			end
+			
+			def call(connection)
+				response = super
+				
+				if accept_digest = response.headers[SEC_WEBSOCKET_ACCEPT]&.first
+					expected_accept_digest = Nounce.accept_digest(@key)
+					
+					unless accept_digest and accept_digest == expected_accept_digest
+						raise ProtocolError, "Invalid accept digest, expected #{expected_accept_digest.inspect}, got #{accept_digest.inspect}!"
+					end
+				end
+				
+				return Wrapper.new(response)
+			end
+		end
+	end
+end

data/lib/async/websocket/upgrade_response.rb

@@ -0,0 +1,52 @@
+# 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
+# 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/http/body/hijack'
+require 'protocol/http/response'
+require 'protocol/websocket/headers'
+
+module Async
+	module WebSocket
+		# The response from the server back to the client for negotiating HTTP/1.x WebSockets.
+		class UpgradeResponse < ::Protocol::HTTP::Response
+			include ::Protocol::WebSocket::Headers
+			
+			def initialize(request, headers = nil, protocol: nil, &block)
+				headers = Protocol::HTTP::Headers::Merged.new(headers)
+				
+				if accept_nounce = request.headers[SEC_WEBSOCKET_KEY]&.first
+					headers << [[SEC_WEBSOCKET_ACCEPT, Nounce.accept_digest(accept_nounce)]]
+					status = 101
+				else
+					status = 400
+				end
+				
+				if protocol
+					headers << [[SEC_WEBSOCKET_PROTOCOL, protocol]]
+				end
+				
+				body = Async::HTTP::Body::Hijack.wrap(request, &block)
+				super(request.version, status, nil, headers, body, PROTOCOL)
+			end
+		end
+	end
+end

data/lib/async/websocket/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module WebSocket
-		VERSION = "0.10.0"
+		VERSION = "0.11.0"
 	end
 end

data/spec/async/websocket/{server → adapters}/rack/client.rb

@@ -2,7 +2,7 @@
 
 require 'async'
 require 'async/io/stream'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 require 'async/websocket/client'
 
 USER = ARGV.pop || "anonymous"
@@ -13,7 +13,7 @@ Async do |task|
 		Async::IO::Generic.new($stdin)
 	)
 	
-	endpoint = Async::HTTP::URLEndpoint.parse(URL)
+	endpoint = Async::HTTP::Endpoint.parse(URL)
 	headers = {'token' => 'wubalubadubdub'}
 	
 	Async::WebSocket::Client.open(endpoint, headers: headers) do |connection|

data/spec/async/websocket/{server → adapters}/rack/config.ru

@@ -1,12 +1,12 @@
 #!/usr/bin/env -S falcon serve --bind http://localhost:7070 --count 1 -c
 
-require 'async/websocket/server/rack'
+require 'async/websocket/adapters/rack'
 require 'set'
 
 $connections = Set.new
 
 run lambda {|env|
-	Async::WebSocket::Server::Rack.open(env, supported_protocols: ['ws']) do |connection|
+	Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
 		$connections << connection
 		
 		begin

data/spec/async/websocket/{server → adapters}/rack_spec.rb

@@ -20,20 +20,20 @@
 
 require 'async/websocket'
 require 'async/websocket/client'
-require 'async/websocket/server/rack'
+require 'async/websocket/adapters/rack'
 
 require 'rack/test'
 require 'falcon/server'
 require 'falcon/adapters/rack'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 
-RSpec.describe Async::WebSocket::Server::Rack do
+RSpec.describe Async::WebSocket::Adapters::Rack do
 	include_context Async::RSpec::Reactor
 	
-	let(:server_address) {Async::HTTP::URLEndpoint.parse("http://localhost:7050")}
+	let(:endpoint) {Async::HTTP::Endpoint.parse("http://localhost:7050")}
 	let(:app) {Rack::Builder.parse_file(File.expand_path('rack/config.ru', __dir__)).first}
-	let(:server) {Falcon::Server.new(Falcon::Server.middleware(app), server_address)}
-	let(:client) {Async::HTTP::Client.new(server_address)}
+	let(:server) {Falcon::Server.new(Falcon::Server.middleware(app), endpoint)}
+	let(:client) {Async::HTTP::Client.new(endpoint)}
 	
 	let!(:server_task) do
 		reactor.async do
@@ -47,6 +47,7 @@ RSpec.describe Async::WebSocket::Server::Rack do
 	
 	it "can make non-websocket connection to server" do
 		response = client.get("/")
+		
 		expect(response).to be_success
 		expect(response.read).to be == "Hello World"
 		
@@ -58,7 +59,7 @@ RSpec.describe Async::WebSocket::Server::Rack do
 	end
 	
 	it "can make websocket connection to server" do
-		Async::WebSocket::Client.open(server_address) do |connection|
+		Async::WebSocket::Client.connect(endpoint) do |connection|
 			connection.write(message)
 			
 			expect(connection.read).to be == message
@@ -68,15 +69,15 @@ RSpec.describe Async::WebSocket::Server::Rack do
 	end
 	
 	it "should use mask over insecure connection" do
-		expect(server_address).to_not be_secure
+		expect(endpoint).to_not be_secure
 		
-		Async::WebSocket::Client.open(server_address) do |connection|
+		Async::WebSocket::Client.connect(endpoint) do |connection|
 			expect(connection.mask).to_not be_nil
 		end
 	end
 	
 	it "should negotiate protocol" do
-		Async::WebSocket::Client.open(server_address, protocols: ['ws']) do |connection|
+		Async::WebSocket::Client.connect(endpoint, protocols: ['ws']) do |connection|
 			expect(connection.protocol).to be == 'ws'
 		end
 	end