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

mongrel2 0.48.0 → 0.49.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

data/examples/config.rb DELETED

@@ -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' )