RubyGems - mongrel2 - Versions diffs - 0.48.0 → 0.49.0 - Mend

mongrel2 0.48.0 → 0.49.0

Files changed (33) hide show

checksums.yaml +4 -4
checksums.yaml.gz.sig +0 -0
data.tar.gz.sig +0 -0
data/ChangeLog +10 -2
data/History.rdoc +7 -0
data/Manifest.txt +0 -16
data/README.rdoc +0 -4
data/Rakefile +7 -7
data/lib/mongrel2.rb +3 -28
data/lib/mongrel2/connection.rb +9 -11
data/lib/mongrel2/control.rb +6 -7
data/lib/mongrel2/handler.rb +50 -18
data/spec/mongrel2/connection_spec.rb +28 -50
data/spec/mongrel2/control_spec.rb +49 -48
data/spec/mongrel2/handler_spec.rb +52 -31
metadata +54 -66
metadata.gz.sig +4 -3
data/data/mongrel2/bootstrap.html +0 -33
data/data/mongrel2/config.rb.in +0 -71
data/data/mongrel2/css/master.css +0 -77
data/data/mongrel2/index.html.in +0 -51
data/data/mongrel2/js/websock-test.js +0 -108
data/data/mongrel2/websock-test.html +0 -33
data/examples/Procfile +0 -7
data/examples/README.txt +0 -6
data/examples/async-upload.rb +0 -109
data/examples/config.rb +0 -63
data/examples/helloworld-handler.rb +0 -33
data/examples/request-dumper.rb +0 -49
data/examples/request-dumper.tmpl +0 -78
data/examples/run +0 -22
data/examples/sendfile.rb +0 -39
data/examples/ws-echo.rb +0 -263

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-require 'pathname'
-require 'tmpdir'
-# The Mongrel config used by the examples. Load it with:
-#
-#   m2sh.rb -c examples.sqlite load examples/config.rb
-#
-examples_dir = Pathname( __FILE__ ).dirname
-basedir = examples_dir.parent
-upload_dir = Pathname( Dir.tmpdir )
-# samples server
-s = server 'examples' do
-	name         'Examples'
-	default_host 'localhost'
-	access_log   '/logs/access.log'
-	error_log    '/logs/error.log'
-	chroot       basedir
-	pid_file     '/var/run/mongrel2.pid'
-	bind_addr    '0.0.0.0'
-	port         8113
-	xrequest     '/usr/local/lib/mongrel2/filters/sendfile.so'
-	# your main host
-	host 'localhost' do
-		route '/', directory( "#{basedir}/data/mongrel2/", 'bootstrap.html', 'text/html' )
-		route '/source', directory( "#{basedir}/examples/", 'README.txt', 'text/plain' )
-		# Handlers
-		dumper = handler( 'tcp://127.0.0.1:9997', 'request-dumper', protocol: 'tnetstring' )
-		route '/hello', handler( 'tcp://127.0.0.1:9999',  'helloworld-handler' )
-		route '/async-upload', handler( 'tcp://127.0.0.1:9950',  'async-upload' )
-		route '/sendfile', handler( 'tcp://127.0.0.1:9895', 'sendfile-quine' )
-		route '/ws', handler( 'tcp://127.0.0.1:9995', 'ws-echo' )
-		route '/dump', dumper
-		route '@js', dumper
-		route '<xml', dumper
-	end
-end
-setting 'zeromq.threads', 1
-setting 'limits.content_length', 4096
-setting 'control_port', 'ipc://var/run/control'
-setting 'upload.temp_store', upload_dir + 'mongrel2.upload.XXXXXX'
-mkdir_p 'var/run'
-mkdir_p 'var/mongrel2'
-mkdir_p 'logs'
-mkdir_p '/tmp/mongrel2-uploads'
-puts "Will chroot to: #{s.chroot}"
-puts "Upload dir is: #{upload_dir}"

data/examples/helloworld-handler.rb DELETED

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-require 'loggability'
-require 'mongrel2/config'
-require 'mongrel2/handler'
-# A dumb, dead-simple example that just returns a plaintext 'Hello' document.
-class HelloWorldHandler < Mongrel2::Handler
-	### The main method to override -- accepts requests and returns responses.
-	def handle( request )
-		response = request.response
-		response.status = 200
-		response.headers.content_type = 'text/plain'
-		response.puts "Hello, world, it's #{Time.now}!"
-		return response
-	end
-end # class HelloWorldHandler
-configdb = ARGV.shift || 'examples.sqlite'
-# Log to a file instead of STDERR for a bit more speed.
-# Loggability.output_to( 'hello-world.log' )
-Loggability.level = :debug
-# Point to the config database, which will cause the handler to use
-# its ID to look up its own socket info.
-Mongrel2::Config.configure( configdb: configdb )
-HelloWorldHandler.run( 'helloworld-handler' )

data/examples/request-dumper.rb DELETED

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-require 'pathname'
-require 'loggability'
-require 'mongrel2/config'
-require 'mongrel2/handler'
-require 'inversion'
-# A handler that just dumps the request it gets from Mongrel2
-class RequestDumper < Mongrel2::Handler
-	TEMPLATE_DIR = Pathname( __FILE__ ).dirname
-	Inversion::Template.configure( :template_paths => [TEMPLATE_DIR] )
-	### Pre-load the template before running.
-	def initialize( * )
-		super
-		@template = Inversion::Template.load( 'request-dumper.tmpl' )
-		$SAFE = 1
-	end
-	### Handle a request
-	def handle( request )
-		template = @template.dup
-		response = request.response
-		template.request = request
-		template.title = "Ruby-Mongrel2 Request Dumper"
-		template.safelevel = $SAFE
-		response.status = 200
-		response.headers.content_type = 'text/html'
-		response.puts( template )
-		response
-	end
-end # class RequestDumper
-Loggability.level = :debug
-Loggability[ Inversion ].level = :info
-# Point to the config database, which will cause the handler to use
-# its ID to look up its own socket info.
-Mongrel2::Config.configure( :configdb => 'examples.sqlite' )
-RequestDumper.run( 'request-dumper' )

data/examples/request-dumper.tmpl DELETED

@@ -1,78 +0,0 @@
-<!doctype html>
-<head>
-  <meta charset="utf-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-  <title><?attr title ?></title>
-  <meta name="description" content="Ruby-Mongrel2 request introspection handler">
-  <meta name="author" content="Michael Granger">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-	<link rel="stylesheet" href="/css/master.css" type="text/css" media="screen"
-		title="no title" charset="utf-8" />
-</head>
-<body>
-  <header>
-	<h1>Request Dump (0x<?call "%0x" % request.object_id ?>)</h1>
-  </header>
-  <section id="dump">
-		<table>
-			<tr>
-				<th>Sender ID</th>
-				<td><?escape request.sender_id ?></td>
-			</tr>
-			<tr>
-				<th>Connection ID</th>
-				<td><?escape request.conn_id.to_s ?></td>
-			</tr>
-			<tr>
-				<th>$SAFE</th>
-				<td><?attr safelevel ?></td>
-			</tr>
-		</table>
-		<section id="headers">
-			<header>
-				<h1>Headers</h1>
-			</header>
-			<table>
-				<?for name, val in request.headers.each_header.each ?>
-				<tr>
-					<th><?attr name ?></th>
-					<td><?attr val ?></td>
-				</tr>
-				<?end for ?>
-			</table>
-		</section>
-		<section id="body">
-			<header>
-				<h1>Body</h1>
-			</header>
-			<p><code><?escape request.body.inspect ?></code>
-				 (<?call "%0.2fKb" % request.body.size ?>, <?call request.body.external_encoding.name ?>)</p>
-		</section>
-		<section id="inspect">
-			<header>
-				<h1>Inspected Request</h1>
-				<pre>
-<?pp request ?>
-				</pre>
-			</header>
-		</section>
-  </section>
-  <footer>
-	<p><tt>$Id: request-dumper.tmpl,v dae4f2b16ef7 2012/06/20 17:48:00 ged $</tt></p>
-  </footer>
-</body>
-</html>

data/examples/run DELETED

@@ -1,22 +0,0 @@
-#!/bin/sh
-if [ "$(type foreman 2>/dev/null)" == "" ]; then
-	echo "You need Foreman installed to start the examples (gem install foreman)"
-	exit 1
-fi
-examplesdir=$(dirname $0)
-echo "Creating/updating the config database..."
-/usr/bin/env ruby -rubygems -I${examplesdir}/../lib $examplesdir/../bin/m2sh.rb \
-	-c ${examplesdir}/examples.sqlite load $examplesdir/config.rb
-if [ $? != 0 ]; then
-	echo "Oops, problems installing the config DB. Aborting."
-	exit 1
-fi
-echo "Okay, now point a browser to http://localhost:8113/."
-cd $examplesdir
-foreman start

data/examples/sendfile.rb DELETED

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-require 'pathname'
-require 'loggability'
-require 'mongrel2/config'
-require 'mongrel2/handler'
-# A handler that sends itself in a 'sendfile' extended response.
-class SendfileQuine < Mongrel2::Handler
-	### Get the fully-qualified path to the handler on startup
-	def initialize( * )
-		super
-		@path = Pathname( __FILE__ ).expand_path
-		@size = @path.size
-	end
-	### Handle a request
-	def handle( request )
-		response = request.response
-		response.headers.content_type = 'text/plain'
-		response.headers.content_length = @size
-		response.extend_reply_with( :sendfile )
-		response.extended_reply_data << @path.to_s
-		response
-	end
-end # class RequestDumper
-Loggability.level = :debug
-# Point to the config database, which will cause the handler to use
-# its ID to look up its own socket info.
-Mongrel2::Config.configure( :configdb => 'examples.sqlite' )
-SendfileQuine.run( 'sendfile-quine' )

data/examples/ws-echo.rb DELETED

@@ -1,263 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-require 'loggability'
-require 'pathname'
-require 'mongrel2/config'
-require 'mongrel2/handler'
-# An example of a WebSocket (RFC6455) Mongrel2 application that echoes back whatever
-# (non-control) frames you send it. It will also ping all of its clients and disconnect
-# ones that don't reply within a given period.
-class WebSocketEchoServer < Mongrel2::Handler
-	include Mongrel2::WebSocket::Constants
-	# Number of seconds to wait between heartbeat PING frames
-	HEARTBEAT_RATE = 5.0
-	# Number of seconds to wait for a data frame or a PONG before considering
-	# a socket idle
-	SOCKET_IDLE_TIMEOUT = 15.0
-	# Add an instance variable to keep track of connections, and one for the
-	# heartbeat thread.
-	def initialize( * )
-		super
-		@connections = {}
-		@heartbeat = nil
-	end
-	######
-	public
-	######
-	# A Hash of last seen times keyed by [sender ID, connection ID] tuple
-	attr_reader :connections
-	# The Thread that sends PING frames to connected sockets and cull any
-	# that don't reply within SOCKET_IDLE_TIMEOUT seconds
-	attr_reader :heartbeat
-	# Called by Mongrel2::Handler when it starts accepting requests. Overridden
-	# to start up the heartbeat thread.
-	def start_accepting_requests
-		self.start_heartbeat
-		super
-	end
-	# Called by Mongrel2::Handler when the server is restarted. Overridden to
-	# restart the heartbeat thread.
-	def restart
-		self.stop_heartbeat
-		super
-		self.start_heartbeat
-	end
-	# Called by Mongrel2::Handler when the server is shut down. Overridden to
-	# stop the heartbeat thread.
-	def shutdown
-		self.stop_heartbeat
-		super
-	end
-	# Mongrel2 will send a disconnect notice when a client's connection closes;
-	# delete the connection when it does.
-	def handle_disconnect( request )
-		self.log.info "Client %d: disconnect." % [ request.conn_id ]
-		self.connections.delete( [request.sender_id, request.conn_id] )
-		return nil
-	end
-	# Non-websocket (e.g., plain HTTP) requests would ordinarily just get
-	# a 204 NO CONTENT response, but we tell Mongrel2 to just drop such connections
-	# immediately.
-	def handle( request )
-		self.log.info "Regular HTTP request (%s): closing channel." % [ request ]
-		self.conn.reply_close( request )
-		return nil
-	end
-	# Handle the initial handshake. Assumes no sub-protocols or protocol version
-	# checks are necessary.
-	def handle_websocket_handshake( handshake )
-		self.log.info "Handshake from %s" % [ handshake.remote_ip ]
-		response = handshake.response( handshake.protocols.first )
-		@connections[ [handshake.sender_id, handshake.conn_id] ] = Time.now
-		return response
-	end
-	# This is the main handler for WebSocket requests. Each frame comes in as a
-	# Mongrel::WebSocket::Frame object, and then is dispatched according to what
-	# opcode it has.
-	def handle_websocket( frame )
-		# Log each frame
-		self.log.info "%s/%d: %s%s [%s]: %p" % [
-			frame.sender_id,
-			frame.conn_id,
-			frame.opcode.to_s.upcase,
-			frame.fin? ? '' : '(cont)',
-			frame.headers.x_forwarded_for,
-			frame.payload.read( 20 ),
-		]
-		frame.payload.rewind
-		# If a client sends an invalid frame, close their connection, but politely.
-		if !frame.valid?
-			self.log.error "  invalid frame from client: %s" % [ frame.errors.join(';') ]
-			res = frame.response( :close )
-			res.set_status( CLOSE_PROTOCOL_ERROR )
-			return res
-		end
-		# Update the 'last-seen' time unless the connection is closing
-		unless frame.opcode == :close
-			@connections[ [frame.sender_id, frame.conn_id] ] = Time.now
-		end
-		# Use the opcode to decide what method to call
-		self.log.debug "Handling a %s frame." % [ frame.opcode ]
-		handler = self.method( "handle_%s_frame" % [frame.opcode] )
-		return handler.call( frame )
-	end
-	# Handle TEXT, BINARY, and CONTINUATION frames by replying with an echo of the
-	# same data. Fragmented frames get echoed back as-is without any reassembly.
-	def handle_text_frame( frame )
-		self.log.info "Echoing data frame: %p" % [ frame ]
-		# Make the response frame
-		response = frame.response
-		response.fin = frame.fin?
-		IO.copy_stream( frame.payload, response.payload )
-		return response
-	end
-	alias_method :handle_binary_frame, :handle_text_frame
-	alias_method :handle_continuation_frame, :handle_text_frame
-	# Handle close frames
-	def handle_close_frame( frame )
-		# There will still be a connection slot if this close originated with
-		# the client. In that case, reply with the ACK CLOSE frame
-		self.conn.reply( frame.response(:close) ) if
-			self.connections.delete( [frame.sender_id, frame.conn_id] )
-		self.conn.reply_close( frame )
-		return nil
-	end
-	# Handle a PING frame; the response is a PONG with the same payload.
-	def handle_ping_frame( frame )
-		return frame.response
-	end
-	# Handle a PONG frame; nothing really to do
-	def handle_pong_frame( frame )
-		return nil
-	end
-	# Start a thread that will periodically ping connected sockets and remove any
-	# connections that don't reply
-	def start_heartbeat
-		self.log.info "Starting heartbeat thread."
-		@heartbeat = Thread.new do
-			Thread.current.abort_on_exception = true
-			self.log.debug "  Heartbeat thread started: %p" % [ Thread.current ]
-			# Use a thread-local variable to signal the thread to shut down
-			Thread.current[ :shutdown ] = false
-			until Thread.current[ :shutdown ]
-				# If there are active connections, remove any that have
-				# timed out and ping the rest
-				unless self.connections.empty?
-					self.cull_idle_sockets
-					self.ping_all_sockets
-				end
-				self.log.debug "    heartbeat thread sleeping"
-				sleep( HEARTBEAT_RATE )
-				self.log.debug "    heartbeat thread waking up"
-			end
-			self.log.info "Hearbeat thread exiting."
-		end
-	end
-	# Tell the heartbeat thread to exit.
-	def stop_heartbeat
-		@heartbeat[ :shutdown ] = true
-		@heartbeat.run.join if @heartbeat.alive?
-	end
-	# Disconnect any sockets that haven't sent any frames for at least
-	# SOCKET_IDLE_TIMEOUT seconds.
-	def cull_idle_sockets
-		self.log.debug "Culling idle sockets."
-		earliest = Time.now - SOCKET_IDLE_TIMEOUT
-		self.connections.each do |(sender_id, conn_id), lastframe|
-			next unless earliest > lastframe
-			# Make a CLOSE frame
-			frame = Mongrel2::WebSocket::Frame.new( sender_id, conn_id, '', {}, '' )
-			frame.opcode = :close
-			frame.set_status( CLOSE_EXCEPTION )
-			# Use the connection directly so we can send a frame and close the
-			# connection
-			self.conn.reply( frame )
-			self.conn.send_close( sender_id, conn_id )
-		end
-	end
-	# Send a PING frame to all connected sockets.
-	def ping_all_sockets
-		self.log.debug "Pinging all connected sockets."
-		self.connections.each do |(sender_id, conn_id), hash|
-			frame = Mongrel2::WebSocket::Frame.new( sender_id, conn_id, '', {}, 'heartbeat' )
-			frame.opcode = :ping
-			frame.fin = true
-			self.log.debug "  %s/%d: PING" % [ sender_id, conn_id ]
-			self.conn.reply( frame )
-		end
-		self.log.debug "  done with pings."
-	end
-end # class RequestDumper
-Loggability.level = $DEBUG||$VERBOSE ? :debug : :info
-Loggability.format_as( :color ) if $stdin.tty?
-# Point to the config database, which will cause the handler to use
-# its ID to look up its own socket info.
-Mongrel2::Config.configure( :configdb => 'examples.sqlite' )
-WebSocketEchoServer.run( 'ws-echo' )