swiftiply 0.5.1 → 0.6.0

data/ext/fastfilereader/mapper.h

@@ -0,0 +1,59 @@
+/*****************************************************************************
+
+$Id: mapper.h 4529 2007-07-04 11:32:22Z francis $
+
+File:     mapper.h
+Date:     02Jul07
+
+Copyright (C) 2007 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat10
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+
+#ifndef __Mapper__H_
+#define __Mapper__H_
+
+
+/**************
+class Mapper_t
+**************/
+
+class Mapper_t
+{
+	public:
+		Mapper_t (const string&);
+		virtual ~Mapper_t();
+
+		const char *GetChunk (unsigned);
+		void Close();
+		size_t GetFileSize() {return FileSize;}
+
+	private:
+		size_t FileSize;
+
+	#ifdef OS_UNIX
+	private:
+		int Fd;
+		const char *MapPoint;
+	#endif // OS_UNIX
+
+	#ifdef OS_WIN32
+	private:
+		HANDLE hFile;
+		HANDLE hMapping;
+		const char *MapPoint;
+	#endif // OS_WIN32
+
+};
+
+
+#endif // __Mapper__H_
+

data/ext/fastfilereader/rubymain.cpp

@@ -0,0 +1,127 @@
+/*****************************************************************************
+
+$Id: rubymain.cpp 4529 2007-07-04 11:32:22Z francis $
+
+File:     rubymain.cpp
+Date:     02Jul07
+
+Copyright (C) 2007 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat10
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+
+
+#include <iostream>
+#include <stdexcept>
+using namespace std;
+
+#include <ruby.h>
+#include "mapper.h"
+
+static VALUE EmModule;
+static VALUE FastFileReader;
+static VALUE Mapper;
+
+
+
+/*********
+mapper_dt
+*********/
+
+static void mapper_dt (void *ptr)
+{
+	if (ptr)
+		delete (Mapper_t*) ptr;
+}
+
+/**********
+mapper_new
+**********/
+
+static VALUE mapper_new (VALUE self, VALUE filename)
+{
+	Mapper_t *m = new Mapper_t (StringValuePtr (filename));
+	if (!m)
+		rb_raise (rb_eException, "No Mapper Object");
+	VALUE v = Data_Wrap_Struct (Mapper, 0, mapper_dt, (void*)m);
+	return v;
+}
+
+
+/****************
+mapper_get_chunk
+****************/
+
+static VALUE mapper_get_chunk (VALUE self, VALUE start, VALUE length)
+{
+	Mapper_t *m = NULL;
+	Data_Get_Struct (self, Mapper_t, m);
+	if (!m)
+		rb_raise (rb_eException, "No Mapper Object");
+
+	// TODO, what if some moron sends us a negative start value?
+	unsigned _start = NUM2INT (start);
+	unsigned _length = NUM2INT (length);
+	if ((_start + _length) > m->GetFileSize())
+		rb_raise (rb_eException, "Mapper Range Error");
+
+	const char *chunk = m->GetChunk (_start);
+	if (!chunk)
+		rb_raise (rb_eException, "No Mapper Chunk");
+	return rb_str_new (chunk, _length);
+}
+
+/************
+mapper_close
+************/
+
+static VALUE mapper_close (VALUE self)
+{
+	Mapper_t *m = NULL;
+	Data_Get_Struct (self, Mapper_t, m);
+	if (!m)
+		rb_raise (rb_eException, "No Mapper Object");
+	m->Close();
+	return Qnil;
+}
+
+/***********
+mapper_size
+***********/
+
+static VALUE mapper_size (VALUE self)
+{
+	Mapper_t *m = NULL;
+	Data_Get_Struct (self, Mapper_t, m);
+	if (!m)
+		rb_raise (rb_eException, "No Mapper Object");
+	return INT2NUM (m->GetFileSize());
+}
+
+
+/**********************
+Init_fastfilereaderext
+**********************/
+
+extern "C" void Init_fastfilereaderext()
+{
+	EmModule = rb_define_module ("EventMachine");
+	FastFileReader = rb_define_class_under (EmModule, "FastFileReader", rb_cObject);
+	Mapper = rb_define_class_under (FastFileReader, "Mapper", rb_cObject);
+
+	rb_define_module_function (Mapper, "new", (VALUE(*)(...))mapper_new, 1);
+	rb_define_method (Mapper, "size", (VALUE(*)(...))mapper_size, 0);
+	rb_define_method (Mapper, "close", (VALUE(*)(...))mapper_close, 0);
+	rb_define_method (Mapper, "get_chunk", (VALUE(*)(...))mapper_get_chunk, 2);
+}
+
+
+

data/external/test_support.rb

@@ -56,3 +56,16 @@ module SwiftcoreTestSupport
 	end
 
 end
+
+class EMConnectionMock
+	attr_accessor :uri, :name
+	
+	def send_data data
+	end
+	
+	def send_file_data filename
+	end
+	
+	def close_connection; end
+	def close_connection_after_writing; end
+end

data/setup.rb

@@ -13,6 +13,11 @@ Dir.chdir(basedir)
 Package.setup("1.0") {
 	name "Swiftcore Swiftiply"
 
+	build_ext "fastfilereader"
+	translate(:ext, 'ext/fastfilereader/' => '/')
+	#translate(:ext, 'ext/http11/' => 'iowa/')
+	ext "ext/fastfilereader/fastfilereaderext.so"
+
 	translate(:lib, 'src/' => '')
 	translate(:bin, 'bin/' => '')
 	lib(*Dir["src/swiftcore/**/*.rb"])
@@ -25,7 +30,7 @@ Package.setup("1.0") {
 	#File.rename("#{Config::CONFIG["bindir"]}/mongrel_rails","#{Config::CONFIG["bindir"]}/mongrel_rails.orig")
 	bin "bin/mongrel_rails"
 
-#	unit_test "test/TC_Swiftiply.rb"
-	
+	unit_test "test/TC_ProxyBag.rb"
+	unit_test "test/TC_Swiftiply.rb"
 	true
 }

data/src/fastfilereader.rb

@@ -0,0 +1,109 @@
+# Written by Francis Cianfrocca (garbagecat10@gmail.com) with contributions
+# from Kirk Haines (wyhaines@gmail.com).
+
+begin
+	load_attempted ||= false
+	require 'eventmachine'
+	require 'fastfilereaderext'
+rescue LoadError => e
+	unless load_attempted
+		load_attempted = true
+		require 'eventmachine'
+		require 'fastfilereaderext'
+		retry
+	end
+	raise e
+end
+
+module EventMachine
+	class FastFileReader
+		include EventMachine::Deferrable
+
+		attr_reader :size
+
+		# TODO, make these constants tunable parameters
+		ChunkSize = 16384
+		BackpressureLevel = 50000
+		MappingThreshold = 32768
+		Crn = "\r\n".freeze
+		C0rnrn = "0\r\n\r\n".freeze
+
+		class << self
+			# Return a newly-created instance of this class, or nil on error.
+			#
+			def open filename
+				FastFileReader.new(filename)
+			rescue
+				nil
+			end
+
+		end
+
+		# This constructor can throw exceptions. Use #open to avoid that fate.
+		#
+		def initialize filename
+			# Throw an exception if we can't open the file.
+			# TODO, perhaps we should throw a different exception?
+			raise "no file" unless File.exist?(filename)
+
+			@size = File.size?(filename)
+			if @size >= MappingThreshold
+				@mapping = Mapper.new( filename )
+			else
+				@content = File.read( filename )
+			end
+		end
+
+
+		# This is a no-op for small files that have a @content
+		# member. For large files with a @mapping, we call #close
+		# on the mapping. In general, this will be done by the
+		# finalizer when the GC runs, but there will be cases
+		# when we will want to know that the underlying file mapping
+		# is closed. This matters particularly on Windows, because
+		# we're holding some HANDLE objects open that can cause
+		# trouble for Ruby.
+		def close
+			@mapping.close if @mapping
+		end
+
+		# We expect to receive something like an EventMachine::Connection object.
+		# We also expect to be running inside a reaactor loop, because we call
+		# EventMachine#next_tick when we have too much data to send.
+		def stream_as_http_chunks sink
+			if @content
+				if @content.length > 0
+					sink.send_data( "#{@content.length.to_s(16)}\r\n#{@content}#{Crn}" )
+				end
+				sink.send_data( C0rnrn )
+				set_deferred_success
+			else
+				@position = 0
+				@sink = sink
+				stream_one_http_chunk
+			end
+		end
+
+		def stream_one_http_chunk
+			loop {
+				if @position < @size
+					if @sink.get_outbound_data_size > BackpressureLevel
+						EventMachine::next_tick {stream_one_http_chunk}
+						break
+					else
+						len = @size - @position
+						len = ChunkSize if (len > ChunkSize)
+						@sink.send_data( "#{len.to_s(16)}\r\n#{@mapping.get_chunk( @position, len))}\r\n" )
+						@position += len
+					end
+				else
+					@sink.send_data( C0rnrn )
+					set_deferred_success
+					break
+				end
+			}
+		end
+		private :stream_one_http_chunk
+	end
+end
+

data/src/swiftcore/Swiftiply.rb

@@ -2,33 +2,66 @@ begin
 	load_attempted ||= false
 	require 'digest/sha2'
 	require 'eventmachine'
+	require 'fastfilereaderext'
+	require 'swiftcore/types'
 rescue LoadError => e
 	unless load_attempted
 		load_attempted = true
+		# Ugh.  Everything gets slower once rubygems are used.  So, for the
+		# best speed possible, don't install EventMachine or Swiftiply via
+		# gems.
 		require 'rubygems'
+		retry
 	end
 	raise e
 end
 
 module Swiftcore
 	module Swiftiply
-		Version = '0.5.1'
-
+		Version = '0.6.0'
+
+		# Yeah, these constants look kind of tacky.  Inside of tight loops,
+		# though, using them makes a small but measurable difference, and those
+		# small differences add up....
+		C_empty = ''.freeze
+		C_slash = '/'.freeze
+		C_slashindex_html = '/index.html'.freeze
+		Caos = 'application/octet-stream'.freeze
+		Ccache_directory = 'cache_directory'.freeze
+		Ccache_extensions = 'cache_extensions'.freeze
 		Ccluster_address = 'cluster_address'.freeze
 		Ccluster_port = 'cluster_port'.freeze
+		Ccluster_server = 'cluster_server'.freeze
 		CBackendAddress = 'BackendAddress'.freeze
 		CBackendPort = 'BackendPort'.freeze
-		Cmap = 'map'.freeze
-		Cincoming = 'incoming'.freeze
-		Ckeepalive = 'keepalive'.freeze
+		Cchunked_encoding_threshold = 'chunked_encoding_threshold'.freeze
 		Cdaemonize = 'daemonize'.freeze
-		Curl = 'url'.freeze
+		Cdefault = 'default'.freeze
+		Cdocroot = 'docroot'.freeze
+		Cepoll = 'epoll'.freeze
+		Cepoll_descriptors = 'epoll_descriptors'.freeze
+		Cgroup = 'group'.freeze
 		Chost = 'host'.freeze
-		Cport = 'port'.freeze
+		Cincoming = 'incoming'.freeze
+		Ckeepalive = 'keepalive'.freeze
+		Ckey = 'key'.freeze
+		Cmap = 'map'.freeze
+		Cmsg_expired = 'browser connection expired'.freeze
 		Coutgoing = 'outgoing'.freeze
+		Cport = 'port'.freeze
+		Credeployable = 'redeployable'.freeze
+		Credeployment_sizelimit = 'redeployment_sizelimit'.freeze
+		Cswiftclient = 'swiftclient'.freeze
 		Ctimeout = 'timeout'.freeze
-		Cdefault = 'default'.freeze
+		Curl = 'url'.freeze
+		Cuser = 'user'.freeze
+
+		C_fsep = File::SEPARATOR
+		
+		RunningConfig = {}
 
+		class EMStartServerError < RuntimeError; end
+		
 		# The ProxyBag is a class that holds the client and the server queues,
 		# and that is responsible for managing them, matching them, and expiring
 		# them, if necessary.
@@ -41,7 +74,14 @@ module Swiftcore
 			@id_map = {}
 			@reverse_id_map = {}
 			@incoming_map = {}
+			@docroot_map = {}
+			@log_map = {}
+			@redeployable_map = {}
+			@keys = {}
 			@demanding_clients = Hash.new {|h,k| h[k] = []}
+			@hitcounters = Hash.new {|h,k| h[k] = 0}
+			# Kids, don't do this at home.  It's gross.
+			@typer = MIME::Types.instance_variable_get('@__types__')
 
 			class << self
 
@@ -53,14 +93,12 @@ module Swiftcore
 				# connections must send the correct access key before being added to
 				# the cluster as a valid backend.
 
-				def key
-					@key
+				def get_key(h)
+					@keys[h] || C_empty
 				end
 
-				# Sets the access key.
-
-				def key=(val)
-					@key = val
+				def set_key(h,val)
+					@keys[h] = val
 				end
 
 				def add_id(who,what)
@@ -73,10 +111,41 @@ module Swiftcore
 					@reverse_id_map.delete(what)
 				end
 
+				def incoming_mapping(name)
+					@incoming_map[name]
+				end
+				
 				def add_incoming_mapping(hashcode,name)
 					@incoming_map[name] = hashcode
 				end
+				
+				def remove_incoming_mapping(name)
+					@incoming_map.delete(name)
+				end
+
+				def add_incoming_docroot(path,name)
+					@docroot_map[name] = path
+				end
+
+				def remove_incoming_docroot(name)
+					@docroot_map.delete(name)
+				end
+
+				def add_incoming_redeployable(limit,name)
+					@redeployable_map[name] = limit
+				end
 
+				def remove_incoming_redeployable(name)
+					@redeployable_map.delete(name)
+				end
+				
+				def add_log(log,name)
+					@log_map[name] = log
+				end
+
+				# Sets the default proxy destination, if requests are received
+				# which do not match a defined destination.
+				
 				def default_name
 					@default_name
 				end
@@ -86,29 +155,127 @@ module Swiftcore
 				end
 
 				# This timeout is the amount of time a connection will sit in queue
-				# waiting for a backend to process it.
+				# waiting for a backend to process it.  A client connection that
+				# sits for longer than this timeout receives a 503 response and
+				# is dropped.
 
 				def server_unavailable_timeout
 					@server_unavailable_timeout
 				end
 
-				# Sets the server unavailable timeout value.
-
 				def server_unavailable_timeout=(val)
 					@server_unavailable_timeout = val
 				end
 
+				# The chunked_encoding_threshold is a file size limit.  Files
+				# which fall below this limit are sent in one chunk of data.
+				# Files which hit or exceed this limit are delivered via chunked
+				# encoding.
+				
+				def chunked_encoding_threshold
+					@chunked_enconding_threshold
+				end
+				
+				def chunked_encoding_threshold=(val)
+					@chunked_encoding_threshold = val
+				end
+				
+				# Handle static files.  It employs an extension to efficiently
+				# handle large files, and depends on an addition to
+				# EventMachine, send_file_data(), to efficiently handle small
+				# files.  In my tests, it streams in excess of 120 megabytes of
+				# data per second for large files, and does 8000+ to 9000+
+				# requests per second with small files (i.e. under 4k).  I think
+				# this can still be improved upon for small files.
+				#
+				# Todo for 0.7.0 -- add etag/if-modified/if-modified-since
+				# support.
+				#
+				# TODO: Add support for logging static file delivery if wanted.
+				#   The ideal logging would probably be to Analogger since it'd
+				#   limit the performance impact of the the logging.
+				#
+				
+				def serve_static_file(clnt)
+					path_info = clnt.uri
+					client_name = clnt.name
+					dr = @docroot_map[client_name]
+					if path = find_static_file(dr,path_info,client_name)
+						#ct = ::MIME::Types.type_for(path).first || Caos
+						ct = @typer.simple_type_for(path) || Caos
+						fsize = File.size?(path)
+						if fsize > @chunked_encoding_threshold
+							clnt.send_data "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: #{ct}\r\nTransfer-encoding: chunked\r\n\r\n"
+							EM::Deferrable.future(clnt.stream_file_data(path, :http_chunks=>true)) {clnt.close_connection_after_writing}
+						else
+							clnt.send_data "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: #{ct}\r\nContent-length: #{fsize}\r\n\r\n"
+							clnt.send_file_data path
+							clnt.close_connection_after_writing
+						end
+						true
+					else
+						false
+					end
+					# The exception is going to be eaten here, because some
+					# dumb file IO error shouldn't take Swiftiply down.
+					# TODO: It should log these errors, though.
+				rescue Object
+					clnt.close_connection_after_writing
+					false
+				end
+
+				# Determine if the requested file, in the given docroot, exists
+				# and is a file (i.e. not a directory).
+				#
+				# If Rails style page caching is enabled, this method will be
+				# dynamically replaced by a more sophisticated version.
+				
+				def find_static_file(docroot,path_info,client_name)
+					path = File.join(docroot,path_info)
+					path if FileTest.exist?(path) and FileTest.file?(path)
+				end
+				
 				# Pushes a front end client (web browser) into the queue of clients
 				# waiting to be serviced if there's no server available to handle
 				# it right now.
 
-				def add_frontend_client clnt
+				def add_frontend_client(clnt,data_q,data)
 					clnt.create_time = @ctime
+					clnt.data_pos = clnt.data_len = 0 if clnt.redeployable = @redeployable_map[clnt.name]
+
+					unless @docroot_map.has_key?(clnt.name) and serve_static_file(clnt)
+						data_q.unshift data
+						unless match_client_to_server_now(clnt)
+							if clnt.uri =~ /\w+-\w+-\w+\.\w+\.[\w\.]+-(\w+)?$/
+								# NOTE: I hate using unshift and delete on arrays
+								# in this code.  Look at switching to something
+								# with a faster profile for push/pull from both
+								# ends as well as deletes.  There has to be
+								# something.  A linked list solves the push/pull
+								# which might be good enough.
+								@demanding_clients[$1].unshift clnt
+							else
+								@client_q[@incoming_map[clnt.name]].unshift(clnt)
+							end
+						end
+						#clnt.push ## wasted call, yes?
+					end
+				end
+				
+				def rebind_frontend_client(clnt)
+					clnt.create_time = @ctime
+					clnt.data_pos = clnt.data_len = 0
+					
 					unless match_client_to_server_now(clnt)
 						if clnt.uri =~ /\w+-\w+-\w+\.\w+\.[\w\.]+-(\w+)?$/
+							# NOTE: I hate using unshift and delete on arrays
+							# in this code.  Look at switching to something
+							# with a faster profile for push/pull from both
+							# ends as well as deletes.  There has to be
+							# something.
 							@demanding_clients[$1].unshift clnt
 						else
-							@client_q[clnt.name].unshift(clnt)
+							@client_q[@incoming_map[clnt.name]].unshift(clnt)
 						end
 					end
 				end
@@ -127,38 +294,28 @@ module Swiftcore
 				end
 
 				# Removes the named client from the client queue.
-				# TODO: Try replacing this with a linked list.  Performance
-				# here has to suck when the list is long.
-
+				# TODO: Try replacing this with ...something.  Performance
+				# here has to be bad when the list is long.
+				
 				def remove_client clnt
 					@client_q[clnt.name].delete clnt
 				end
 
-				# Walks through the client and server queues, matching
-				# waiting clients with waiting servers until the queue
-				# runs out of one or the other.  DEPRECATED
-
-				#def match_clients_to_servers
-				#	while @server_q.first && @client_q.first
-				#		server = @server_q.pop
-				#		client = @client_q.pop
-				#		server.associate = client
-				#		client.associate = server
-				#		client.push
-				#	end
-				#end
-
-				# Tries to match the client passed as an argument to a
+				# Tries to match the client (passed as an argument) to a
 				# server.
 
 				def match_client_to_server_now(client)
 					sq = @server_q[@incoming_map[client.name]]
-					if client.uri =~ /\w+-\w+-\w+\.\w+\.[\w\.]+-(\w+)?$/ and sidx = sq.index(@reverse_id_map[$1])
-						server = sq.delete_at(sidx)
-						server.associate = client
-						client.associate = server
-						client.push
-						true
+					if client.uri =~ /\w+-\w+-\w+\.\w+\.[\w\.]+-(\w+)?$/
+						if sidx = sq.index(@reverse_id_map[$1])
+							server = sq.delete_at(sidx)
+							server.associate = client
+							client.associate = server
+							client.push
+							true
+						else
+							false
+						end
 					elsif server = sq.pop
 						server.associate = client
 						client.associate = server
@@ -169,7 +326,7 @@ module Swiftcore
 					end
 				end
 	
-				# Tries to match the server passed as an argument to a
+				# Tries to match the server (passed as an argument) to a
 				# client.
 
 				def match_server_to_client_now(server)
@@ -192,10 +349,13 @@ module Swiftcore
 				# available to process clients and expire any clients that
 				# have been waiting longer than @server_unavailable_timeout
 				# seconds.  Clients which are expired will receive a 503
-				# response.
+				# response.  If this is happening, either you need more
+				# backend processes, or you @server_unavailable_timeout is
+				# too short.
 
 				def expire_clients
 					now = Time.now
+
 					@server_q.each_key do |name|
 						unless @server_q[name].first
 							while c = @client_q[name].pop
@@ -225,12 +385,10 @@ module Swiftcore
 
 		class ClusterProtocol < EventMachine::Connection
 
-			attr_accessor :create_time, :associate, :name
+			attr_accessor :create_time, :associate, :name, :redeployable, :data_pos, :data_len
 
 			Crn = "\r\n".freeze
 			Crnrn = "\r\n\r\n".freeze
-			Rrnrn = /\r\n\r\n/
-			R_colon = /:/
 			C_blank = ''.freeze
 
 			# Initialize the @data array, which is the temporary storage for blocks
@@ -239,26 +397,28 @@ module Swiftcore
 
 			def initialize *args
 				@data = []
-				@name = nil
-				@uri = nil
+				@data_pos = 0
+				@name = @uri = nil
 				super
 			end
 
 			def receive_data data
-				@data.unshift data
 				if @name
+					@data.unshift data
 					push
 				else
-					data =~ /\s([^\s\?]*)/
-					@uri ||= $1
-					if data =~ /^Host:\s*([^\r\n:]*)/
-						@name = $1
-						ProxyBag.add_frontend_client self
-						push
-					elsif data.index(/\r\n\r\n/)
+					if data =~ /^Host:\s*([^\r:]*)/
+						# NOTE: Should I be using intern for this?  It might not
+						# be a good idea.
+						@name = $1.intern
+						
+						data =~ /\s([^\s\?]*)/
+						@uri = $1
+						@name = ProxyBag.default_name unless ProxyBag.incoming_mapping(@name)
+						ProxyBag.add_frontend_client(self,@data,data)
+					elsif data =~ /\r\n\r\n/
 						@name = ProxyBag.default_name
-						ProxyBag.add_frontend_client self
-						push
+						ProxyBag.add_frontend_client(self,@data,data)
 					end
 				end
 			end
@@ -281,8 +441,26 @@ module Swiftcore
 
 			def push
 				if @associate
-					while data = @data.pop
-						@associate.send_data data
+					unless @redeployable
+						# normal data push
+						data = nil
+						@associate.send_data data while data = @data.pop
+					else
+						# redeployable data push; just send the stuff that has
+						# not already been sent.
+						(@data.length - 1 - @data_pos).downto(0) do |p|
+							d = @data[p]
+							@associate.send_data d
+							@data_len += d.length
+						end
+						@data_pos = @data.length
+
+						# If the request size crosses the size limit, then
+						# disallow redeployent of this request.
+						if @data_len > @redeployable
+							@redeployable = false
+							@data.clear
+						end
 					end
 				end
 			end
@@ -301,8 +479,11 @@ module Swiftcore
 				@uri
 			end
 
-		end
+			def setup_for_redeployment
+				@data_pos = 0
+			end
 
+		end
 
 		# The BackendProtocol is the EventMachine::Connection subclass that
 		# handles the communications between Swiftiply and the backend process
@@ -311,8 +492,8 @@ module Swiftcore
 		class BackendProtocol < EventMachine::Connection
 			attr_accessor :associate, :id
 
+			C0rnrn = "0\r\n\r\n".freeze
 			Crnrn = "\r\n\r\n".freeze
-			Rrnrn = /\r\n\r\n/
 
 			def initialize *args
 				@name = self.class.bname
@@ -336,31 +517,47 @@ module Swiftcore
 			def setup
 				@headers = ''
 				@headers_completed = false
-				@content_length = nil
+				#@content_length = nil
 				@content_sent = 0
 			end
-
+			
 			# Receive data from the backend process.  Headers are parsed from
-			# the rest of the content, and the Content-Length header used to
-			# determine when the complete response has been read.  The proxy
-			# will attempt to maintain a persistent connection with the backend,
-			# allowing for greater throughput.
+			# the rest of the content.  If a Content-Length header is present,
+			# that is used to determine how much data to expect.  Otherwise,
+			# if 'Transfer-encoding: chunked' is present, assume chunked
+			# encoding.  Otherwise be paranoid; something isn't the way we like
+			# it to be.
 
 			def receive_data data
 				unless @initialized
-					@id = data.slice!(0..11)
-					ProxyBag.add_id(self,@id)
-					@initialized = true
+					preamble = data.slice!(0..24)
+					
+					keylen = preamble[23..24].to_i(16)
+					keylen = 0 if keylen < 0
+					key = keylen > 0 ? data.slice!(0..(keylen - 1)) : C_empty
+					if preamble[0..10] == Cswiftclient and key == ProxyBag.get_key(@name)
+						@id = preamble[11..22]
+						ProxyBag.add_id(self,@id)
+						@initialized = true
+					else
+						close_connection
+						return
+					end
 				end
+				
 				unless @headers_completed 
-					if data.index(Crnrn)
+					if data =~ /\r\n\r\n/
 						@headers_completed = true
-						h,d = data.split(Rrnrn)
+						h,data = data.split(/\r\n\r\n/,2)
 						@headers << h << Crnrn
-						@headers =~ /Content-Length:\s*([^\r\n]+)/
-						@content_length = $1.to_i
+						if @headers =~ /Content-[Ll]ength:\s*([^\r]+)/
+							@content_length = $1.to_i
+						elsif @headers =~ /Transfer-encoding:\s*chunked/
+							@content_length = nil
+						else
+							@content_length = 0
+						end
 						@associate.send_data @headers
-						data = d
 					else
 						@headers << data
 					end
@@ -369,15 +566,20 @@ module Swiftcore
 				if @headers_completed
 					@associate.send_data data
 					@content_sent += data.length
-					if @content_sent >= @content_length
+					if @content_length and @content_sent >= @content_length or data[-6..-1] == C0rnrn
 						@associate.close_connection_after_writing
 						@associate = nil
-						setup
+						@headers = ''
+						@headers_completed = false
+						#@content_length = nil
+						@content_sent = 0
+						#setup
 						ProxyBag.add_server self
 					end
 				end
+			# TODO: Log these errors!
 			rescue
-				@associate.close_connection_after_writing
+				@associate.close_connection_after_writing if @associate
 				@associate = nil
 				setup
 				ProxyBag.add_server self
@@ -390,7 +592,13 @@ module Swiftcore
 
 			def unbind
 				if @associate
-					@associate.close_connection_after_writing
+					if !@associate.redeployable or @content_length
+						@associate.close_connection_after_writing
+					else
+						@associate.associate = nil
+						@associate.setup_for_redeployment
+						ProxyBag.rebind_frontend_client(@associate)
+					end
 				else
 					ProxyBag.remove_server(self)
 				end
@@ -410,36 +618,157 @@ module Swiftcore
 		# handlers, then create the timers that are used to expire unserviced
 		# clients and to update the Proxy's clock.
 
-		def self.run(config, key = nil)
-			existing_backends = {}
+		def self.run(config)
+			@existing_backends = {}
+			
+			# Default is to assume we want to try to turn epoll support on.  EM
+			# ignores this on platforms that don't support it, so this is safe.
+			EventMachine.epoll unless config.has_key?(Cepoll) and !config[Cepoll]
+			EventMachine.set_descriptor_table_size(4096 || config[Cepoll_descriptors]) if config[Cepoll]
 			EventMachine.run do
-				EventMachine.start_server(config[Ccluster_address], config[Ccluster_port], ClusterProtocol)
-				config[Cmap].each do |m|
-					if m[Ckeepalive]
-						incoming_hash = Digest::SHA512.hexdigest(m[Cincoming].join('|'))
-						m[Cincoming].each do |p|
-							ProxyBag.add_incoming_mapping(incoming_hash,p)
-							m[Coutgoing].each do |o|
-								ProxyBag.default_name = p if m[Cdefault]
-								if existing_backends.has_key?(o)
-									# Do we need to do anything here other than skip?
-									next
-								else
-									existing_backends[o] = true
-									backend_class = Class.new(BackendProtocol)
-									backend_class.bname = incoming_hash
-									host, port = o.split(/:/,2)
-									EventMachine.start_server(host, port.to_i, backend_class)
+				trap("HUP") {em_config(Swiftcore::SwiftiplyExec.parse_options); GC.start}
+				trap("INT") {EventMachine.stop_event_loop}
+				em_config(config)
+				GC.start
+			end
+		end
+		
+		def self.em_config(config)
+			new_config = {}
+			if RunningConfig[Ccluster_address] != config[Ccluster_address] or RunningConfig[Ccluster_port] != config[Ccluster_port]
+				begin
+			    	new_config[Ccluster_server] = EventMachine.start_server(
+                	config[Ccluster_address],
+                	config[Ccluster_port],
+                	ClusterProtocol)
+				rescue RuntimeError => e
+					advice = ''
+					if config[Ccluster_port] < 1024
+						advice << 'Make sure you have the correct permissions to use that port, and make sure there is nothing else running on that port.'
+					else
+						advice << 'Make sure there is nothing else running on that port.'
+					end
+					advice << "  The original error was:  #{e}\n"
+					raise EMStartServerError.new("The listener on #{config[Ccluster_address]}:#{config[Ccluster_port]} could not be started.\n#{advice}")
+				end
+				new_config[Ccluster_address] = config[Ccluster_address]
+				new_config[Ccluster_port] = config[Ccluster_port]
+		    	RunningConfig[Ccluster_server].stop_server if RunningConfig.has_key?(Ccluster_server)
+			else
+				new_config[Ccluster_server] = RunningConfig[Ccluster_server]
+				new_config[Ccluster_address] = RunningConfig[Ccluster_address]
+				new_config[Ccluster_port] = RunningConfig[Ccluster_port]
+			end
+		    	
+			new_config[Coutgoing] = {}
+
+			config[Cmap].each do |m|
+				if m[Ckeepalive]
+					# keepalive requests are standard Swiftiply requests.
+					
+					# The hash of the "outgoing" config section.  It is used to
+					# uniquely identify a section.
+					hash = Digest::SHA256.hexdigest(m[Cincoming].sort.join('|')).intern
+					
+					# For each incoming entry, do setup.
+					new_config[Cincoming] = {}
+					m[Cincoming].each do |p_|
+						p = p_.intern
+						new_config[Cincoming][p] = {}
+						ProxyBag.add_incoming_mapping(hash,p)
+						
+						if m.has_key?(Cdocroot)
+							ProxyBag.add_incoming_docroot(m[Cdocroot],p)
+						else
+							ProxyBag.remove_incoming_docroot(p)
+						end
+						
+						if m[Credeployable]
+							ProxyBag.add_incoming_redeployable(m[Credeployment_sizelimit] || 16384,p)
+						else
+							ProxyBag.remove_incoming_redeployable(p)
+						end
+						
+						if m.has_key?(Ckey)
+							ProxyBag.set_key(hash,m[Ckey])
+						else
+							ProxyBag.set_key(hash,C_empty)
+						end
+						
+						if m.has_key?(Ccache_extensions) or m.has_key?(Ccache_directory)
+							require 'swiftcore/Swiftiply/support_pagecache'
+							ProxyBag.add_suffix_list((m[Ccache_extensions] || ProxyBag.const_get(:DefaultSuffixes)),p)
+							ProxyBag.add_cache_dir((m[Ccache_directory] || ProxyBag.const_get(:DefaultCacheDir)),p)
+						else
+							ProxyBag.remove_suffix_list(p) if ProxyBag.respond_to?(:remove_suffix_list)
+							ProxyBag.remove_cache_dir(p) if ProxyBag.respond_to?(:remove_cache_dir)
+						end
+							
+						m[Coutgoing].each do |o|
+							ProxyBag.default_name = p if m[Cdefault]
+							if @existing_backends.has_key?(o)
+								new_config[Coutgoing][o] ||= RunningConfig[Coutgoing][o]
+								next
+							else
+								@existing_backends[o] = true
+								backend_class = Class.new(BackendProtocol)
+								backend_class.bname = hash
+								host, port = o.split(/:/,2)
+								begin
+									new_config[Coutgoing][o] = EventMachine.start_server(host, port.to_i, backend_class)
+								rescue RuntimeError => e
+									advice = ''
+									if port.to_i < 1024
+										advice << 'Make sure you have the correct permissions to use that port, and make sure there is nothing else running on that port.'
+									else
+										advice << 'Make sure there is nothing else running on that port.'
+									end
+									advice << "  The original error was:  #{e}\n"
+									raise EMStartServerError.new("The listener on #{host}:#{port} could not be started.\n#{advice}")
 								end
 							end
 						end
+						
+						# Now stop everything that is still running but which isn't needed.
+						if RunningConfig.has_key?(Coutgoing)
+							(RunningConfig[Coutgoing].keys - new_config[Coutgoing].keys).each do |unneeded_server_key|
+								RunningConfig[Coutgoing][unneeded_server_key].stop_server
+							end
+						end
 					end
+				else
+					# This is where the code goes that sets up traditional proxy destinations.
+					# This is a future TODO item.	
 				end
-				ProxyBag.server_unavailable_timeout ||= config[Ctimeout]
-				ProxyBag.key = key
+			end
+
+			#EventMachine.set_effective_user = config[Cuser] if config[Cuser] and RunningConfig[Cuser] != config[Cuser]
+			run_as(config[Cuser],config[Cgroup]) if (config[Cuser] and RunningConfig[Cuser] != config[Cuser]) or (config[Cgroup] and RunningConfig[Cgroup] != config[Cgroup])
+			new_config[Cuser] = config[Cuser]
+			new_config[Cgroup] = config[Cgroup]
+			
+			ProxyBag.server_unavailable_timeout ||= config[Ctimeout]
+			ProxyBag.chunked_encoding_threshold = config[Cchunked_encoding_threshold] || 16384
+			
+			unless RunningConfig[:initialized]
 				EventMachine.add_periodic_timer(2) { ProxyBag.expire_clients }
 				EventMachine.add_periodic_timer(1) { ProxyBag.update_ctime }
+				new_config[:initialized] = true
 			end
+			
+			RunningConfig.replace new_config
+		end
+		
+		
+		# This can be used to change the effective user and group that
+		# Swiftiply is running as.
+		
+		def self.run_as(user = "nobody", group = "nobody")
+			Process.initgroups(user,Etc.getgrnam(group).gid) if user and group
+			::Process::GID.change_privilege(Etc.getgrnam(group).gid) if group
+			::Process::UID.change_privilege(Etc.getpwnam(user).uid) if user
+		rescue Errno::EPERM
+			raise "Failed to change the effective user to #{user} and the group to #{group}"
 		end
 	end
 end