fishman-eventmachine_httpserver 0.2.1

data/ext/http.h

@@ -0,0 +1,115 @@
+/*****************************************************************************
+
+File:     http.h
+Date:     21Apr06
+
+Copyright (C) 2006-07 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 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+
+#ifndef __HttpPersonality__H_
+#define __HttpPersonality__H_
+
+
+
+/**********************
+class HttpConnection_t
+**********************/
+
+class HttpConnection_t
+{
+	public:
+		HttpConnection_t();
+		virtual ~HttpConnection_t();
+
+		void ConsumeData (const char*, int);
+
+		virtual void SendData (const char*, int);
+		virtual void CloseConnection (bool after_writing);
+		virtual void ProcessRequest (const char *method,
+				const char *cookie,
+				const char *ifnonematch,
+				const char *content_type,
+				const char *query_string,
+				const char *path_info,
+				const char *request_uri,
+				const char *protocol,
+				int postlength,
+				const char *postdata,
+				const char* hdrblock,
+				int hdrblksize);
+
+		virtual void ReceivePostData(const char *data, int len);
+		virtual void SetNoEnvironmentStrings() {bSetEnvironmentStrings = false;}
+		virtual void SetDontAccumulatePost() {bAccumulatePost = false;}
+
+  private:
+
+		enum {
+			BaseState,
+			PreheaderState,
+			HeaderState,
+			ReadingContentState,
+			DispatchState,
+			EndState
+		} ProtocolState;
+
+		enum {
+			MaxLeadingBlanks = 12,
+			MaxHeaderLineLength = 8 * 1024,
+			MaxContentLength = 20 * 1024 * 1024,
+			HeaderBlockSize = 16 * 1024
+		};
+		int nLeadingBlanks;
+
+		char HeaderLine [MaxHeaderLineLength];
+		int HeaderLinePos;
+
+		char HeaderBlock [HeaderBlockSize];
+		int HeaderBlockPos;
+
+		int ContentLength;
+		int ContentPos;
+		char *_Content;
+
+		bool bSetEnvironmentStrings;
+		bool bAccumulatePost;
+		bool bRequestSeen;
+		bool bContentLengthSeen;
+
+		const char *RequestMethod;
+		std::string Cookie;
+		std::string IfNoneMatch;
+		std::string ContentType;
+		std::string PathInfo;
+		std::string RequestUri;
+		std::string QueryString;
+		std::string Protocol;
+
+	private:
+		bool _InterpretHeaderLine (const char*);
+		bool _InterpretRequest (const char*);
+		bool _DetectVerbAndSetEnvString (const char*, int);
+		void _SendError (int);
+};
+
+#endif // __HttpPersonality__H_
+
+
+

data/ext/rubyhttp.cpp

@@ -0,0 +1,279 @@
+/*****************************************************************************
+
+File:     libmain.cpp
+Date:     06Apr06
+
+Copyright (C) 2006-07 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 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#include <iostream>
+#include <string>
+#include <stdexcept>
+
+using namespace std;
+
+#include <ruby.h>
+#include "http.h"
+
+
+
+/**************************
+class RubyHttpConnection_t
+**************************/
+
+class RubyHttpConnection_t: public HttpConnection_t
+{
+	public:
+		RubyHttpConnection_t (VALUE v): Myself(v) {}
+		virtual ~RubyHttpConnection_t() {}
+
+		virtual void SendData (const char*, int);
+		virtual void CloseConnection (bool after_writing);
+		virtual void ProcessRequest (const char *request_method,
+				const char *cookie,
+				const char *ifnonematch,
+				const char *contenttype,
+				const char *query_string,
+				const char *path_info,
+				const char *request_uri,
+				const char *protocol,
+				int postlength,
+				const char *postdata,
+				const char *hdrblock,
+				int hdrblocksize);
+		virtual void ReceivePostData (const char *data, int len);
+
+	private:
+		VALUE Myself;
+};
+
+
+/******************************
+RubyHttpConnection_t::SendData
+******************************/
+
+void RubyHttpConnection_t::SendData (const char *data, int length)
+{
+	rb_funcall (Myself, rb_intern ("send_data"), 1, rb_str_new (data, length));
+}
+
+
+/*************************************
+RubyHttpConnection_t::CloseConnection
+*************************************/
+
+void RubyHttpConnection_t::CloseConnection (bool after_writing)
+{
+	VALUE v = rb_intern (after_writing ? "close_connection_after_writing" : "close_connection");
+	rb_funcall (Myself, v, 0);
+}
+
+
+/*************************************
+RubyHttpConnection_t::ReceivePostData
+*************************************/
+
+void RubyHttpConnection_t::ReceivePostData (const char *data, int len)
+{
+	VALUE data_val = Qnil;
+	
+	if ((len > 0) && data) {
+		data_val = rb_str_new(data,len);
+		rb_funcall (Myself, rb_intern ("receive_post_data"), 1, data_val);
+	}
+}
+	
+/************************************
+RubyHttpConnection_t::ProcessRequest
+************************************/
+
+void RubyHttpConnection_t::ProcessRequest (const char *request_method,
+		const char *cookie,
+		const char *ifnonematch,
+		const char *contenttype,
+		const char *query_string,
+		const char *path_info,
+		const char *request_uri,
+		const char *protocol,
+		int post_length,
+		const char *post_content,
+		const char *hdr_block,
+		int hdr_block_size)
+{
+	VALUE post = Qnil;
+	VALUE headers = Qnil;
+	VALUE req_method = Qnil;
+	VALUE cookie_val = Qnil;
+	VALUE ifnonematch_val = Qnil;
+	VALUE contenttype_val = Qnil;
+	VALUE path_info_val = Qnil;
+	VALUE query_string_val = Qnil;
+	VALUE request_uri_val = Qnil;
+	VALUE protocol_val = Qnil;
+
+	if ((post_length > 0) && post_content)
+		post = rb_str_new (post_content, post_length);
+
+	if (hdr_block && (hdr_block_size > 0))
+		headers = rb_str_new (hdr_block, hdr_block_size);
+	else
+		headers = rb_str_new ("", 0);
+
+	if (request_method && *request_method)
+		req_method = rb_str_new (request_method, strlen (request_method));
+	if (cookie && *cookie)
+		cookie_val = rb_str_new (cookie, strlen (cookie));
+	if (ifnonematch && *ifnonematch)
+		ifnonematch_val = rb_str_new (ifnonematch, strlen (ifnonematch));
+	if (contenttype && *contenttype)
+		contenttype_val = rb_str_new (contenttype, strlen (contenttype));
+	if (path_info && *path_info)
+		path_info_val = rb_str_new (path_info, strlen (path_info));
+	if (query_string && *query_string)
+		query_string_val = rb_str_new (query_string, strlen (query_string));
+	if (request_uri && *request_uri)
+		request_uri_val = rb_str_new (request_uri, strlen (request_uri));
+	if (protocol && *protocol)
+		protocol_val = rb_str_new (protocol, strlen (protocol));
+
+	rb_ivar_set (Myself, rb_intern ("@http_request_method"), req_method);
+	rb_ivar_set (Myself, rb_intern ("@http_cookie"), cookie_val);
+	rb_ivar_set (Myself, rb_intern ("@http_if_none_match"), ifnonematch_val);
+	rb_ivar_set (Myself, rb_intern ("@http_content_type"), contenttype_val);
+	rb_ivar_set (Myself, rb_intern ("@http_path_info"), path_info_val);
+	rb_ivar_set (Myself, rb_intern ("@http_request_uri"), request_uri_val);
+	rb_ivar_set (Myself, rb_intern ("@http_query_string"), query_string_val);
+	rb_ivar_set (Myself, rb_intern ("@http_post_content"), post);
+	rb_ivar_set (Myself, rb_intern ("@http_headers"), headers);
+	rb_ivar_set (Myself, rb_intern ("@http_protocol"), protocol_val);
+	rb_funcall (Myself, rb_intern ("process_http_request"), 0);
+}
+
+
+/*******
+Statics
+*******/
+
+VALUE Intern_http_conn;
+
+/***********
+t_post_init
+***********/
+
+static VALUE t_post_init (VALUE self)
+{
+	RubyHttpConnection_t *hc = new RubyHttpConnection_t (self);
+	if (!hc)
+		throw std::runtime_error ("no http-connection object");
+
+	rb_ivar_set (self, Intern_http_conn, LONG2NUM ((long)hc));
+	return Qnil;
+}
+
+
+/**************
+t_receive_data
+**************/
+
+static VALUE t_receive_data (VALUE self, VALUE data)
+{
+	int length = NUM2INT (rb_funcall (data, rb_intern ("length"), 0));
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));
+	if (hc)
+		hc->ConsumeData (StringValuePtr (data), length);
+	return Qnil;
+}
+
+/*******************
+t_receive_post_data
+*******************/
+
+static VALUE t_receive_post_data (VALUE self, VALUE data)
+{
+	/** This is a NOOP.  It should be overridden.  **/
+	return Qnil;
+}
+
+/********
+t_unbind
+********/
+
+static VALUE t_unbind (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));
+	if (hc)
+		delete hc;
+	return Qnil;
+}
+
+
+/**********************
+t_process_http_request
+**********************/
+
+static VALUE t_process_http_request (VALUE self)
+{
+	// This is a stub in case the caller doesn't define it.
+	rb_funcall (self, rb_intern ("send_data"), 1, rb_str_new2 ("HTTP/1.1 200 ...\r\nContent-type: text/plain\r\nContent-length: 8\r\n\r\nMonorail"));
+	return Qnil;
+}
+
+/************************
+t_no_environment_strings
+************************/
+
+static VALUE t_no_environment_strings (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));
+	if (hc)
+		hc->SetNoEnvironmentStrings();
+	return Qnil;
+}
+
+/**********************
+t_dont_accumulate_post
+**********************/
+
+static VALUE t_dont_accumulate_post (VALUE self)
+{
+	RubyHttpConnection_t *hc = (RubyHttpConnection_t*)(NUM2LONG (rb_ivar_get (self, Intern_http_conn)));
+	if (hc)
+		hc->SetDontAccumulatePost();
+	return Qnil;
+}
+
+
+/****************************
+Init_eventmachine_httpserver
+****************************/
+
+extern "C" void Init_eventmachine_httpserver()
+{
+	Intern_http_conn = rb_intern ("http_conn");
+
+	VALUE EmModule = rb_define_module ("EventMachine");
+	VALUE HttpServer = rb_define_module_under (EmModule, "HttpServer");
+	rb_define_method (HttpServer, "post_init", (VALUE(*)(...))t_post_init, 0);
+	rb_define_method (HttpServer, "receive_data", (VALUE(*)(...))t_receive_data, 1);
+	rb_define_method (HttpServer, "receive_post_data", (VALUE(*)(...))t_receive_post_data, 1);
+	rb_define_method (HttpServer, "unbind", (VALUE(*)(...))t_unbind, 0);
+	rb_define_method (HttpServer, "process_http_request", (VALUE(*)(...))t_process_http_request, 0);
+	rb_define_method (HttpServer, "no_environment_strings", (VALUE(*)(...))t_no_environment_strings, 0);
+	rb_define_method (HttpServer, "dont_accumulate_post", (VALUE(*)(...))t_dont_accumulate_post, 0);
+}

data/lib/evma_httpserver.rb

@@ -0,0 +1,35 @@
+# EventMachine HTTP Server
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# 
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 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 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+
+
+require 'eventmachine_httpserver'
+require 'evma_httpserver/response'
+

data/lib/evma_httpserver/response.rb

@@ -0,0 +1,318 @@
+# EventMachine HTTP Server
+# HTTP Response-support class
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# 
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 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 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+
+module EventMachine
+
+	# This class provides a wide variety of features for generating and
+	# dispatching HTTP responses. It allows you to conveniently generate
+	# headers and content (including chunks and multiparts), and dispatch
+	# responses (including deferred or partially-complete responses).
+	#
+	# Although HttpResponse is coded as a class, it's not complete as it
+	# stands. It assumes that it has certain of the behaviors of
+	# EventMachine::Connection. You must add these behaviors, either by
+	# subclassing HttpResponse, or using the alternate version of this
+	# class, DelegatedHttpResponse. See the test cases for current information
+	# on which behaviors you have to add.
+	#
+	# TODO, someday it would be nice to provide a version of this functionality
+	# that is coded as a Module, so it can simply be mixed into an instance of
+	# EventMachine::Connection.
+	#
+	class HttpResponse
+		attr_accessor :status, :content, :headers, :chunks, :multiparts
+
+		def initialize
+			@headers = {}
+		end
+
+		def keep_connection_open arg=true
+			@keep_connection_open = arg
+		end
+
+		def xhr_streaming_enable arg=true
+			keep_connection_open arg
+			@xhr_streaming_enable = arg
+		end
+
+		# sugarings for headers
+		def content_type *mime
+			if mime.length > 0
+				@headers["Content-type"] = mime.first.to_s
+			else
+				@headers["Content-type"]
+			end
+		end
+
+		# Sugaring for Set-cookie headers. These are a pain because there can easily and
+		# legitimately be more than one. So we use an ugly verb to signify that.
+		# #add_set_cookies does NOT disturb the set-cookie headers which may have been
+		# added on a prior call. #set_cookie clears them out first.
+		def add_set_cookie *ck
+			if ck.length > 0
+				h = (@headers["Set-cookie"] ||= [])
+				ck.each {|c| h << c}
+			end
+		end
+		def set_cookie *ck
+			h = (@headers["Set-cookie"] ||= [])
+			if ck.length > 0
+				h.clear
+				add_set_cookie *ck
+			else
+				h
+			end
+		end
+
+
+		# This is intended to send a complete HTTP response, including closing the connection
+		# if appropriate at the end of the transmission. Don't use this method to send partial
+		# or iterated responses. This method will send chunks and multiparts provided they
+		# are all available when we get here.
+		# Note that the default @status is 200 if the value doesn't exist.
+		def send_response
+			send_headers
+			send_body
+			send_trailer
+			close_connection_after_writing unless (@keep_connection_open and (@status || 200) == 200)
+		end
+
+		# Send the headers out in alpha-sorted order. This will degrade performance to some
+		# degree, and is intended only to simplify the construction of unit tests.
+		#
+		def send_headers
+			raise "sent headers already" if @sent_headers
+			@sent_headers = true
+
+			fixup_headers
+
+			ary = []
+			ary << "HTTP/1.1 #{@status || 200} ...\r\n"
+			ary += generate_header_lines(@headers)
+			ary << "\r\n"
+
+			send_data ary.join
+		end
+
+
+		def generate_header_lines in_hash
+			out_ary = []
+			in_hash.keys.sort.each {|k|
+				v = in_hash[k]
+				if v.is_a?(Array)
+					v.each {|v1| out_ary << "#{k}: #{v1}\r\n" }
+				else
+					out_ary << "#{k}: #{v}\r\n"
+				end
+			}
+			out_ary
+		end
+		private :generate_header_lines
+
+
+		# Examine the content type and data and other things, and perform a final
+		# fixup of the header array. We expect this to be called just before sending
+		# headers to the remote peer.
+		# In the case of multiparts, we ASSUME we will get called before any content
+		# gets sent out, because the multipart boundary is created here.
+		#
+		def fixup_headers
+			if @content
+				@headers["Content-length"] = @content.to_s.length
+			elsif @chunks
+				@headers["Transfer-encoding"] = "chunked"
+				# Might be nice to ENSURE there is no content-length header,
+				# but how to detect all the possible permutations of upper/lower case?
+			elsif @multiparts
+				@multipart_boundary = self.class.concoct_multipart_boundary
+				@headers["Content-type"] = "multipart/x-mixed-replace; boundary=\"#{@multipart_boundary}\""
+			elsif !@xhr_streaming_enable
+				@headers["Content-length"] = 0
+			end
+		end
+
+		# we send either content, chunks, or multiparts. Content can only be sent once.
+		# Chunks and multiparts can be sent any number of times.
+		# DO NOT close the connection or send any goodbye kisses. This method can
+		# be called multiple times to send out chunks or multiparts.
+		def send_body
+			if @content
+				send_content
+			elsif @chunks
+				send_chunks
+			elsif @multiparts
+				send_multiparts
+			else
+				@content = ""
+				send_content
+			end
+		end
+
+		# send a trailer which depends on the type of body we're dealing with.
+		# The assumption is that we're about to end the transmission of this particular
+		# HTTP response. (A connection-close may or may not follow.)
+		#
+		def send_trailer
+			send_headers unless @sent_headers
+			if @content
+				# no-op
+			elsif @chunks
+				unless @last_chunk_sent
+					chunk ""
+					send_chunks
+				end
+			elsif @multiparts
+				# in the lingo of RFC 2046/5.1.1, we're sending an "epilog"
+				# consisting of a blank line. I really don't know how that is
+				# supposed to interact with the case where we leave the connection
+				# open after transmitting the multipart response.
+				send_data "\r\n--#{@multipart_boundary}--\r\n\r\n"
+			else
+				# no-op
+			end
+		end
+
+		def send_content
+			raise "sent content already" if @sent_content
+			@sent_content = true
+			send_data((@content || "").to_s)
+		end
+
+		# add a chunk to go to the output.
+		# Will cause the headers to pick up "content-transfer-encoding"
+		# Add the chunk to a list. Calling #send_chunks will send out the
+		# available chunks and clear the chunk list WITHOUT closing the connection,
+		# so it can be called any number of times.
+		# TODO!!! Per RFC2616, we may not send chunks to an HTTP/1.0 client.
+		# Raise an exception here if our user tries to do so.
+		# Chunked transfer coding is defined in RFC2616 pgh 3.6.1.
+		# The argument can be a string or a hash. The latter allows for
+		# sending chunks with extensions (someday).
+		#
+		def chunk text
+			@chunks ||= []
+			@chunks << text
+		end
+
+		# send the contents of the chunk list and clear it out.
+		# ASSUMES that headers have been sent.
+		# Does NOT close the connection.
+		# Can be called multiple times.
+		# According to RFC2616, phg 3.6.1, the last chunk will be zero length.
+		# But some caller could accidentally set a zero-length chunk in the middle
+		# of the stream. If that should happen, raise an exception.
+		# The reason for supporting chunks that are hashes instead of just strings
+		# is to enable someday supporting chunk-extension codes (cf the RFC).
+		# TODO!!! We're not supporting the final entity-header that may be
+		# transmitted after the last (zero-length) chunk.
+		#
+		def send_chunks
+			send_headers unless @sent_headers
+			while chunk = @chunks.shift
+				raise "last chunk already sent" if @last_chunk_sent
+				text = chunk.is_a?(Hash) ? chunk[:text] : chunk.to_s
+				send_data "#{format("%x", text.length).upcase}\r\n#{text}\r\n"
+				@last_chunk_sent = true if text.length == 0
+			end
+		end
+
+		# To add a multipart to the outgoing response, specify the headers and the
+		# body. If only a string is given, it's treated as the body (in this case,
+		# the header is assumed to be empty).
+		#
+		def multipart arg
+			vals = if arg.is_a?(String)
+				{:body => arg, :headers => {}}
+			else
+				arg
+			end
+
+			@multiparts ||= []
+			@multiparts << vals
+		end
+
+		# Multipart syntax is defined in RFC 2046, pgh 5.1.1 et seq.
+		# The CRLF which introduces the boundary line of each part (content entity)
+		# is defined as being part of the boundary, not of the preceding part.
+		# So we don't need to mess with interpreting the last bytes of a part
+		# to ensure they are CRLF-terminated.
+		#
+		def send_multiparts
+			send_headers unless @sent_headers
+			while part = @multiparts.shift
+				send_data "\r\n--#{@multipart_boundary}\r\n"
+				send_data( generate_header_lines( part[:headers] || {} ).join)
+				send_data "\r\n"
+				send_data part[:body].to_s
+			end
+		end
+
+		# TODO, this is going to be way too slow. Cache up the uuidgens.
+		#
+		def self.concoct_multipart_boundary
+			@multipart_index ||= 0
+			@multipart_index += 1
+			if @multipart_index >= 1000
+				@multipart_index = 0
+				@multipart_guid = nil
+			end
+			@multipart_guid ||= `uuidgen -r`.chomp.gsub(/\-/,"")
+			"#{@multipart_guid}#{@multipart_index}"
+		end
+		
+		def send_redirect location
+			@status = 302 # TODO, make 301 available by parameter
+			@headers["Location"] = location
+			send_response
+		end
+	end
+end
+
+#----------------------------------------------------------------------------
+
+require 'forwardable'
+
+module EventMachine
+	class DelegatedHttpResponse < HttpResponse
+		extend Forwardable
+		def_delegators :@delegate,
+			:send_data,
+			:close_connection,
+			:close_connection_after_writing
+
+		def initialize dele
+			super()
+			@delegate = dele
+		end
+	end
+end
+