falcon 0.36.4

data/examples/redis/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem "sinatra"
+gem "falcon"
+
+gem "async-redis", ">= 0.3.1"

data/examples/redis/config.ru

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'async/redis'
+require 'async/clock'
+
+CLIENT = Async::Redis::Client.new(Async::Redis.local_endpoint)
+
+class MyApp < Sinatra::Base
+	get "/" do
+		puts "Starting BLPOP SLEEP..."
+		duration = Async::Clock.measure do
+			CLIENT.call "BLPOP", "SLEEP", 1
+		end
+		puts "Finished BLPOP SLEEP after #{duration.round(2)}s"
+		
+		"ok"
+	end
+end
+
+use MyApp # Then, it will get to Sinatra.
+run lambda {|env| [404, {}, []]} # Bottom of the stack, give 404.
+
+# Start server like this:
+# falcon --verbose serve --threaded --count 1 --bind http://localhost:9292
+
+# Test server, e.g.:
+# time ab -n 64 -c 64 http://localhost:9292/

data/examples/sequel/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'falcon'
+gem 'sequel'

data/examples/sequel/config.ru

@@ -0,0 +1,8 @@
+# config.ru
+require 'sequel'
+
+# Turn on single threaded mode
+Sequel.single_threaded = true
+DB = Sequel.sqlite('data.sqlite3')
+
+run(proc{|env| [200, {}, [DB[:user].get(:name)]]})

data/examples/server/standalone.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'async'
+require 'async/http/endpoint'
+require 'async/websocket/adapters/rack'
+
+require 'falcon'
+
+module WebSocketApp
+	def self.call(env)
+		Async::WebSocket::Adapters::Rack.open(env, protocols: %w[ws]) do |connection|
+			while (message = connection.read)
+				pp message
+			end
+		end or [200, [], ["Websocket only."]]
+	end
+end
+
+Async do
+	websocket_endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:3000')
+	
+	app = Falcon::Server.middleware(WebSocketApp)
+	
+	server = Falcon::Server.new(app, websocket_endpoint)
+	
+	server.run.each(&:wait)
+end

data/examples/sinatra/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem "sinatra"
+gem "falcon"

data/examples/sinatra/Gemfile.lock

@@ -0,0 +1,53 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    async (1.9.1)
+      nio4r (~> 2.3)
+      timers (~> 4.1)
+    async-container (0.5.0)
+      async (~> 1.0)
+      async-io (~> 1.4)
+    async-http (0.24.3)
+      async (~> 1.6)
+      async-io (~> 1.12)
+      http-2 (~> 0.9.0)
+    async-io (1.12.1)
+      async (~> 1.3)
+    falcon (0.15.2)
+      async-container (~> 0.5.0)
+      async-http (~> 0.24.0)
+      async-io (~> 1.9)
+      rack (>= 1.0)
+      samovar (~> 1.3)
+    hitimes (1.2.6)
+    http-2 (0.9.1)
+    mapping (1.1.1)
+    mustermann (1.0.2)
+    nio4r (2.3.1)
+    rack (2.0.8)
+    rack-protection (2.0.3)
+      rack
+    rainbow (2.2.2)
+      rake
+    rake (13.0.1)
+    samovar (1.8.0)
+      mapping (~> 1.0)
+      rainbow (~> 2.0)
+    sinatra (2.0.3)
+      mustermann (~> 1.0)
+      rack (~> 2.0)
+      rack-protection (= 2.0.3)
+      tilt (~> 2.0)
+    tilt (2.0.8)
+    timers (4.1.2)
+      hitimes
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  falcon
+  sinatra
+
+BUNDLED WITH
+   1.16.1

data/examples/sinatra/config.ru

@@ -0,0 +1,16 @@
+#!/usr/bin/env falcon --verbose serve -c
+# frozen_string_literal: true
+
+# Save this as `config.ru`, make it executable and then run it (or run falcon serve by hand)
+
+# Middleware that responds to incoming requests:
+require 'sinatra/base'
+class MyApp < Sinatra::Base
+	get "/" do
+		response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+	end
+end
+
+# Build the middleware stack:
+use MyApp # Then, it will get to Sinatra.
+run lambda {|env| [404, {}, []]} # Bottom of the stack, give 404.

data/examples/trailers/config.ru

@@ -0,0 +1,34 @@
+#!/usr/bin/env falcon --verbose serve -c
+# frozen_string_literal: true
+
+require 'async'
+
+class RequestLogger
+	def initialize(app)
+		@app = app
+	end
+	
+	def call(env)
+		logger = Async.logger.with(level: :debug, name: "middleware")
+		
+		Async(logger: logger) do
+			@app.call(env)
+		end.wait
+	end
+end
+
+use RequestLogger
+
+run lambda {|env|
+	start_time = Async::Clock.now
+	
+	server_timing = ->{
+		"app;dur=#{Async::Clock.now - start_time}"
+	}
+	
+	[
+		200,
+		[["trailers", "server-timing"], ["server-timing", server_timing]],
+		["Hello World"]
+	]
+}

data/examples/trailers/falcon.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env falcon-host
+# frozen_string_literal: true
+
+load :rack, :self_signed_tls, :supervisor
+
+rack 'trailers.localhost', :self_signed_tls
+
+supervisor

data/falcon.gemspec

@@ -0,0 +1,45 @@
+
+require_relative 'lib/falcon/version'
+
+Gem::Specification.new do |spec|
+	spec.name          = "falcon"
+	spec.version       = Falcon::VERSION
+	spec.authors       = ["Samuel Williams"]
+	spec.email         = ["samuel.williams@oriontransfer.co.nz"]
+	
+	spec.summary       = "A fast, asynchronous, rack-compatible web server."
+	spec.homepage      = "https://github.com/socketry/falcon"
+	
+	spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+		f.match(%r{^(test|spec|features)/})
+	end
+	
+	spec.required_ruby_version = '~> 2.4'
+	
+	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.require_paths = ["lib"]
+	
+	spec.add_dependency "async", "~> 1.13"
+	spec.add_dependency "async-io", "~> 1.22"
+	spec.add_dependency "async-http", "~> 0.52.0"
+	spec.add_dependency "async-http-cache", "~> 0.2.0"
+	spec.add_dependency "async-container", "~> 0.16.0"
+	
+	spec.add_dependency "rack", ">= 1.0"
+	
+	spec.add_dependency 'samovar', "~> 2.1"
+	spec.add_dependency 'localhost', "~> 1.1"
+	spec.add_dependency 'build-environment', '~> 1.13'
+	
+	spec.add_dependency 'process-metrics', '~> 0.2.0'
+	
+	spec.add_development_dependency "async-rspec", "~> 1.7"
+	spec.add_development_dependency "async-websocket", "~> 0.14.0"
+	spec.add_development_dependency "async-process", "~> 1.1"
+	
+	spec.add_development_dependency "bake"
+	spec.add_development_dependency "covered"
+	spec.add_development_dependency "bundler"
+	spec.add_development_dependency "rspec", "~> 3.6"
+	spec.add_development_dependency "bake-bundler"
+end

data/gems/rack1.gemfile

@@ -0,0 +1,4 @@
+
+eval_gemfile("../Gemfile")
+
+gem 'rack', '~> 1.0'

data/gems/rack3.gemfile

@@ -0,0 +1,4 @@
+
+eval_gemfile("../Gemfile")
+
+gem 'rack', github: 'rack/rack'

data/lib/falcon.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# 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 "falcon/server"

data/lib/falcon/adapters/early_hints.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: 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/http/middleware'
+
+module Falcon
+	module Adapters
+		class EarlyHints
+			PRELOAD = /<(?<path>.*?)>;.*?rel=preload/
+			
+			def initialize(request)
+				@request = request
+			end
+			
+			def push(path, preload: true, **options)
+				@request.push(path)
+			end
+			
+			def call(headers)
+				headers.each do |key, value|
+					if key.casecmp("link").zero? and match = PRELOAD.match(value)
+						@request.push(match[:path])
+					else
+						Async.logger.warn(@request) {"Unsure how to handle early hints header: #{key}"}
+					end
+				end
+			end
+		end
+	end
+end

data/lib/falcon/adapters/input.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# Copyright, 2018, 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/io/buffer'
+require 'protocol/http/body/rewindable'
+
+module Falcon
+	module Adapters
+		# The input stream is an IO-like object which contains the raw HTTP POST data. When applicable, its external encoding must be “ASCII-8BIT” and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to gets, each, read and rewind.
+		class Input
+			def initialize(body)
+				@body = body
+				
+				# Will hold remaining data in `#read`.
+				@buffer = nil
+				@finished = @body.nil?
+			end
+			
+			attr :body
+			
+			# each must be called without arguments and only yield Strings.
+			def each(&block)
+				return to_enum unless block_given?
+				
+				while chunk = gets
+					yield chunk
+				end
+			end
+			
+			# rewind must be called without arguments. It rewinds the input stream back to the beginning. It must not raise Errno::ESPIPE: that is, it may not be a pipe or a socket. Therefore, handler developers must buffer the input data into some rewindable object if the underlying input stream is not rewindable.
+			# @return [Boolean] whether the body could be rewound.
+			def rewind
+				if @body and @body.respond_to? :rewind
+					# If the body is not rewindable, this will fail.
+					@body.rewind
+					@buffer = nil
+					@finished = false
+					
+					return true
+				end
+				
+				return false
+			end
+			
+			# read behaves like IO#read. Its signature is read([length, [buffer]]). If given, length must be a non-negative Integer (>= 0) or nil, and buffer must be a String and may not be nil. If length is given and not nil, then this method reads at most length bytes from the input stream. If length is not given or nil, then this method reads all data until EOF. When EOF is reached, this method returns nil if length is given and not nil, or “” if length is not given or is nil. If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
+			# @param length [Integer] the amount of data to read
+			# @param buffer [String] the buffer which will receive the data
+			# @return a buffer containing the data
+			def read(length = nil, buffer = nil)
+				buffer ||= Async::IO::Buffer.new
+				buffer.clear
+				
+				until buffer.bytesize == length
+					@buffer = read_next if @buffer.nil?
+					break if @buffer.nil?
+					
+					remaining_length = length - buffer.bytesize if length
+					
+					if remaining_length && remaining_length < @buffer.bytesize
+						# We know that we are not going to reuse the original buffer.
+						# But byteslice will generate a hidden copy. So let's freeze it first:
+						@buffer.freeze
+						
+						buffer << @buffer.byteslice(0, remaining_length)
+						@buffer = @buffer.byteslice(remaining_length, @buffer.bytesize)
+					else
+						buffer << @buffer
+						@buffer = nil
+					end
+				end
+				
+				return nil if buffer.empty? && length && length > 0
+				
+				return buffer
+			end
+			
+			def eof?
+				@finished and @buffer.nil?
+			end
+			
+			# gets must be called without arguments and return a string, or nil on EOF.
+			# @return [String, nil] The next chunk from the body.
+			def gets
+				if @buffer.nil?
+					return read_next
+				else
+					buffer = @buffer
+					@buffer = nil
+					return buffer
+				end
+			end
+			
+			# close must never be called on the input stream. huh?
+			def close
+				@body&.close
+			end
+			
+			private
+			
+			def read_next
+				return nil if @finished
+				
+				if chunk = @body.read
+					return chunk
+				else
+					@finished = true
+					return nil
+				end
+			end
+		end
+	end
+end