swiftiply 0.6.1.1 → 1.0.0

data/src/swiftcore/Swiftiply/backend_protocol.rb

@@ -0,0 +1,213 @@
+module Swiftcore
+  module Swiftiply
+    
+    # The BackendProtocol is the EventMachine::Connection subclass that
+		# handles the communications between Swiftiply and the backend process
+		# it is proxying to.
+
+		class BackendProtocol < EventMachine::Connection
+			attr_accessor :associate, :id
+
+			C0rnrn = "0\r\n\r\n".freeze
+			Crnrn = "\r\n\r\n".freeze
+
+			def initialize *args
+				@name = self.class.bname
+				@permit_xsendfile = self.class.xsendfile
+				@enable_sendfile_404 = self.class.enable_sendfile_404
+				super
+			end
+
+			def name
+				@name
+			end
+
+			# Call setup() and add the backend to the ProxyBag queue.
+
+			def post_init
+				setup
+				@initialized = nil
+				ProxyBag.add_server self
+			end
+
+			# Setup the initial variables for receiving headers and content.
+
+			def setup
+				@headers = ''
+				@headers_completed = @dont_send_data = false
+				#@content_length = nil
+				@content_sent = 0
+				@filter = self.class.filter
+			end
+			
+			# Receive data from the backend process.  Headers are parsed from
+			# 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
+					# preamble = data.slice!(0..24)
+					preamble = data[0..24]
+					data = data[25..-1] || C_empty
+					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)
+					if preamble.index(Cswiftclient) == 0 and key == ProxyBag.get_key(@name)
+						@id = preamble[11..22]
+						ProxyBag.add_id(self,@id)
+						@initialized = true
+					else
+						# The worker that connected did not present the proper authentication,
+						# so something is fishy; time to cut bait.
+						close_connection
+						return
+					end
+				end
+				
+				unless @headers_completed 
+					if data.include?(Crnrn)
+						@headers_completed = true
+						h,data = data.split(/\r\n\r\n/,2)
+						#@headers << h << Crnrn
+						if @headers.length > 0
+							@headers << h
+						else
+							@headers = h
+						end
+						
+						if @headers =~ /Content-[Ll]ength: *([^\r]+)/
+							@content_length = $1.to_i
+						elsif @headers =~ /Transfer-encoding:\s*chunked/
+							@content_length = nil
+						else
+							@content_length = 0
+						end
+
+						if @permit_xsendfile && @headers =~ /X-[Ss]endfile: *([^\r]+)/
+							@associate.uri = $1
+							if ProxyBag.serve_static_file(@associate,ProxyBag.get_sendfileroot(@associate.name))
+								@dont_send_data = true
+							else
+								if @enable_sendfile_404
+									msg = "#{@associate.uri} could not be found."
+									@associate.send_data "HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\nContent-Type: text/html\r\nContent-Length: #{msg.length}\r\n\r\n#{msg}"
+									@associate.close_connection_after_writing
+									@dont_send_data = true
+								else
+									@associate.send_data @headers + Crnrn
+								end
+							end
+						else
+							@associate.send_data @headers + Crnrn
+						end
+						
+						# If keepalive is turned on, the assumption is that it will stay
+						# on, unless the headers being returned indicate that the connection
+						# should be closed.
+						# So, check for a 'Connection: Closed' header.
+						if keepalive = @associate.keepalive
+							keepalive = false if @headers =~ /Connection: [Cc]lose/
+							if @associate_http_version == C1_0
+								keepalive = false unless @headers == /Connection: Keep-Alive/i
+							end
+						end
+					else
+						@headers << data
+					end
+				end
+
+				if @headers_completed
+					@associate.send_data data unless @dont_send_data
+					@content_sent += data.length
+					if @content_length and @content_sent >= @content_length or data[-6..-1] == C0rnrn
+						# If @dont_send_data is set, then the connection is going to be closed elsewhere.
+						unless @dont_send_data
+							# Check to see if keepalive is enabled.
+							if keepalive
+								@associate.reset_state
+								ProxyBag.remove_client(self) unless @associate
+							else
+								@associate.close_connection_after_writing
+							end
+						end
+						@associate = @headers_completed = @dont_send_data = nil
+						@headers = ''
+						#@headers_completed = false
+						#@content_length = nil
+						@content_sent = 0
+						#setup
+						ProxyBag.add_server self
+					end
+				end
+			# TODO: Log these errors!
+			rescue Exception => e
+				puts "Kaboom: #{e} -- #{e.backtrace.inspect}"
+				@associate.close_connection_after_writing if @associate
+				@associate = nil
+				setup
+				ProxyBag.add_server self
+			end
+
+			# This is called when the backend disconnects from the proxy.
+			# If the backend is currently associated with a web browser client,
+			# that connection will be closed.  Otherwise, the backend will be
+			# removed from the ProxyBag's backend queue.
+
+			def unbind
+				if @associate
+					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
+				ProxyBag.remove_id(self)
+			end
+
+			def self.bname=(val)
+				@bname = val
+			end
+
+			def self.bname
+				@bname
+			end
+			
+			def self.xsendfile=(val)
+				@xsendfile = val
+			end
+			
+			def self.xsendfile
+				@xsendfile
+			end
+			
+			def self.enable_sendfile_404=(val)
+				@enable_sendfile_404 = val
+			end
+			
+			def self.enable_sendfile_404
+				@enable_sendfile_404
+			end
+			
+			def self.filter=(val)
+				@filter = val
+			end
+			
+			def self.filter
+				@filter
+			end
+			
+			def filter
+				@filter
+			end
+		end
+
+  end
+end

data/src/swiftcore/Swiftiply/cache_base.rb

@@ -0,0 +1,49 @@
+module Swiftcore
+	begin
+		# Attempt to load the SplayTreeMap and Deque.  If it is not found, rubygems
+		# will be required, and SplayTreeMap will be checked for again.  If it is
+		# still not found, then it will be recorded as unavailable, and the
+		# remainder of the requires will be performed.  If any of them are not
+		# found, and rubygems has not been required, it will be required and the
+		# code will retry, once.
+		load_state ||= :start
+		rubygems_loaded ||= false
+		load_state = :splaytreemap
+		require 'swiftcore/splaytreemap' unless const_defined?(:HasSplayTree)
+		HasSplayTree = true unless const_defined?(:HasSplayTree)
+
+		load_state = :deque
+		require 'swiftcore/deque' unless const_defined?(:HasDeque)
+		HasDeque = true unless const_defined?(:HasDeque)
+		
+		load_state = :remainder
+	rescue LoadError => e
+		if !rubygems_loaded
+			begin
+				require 'rubygems'
+				rubygems_loaded = true
+			rescue LoadError
+				raise e
+			end
+			retry
+		end
+		
+		case load_state
+		when :deque
+			HasDeque = false
+			retry
+		when :splaytreemap
+			HasSplayTreeMap = false
+			retry
+		end
+		
+		raise e
+	end
+
+		
+	if HasSplayTree
+		require 'swiftcore/Swiftiply/splay_cache_base'
+	else
+		require 'swiftcore/Swiftiply/hash_cache_base'
+	end
+end

data/src/swiftcore/Swiftiply/cache_base_mixin.rb

@@ -0,0 +1,52 @@
+module Swiftcore
+	module Swiftiply
+		module CacheBaseMixin
+			attr_accessor :vw, :owners, :owner_hash, :name
+			
+			def add_to_verification_queue(path)
+				@vq.unshift(path)
+				true
+			end
+			
+			def vqlength
+				@vq.length
+			end
+
+			def check_verification_queue
+				start = Time.now
+				count = 0
+				@push_to_vq = {}
+				vql = @vq.length
+				qg = vql - @old_vql
+				while Time.now < start + @tl && !@vq.empty?
+					count += 1
+					path = @vq.pop
+					verify(path) ? @push_to_vq[path] = 1 : delete(path)
+				end
+				@push_to_vq.each_key {|x| add_to_verification_queue(x)}
+				@old_vql = @vq.length
+
+				rt = Time.now - start
+
+				# This algorithm is self adaptive based on the amount of work
+				# completed in the time slice, and the amount of remaining work
+				# in the queue.
+				# (verification_window / (verification_queue_length / count)) * (real_time / time_limit)
+
+				# If the queue growth in the last time period exceeded the count of items consumed this time,
+				# use the ratio of the two to reduce the count number. This will result in a shorter period of
+				# of time before the next check cycle. This lets the system stay on top of things when there
+				# are bursts.
+				if qg > count
+					count *= count/qg
+				end
+				if vql == 0
+					@vw / 2
+				else
+					wait_time = (@vwtl * count) / (vql * rt)
+					wait_time < rt ? rt * 2.0 : wait_time > @vw ? @vw : wait_time
+				end
+			end			
+		end
+	end
+end

data/src/swiftcore/Swiftiply/cluster_managers/rest_based_cluster_manager.rb

@@ -0,0 +1,9 @@
+module Swiftcore
+	module Swiftiply
+		module ClusterManagers
+			class RestBasedClusterManager
+
+			end
+		end		
+	end
+end

data/src/swiftcore/Swiftiply/cluster_protocol.rb

@@ -0,0 +1,70 @@
+# Encoding:ascii-8bit
+
+require "swiftcore/Swiftiply/http_recognizer"
+
+module Swiftcore
+  module Swiftiply
+
+    # The ClusterProtocol is the subclass of EventMachine::Connection used
+    # to communicate between Swiftiply and the web browser clients.
+
+    class ClusterProtocol < HttpRecognizer
+
+      proxy_bag_class_is Swiftcore::Swiftiply::ProxyBag
+
+      C503Header = "HTTP/1.1 503 Server Unavailable\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\n"
+
+      def self.init_class_variables
+        @count_503 = 0
+        super
+      end
+
+      def self.increment_503_count
+        @count_503 += 1
+      end
+      
+      # Hardcoded 503 response that is sent if a connection is timed out while
+      # waiting for a backend to handle it.
+
+      def send_503_response
+        ip = Socket::unpack_sockaddr_in(get_peername).last rescue Cunknown_host
+        error = "The request (#{@uri} --> #{@name}), received on #{create_time.asctime} from #{ip} timed out before being deployed to a server for processing."
+        send_data "#{C503Header}Server Unavailable\n\n#{error}"
+        ProxyBag.logger.log(Cinfo,"Server Unavailable -- #{error}")
+        close_connection_after_writing
+        increment_503_count
+      end
+  
+      def increment_503_count
+        @klass.increment_503_count
+      end
+
+      def push
+        if @associate
+          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
+
+    end
+  end
+end

data/src/swiftcore/Swiftiply/config.rb

@@ -0,0 +1,370 @@
+module Swiftcore
+  module Swiftiply
+    class Config
+      def self.configure_logging(config, data)
+        ProxyBag.remove_log(data[:hash])
+        if config['logger'] and (!ProxyBag.log(data[:hash]) or MockLog === ProxyBag.log(data[:hash]))
+          new_log = ::Swiftcore::Swiftiply::handle_logger_config(config['logger'])
+
+          ProxyBag.add_log(new_log[:logger],data[:hash])
+          ProxyBag.set_level(new_log[:log_level],data[:hash])
+        end
+      end
+
+      def self.configure_file_cache(config, data)
+        # The File Cache defaults to a max size of 100 elements, with a refresh
+        # window of five minues, and a time slice of a hundredth of a second.
+        sz = 100
+        vw = 300
+        ts = 0.01
+
+        if config.has_key?(Cfile_cache)
+          sz = config[Cfile_cache][Csize] || 100
+          sz = 100 if sz < 0
+          vw = config[Cfile_cache][Cwindow] || 900
+          vw = 900 if vw < 0
+          ts = config[Cfile_cache][Ctimeslice] || 0.01
+          ts = 0.01 if ts < 0
+        end
+
+        ProxyBag.logger.log('debug',"Creating File Cache; size=#{sz}, window=#{vw}, timeslice=#{ts}") if ProxyBag.log_level > 2
+        file_cache = Swiftcore::Swiftiply::FileCache.new(vw,ts,sz)
+        file_cache.owners = data[:owners]
+        file_cache.owner_hash = data[:hash]
+        EventMachine.add_timer(vw/2) {ProxyBag.verify_cache(file_cache)} unless RunningConfig[:initialized]
+        file_cache
+      end
+
+      def self.configure_dynamic_request_cache(config, data)
+        # The Dynamic Request Cache defaults to a max size of 100, with a 15 minute
+        # refresh window, and a time slice of a hundredth of a second.
+        sz = 100
+        vw = 900
+        ts = 0.01
+        if config.has_key?(Cdynamic_request_cache)
+          sz = config[Cdynamic_request_cache][Csize] || 100
+          sz = 100 if sz < 0
+          vw = config[Cdynamic_request_cache][Cwindow] || 900
+          vw = 900 if vw < 0
+          ts = config[Cdynamic_request_cache][Ctimeslice] || 0.01
+          ts = 0.01 if ts < 0
+        end
+        ProxyBag.logger.log('debug',"Creating Dynamic Request Cache; size=#{sz}, window=#{vw}, timeslice=#{ts}") if ProxyBag.log_level > 2
+        dynamic_request_cache = Swiftcore::Swiftiply::DynamicRequestCache.new(config[Cdocroot],vw,ts,sz)
+        dynamic_request_cache.owners = data[:owners]
+        dynamic_request_cache.owner_hash = data[:hash]
+        EventMachine.add_timer(vw/2) {ProxyBag.verify_cache(dynamic_request_cache)} unless Swiftcore::Swiftiply::RunningConfig[:initialized]
+        dynamic_request_cache
+      end
+
+      def self.configure_etag_cache(config, data)
+        # The ETag Cache defaults to a max size of 10000 (it doesn't take a lot
+        # of RAM to hold an etag), with a 5 minute refresh window and a time
+        # slice of a hundredth of a second.
+        sz = 10000
+        vw = 300
+        ts = 0.01
+        if config.has_key?(Cetag_cache)
+          sz = config[Cetag_cache][Csize] || 100
+          sz = 100 if sz < 0
+          vw = config[Cetag_cache][Cwindow] || 900
+          vw = 900 if vw < 0
+          ts = config[Cetag_cache][Ctimeslice] || 0.01
+          ts = 0.01 if ts < 0
+        end
+        ProxyBag.logger.log('debug',"Creating ETag Cache; size=#{sz}, window=#{vw}, timeslice=#{ts}") if ProxyBag.log_level > 2
+        etag_cache = Swiftcore::Swiftiply::EtagCache.new(vw,ts,sz)
+        etag_cache.owners = data[:owners]
+        etag_cache.owner_hash = data[:hash]
+        EventMachine.add_timer(vw/2) {ProxyBag.verify_cache(etag_cache)} unless Swiftcore::Swiftiply::RunningConfig[:initialized]
+        etag_cache
+      end
+
+      def self.setup_caches(new_config,data)
+        # The dynamic request cache may need to know a valid client name.
+        data[:dynamic_request_cache].one_client_name ||= data[:p]
+
+        new_config[Cincoming][data[:p]] = {}
+        ProxyBag.add_incoming_mapping(data[:hash],data[:p])
+        ProxyBag.add_file_cache(data[:file_cache],data[:p])
+        ProxyBag.add_dynamic_request_cache(data[:dynamic_request_cache],data[:p])
+        ProxyBag.add_etag_cache(data[:etag_cache],data[:p])
+      end
+
+      def self.configure_docroot(config, p)
+        if config.has_key?(Cdocroot)
+          ProxyBag.add_docroot(config[Cdocroot],p)
+        else
+          ProxyBag.remove_docroot(p)
+        end
+      end
+
+      def self.configure_sendfileroot(config, p)
+        if config.has_key?(Csendfileroot)
+          ProxyBag.add_sendfileroot(config[Csendfileroot],p)
+          true
+        else
+          ProxyBag.remove_sendfileroot(p)
+          false
+        end
+      end
+
+      def self.configure_xforwardedfor(config, p)
+        if config[Cxforwardedfor]
+          ProxyBag.set_x_forwarded_for(p)
+        else
+          ProxyBag.unset_x_forwarded_for(p)
+        end
+      end
+
+      def self.configure_redeployable(config, p)
+        if config[Credeployable]
+          ProxyBag.add_redeployable(config[Credeployment_sizelimit] || 16384,p)
+        else
+          ProxyBag.remove_redeployable(p)
+        end
+      end
+
+      def self.configure_key(config, p, data)
+        if config.has_key?(Ckey)
+          ProxyBag.set_key(data[:hash],config[Ckey])
+        else
+          ProxyBag.set_key(data[:hash],C_empty)
+        end
+      end
+
+      def self.configure_staticmask(config, p)
+        if config.has_key?(Cstaticmask)
+          ProxyBag.add_static_mask(Regexp.new(config[Cstaticmask]),p)
+        else
+          ProxyBag.remove_static_mask(p)
+       end
+      end
+
+      def self.configure_cache_extensions(config, p)
+        if config.has_key?(Ccache_extensions) or config.has_key?(Ccache_directory)
+          require 'swiftcore/Swiftiply/support_pagecache'
+          ProxyBag.add_suffix_list((config[Ccache_extensions] || ProxyBag.const_get(:DefaultSuffixes)),p)
+          ProxyBag.add_cache_dir((config[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
+      end
+
+      def self.configure_cluster_manager(config, p)
+        # Check for a cluster management section and do setup.
+        # manager: URL
+        #
+        # manager:
+        #   callsite: URL
+        #
+        # manager:
+        #   require: FILENAME
+        #   class: CLASSNAME
+        #   callsite: CLASS specific destination
+        #   params: param list to pass to the class
+        #
+        # If a filename is not given, cluster management will default to the
+        # URL triggered system, which requires a URL
+
+        if config.has_key?(Cmanager)
+          config[Cmanager].each do |manager|
+            cluster_manager_params = {}
+            if Hash === manager
+              cluster_manager_params[:callsite] = manager[Ccallsite]
+              require manager[Crequire] || "swiftcore/Swiftiply/rest_based_cluster_manager"
+              cluster_manager_params[:class] = get_const_from_name(manager[Cclassname] || "RestBasedClusterManager", ::Swiftcore::Swiftiply::ManagerProtocols)
+              cluster_manager_params[:params] = manager[Cparams] || []
+            else
+              cluster_manager_params[:callsite] = manager
+              require "swiftcore/Swiftiply/rest_based_cluster_manager"
+              cluster_manager_params[:class] = ::Swiftcore::Swiftiply::ManagerProtocols::RestBasedClusterManager
+              cluster_manager_params[:params] = []
+            end
+            ProxyBag.add_cluster_manager(cluster_manager_params, hash)
+          end
+        else
+          ProxyBag.remove_cluster_manager(hash)
+        end
+      end
+
+      def self.configure_backends(k,args)
+        config = args[:config]
+        p = args[:p]
+        config_data = args[:config_data]
+        new_config = args[:new_config]
+        klass = args[:self]
+        directory_class = args[:directory_class]
+        directory_args = args[:directory_args]
+        
+        ProxyBag.remove_filters(p)
+
+        is_a_server = klass.respond_to?(:is_a_server?) && klass.is_a_server?
+
+        if config[k]
+                    #
+          # outgoing: 127.0.0.1:12340
+          # outgoing:
+          #   to: 127.0.0.1:12340
+          #
+          # outgoing:
+          #   match: php$
+          #   to: 127.0.0.1:12342
+          #
+          # outgoing:
+          #   prefix: /blah
+          #   to: 127.0.0.1:12345
+          #
+          #####
+          #
+          # If the outgoing is a simple host:port, then all
+          # requests go striaght to a backend connected to
+          # that socket location.
+          #
+          # If the outgoing is a hash, and the hash only has
+          # a 'to' key, then the behavior is the same as if
+          # it were a simple host:port.
+          #
+          # If the outgoing hash has a 'to' and a 'match',
+          # then the incoming request's uri will be compared
+          # to the regular expression contained in the
+          # 'match' parameter.
+          #
+          # If the outgoing hash has a 'to' and a 'prefix',
+          # then the incoming request's uri will be compared
+          # with the prefix using a trie classifier.
+          #   THE PREFIX OPTION IS NOT FULLY IMPLEMENTED!!!
+          config[k].each do |o|
+            # Directory classes have a lot of power to customize what's happening. So, make a new instance right away.
+            new_directory_class = generate_new_directory_class(directory_class, o, new_config)
+
+            if is_a_server
+              if klass.respond_to?(:parse_connection_params)
+                params = klass.parse_connection_params(o, new_directory_class) # Provide the directory class, as it might have an opinion on how to parse this information.
+                out = params[:out]
+                host = params[:host]
+                port = params[:port]
+                filter = params[:filter]
+              else
+                if Hash === o
+                  out = [o['to'],o['match'],o['prefix']].compact.join('::')
+                  host, port = o['to'].split(/:/,2)
+                  filter = Regexp.new(o['match'])
+                else
+                  out = o
+                  host, port = out.split(/:/,2)
+                  filter = nil
+                end
+              end
+  
+              ProxyBag.logger.log(Cinfo,"  Configuring outgoing server #{out}") if ::Swiftcore::Swiftiply::log_level > 0
+              ProxyBag.default_name = p if config[Cdefault]
+              if Swiftcore::Swiftiply::existing_backends.has_key?(out)
+                ProxyBag.logger.log(Cinfo,'    Already running; skipping') if ::Swiftcore::Swiftiply::log_level > 2
+                new_config[Coutgoing][out] ||= Swiftcore::Swiftiply::RunningConfig[Coutgoing][out]
+                next
+              else
+                # TODO:  Add ability to create filters for outgoing destinations, so one can send different path patterns to different outgoing hosts/ports.
+                Swiftcore::Swiftiply::existing_backends[out] = true
+                backend_class = setup_backends(args.dup.merge(:directory_class => new_directory_class), filter)
+
+                begin
+                  new_config[Coutgoing][out] = EventMachine.start_server(host, port.to_i, backend_class)
+                rescue RuntimeError => e
+                  puts e.inspect
+                  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
+            else # it's not a server
+              if klass.respond_to?(:parse_connection_params)
+                params = klass.parse_connection_params(o, new_directory_class) # Provide the directory class, as it might have an opinion on how to parse this information.
+                out = params[:out] # this should be some sort of identifier, just for logging purposes.
+                filter = params[:out]
+              else
+                if Hash === o
+                  filter = Regexp.new(o['match'])
+                end
+              end
+
+              out ||= p
+              ProxyBag.logger.log(Cinfo,"  Configuring outgoing protocol for #{out}") if ::Swiftcore::Swiftiply::log_level > 0
+              ProxyBag.default_name = p if config[Cdefault]
+              
+              setup_backends(args.dup.merge(:directory_class => new_directory_class), filter)
+            end
+          end # done iterating on config
+        else
+          new_directory_class = generate_new_directory_class(directory_class, config, new_config)
+
+          if klass.respond_to?(:parse_connection_params)
+            params = klass.parse_connection_params({}, new_directory_class) # Provide the directory class, as it might have an opinion on how to parse this information.
+            out = params[:out] # this should be some sort of identifier, just for logging purposes.
+            filter = params[:out]
+          end
+
+          out ||= p
+          ProxyBag.logger.log(Cinfo,"  Configuring outgoing protocol for #{out}") if ::Swiftcore::Swiftiply::log_level > 0
+          ProxyBag.default_name = p if config[Cdefault]
+
+          setup_backends(args.dup.merge(:directory_class => new_directory_class), filter)
+        end
+      end
+
+      def self.stop_unused_servers(new_config)
+        # Now stop everything that is still running but which isn't needed.
+        if Swiftcore::Swiftiply::RunningConfig.has_key?(Coutgoing)
+          (Swiftcore::Swiftiply::RunningConfig[Coutgoing].keys - new_config[Coutgoing].keys).each do |unneeded_server_key|
+            EventMachine.stop_server(Swiftcore::Swiftiply::RunningConfig[Coutgoing][unneeded_server_key])
+          end
+        end
+      end
+
+      def self.set_server_queue(data, klass, config)
+        klass ||= ::Swiftcore::Deque
+        ProxyBag.set_server_queue(data[:hash], klass, config)
+      end
+
+      def self.generate_new_directory_class(directory_class, config, new_config)
+        new_directory_class = Class.new(directory_class)
+        new_directory_class.config(config, new_config) if new_directory_class.respond_to? :config
+        new_directory_class
+      end
+
+      def self.setup_backends(args, filter)
+        config = args[:config]
+        p = args[:p]
+        config_data = args[:config_data]
+        new_config = args[:new_config]
+        klass = args[:self]
+        directory_class = args[:directory_class]
+        directory_args = args[:directory_args]
+
+        backend_class = Class.new(klass)
+        backend_class.bname = config_data[:hash]
+        ProxyBag.logger.log(Cinfo,"    Do Caching") if config['caching'] and ::Swiftcore::Swiftiply::log_level > 0
+        backend_class.caching = config['caching'] if backend_class.respond_to? :caching
+        ProxyBag.logger.log(Cinfo,"    Permit X-Sendfile") if config_data[:permit_xsendfile] and ::Swiftcore::Swiftiply::log_level > 0
+        backend_class.xsendfile = config_data[:permit_xsendfile]
+        ProxyBag.logger.log(Cinfo,"    Enable 404 on missing Sendfile resource") if config[Cenable_sendfile_404] and ::Swiftcore::Swiftiply::log_level > 0
+        backend_class.enable_sendfile_404 = true if config[Cenable_sendfile_404]                
+        backend_class.filter = !filter.nil?
+
+        directory_class.backend_class = backend_class if directory_class.respond_to? :backend_class
+        Config.set_server_queue(config_data, directory_class, directory_args)
+
+        ProxyBag.add_filter(filter,config_data[:hash]) if filter
+        ProxyBag.set_server_queue_as_filter_queue(config_data[:hash],backend_class) if filter
+        backend_class
+      end
+
+    end
+  end
+end