falcon 0.36.4 → 0.37.1

data/examples/beer/falcon.rb

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

data/examples/benchmark/config.ru

@@ -1,39 +0,0 @@
-#!/usr/bin/env falcon --verbose serve -c
-# frozen_string_literal: true
-
-class Benchmark
-	def initialize(app)
-		@app = app
-	end
-	
-	PATH_INFO = 'PATH_INFO'.freeze
-	
-	SMALL = [200, {}, ["Hello World\n" * 10] * 10].freeze
-	
-	def small(env)
-		SMALL
-	end
-	
-	BIG = [200, {}, ["Hello World\n" * 1000] * 1000].freeze
-	
-	def big(env)
-		BIG
-	end
-	
-	def call(env)
-		_, name, *path = env[PATH_INFO].split("/")
-		
-		method = name&.to_sym
-		
-		if method and self.respond_to?(method)
-			self.send(method, env)
-		else
-			@app.call(env)
-		end
-	end
-end
-
-use Benchmark
-
-run lambda {|env| [200, {}, ["Hello World"]]}
-

data/examples/benchmark/falcon.rb

@@ -1,6 +0,0 @@
-#!/usr/bin/env -S ./bin/falcon virtual
-# frozen_string_literal: true
-
-load :rack, :self_signed_tls, :supervisor
-
-rack 'benchmark.local', :self_signed_tls

data/examples/csv/config.ru

@@ -1,31 +0,0 @@
-#!/usr/bin/env falcon --verbose serve -c
-# frozen_string_literal: true
-
-class MyApp
-	def initialize(app)
-		@app = app
-		
-		@words = File.readlines('/usr/share/dict/words', chomp: true).each_slice(3).to_a
-	end
-	
-	def call(env)
-		body = Async::HTTP::Body::Writable.new(queue: Async::LimitedQueue.new(8))
-		
-		Async do |task|
-			@words.each do |words|
-				Async.logger.debug("Sending #{words.inspect}")
-				body.write(words.join(",") + "\n")
-				task.sleep(1)
-			end
-		ensure
-			body.close($!)
-		end
-		
-		return [200, [], body]
-	end
-end
-
-# Build the middleware stack:
-use MyApp
-
-run lambda {|env| [404, {}, []]}

data/examples/google/falcon.rb

@@ -1,14 +0,0 @@
-#!/usr/bin/env falcon-host
-# frozen_string_literal: true
-
-load :proxy, :self_signed_tls, :supervisor
-
-supervisor
-
-proxy "google.localhost", :self_signed_tls do
-	url 'https://www.google.com'
-end
-
-proxy "codeotaku.localhost", :self_signed_tls do
-	url 'https://www.codeotaku.com'
-end

data/examples/hello/config.ru

@@ -1,22 +0,0 @@
-#!/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)
-		
-		Async(logger: logger) do
-			@app.call(env)
-		end.wait
-	end
-end
-
-# use RequestLogger
-
-run lambda {|env| [200, {'cache-control' => 'max-age=10, public'}, ["Hello World"]]}

data/examples/hello/falcon.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env falcon-host
-# frozen_string_literal: true
-
-load :rack, :self_signed_tls, :supervisor
-
-supervisor
-
-rack 'hello.localhost', :self_signed_tls do
-	# scheme 'http'
-	# protocol {Async::HTTP::Protocol::HTTP1}
-	# 
-	# endpoint do
-	# 	Async::HTTP::Endpoint.for(scheme, "localhost", port: 9292, protocol: protocol)
-	# end
-	
-	append preload "preload.rb"
-	
-	# Process will connect to supervisor to report statistics periodically, otherwise it would be killed.
-	# report :supervisor
-end
-
-# service 'jobs' do
-# 	shell ['rake', 'background:jobs:process']
-# end

data/examples/hello/preload.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-if GC.respond_to?(:compact)
-	Async.logger.warn(self, "Compacting the mainframe...")
-	GC.compact
-	Async.logger.warn(self, "Compacting done...")
-end

data/examples/internet/config.ru

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'async'
-require 'async/http/internet'
-
-# Experimental.
-require 'kernel/sync'
-
-class Search
-	def initialize(app)
-		@internet = Async::HTTP::Internet.new
-		
-		@app = app
-	end
-	
-	# This method uses the `Async` method to create a reactor if required, and then executes the contained code without waiting for the result. So even if the search query takes a long time (e.g. 100ms), it won't hold up the request processing.
-	def async(close: !Async::Task.current?)
-		Async do
-			response = @internet.get("https://google.com/search?q=async+ruby")
-			
-			puts response.inspect
-		ensure
-			response&.finish
-		end
-	end
-	
-	# This method uses the experimental `Sync` method to create a reactor if required. If the code is already running in a reactor, it runs synchronously, otherwise it's effectively the same as `Async` and a blocking operation. This allow you to write efficient non-blocking code that works in both traditional web application servers, but gains additional scalability in `Async`-aware servers like Falcon.
-	# You can achieve a similar result by calling `Async{}.wait`, but this is less efficient as it will allocate a sub-task even thought it's not needed.
-	def sync(close: !Async::Task.current?)
-		Sync do
-			response = @internet.get("https://google.com/search?q=async+ruby")
-			
-			puts response.inspect
-		ensure
-			response&.finish
-		end
-	end
-	
-	# The only point of this is to invoke one of the above two methods.
-	def call(env)
-		case env['PATH_INFO']
-		when '/sync'
-			self.sync
-		when '/async'
-			self.async
-		end
-		
-		return @app.call(env)
-	end
-end
-
-use Search
-
-run lambda{|env| [404, [], []]}

data/examples/memory/allocations.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class Allocations
-	def initialize(app)
-		@app = app
-	end
-	
-	def allocations
-		counts = Hash.new{|h,k| h[k] = 0}
-		
-		ObjectSpace.each_object do |object|
-			counts[object.class] += 1
-		end
-		
-		return counts
-	end
-	
-	def print_allocations(minimum = 100)
-		buffer = StringIO.new
-		
-		total = allocations.values.sum
-		
-		allocations.select{|k,v| v >= minimum}.sort_by{|k,v| -v}.each do |key, value|
-			buffer.puts "#{key}: #{value} allocations"
-		end
-		
-		buffer.puts "** Total: #{total} allocations."
-		
-		return buffer.string
-	end
-	
-	def call(env)
-		if env["PATH_INFO"] == "/allocations"
-			return [200, [], [print_allocations]]
-		else
-			return @app.call(env)
-		end
-	end
-end

data/examples/memory/config.ru

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'allocations'
-
-use Allocations
-
-run lambda{|env| [404, [], []]}
-
-# % curl --insecure https://localhost:9292/allocations
-# String: 32179 allocations
-# Array: 10228 allocations
-# Hash: 1299 allocations
-# Class: 1118 allocations
-# ** Total: 50162 allocations.

data/examples/push/client.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'async'
-require 'async/http/endpoint'
-require 'async/http/client'
-
-Async do
-	endpoint = Async::HTTP::Endpoint.parse("https://localhost:9292")
-	client = Async::HTTP::Client.new(endpoint, Async::HTTP::Protocol::HTTP2::WithPush)
-	
-	response = client.get("/index.html")
-	
-	puts response.status
-	puts response.read
-	puts
-	
-	while promise = response.promises.dequeue
-		promise.wait
-		
-		puts "** Promise: #{promise.request.path} **"
-		puts promise.read
-		puts
-	end
-ensure
-	client.close
-end
-
-puts "Done"

data/examples/push/config.ru

@@ -1,28 +0,0 @@
-#!/usr/bin/env falcon --verbose serve --concurrency 1 --config
-# frozen_string_literal: true
-
-class EarlyHints
-	def initialize(app)
-		@app = app
-	end
-	
-	def call(env)
-		path = env['PATH_INFO']
-		early_hints = early_hints = env['rack.early_hints']
-		
-		Async.logger.debug("path: #{path} #{early_hints}")
-		
-		if path == "/index.html" and early_hints
-			early_hints.push("/style.css")
-			early_hints.push("/script.js")
-		end
-		
-		@app.call(env)
-	end
-end
-
-use EarlyHints
-
-use Rack::Static, :urls => [""], :root => __dir__, :index => 'index.html'
-
-run lambda{|env| [404, [], ["Not Found"]]}

data/examples/push/index.html

@@ -1,14 +0,0 @@
-<!doctype HTML>
-<html>
-	<head>
-		<title>Hello World</title>
-		
-		<link rel="stylesheet" href="/style.css" />
-		<script type="text/javascript" src="script.js"></script>
-	</head>
-	<body>
-		<h1>Early Hints</h1>
-		
-		<p>Check the developer tools to see if early hints worked!</p>
-	</body>
-</html>

data/examples/push/script.js

@@ -1,2 +0,0 @@
-
-console.log("Hello World")

data/examples/push/style.css

@@ -1,4 +0,0 @@
-
-html {
-	font-family: Helvetica;
-}

data/examples/redis/Gemfile

@@ -1,9 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

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

data/examples/sequel/config.ru

@@ -1,8 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-#!/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