shot 0.0.2 → 1.0.0

data/README.md

@@ -0,0 +1,33 @@
+Introduction
+------------
+
+The Shot Core is responsible for implementing the base `Application` class, which processes incoming web socket
+connections, turning them into instances of `ApplicationInstance`. The `Application` class also is capable of
+being extended through [**Loaders**](https://github.com/shot-framework/shot-core/wiki/Loaders) and 
+[**Routers**](https://github.com/shot-framework/shot-core/wiki/Routers).
+
+# Installation
+
+```bash
+gem install shot
+```
+
+# Usage Example
+
+```ruby
+require 'shot'
+
+app = Application.new
+
+app.run do
+    app.on 'load' do |instance|
+        instance.emit 'loaded' 
+    end
+end
+
+app.start
+```
+
+# License
+
+Licensed under the MIT License. For full licensing information, please see LICENSE.md.

data/lib/shot/application.rb

@@ -0,0 +1,100 @@
+# Application
+#
+# Main application instance of a Shot application. Inherits from EventdServer and implements various
+# "routers", which take care of handling special Shot emissions, such as controller calling, etc.
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+require 'eventd'
+
+require_relative './application_instance'
+
+class Application < EventdServer
+	# Array of routers
+	attr_accessor :routers
+
+	# Array of loaders
+	attr_accessor :loaders
+
+	# Active connected clients
+	attr_accessor :clients
+
+	# Temporary data for storage of state-based information
+	attr_accessor :data
+
+	# Initialize the Application and EventdServer. Specifies a default configuration which
+	# allows the EventdServer to bind on http://127.0.0.1:8080
+
+	def initialize(options = { :host => '127.0.0.1', :port => 8080 })
+		super(options)
+		@routers = []
+		@loaders = []
+		@clients = []
+		@data = {}
+		setup_handlers
+	end
+
+	# Add a router to the list of custom routers the application supports.
+	#
+	# Note:: Existing clients will not be handled by the new router.
+	#
+	# ==Attributes
+	#
+	# * +router+ - A class which inherits from Router
+
+	def add_router(router)
+		@routers.push router unless @routers.include? router
+	end
+
+	# Add a loader to the list of custom loaders the application supports.
+	#
+	# == Attributes
+	#
+	# * +loader+ - A class which inherits from Loader
+
+	def add_loader(loader)
+		unless @loaders.include? loader
+			@loaders.push loader
+
+			@clients.each do |client|
+				client.add_loader loader
+			end
+		end
+	end
+
+	# Gets a value from the state-based store
+
+	def get(key)
+		@data[key]
+	end
+
+	# Sets a value to the state-based store
+
+	def set(key, value)
+		@data[key] = value
+	end
+
+	private
+
+	def setup_handlers
+		self.on 'connection' do |client|
+			client.on 'connect' do
+				application_instance = ApplicationInstance.from_eventd_client client, self
+
+				@clients.push application_instance
+
+				@loaders.each do |loader|
+					application_instance.add_loader loader
+				end
+
+				@routers.each do |router|
+					router.new(application_instance)
+				end
+
+				self.emit 'load', application_instance
+			end
+		end
+	end
+end

data/lib/shot/application_instance.rb

@@ -0,0 +1,69 @@
+# ApplicationInstance
+#
+# Inherits from EventdClient and represents a single client in a Shot Application.
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+require 'eventd'
+
+class ApplicationInstance < EventdClient
+	# Array of loaders
+	attr_accessor :loaders
+
+	# Main Application instance
+	attr_accessor :app
+
+	# App Configuration
+	attr_accessor :config
+
+	# Initialize a new ApplicationInstance from an existing EventdClient.
+	#
+	# Note:: This is the preferred way to initialize an ApplicationInstance.
+	#
+	# == Attributes
+	#
+	# * +client+ - EventdClient to copy properties from.
+
+	def self.from_eventd_client(client, app)
+		instance = ApplicationInstance.new
+		instance.app = app
+		instance.socket = client.socket
+		instance.setup_socket
+		instance
+	end
+
+	# Initialize the superclass.
+	#
+	# Note::
+	#   Please use the ApplicationInstance#from_eventd_client method instead, since it is not usually
+	#   a good idea to instantiate an EventdClient without a socket.
+
+	def initialize(socket = nil)
+		super(socket)
+		@config = {}
+		@loaders = {}
+	end
+
+	# Add a loader to the list of custom loaders the application supports.
+	#
+	# == Attributes
+	#
+	# * +loader+ - A class which inherits from Loader
+
+	def add_loader(loader)
+		loader_instance = loader.new self
+		@loaders[loader_instance.type] = loader_instance
+	end
+
+	# Calls out to any available loader and loads the specified file
+
+	def get(type, file)
+		if @loaders[type]
+			@loaders[type].get file
+		else
+			raise LoaderNotFoundException.new "Could not load type #{type}"
+		end
+	end
+end

data/lib/shot/configuration_loader.rb

@@ -0,0 +1,49 @@
+# ConfigurationLoader
+#
+# Loads all configuration files from the 'application/config' directory
+# if it exists. Otherwise, doesn't do anything.
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+require 'yaml'
+
+require_relative './loader'
+
+class ConfigurationLoader < Loader
+	def initialize(client)
+		super(client)
+		@type = 'config'
+		get_all
+	end
+
+	def get(config_file)
+		if config_folder_exists and config_file_exists config_file then
+			@client.config[config_file] = YAML.load File.read "./application/config/#{config_file}.yml"
+		end
+	end
+
+	def get_all
+		if config_folder_exists
+			config_folder = Dir.new './application/config/'
+
+			config_folder.each do |file|
+				if file != '.' and file != '..'
+					file['.yml'] = ''
+					get file
+				end
+			end
+		end
+	end
+
+	private
+
+	def config_folder_exists
+		Dir.exists? './application/config'
+	end
+
+	def config_file_exists(file)
+		File.exists? "./application/config/#{file}.yml"
+	end
+end

data/lib/shot/loader.rb

@@ -0,0 +1,27 @@
+# Loader
+#
+# Interface which defines how a Loader should work, and appropriately raises exceptions for unimplemented
+# requirements of a custom Loader.
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+
+require_relative './loader_exception'
+
+class Loader
+	# Loader type
+	attr_accessor :type
+
+	# Associated EventdClient
+	attr_accessor :client
+
+	def initialize(client)
+		@client = client
+	end
+
+	def get(name)
+		raise LoaderException.new 'Custom Loader #get method has not been overridden.'
+	end
+end

data/lib/shot/loader_exception.rb

@@ -0,0 +1,14 @@
+# LoaderException
+#
+# Custom exception raised when an issue is detected with a custom Loader
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+
+class LoaderException < Exception
+	def initialize(message)
+		super(message)
+	end
+end

data/lib/shot/loader_not_found_exception.rb

@@ -0,0 +1,14 @@
+# LoaderNotFoundException
+#
+# Raised if a loader is not available for a specified type
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+
+class LoaderNotFoundException < Exception
+	def initialize(message)
+		super(message)
+	end
+end

data/lib/shot/router.rb

@@ -0,0 +1,26 @@
+# Router
+#
+# Defines the basic structure of a Router. Routers allow for custom behavior for incoming EventdClients when
+# they connect to the Shot Application. Routers should, at the very least, implement the Router#initialize
+# method, which will be passed an instance of the client the router is handling.
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+
+class Router
+
+	# Associated EventdClient
+	attr_accessor :client
+
+	# Initialize the Router, and save the passed client
+	#
+	# == Attributes
+	#
+	# * +client+ - Instance of EventdClient, which the router should handle
+
+	def initialize(client)
+		@client = client
+	end
+end

data/lib/shot/shot.rb

@@ -0,0 +1,20 @@
+# What is this item?
+#
+# What does this item do?
+#
+# Shot Framework - Copyright (c) Jesse Aaron Dunlap <me@jessedunlap.me>
+# Licensed under the MIT License. For full licensing information, please
+# see LICENSE.md. http://github.com/JesseDunlap/shot/
+
+
+class Shot
+	# Configure paths for easier load and require access to the lib and application folders
+
+	def self.setup
+		$:.unshift(File.expand_path('lib/', __FILE__.gsub('app.rb', '')))
+		$:.unshift(File.expand_path('application/', __FILE__.gsub('app.rb', '')))
+
+		$LOAD_PATH.unshift(File.expand_path('lib/', __FILE__.gsub('app.rb', '')))
+		$LOAD_PATH.unshift(File.expand_path('application/', __FILE__.gsub('app.rb', '')))
+	end
+end

data/lib/shot.rb

@@ -1,2 +1,7 @@
-require_relative '../lib/shot/shot_server'
-require_relative '../lib/shot/shot_client'
+require_relative './shot/shot'
+require_relative './shot/application'
+require_relative './shot/router'
+require_relative './shot/loader'
+require_relative './shot/loader_exception'
+require_relative './shot/loader_not_found_exception'
+require_relative './shot/configuration_loader'

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: shot
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
-- Jesse Dunlap
+- Jesse A. Dunlap
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-18 00:00:00.000000000 Z
+date: 2013-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventd
@@ -27,18 +27,43 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Shot provides an event based WebSocket client and server for Ruby.
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Shot Core provides a fundamental starting point for all Shot applications
+  by implementing an EventdServer, and a series of extensible systems (Routers & Loaders).
 email: me@jessedunlap.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/shot/application.rb
+- lib/shot/application_instance.rb
+- lib/shot/configuration_loader.rb
+- lib/shot/loader.rb
+- lib/shot/loader_exception.rb
+- lib/shot/loader_not_found_exception.rb
+- lib/shot/router.rb
+- lib/shot/shot.rb
 - lib/shot.rb
-- lib/shot/shot_server.rb
-- lib/shot/shot_client.rb
-- lib/shot/web_socket.rb
-homepage: ''
-licenses: []
+- LICENSE.md
+- README.md
+homepage: http://github.com/shot/
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -60,5 +85,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: An event based WebSocket layer.
+summary: The core of Shot, a real time applciation framework written in Ruby.
 test_files: []

data/lib/shot/shot_client.rb

@@ -1,44 +0,0 @@
-require 'json'
-require 'eventd'
-
-##
-# An enhanced event-based client. Each connection to a MagicSocketServer initializes
-# a new instance of MagicSocketClient for easier interaction.
-class MagicSocketClient < Eventd
-	##
-	# MagicSocketClient constructor
-	def initialize(socket)
-		super()
-		@socket = socket
-
-		@socket.onmessage do |message|
-			begin
-				json        = JSON.parse message
-
-				event       = json['event']
-				parameters  = json['parameters']
-
-				# Passing false as third parameter to prevent this being sent
-				# back over the socket to the client
-				self.emit event, parameters, false
-				self.emit 'any', { :event => event, :parameters => parameters }, false
-			rescue Exception => e
-				$stderr.puts e
-				$stderr.puts e.backtrace
-			end
-		end
-
-		@socket.onclose do |e|
-			self.emit 'disconnect', e
-		end
-	end
-
-	def emit(event_name, parameters, allow_socket = true)
-		if allow_socket
-			json = { :event => event_name, :parameters => parameters }
-			@socket.send json.to_json
-		end
-
-		super(event_name, parameters)
-	end
-end

data/lib/shot/shot_server.rb

@@ -1,59 +0,0 @@
-require 'json'
-require 'eventd'
-require 'em-websocket'
-require_relative 'shot_client'
-
-##
-# Implements an event-based WebSocket server that accepts client connections
-# utilizing the WebSocket protocol. Uses the em-websocket library to create
-# a server, accept connections, and handshake with them.
-#
-# Author::    Jesse A. Dunlap <me@jessedunlap.me>
-# License::   MIT
-
-class ShotServer < Eventd
-	##
-	# MagicSocketServer constructor
-	def initialize(host = '127.0.0.1', port = 8080)
-		super()
-
-		@configuration = {
-				:host => host,
-		    :port => port
-		}
-
-		@clients  = []
-	end
-
-	##
-	# Merges a new configuration object with the existing default configuration.
-	# Configuration is passed into the EM::WebSocket.run method. This method can
-	# be used to set up SSL and other em-websocket configuration.
-	def configure(configuration)
-		@configuration = @configuration.merge configuration
-	end
-
-	##
-	# Calls the specified callback when the server is running, so that you can then
-	# handle connections properly.
-	def run(&callback)
-		@run = callback
-	end
-
-	##
-	# Binds the websocket connection to the configured host and port, and begins
-	# handling incoming connections. NOTE: It is important to call this method
-	# **after** you implement the run method. No code will execute past the point
-	# at which you call listen.
-	def listen
-		EM.run do
-			if @run then @run.call end
-
-			EM::WebSocket.run(@configuration) do |ws|
-				ws.onopen do |handshake|
-					self.emit 'connection', MagicSocketClient.new(ws)
-				end
-			end
-		end
-	end
-end

data/lib/shot/web_socket.rb

@@ -1,588 +0,0 @@
-# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
-# Lincense: New BSD Lincense
-# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
-# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
-# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07
-# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10
-
-require "base64"
-require "socket"
-require "uri"
-require "digest/md5"
-require "digest/sha1"
-require "openssl"
-require "stringio"
-
-
-class WebSocket
-
-	class << self
-
-		attr_accessor(:debug)
-
-	end
-
-	class Error < RuntimeError
-
-	end
-
-	WEB_SOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-	OPCODE_CONTINUATION = 0x00
-	OPCODE_TEXT = 0x01
-	OPCODE_BINARY = 0x02
-	OPCODE_CLOSE = 0x08
-	OPCODE_PING = 0x09
-	OPCODE_PONG = 0x0a
-
-	def initialize(arg, params = {})
-		if params[:server] # server
-
-			@server = params[:server]
-			@socket = arg
-			line = gets()
-			if !line
-				raise(WebSocket::Error, "Client disconnected without sending anything.")
-			end
-			line = line.chomp()
-			if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
-				raise(WebSocket::Error, "Invalid request: #{line}")
-			end
-			@path = $1
-			read_header()
-			if @header["sec-websocket-version"]
-				@web_socket_version = @header["sec-websocket-version"]
-				@key3 = nil
-			elsif @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
-				@web_socket_version = "hixie-76"
-				@key3 = read(8)
-			else
-				@web_socket_version = "hixie-75"
-				@key3 = nil
-			end
-			if !@server.accepted_origin?(self.origin)
-				raise(WebSocket::Error,
-				      ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
-						      "To accept this origin, write e.g. \n" +
-						      "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
-						      "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
-						      [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
-			end
-			@handshaked = false
-
-		else # client
-
-			@web_socket_version = "hixie-76"
-			uri = arg.is_a?(String) ? URI.parse(arg) : arg
-
-			if uri.scheme == "ws"
-				default_port = 80
-			elsif uri.scheme = "wss"
-				default_port = 443
-			else
-				raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
-			end
-
-			@path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
-			host = uri.host + ((!uri.port || uri.port == default_port) ? "" : ":#{uri.port}")
-			origin = params[:origin] || "http://#{uri.host}"
-			key1 = generate_key()
-			key2 = generate_key()
-			key3 = generate_key3()
-
-			socket = TCPSocket.new(uri.host, uri.port || default_port)
-
-			if uri.scheme == "ws"
-				@socket = socket
-			else
-				@socket = ssl_handshake(socket)
-			end
-
-			write(
-					"GET #{@path} HTTP/1.1\r\n" +
-							"Upgrade: WebSocket\r\n" +
-							"Connection: Upgrade\r\n" +
-							"Host: #{host}\r\n" +
-							"Origin: #{origin}\r\n" +
-							"Sec-WebSocket-Key1: #{key1}\r\n" +
-							"Sec-WebSocket-Key2: #{key2}\r\n" +
-							"\r\n" +
-							"#{key3}")
-			flush()
-
-			line = gets().chomp()
-			raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
-			read_header()
-			if (@header["sec-websocket-origin"] || "").downcase() != origin.downcase()
-				raise(WebSocket::Error,
-				      "origin doesn't match: '#{@header["sec-websocket-origin"]}' != '#{origin}'")
-			end
-			reply_digest = read(16)
-			expected_digest = hixie_76_security_digest(key1, key2, key3)
-			if reply_digest != expected_digest
-				raise(WebSocket::Error,
-				      "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
-			end
-			@handshaked = true
-
-		end
-		@received = []
-		@buffer = ""
-		@closing_started = false
-	end
-
-	attr_reader(:server, :header, :path)
-
-	def handshake(status = nil, header = {})
-		if @handshaked
-			raise(WebSocket::Error, "handshake has already been done")
-		end
-		status ||= "101 Switching Protocols"
-		def_header = {}
-		case @web_socket_version
-			when "hixie-75"
-				def_header["WebSocket-Origin"] = self.origin
-				def_header["WebSocket-Location"] = self.location
-				extra_bytes = ""
-			when "hixie-76"
-				def_header["Sec-WebSocket-Origin"] = self.origin
-				def_header["Sec-WebSocket-Location"] = self.location
-				extra_bytes = hixie_76_security_digest(
-						@header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
-			else
-				def_header["Sec-WebSocket-Accept"] = security_digest(@header["sec-websocket-key"])
-				extra_bytes = ""
-		end
-		header = def_header.merge(header)
-		header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
-		# Note that Upgrade and Connection must appear in this order.
-		write(
-				"HTTP/1.1 #{status}\r\n" +
-						"Upgrade: websocket\r\n" +
-						"Connection: Upgrade\r\n" +
-						"#{header_str}\r\n#{extra_bytes}")
-		flush()
-		@handshaked = true
-	end
-
-	def send(data)
-		if !@handshaked
-			raise(WebSocket::Error, "call WebSocket\#handshake first")
-		end
-		case @web_socket_version
-			when "hixie-75", "hixie-76"
-				data = force_encoding(data.dup(), "ASCII-8BIT")
-				write("\x00#{data}\xff")
-				flush()
-			else
-				send_frame(OPCODE_TEXT, data, !@server)
-		end
-	end
-
-	def receive()
-		if !@handshaked
-			raise(WebSocket::Error, "call WebSocket\#handshake first")
-		end
-		case @web_socket_version
-
-			when "hixie-75", "hixie-76"
-				packet = gets("\xff")
-				return nil if !packet
-				if packet =~ /\A\x00(.*)\xff\z/nm
-					return force_encoding($1, "UTF-8")
-				elsif packet == "\xff" && read(1) == "\x00" # closing
-					close(1005, "", :peer)
-					return nil
-				else
-					raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
-				end
-
-			else
-				begin
-					bytes = read(2).unpack("C*")
-					fin = (bytes[0] & 0x80) != 0
-					opcode = bytes[0] & 0x0f
-					mask = (bytes[1] & 0x80) != 0
-					plength = bytes[1] & 0x7f
-					if plength == 126
-						bytes = read(2)
-						plength = bytes.unpack("n")[0]
-					elsif plength == 127
-						bytes = read(8)
-						(high, low) = bytes.unpack("NN")
-						plength = high * (2 ** 32) + low
-					end
-					if @server && !mask
-						# Masking is required.
-						@socket.close()
-						raise(WebSocket::Error, "received unmasked data")
-					end
-					mask_key = mask ? read(4).unpack("C*") : nil
-					payload = read(plength)
-					payload = apply_mask(payload, mask_key) if mask
-					case opcode
-						when OPCODE_TEXT
-							return force_encoding(payload, "UTF-8")
-						when OPCODE_BINARY
-							raise(WebSocket::Error, "received binary data, which is not supported")
-						when OPCODE_CLOSE
-							close(1005, "", :peer)
-							return nil
-						when OPCODE_PING
-							raise(WebSocket::Error, "received ping, which is not supported")
-						when OPCODE_PONG
-						else
-							raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
-					end
-				rescue EOFError
-					return nil
-				end
-
-		end
-	end
-
-	def tcp_socket
-		return @socket
-	end
-
-	def host
-		return @header["host"]
-	end
-
-	def origin
-		case @web_socket_version
-			when "7", "8"
-				name = "sec-websocket-origin"
-			else
-				name = "origin"
-		end
-		if @header[name]
-			return @header[name]
-		else
-			raise(WebSocket::Error, "%s header is missing" % name)
-		end
-	end
-
-	def location
-		return "ws://#{self.host}#{@path}"
-	end
-
-	# Does closing handshake.
-	def close(code = 1005, reason = "", origin = :self)
-		if !@closing_started
-			case @web_socket_version
-				when "hixie-75", "hixie-76"
-					write("\xff\x00")
-				else
-					if code == 1005
-						payload = ""
-					else
-						payload = [code].pack("n") + force_encoding(reason.dup(), "ASCII-8BIT")
-					end
-					send_frame(OPCODE_CLOSE, payload, false)
-			end
-		end
-		@socket.close() if origin == :peer
-		@closing_started = true
-	end
-
-	def close_socket()
-		@socket.close()
-	end
-
-	private
-
-	NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
-
-	def read_header()
-		@header = {}
-		while line = gets()
-			line = line.chomp()
-			break if line.empty?
-			if !(line =~ /\A(\S+): (.*)\z/n)
-				raise(WebSocket::Error, "invalid request: #{line}")
-			end
-			@header[$1] = $2
-			@header[$1.downcase()] = $2
-		end
-		if !@header["upgrade"]
-			raise(WebSocket::Error, "Upgrade header is missing")
-		end
-		if !(@header["upgrade"] =~ /\AWebSocket\z/i)
-			raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
-		end
-		if !@header["connection"]
-			raise(WebSocket::Error, "Connection header is missing")
-		end
-		if @header["connection"].split(/,/).grep(/\A\s*Upgrade\s*\z/i).empty?
-			raise(WebSocket::Error, "invalid Connection: " + @header["connection"])
-		end
-	end
-
-	def send_frame(opcode, payload, mask)
-		payload = force_encoding(payload.dup(), "ASCII-8BIT")
-		# Setting StringIO's encoding to ASCII-8BIT.
-		buffer = StringIO.new(force_encoding("", "ASCII-8BIT"))
-		write_byte(buffer, 0x80 | opcode)
-		masked_byte = mask ? 0x80 : 0x00
-		if payload.bytesize <= 125
-			write_byte(buffer, masked_byte | payload.bytesize)
-		elsif payload.bytesize < 2 ** 16
-			write_byte(buffer, masked_byte | 126)
-			buffer.write([payload.bytesize].pack("n"))
-		else
-			write_byte(buffer, masked_byte | 127)
-			buffer.write([payload.bytesize / (2 ** 32), payload.bytesize % (2 ** 32)].pack("NN"))
-		end
-		if mask
-			mask_key = Array.new(4){ rand(256) }
-			buffer.write(mask_key.pack("C*"))
-			payload = apply_mask(payload, mask_key)
-		end
-		buffer.write(payload)
-		write(buffer.string)
-	end
-
-	def gets(rs = $/)
-		line = @socket.gets(rs)
-		$stderr.printf("recv> %p\n", line) if WebSocket.debug
-		return line
-	end
-
-	def read(num_bytes)
-		str = @socket.read(num_bytes)
-		$stderr.printf("recv> %p\n", str) if WebSocket.debug
-		if str && str.bytesize == num_bytes
-			return str
-		else
-			raise(EOFError)
-		end
-	end
-
-	def write(data)
-		if WebSocket.debug
-			data.scan(/\G(.*?(\n|\z))/n) do
-				$stderr.printf("send> %p\n", $&) if !$&.empty?
-			end
-		end
-		@socket.write(data)
-	end
-
-	def flush()
-		@socket.flush()
-	end
-
-	def write_byte(buffer, byte)
-		buffer.write([byte].pack("C"))
-	end
-
-	def security_digest(key)
-		return Base64.encode64(Digest::SHA1.digest(key + WEB_SOCKET_GUID)).gsub(/\n/, "")
-	end
-
-	def hixie_76_security_digest(key1, key2, key3)
-		bytes1 = websocket_key_to_bytes(key1)
-		bytes2 = websocket_key_to_bytes(key2)
-		return Digest::MD5.digest(bytes1 + bytes2 + key3)
-	end
-
-	def apply_mask(payload, mask_key)
-		orig_bytes = payload.unpack("C*")
-		new_bytes = []
-		orig_bytes.each_with_index() do |b, i|
-			new_bytes.push(b ^ mask_key[i % 4])
-		end
-		return new_bytes.pack("C*")
-	end
-
-	def generate_key()
-		spaces = 1 + rand(12)
-		max = 0xffffffff / spaces
-		number = rand(max + 1)
-		key = (number * spaces).to_s()
-		(1 + rand(12)).times() do
-			char = NOISE_CHARS[rand(NOISE_CHARS.size)]
-			pos = rand(key.size + 1)
-			key[pos...pos] = char
-		end
-		spaces.times() do
-			pos = 1 + rand(key.size - 1)
-			key[pos...pos] = " "
-		end
-		return key
-	end
-
-	def generate_key3()
-		return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
-	end
-
-	def websocket_key_to_bytes(key)
-		num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
-		return [num].pack("N")
-	end
-
-	def force_encoding(str, encoding)
-		if str.respond_to?(:force_encoding)
-			return str.force_encoding(encoding)
-		else
-			return str
-		end
-	end
-
-	def ssl_handshake(socket)
-		ssl_context = OpenSSL::SSL::SSLContext.new()
-		ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
-		ssl_socket.sync_close = true
-		ssl_socket.connect()
-		return ssl_socket
-	end
-
-end
-
-
-class WebSocketServer
-
-	def initialize(params_or_uri, params = nil)
-		if params
-			uri = params_or_uri.is_a?(String) ? URI.parse(params_or_uri) : params_or_uri
-			params[:port] ||= uri.port
-			params[:accepted_domains] ||= [uri.host]
-		else
-			params = params_or_uri
-		end
-		@port = params[:port] || 80
-		@accepted_domains = params[:accepted_domains]
-		if !@accepted_domains
-			raise(ArgumentError, "params[:accepted_domains] is required")
-		end
-		if params[:host]
-			@tcp_server = TCPServer.open(params[:host], @port)
-		else
-			@tcp_server = TCPServer.open(@port)
-		end
-	end
-
-	attr_reader(:tcp_server, :port, :accepted_domains)
-
-	def run(&block)
-		while true
-			Thread.start(accept()) do |s|
-				begin
-					ws = create_web_socket(s)
-					yield(ws) if ws
-				rescue => ex
-					print_backtrace(ex)
-				ensure
-					begin
-						ws.close_socket() if ws
-					rescue
-					end
-				end
-			end
-		end
-	end
-
-	def accept()
-		return @tcp_server.accept()
-	end
-
-	def accepted_origin?(origin)
-		domain = origin_to_domain(origin)
-		return @accepted_domains.any?(){ |d| File.fnmatch(d, domain) }
-	end
-
-	def origin_to_domain(origin)
-		if origin == "null" || origin == "file://"  # local file
-			return "null"
-		else
-			return URI.parse(origin).host
-		end
-	end
-
-	def create_web_socket(socket)
-		ch = socket.getc()
-		if ch == ?<
-			# This is Flash socket policy file request, not an actual Web Socket connection.
-			send_flash_socket_policy_file(socket)
-			return nil
-		else
-			socket.ungetc(ch) if ch
-			return WebSocket.new(socket, :server => self)
-		end
-	end
-
-	private
-
-	def print_backtrace(ex)
-		$stderr.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
-		for s in ex.backtrace[1..-1]
-			$stderr.printf("        %s\n", s)
-		end
-	end
-
-	# Handles Flash socket policy file request sent when web-socket-js is used:
-	# http://github.com/gimite/web-socket-js/tree/master
-	def send_flash_socket_policy_file(socket)
-		socket.puts('<?xml version="1.0"?>')
-		socket.puts('<!DOCTYPE cross-domain-policy SYSTEM ' +
-				            '"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">')
-		socket.puts('<cross-domain-policy>')
-		for domain in @accepted_domains
-			next if domain == "file://"
-			socket.puts("<allow-access-from domain=\"#{domain}\" to-ports=\"#{@port}\"/>")
-		end
-		socket.puts('</cross-domain-policy>')
-		socket.close()
-	end
-
-end
-
-
-if __FILE__ == $0
-	Thread.abort_on_exception = true
-
-	if ARGV[0] == "server" && ARGV.size == 3
-
-		server = WebSocketServer.new(
-				:accepted_domains => [ARGV[1]],
-				:port => ARGV[2].to_i())
-		puts("Server is running at port %d" % server.port)
-		server.run() do |ws|
-			puts("Connection accepted")
-			puts("Path: #{ws.path}, Origin: #{ws.origin}")
-			if ws.path == "/"
-				ws.handshake()
-				while data = ws.receive()
-					printf("Received: %p\n", data)
-					ws.send(data)
-					printf("Sent: %p\n", data)
-				end
-			else
-				ws.handshake("404 Not Found")
-			end
-			puts("Connection closed")
-		end
-
-	elsif ARGV[0] == "client" && ARGV.size == 2
-
-		client = WebSocket.new(ARGV[1])
-		puts("Connected")
-		Thread.new() do
-			while data = client.receive()
-				printf("Received: %p\n", data)
-			end
-		end
-		$stdin.each_line() do |line|
-			data = line.chomp()
-			client.send(data)
-			printf("Sent: %p\n", data)
-		end
-
-	else
-
-		$stderr.puts("Usage:")
-		$stderr.puts("  ruby web_socket.rb server ACCEPTED_DOMAIN PORT")
-		$stderr.puts("  ruby web_socket.rb client ws://HOST:PORT/")
-		exit(1)
-
-	end
-end