async-websocket 0.14.0 → 0.19.0

data/examples/chat/multi-client.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/semaphore'
-require 'async/clock'
-require 'async/io/stream'
-require 'async/http/endpoint'
-require_relative '../../lib/async/websocket/client'
-
-require 'samovar'
-
-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: "https://localhost: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::Endpoint.parse(@options[:connect])
-		# endpoint = endpoint.each.first
-		
-		count = @options[:count]
-		
-		connections = Async::Queue.new
-		
-		Async do |task|
-			task.logger.info!
-			
-			task.async do |subtask|
-				while connection = connections.dequeue
-					subtask.async(connection) do |subtask, connection|
-						while message = connection.read
-							puts "> #{message.inspect}"
-						end
-					ensure
-						connection.close
-					end
-				end
-				
-				GC.start
-			end
-			
-			client = Async::WebSocket::Client.open(endpoint)
-			start_time = Async::Clock.now
-			
-			count.times do |i|
-				connections.enqueue(client.connect(endpoint.path))
-				
-				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
-	end
-end
-
-Command.call

data/examples/mud/client.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/io/stream'
-require 'async/http/endpoint'
-require 'async/websocket/client'
-
-USER = ARGV.pop || "anonymous"
-URL = ARGV.pop || "http://127.0.0.1:7070"
-
-Async do |task|
-	stdin = Async::IO::Stream.new(
-		Async::IO::Generic.new($stdin)
-	)
-	
-	endpoint = Async::HTTP::Endpoint.parse(URL)
-	
-	Async::WebSocket::Client.connect(endpoint) do |connection|
-		task.async do
-			$stdout.write "> "
-			
-			while line = stdin.read_until("\n")
-				connection.write({input: line})
-				connection.flush
-				
-				$stdout.write "> "
-			end
-		end
-		
-		while message = connection.read
-			$stdout.puts message
-		end
-	end
-end

data/examples/mud/config.ru

@@ -1,142 +0,0 @@
-#!/usr/bin/env -S falcon serve --count 1 --bind http://127.0.0.1:7070 -c
-
-require 'async/websocket/adapters/rack'
-
-class Room
-	def initialize(name, description = nil)
-		@name = name
-		@description = description
-		
-		@actions = {}
-		@users = []
-	end
-	
-	attr :name
-	attr :description
-	
-	attr :actions
-	
-	def connect(key, room)
-		@actions[key] = lambda do |user|
-			self.exit(user)
-			room.enter(user)
-		end
-		
-		return room
-	end
-	
-	def broadcast(message)
-		@users.each do |user|
-			user.write(message)
-			user.flush
-		end
-	end
-	
-	def enter(user)
-		user.notify("You have entered the #{@name}.")
-		user.room = self
-		
-		@users << user
-		
-		@users.each do |user|
-			user.notify("#{user.name} entered the room.")
-		end
-	end
-	
-	def exit(user)
-		if @users.delete(user)
-			@users.each do |user|
-				user.notify("#{user.name} left the room.")
-			end
-		end
-	end
-	
-	def as_json
-		{
-			name: @name,
-			description: @description,
-			actions: @actions.keys,
-		}
-	end
-end
-
-module Command
-	def self.split(line)
-		line.scan(/(?:"")|(?:"(.*[^\\])")|(\w+)/).flatten.compact
-	end
-end
-
-class User < Async::WebSocket::Connection
-	def initialize(*)
-		super
-		
-		@name = name
-		@room = nil
-		@inventory = []
-	end
-	
-	attr_accessor :room
-	
-	ANONYMOUS = "Anonymous"
-	
-	def name
-		@name || ANONYMOUS
-	end
-	
-	def handle(message)
-		key, *arguments = Command.split(message[:input])
-		case key
-		when "name"
-			@name = arguments.first
-		when "look"
-			self.write({room: @room.as_json})
-		else
-			if action = @room.actions[key]
-				action.call(self, *arguments)
-			else
-				message[:user]
-				@room.broadcast(message)
-			end
-		end
-	end
-	
-	def notify(text)
-		self.write({notify: text})
-		self.flush
-	end
-	
-	def close
-		if @room
-			@room.exit(self)
-		end
-		
-		super
-	end
-end
-
-class Server
-	def initialize(app)
-		@app = app
-		
-		@entrance = Room.new("Portal", "A vast entrance foyer with a flowing portal.")
-		@entrance.connect("forward", Room.new("Training Room"))
-		@entrance.connect("corridor", Room.new("Shop"))
-	end
-	
-	def call(env)
-		Async::WebSocket::Adapters::Rack.open(env, handler: User) do |user|
-			@entrance.enter(user)
-			
-			while message = user.read
-				user.handle(message)
-			end
-		ensure
-			# Async.logger.error(self, $!) if $!
-			user.close
-		end or @app.call(env)
-	end
-end
-
-use Server
-
-run lambda {|env| [200, {}, []]}

data/examples/rack/client.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/http/endpoint'
-require 'async/websocket/client'
-
-URL = ARGV.pop || "http://127.0.0.1:7070"
-
-Async do |task|
-	endpoint = Async::HTTP::Endpoint.parse(URL)
-	
-	Async::WebSocket::Client.connect(endpoint) do |connection|
-		connection.write ["Hello", "World"]
-		
-		while message = connection.read
-			p message
-		end
-	end
-end

data/examples/rack/config.ru

@@ -1,12 +0,0 @@
-#!/usr/bin/env -S falcon serve --bind http://127.0.0.1:7070 --count 1 -c
-
-require 'async/websocket/adapters/rack'
-
-app = lambda do |env|
-	Async::WebSocket::Adapters::Rack.open(env) do |connection|
-		message = connection.read
-		connection.write message.reverse
-	end
-end
-
-run app

data/examples/utopia/.bowerrc

@@ -1,4 +0,0 @@
-{
-  "directory": "lib/components",
-  "public": "public/_components"
-}

data/examples/utopia/.gitignore

@@ -1,9 +0,0 @@
-# Development specific:
-.rspec_status
-.tags*
-
-# Temporary data should not be added to the repository:
-tmp/
-
-# This file should only ever exist on production, and may contain sensitive information:
-config/environment.yaml

data/examples/utopia/.rspec

@@ -1,4 +0,0 @@
---format documentation
---backtrace
---warnings
---require spec_helper

data/examples/utopia/Gemfile

@@ -1,33 +0,0 @@
-
-source "https://rubygems.org"
-
-gem "utopia", "~> 2.9.3"
-
-gem "rake"
-gem "bundler"
-
-gem 'async-websocket'
-
-gem "rack-freeze", "~> 1.2"
-
-group :development do
-	# For `rake server`:
-	gem "guard-falcon", require: false
-	gem 'guard-rspec', require: false
-	
-	# For `rake console`:
-	gem "pry"
-	gem "rack-test"
-	
-	# For `rspec` testing:
-	gem "rspec"
-	gem "simplecov"
-	
-	# For testing:
-	gem 'async-rspec'
-end
-
-group :production do
-	# Used for passenger-config to restart server after deployment:
-	gem "passenger"
-end

data/examples/utopia/Guardfile

@@ -1,29 +0,0 @@
-
-group :development do
-	guard :falcon, port: 9292 do
-		watch('Gemfile.lock')
-		watch('config.ru')
-		watch(%r{^config|lib|pages/.*})
-		
-		notification :off
-	end
-end
-
-group :test do
-	guard :rspec, cmd: 'rspec' do
-		# Notifications can get a bit tedious:
-		# notification :off
-		
-		# Re-run specs if they are changed:
-		watch(%r{^spec/.+_spec\.rb$})
-		watch('spec/spec_helper.rb') {'spec'}
-		
-		# Run relevent specs if files in `lib/` or `pages/` are changed:
-		watch(%r{^lib/(.+)\.rb$}) {|match| "spec/lib/#{match[1]}_spec.rb" }
-		watch(%r{^pages/(.+)\.(rb|xnode)$}) {|match| "spec/pages/#{match[1]}_spec.rb"}
-		watch(%r{^pages/(.+)controller\.rb$}) {|match| Dir.glob("spec/pages/#{match[1]}*_spec.rb")}
-		
-		# If any files in pages changes, ensure the website still works:
-		watch(%r{^pages/.*}) {'spec/website_spec.rb'}
-	end
-end

data/examples/utopia/README.md

@@ -1,16 +0,0 @@
-# Example WebSocket Chat Server
-
-This is a simple chat client/server implementation with specs.
-
-## Starting Development Server
-
-To start the development server, simply execute
-
-	> rake
-	Generating transient session key for development...
-	20:57:36 - INFO - Starting Falcon HTTP server on localhost:9292
-	20:57:36 - INFO - Guard::RSpec is running
-	20:57:36 - INFO - Guard is now watching at '...'
-	[1] guard(main)>
-
-Then browse http://localhost:9292 (or as specified) to see your new site.

data/examples/utopia/Rakefile

@@ -1,8 +0,0 @@
-
-require 'pathname'
-SITE_ROOT = Pathname.new(__dir__).realpath
-
-# Load all rake tasks:
-import(*Dir.glob('tasks/**/*.rake'))
-
-task :default => :development

data/examples/utopia/config.ru

@@ -1,47 +0,0 @@
-#!/usr/bin/env rackup
-
-require_relative 'config/environment'
-
-require 'rack/freeze'
-
-if RACK_ENV == :production
-	# Handle exceptions in production with a error page and send an email notification:
-	use Utopia::Exceptions::Handler
-	use Utopia::Exceptions::Mailer
-else
-	# We want to propate exceptions up when running tests:
-	use Rack::ShowExceptions unless RACK_ENV == :test
-	
-	# Serve the public directory in a similar way to the web server:
-	use Utopia::Static, root: 'public'
-end
-
-use Rack::Sendfile
-
-use Utopia::ContentLength
-
-use Utopia::Redirection::Rewrite,
-	'/' => '/client/index'
-
-use Utopia::Redirection::DirectoryIndex
-
-use Utopia::Redirection::Errors,
-	404 => '/errors/file-not-found'
-
-use Utopia::Localization,
-	:default_locale => 'en',
-	:locales => ['en', 'de', 'ja', 'zh']
-
-require 'utopia/session'
-use Utopia::Session,
-	:expires_after => 3600 * 24,
-	:secret => ENV['UTOPIA_SESSION_SECRET']
-
-use Utopia::Controller
-
-use Utopia::Static
-
-# Serve dynamic content
-use Utopia::Content
-
-run lambda { |env| [404, {}, []] }